Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Start here

What FusionSpace HPR and its flight simulator, FusionSpace HPR · Sim, do today, and how to read this site.

FusionSpace HPR is a suite of open-source tools I’m building for hobby and high-power rockets. Its first product, FusionSpace HPR · Sim (HPR Sim for short), is a flight simulator. The first release is out, but HPR Sim isn’t ready to rely on yet. A flight analyzer, a competition kit and an app are planned (Decisions and the roadmap). This site explains what the simulator models, where each model comes from, and how well each one has been checked. I wrote it for a rocketeer who knows some physics and some code, but not this project.

What the simulator is

HPR Sim (called hpr-sim before release 0.1) simulates a rocket’s flight from the launch rail to landing. It’s a 6-DOF simulator: it follows all six degrees of freedom, the rocket’s position along three axes and its rotation about three. Meanwhile the motor burns, and the rocket’s mass, center of gravity and inertia (how hard it is to turn) change.

I made it a Rust library first, meant to be built into other programs, as RocketPy is. RocketPy is an open-source rocket flight simulator, written in Python and used as a Python library. HPR Sim has a Python package too (Python), and a graphical app is planned. It reads OpenRocket .ork design files today.

The command-line tool, hpr, flies a .ork or a rocket’s JSON. It looks up and converts motor files, searches vendors’ motor stock and prices, and re-runs the validation. It also reads an altimeter’s flight log and fetches a launch day’s weather (The command line). HPR Sim is the simulator’s guide. A tour of HPR Sim shows it working on a small rocket and a public flight, and Compared with other simulators sets it beside OpenRocket, RocketPy and RASAero II.

I built it to be checked, too. Every model cites a published source, and tests pin every model. The simulator is compared with RocketPy, OpenRocket and the logs of real flights, and the results are committed to the repository.

For now it covers only commercial off-the-shelf solid rocket motors (COTS motors), the kind you buy from a manufacturer. That stays true until the first app.

Release 0.1.0 came out on October 8, 2026. Install its files as Install a release says, or build it from source. How a release is built says what a release holds and how each of its files is checked. The changelog says what 0.1.0 does, how far to trust it, and its known gaps. Among them are the open issues that make a number look safer than it is.

Releases come at product boundaries, and I don’t promise dates (Phase 8, releases). Plan says what each one holds and how likely each goal is:

  • 0.1, the simulator: the library, the command line and the Python package, with Monte Carlo dispersion from the command line and Python. It waited on the logged flights’ apogees and named fixes (release 0.1). It shipped with its known limits listed. Among them is drag that reads high above Mach 0.8, so the apogee there reads low.
  • 0.2, the flight analyzer: it reads the common altimeters’ logs on their own, with no design file. Then it compares a log with its simulation, which works today, and fits the rocket’s drag from it, which is still to come.
  • 0.3, accuracy and diagnosis: the simulator measured against logged flights and improved, and a flight’s likely faults ranked from its log.
  • 0.4, the competition kit: rules presets for Student Launch, IREC and others, and an optimizer. It adds the numbers a submission asks for, ejection-charge sizing, and RASAero and RocketPy files.
  • 0.5, an app preview, on the desktop and in a web browser. Open a design or a log, fly it and replay it in 3D, with the simulated flight drawn as a “ghost” beside the real one.
  • 1.0, the app, with its design editor.

After 1.0, new product lines come one at a time, in an order that may still change. First comes designing your own solid motors, then parachutes. Then a pad-day mode on your phone: the day’s forecast, the best launch hour, drift on the field and a flight card. Then flight computers and trackers. Hybrids and liquids come last (the second-pass plan).

What works today

These parts are built and tested. Each page gives its sources, and most say what they leave out.

The pages, the program’s messages and the library’s names use US spelling for the words the style guide checks. Some saved forms held a British-spelled key: a landing ellipse, a design-check finding, a laid-out rocket and a few more. They still read the old key but write the new one, so an older build may not read what this one saves. Design files never held one and are unchanged (US names).

Earth

Gravity follows WGS 84, the model of the Earth’s shape and gravity that GPS uses, and varies with latitude and height. The Earth’s rotation is in the flight too. HPR Sim works with launch-site coordinates and gives the distance and bearing between two places. A site’s elevation is looked up online or read from a GeoTIFF file. The detail is in Frames, Geodesy, Gravity and A launch site’s elevation.

Air

The air is the 1976 US Standard Atmosphere up to 86 km (282,152 ft), with temperature offsets and humidity. Or it’s a sounding, a measured or forecast profile of pressure, temperature and wind against height. A sounding can be a real day’s weather from an ERA5 file, an Open-Meteo forecast, a weather balloon, or NOAA’s GFS and RAP forecasts. The detail is in Atmosphere, ERA5 weather files, Launch-day weather, Weather-balloon soundings and NOAA forecasts: GFS and RAP.

Wind

Wind profiles can be constant, layered, power-law or logarithmic. Turbulence, random gusts, comes from a random-number generator started from a seed, a number you choose. The same seed gives exactly the same gusts every time on the same platform (operating system and processor). The detail is in Wind and Turbulence.

Motors

HPR Sim reads .eng and .rse thrust curves, and follows a motor’s thrust, mass, center of gravity and inertia through the burn. It carries a copy of ThrustCurve.org’s whole catalog of solid motors, taken October 28, 2026: 1,004 motors and 1,701 of their 1,706 files (the whole catalog says why five are left out). By name it flies the 924 motors with a file that reads, offline, each file checked against ThrustCurve.org’s figures, and the 412 that pass held to ThrustCurve.org’s own statistics code (how). One it lacks is fetched from there by name and cached, so it flies offline after that (motors on demand). hpr motors update caches the motors and files ThrustCurve.org’s records show as added since the copy was taken (newer motors gives its limits). Stock and prices come from motor.fusionspace.co. The detail is in Solid motors, .eng files, .rse files and Motor stock and prices.

