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 filehpr simandhpr mcwrite beside a CSV (provenance on the exports). So do GeoJSON, KML, Parquet and the--plotfigure (provenance on every export). A catalog motor thathpr convertwrites says the catalog’s date. A weather profile thathpr weather --outputsaves 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,280is 1,280 m (4,199 ft). A comma it can’t read as a thousands separator, such as3,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 ahelp: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 simflies a design and plots its flight. It flies a.orkfile or an HPR design file and exports its recording (The command line). With--plotit 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 simreads 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.orkfile’s parachutes and streamers, and its powered separations, one or several (powered separation inhpr 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.jsoncarries 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 withrecovery=True, but no staging (Python). -
Not every
.orkfile’s motors fly offline. HPR Sim reads a.orkfile (.orkdesign 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, beforehpr sim’s design checks (the counts).hpr simlooks 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 --motorflies 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 mcruns one on any designhpr simflies, and exports every flight as CSV. For a design without staging,hpr.MonteCarloreturns 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 analyzeand 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).--ghostwrites the logs’ paths for a viewer, as JSON, CZML or glTF (ghost files). Likehpr weatherandhpr 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
.eepromfiles 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
.odfis 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
.rtxfile 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
.FIPaof the same flight, sample by sample. Every cell of the sample AltiMAX.xlsexport 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 comparesets a log against a simulation of it, and fitting drag and impulse to the log is planned (a flight against its simulation). - AltOS’s raw downloads, the
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 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
.orkfile, 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.orkfile. OpenRocket 24.12 opens and flies one in 7 clicks but has no Monte Carlo, and RocketPy reads no.orkfile (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:
- Trusting a simulation: how far a simulated apogee has been from real flights, and which way it errs.
- Stability in flight: how the center of pressure moves with speed and angle, against a wind tunnel.
- When fins flutter: what a flutter speed means, and which errors flatter it.
- Drag through the speed of sound: how drag climbs near Mach 1, what the finish adds, and which way HPR Sim’s drag errs against a wind tunnel.
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
where is its mass, gravity, the air’s density and 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.
The footer
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.
| Field | Entry |
|---|---|
| Owner | FusionSpace |
| Title | FusionSpace HPR · Sim: a flight simulator for hobby and high-power rockets, and its documentation |
| Designation | FS-ACHERNAR · SW · TOOL 001 |
| Version | 0.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 issue | 2026-11-21 |
| Status | IN 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 |
| Units | SI (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) |
| Data | Thrust 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. |
| Fonts | Archivo and Cascadia Mono, SIL Open Font License 1.1, served from this site; no page asks another server for anything |