Can Julia land on the Moon? On the development of a GNC simulation framework for the Argonaut lunar lander

arXiv:2609.03843 · eess.SY, cs.SY · Submitted 2026-09-03 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.

Rosa: Today's paper: "Can Julia land on the Moon? On the development of a GNC simulation framework for the Argonaut lunar lander".

Dev: The gist: No, the Julia programming language cannot land on the Moon — but it can play a crucial role in designing and analysing the Guidance, Navigation,

Rosa: First, who's behind it and why it matters.

Title and authors: Rosa: We started by looking at the title of this paper, "Can Julia land on the Moon? On the development of a GNC simulation framework for the Argonaut lunar lander," and it immediately makes you think about testing if this language is serious enough for deep space applications.

Dev: That title sets up a big question right away, asking whether Julia can actually be used to build a complete system for landing on the Moon. It frames the entire paper around that feasibility check.

Taro: It’s not just about whether Julia can run calculations; it’s about whether you can use it to design and analyze all the guidance, navigation, and control algorithms needed for a real lunar landing.

Rosa: The authors are showing us that they developed something called ATLAS, which is this modular suite of tools specifically designed for analyzing and simulating the entire descent and landing phase of the Argonaut lander.

Dev: And ATLAS integrates a lot—it’s not just one part—so it brings in high-fidelity translational dynamics, rotational dynamics, varying mass properties, propellant sloshing, detailed sensor models, and actuator models all together.

Taro: So they’re not just simulating the physics; they are simulating the entire complex environment that a real spacecraft faces during landing. That level of detail is crucial for testing autonomy decisions under stress.

Rosa: They also include flight-representative GNC algorithms within this framework, which means it’s not just running abstract math; it’s using actual control logic that mimics what you'd actually need in a mission.

Dev: It frames the whole thing as an exploration of whether using a different programming language, like Julia, could offer tangible benefits over established tools like MATLAB or Simulink.

Taro: So the motivation here is really about seeing if switching languages for simulation can give us something practical, especially when simulation speed is a major factor in GNC development work.

Rosa: That’s the core tension they are exploring—the ambition of using Julia to replace established methods while still delivering the high fidelity needed for space missions.

Dev: So, it’s not a definitive yes or no on landing on the Moon with Julia, but rather a deep dive into what Julia *can* do in this specific domain.

Taro: I think that’s the right way to look at it; we are looking at its potential role in the design and analysis side of complex autonomous systems.

Rosa: And that leads us into what they actually present in terms of their summary of this work.

The paper's summary: Dev: So, the paper summarizes how they built ATLAS to be a modular suite covering the complete descent and landing phase of Argonaut. It’s structured around four main phases: a braking burn phase, a pitch-up phase, a powered descent for those final few hundred meters to get above the site, and then the vertical descent.

Rosa: They emphasize that ATLAS is designed to be modular so you can separate out the flight software—the GNC part—from the sensor suite, actuators, and dynamics models. This separation is key for making sure different parts can be developed independently.

Taro: I think that modularity helps a lot when you’re building autonomy systems because it lets you test the guidance module separately from the control architecture or the vehicle dynamics.

Dev: The GNC module inside ATLAS includes a mission and vehicle manager to implement that system state machine, followed by a navigation function based on a six-degrees-of-freedom error-state Schmidt–Kalman filter.

Rosa: That Kalman filter is how it estimates the lander's position and attitude using sensor data, which is essential for knowing where you are and which way you’re pointing during the descent.

Taro: So when we think about autonomy, that navigation function provides a solid foundation—if the state estimation is accurate, then whatever guidance or control decisions you make based on that estimate will be more reliable.

Dev: Then there's a guidance module that generates the reference trajectory, which outputs position, velocity, attitude profiles for all those mission phases. This feeds into a control architecture with four SISO control channels: one for vertical translation, one for roll, and two lateral channels controlling coupled attitude-position motion.

Rosa: Those four control channels have a specific structure where the lateral channels use a cascaded structure to convert forces from the outer position loops into attitude commands.

Taro: That cascading structure sounds like it’s trying to manage how different physical movements—like moving forward versus changing orientation—interact in real time.

Dev: The whole system then translates those control demands into actuator-level commands, including main-engine thrust levels and RCS on-times, which are generated by an algorithm inspired by simplex allocation for the main engine.

Rosa: And finally, the actuator module handles high-fidelity models of the three main engines and the RCS thrusters. It’s a complete loop from decision to physical action.

Taro: It makes sense that they put all those pieces together because in real autonomy, you need that entire sequence—from sensing to deciding to act—to be integrated smoothly.

Dev: This whole structure is designed for multi-rate simulation, which lets components operate at different frequencies through internal triggering and delay management mechanisms.