The rocket

A rocket is built from nose cones, body tubes, transitions (tapered sections between tubes of different diameters), fins and other parts, each with its material. HPR Sim works out the whole rocket’s mass properties and checks the design. Everyday fits warn, and only what can’t be built is refused (design checks that match reality). A packed part drawn wider than its bore warns. So does a part that fits a cone’s wide end but meets its wall where it narrows. The detail is in Design tree, Shapes and Mass properties.

Aerodynamics

HPR Sim finds the center of pressure, where the aerodynamic force acts. Its distance behind the center of gravity is the stability margin. HPR Sim also finds drag and the normal force. That’s the sideways force when the rocket flies at an angle to the airflow, its angle of attack. For small angles of attack, both run from Mach 0 to 5. Both are checked against a wind tunnel from Mach 0.6 to 4.63, and the drag reads high at most speeds. A part’s own drag coefficient, stated in a .ork file, flies as OpenRocket flies it (A part’s stated drag coefficient). OpenRocket’s Base drag hack example relies on that. With recovery in both programs, it flies within 4.52% of OpenRocket’s apogee on two of its three motors. On the third it’s 7.80% high, which misses the 5% bar (the table). The detail is in Aerodynamics.

Flight

A flight runs from the launch rail through powered flight and the coast to apogee. It takes an adaptive time step and marks events such as burnout and apogee. The detail is in Rigid-body flight and Time integration. To size a difference from another program, a flight in the Rust library can also take that program’s thrust, and its mass and center of mass, as numbers against time in place of its own. Only a validation test uses it so far; no command takes it (Thrust and mass from another program).

A body with only a mass and an inertia, no design and no motor, flies eight of NASA’s check cases against the histories other flight codes published: a sphere dropped with and without drag, in still air and in wind, a sphere shot from sea level, and a tumbling brick with and without damping. HPR Sim differs from those codes by more than they differ from each other in six: by 19.51 mm (0.77 in) of altitude after 30 s, because its gravity model holds terms theirs drops; by up to 0.01633 deg/s of turn rate, because its rotational equations leave the Earth’s rotation out; and by up to 105.0 mm (4.1 in) of a dragged sphere’s position, against one code whose air is denser than the standard atmosphere. Each named difference, sized on its own, brings its difference inside the codes’ spread at each code’s largest difference; for that one code it does so without explaining the gap. The two shots come out inside the spread as flown (A free body against NASA’s check cases).

Recovery

Parachutes, streamers and tumbling bring a rocket down, and HPR Sim gives the drift they carry it downwind. A rocket can separate into bodies that each descend on their own. A .ork file’s parachutes and streamers fly as OpenRocket flies them, in hpr sim too. HPR Sim’s landing speed is within 0.021% of OpenRocket’s on 50 of its 53 example flights, and within 0.12% on all 53 (Recovery). hpr sim also flies a .ork’s powered separations, one or several, though a dropped booster’s landing is rough (powered separation in hpr sim). Staged flights and a payload’s drop are below.

Design files

HPR Sim opens an OpenRocket .ork file, zipped, gzipped or plain XML, and reads the whole design. That’s the stages, the parts on and inside them, the motor configurations, when parachutes open, and the simulations OpenRocket stored. The airframe’s shape is cross-checked against OpenRocket and against RocketSerializer, a second program that reads .ork files. The parts’ positions are checked against OpenRocket alone (.ork design files). Its mass and center of gravity are checked against OpenRocket 24.12 (Mass properties). Pods and fins on a nose cone are read, weighed and flown (Pods). So are parallel stages on a rocket of one stage on the axis (Parallel stages). Three results on OpenRocket’s examples with these parts stand apart. A pod example’s sustainer reads 37.93% below OpenRocket’s apogee; it turns over before apogee in both programs. OpenRocket aborts its own flight of that example’s first configuration, so that one is compared only up to the abort. And on two pod examples the stability margin reads about 0.07 calibers high, the flattering side. A part HPR Sim can’t shape honestly is left out with a warning.

hpr sim flies 136 of the 170 motor configurations in the reference library and OpenRocket’s examples as saved, 54 of OpenRocket’s 56 among them. It flies 25 more with --accept-design-errors, and the other 9 are refused: 3 for a hybrid motor, 3 for a motor with no curve, and 3 for other reasons (How many configurations hpr sim flies). A design writes back out as a .ork that reads back as the same design. It can also be kept as a .hpr file in the HPR design format, which TypeScript and Python programs read with generated types. OpenRocket’s parts catalog is built in: 16 .orc files with 3,449 makers’ parts. The builder makes a rocket of its parts (Parts from a catalog, .orc parts catalogs). The detail is in .ork design files.

Flight logs

