【Leap71】Leap71’s Computational Methodology for Aerospike Engine Development　：2026/1/2

AI活用

Core concept
Leap71 develops aerospike rocket engines using a computational engineering model (Noyron) instead of traditional CAD-based design.

Human role (requirements & logic)
Engineers do not draw geometry.
They:

  • Define performance requirements (thrust, pressure, propellants, cooling)
  • Encode physics, constraints, and design rules directly into code
    → Human expertise is translated into algorithmic logic.

Parametric design (fully automated)

  • Noyron autonomously generates the full aerospike engine geometry
  • Includes chamber, spike contour, injectors, cooling channels, manifolds
  • Output is manufacturing-ready, not just conceptual CAD
  • Same “computational DNA” can generate bell nozzles or aerospikes by changing inputs.

Optimization approach

  • Fast, physics-based internal models are used instead of brute-force CFD everywhere
  • Parametric sweeps and rule-based optimization are automated
  • High-fidelity CFD is used selectively for validation, not every iteration.

Iteration speed

  • Design → print → hot-fire test cycles run on ~monthly timescales
  • Aerospike engine reached successful first hot-fire on initial attempt.

Learning loop

  • Test data feeds back into the computational model
  • Engineers update physics models and rules when discrepancies appear
  • The system improves deterministically, not via black-box ML training.

Automation boundary

  • Geometry generation, sizing, integration: fully automated
  • Requirement definition, physics modeling, interpretation of results: human-led

Strategic significance

  • Demonstrates “first-time-right” rocket engines
  • Shows aerospike engines are viable when designed computationally
  • Scales naturally to much larger thrust classes without redesign from scratch.

Requirements Definition and Engineering Logic Capture

In the initial phase, Leap71’s human engineers define the engine’s requirements and encode the fundamental design logic into the Noyron system. Rather than producing a static specification document or a hand-drawn blueprint, the team translates the aerospike engine’s requirements into an algorithmic model. A computational engineer begins by breaking down the design into fundamental building blocks and defining how components like the combustion chamber, spike nozzle, cooling channels, and injector interact via clear logical dependenciesleap71.com. At this stage, the focus is on capturing essential rules and constraints: the desired functional requirements (e.g. target thrust of the engine, propellant type, chamber pressure), physical constraints (materials, thermal limits, geometric envelopes), manufacturing considerations, and performance criteria. All of these are explicitly codified as part of the model’s input and logicleap71.com.

