Using AeroSculpt

AeroSculpt has three wind tunnels; pick one with the switch at the top of the workspace, and change it whenever you like.

Above each body's critical Mach number (typically 0.7–0.85) the General tunnel's drag is a transonic estimate that joins the Supersonic tunnel at Mach 1.2 (see compressibility). The steps below are those of the General tunnel; the RC and Supersonic tunnels add their own. Contents: 1 Model · 2 Protect · 3 Flight envelope · 4 Simulate · 5 Optimize · templates (named dimensions) · rockets · fixed-wing UAVs · RC tunnel · Supersonic tunnel · accuracy tools · cars · CAD and Fusion · structure and mission · reports and exports · teams · desktop app · physics · safety · limits · API

1. Model

• Formats. STL and OBJ are read on the server; STEP, IGES, BREP, 3MF, PLY and glTF are tessellated in your browser and uploaded as STL.
• Units and orientation. Pick the file's units and the axis the nose points along. The tunnel flow travels along +X with Z up; the blue arrow in the view shows it, and the nose should face it. Check the reported length — a UAV listed as 1,400 m means the file is in millimetres.
• Watertight is best. Closed shells give exact inside/outside tests and the volume and keep-inside checks. Open meshes still run as thin walls.
• Assemblies are fine. Wings pushed into a fuselage, fins into a body tube: shells are voxelized separately so overlaps never cancel.

2. Protect

Regions tell the optimizer what it must respect. Each is a box or a cylinder (a cylinder runs along the flow axis until you turn it), with its centre and size in your model's own units. Add one and click the model to place it. Then shape it in the 3D view: drag the handles to Move (W), Turn (E) or Resize (R) it — the centre handle of Resize scales evenly, and Snap (or holding Shift) steps turns by 15° and sizes by 5 %. Click any region in the view to select it. The card on the left shows the same numbers, including the turn as roll, pitch and yaw about the airframe's axes, and you can type them exactly.

Volume limits (in step 5) add a global constraint on top: keep at least, and at most, a given share of the original volume.

3. Flight envelope

Instead of a single condition, you give an airspeed range and an angle-of-attack range, each with a number of points. Every result — and every optimization — covers all combinations.

• Angles cost runs, speeds are (usually) free. Each angle of attack is one CFD run. When the flight Reynolds number is above what the grid resolves (almost always for rockets and UAVs), the simulated coefficients do not depend on speed, so every airspeed comes from the same run: only the skin friction is re-scaled to each speed's Reynolds number.
• Symmetric bodies. If the body is mirror-symmetric top-to-bottom (most rockets and pods), negative angles are mirrored from the positive ones instead of being simulated again.
• Altitude sets air density and viscosity from the International Standard Atmosphere. Sideslip yaws the body.
• Reference area defaults to the frontal area. For UAVs enter the wing area to get conventional lift and drag coefficients.
• Compressibility. The CFD itself runs at low Mach number. Above Mach 0.3 every face's pressure is corrected with the Kármán–Tsien rule and skin friction with the subsonic compressible flat-plate factor (1 − 0.1 M²). Each run also finds the body's critical Mach number, where its lowest pressure first reaches sonic speed. Up to there the corrections are standard practice; above it, shocks form and the drag is a transonic estimate — a smooth bridge from the corrected value to the supersonic surface methods at Mach 1.2 — with lift and moments held at their critical-Mach values. Every condition is labelled incompressible, corrected or transonic estimate. The top speed is Mach 1.2.

4. Simulate

The tunnel runs on an NVIDIA GPU when the server has one (measured on a laptop GTX 1650 Ti: about 400 million lattice updates a second, twelve times the 6-core CPU) and falls back to the CPU otherwise; both give the same answer to within 0.2 %. A run is one angle of attack; later angles warm-start from the flow of the previous one and finish sooner. The workspace shows the time measured on the server you are using.

Results include the drag polar (Cd against angle at each speed), lift curve and its slope CL_α, L/D and where it peaks, pitching moment and its slope Cm_α (negative means statically stable about the body centre), drag and power at every speed, a pressure/friction breakdown, and surface pressure, streamlines and slices at every angle. Use the α and V selectors at the bottom of the 3D view to move between conditions.