hpr analyze, Python and the library read a flight log on its own, with no design file (Reading a flight log). From any logger’s barometric altitude or pressure, they take liftoff, apogee, the top speed, landing, the flight time and the descent under each canopy. An accelerometer along the rocket’s axis adds the top acceleration and burnout. Without one, burnout is a floor, the top speed’s time less its bound. Each reading is within a bound held on the synthetic flights’ tuning set, or withheld with the reason the log can’t support it (Flight-log readings). The synthetic flights’ census holds 2,200 simulated flights, each with its logger’s log and its known truth (Synthetic flights). In the library, twelve readings also state a 90% interval: liftoff, the apogee’s height and time, the top speed, landing, the flight time, the mean descent rate, the top acceleration, burnout, each canopy’s rate and the main’s opening. Each passes a two-sided test on synthetic flights held apart from the 2,000 its points were fitted on; the top speed only below 227.7 m/s (747 ft/s), on 286 readings on each set, where the height’s have 820 and 845. A floor, whose truth may lie any amount above it, states a lower end in its place, tested on that test’s lower tail; a clipped top’s on tops written near a clip imposed on the log. The misses of the height, the top speed and the rates of descent fall on the coldest and warmest days, a warm day reading low; the times lean by logger, and the top acceleration most. So a waiver goes by the apogee plus its bound, a fin’s margin by the top speed plus its bound, and a load by the top acceleration plus its bound, unless the reading is a floor, which has no upper figure (The 90% intervals; not yet checked on a real flight, evidence row G34). The library’s smoother fuses a log’s barometer, accelerometer and GNSS receiver into the height and vertical speed at every sample, each with a 90% interval. At four moments of each synthetic flight with a barometer, the three sets’ intervals hold between 94.2% and 99.4% of the truths, and two logger cells 88.7% and 89.2%, which the check allows. Those sets were seen while its rules were set. It isn’t yet checked against a real flight’s (The smoother).

hpr compare sets a log against a simulation of it: how far the logged height and speed lie from the simulated, phase by phase, and each reading beside the simulation’s, read the same way (Comparing a flight with its simulation). It reports the gap and fits nothing. In the library, a least-squares fit goes further: it fits the drag, the impulse, a constant wind and the mass to a log, each with a 90% interval that passes its test on the synthetic flights (the wind’s on logs with a track), on sets seen while its model was chosen. No hpr command runs it yet, and no real flight has checked its intervals. A Bayesian option gives a second kind of interval from the same fit; it doesn’t pass its test yet, so use the least-squares ones. The library also predicts apogee from a log cut after burnout, on a barometer’s log whose climb stays under 227.7 m/s (747 ft/s). It is run on 7 of the 12 public flights, those compared along their climb. It predicts 2 of the 7, too few to say whether it beats the forward simulation: Bella Lui at +1.2% (forward +1.1%) and NDRT 2020 at −3.6% (forward +10.4%), both cut after the burn. The other 5 reach that speed before a cut (the report). In the private collection it predicts the 21 flights it can cut and fit, the slower ones: 36 others reach that speed before a cut. It reads each log up to the cut, which the forward simulation doesn’t. Its mean absolute apogee error is 3.17% against the forward simulation’s 9.37% on the 12 flights of the calibration half. On the 9 held out from later model choices (but not blind), it is 3.60% against 16.75%. Without the flights that deployed something before apogee, it is 3.00% against 10.12% on the calibration half’s 8 and 3.08% against 10.40% on the held-out half’s 3, too few for an interval (the errors). The scoreboard lists it as accuracy.from-boost.

The library reads each format into one record, every column kept on its own clock. The formats come from PerfectFlite (.pf2 files), AltOS, Featherweight’s Raven and Blue Raven, Missile Works’ RRC3 and RTx, and Eggtimer. Others come from AltimeterCloud, Entacore AIM, AerospaceNU, Silicdyne, the ARTS2, the R-DAS, AltiMAX and MARSA. A phone app’s log, GPS tracks, a course’s Teensy logger and one team’s radio telemetry packets are read too. So are zip archives and Excel workbooks. A table no reader knows is read by the units its header states, or by a column mapping you write. Binary records are read by a layout you write (Reading your own logger). That’s shown so far on one invented flight’s files (evidence row G11, your own logger). Flight logs covers each layout and how it was checked, and the notes below give some readers’ checks.

Monte Carlo

A Monte Carlo run flies one rocket many times, with its mass, drag, motor, wind, rail and recovery delays scattered. It’s seeded, so a run repeats exactly. It gives the spread of the apogee, the landing or any number a flight reports, with failed flights counted. It runs from Rust or hpr mc, staged flights included, and exports every flight as CSV. For a design without staging, Python gets the flights as NumPy arrays. Python’s numbers are the library’s to the bit on one platform, with both built in release mode (Monte Carlo dispersion).

Optimization

Three optimizers search for the design that makes a result best. CMA-ES tunes a design’s numbers, such as a ballast mass or a body length. It also picks from choices such as a motor or a catalog nose cone, within limits such as a minimum stability margin. NSGA-II weighs two goals against each other, such as apogee against stability. EGO, efficient global optimization, is for models so slow that only tens of evaluations can be afforded. Each is held to test functions whose answers are known, and CMA-ES and NSGA-II also to outside implementations. On a rocket, an answer is only as good as HPR Sim’s flight models. They run from Rust only, and competition rule files aren’t built yet (Optimization).

Python

The hpr package builds the rocket, motor, site and flight from Python, returns the recording as NumPy arrays, and reads a design from a file. It runs Monte Carlo too, its flights as NumPy arrays. Install it with pip install fusionspace-hpr from PyPI, or build it from source. It has no staging. A design read from a file flies its stored parachutes with recovery=True, but most .ork configurations are refused, as they don’t fly as written (Python).

Evidence

What backs each claim is a register of the gaps these pages state in what backs a file reader, a model or a check. Each row gives the kind of evidence behind a claim, the kind that would settle it, and the open issue waiting for a real sample. The build fails a gap stated in one of its listed phrases with no row, though a gap worded otherwise passes (the evidence register).

What doesn’t work yet

These are the gaps you’re most likely to meet. Each model page lists what its own model leaves out, and What backs each claim lists the gaps the pages state, with the issue that waits for each one’s evidence.

Speed and angle of attack