Rosa: So the summary boils down to a complete closed-loop simulation framework that tests the entire descent process end-to-end within one environment. It’s very comprehensive for what it aims to achieve with this paper.

The paper's improvements: Taro: Now let’s talk about how the authors suggest improving this work, because they point out some areas where the framework could be even stronger than what they currently have.

Rosa: They focus on using Julia’s strengths—its ability to handle complex systems through composite types, or structs—as a fundamental architectural principle for representing engineering systems made of multiple interacting subsystems.

Dev: That means they are leaning into Julia’s structure to create a design that feels more like flight software than those older block-diagram simulators, which is a big architectural improvement in my book.

Taro: If the architecture is closer to actual flight software, it means better deterministic execution order and better traceability when you're debugging issues down the line.

Rosa: They also highlighted the simulation step function, simStep!, which orchestrates everything by sequentially calling functions for DKE propagation, sensor execution, GNC execution, and actuator execution.

Dev: That sequential orchestration is what allows them to manage components operating at different frequencies through internal triggering and delay management mechanisms. It’s a smart way to handle the time differences between things running at different rates.

Taro: So they are emphasizing the need for modular, testable simulation components so that when you're building autonomy software, you have clear interfaces defined between those parts.

Rosa: They also mentioned that the development experience with Julia can be improved by encouraging a code-based paradigm where interfaces are clearly defined and data types are consistent across all subsystems.

Dev: That consistency in data types is crucial because if the language allows for subtle errors like inadvertent aliasing through references, having strict conventions helps prevent those hard-to-find bugs.

Taro: So the authors are pushing for a workflow where you build things in a way that makes them inherently testable, which directly supports the goal of creating reliable autonomy software.

Rosa: They are also noting that this approach democratizes access because someone can clone the repository, install Julia, and immediately run a high-fidelity simulation without needing to request expensive licenses for every step.

Dev: That’s a huge win for prototyping; it means engineers don't have to wait for lengthy setup processes before they can start their analysis cycles.

Taro: So the idea is that this code-based approach makes the development process less about configuration and more about writing good, structured code from the beginning.

Rosa: Ultimately, these improvements suggest that Julia is a credible path for high-performance simulation and prototyping in the pre-development stages of a program.

Conclusion: Dev: So to wrap up on this discussion about "Can Julia land on the Moon? On the development of a GNC simulation framework for the Argonaut lunar lander," we’ve seen that Julia delivers excellent runtime performance for large-scale GNC analyses when you optimize it correctly.

Rosa: It’s a modular, closed-loop simulation framework that covers everything from dynamics and sensor models to actuator commands in one place, which is really powerful for high-fidelity testing.

Taro: For autonomy research, this means we have a tool capable of supporting rapid iterations between controller design and Monte Carlo validation because the simulation speed allows for routine accessibility.

Dev: The paper shows that while Julia has challenges with its language semantics, like default reference handling, it can still be a strong contender for pre-development phases.

Rosa: So the conclusion is that Julia provides a way to unify high-level expressiveness and low-level performance for complex GNC analysis, even if full industrial adoption isn't proven yet.

Taro: For autonomy development, this means we have a high-performance simulation ground available for testing control algorithms right now, provided we focus on the structural improvements the authors suggested.

Dev: So in short, ATLAS is a powerful framework for exploring GNC design and analysis for missions like Argonaut. It’s a tool that can be used effectively in those early prototyping activities.

Rosa: We’ve talked about how this paper presents the ATLAS framework as a high-fidelity closed-loop simulation environment developed entirely in Julia.

Taro: I just want to say that it opens up a path for us to seriously explore these kinds of tools for future autonomy development efforts.

Dev: Agreed, it’s a credible alternative for high-performance simulation and prototyping, especially when you focus on optimizing the execution speed.

European Space Agency

eess.SY, cs.SY

Submitted: 2026-09-03

Updated: 2026-10-08

Comments: Author draft, presented at the ESA GNC & ICATT Conference 2026

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 89/100

The gist: The gist: No, the Julia programming language cannot land on the Moon — but it can play a crucial role in designing and analysing the Guidance, Navigation, and Control (GNC) algorithms required for

Key concepts

ATLAS Framework
ATLAS is a modular simulation suite designed to model the entire descent and landing phase of the Argonaut lander. It combines high-fidelity physics, including vehicle dynamics, propellant sloshing, sensor models, and flight GNC algorithms into one environment for prototyping.
GNC Algorithms
Guidance, Navigation, and Control (GNC) are the core algorithms that tell a spacecraft how to navigate to a target. This includes guidance for trajectory planning (where to go), navigation for determining current position (where you are), and control for executing maneuvers (how to move).
Julia Composite Types
ATLAS uses Julia's 'struct' types, which allow engineers to represent complex engineering systems as collections of interacting subsystems. This modular design makes the simulation structure closely resemble flight software architecture, improving maintainability and organization.
Monte Carlo Analysis
This is a method used to test a system by running many simulations with varying inputs (like random initial conditions). By using ATLAS, researchers can run thousands of these simulations quickly to validate controller designs against uncertainty in the landing process.