5. Optimize

Choose a goal and how hard to search (Quick, Balanced or Thorough), then press Optimize. By default AeroSculpt decides what to change: every whole-body change your plan allows (nose, tail, cross-section, length, camber, edges) plus new geometry it designs itself — a boat-tail, a rounded front, a rear slant, a rear diffuser angle. It keeps only what the wind tunnel confirms, then designs new ideas on the improved shape and tests those, round after round, until a round finds nothing more. Protected regions and your limits always hold. Under Show advanced options you can instead pick the changes yourself, add shape features, set the exact budget and the volume and size limits.

Every design is scored against your original at every (angle, speed) condition, so the winner is better across the envelope, not just at one point. Each round spends its runs in four steps:

1. Measure the error. The original is re-run shifted by part of a grid cell. The scatter is the solver's run-to-run error for this body on this grid; a change is only accepted when it beats twice that (or 0.2–0.4% for the deterministic models).
2. Screen. Each free parameter is moved once by a quarter of its range, each alternative profile is tried once, and the parameters are ranked by their effect. You see the ranking with the error line drawn on it. Only the top few (your choice) with a real effect go on.
3. Search. A Gaussian-process model of the objective chooses each next design by expected improvement. It stops at the budget, or when several designs in a row bring no gain larger than the error.
4. Confirm. The best candidates and the original are re-run one level up — CFD bodies explore on a coarser grid and confirm at the fidelity you chose (a body too small for the coarser grid explores at your fidelity and confirms one level finer, at no extra credits); wings explore on a coarse wing model and confirm at full resolution. Each candidate is also re-run at both grid shifts of the error probe and must win at every one: a shape that only wins where the grid happens to fall is exploiting the grid, not the air. If the gain does not survive by more than the error, the result says no reliable improvement and keeps your original.

Every candidate is checked before it costs a run: your size and wall limits, the volume range, keep-inside and protected regions, a watertight surface with no part passing through itself, and for winged designs stall and stability. Identical cases are never run twice (results are cached by a hash of the geometry and settings), and each run starts from the previous flow field. Runs are not spread over several processes at once: one run already uses every processor core.

An optimizer finds whatever the solver rewards. The tunnel's lift still reads low on thin wings (see the validation page), so the lift-based goals are marked indicative: use them to compare designs, not to size a wing from the lift numbers. Lift needs two or more angles of attack — at a single angle a body may make almost no lift. Results show lift against drag (the drag polar, one point per angle) and lift and drag force against airspeed.

On an uploaded mesh the parameters are these whole-body controls. Hold the wing (planform) area stops the optimizer from winning by shrinking a wing. Continue from this design starts a new project from the winner for another round.

When the grid is too coarse. On slender bodies the draft grid can put only a few cells across the body, and the measured error (±3–7%) can be larger than what nose or tail changes achieve. The optimizer then reports no reliable improvement rather than a number made of noise; raise the fidelity, or optimize noses in the Supersonic tunnel.

Shape features

Shape features edit any model the way a CAD timeline does: a list of named operations applied in order, each with its own dimensions. Open Shape features in the workspace and pick one; features you place with a click start sized to the model where you clicked.

Drag a feature's box or marker in the 3D view with the same Move, Turn and Resize tools as protected regions. Each dimension has a lock and an optimizer range: unlock one (a fairing's tail length, a cut's depth, a wing's span) and the optimizer screens and searches it with everything else. Added parts merge with the body in the tunnel, and surfaces buried inside another part never count as wetted area. Every result is checked to be watertight and free of self-intersections before it is simulated. The UAV and wing templates use the wing model rather than the CFD, so shape features are not available on them.

Generative design ideas

Generate design ideas proposes new geometry for the body you uploaded: a boat-tail that continues the body's own rear section and tapers it, a rounded front when the front is blunt, and rear slant and diffuser angles. Each idea is optional: the optimizer first measures the original, then the design with each idea added, keeps every idea that beats the solver's measured error (adding them one at a time), and only then searches the kept ideas' dimensions. When nothing clears the error, the result still shows the most promising design, labelled unconfirmed, so you can look at it, download it and check it at higher fidelity.