Drag near and past Mach 1 is lightly checked. Since the drag buildup through Mach 1 was built, a flight on HPR Sim’s own drag flies from Mach 0 to 5. One that reaches Mach 5, the top of the models, stops with an error.

Near and above the speed of sound, the transonic and supersonic speeds, the drag is Niskanen’s 2009 method. It’s semi-empirical: formulas fitted to measurements. Against NASA’s wind-tunnel tests of the Arcas Robin sounding rocket, from Mach 0.6 to 4.63, it reads high at most speeds. It’s highest with fins past Mach 1 (Aerodynamics). So for a rocket that goes past Mach 1, expect HPR Sim’s apogee to come out low rather than high. Its base drag, on the flat aft end, has been compared with three references. The first is MIL-HDBK-762’s worked example, a handbook calculation from Mach 0.5 to 3.2. The second is Love’s correlation of measured bases. The base drag reads high from Mach 0.8 to 1.2 against the first, and low from Mach 1.5 against the second. Between Mach 1.2 and 1.5 the sign is unmeasured (issue 68, the base drag’s error; the handbook’s calculation). Below Mach 0.8 the third, one long-boattailed NACA missile model’s measured flight, checks it coasting and with the motor burning: coasting it reads high, and under power the rule as flown reads low (the base under power).

It’s also been compared with RASAero II’s drag near Mach 1, and that comparison isn’t within the 10% target everywhere. Accuracy has the cases and errors. A drag table from another tool can replace HPR Sim’s own drag (Aerodynamics).

The normal force still has gaps near Mach 1 and on some supersonic bodies. The current body and Arcas Robin comparisons, with their measured error ranges, are in Aerodynamics and Accuracy.

HPR Sim’s models are for small angles of attack: its accuracy work assumes 15° or less (the operating envelope). Nothing models stall, the loss of lift at a large angle of attack, yet a flight uses the same models at every angle. So results near rail exit in a strong crosswind, and near apogee, are the least trustworthy.

Staging, two-stage rockets, clusters and air starts

Staging is new, and it’s checked against OpenRocket on OpenRocket’s own examples. Each motor lights at its own time, an air start included. A sustainer flies on after dropping its booster, which lands on its own (Staging). Tests check the bookkeeping. OpenRocket’s two-stage, three-stage, cluster and air-start examples make 15 flights in all. Each is within 5% of OpenRocket’s apogee and largest speed. In OpenRocket’s flights of five of them, three of the cluster’s and two of the three-stage example’s, the parachute opened before apogee. Those five apogees are compared with OpenRocket’s flight with no parachute (a two-stage and a cluster design against OpenRocket; several separations; results).

A .ork file’s ignition settings and every powered separation are read, from the tail forward (several separations). A powered separation has a time known before the flight. At that time a motor ahead of it is still burning or yet to light, and none behind it is. A separation at its own stage’s first burnout may drop that stage’s other motors while they still burn, if they lit strictly before the split. OpenRocket does the same (a stage’s first burnout).

The ignitions come with the rocket. Your program passes the separation to the flight, with a recovery device on each part, since HPR Sim refuses the flight without them. hpr sim does the same for you (Separation). The example ork_two_stage.rs does both. A lone separation with nothing ahead of it left to burn, such as a payload’s, is read too. hpr sim flies it when the payload’s own device opens at the split (a payload’s split). One beside another separation, or at or after apogee beside another, isn’t flown (which configurations fly).

A cluster, several motors burning side by side, flies, whether they share one mount of several tubes or each has its own. HPR Sim adds up their thrust and mass, and a motor off the rocket’s center line adds a turning moment. You can set a motor that fails to light, and the rocket then turns as a hand calculation says (Clusters). A .ork file’s cluster flies with a motor in every tube.

A rocket can separate into parts for recovery once the aft part’s motors have burnt out.

Effects left out

These are left out of a flight, or approximated:

  • tip-off, the rocket pitching as it leaves the rail. Its cost is measured with RocketPy’s. The Rust library flies a tip-off phase when asked. It is held to RocketPy’s in still air, and not yet in a crosswind on HPR Sim’s own normal force. On the real flights it moves each apogee by under 1%. It moves each set’s mean error by a tenth of a point or less (what it moves). Flying it by default is planned;
  • thrust misalignment, a motor pushing slightly off the rocket’s axis;
  • turbulence: the model exists, but a flight doesn’t use it. No milestone plans these last two yet, though turbulence has an open issue of its own, #39;
  • the shock load when a parachute opens, and the canopy’s overshoot of its steady drag (Recovery);
  • the internal momentum of the burning propellant, counted twice, as RocketPy counts it. A thrust curve measured on a test stand already includes its effect, and the equations of motion add it again. On Valetudo, the rocket that Getting started flies, it adds 21 N to the push at liftoff. It changes the burnout speed by at most 0.05 m/s (0.2 ft/s) (Rigid-body flight).