Terminology

Summary

The gist: No, the Julia programming language cannot land on the Moon — but it can play a crucial role in designing and analysing the Guidance, Navigation, and Control (GNC) algorithms required for doing so.

ATLAS Framework Development

The paper presents ATLAS (Argonaut Tools for Landing Analysis and Simulation), which is a modular suite of analysis and simulation tools that cover the complete descent and landing phase of Argonaut, integrating high fidelity translational and rotational dynamics, varying mass properties, propellant sloshing, detailed sensor and actuator models, and flightrepresentative GNC algorithms within a multi-rate simulation environment<ref:2609.03843#pg2> The framework is intended to bridge early-phase prototyping and large-scale Monte Carlo analysis within a single environment<ref:2609.03843#pg2>.

ATLAS Architecture

ATLAS focuses on the Argonaut descent and landing phase, which involves four main phases: a braking burn phase, a pitch-up phase, a powered descent for the last few hundred meters to reach a desired state above the landing site, and finally a vertical descent<ref:2609.03843#pg3>. The architecture is modular with clear separation between the flight software (GNC), the sensor suite (SEN), the actuator chain (ACT), and the dynamics, kinematics, and environment models (DKE)<ref:2609.03843#pg4>. The GNC module includes a mission and vehicle manager to implement the system state machine, a navigation function centered on a six-degrees-of-freedom (6-DoF) error-state Schmidt–Kalman filter, a guidance module that generates the reference trajectory, and a control architecture consisting of four SISO control channels<ref:2609.03843#pg5>.

Software Architecture and Design

ATLAS is designed with modularity as a fundamental architectural principle, relying heavily on Julia’s composite types (struct) to represent engineering systems composed of multiple interacting subsystems<ref:2609.03843#pg6>. The simulation step function, simStep!, orchestrates the closed-loop execution by sequentially calling functions for DKE propagation, sensor execution, GNC execution, and actuator execution<ref:2609.03843#pg7>. This structure allows for the coexistence of components operating at different frequencies through internal triggering and delay management mechanisms<ref:2609.03843#pg8>.

Julia Advantages and Limitations

Julia offers a powerful, flexible, and high-performance environment for agency-driven research, enabling large-scale parallelizable simulations and rapid design iteration cycles<ref:2609.03843#pg2>. Key advantages include its ability to combine the ease of use of high-level interpreted languages with the performance traditionally associated with compiled languages such as C and C++<ref:2609.03843#pg2>. However, limitations exist regarding language semantics, specifically how Julia handles data through references by default, which can introduce subtle errors like inadvertent aliasing that are difficult to diagnose in closed-loop simulations<ref:2609.03843#pg9>. Furthermore, the absence of a widely used graphical modelling environment makes the initial development process slower and demands stronger software engineering skills<ref:2609.03843#pg10>.

Performance and Workflows

The simulation speed is a primary motivation for adopting Julia, as it can deliver performance comparable to low-level languages when optimized with state-of-the-art libraries like DifferentialEquations.jl and by minimizing heap allocations. Through an effort involving incremental improvements, including multithreading and comprehensive refactoring to reduce heap allocations, ATLAS achieved execution times of approximately 0.1 seconds for a complete 900-second landing simulation. This capability allows large-scale Monte Carlo campaigns to become routinely accessible, enabling rapid iterations between controller design and Monte Carlo validation. The authors conclude that Julia provides the capability to unify high-level expressiveness and low-level performance, but realizing both simultaneously is generally not easy or even possible.

Industrial Perspective

The ultimate objective of GNC development is a verified flight software application compliant with ECSS software engineering standards, and the most realistic near-term industrial application of Julia may be in the pre-development phases, including feasibility studies and early GNC prototyping. While Julia provides substantial benefits in terms of simulation performance and development flexibility during these early stages, the transition to operational flight software development remains largely unproven. The paper suggests that the most realistic near-term industrial application of Julia may be in the pre-development phases of a programme, including feasibility studies, Phase A/B activities, trade-off analyses, architecture assessments, and early GNC prototyping.

Conclusion