Ideas are judged by paired comparisons: each one is simulated at its normal position and shifted by part of a grid cell, against the original at the same shift. Moving the whole body moves both drags together, so the error that matters is how well those two comparisons agree. When a body is under about 12 cells across on the exploration grid, exploration moves to the grid you chose (on a GPU).

An optional AI design assistant can choose and size the ideas from a sentence you write. It uses any OpenAI-compatible model — a free one running on the server with Ollama, or a hosted free tier — set by AI_BASE_URL, AI_MODEL and AI_API_KEY. It never writes geometry: its choices are built by the same code and tested by the same CFD.

Visual meshes: make a solid copy

Models made for rendering (cars and aircraft from asset sites, game exports) are open panels with gaps: thousands of pieces, windows as single sheets. Air leaks through them in the tunnel, drag jumps from run to run and no change can be trusted. The Model section flags such files and offers Make a solid copy: the panels are wrapped like shrink film (seams and holes narrower than a few grid cells are closed, the inside is filled) into one watertight body, as a new project with the same settings. If the file's units are unusual, choose Set the real length and type the real overall length.

Templates: named dimensions

Instead of uploading a mesh you can start from a rocket, fixed-wing UAV or wing template on the Projects page. Every dimension is a parameter with a unit, a slider, a number box, an optimizer range and a lock; moving one rebuilds the geometry in milliseconds without simulating anything. The optimizer changes the real dimensions and the result is a list of them, not just a mesh.

The NACA formulas take any value, so the optimizer can settle on 2.3% camber at 38% and 10.4% thickness; the result names the nearest catalogue section (“≈ NACA 2410”). Which section is “most efficient” depends on the lift you need, which is why wings are optimized for drag at fixed lift: give the flight mass (or the original design’s lift is kept) and each design flies at the angle that carries it. The thinnest symmetric section has the least drag at zero lift but is no use for flying, and a smaller wing only wins if it can still carry the load without stalling.

How wings are scored. The 3D CFD cannot rank airfoils — good sections differ by a few thousandths in drag — and its thin-wing lift is not validated, so winged templates use the wing model: a vortex lattice for lift and induced drag, NeuralFoil for each strip’s section drag at its own lift and Reynolds number, and Hoerner’s method for the fuselage. A design takes about a second, so large budgets cost almost nothing. Stall (any strip above 92% of its section’s maximum lift) and stability (the neutral point may move at most 5% of the mean chord) are checked on every design. Not modelled: propeller slipstream on the wing, pitch trim, structure — set a minimum wall thickness for the thinnest section you can build.

Noses. At supersonic speed the nose profile matters: the Supersonic tunnel marches second-order shock-expansion theory along each meridian, validated on cones and ogives. Subsonic, nose shape changes little as long as the flow stays attached, so the UAV template locks its nose profile by default.

Rockets: from a kit to a flight, step by step

Rocket projects carry a flight model beside the wind tunnels: the component drag build-up, Barrowman stability, fin flutter and a flight simulation with your motor, on a launch rail, in wind. It runs in milliseconds, so the Flight tab updates as you move a slider.

1. Start from the Rocket template on the Projects page, or drop an OpenRocket (.ork) or RockSim (.rkt) file: its nose, body, boat-tail, fins, launch lug, part masses, parachute and motor are read in (anything that could not be reproduced is listed on the Flight tab).
2. Design parameters: nose profile and length, body, boat-tail, fin shape (trapezoidal / swept / elliptical), fin count 3–6, fin position. Lock what your kit fixes; unlock what you are free to change.
3. Rocket flight: pick Imperial if you think in inches and feet. Masses either estimated from the geometry and typical materials (the optimizer then pays for every gram it adds), measured (dry mass and balance point) or part by part. Choose the motor from the built-in list (approximate curves shaped to the published impulse), upload the manufacturer's .eng / .rse file, or search ThrustCurve.org for the certified curve. Set the rail length, launch angle, wind, site elevation and the parachute.
4. Read the Flight tab: the verdict first (ready to fly, or what fails), then apogee, top speed and Mach, the static margin at liftoff and at top speed (CP and CG drawn on the rocket; aim for 1–2 calibres), speed off the rail (about 15 m/s / 50 ft/s or more), the optimal ejection delay and the nearest delay the motor offers, fin flutter speed against top speed, descent time and drift. Altitude and speed over time, the drag curve by part, and every mass are below.
5. Optimize with the goal Highest apogee: every design is flown on your motor and must keep the static margin, pass the flutter check and leave the rail fast enough before it is scored. Lowest drag (rocket drag model) works the same on the drag build-up. Lowest drag (CFD) compares shapes in the wind tunnel and still checks stability and flutter.
6. Compare with a real flight: upload the altimeter's CSV (time, altitude in m or ft) and it is drawn over the simulated altitude.
7. Build and fly safely. This is a simulation. Fly within the NAR and Tripoli safety codes and your local rules: certified motors, a rail or rod, a recovery system, a clear range, no flights into wind above the code's limit. The simulation does not replace a swing test, a range safety officer or the motor manufacturer's recommendations. See safety and limits.