Outputs and ways to use it

  • Output files. Exporting a flight writes a recording as CSV, JSON or Parquet (Parquet recordings), and the flight path with its landings as GeoJSON or KML for a map. Flight metrics gives a flight’s peaks and its stability margin from the rail exit to apogee. For a rocket with a fin set of one or two fins, that’s the weakest direction’s margin (issue 329, one- and two-fin sets). It also gives the optimum ejection delay and the landing’s latitude and longitude. Fin flutter gives the fins’ flutter speed and margin.

  • Where an export comes from. A CSV’s header gives each column’s unit in brackets (time [s]). hpr sim’s JSON recording carries the motor catalog’s as-of date and how far to trust the numbers. So does the small file hpr sim and hpr mc write beside a CSV (provenance on the exports). So do GeoJSON, KML, Parquet and the --plot figure (provenance on every export). A catalog motor that hpr convert writes says the catalog’s date. A weather profile that hpr weather --output saves says whether it’s measured, a forecast or a reanalysis, and how far to trust it (provenance on the other files).

  • It reads what you type, and says what to do when it can’t. It reads numbers as you’d write them by hand: --elevation 1,280 is 1,280 m (4,199 ft). A comma it can’t read as a thousands separator, such as 3,9, is asked about. A refused option is named with its value, its unit and an example. For a file that isn’t there, it names the closest file in the same folder (typing numbers; errors and typed numbers). Every refusal ends with a help: line that says what to do. A fetch that waits on the network says on the terminal what it’s waiting for (next steps and waits).

  • hpr sim flies a design and plots its flight. It flies a .ork file or an HPR design file and exports its recording (The command line). With --plot it draws the flight’s altitude, speed and acceleration against time, as an SVG in the FusionSpace chart style. Events are marked and listed in a table, and a title block closes it. The panels’ heights are chosen so their slopes run near 45° (banked). The numbers it draws go in a CSV beside it (Plotting the flight; plots; their style; balloons, banking, title block and data).

  • hpr sim reads by name. Its readout leads with the static margin, and the center of gravity and center of pressure it came from. Then come the apogee, the rail exit speed, the ejection delay and the descent speed under open parachutes. Each height and speed is in SI, with feet or feet per second in parentheses (units). It ends with how far to trust it, from 60 logged flights (how far to trust a result). It calls configurations and parts by name, such as [C6-5] for a configuration the file leaves unnamed (readable output). It flies a .ork file’s parachutes and streamers, and its powered separations, one or several (powered separation in hpr sim; several separations). It also flies a payload dropped with nothing left to burn, when its own parachute opens at the split (a payload’s split). A rocket’s .json carries no parachute. A Rust program flies separations and parachutes. Getting started flies a first rocket, and The builder builds and flies one of your own in a few calls. A Python program flies the parachutes of a rocket it builds part by part, or a design file’s with recovery=True, but no staging (Python).

  • Not every .ork file’s motors fly offline. HPR Sim reads a .ork file (.ork design files), but a file rarely carries its motors’ curves. On the file’s curves and the bundled catalog, 154 of the 170 motor configurations of the reference library and OpenRocket’s examples fly, before hpr sim’s design checks (the counts). hpr sim looks for a missing curve on ThrustCurve.org and keeps what it finds. After that one fetch, 136 of the 170 fly as saved, 25 more with --accept-design-errors, and 9 are refused (how many fly). Its parachutes and streamers fly as OpenRocket flies them (Recovery). hpr sim --motor flies one with a motor you give (The command line).

  • Monte Carlo runs give the apogee’s spread and landing ellipses, from Rust, the command line or Python. A Monte Carlo run flies a rocket many times with its mass, drag, motor, wind and rail scattered. It’s seeded and reproducible (Monte Carlo dispersion), and it draws the ellipse its landings fall in (Landing ellipses). hpr mc runs one on any design hpr sim flies, and exports every flight as CSV. For a design without staging, hpr.MonteCarlo returns the same flights to Python as NumPy arrays, but not the ellipses (Python). Morris screening and Sobol’ indices rank which inputs matter most (Sensitivity analysis). CMA-ES finds the values of a design’s numbers that hit a target. For example, it finds the ballast and body length for a 3,048 m (10,000 ft) apogee with a chosen margin. CMA-ES also chooses a motor and a nose cone within a competition’s limits, and NSGA-II weighs apogee against stability (Optimization). Their answers are only as good as HPR Sim’s flight models. Competition rule files aren’t built yet. There’s no app yet: it’s on the roadmap.

  • A damaged file gets an error, or a value from what was left, on the damage the tests try. Each reader is tried on cut, changed and arbitrary bytes, for a crash or a hang (Damaged files).

  • The flight-log analyzer gives readings within bounds; twelve state intervals, and the smoother gives a health card. hpr analyze and the Python package read a flight log on its own, with no design file and no simulation. They use its format’s reader, or the column mapping or record layout you write for your own logger (Reading your own logger). They give liftoff, apogee, the top speed, landing, the flight time and the descent under each canopy. From an accelerometer along the rocket’s axis they also give the top acceleration and burnout. Burnout and each leg of the descent came with the rest of the readings. Each reading comes within a stated bound, or is withheld with the reason the log can’t support it (Reading a flight log). A GPS track gives no reading, and a board’s three axes give no top acceleration. Two logs of one flight, or one logger to a stage, go on one timeline by a shared liftoff and read side by side, never averaged (two logs of one flight). --ghost writes the logs’ paths for a viewer, as JSON, CZML or glTF (ghost files). Like hpr weather and hpr motors show, it ends with how far to trust its figures (units and trust notes on every readout).

    Here are notes on some of the readers. Most say what the reader was checked against:

    • AltOS’s raw downloads, the .eeprom files of the board’s own log, match AltosUI’s exports on every value converted to SI, in all 9 samples that have one. One export’s acceleration, zeroed at +1 g, is counted apart (AltOS raw downloads, the layout).
    • The ARTS2’s .odf is in units from its own calibration, and holds the same records as its raw CSV. It agrees with DataAnalyzer’s export in all 3 samples: the acceleration within half a count, the barometric altitude in order only (ARTS2 raw data, the layout).
    • The words of Missile Works’ RTx GPS tracker’s .rtx file are decoded from the files. They agree with mDACS’s CSV and text exports on every fix but the last, which the exports leave out, in all 5 samples. Every field agrees in 4, and positions and altitudes in the fifth (Missile Works’ RTx, the layout).
    • A table from a logger no other reader knows is read only as far as its header states its units, each unit held to the column’s name and values. Of the 31 sample tables, 224 columns are read in a stated unit, and the rest kept as written (tables read by their headers, the layout).
    • GPX 1.0 and 1.1 files: each value of three invented files equals an independent reader’s (GPX tracks, the layout, the register’s row on GPX).
    • A zip archive of a flight’s files is unpacked to read each one (archives and two readers’ variants).
    • An Excel workbook’s sheets are each read as a file. Every cell of the 16 sample workbooks agrees with an independent reader’s (Excel workbooks, the layout).
    • Eggtimer and RRC3 exports saved by a European locale’s spreadsheet are read, with decimal commas tested on invented files. In the survey, six team tables are read by the column mapping RocketPy states for them (mappings a publisher states, the mappings).
    • A team flight computer’s binary records, from a raw file or a console capture’s base64, are read by a layout the caller states. Every field of the 5 sample files matches the team’s own decoded table (binary records by a stated layout, the layout).
    • A Blue Raven’s USB download keeps only the records whose CRC checks, each held to its stated length, and reads the fields its manual lists. Every value of the 2 sample files matches the survey’s own decoding (the Blue Raven’s USB download, the layout).
    • Every value of the 8 sample files from a course’s Teensy data logger matches the survey’s own decoding (a course’s Teensy data logger, the layout). Each unit no line states is held to the flight’s physics: the barometer’s altitude to its pressure by the BMP180’s formula, 1 g at rest, the time to apogee.
    • A team’s radio telemetry packets are read as its flight computer logged them, as a receiver heard them, and inside an RTF document. Every packet a receiver or an export holds that the onboard log also holds matches the log’s, field for field (radio packets, the layout).
    • A Raven FIP export pasted into a workbook with its header missing is read under a stated header (workbooks with a reading beside, the layouts). The two sample sheets match the .FIPa of the same flight, sample by sample. Every cell of the sample AltiMAX .xls export is checked by an outside reader, and each of its heights follows its pressure by the standard atmosphere’s formula.
    • A MARSA altimeter’s download is read in feet and g. Its units are held to an AltOS board’s in the same flight, the apogee 0.981 and 0.986 times its. AltOS’s radio telemetry decoded to a table is read by its header, and a table cut from an AltOS export by AltOS’s state numbers. An AltOS export a spreadsheet re-saved keeps each formula as text (altimeters’ other text, the layouts).
    • A table whose header states too little, or that has none, is read by a column mapping. The sample tables’ mappings each hold every unit to a physical check (tables by mapping, the layout).

    The layouts read covers each format. The first readers came with the record, a survey and three families and RRC3, Eggtimer and Blue Raven CSV. GPS tracks, text loggers and club layouts followed. Every sample log in a layout HPR Sim knows is read. The formats with no sample, such as CATS’s, are listed as needing samples (the register’s row on these formats). hpr compare sets a log against a simulation of it, and fitting drag and impulse to the log is planned (a flight against its simulation).