Human designers play a crucial role here – they contribute their domain knowledge and creative engineering insight by manually encoding engineering knowledge into Noyron’s codebasemetal-am.com. The co-founders of Leap71 describe how they “manually encode engineering knowledge drawn from textbooks, existing designs, first-principle thinking, and practical experience” into the modelmetal-am.com. In practice, this means writing object-oriented source code (Noyron is implemented in C#) that represents the rocket engine’s design rules and formulasmetal-am.com. Every aspect that a human expert knows about rocket engines – from fluid dynamics equations to empirical cooling correlations and safety factors – is built into the computational model as deterministic logic. The outcome of the requirements-definition phase is not a single CAD drawing, but rather a living design algorithm that can generate a family of rocket engine designs meeting the specified requirementsleap71.com.

Notably, Leap71 treats the design requirements as the beginning of an ongoing “conversation” between the human engineers and the AI system, rather than a fixed one-time specmetal-am.com. As Lin Kayser (Leap71’s co-founder) explains, real engineering is exploratory and iterative – you rarely know all requirements upfront, especially for novel concepts like an aerospike. Thus, the ideal AI design process is interactive: the system (analogous to Tony Stark’s J.A.R.V.I.S.) listens to inputs, suggests solutions, flags infeasible ideas, and continually incorporates new insights as goals evolvemetal-am.commetal-am.com. In practice, this means that during development the team might refine requirements or add new constraints after seeing intermediate results. For example, in designing their 5 kN aerospike, the team had to consider an unusual cooling scheme (cooling the central spike with liquid oxygen and the outer chamber with kerosene) – a requirement which they extended Noyron’s physics models to handleleap71.com. This human-guided updating of the requirement logic ensured that Noyron understood the unique thermal management needs of an aerospike engine and could design appropriate cooling channels. Throughout this phase, human engineers remain in the loop to define what the engine must achieve, but they delegate to the software how to fulfill those requirements logically.

Parametric Design Generation (Autonomous, Physics-Based Design)

Once the requirements and design rules are encoded, Leap71 leverages Noyron to automatically generate the aerospike engine geometry and system design in a parametric, generative manner. Noyron acts as a physics-informed generative design engine: given a set of input parameters and specifications, it produces a complete, production-ready engine design that satisfies the requirementsleap71.comleap71.com. This process is highly automated – Noyron “generates complex machinery directly from specification to production-ready design” by internally applying first-principles physics, engineering logic, and manufacturing constraints in a coherent frameworkleap71.com. In other words, the human provides the inputs (like “5 kN thrust, methalox propellant, regenerative cooling, 50 bar chamber pressure”) and Noyron’s algorithms output a fully detailed engine design that meets those specs, including all necessary features (combustion chamber, spike contour, injector, cooling passages, manifolds, etc.) integrated into the geometry.

Critically, the design generation is parametric and rule-driven rather than a one-off static model. The computational model is essentially an engine-design program that can be run with different input values to explore countless design variants. The same Noyron rocket propulsion model can output radically different engine architectures by adjusting parameters – for example, Leap71 demonstrated that a conventional bell-nozzle engine and an aerospike engine (vastly different geometries) were both generated by the same Noyron model using the same underlying physics logicleap71.com. Josefine Lissner (Leap71’s CEO and Noyron’s chief architect) noted that these are “different phenotypes of the same computational DNA,” enabled by a unified algorithmic approach rather than separate design effortsvoxelmatters.com. Because the design logic is generalized, scaling to a larger or smaller thrust class is as simple as changing the inputs; indeed, the team can generate similar engines tailored to specific customer requirements by tweaking parameters like thrust level or sizeleap71.com. This stands in contrast to traditional design, where a new thrust requirement might require starting a CAD model almost from scratch.

Automation and Tools: The parametric design generation phase is highly automated by Leap71’s software stack. Noyron itself is built on top of a custom geometry kernel called PicoGK, which was developed to handle the complex, algorithmically-generated shapes that traditional CAD systems struggle withleap71.com. PicoGK operates on a voxel-based geometry representation that can capture extremely intricate lattice structures, curved cooling channels, and other organic forms that the algorithm producesjlk.aejlk.ae. With this foundation, Noyron’s output is not just a conceptual shape – it includes fully detailed 3D geometry and associated manufacturing data. The model directly produces files ready for fabrication, such as 3D printer build files (STL/slices or G-code) and even post-processing instructionsmetal-am.com. In essence, the output of the computational model is a manufacturable design, not merely a CAD drawingleap71.com. For example, in the case of the 5 kN aerospike, Noyron’s output was a single unified CAD/voxel model of the engine with all internal channels and features, which was then 3D-printed in metal as one piece. (Leap71’s stack even considers manufacturing constraints during generation – the model “understands” the limitations of processes like metal additive manufacturing and designs within those boundsmetal-am.com.)

Because of the high degree of automation, human involvement in this phase is minimal in terms of direct design creation. Engineers are not manually drawing the chamber or nozzle contours – the software does that in seconds or minutesleap71.com. However, humans still oversee the results: they will inspect the generated design, perhaps using visualization tools, to ensure it looks plausible, and verify that no constraints have been violated. Leap71 reports that Noyron can generate functional engine designs within minutes, dramatically faster than a human could model even a single componentleap71.com. This speed allows the team to quickly iterate or regenerate alternatives if something is amiss. The designs are grounded in physics: Noyron “aims to build an object that closely matches the desired functionality” by inferring physical interactions (fluid flow, thermal behavior, etc.) during generationleap71.com. Every time it constructs a geometry, the model runs built-in physics calculations, rule checks, and manufacturing validations at various points in the algorithm, adjusting the design as needed to meet the requirementsmetal-am.com. For instance, the software will size the regenerative cooling channels based on heat transfer equations and material limits, ensuring the aerospike’s spike and chamber walls can be adequately cooled. The result of this phase is a complete parametric design of an aerospike engine, produced with little to no manual drafting – a design that is ready to analyze, optimize, and fabricate.

High-Speed Optimization and Iteration Cycles

After an initial design is generated, Leap71’s methodology enters a rapid optimization and iteration cycle driven by simulation and testing. This phase is where the design is refined and improved in high-speed loops, far faster than traditional hardware development cycles. There are two primary feedback mechanisms in these loops: numerical simulations (CFD/FEA and other analyses) and physical testing of prototypes. Both are leveraged in an automated or semi-automated fashion to evolve the design toward an optimal solution.

On the computational side, the Noyron platform enables fast virtual optimization loops. Because the engine design exists as an algorithmic model, the team can programmatically explore variations and perform what-if studies. The Noyron engine model can be run repeatedly with different input parameters (geometrical tweaks, boundary conditions, etc.), and for each variant it can output predicted performance metrics. Leap71’s engineers incorporate automated numerical simulations and physics calculations to evaluate these design variants. As the company describes, engineers validate the model’s outputs across a wide parameter space using “visual inspection, physical testing, and increasingly, automated numerical simulation”leap71.com. For example, an aerospike design might be generated with a slightly different nozzle expansion ratio or a modified cooling channel pattern, and then a CFD simulation or internal flow calculation is executed to gauge the effect on performance and wall temperatures. These simulations can be orchestrated in a scripted manner, enabling many designs to be assessed in a short time. Feedback loops are central to this process – as Kayser writes, by “plugging in physical formulas and building feedback loops, based on simulation or actual testing, the algorithms can explore a vast number of variants” efficientlyjlk.ae. In practice, this means Noyron’s code can adjust design parameters in response to simulation results (or real test data), inching the design closer to performance targets without human trial-and-error at each step.

Notably, Leap71’s approach emphasizes physics-based, first-principles modeling for speed. Rather than relying solely on full 3D CFD for every iteration (which would be too slow for hundreds of design candidates), Noyron encodes many engineering correlations and analytical models that allow it to predict performance quicklymetal-am.comreddit.com. For instance, it uses internal thermal models, fluid dynamic equations, and heuristics to estimate quantities like pressure drops, heat flux, thrust, and stresses as it generates the designleap71.com. These built-in models act as fast surrogates for detailed simulations. Only when higher fidelity is needed (for final verification or where the model’s uncertainty is high) does the team turn to more intensive CFD/FEA analysis. This balanced strategy is why Noyron can “operate independently of humans – radically compressing iteration times” in design optimizationleap71.com. The outcome is that many design changes can be evaluated in silico within hours or days, something that would be impractical with a conventional manual workflow.

The second, equally important part of the optimization cycle is physical testing and data feedback. Once a promising aerospike design is generated and passes virtual checks, Leap71 proceeds to manufacture and test it rapidly, using the results to further improve the model. Thanks to advanced additive manufacturing, the turnaround from design to prototype is extremely fast. Leap71’s methodology is tightly coupled with industrial 3D printing – the complex aerospike engines are printed in one piece from high-performance copper alloy (CuCrZr), eliminating assembly and enabling quick productionleap71.comleap71.com. The company has partnered with metal AM firms (such as Aconity3D and others) to fabricate designs at record speed. As a result, they have been able to conduct an engine hot-fire test roughly every four weeks on average, an astonishing pace in rocketryleap71.com. Each test provides real-world performance data – pressures, temperatures, thrust levels, transient behavior – which is priceless for validation. Noyron uses this data as training feedback: the observed behavior from tests is fed back into the model to refine its predictions and logic for the next iterationleap71.com. In effect, the AI model “learns” from each physical test, adjusting its internal formulas or adding new rules so that the next design it generates will closer match reality.

https://leap71.com/formnext_24_aconity3d_aerospike/ A 5 kN aerospike rocket engine, additively manufactured in a single copper-alloy piece from a Noyron-generated designmetal-am.com. This AI-designed engine was developed in only a few weeks and successfully hot-fired on the first attempt in December 2024leap71.com. Its toroidal combustion chamber and central spike (visible at top) are cooled by intricate regenerative channels that were algorithmically engineered by Noyron to handle 3,500 °C exhaust gasesleap71.com.

The development cycle flow at Leap71 thus becomes a continuous loop: capture requirements → generate design → simulate → fabricate → test → update model → (repeat). A real-world example of this is the development of their 5 kN kerosene/LOX aerospike engine (shown above). The requirement was set for a 5,000 N thrust aerospike operating from sea-level to vacuum. Using Noyron, the team generated a novel toroidal-chamber aerospike design that integrated all components (combustion chamber, injector, nozzle spike, cooling passages) into a single monolithic partleap71.com. This design was produced entirely by the AI in a matter of weeks and 3D-printed in copper. Upon hot-fire testing, the engine achieved a full chamber pressure of 50 bar and fired successfully on the very first tryleap71.comleap71.com – a testament to the accuracy of Noyron’s physics-driven design. During that test, some issues were observed with startup transients (ignition dynamics) on the aerospike, which prompted the engineers to refine the design with an improved ignition system for the next iterationleap71.comleap71.com. All the test data (pressures, temperatures, efficiency measurements) were fed into the Noyron model to sharpen its predictive capabilities going forwardleap71.com. Lin Kayser noted that Noyron’s ability to quickly “re-engineer and iterate after a test” enabled the team to converge rapidly on an optimal design after only a few cyclesleap71.com. Indeed, over the span of 12 months, Leap71 tested multiple Noyron-designed engines (ranging from 1.5 kN to 7.5 kN thrust, in different configurations) and reached the point where Noyron could deliver “first-time-right” rocket engines for certain propellantsleap71.com. Each iteration not only improved a specific engine’s performance but also enriched the overall computational model for future projects.

Throughout these high-speed optimization cycles, human engineers remain deeply involved in a supervisory and learning capacity. They set the goals for optimization (e.g. improve combustion efficiency, reduce wall temperature, etc.), monitor the simulation outcomes, and analyze test results. Crucially, they update the Noyron code with any new understanding gained – for example, if a certain empirical correlation needs tuning or a previously neglected phenomenon (like methane’s compressibility at cryogenic conditions) needs to be added, the engineers modify the model accordinglyleap71.commetal-am.com. This human-in-the-loop approach ensures that the AI design agent (Noyron) is always guided by expert knowledge and real-world data. Over time, the need for large corrections diminishes as the model becomes more mature and validated. Leap71’s team has described this virtuous cycle as a “physics-driven approach to computational AI,” where each design-test iteration makes the AI smarter and the designs more reliableleap71.comleap71.com. The end result is a development methodology that blends human ingenuity with machine speed: critical engineering judgment is applied to set targets and interpret outcomes, while the heavy lifting of design generation and brute-force optimization is handled by the computer.

Conclusion and Outlook

Leap71’s development methodology for aerospike rocket engines exemplifies the power of combining human expertise with advanced computational design automation. In the requirements definition phase, human engineers explicitly program the design intent, constraints, and physics into an AI-driven model (Noyron), essentially creating a digital engineer. In the parametric design phase, that model autonomously generates a viable engine design in a matter of minutes, complete with all geometry and internal features, thanks to its encoded knowledge of physics and manufacturing. Finally, through high-speed optimization cycles, the design is rapidly refined by looping through simulations and real-world tests, with the AI model learning from each iteration. This process is far more automated and faster than traditional rocket engine development – Leap71 has shown that even a complex aerospike engine can go from concept to hot-fire in weeks, and then be continuously improved in short cyclesleap71.comleap71.com. Human designers remain integral at each stage: they define the problem and constraints, they embed the engineering wisdom into the algorithms, and they interpret and augment the AI’s output. However, much of the labor-intensive work (detailed design drafting, routine optimization, data processing) is handled by the computational engineering platform.

Leap71’s toolset – notably Noyron and the PicoGK geometric kernel – provides the backbone for this methodology, enabling what the company calls “engineering at the speed of Moore’s Law.” Designs that once took months or years of manual effort can now be generated or altered in minutesjlk.ae. By capturing engineering knowledge in code, the process ensures that nothing is lost between iterations and that each new design stands on the shoulders of the lastmetal-am.comleap71.com. The case of the AI-designed aerospike engine underscores the potential: an engine type long considered elusive was successfully realized and optimized through an AI-driven approach, something that might have been prohibitively slow with conventional methods. Moving forward, Leap71 is scaling this methodology to much larger engines (on the order of 200 kN to 2,000 kN thrust) by using the same computational DNA and partnering with large-format 3D printing providersvoxelmatters.comvoxelmatters.com. As they progress, the iterative loop of requirement → design → simulation/testing → refinement is expected to continue, with ever greater automation. The company’s vision is that future propulsion systems won’t be hand-drawn at all – they will be computedmetal-am.com, allowing engineers to focus on defining goals and innovating, while AI design agents handle the heavy lifting of optimization. Leap71’s early successes with aerospike engines suggest that this vision of faster, smarter engineering is well on its way to becoming reality.

Sources:

コメント

タイトルとURLをコピーしました