Accuracy. The drag build-up follows Hoerner, Barrowman and the OpenRocket documentation; for a typical 3-fin kit it gives Cd ≈ 0.6 against Gregorek's measured 0.45–0.75, and the Estes Alpha III on a C6-5 comes out within a few per cent of the published altitude. Stability and the integrator match their references to a few per cent (validation). Built-in motor curves are approximate: use the certified file for the real thing. Not modelled: a 6-degree-of-freedom flight (the rocket is assumed to weathercock perfectly into the relative wind), base-drag reduction while the motor burns, spin, clusters and stages, fins on a transition, and body lift at large angles.

Fixed-wing UAVs

• Set the reference area to the wing area and the reference length to the mean aerodynamic chord (the samples do this). Sweep from just below zero lift to beyond cruise angle (for example −2° to 8°) at your cruise speeds.
• Protect wing roots, hard points and servo hatches; keep the payload bay and battery inside.
• Optimize the fuselage, pods and fairings for drag; protect the wing roots so the wing itself is not reshaped.
• Treat the CFD’s lift, L/D and pitching moment as indicative: on thin wings the simulated lift is currently 50–66% low at every fidelity (see limitations). To size and shape the wing itself, start from the UAV or wing template: those are optimized with the validated wing model at fixed lift.

RC tunnel: propellers

The General tunnel plus spinning propellers. Each propeller is described the way it is sold — blade family, diameter and pitch in inches, blade count (2–6), rpm and rotation — and placed where it will really be.

• Placing and moving: Click to place puts the hub where you click the model and, by default, onto the centre line of the part you clicked (fuselage nose, nacelle). After that, Move in 3D shows a drag handle with an arrow per axis, the Nudge buttons move it by the chosen step (1 mm to 5 cm), Snap to puts it on the centre line, just ahead of the nose (tractor) or just behind the tail (pusher), and you can type the hub position. Duplicate a propeller to make a mirrored twin with opposite rotation.
• Blade families: thin electric (slim, tapered, APC-style) and wide blade (broad constant chord, scale and multirotor style). Each has a measured planform and section aerodynamics fitted on one propeller. Checked against UIUC wind-tunnel data: three APC props within 8%, and the same wide blade with 2, 3 and 4 blades within 4% — the model reproduces the measured blade-count effect (3 blades +29%, 4 blades +56% thrust at the same advance ratio). Five and six blades are extrapolated.
• Live estimate: each propeller card shows its free-air thrust, shaft power, efficiency and slipstream speed at your envelope's airspeeds, and a comparison table when there are several, so you can choose options before spending a CFD run.
• Thrust and torque come from blade-element momentum theory with Prandtl tip and hub losses.
• The slipstream: that loading is added to the CFD as an actuator disk — axial thrust and swirl spread over a thin disk of cells — so the airframe is tested inside the propwash. The far-wake speed matches momentum theory within 1%. Individual blades are not resolved.
• Runs: the propeller loading depends on the advance ratio J = V/(nD), so with propellers turning every angle and airspeed is its own CFD run.
• Results: thrust, shaft power, propeller efficiency and advance ratio at every condition, airframe drag in the slipstream, thrust against drag, and the estimated level top speed where they cross. Flow fields are shown at the middle airspeed.
• Limits: no static thrust (the lowest airspeed is 2 m/s); the propeller axis follows the airframe, with axial inflow only (no P-factor); heavily loaded propellers slow the lattice down to stay in its low-Mach range, which makes runs longer. Wing lift carries the General tunnel's caveat.