Accuracy so far

Accuracy gathers every result so far, gaps included. The accuracy work aims first at the flights most rocketeers make, the core band: up to Mach 2.5. It assumes angles of attack of 15° or less. The wider envelope runs to Mach 3.5, at any angle (the operating envelope). So far, whole flights are checked mostly below about Mach 1.15.

Faster flights still fly, and they say so. A flight carries a flag when it goes beyond the validated range, at a high angle of attack, outside the core band or beyond the envelope (the envelope flags). A flight that meets a known error in HPR Sim’s drag, its stability or the flight’s path warns by its issue number (the lists). The warnings came in steps: drag, stability, four more and a flight unstable under power, and the flight’s path. A flight whose static margin falls below zero while a motor burns says its apogee isn’t a prediction. The results so far:

  • Whole flights match RocketPy’s in height, speed and time when both codes fly the same drag. Six of RocketPy’s example rockets agree within 3% on apogee, speeds, burnout and flight time (the whole-flight cases). So does where they go, except for rockets that leave the rail slowly in a wind. There, three things move HPR Sim’s drift: its body lift, which RocketPy leaves out, its later release from the rail, and for one rocket its simpler fin model. They put the apogee’s drift −4.333% to −38.158% from RocketPy’s, and the landing’s −21.686% to +36.678% (report; Accuracy). With HPR Sim’s own drag, against RocketPy flying the drag its examples ship, HPR Sim’s heights differ from RocketPy’s by −7.280% to +10.302% (report). The larger gaps are where the two drags differ most. HPR Sim’s drag is well below the example’s for two rockets. It’s above it at high speed for Prometheus 2022, which flies through Mach 1 (Accuracy).

  • Against 12 public real flights, HPR Sim’s apogees miss by 8.88% on average, outside the 5% target (the register’s row on these misses). One by one they miss by −29.16% to +10.40%. HPR Sim’s height is read the way each log’s barometric altimeter reads the air. Seven of the 12 altimeters are assumed to be barometric. Four are from the seven flights compared first (the register’s row on those altimeters), and three from EuRoC 2022 (the register’s row on those three). Drift and speed aren’t compared yet (real flights, report).

  • Against 60 more real flights, from a private collection, HPR Sim and OpenRocket both over-predict the logged apogee. HPR Sim does by 8.01% on average and OpenRocket by 6.72%, and they agree with each other within 5% on 59 of them. Neither meets the 5% target. Each flight was rechecked against the collection’s own catalog of its sources (the collection rechecked). On the 68 flights both fly, the gap between the two codes is split by cause, and drag is the largest part on 61 (the split). By Mach number, the largest share of that drag difference, in mean absolute value, is below Mach 0.8 (the bands). The largest term in that share is the base drag, four fifths of it while the motor burns (by term). On a NACA missile model’s measured flight below Mach 0.8, HPR Sim’s rule leaves no base drag under power, too little. Coasting, behind its long boattail, HPR Sim read the base 5 to 8 times the measured; it now keeps dB/d1 of the flat-base value behind a boattail, on Stoney’s rule, and reads 3.0 to 5.1 times (the base under power). On the 5 that only just pass Mach 1 (1.06 on average) with a tangent-ogive nose, flying OpenRocket’s nose pressure drag in HPR Sim lifts its apogee by 1.28% of OpenRocket’s on average. That sizes a difference between the codes, not which is right (the nose’s line). The flights’ owners allow only aggregate numbers (private collection, report).

  • The scoreboard sets HPR Sim beside OpenRocket and RocketPy, axis by axis, each number read from these reports. It opens with how many of its cells are measured. Where HPR Sim and another tool both are, it says which is ahead, and each cell nothing measures yet names the milestone that will. CI fails when one of HPR Sim’s numbers there gets worse, unless a decision record accepts it (the scoreboard’s milestone; Accuracy; scoreboard).

  • The scoreboard counts the steps to a first answer: opening a design’s .ork file, flying it and getting its landing spread. HPR Sim takes 2 commands or 10 lines of Python, from files a test runs. Neither OpenRocket nor RocketPy does all three from the .ork file. OpenRocket 24.12 opens and flies one in 7 clicks but has no Monte Carlo, and RocketPy reads no .ork file (steps to a first answer; Accuracy).

  • The descent under a parachute matches RocketPy’s. The comparison flies the descents of five of RocketPy’s example rockets in both codes:

    • Each starts from the same state near apogee, with the first parachute opening at once.
    • Both codes get the same drag areas and wind.
    • RocketPy’s parachutes can add random noise, which would make each run differ; it’s switched off.
    • HPR Sim uses RocketPy’s formula for gravity. It also uses RocketPy’s way of interpolating the wind, that is, of working out the wind between the heights it’s given.

    Six numbers are compared for each rocket. They’re the descent time, the mean descent rate, the descent rate at landing, and the drift in total, to the east and to the north. All 30 agree with RocketPy’s within 3%; the largest difference is +2.865%. That shows the two codes agree on the descent physics, not that either matches a real flight. The committed validation report has every number, and Recovery explains the comparison.

  • Each model is tested on its own: against exact answers, and against its source’s tables or worked examples where it prints them. Several parts are also tested against RocketPy. Each test states its tolerance. The largest known gaps:

    • The drag was checked at Mach 0.3 against other programs’ curves (below), and from Mach 0.6 to 4.63 against NASA’s Arcas Robin wind tunnel. There it reads high at most speeds, most of all with fins past Mach 1. 2 of 44 measurements are within the 10% target set before measuring (Aerodynamics). The normal force and center of pressure were checked at Mach 0 against Barrowman’s worked examples. From Mach 0.6 to 4.63, against the same wind tunnel, they miss at Mach 0.8, 0.9, 0.95 and 1.2 on the short model, and at 0.9, 1.0, 1.2, 1.8 and 2.3 on the long one. Where the center of pressure misses up to Mach 1.2, it reads 0.67 to 2.36 calibers aft of the tunnel’s, the flattering side for the margin; the short model’s miss at 1.2 is on lift alone. At 1.8 and 2.3 the long model’s center of pressure reads 0.52 to 0.53 calibers forward, the cautious side. From Mach 2.96 up, both are within target. Aerodynamics reports the current comparison and its measured range.
    • The drag was compared with drag curves that come with RocketPy’s example rockets, labeled as RASAero II’s (another rocket aerodynamics program). The curves don’t record the fins’ edges or the surface finish, so HPR Sim’s copies of the designs follow a declared guess. HPR Sim is within 10% in two of the seven cases.
    • HPR Sim’s drag is 18% low for Cavour, another of RocketPy’s examples, while its motor burns (power-on drag). The cause isn’t known yet.
    • HPR Sim’s drag is 47% to 50% below Valetudo’s example curve. Valetudo is the rocket that Getting started flies. Its references disagree with each other, though. At Mach 0.3 the example curve gives a drag coefficient of 1.05, 1.44 times the 0.728 in an OpenRocket file of the same rocket. Given that file’s own surface finish and launch lugs, HPR Sim gives 0.714, 1.9% under the file’s 0.728 (Aerodynamics).
    • The Recruiter is a six-fin model rocket that J. S. Barrowman works through in his 1970 report Centuri TIR-33. HPR Sim follows his method for the normal force. For the Recruiter, HPR Sim’s normal-force slope, how fast the sideways force grows with angle of attack, is 2.87% above his printed value. On the fins alone it’s 3.42% above. Most of that comes from a different rule for six fins (Aerodynamics).
    • Tumbling drag is −10 to +19% off its source’s own drop tests. A separated body falls with no drag until its parachute opens. So the parachute can open at a higher speed than it would for real (Recovery).
  • You can check it yourself. Getting started shows how. Run a program that shows how much the drag moves the apogee, or trace any number with Checking a claim. Or compare HPR Sim’s apogee by hand with your own altimeter’s or another simulator’s.