The paper presented ATLAS as a high-fidelity closed-loop simulation framework for the ESA Argonaut lander developed entirely in Julia. The results demonstrate that Julia can deliver excellent runtime performance for large-scale GNC analyses. Through the use of optimized numerical libraries, multithreading, and extensive reduction of heap allocations, ATLAS achieved execution times of approximately 0.1 seconds for a complete 900-second landing simulation. The development experience highlighted several challenges associated with the language. Nevertheless, the software-centric approach encouraged by Julia led to a modular architecture that is closer to flight software than traditional block-diagram-based simulators. Julia is a credible alternative for high-performance GNC simulation and prototyping, even if its possible adoption in an industrial context and beyond Phase 0/A/B1 remains to be proven.

Acknowledgments

The Authors would like to thank the entire ESA Argonaut Team, and more particularly Pedro Simplicio and Olivier Dubois-Matra for their support and contributions to ATLAS.

References

[1] J. Bezanson, S. Karpinski, V. B. Shah, A. Edelman, Julia: A Fast Dynamic Language for Technical Computing, arXiv, September 2024, https://arxiv.org/abs/1209.5145.

[7] C. Rackauckas, Q. Nie, DifferentialEquations.jl – A Performant and Feature-Rich Ecosystem for Solving Differential Equations in Julia, Journal of Open Research Software, vol. 5, no. 1, 2017, https://doi.org/10.5334/jors.151.

[9] S. Danisch, J. Krumbiegel, Makie.jl: Flexible high-performance data visualization for Julia, Journal of Open Source Software, vol. 6 no. 65, 2021, https://doi.org/10.21105/joss.03349.

[15] Guidelines for the Automatic Code Generation for AOCS/GNC Flight SW Handbook: Volume 1 – General Concepts, SAVOIR-HB-005, European Space Agency, June 2021.

[16] Guidelines for the Automatic Code Generation for AOCS/GNC Flight SW Handbook: Volume 2 – Mathworks Specific Guidelines, SAVOIR-HB-005, European Space Agency, June 2021.

[1] J. Bezanson, S. Karpinski, V. B. Shah, A. Edelman, Julia: A Fast Dynamic Language for Technical Computing, arXiv, September 2024, https://arxiv.org/abs/1209.5145.

[3] A. R. Klumpp, Apollo lunar descent guidance. Automatica, vol. 10, no. 2, 1974, https://doi.org/10.1016/0005-1098(74)90019-3.

[4] F. Capolupo, A. Rinalducci, "Descent & Landing Trajectory and Guidance Algorithms with Divert Capabilities for Moon Landing". AIAA Scitech Forum 2024, January 2024, https://doi.org/10.2514/6.2024-0086<ref:2609.

Improvements for AI systems

  1. Improved GNC simulation performance for large-scale Monte Carlo campaigns by reducing execution time to approximately 0.1 seconds per simulation through a comprehensive refactoring phase aimed specifically at reducing and, where possible, eliminating heap allocations within the simulation loop.

  2. Enhanced design iteration cycles by enabling rapid iterations between controller design and Monte Carlo validation because the simulation speeds achieved with ATLAS made large-scale simulations a routinely accessible tool.

  3. Development of more robust GNC software architectures by enforcing a modular architecture that is closer to flight software than traditional block-diagram-based simulators, which promotes deterministic execution order, traceability, and maintainability.

  4. Democratization of advanced simulation tools by allowing engineers to use Julia for prototyping without relying on licenses or complex configurations, as the text notes, A system engineer can clone a repository, install Julia, and immediately run a high-fidelity simulation without needing to request licenses.

  5. Creation of more rigorous GNC development workflows by encouraging the development of modular, testable, and maintainable simulation components through a code-based paradigm that makes interfaces clearly defined and data types consistent.

Abstract

No, the Julia programming language cannot land on the Moon - but it can play a crucial role in designing and analysing the Guidance, Navigation, and Control (GNC) algorithms required for doing so. This paper presents the development of a lunar landing simulation framework implemented in Julia at the European Space Agency (ESA), within the Argonaut lunar lander programme. ATLAS (Argonaut Tools for Landing Analysis and Simulation) is a modular suite of analysis and simulation tools that cover the complete descent and landing phase of Argonaut, integrating high fidelity translational and rotational dynamics, varying mass properties, propellant sloshing, detailed sensor and actuator models, and flight-representative GNC algorithms within a multi-rate simulation environment. The framework is intended to bridge early-phase prototyping and large-scale Monte Carlo analysis within a single environment. This work evaluates the advantages and limitations of adopting Julia compared to established GNC development practices based on the MATLAB/Simulink ecosystem. The results show that Julia provides a powerful, flexible, and high-performance environment for agency-driven research, early-phase design studies, and computationally intensive closed-loop simulations enabling large-scale, parallelizable simulations and rapid design iteration cycles.

Sources

Related papers