Supersonic tunnel: shock, heat and materials

Above Mach 1.2 the flow is computed face by face on your mesh with the engineering methods used for conceptual supersonic and hypersonic design (the S/HABP family), so a whole sweep takes seconds.

• Envelope: a Mach range, an angle range and an altitude from 0 to 80 km (US Standard Atmosphere 1976).
• Materials: pick the skin material from the library (fibreglass, carbon fibre, aluminium, titanium, stainless steel, Inconel, silica tile, carbon-carbon, UHTC, ablator) or define your own limit and emissivity. Give a nose cap or leading edge its own material with a Material region in the Protect step. The Margin view colours every face by how far it is from its own material's limit.
• Nose radius drives stagnation heating (q ∝ 1/√R). It is measured from the mesh; sharp tips come out as small as the mesh allows, which is physically right but mesh-dependent — enter the real tip radius if you know it.
• Optimization minimizes drag across the envelope or the peak wall temperature, and with Respect material limits on, designs that overheat are penalised. Hundreds of designs are affordable: one credit per ten.
• Accuracy: sphere drag within 5% of free-flight data (Mach 4–10), thin-plate lift within 2% of linear theory, stagnation heating within 7% of Sutton–Graves. Normal force on slender bodies is over-predicted at low supersonic Mach (+38% at Mach 2, +10% at Mach 4), so treat centre-of-pressure positions there with care. Perfect gas: above Mach 6 real-gas chemistry starts to matter and temperatures are approximate. Not modelled: shock interactions, one part shadowing another, transient heat soak (radiative equilibrium is the conservative steady state).

Accuracy tools

Wall model. A grid can carry a limited Reynolds number, so on its own it grows thick, laminar-like boundary layers that separate too early. When the flight boundary layer is turbulent (Reynolds number above 5×10⁵), every wall cell slips tangentially by just enough that the shear the grid feels equals the log law of the wall at the flight Reynolds number (a wall-modelled LES). It is on automatically and costs nothing.

Refine near the body (Simulate step). After the normal run, a box around the body and its near wake is run again on a grid about twice as fine, its faces held at the first run's mean flow — a nested "zoom" grid. Forces come from the fine grid. It costs about 3× a run, where refining the whole tunnel twice as finely would cost about 16×. On the Ahmed car body it brings the drag from about 2× the measured value to within about 25%.

Check grid convergence (Simulate step). The design is also run on two coarser grids (2.2× fewer cells each, refinement ratio 1.3); from the three drag values the result shows the observed order of accuracy, the grid-independent (Richardson-extrapolated) value and the uncertainty on your grid as a Grid Convergence Index (Roache; procedure of Celik et al., 2008). When the values oscillate between grids, no extrapolation is shown and the band is conservative. About 1.6× the time; the coarse runs are billed at the exploration rate.

Confirmation on a different grid. The optimizer explores on one grid and confirms on another, re-running each candidate at two sub-cell shifts, so a shape that only wins through one grid's error is not reported.

Cars and ground vehicles

Turn on Rolling road in the flight envelope. The tunnel floor becomes a road moving with the air, as on a moving-belt wind tunnel, and the car sits level on it (only 0° is run). Detect wheels proposes a box around each wheel from the lowest points of the model — check and adjust them; wheels spin at road speed (rolling without slip) and are never reshaped. Keep at least 3 grid cells between the road and the underbody: below that the result warns, and Refine near the body doubles the resolution there. Not modelled: cooling flow through the radiator, and underbody detail the model does not have.

CAD exchange and Fusion

In: STL, OBJ, STEP and IGES. STEP/IGES are tessellated with the OpenCASCADE kernel (by curvature: fine on a nose radius, coarse on a flat side); the original file is kept beside the project. Out: a template design downloads as smooth STEP solids lofted through its own sections, which a CAD system can fillet, shell and dimension; any other design as a faceted STEP solid (exact to its triangles, up to 60,000), or STL.