Reading these pages

New here? Getting started builds HPR Sim and flies a first rocket. How a flight is simulated follows a flight from the pad to the ground, linking the page for each model on the way.

Have an OpenRocket design? Three how-to guides take it through hpr on the command line: Fly your .ork, Pick a motor and Check stability for a certification flight.

Want the physics behind a number? Rocketry explained holds guides that explain it, each figure drawn from HPR Sim’s own results:

Each model page opens with In short: what it models, its sources, how well it is validated and what it leaves out. Below that, it names the code that implements the model, the sources it follows and the tests that pin it.

Sources are cited by a short key in square brackets, such as [N09] for Niskanen’s 2009 thesis on model rocket simulation. The full reference is near the top of the page.

Equations are typeset as a textbook sets them, here and on GitHub. The code’s documentation writes them in plain text. For example, once its drag balances its weight, a rocket under a parachute falls at the steady speed

ve=2mgρCDS

where m is its mass, g gravity, ρ the air’s density and CDS the parachute’s drag area (Recovery).

Terms are defined in the Glossary. Checking a claim shows how to trace any number to its source, its test and its validation.

The code itself is documented in the API reference, which Rust’s documentation tool generates from the source. It lists every public type and function. Each crate’s front page links back to the pages here that explain its models.

Three kinds of label link to the project’s records on GitHub, which Decisions and the roadmap introduces:

  • A milestone, such as M1.8, is a step of the roadmap, the ordered plan of work.
  • A decision record, such as ADR-011, explains a significant choice and the alternatives that were considered. All of them are in the decision log.
  • A Loft lesson, such as Loft lesson L15, is a mistake found in Loft, the project that came before HPR Sim. A test here guards against it, or will once its milestone ships. They’re listed in Lessons from Loft.

