# AeroSandbox for Differentiable Aircraft Design and Optimization > AeroSandbox is a Python package for composing aerodynamic, propulsion, structural, trajectory, and mission analyses into optimization models. Its automatic differentiation and NumPy-like syntax suit engineering studies with large design spaces, subject to the fidelity of the selected physics models. **peterdsharpe/AeroSandbox** — Aircraft design optimization made fast through computational graph transformations (e.g., automatic differentiation). Composable analysis tools for aerodynamics, propulsion, structures, trajectory design, and much more. - Repository: https://github.com/peterdsharpe/AeroSandbox - Website: https://peterdsharpe.github.io/AeroSandbox/ - Stars: 1,372 · Forks: 212 - Language: Jupyter Notebook - License: MIT - Published: 2026-10-16 · Updated: 2026-10-16 · Language: en - Canonical page: https://hysenlabs.com/projects/peterdsharpe-aerosandbox ## AeroSandbox's Multidisciplinary Design Problem AeroSandbox addresses a specific aircraft engineering problem: evaluating many coupled design choices without manually deriving and implementing every gradient between variables, objectives, constraints, and analyses. It is aimed at Python users working on conceptual aircraft design, aerodynamic shape optimization, airfoil studies, mission sizing, propulsion analysis, structural sizing, trajectory design, and related engineering calculations. The repository also presents AeroSandbox as a general optimization suite for engineered systems, although its documented models and examples are aerospace focused. The package joins analysis components instead of asking every study to begin with its own data plumbing. A design study can combine aerodynamics, structures, propulsion, mission trajectory, and stability, according to the README. It can also be used as a narrower aerodynamics toolkit. The repository links examples for vortex lattice method simulation, wing planform optimization, and airfoil optimization involving aerodynamic, structural, and manufacturing considerations. That scope creates a clear appeal for early design work, where engineers need to inspect tradeoffs among competing requirements. It does not make every analysis suitable for detailed certification or a specific flight condition. The selected aerodynamic method, structural assumptions, propulsion representation, and mission constraints still determine what the resulting design means. Automatic differentiation improves how an optimizer sees the assembled model. It does not correct an inappropriate physical approximation. ## How AeroSandbox Builds Differentiable Engineering Graphs The central mechanism is a collection of end-to-end differentiable aerospace physics models presented as components of an optimization graph. AeroSandbox exposes familiar NumPy syntax and connects that interface to modern automatic differentiation. In an optimization, this arrangement allows the software to propagate derivative information through calculations that connect design variables to the objective and constraints. Based on the repository description, this architecture is intended to coordinate multiple disciplines rather than optimize one isolated coefficient. Aerodynamics, structures, propulsion, mission trajectory, and stability can participate simultaneously. This matters because a change in one quantity can alter results in another discipline. A wing sizing decision, for example, may affect both aerodynamic force output and the loads passed into a structural analysis, although the exact study wiring still has to be defined by the user. The composability has a second path: users may use built-in physics models or supply arbitrary custom physics models. The README positions AeroSandbox as an option package rather than a closed application. Its repository contains separate aerodynamics tutorials, studies, documentation resources, and Jupyter notebooks. This makes the package relevant both to users assembling standard analyses and to engineers who need to insert a project-specific model into an optimization formulation. Automatic differentiation requires every connected calculation to preserve usable derivative information. The available documentation describes this capability and shows compatible model use, but it does not establish that every possible external model is differentiable. The continuous connection through the graph is therefore a more precise description than saying that all analyses are equally differentiable. ## Installing AeroSandbox 4.2.10 and Starting the Tutorials The README gives this command to install the package with its optional `full` dependency group: ```bash pip install aerosandbox[full] ``` This is the documented installation route. The `full` group adds CAD and geometry packages listed in `pyproject.toml`, including `cadquery`, `pyvista`, `shapely`, `sympy`, `trimesh`, and `plotly`. The base dependencies include NumPy, SciPy, CasADi, Pandas, Matplotlib, Seaborn, NeuralFoil, and supporting libraries. The project requires Python 3.10 or newer, and `pyproject.toml` identifies the current project version as `4.2.10`. For a first real use, the repository directs readers to its Jupyter Notebook tutorials. One linked notebook begins with vortex lattice method simulation of a glider and control-surface deflections, while another covers aerodynamic wing-planform optimization. These are concrete first-study choices rather than invented API calls. The repository also includes tutorials for two-dimensional aerodynamics and airfoil optimization. The README excerpt does not provide a standalone one-cell example that can be reproduced safely here, so it would be misleading to invent import statements or method arguments. A reader can therefore establish the package with the documented command, then use the linked tutorial notebook as the first executable study. Before treating notebook output as an answer, inspect which geometry and flow assumptions it uses. The repository's `tutorial/` directory is the documented source for that setup. ## Model Fidelity, Dependencies, and Optimization Boundaries The main limitation is the gap between a differentiable conceptual model and a validated engineering result. The README makes large-scale optimization a central capability, but it does not claim that every included analysis resolves the flow, structural, thermal, or operational questions encountered by a particular aircraft program. A vortex lattice calculation, for example, is presented as a three-dimensional aerodynamics tool, not as an unrestricted substitute for every aerodynamic regime. Users must also choose the analysis depth appropriate to the design phase. AeroSandbox offers both two-dimensional and three-dimensional aerodynamics and supports multidisciplinary optimization, yet the correct combination depends on the question being asked. A mission model with uncertain weather assumptions, a propulsion model outside its training data, or a structural idealization may produce a differentiable but weakly supported result. The package cannot remove that uncertainty through graph construction. Dependency compatibility creates another practical constraint. `pyproject.toml` caps NeuralFoil below version `0.4.0`, stating that minor releases can change network weights and the API. It specifically notes that AeroSandbox 4.2.7 required compatibility work for NeuralFoil 0.3.0. This cap is evidence that dependency upgrades need review rather than blind installation. The repository also contains `CHANGELOG.md`, which is the relevant file for checking recorded compatibility changes. AeroSandbox is consequently a poor choice if the requirement is a certified analysis package with regulated traceability, or if the needed physical model cannot be represented by the available APIs and custom model interface. It is better suited to exploration, sizing, optimization, and studies where model assumptions are explicit and can be revisited. ## Composing Custom Models Versus Building an Aerospace Stack A real alternative is to build an optimization stack from separate discipline libraries and connect them with a general-purpose numerical optimizer. That approach differs from AeroSandbox's main proposition. Instead of relying on end-to-end differentiable aerospace models and NumPy-like composition, the developer may write ordinary analysis functions, choose finite-difference or analytic derivatives, and manage coupling between external solvers. The custom-stack route can offer greater control over each solver and data interface, especially when an organization already has validated proprietary analysis software. It also makes solver licensing, exchange formats, and gradient estimation explicit engineering concerns. The cost is more assembly work: the developer must maintain model interfaces, derivative behavior, variable mapping, constraints, and coupling logic. AeroSandbox instead offers a domain-oriented set of composable models and a documented route to optimization. That is the meaningful difference. It is not simply another general optimizer with an aerospace name, because its value proposition rests on aerospace physics components connected to automatic differentiation. Conversely, replacing it with separate libraries is not automatically superior. The right comparison is between preconnected, differentiable disciplinary models and an application-specific integration that you assemble and maintain yourself. ## AeroSandbox Maintenance, Releases, and MIT Obligations The repository is not archived, and its last push was on 2026-10-07. That date supports treating the project as recently changed, although it does not by itself guarantee API stability. The repository has no GitHub releases, so versioning information comes from files such as `pyproject.toml` and `CHANGELOG.md`. The declared project version is `4.2.10`, and the metadata classifies the package as `Development Status :: 5 - Production/Stable`. The README and `LICENSE.txt` identify an MIT license. In practical terms, the license permits use and modification under its conditions, while distributed copies and derivative works must retain the required license and notice material. This is a summary of repository metadata, not legal advice. Organizations should inspect the actual `LICENSE.txt` and any dependency licenses separately before shipping software. Upgrade cost is likely to be more visible in compatibility work than in the package manager itself. The NeuralFoil version cap and the changelog entry about AeroSandbox 4.2.7 show why users should review dependency changes, especially for models embedded in notebooks or custom analysis graphs. Users who rely on custom models should also verify that their own interfaces still match the package version they target. The last push date is a useful maintenance signal, while `CHANGELOG.md` and dependency constraints provide the more concrete evidence for upgrade planning. ## Conclusion Adopt AeroSandbox for conceptual aircraft studies, multidisciplinary trade studies, or standalone aerodynamics when the project models fit the required fidelity and Python 3.10 or newer is available. Do not treat its outputs as final certification evidence or assume that differentiability makes an incomplete physics model accurate. Check the intended analysis methods, solver convergence, optional dependencies, and the API changes recorded in `CHANGELOG.md` before committing a long-running study. ## FAQ ### What is AeroSandbox used for? AeroSandbox is used to design and optimize aircraft and other engineered systems. Its documented models cover aerodynamics, propulsion, structures, mission trajectory, stability, and related aerospace analyses. ### How do I install AeroSandbox? The README gives `pip install aerosandbox[full]` as the installation command. The project requires Python 3.10 or newer, and the `full` extra installs the optional CAD and geometry dependencies listed in `pyproject.toml`. ### Does AeroSandbox support automatic differentiation? Yes. The README describes automatic differentiation as a central part of its optimization suite and says that its aerospace physics models are end-to-end differentiable. The repository also includes resources on automatic differentiation. ### Can AeroSandbox optimize only aerodynamics? Yes. The README presents AeroSandbox as a pure aerodynamics toolkit and links examples for vortex lattice simulation, wing-planform optimization, and airfoil optimization. The package also supports broader multidisciplinary studies. ### What license does AeroSandbox use? The repository metadata and README identify the project as MIT licensed. The actual `LICENSE.txt` file should be consulted for the license text and required notices. ## Sources - [Issues](https://github.com/peterdsharpe/AeroSandbox/issues) - [License: MIT](https://github.com/peterdsharpe/AeroSandbox/blob/master/LICENSE) - [peterdsharpe/AeroSandbox on GitHub](https://github.com/peterdsharpe/AeroSandbox) - [Project website](https://peterdsharpe.github.io/AeroSandbox/) - [README](https://github.com/peterdsharpe/AeroSandbox/blob/master/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/peterdsharpe-aerosandbox