Fusion. Template designs export a Fusion script that writes every dimension as a Fusion user parameter (named like the template's), so a parametric Fusion model built on the same names rebuilds to the optimized shape. When AeroSculpt runs on the same computer as Fusion (the desktop app, or a local preview) and the FusionMCPBridge add-in is running, Send dimensions to Fusion and Import into Fusion do it directly; this is never available on a public server.

Structure and mission (winged designs)

Every wing design the optimizer considers gets a spar: two caps at the airfoil's depth sized for load factor × 1.5 × the weight (strength), then grown until the tip bends no more than the allowed fraction of the semi-span at limit load (stiffness). A wing too thin to hold the caps is rejected, so the optimizer can no longer return a wing that would break. Set the material, load factor and stiffness under Optimize → Structure. The results plot drag against structure mass for every design; the front of that cloud is the trade-off, and any point opens as a new project.

Mission. From the drag polar at the flight weight: stall speed, best-endurance and best-range speeds, endurance and range from your battery (Wh, usable fraction, propulsion efficiency) and the rate of climb from the motor's power. A design optimized for cruise drag often stalls faster and flies shorter — the mission table shows it.

Reports, exports and comparing runs

Every finished run downloads as a PDF engineering report (setup, grid, conditions, forces, polars, convergence, flow slices, geometry, how the optimizer spent its runs, structure, mission, and the methods with the solver's measured accuracy), as flow fields for ParaView (VTK: the mean velocity, pressure and Q-criterion on a grid, and the body with its surface pressure), and as STEP. The 3D view shows vortex surfaces (Q-criterion) beside streamlines and slices. In the Runs tab, tick two runs and Compare them condition by condition.

Teams and single sign-on

On Pro, create a team under Account and invite colleagues by email (someone without an account joins when they first sign in). Share a project from its Model step. Roles: viewer opens results and downloads reports; editor also changes the design and runs jobs (billed to whoever starts them); admin manages members and reads the team's audit trail (who shared, ran, invited or changed what, and when); owner can do everything. A server can offer single sign-on through any OpenID Connect provider (Okta, Microsoft Entra ID, Google Workspace, Auth0, Keycloak): set OIDC_ISSUER, OIDC_CLIENT_ID, OIDC_CLIENT_SECRET and optionally OIDC_ALLOWED_DOMAINS; the provider's ID token is verified before any account is touched.

Desktop app

AeroSculpt also runs as a desktop app on your own computer: AeroSculpt.exe (or python desktop.py) starts it privately on 127.0.0.1 with no sign-in, keeps projects in your user folder, simulates on your NVIDIA graphics card (or the CPU) and opens it in your browser. Nothing leaves the computer unless you ask (motor search, update check), which suits CAD that cannot be uploaded. The app only answers to localhost and opens through a launch link with a one-time token, so no website you visit can drive it. Without a licence key it runs the free desktop tier; a Pro key from your account page unlocks the rest (checked offline, with a 30-day grace period after it expires). The GPU pack (CUDA runtime) is a separate download for NVIDIA cards; STEP/IGES import needs gmsh, which is GPL and not bundled. Build it with python scripts/build_desktop.py --gpu-pack --installer; AeroSculpt.exe --check says what the computer can use; Account → Desktop app saves a diagnostic bundle and checks for updates.

How the solver works

AeroSculpt builds a uniform voxel wind tunnel sized to the body (about 1.5 near-field lengths upstream and to the sides, 4 downstream, with absorbing sponge layers; flat airframes are sized by their mean chord) and runs a 3D lattice-Boltzmann large-eddy simulation: D3Q19 lattice, regularized collision, Smagorinsky sub-grid model and bulk-viscosity acoustic damping. Walls use interpolated (Bouzidi) bounce-back on the true triangle surface, so forces change smoothly with shape. Forces come from momentum exchange with a blockage correction, and each run continues until the windowed mean drag coefficient moves by less than 1%. Runs at the same angle warm-start from each other's flow.

Two regimes. Where the grid resolves the flight Reynolds number the simulated force is used directly. Above that the tunnel runs at the highest Reynolds number the grid supports: pressure drag, lift and moments come from the simulation, while skin friction is re-scaled to flight conditions with the Prandtl–Schlichting flat-plate law. See validation for accuracy.

Safety, responsibility and export control

AeroSculpt is an engineering estimate, not a certification. Rocketry carries real risk: follow the NAR / Tripoli safety codes (or your national association's), use certified motors, and have a range safety officer decide what flies. Vehicles you build from these results are your responsibility. The methods implemented here are published, public-domain engineering methods (Hoerner, Barrowman, NACA reports, textbook gas dynamics); users remain responsible for complying with the export-control and other laws that apply to their own projects and the data they upload.

Limitations

• The rocket flight model is a point mass pointing into the relative wind (no 6-DOF dynamics, spin or coning); base drag is not reduced while the motor burns; the transonic rise of the pressure drag is interpolated between Mach 0.8 and 1.3; stages and clusters are not modelled.
• The CFD is incompressible with compressibility corrections: sound to the critical Mach number, an estimate from there to Mach 1.2 (no shocks are simulated). No heat transfer in the General tunnel; propellers in the RC tunnel only.
• Boundary-layer transition is not predicted; very streamlined bodies at high Reynolds number come out conservative.
• Lift on thin wings is under-predicted by 50–66% (NACA 0012 wing, aspect ratio 6, against lifting-line theory). The tunnel resolves the boundary layer too coarsely, so it separates early on the suction side. Lift, L/D and pitching moment are indicative only, and the lift-based optimization goals are marked indicative until this is fixed.
• Uniform grids under-resolve features much thinner than a cell; wings and fins thinner than about two cells are represented as one-cell walls.
• Results are engineering estimates. Validate safety-critical designs with independent analysis or testing.

REST API (Pro)

Create a key under Account and send it as a bearer token. All endpoints return JSON.

# upload a model (STL or OBJ bytes)
curl -X POST "$HOST/api/projects?filename=uav.stl&name=UAV" \
  -H "Authorization: Bearer $KEY" --data-binary @uav.stl

# sweep and optimize
curl -X POST "$HOST/api/projects/$PROJECT/jobs" -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" -d '{
    "kind": "optimize", "fidelity": "standard", "units": "mm", "forward": "-x", "up": "+z",
    "envelope": {"speed_min": 15, "speed_max": 30, "speed_count": 4, "aoa_min": -2, "aoa_max": 8,
                 "aoa_count": 5, "altitude": 500, "yaw": 0, "ref_area": 0.42},
    "zones": [{"type": "keep", "shape": "box", "center": [320, 0, 10], "size": [180, 90, 70], "name": "payload"}],
    "optimize": {"objective": "drag", "aspects": ["nose", "tail", "fairing"], "iterations": 20,
                 "max_change": 0.25, "min_volume": 0.95, "max_volume": 1.5, "verify": "high"}}'

# poll, then download the optimized geometry
curl "$HOST/api/jobs/$JOB" -H "Authorization: Bearer $KEY"
curl -o optimized.stl "$HOST/api/jobs/$JOB/files/optimized.stl" -H "Authorization: Bearer $KEY"

Other files per job: result.json (polars for every angle and speed), history.json, fields_baseline_N.json / fields_best_N.json (flow fields per simulated angle) and baseline_body.stl / best_body.stl. Exports: /api/jobs/$JOB/export/pdf (report), /export/step, /export/vtk (zip) and /export/fusion-script; POST /api/jobs/$JOB/mission recomputes the mission with {"battery_wh", "usable", "efficiency", "motor_w", "mass_kg"}; POST /api/projects/$PROJECT/estimate takes a job body and returns how long it would take; analyses accept "grid_study": true and "refine": true.

Python client and command line. aerosculpt_client.py is one file with no dependencies: python aerosculpt_client.py upload wing.step --units mm, analyze PROJECT --grid-study --wait, optimize PROJECT --effort balanced --wait, download JOB pdf report.pdf, compare JOB_A JOB_B and sweep PROJECT --param wing_span=2.0,2.4,2.8 for batch studies. Set AEROSCULPT_URL and AEROSCULPT_KEY.