Every page’s source is a Markdown file in the repository’s docs/ folder. The pencil icon at the top of a page opens its source in GitHub’s editor, where you can propose a fix.

Under each page’s title, one sentence in larger gray type says what the page covers. Each of its two to six sections starts under a thick rule in the text’s color.

The header and the theme switch

The theme switch, Auto, Light, Dark and Field, sits in the header before the print and edit buttons on a window 960 px wide or wider. On a narrower one it’s at the top of the table of contents, and on a phone it’s behind the menu button. Auto follows your system’s light or dark setting. Field is the design system’s theme for reading outdoors, at the pad. It differs from Light in three ways: a white page instead of a gray one, darker secondary text, and stronger rules (Field in the switch). It prints the same as Light. A choice you make is kept in your browser, for this site only. Each button’s tooltip says what its theme looks like, or what it’s for.

With the keyboard, Tab reaches every button in the header. On a phone, Enter or Space on the menu button, the three-line icon named Toggle Table of Contents, opens the table of contents and moves to its first control, the theme switch.

Each page but the print page (the whole guide on one page, below) ends with one line: the FusionSpace mark and the name FusionSpace HPR, Version and the last release’s number, Issued and the date of the commit the site is built from, a chip with the site’s status, and About HPR Sim, a link back to this page. The version and the date can be weeks apart. The chip reads In preparation while the pages describe work after the last release, and Released when they describe a release as it shipped. The title block at the end of this page is the site’s about box: it says what each entry means, and writes the status in capitals, as a drawing’s title block does.

Printing

A page prints in the light theme’s colors, whichever theme you read it in, without the table of contents or the buttons. Each link’s address follows it in parentheses. For another site that’s the whole address, and for a page of this one it’s the path from the page, such as cli.html#units. The line with the version and date closes the page, without the footer’s link to this page. The printer icon at the top, Print the guide, opens a cover with a Print the guide button, which prints every chapter one after another, then the whole title block. That runs long, since it holds every chapter and its links’ addresses. Printed to a PDF file, the guide reads offline.

Title block

The table below is the site’s title block. It’s the box in an engineering drawing’s corner that says what a document is, who issued it, when, and which sources it rests on. Its fields follow ISO 7200, the standard for drawings’ title blocks. Its entries describe the whole site and this version of HPR Sim. The line at the foot of every page but the print page takes the version, the date and the status from it. The printed guide ends with the whole block, its own title added as “Page” after the site’s. FS-ACHERNAR · SW · TOOL 001 is HPR Sim’s number in the register of FusionSpace, the family of tools it belongs to: Achernar, the simulator’s internal name, then software tool 1.

FieldEntry
OwnerFusionSpace
TitleFusionSpace HPR · Sim: a flight simulator for hobby and high-power rockets, and its documentation
DesignationFS-ACHERNAR · SW · TOOL 001
Version0.1.0, released 2026-10-08 (what it holds); the site is built from the repository’s main branch, which may be ahead of it
Date of issue2026-11-21
StatusIN PREPARATION: these pages describe the next release as the main branch holds it, so a page may describe what 0.1.0 lacks; how far to trust each result is in Accuracy so far
UnitsSI (meters, kilograms, seconds) first. Every command’s text adds US units in parentheses: feet after heights and distances, feet per second after speeds, miles per hour after the wind, °F after the air’s temperature, g after an acceleration and inches after stations along the rocket and a motor’s size; hpr motors show adds ounces or pounds. The plot gives a second scale in feet, feet per second and g. This site’s pages, unlike the program’s output, keep a motor’s nominal size in millimeters alone, as motors are named (a 54 mm motor); every other height, distance, size and speed on them gives its US units in brackets, checked as conversions (house style). JSON and exported files stay SI (units)
DataThrust curves: ThrustCurve.org’s solid motors, catalog captured 2026-10-28, the date flight reports give (as of 2026-10-28). Atmosphere: U.S. Standard Atmosphere 1976, or a sounding or forecast you supply or fetch (weather). Magnetic field: WMM2025. Accuracy: the committed validation report. Every source and its terms: third-party notices.
FontsArchivo and Cascadia Mono, SIL Open Font License 1.1, served from this site; no page asks another server for anything
FusionSpace HPRVersion 0.1.0Issued 2026-11-21In preparationAbout HPR Sim