Decisions and the roadmap
See why the simulator works as it does and what comes next, through the project’s decision log, roadmap and lessons from earlier work.
This page is the way into the project’s three records: the decision log, the roadmap and the
lessons from Loft. They are files in the repository, not pages of this site, because they are
written as the work happens. Every label you meet on the other pages, such as a decision record
(ADR- and a number), a milestone (M and a number) or a Loft lesson, links into one of them.
Decision records
A decision record, or ADR (architecture decision record), explains one significant choice: the
problem, the options that were considered, what was chosen and why, and what it costs. Records
are numbered in order and never renumbered. A record is not rewritten when a choice changes; a
new record replaces it and points back. Each record is a file of its own; the decision log
is their index, one row per record with its summary and status. The table below gives each one in
a line and is kept by a command (cargo xtask records), so a new record appears here as soon as
it is written. From the 126th record on, a row shows the record’s own summary, which is more technical,
until someone rewrites it in plainer words.
| record | what it decides | where it shows |
|---|---|---|
| ADR-000: Kickoff decisions | A Rust library first; physics and validation before interfaces; the license; a clean room (no GPL source is read); commercial solid motors only | Start here |
| ADR-001: License and workspace layout | MIT OR Apache-2.0, and how the code is split into crates | Start here |
| ADR-002: The reference library | How published sources and reference programs are pinned by hash, fetched and checked | Checking a claim |
| ADR-003: Frames, attitude, geodesy and gravity | The axes and sign conventions, WGS 84 gravity, and the Earth’s rotation | Frames, Gravity |
| ADR-004: Atmosphere, wind and turbulence | The standard atmosphere, wind by height above sea level, and seeded turbulence | Atmosphere, Wind, Turbulence |
| ADR-005: Solid motors | How a thrust curve becomes impulse, mass and inertia over the burn, and which curves are bundled | Solid motors |
| ADR-006: Component geometry and mass properties | How each part’s shape, walls, fins and material give its mass, center of gravity and inertia | Mass properties, Shapes |
| ADR-007: The design tree | Where parts sit, automatic sizes, overrides, motor mounts and design checks | Design tree |
| ADR-008: Subsonic normal force and centre of pressure | The body and fin lift models behind the center of pressure | Aerodynamics |
| ADR-009: Subsonic drag | The drag buildup, surface finishes and drag tables that override it | Aerodynamics |
| ADR-010: Time integration | The adaptive integrator, and how events such as burnout and apogee are found | Time integration |
| ADR-011: Rigid-body flight | The equations of motion, the launch rail, the phases of a flight and when it stops | Rigid-body flight |
| ADR-012: Recovery | Parachute drag areas, when devices open, how they fill, and the descent | Recovery |
| ADR-013: Streamer and tumble drag | Which published data sets give a streamer’s and a tumbling body’s drag | Recovery |
| ADR-014: Separation | How a rocket splits into bodies that each descend on their own | Recovery |
| ADR-015: The validation harness | How comparisons with other programs are run, gated and reported | Accuracy, Checking a claim |
| ADR-016: The documentation site | This site: how it is built, and the checks every page passes | Start here |
| ADR-017: In short, traced numbers and this page | How every model page opens, how Accuracy’s numbers are checked against their sources, and why these records are files rather than pages | Accuracy |
| ADR-018: Examples and quotes | Every example program runs in CI and must print its committed output, and a page’s quote of a file must match it line for line | Getting started |
| ADR-019: Publishing the site | How this site and the API reference are built together, link each other, and are published from main | The API reference |
| ADR-020: The reader test | How the site was tested on a new reader, and why every milestone and lesson label links a row of plain words on this page | Decisions and the roadmap |
| ADR-021: Whole flights against RocketPy | What a whole-flight comparison measures and how, why a sixth rocket was added, and how a case declares a limit of hpr’s as a known gap | Accuracy |
| ADR-022: Validation in CI, and regenerating references only by hand | How every pull request reruns the validation cases on three operating systems, and why the references change only when a person regenerates them and reviews the diff | Checking a claim |
| ADR-023: Predicted mode | How hpr’s own aerodynamics are compared with RocketPy flying each example’s own drag, and why those results are reported against a target rather than gated | Accuracy |
| ADR-024: The time-series RMS | How each whole flight’s height and speed over time are compared with RocketPy’s, on what clock, and why each is held to 3% of its apogee or max speed | Accuracy |
| ADR-025: The calm-air cases | Juno III, Calisto and Bella Lui flown with no wind, and why Juno III’s drifts were at first reported but not scored: the two codes free the rocket from the rail at different points | Accuracy |
| ADR-026: The path in wind | Why HPR Sim turned into the wind less than RocketPy: RocketPy’s equations took the turning moments about the wrong point during the burn (corrected upstream, and in the comparison), and hpr’s body lift, which RocketPy leaves out, pushes a slow rocket downwind | Accuracy |
| ADR-027: The normal force through Mach 1 | How the fins’ normal force and center of pressure carry through Mach 1: Barrowman’s subsonic method to Mach 0.8, supersonic linear theory once it holds, a straight-line join between, and how they compare with a wind tunnel and with RASAero II | Aerodynamics |
| ADR-028: Drag through Mach 1 | How noses, shoulders and steps drag through Mach 1: Niskanen’s method with Stoney’s measured nose curves, and how the drag compares with NASA’s wind tunnel | Aerodynamics |
| ADR-029: Drag against RASAero II through Mach 2 | How hpr’s drag compares with RASAero II’s curves by speed band, why it misses faster than sound, and a second reference with every input known: MIL-HDBK-762’s worked example | Aerodynamics |
| ADR-030: The afterbody faster than sound | A boattail’s supersonic wave drag from MIL-HDBK-762’s chart held to the Prandtl-Meyer limit, separation on steep boattails, the base pressure behind them, and a lip in a boattail’s wake; checked against measured boattails, and why its targets aren’t met | Aerodynamics |
| ADR-031: Roll from canted fins | Roll forcing from canted fins and roll damping by Barrowman’s strip theory with his body factors, the fin’s own slope in the damping, and the comparison with NASA’s measured roll effectiveness and the Basic Finner’s roll damping | Aerodynamics |
| ADR-032: Normal-force overrides | Flying RASAero II’s normal force and center of pressure: how its export is read, the slope at 0°, the angles past its last, and why the damping stays hpr’s | Aerodynamics |
| ADR-033: The body faster than sound | The lift a body’s cylinder carries behind its nose faster than sound, by the second-order shock-expansion method: the report’s tangent body, its limit, and the cone slopes read by hand | Aerodynamics |
| ADR-034: The body’s supersonic normal force in flight | How a flight uses that method: a table of each part’s share every 0.05 in Mach, joined in a straight line from slender-body theory over Mach 1.2 to 1.5 | Aerodynamics |
| ADR-035: Drop the orhelper dependency | The GPL-2.0 wrapper for the OpenRocket jar is removed from the oracle environment, unused; how the OpenRocket oracle milestone drives the jar is decided when it starts | How correctness is proven |
| ADR-036: The Arcas Robin’s supersonic body gap | How hpr’s body faster than sound is compared with NASA’s wind tunnel from now on (as the tunnel measures, at its angles), and why M1.8e6 takes the size of crossflow lift and the boattail’s share together | Aerodynamics |
| ADR-037: Body lift by Jorgensen’s crossflow | Body lift’s size at every speed from Jorgensen’s crossflow drag, how his two η figures are combined, a boattail’s share faster than sound from Washington and Pettis’s measurements, and why blunt tips moved to M1.8e7 | Aerodynamics |
| ADR-038: Blunt tips by a Newtonian cap | How a nose with a blunt or vertical tip (power-series, Haack, elliptical) flies the shock-expansion method faster than sound: NASA TN D-4865’s Newtonian cap and handover, the method started behind it from the tangent cone rather than the report’s own start, and how both were checked | Aerodynamics |
| ADR-039: A lip in a boattail’s wake carries nothing | Why a short flare at the very base, behind a boattail, gets no normal force faster than sound, what the tunnel’s pitching moment says about that, and how far the shelter reaches | Aerodynamics |
| ADR-040: A steep boattail’s correlation, and the 15% target judged | How steep a boattail hpr still reads its measured share for, how footnote 8 and the tube behind it were integrated by hand, and where the Arcas Robin’s body alone still misses its 15% target | Aerodynamics |
| ADR-041: A lip’s shelter weighed, not switched | Why a lip rising out of its boattail’s wake now moves a rocket between the two supersonic body models smoothly, and how big the switches that remain are | Aerodynamics |
| ADR-042: Cone slopes past Fig. 2’s edge, from Sims | Where the slopes for tangent cones of 24° to 30° come from, how they were checked against the chart they extend, and what a cone steeper than 30° still costs | Aerodynamics |
| ADR-043: The blunt tip’s handover cap | What moving a blunt tip’s handover from 24° to the cone tables’ 30° would be worth on the report’s own sphere-cone, what it does to the march on a nose that flattens fast, and why the cap stays where it is | Aerodynamics |
| ADR-044: What the answer follows when it follows the mesh | That it is the surface pressure crossing its tangent cone’s, not the method being reduced, that marks a reading whose answer moves with the element count: how far that goes, and what it re-aims issue #108 at | Aerodynamics |
| ADR-045: Where a flare’s march stops | That what stops the march is the corner’s isentropic turn, not the flare’s shock detaching; that the two limits cross near Mach 1.55, so neither bounds the other; and that above Mach 2.13 neither binds: the cone tables’ 30° does | Aerodynamics |
| ADR-046: Debrief folded in, and analysis that stands on its own | That a universal flight log analyzer becomes part of this project, and that reading a log never needs the simulator: hpr-flightdata may not depend on hpr-sim, a check enforces it, and comparing a flight with a simulation lives in hpr-forensics | Start here What the analyzer is being built from is written up in the log formats, the readings and what may be ported. |
| ADR-047: A flare flies the method where its corner’s shock is attached | That a flared body now flies the shock-expansion method; that the test for the corner’s shock is NACA 1135’s wedge limit read at the flow reaching it, the same one a blunt tip’s cap already uses; that a steeper flare is read as one of the same radii drawn out to that limit, so nothing jumps across the boundary; and what still switches: a band of flares a third of a millimeter tall the march refuses (read through since ADR-050) | Aerodynamics |
| ADR-048: What a marched flare is worth | That TN D-4865 model 2’s readings are committed and compared: an 18.5° flare read −1.9% and +7.0% against the wind tunnel at Mach 1.9 and 2.3, +13.4% at 2.96 and about +51% at 3.95 and 4.63, whose flare the report’s shadowgraphs show separated; with no reading at all below Mach 1.5289, where drawing the flare out to its shock’s limit lands past the march’s own | Aerodynamics |
| ADR-049: What a step in radius costs | That a step’s cost is measured and published rather than modeled: it takes the whole body off the shock-expansion method, worth −8.65% and 1.03 calibers at its threshold and −12.55% and 1.36 calibers at a 2 mm (0.079 in) step down, and −11.34% and 1.10 calibers on a boattailed body, whose threshold is 1.3e−13 m rather than 2.7e−11 m; and that stopping the march at the step instead was built, measured and rejected, because the mixed reading lands outside both pure models and misses the boattail’s band | Aerodynamics |
| ADR-050: A reduced element read by the generalized method | That where the second-order method’s exponential form cannot hold (the pressure behind a corner on the far side of its tangent cone’s from where its own gradient points), the element is read by the generalized method wherever it has a tangent cone of its own, so a near-flat flare no longer takes the whole body off the method; that the region’s two edges are solved from the corner’s own state, not bisected, reproducing all three published angles; and that what is left is the loading’s step at the crossing, +0.129% and 0.0051 calibers on the tests’ rocket but not bounded by it: +4.3% and 0.19 calibers on a body with a short shoulder, and −2.8% between two adjacent Mach rows | Aerodynamics |
ADR-051: M3.1 split, and a .ork document kept whole | That reading an OpenRocket file is split into four increments, the container and the document first; that the document is read into a tree and interpreted by nobody, because with no schema for .ork keeping the whole file is the only way to be sure nothing was dropped; that reading it, writing it and reading it again gives the same document, checked over generated trees and over all 76 corpus files that open; that nesting is counted before the text is parsed, since the XML parser underneath overflows the stack past 120 levels; and that the corpus survey names the two files that are not XML rather than skipping them quietly | OpenRocket .ork design files |
ADR-052: What a .ork value means | That an automatic dimension keeps both its flag and the number OpenRocket last worked out, rather than becoming a hand-typed one; that either name of the two pure renames may be read, because where OpenRocket writes both it agrees with itself on the number and the frame every time (642 and 109 elements), while two more pairs that look the same stay unread, their newer name carrying a frame the older never does; that a stated zero is a value, which an override to no drag at all needs; and that the single flag the three subcomponent-override flags replaced is read as setting all three, out loud (the warning since dropped by ADR-095, which measured OpenRocket’s reading) | .ork design files |
ADR-053: The parts on and inside a .ork body | That .ork angles are degrees, though nothing in the file says so: 178 of its 188 non-zero ones exceed a whole turn; that radialposition and radiusoffset are each read on the parts that carry them, so ADR-052’s open question need not be answered; that a part this reader cannot shape honestly is left out (5 in the corpus); that an inner tube’s automatic outer radius is its parent’s bore, resolved before any ring’s, so sibling order cannot matter; that the five surface-finish words take the roughness heights OpenRocket’s author published, polished possibly moved in a newer OpenRocket; and that a tube of no wall carries no mass (replaced by ADR-061: every part of no wall weighs nothing) | .ork design files |
| ADR-054: An automatic radius with nothing to take | That an automatic body radius with no fixed radius anywhere along its chain takes OpenRocket’s default radius, 25 mm (0.98 in), which OpenRocket’s maintainers call “the default radius” and OpenRocket 24.12 settles on in a committed oracle run, never the number cached after auto, which OpenRocket itself ignores; that hpr departs from OpenRocket only where OpenRocket answers −1 m (−3.3 ft), a radius no shape can have; that hpr is held to OpenRocket’s settled answer rather than its first reading, which settles the Dual parachute example’s odd cache in hpr’s favor (67 of 67 body radii agree over 18 designs); and that a <rocket> holding nothing is a document with no design rather than a design that fails | .ork design files |
ADR-055: M3.1c split, and the motors a .ork flies | That reading a .ork file’s motors, recovery, stored results and pods is split into four increments. That a motor’s thrust curve comes from the file first and hpr’s bundled catalog second, matched on manufacturer and designation both. That none is a plugged motor and 0 a charge at burnout. And that the rocket flies a configuration only when every motor in it has a curve and lights at launch, on a one-stage rocket read without a warning, because hpr lights every motor at launch and flies one body until staging arrives: 2 of the library’s 170 configurations do | .ork design files |
ADR-056: A .ork design’s recovery and separation | That when each parachute and streamer opens, and when each stage separates, is read as the file wrote it and not yet flown. That the words are OpenRocket’s own, measured by a committed probe. That a deploy height is above the ground. And that two choices are left open, in plain view, for the step that flies a .ork: a deploy height the rocket never reaches, which OpenRocket never opens, and an automatic drag coefficient | .ork design files |
ADR-057: A .ork design’s stored simulations | That the simulations OpenRocket last ran on a design are read back as it wrote them: the launch conditions, the summary, and each stage’s time series and events. That their units are measured by a committed probe: the rod’s angle and direction in degrees, a compass bearing; the wind’s direction in radians, where it blows from. And that they are OpenRocket’s answers to compare against, not flights hpr makes | .ork design files |
ADR-058: What a .ork holds that hpr does not model | That the parts and sections of a .ork hpr does not read (pods, parallel stages, OpenRocket’s 3D-view settings, a simulation’s plug-ins) are kept whole beside the design, in an extension called x-openrocket, at a path that leads back to where each was, so that writing the file back can put them back; that a design missing parts this way says it is reduced; and that the same goes for every tag and attribute no reader asks for, recorded as hpr reads | .ork design files |
| ADR-059: The RocketSerializer cross-check | That hpr’s reading of a design’s key geometry (the nose cone, transitions, fin sets, where each sits, and the body radius) is held to RocketSerializer’s, a second program that reads .ork files, with OpenRocket itself run on the same file to settle any difference; that “agrees” means no number of hpr’s is apart from both; that a cause is named only where the record proves it; and that an import error is a file that does not read or a design that does not lay out | .ork design files |
| ADR-060: M2.2 split, and the structure’s mass held to OpenRocket’s | The OpenRocket comparison goes mass first, then OpenRocket’s mass conventions, the motors OpenRocket flies, flights on public designs, and the corpus. Each design’s structure is held to OpenRocket’s within 1% in mass and 1% of length in center of mass, thresholds set before measuring, and every design outside is given its cause. Which of OpenRocket’s inertias is roll is measured on a tube worked out by hand | Mass properties |
ADR-061: What a .ork leaves unsaid, read as OpenRocket reads it | Probe designs measure what OpenRocket makes of a wall or shoulder of no thickness (nothing), a part with no thickness written (a 2 mm (0.079 in) wall) or no material (its default by kind), and which override wins. hpr reads each the same way. Two override rules stay hpr’s own, each pinned by a test: the center under a mass override that covers the parts inside, and inertia under an override | Mass properties |
| ADR-062: Fins and rail buttons against OpenRocket; roll inertia explained | Probes of one tube and one part find the fins behind the roll inertia’s gap: OpenRocket’s shortcut for a fin set, inferred from its output, accounts for the corpus’s 2.1%, and hpr keeps its exact integral. hpr keeps its rounded and airfoil sections and its exact ellipse, each pinned against OpenRocket’s; a .ork rail button now sits where OpenRocket puts it (issue #151). M2.2b2, the fins and rail buttons, split their remaining clusters, fillets and unread parts into M2.2b4 | Mass properties |
| ADR-063: Packed parts read and weighed as OpenRocket packs them | A parachute, streamer, shock cord or mass component whose file writes no packed size is 25 mm (0.98 in) long and 12.5 mm (0.49 in) in radius, as OpenRocket packs it, and a mass override on one that weighs nothing is spread over its packing, not put at a point; both measured on probe designs | Mass properties |
| ADR-064: Clusters, fillets and unread parts remain visible departures | A 3-ring cluster is read as one tube and pinned as a measured departure (superseded for clusters by ADR-075); 5 mm (0.20 in) and 10 mm (0.39 in) fin fillets are omitted and pinned (superseded for fillets by ADR-096); unread parts remain in x-openrocket and mark the design reduced. The 2026-09-23 scratch-excluding corpus rerun gives 58 of 71 within 1% in mass, 59 in center, 50 in pitch inertia and 56 in roll with OpenRocket’s fin rule | Mass properties |
| ADR-065: Stored results are references only when current and structurally plausible | Stored results remain readable, but only current runs with RK4Simulator and BarrowmanCalculator provenance markers and complete finite, internally consistent ascent summaries pass the stored-reference screen; the 2026-09-25 survey found 91 of 174 eligible and 83 excluded (47 inconsistent, 17 external, 11 outdated, 7 not-simulated and 1 missing simulator). Hpr reproduction is separate: 1 of those 91 is reproducible and 90 are not (40 reproducible once ADR-067 supplies OpenRocket’s motor database). | .ork stored simulations |
| ADR-066: Every curve hpr flies is integrated as OpenRocket integrates it | The oracle hands OpenRocket the same bytes hpr reads, so the comparison is of two integrations of one file: hpr’s total impulse, peak thrust, 5% burn-time window and curve duration are all bit for bit OpenRocket 24.12’s on all 32 bundled curves. The one real difference is the average thrust, hpr’s being +0.0107% to +0.3147% higher because its numerator is the whole curve’s impulse where OpenRocket’s is the window’s: a written departure, not held. The reference library’s own curves stay private, counted in M2.2c2. | Solid motors: validation |
| ADR-067: Curves come from OpenRocket’s own database by digest, each held to its impulse | Most designs name a motor’s curve by its digest and do not carry it. An oracle records the motor database OpenRocket 24.12 ships, and cargo xtask ork supplies each solid curve for its digest, never by name. Every curve’s total impulse is within 0.1% of OpenRocket’s, and bit for bit: the 3 the library embeds are two independent readings, and the 1,288 database curves check the hand-off. In all 67 configurations hpr flies with a supplied curve, OpenRocket places each one too. Of the 162 configurations the bundled catalog left without a curve, 66 now fly, 72 are held back for another named reason and 24 still have none. Where each motor’s weight sits still differs from OpenRocket’s. | The .ork format: motors |
| ADR-068: OpenRocket’s flights of the public designs, and what its metric words mean | M2.2d, flights against OpenRocket, splits in two. OpenRocket 24.12 flies the public designs in calm air: 56 complete flights and one aborted run, which is no reference. A record keeps each summary word beside the quantities of its own time series: nine of ten words are defined, among them the deployment speed as the last deployment’s; the optimum delay is not measured and is withheld, as are other versions’ words (L80). A metric whose event is missing is never scored: withheld when neither flight had the event, failed when only one did (L81). | .ork: what the summary words mean |
| ADR-069: hpr’s flights of the public designs against OpenRocket’s | M2.2d2: cargo xtask ork-flights flies the 21 configurations of OpenRocket’s examples that hpr can fly, in OpenRocket’s recorded conditions, and a committed report sets each against OpenRocket’s apogee, largest speed and margin at rod clearance, by ADR-068’s definitions. The margins are within 0.016 calibers. With no named cause, hpr’s apogees are 0.06% to 4.34% low. Each apogee more than 5% off has a named cause: a parachute OpenRocket opened before apogee (hpr flies none from a .ork yet), or a part set to no drag, which hpr ignores (#165). | .ork: hpr’s flights against OpenRocket’s |
| ADR-070: M2.2e split: mass and centre of mass first, then the corpus | M2.2e is cut into four: M2.2e1 adds the spread of hpr’s mass and center of mass against OpenRocket’s to the flight report; then OpenRocket flies the private designs (the corpus), hpr flies them, and each apogee more than 5% off gets a written cause. On the 21 public flights the launch mass is within 0.21% and the center of mass within 0.016 calibers. | .ork: hpr’s flights against OpenRocket’s |
ADR-071: The corpus OpenRocket flies is its .ork files | M2.2e2 flies the private library’s 27 .ork files: 88 of 89 configurations to the end. Its 4 RASAero and 4 RockSim files wait until hpr reads those formats. | .ork: OpenRocket’s flights of the private designs |
| ADR-072: hpr’s flights of the private library, under anonymised ids | M2.2e3 tries the 12 private designs that are not copies of public ones and publishes only differences, under ids like C09/2. hpr flies 17 configurations of 4 of them, so the two reports hold 9 designs, not the 20 that M2.2 (the OpenRocket comparison) asks for. That bar is now M2.2e9 (ADR-094 split the tilted rod off as M2.2e5, which added one design, and ADR-095 the old override flag as M2.2e6, another). The rest can come from the staging and cluster designs (M1.9), the airframe readings (#174, two designs left), or the four public designs held by pods and parallel stages (OpenRocket’s pod examples, unflown for reasons outside the pods though M1.13 is done) or tube fins (#133). | .ork: hpr’s flights of the private designs |
| ADR-073: Each named cause sized by OpenRocket’s own flight without it | M2.2e4 sizes the two causes named for the five apogees more than 5% from OpenRocket’s: OpenRocket flies each flight again with nothing deployed and, where a part is told it has no drag, with that setting cleared (matching what hpr flies, since hpr reads the setting but can’t apply it yet) or the part removed. Four of the five come within 5% of every such flight. The fifth stays 7.80% high like for like (the no-drag part removed from both programs), and what is left on its design has a lead, not an explanation (#177, a very blunt nose’s drag). | .ork: the two named causes, and their size |
| ADR-074: Ignition times and powered staging: the sustainer flies on as a rigid body | M1.9a lets each motor light at its own time (at launch, at a time, after another motor’s burnout, or after its stage’s separation). A separation with the forward part still to burn is powered: that part, the sustainer, flies on with its own shape and mass while the booster falls to its own landing. The sustainer keeps the nose, so its aerodynamics are an ordinary rocket’s; nothing needs a model of a rocket without a nose. Checked by tests, not yet against another simulator. | Staging |
| ADR-075: A cluster is one tube repeated, and a motor in it one motor per tube | M1.9b makes a cluster a list of tube places on one inner tube: the tube and what it holds are repeated in each, and its motor is one motor per tube, so thrust, mass and moments add up as for any motors. A tube can be marked as a motor out. A .ork file’s pattern is read as OpenRocket places it, measured on 25 probes; OpenRocket weighs the tubes stacked on the cluster’s axis, which hpr does not copy. | Clusters |
ADR-076: A .ork file’s ignitions and one powered separation flown against OpenRocket | M1.9c reads each motor’s ignition in a .ork file into hpr’s (at launch, at a time, or after the stage below burns out or fires its charge) and flies one powered separation, a cluster with a motor in every tube, and an air start. The tolerance, set before measuring: every flight of a design within 5% of OpenRocket’s apogee and largest speed. OpenRocket’s two-stage, cluster and air-start examples all are (three cluster apogees against OpenRocket’s flight with no parachute, because its parachute opened before apogee) | Staging |
| ADR-077: Flight metrics: peaks on the dense output, margins only where they mean something | M1.10a finds each peak (speed, Mach number, dynamic pressure, the boost’s acceleration and, apart, the opening shock) between the integrator’s steps rather than in a recorded table. It keeps the static margin and the margin at the flight’s Mach number from the rail exit to apogee, and gives none where the parts’ normal-force slopes nearly cancel, since the margin is then noise. The optimum delay comes from a flight with the charges held, so it doesn’t depend on the delay flown. Anything that didn’t happen is None. Tests pin each against a hand calculation; nothing is checked against a real flight. | Flight metrics |
| ADR-078: Fin flutter by NACA TN 4197, the lower reading wherever the source leaves room | M1.10b gives a fin’s flutter speed and margin by Martin’s 1958 criterion, reproducing both his worked examples at their printed precision. It fixes a flutter dynamic pressure, so the least margin is at max q. Martin’s own line between safe and failed wings, a band measured off his figure 3, puts the flutter speed at 1.8 to 2 times the speed of sound, so a flutter speed just above the flight’s speed is not shown to be safe. Where the source allows two readings (the thickness ratio, a flat fin’s stiffness), hpr takes the lower flutter speed. 14 built-in materials carry a cited shear modulus; G10/FR-4 has none. Nothing is checked against a hobby rocket’s flight. | Fin flutter |
| ADR-079: Exports as text built in the core, heights on each format’s own datum | M1.10c1 writes a recording as CSV or JSON, and the flight path and landings as GeoJSON or KML. Each function returns text and writes no file. Numbers are written so they read back exactly; a value that isn’t finite is refused. GeoJSON heights are above the WGS 84 ellipsoid and KML heights above sea level, as their standards say. GeoJSON is checked against the published schema and KML by parsing. Parquet is split off to M1.10c2. | Exporting a flight |
| ADR-080: Parquet written in-house, read back by Apache’s library | M1.10c2 writes a recording as an Apache Parquet file, behind the parquet cargo feature. hpr-sim writes it from the format’s specification, with no added library, and the tests read it back with Apache’s own Parquet library, every number bit for bit. The file is uncompressed and has no per-page statistics; pyarrow and DuckDB read it once, by hand, not in CI. | Exporting a flight |
ADR-081: ERA5 weather read from netCDF classic in hpr-io; M2.3 split a to c | M2.3a reads the weather over a launch site from an ERA5 file. hpr reads netCDF classic files itself, from Unidata’s specification; the newer netCDF-4 files are converted first with three lines of Python. Values are interpolated between the four grid points around the site as RocketPy does, and between the two hours around the launch, where RocketPy takes the nearer hour. Heights use the World Meteorological Organization’s formula at the site’s latitude, where RocketPy uses ECMWF’s; both are approximations, and the page compares them. Real flights in that weather are M2.3b, and the private designs with flight logs M2.3c. | ERA5 weather files |
| ADR-082: Real flights read from refs, compared over the ascent, with checked explanations | M2.3b flies seven of RocketPy’s documented rockets in the weather of their day, with hpr’s own aerodynamics and each example’s own motor file, and compares each with its team’s altitude log: the apogee, and the climb to it. hpr’s height is read the way the log’s barometric altimeter reads the air, which on a hot day is several per cent below the height climbed. The mean absolute apogee error is reported against a 5% target; each flight outside it carries an explanation that the report checks against its own numbers: a second flight on the team’s own drag, or on the thrust file as recorded. | Accuracy: real flights |
| ADR-083: M2.3c blocked: no private design is the rocket of a logged flight | M2.3c was to fly the private designs that have a flight log. None does: the private logs match no design in the private library, and the only designs there with a logged rocket are copies of RocketPy’s public examples, whose logs are RocketPy’s and were already flown in M2.3b. One design shares a source with some logs, but nothing ties it to any of those flights, and a comparison against a guessed pair would measure nothing. So it waits for a design and its flight’s log to be added to the private data, and work moves on to M2.4. | Accuracy: real flights |
| ADR-084: The accuracy census: the reports’ numbers held to the ones accepted | M2.4 counts the numbers the validation reports hold hpr to, once each, naming for each group what it was compared with, the kind of comparison, how many flights and how fast they flew. The census accepted last is committed, and CI holds each of those numbers to it: one that moves by more than 0.1% of its bar, better or worse, fails until the change is accepted with a written reason. That catches what a regenerated report could otherwise carry in, such as hpr’s own drag getting worse inside a target. | Accuracy: the census |
| ADR-085: Ejected pieces: an airframe that parts at any joint | M1.11a lets the airframe part anywhere: at the joint aft of any body component, as a nose cone pushed off does, or around a payload carried inside. Each piece flies on to its own landing under its own parachute. The pieces are fixed before the flight, so a body’s number never depends on which trigger fires first, and the nose’s body is always body 0. Each parting adds no impulse, so masses and momenta add up. An override that doesn’t say how its mass divides between pieces is refused rather than guessed. The push of an ejection charge, and a tumbling piece, are M1.11b (ADR-086). | Recovery: ejected pieces |
| ADR-086: Ejection impulse and tumbling pieces | M1.11b lets an ejection push its two sides apart with an impulse, equal and opposite, so each changes velocity by the impulse over its own mass and the momentum is unchanged. While the airframe flies whole with nothing open the push is along its axis. A body with no attitude to go by is assumed to point against its velocity through the air when it hangs from an open parachute, and along it when nothing is open. A piece can tumble by the tumble model over its own parts, and that model now integrates a curved nose’s side area rather than taking its end diameters. | Recovery: ejected pieces |
| ADR-087: Mass that moves along the airframe | M1.12a lets ballast or a payload slide along the airframe during the flight, on the triggers a parachute has, along a smooth curve that starts and ends at rest. The rocket’s center of mass and inertia follow it exactly. The equations of motion gain one term, the moving part’s angular momentum relative to the airframe, which is zero for a part on the axis; its rates are exact rather than differenced. A mass released in flight is M1.12b. | Moving mass |
| ADR-088: Mass released in flight | M1.12b lets ballast or a payload go during the flight, on the triggers a parachute has. The rest of the rocket flies on in six degrees of freedom from the same state with its mass, center of mass and inertia stepped to the rest’s; the part leaves with the velocity it had in the airframe, so mass and momentum are kept, and falls to the ground as a point mass under a drag area the user gives. | Released mass |
| ADR-089: A pod is a stack of body components repeated around the axis (superseded for aerodynamics and tumbling by ADR-092) | M1.13a adds pods: a pod set on a body tube holds the pod’s own body components, which stack along the pod, and hpr repeats that one pod, with everything in it, evenly around the axis, each copy turned with its pod as a fin set’s fins are. Each copy is weighed where it sits, with its parallel-axis term, and a motor in a pod is one motor per pod. The aerodynamics and the tumble model refuse pods until a cited method for their normal force and drag is in (M1.13c). | Pods |
ADR-090: .ork pods placed as OpenRocket places them; pods of no length left out | M1.13b1 reads a pod set’s pods and puts them where OpenRocket 24.12 does, measured on probes: a relative offset is from the tube’s surface to the pod’s widest part. A flipped nose cone is read as the tail cone it is. Pods of no length, drawn to hang fins off the axis, were left out with a warning until M1.13b2 read them (ADR-091). | .ork: Pods |
| ADR-091: A pod of no length weighs nothing and holds its parts on its axis | M1.13b2 reads the pods OpenRocket draws to hang winglets or a lug off the axis: a pod whose only part is a tube of no length, no wall and usually no radius. That tube weighs nothing, and fins or a lug on it sit on the pod’s own axis, as OpenRocket 24.12 places them on probes. A pod set that holds nothing is read, and weighs nothing. | .ork: Pods, Pods |
| ADR-092: A pod’s parts are Barrowman’s, once per pod, on the axis | M1.13c1 flies pods: each pod’s nose cones, transitions and tubes get the normal force and drag they would have on the airframe, at the pod’s own fineness, and each pod’s fins are its own, turned with it; every pod adds its share. The forces act on the rocket’s axis, exact for two pods or more to first order, and the roll damping the pods’ offsets give is added. How the pods and the body disturb each other’s flow is left out, with its size stated, and a single pod’s off-axis moments are left to issue #213. | Pods |
| ADR-093: Pod probes flown as the public designs are, and listed apart | M1.13c2 checks pods against OpenRocket on six probe designs, one airframe carrying pods of bodies, fins, tail cones, winglets or motors, or none, flown as the public designs are and listed apart from them. Each is within 5% of OpenRocket’s apogee and largest speed, and what the pods change is held too, since a straight-up flight tests drag more than normal force. The close agreement shows the two codes apply the same rules; it cannot size the interference both leave out. | Pods |
| ADR-094: A tilted launch rod flown as OpenRocket records it | M2.2e5 flies a tilted rod as OpenRocket records it: hpr’s rail takes the same compass bearing and an elevation of 90 degrees minus the tilt. Four public probes check it: the bearing at apogee agrees within 0.03 degrees and the apogee the tilt takes off within 0.27 percentage points. OpenRocket’s rocket clears a tilted rod at a small angle of attack, which on the probes and on the one private design explains most of a margin gap that grows with the tilt. | The .ork format: a tilted launch rod |
| ADR-095: The single pre-1.9 override flag read as OpenRocket reads it | Older .ork files use one flag to say a part’s overrides cover the parts inside it. M2.2e6 reads it as OpenRocket 24.12 does: as all three per-quantity flags, the later tag winning where a file writes both. Eleven probe designs measured it, and a test holds hpr to them. One private design now flies, within 0.26% of OpenRocket’s apogee. The other the flag was blamed for does not: it also has a stage separation HPR Sim can’t fly yet (#184), so that part of the bar is recorded as not met. | The .ork format: the values inside the tags |
| ADR-096: Fin fillets and an automatic radius inside a nose cone read as OpenRocket reads them | M2.2e7 weighs a fin fillet as a prism of its section along the root chord, one each side of every fin. An automatic outer radius inside a hollow nose cone or transition is the bore at the part’s narrower end; an innertube written auto keeps OpenRocket’s 9.5 mm (0.37 in). 21 new probes measure it. On 9 fillet probes, the fillets’ mass and center of mass are OpenRocket’s to 1e-15, the whole probe’s pitch inertia up to 0.64% apart. On 14 bore probes, 13 of which hpr flies, every part inside but one packed mass component (#186) is at OpenRocket’s mass to 1e-14 and station to 1e-15; a coupler at a nose’s tip is refused. | Mass properties: fin fillets, the .ork format: inside a nose cone |
| ADR-097: A cause in the drag sized by hpr flying OpenRocket’s drag | The first supersonic flight in the OpenRocket reports climbs 13.60% higher in hpr. An oracle records OpenRocket’s drag coefficient along its flight, and hpr flies it: +1.11%, so the cause is the drag. OpenRocket keeps the whole base’s drag under power, measured on its own examples, which hpr can now fly for comparisons; hpr’s supersonic pressure drag is about twice OpenRocket’s. Which of each is right is open (#222: supersonic pressure drag and base drag under power) | The .ork format: a supersonic flight, Aerodynamics: drag |
| ADR-098: A tube fin set’s automatic radius read as OpenRocket reads it | M2.2e8 reads the automatic radius of a .ork tube fin set. For three tubes or more, the radius is the one at which each tube touches the body and its neighbors; for one or two, it is the body’s radius. OpenRocket 24.12 gives the same radius, within 1e-15, on 19 probe designs. More than 8 tubes are read as 8, as in OpenRocket. Both inertias are departures, kept on purpose: OpenRocket’s roll inertia exceeds what any mass in the ring could give, and its pitch inertia leaves out the tubes’ distance from the axis; hpr keeps its own. Tube fins are weighed but not yet flown: M2.2e9 adds their aerodynamics. | |
| ADR-099: Tube fins flown as ring wings | M2.2e9 flies each tube of a tube fin as a ring wing: Weissinger’s slope (within 3% of NACA’s five rings), Fletcher’s measured aerodynamic center joined to the leading edge by hpr’s slender-body derivation (his longest ring, A = 1/3, left out by judgment), and friction inside and out with a square edge’s drag on the wall, below Mach 0.8 and for three tubes or more. The tube fin example’s apogee is 6.95% above OpenRocket’s, within 0.03% on OpenRocket’s own drag, so the gap is hpr’s drag, probably low because OpenRocket’s was refined on measured flights (#228). Its margin is 1.08 calibers below OpenRocket’s; ADR-102 keeps a first look: OpenRocket’s slope at 1.62 times the long-ring limit (1.65 times hpr’s) | |
| ADR-100: A motor whose ignition never comes flown unlit | M2.2e10 flies a .ork motor set never, or lit at an event that never comes (burnout or ejectioncharge in the bottom stage, or a plugged motor’s charge), unlit and loaded, as OpenRocket does on five probes of its two-stage example; a separation at such a motor’s burnout or charge never comes. One more private design flies, 0.88% above OpenRocket in apogee, which makes the 20 designs M2.2 asks for. It corrects ADR-076’s reading of one private record | |
| ADR-101: OpenRocket’s mass conventions rolled up | M2.2b closes: each mass convention OpenRocket was found to follow is hpr’s rule or a departure pinned by a test. The corpus survey, run again on 71 files (51 distinct by content), has mass and center of mass within 1% on 68, pitch inertia on 56 and roll inertia on 57 with OpenRocket’s fin shortcut; each file outside in mass, center or roll has a named cause (mass page). The comparison as a whole stays open for two Loft lessons, L19 and L82, moved to M2.2f | |
| ADR-102: Tube fins’ centre of pressure measured against OpenRocket | M2.2f records OpenRocket 24.12’s answers for tube fins: 14 probe designs and its Tube fin rocket, at five Mach numbers. Its tubes lift 1.26 to 1.86 times what hpr’s ring wings do, the same per tube at any count, and act a quarter of their length aft of the leading edge up to Mach 0.5. No measurement supports either, so hpr keeps its model; slender-body theory adds a body interference that hpr leaves out and OpenRocket does not vary with the count (#234). L19’s quarter-caliber bar is not met: up to Mach 0.5 hpr’s center of pressure is 0.42 to 3.0 calibers forward of OpenRocket’s, 1.07 on the Tube fin rocket, with each gap pinned by a test (tube fins) | |
| ADR-103: The builder API wraps the crates’ own types, with no default materials | M4.1 is split: the builder first (M4.1a), then models of your own and a guide in the API reference (M4.1b). The builder’s Environment, Motor, Rocket and Flight make the crates’ own design tree and simulation and hand them over, so no physics is written twice. Every part names its material and wall, since a default would be a guess at the rocket’s mass. Degenerate numbers are refused where they are given, each by name (L95; The builder) | |
| ADR-104: A drag model replaces the zero-lift drag only, as a drag table does | M4.1b closes M4.1: a drag model of your own, a Rust trait, gives the rocket’s zero-lift drag coefficient at each flow, with hpr’s own drag at hand to adjust. The flight scales it for the angle of attack as it scales a table’s; the normal force, center of pressure and damping stay hpr’s. A model and a table replace each other, and a powered separation refuses either. A model handing back hpr’s drag flies the same flight bit for bit. Three examples join the builder’s, and hpr::guide is the guide in the API reference (Models of your own) | |
| ADR-105: The command line’s surface: every command registered, JSON by schema, a generated table | M4.2 is split in four: the command surface and hpr motors first (M4.2a), then flying a design (M4.2b), the validation cases and file conversion (M4.2c), and reading a flight log (M4.2d). Every command is registered from the start, and one not yet available refuses with exit status 3 and the milestone that brings it. With --json a command prints one JSON document, even when it fails, and each document has a published schema. The README’s command table is written from the tool’s own list of commands, so it can’t claim one that doesn’t exist (The command line) | |
ADR-106: hpr sim flies the library’s flight, the stack whole, from a stated launch | M4.2b: hpr sim flies a .ork or a rocket’s JSON with the library’s own code, so its numbers are a program’s to the last bit. Without options it launches at 0° N, 0° E, sea level, from a vertical 1.5 m (4.9 ft) rail in calm air, and prints what it used. It flies no parachute or separation yet, and says so in its notes; a rocket whose stages come apart under power is refused (The command line) | |
ADR-107: hpr validate shares the project’s own validation check; hpr convert translates .eng and .rse by the format notes | M4.2c: hpr validate re-runs the RocketPy validation cases and makes the check the project’s automated tests make, with the same code, so the two fail together; it needs a copy of the repository (since replaced by cargo xtask validate --check, ADR-187). hpr convert writes a motor as .eng or .rse: the thrust curve, size and masses come back bit for bit, what .rse adds is filled the way ThrustCurve.org’s .rse files are, and what .eng can’t hold is dropped with a warning (The command line) | |
ADR-108: A flight log read alone: PerfectFlite’s .pf2 first, heights after a running median, an invented log in CI | M4.2d: hpr analyze reads a PerfectFlite altimeter’s log, with no design file, and prints liftoff, apogee, the top speed and landing, each saying where it came from or why the log can’t support it. Heights come from the altitude after a running median, not the Hampel filter Debrief used, because on a real log the Hampel filter kept an ejection charge’s pressure pulse as the apogee. The tests read an invented log whose every reading is known; the one public real log, whose terms are unclear, is read only where it has been fetched (Flight-log readings) | |
ADR-109: M3.2 split, and a .ork written from the design | M3.2 is split: the writer first (M3.2a), then OpenRocket loading and flying what it writes (M3.2b). hpr writes a .ork from its own design, each value as the reader reads it, and puts back everything it keeps but doesn’t model where it was. A value the reader drops, such as a rail button’s screw height, is kept and written back, so OpenRocket still reads it. Each number is written as the shortest decimal that reads back to the same bits. Ids that aren’t UUIDs are left out, since OpenRocket refuses a file holding one (Writing a .ork) | |
| ADR-110: M3.2b: OpenRocket flies the export; only counts are published | OpenRocket 24.12 tries to fly each of the 75 .ork files hpr’s checks use twice, as written and as hpr writes it back out, and only counts are committed. Every design it opens as written must open as exported, a design it refuses must be refused for the same reason, and every configuration flown both ways must reach the original’s apogee within 0.5% (Checked in OpenRocket) | |
| ADR-111: M3.3: the hpr design format, its extensions, versions and crate | M3.3 is split: the JSON document first (M3.3a), then the zip container, migrations and the comparison (M3.3b), then generated types (M3.3c). A design is a .hpr file, the container a .hprz. A document names its format and a major.minor version, checked first; a key its version doesn’t define is refused, not dropped. The document holds the design as the .ork reader models it, with the source file’s other files, so hpr-format builds on hpr-io (The hpr design format) | |
ADR-112: M3.3b: the .hprz container and migrations | Version 0.2 renames the source file’s other files source_files, so “attachment” means a file in a .hprz, and records why a .ork’s airframe wasn’t read as written, which the .ork written from a document can’t say. A change that stops old documents reading takes a new version and a migration, tested on a committed older document. A .hprz is a zip whose first entry is the .hpr; attachment names are relative paths, refused otherwise. hpr convert and hpr sim take all three design formats (The hpr design format) | |
| ADR-113: M3.3c: TypeScript and Python types | xtask generates the types and a reader for each language from the schema, not a third-party generator. A reader checks a document against the schema embedded in its file, and tests hold both readers to a separate schema checker on 4,892 altered documents. Not on npm or PyPI (TypeScript and Python) | |
| ADR-114: M4.3: the Python package | M4.3, the Python bindings, is split in three: the package, RocketPy’s example flown from Python, and models written in Python. The package wraps the Rust builder and adds no physics; it keeps RocketPy’s shape (a flight flies when it is made, its recording comes back as arrays) but the Rust API’s unit-named arguments. One wheel per operating system serves CPython 3.10 on; nothing is published to PyPI | Python |
| ADR-115: M4.3b: a drag table, and Calisto from Python | The flight builder takes another program’s drag table, and the Python package gains it with RocketPy’s gravity formula and a parachute cut away when another opens. RocketPy’s ways of measuring a flight (from the dry center of mass, its rail exit at the forward button) stay in the Calisto example rather than the library; a test holds the example to 3% of RocketPy and to the validation suite’s own numbers | Python |
| ADR-116: M4.3c: drag and wind as Python functions | A flight takes a drag, and an environment a wind, written as Python functions. hpr calls them as it flies; an exception one raises stops the flight and reaches the caller unchanged, not as hpr’s own error. A constant drag function flies exactly as a table of the same number | Python |
| ADR-117: M5.1 split; the cache and offline mode | The online layer ships in two parts: first the cache and the offline rule over a transport you plug in, then HTTP. Offline never calls the transport; online, a copy younger than the source’s time to live is served without fetching, and a failed fetch falls back to an old copy marked stale | Online data and the cache |
| ADR-118: M5.1b, HTTP over the cache | The HTTP client is ureq with rustls, behind a cargo feature, so no OpenSSL. Its size limit counts the unpacked answer, since a small compressed one can unpack to gigabytes. The platform’s cache folder is found by hand, because the usual crate for it pulls in a weak-copyleft (MPL-2.0) dependency | Online data and the cache |
| ADR-119: M5.2 split; Open-Meteo’s pressure levels as a sounding | The weather milestone ships in four parts: Open-Meteo first, then weather-balloon soundings, then NOAA’s model files, then files you download and the hpr weather command. Open-Meteo’s answer becomes a sounding whose lowest level is the ground, with the 10 m (33 ft) wind as the wind on the rail. Levels the models report below the ground are left out, and the heights are read as geopotential, which a check on the recorded answers bears out | Launch-day weather |
| ADR-120: University of Wyoming soundings | A weather balloon’s sounding from the University of Wyoming’s archive is read from its comma-separated text, whose column names carry the units. Rows are kept from the longest chain from the ground in which each row fits the thickness the hypsometric equation gives the layer from the row before it; of each run of rows with the same rounded pressure the middle one is kept; a row kept must lie above the last one kept. The first row is the ground; the answer is refused when a chain without the ground beats every chain with it. A saved copy is fetched again once the sounding has settled. Only soundings from U.S. stations, U.S. government works, are committed as test data | Weather-balloon soundings |
| ADR-121: GFS and RAP from NOMADS’ grib filter, read by an in-house GRIB2 decoder | NOAA’s GFS and RAP forecasts are fetched as a small GRIB2 cut from NOMADS’ grib filter, 0.3° each way around the site, and blended bilinearly between the four grid points around it. The ground and the levels above it follow ADR-119 (the Open-Meteo sounding), and RAP’s winds, given along its map’s grid, are turned to east and north at the site. hpr reads GRIB2 with its own decoder (latitude/longitude and Lambert grids, simple packing) rather than the grib crate, which gives single-precision values and binds C libraries; every value matches ecCodes’ to one rounding. Whole NCEP files, with complex packing or JPEG 2000, are refused and left for files you download | NOAA forecasts: GFS and RAP |
ADR-122: hpr weather, and M5.2d split | The command line fetches a launch day’s weather from any of the sources, one subcommand each, through the same cache as the library. --offline answers from the cache alone, and --from reads an answer saved earlier, held to the same checks as a fetched one. The profile is written as the library’s own sounding type, which reads it back with its checks. NOAA’s whole files, with their other compressions, follow in two more steps | The command line |
| ADR-123: Complex packing, and a whole GFS file | hpr’s GRIB2 decoder reads the tighter packing of NOAA’s whole GFS files, and totals over a time span (such as accumulated rain; read, not used in a profile). Every value of one whole file was checked against ecCodes by a script, run once outside CI; CI checks eight of its messages and a recorded cut ecCodes packed the same way. A whole file’s profile is its NOMADS cut’s to 1.04e-7, with the levels above 10 hPa as well | A whole GFS file |
ADR-124: JPEG 2000 packing, through hayro-jpeg2000 | hpr’s GRIB2 decoder reads fields stored as JPEG 2000 images, as NOAA’s whole RAP files are, using a JPEG 2000 decoder written in Rust rather than one of its own. Only lossless images of up to 21 bits a value, coded as NCEP codes them, are read, which its 32-bit floats keep exact; the rest are refused by name. CI checks four public RAP fields against ecCodes | Files in JPEG 2000 |
ADR-125: Site data split, and WMM2025 in hpr-core | M5.3 split a to c; WMM2025 in hpr_core::magnetic, finite at the poles, refused outside 2025 to 2030 and −1 to 850 km (−0.62 to 528 mi); NOAA’s 112 test values, NCEI’s file’s X to its measured 7.18e-4 nT residue, shown to lie in the file’s X′ | |
| ADR-126: M5.3b, Open-Meteo’s elevation through the cache | M5.3b: Open-Meteo’s elevation in hpr_net::elevation, up to 100 places a request, coordinates to 5 decimals in the URL, a year’s TTL, heights refused outside −1,000 to 9,000 m (−3,281 to 29,528 ft), a surface model above the EGM2008 geoid with N left to the caller; no command yet | |
| ADR-127: M5.3c1, geodesics through GeographicLib, held to Karney’s test set | M5.3c split c1, c2; geodesics in hpr_core::geodesic through geographiclib-rs, flattening past 1/150 refused; Karney’s 500,000-line test set within his 15 nm on five measures, either azimuth pair on its 21 mirror lines | |
| ADR-128: M5.3c2, a site’s height from a user’s GeoTIFF, held to rasterio’s reading | M5.3c2: a user’s GeoTIFF in hpr_io::geotiff over the tiff crate; geographic CRSs within a few meters of WGS 84 only, projections and far datums refused; the containing pixel placed as GDAL places it; GDAL’s scale and offset, units the file states, else meters; held to rasterio 1.5.2 on seven fixtures and a whole USGS tile | |
| ADR-129: M5.4 split, and M5.4a, the motor finder’s API through the cache | M5.4 split a to c; M5.4a: motor.fusionspace.co’s five files in hpr_net::motor_finder through the cache, an hour’s TTL, its structural rules refused and its derived ones pinned on the recording; eight answers of one build committed as fixtures; the credit with the site’s caution on every answer | |
| ADR-130: M5.4b, ThrustCurve searches and curves through the cache, and the in-stock join | M5.4b: ThrustCurve.org’s search and download in hpr_net::thrustcurve through the cache, a day’s TTL; the join by exact maker and designation, misses reported not guessed; three makers’ searches and two public-domain files committed as fixtures; the join’s report in validation/reports/thrustcurve-join.md | |
ADR-131: M5.4c, hpr motors search, stock and prices at the command line | M5.4c: hpr motors search, the finder’s list from the network, the cache or a saved file; five filters, --max-price in exact cents on the cheapest in-stock offer; cheapest first; both credits on every list; the example tested on an edited copy, as the recording lists nothing at $150 | |
ADR-132: M5.5a, OpenRocket’s .orc parts catalogues, held to OpenRocket’s reading | M5.5 split a and b; M5.5a: hpr_io::orc reads OpenRocket’s .orc parts catalogs; the 16 files OpenRocket 24.12 ships bundled unchanged (Apache-2.0); held part by part to OpenRocket’s preset loader, run as an oracle; exact unit definitions, the file’s makers’ names and densities kept, a stated mass kept beside them; unreadable parts left out with a warning, not the file | |
| ADR-133: M5.5b, catalogue parts in the builder, weighed as OpenRocket builds them | M5.5b: catalog parts in the builder (from_catalog on Nose, Tube, Transition, MotorTube, and the new Fitting); what the file leaves unsaid as OpenRocket 24.12 builds it, but a hollow part’s shoulder takes its wall; a stated mass scales the part’s density; a part with an undefined material refused; every part held to OpenRocket’s built mass and center, the two codes’ hollow walls each checked | |
| ADR-134: Monte Carlo dispersion: independent normals, one stream per sample and input | M6.1a: Monte Carlo dispersion in hpr_analysis::montecarlo; each input an independent normal about its nominal value; one random stream per sample, input and copy, keyed by SeededRng::for_stream; impulse dispersed with the propellant mass; a drag scale in the aero model; failed samples kept; M6.1 split a to d | |
| ADR-135: Landing ellipses: the normal ellipse, the next flight’s, and a count of what each holds | M6.1b: landing ellipses in hpr_analysis::ellipse; the normal ellipse of the sample’s mean and covariance, scaled by k² = −2 ln(1 − p); a prediction ellipse for the next flight by Hotelling’s T²; the landings each ellipse really holds counted, failures as bounds; tested against normal spreads with known answers | |
| ADR-136: Sensitivity analysis: Morris paths and Saltelli’s Sobol’ estimates, with their standard errors | M6.1c: sensitivity analysis in hpr_analysis::sensitivity; uniform independent factors; Morris’s paths with μ, μ*, σ and μ*’s standard error, and the exact grid moments by Morris::population; Saltelli 2010’s first-order and Jansen’s total estimates on pseudo-random rows, with delta-method standard errors; held to Ishigami and Sobol’s g in closed form and calibrated over seeds | |
| ADR-137: Ten thousand flights: a run’s flights share the nominal’s layout and supersonic table | M6.1d: a Monte Carlo run’s flights share the nominal design’s supersonic table (AeroModel::share_supersonic_table, when the covered segments and reference area are equal) and its layout (Rocket::lay_out, LaidOut::relay, Simulation::from_laid_out); evaluations borrowed, not copied; 10,000 flights timed on Valetudo (the flight benchmarks’ Level 2 rocket) and on a supersonic K940 rocket, by a bench target; per-evaluation speed-ups left to #285 | |
| ADR-138: Optimization: CMA-ES first, held to test functions and to pycma | M6.2 split a to e; M6.2a: CMA-ES (Hansen’s tutorial, Table 1, positive weights only) over continuous variables, worked in each variable divided by its step, with optional bounds by resampling, ask-and-tell (Run::tell), Jacobi eigen-decomposition each generation; held to four test functions’ minima, to pycma 4.5.0’s evaluation counts (medians within 25%) and to a dense recomputation of every generation; the 3,048 m (10,000 ft) problem re-flown from a fresh build and at 100× tighter tolerances | |
| ADR-139: Optimization constraints by Deb’s feasibility rules | M6.2b split b1, b2; M6.2b1: constraints for CMA-ES by Deb’s (2000) feasibility rules (Evaluation, Run::tell_constrained), no penalty weight; infeasible candidates ranked, not redrawn; a target and TolFun count only feasible points; held to the sphere with x₀ ≥ 1, the tangent problem and CEC 2006 g06 from 20 seeds | |
| ADR-140: Discrete choices by CMA-ES with margin | M6.2b2: integer variables (Variable::integer) by CMA-ES with margin (Hamano et al., GECCO 2022), α = 1/(nλ); Φ by libm::erfc, Φ⁻¹ by AS 241; held to SphereInt, EllipsoidInt and SphereOneMax at 10 and 20 variables and to cmaes 0.13.1’s CMAwM; the rocket example hits 3,048 m (10,000 ft) with the motor and nose free, its body length fixed so designs share a supersonic table | |
| ADR-141: Several goals by NSGA-II | M6.2c: several goals by NSGA-II (Deb et al. 2002) with bounded SBX and polynomial mutation, constrained domination; held to ZDT1 to ZDT3’s exact fronts and to pymoo 0.6.2 (every run’s GD and IGD within twice pymoo’s worst, medians within a factor of 1.25 either way), tournaments paired as pymoo pairs them; a rocket’s apogee against static margin, its front flown again and matched by CMA-ES at 2.5 calibers | |
| ADR-142: Few evaluations by EGO | M6.2d: EGO (Jones, Schonlau and Welch 1998) with a kriging surrogate fitted by likelihood and the expected improvement searched by CMA-ES; M6.2d split d1 (Branin, Hartmann 3: within 1% of the minimum in 50 evaluations from 20 seeds, worst 0.12%) and d2 (Hartmann 6, which d1’s version leaves at a local minimum in 7 runs of 10) | |
| ADR-143: The operating envelope and a stop rule for accuracy work | Bands are by Mach alone. Accuracy work goes to the core band first, Mach 0 to 2.5, where nearly all commercial-motor flights are; Mach 2.5 to 3.5 is the extended band, flown with less accuracy checking. The envelope is Mach 0 to 3.5 at any angle of attack. Angle is a separate condition: accuracy work assumes 15° or less. Faster flights still fly; M1.14a will flag those at high angle of attack, outside the core band or beyond the envelope. An accuracy step counts as progress when it shrinks a measured error against an independent reference, or adds a reference that will; two in a row that do neither end the milestone, gaps written down. | Validation plan: the operating envelope |
| ADR-144: The 2026-10-03 planning review: leaner bookkeeping, issues, writing, guardrails and licensing records | The 2026-10-03 planning review: M0.5 leaner bookkeeping first, then M6.2d2 (one attempt), M4.5, M1.14, M6.2e, M6.3 on; M4.5 and M8.3 CAD interop added; issue labels and P-critical first; a writing standard; guardrails; licensing records | |
| ADR-145: Recorded answers and their licences: stand-in ThrustCurve searches, CC BY 4.0 for the motor finder | Recorded answers and their licenses: ThrustCurve.org’s three searches replaced by stand-ins (five invented motors per maker, and the in-stock motors’ records carrying the motor finder’s CC BY 4.0 values); motor.fusionspace.co’s answers under CC BY 4.0, credited “Motor stock data from motor.fusionspace.co” | |
| ADR-146: Leaner bookkeeping split, and one file per decision record | M0.5 in nine increments, one per item of its plan; each decision record in its own file, with this site’s links and the generated index pointing at it, and every older link still landing on the record’s row | Decisions and the roadmap |
| ADR-147: M0.5b and M0.5d, a roadmap of open work, an archive and tables kept by the tool, and a queue the check follows | The roadmap now holds only open work, in an order set by a queue at its top that the checks follow; done milestones move unchanged to an archive file, and the site’s tables of records follow, by a command rather than by hand | |
| ADR-148: M0.5c, short planning files with size checks | Planning files kept short, with size checks. | |
| ADR-149: M0.5e to g, reviews while CI runs, a faster gate and a split CI | Reviews start once the PR is open and CI runs, with a shared bar for blocking findings and scoped re-reviews; the gate runs tests in parallel and adds the private-data checks when physics changes; CI’s slowest job is split. Amended 2026-11-03: a pull request’s CI within 20 minutes and a passing full gate within 30; the flight censuses (the synthetic flights, two logs and the fit’s intervals) run whole each night on main, a failure filing a P-critical issue, and a change to research notes alone skips the jobs that read none. Amended 2026-11-04: pull requests and the gate fly every 21st flight of the synthetic flights and two logs, held line for line to a committed slice. | |
| ADR-150: Peak thrust and the burn-time crossings come from delivered samples | A thrust-curve sample strictly inside a run of three or more equal times is never delivered, so it no longer sets the peak thrust or a 5%-of-peak burn-time crossing; no surveyed ThrustCurve.org file changes | |
| ADR-151: hpr-sim-fixtures joins the reference library as private data | Neer’s collection of designs paired with the logs of the same flights is pinned in the reference library and kept private under refs/; only aggregate statistics are published; it stays out of the default .ork survey until an increment brings it in | |
| ADR-152: Hartmann 6 by EGO’s log transform | M6.2d2: EGO fits its surrogate to −ln(−y) (or ln y) of the values when the caller asks, as Jones, Schonlau and Welch did on Hartmann 6; all 20 runs (seeds 1 to 20) end within 1% of the minimum in 250 evaluations, worst 0.29%, against 6 of 20 without; the 20-run check is a release-build program the local gate runs, as it takes hours in CI’s debug build | |
ADR-153: A .ork’s recovery flown as OpenRocket flies it, held to its descents | M4.5a: a .ork configuration’s parachutes and streamers become flight devices: the stated drag coefficient, or OpenRocket’s own (0.8 on the canopy for a parachute, appendix C for a streamer), opening at once; apogee, altitude, ejection and launch triggers with the file’s delay. Targets, set before any hpr descent was measured: each deployment within 0.1 s or 2% of OpenRocket’s time, landing speed and flight time within 5% | |
| ADR-154: Motors fetched from ThrustCurve.org by name, cached, and named when offline | M4.5b: hpr sim fetches a motor the bundled catalog lacks from ThrustCurve.org, by name for --motor and by manufacturer and designation for a .ork motor with no curve, through hpr_net’s cache; hpr motors fetch pre-loads; offline and uncached, the refusal names the exact command. One rule picks the file; nothing is bundled | |
| ADR-155: Design checks that match reality: a part through the skin, a case that can’t fit | M4.5c: an internal part wider than its parent’s bore but inside the airframe warns; one that reaches past the airframe’s outside by more than 0.005 in is an error. A nominal motor size wider than its mount’s bore warns while AeroTech’s drawn case fits it, and is an error past that. OpenRocket’s examples raise no design error; the private library’s errors fall from 13 flights to 5 | |
ADR-156: hpr sim reads by name: configurations by their motors, a lead summary | M4.5d: hpr sim’s text names configurations, mounts and the design checks’ parts by name, never by UUID; an unnamed configuration is called by its motors and delays in brackets, such as [C6-5]; --config takes a configuration’s number, name or id, and --mount a mount’s name or id; the checks print as sentences; the summary leads with margin, apogee, rail exit speed, delay and descent. --json keeps the ids | |
ADR-157: hpr sim --plot draws one fixed SVG figure | M4.5e: hpr sim --plot FILE.svg writes one SVG: altitude, speed and acceleration against time in three panels over one time axis, each instant with events a numbered marker listed underneath, and the fall on the airframe alone shaded “not a prediction”. It is drawn by hand in hpr-cli, with no plotting dependency, from its own sampling of the flight, which adds every step’s start and end to the recorder’s times so a parachute’s opening is drawn at full height | |
ADR-158: Three how-to guides run like the command-line guide, on a rocket of their own, with --delay for --motor | M4.5f: the guides “Fly your .ork”, “Pick a motor” and “Check stability for a certification flight”, and the README’s “Install and first flight”, show hpr’s output made by running each command, as docs/cli.md does, so CI fails when one goes stale. They fly a hand-written public design, validation/fixtures/ork/guides/level-1.ork, whose two motors are in hpr’s catalog, so they run offline. hpr sim --delay sets --motor’s ejection delay. Guidance numbers are quoted from their sources, dated, never stated as hpr’s | |
ADR-159: A .ork’s powered separation flown in hpr sim, each part under its own devices, a part with none tumbling | M4.5g1: hpr sim flies a .ork configuration whose booster drops away under power. hpr::ork::separated_recovery puts each parachute and streamer on the part its stage is in, and adds the tumbles the flight needs: the booster tumbles from the split until its first own device opens and releases the tumble, and a sustainer with no device tumbles from its apogee. FlightBuilder::separation takes the separation, so the command flies the library’s flight, bit for bit. Each part’s landing is printed. The sustainer’s descent is held to OpenRocket’s with ADR-153’s targets; the booster’s is not validated | |
| ADR-160: Several powered separations, each handing the flight on to a sustainer cut at its boundary | M4.5g2: the flight takes a list of separations, each at a stage boundary further forward than the one before (Simulation::with_separations). With more than one, each must leave the nose’s body a motor to burn: at each, the stages behind drop away and the flight flies on as a sustainer cut from the whole design at that boundary. OpenRocket’s Three stage low power rocket flies in hpr sim and in cargo xtask ork-flights. On OpenRocket’s own curves its three configurations are within 1.48% of OpenRocket’s apogee and 1.64% of its largest speed, both separations at OpenRocket’s times; in hpr sim, on the curves it fetches (ADR-161, OpenRocket’s curves by digest), within 2.48% and 1.67% | |
ADR-161: A .ork motor fetched from ThrustCurve takes the file holding OpenRocket’s curve for its digest | amends ADR-154 §2 and §4: a fetch may name a ThrustCurve data file to take ahead of the rank’s order (Wanted::prefer, hpr motors fetch --file). hpr sim names one for a .ork motor whose digest a committed table holds: the file whose curve is the one OpenRocket flies. cargo xtask ork-curves writes the table for the motors of OpenRocket’s examples by comparing curves; it holds ids alone. With it, OpenRocket’s three-stage example’s first configuration reads +0.31% of OpenRocket’s largest speed in hpr sim, not +5.7%, and every configuration is within 2.48% of OpenRocket’s apogee | |
| ADR-162: The suite and its releases: what ships when, and the order of the new product lines | Neer’s 2026-10-04 ideas: hpr-sim becomes a suite of six products built in one workspace and joined by shared formats (simulator, flight analyzer, app, motor designer, recovery designer, avionics). Releases come at product boundaries: 0.1 the simulator once M4.5 and M1.14a are met, 0.2 accuracy, 0.3 the flight analyzer, 0.4 competitions, 1.0 the first app. The UI phase no longer waits for every library phase. COTS solids stay the only scope until 1.0. After it, the new lines come one at a time: experimental solid motors, then custom parachutes, then avionics, then hybrids and liquids. Each line gets its own guardrails | |
| ADR-163: The second pass: six products, the analyzer before the accuracy campaign, and what each release must hold | Amends ADR-162 §1 to §4 after a whole-project review (95 open issues). Six products, defined by who uses them; the competition kit is one, and avionics starts as a test bench for any flight computer. Release 0.1 adds Monte Carlo from the CLI and Python, an apogee check on logged flights, and named issue fixes. 0.2 becomes the flight analyzer, ahead of the accuracy campaign; 0.3 is accuracy and fault diagnosis; 0.4 the competition kit, with RASAero and RocketPy files and ejection-charge sizing; 0.5 an app preview centered on the 3D ghost replay; 1.0 the app with the editor. After 1.0: the motor designer, the recovery designer, pad day on a phone, then avionics | |
ADR-164: hpr-sim follows the FusionSpace product system, as FS · SW · TOOL 005 | hpr-sim adopts the FusionSpace product system (nrdptel/fusionspace-design, product/, Rev A, pinned at 32770a4) for its command line, documentation site, plots, exports, writing and every later app and device. It takes the designation FS · SW · TOOL 005. Apache-2.0 files from the system are copied in with their license lines; brand files only as README banners, outside the repository’s license. Milestone M0.6 makes the existing surfaces comply, after M4.5 and before release 0.1; later milestones and every release checklist take the system’s rules and checklists. The CLI keeps SI first with US units in brackets, and carries no brand banner | |
ADR-165: A .ork’s separation with nothing left to burn flies in hpr sim when each part has drag from the split | M4.5g3: a .ork configuration whose only separation comes with nothing ahead of it left to burn is read and flown. From the split every part flies as a point with only its own devices’ drag, ADR-014’s model unchanged, so hpr::ork::tumbling flies it only when the part that keeps the nose has a device of its own open by the split, and refuses it otherwise. lowerstageseparation opens a device on the split’s own trigger. OpenRocket’s Deployable payload and ARC payload rocket fly: the payload’s apogee within 1.05% of OpenRocket’s record and every descent within ADR-153’s targets. The coast with no drag that the rule refuses would put one payload 4.00% above OpenRocket’s own free flight of it | |
| ADR-166: A fin set on a nose cone or a transition, its root along the surface | M4.5g4: a freeform fin outline’s last point may stand above its first, and the planform gains root_m, the root’s points between its trailing and leading edges. A fin set may sit on a nose cone or transition: the tree checks that each of its root’s points lies within a micron of the surface and that it has no tab or fillet. The .ork reader draws the root through 63 points on the parent’s profile. OpenRocket’s Pods--airframes and winglets flies all five configurations, each apogee within 0.5% of OpenRocket’s record; its cockpit’s area, mass and center of mass match on OpenRocket’s own root points | |
| ADR-167: A part’s drag override, as OpenRocket flies it | M4.5h: a .ork part’s or stage’s stated drag coefficient flies in hpr as OpenRocket 24.12 flies it, measured on 25 probes; a step down belongs to the part ahead of it; Base drag hack (short-wide) within 2.1% on a C11-5, but 13% and 11% high on a D12-3 and an E12-4 for its nose (#177), not the setting: not met for those two, recorded. | |
| ADR-168: Pods--powered flies, and the margin is the weakest plane’s | M4.5i: a rail button’s screw head weighed as half an ellipsoid; the thrusting motors’ area told apart per pod set; a device at the charge of a stage where no motor lights never opens, as in OpenRocket; the margin reported in the rocket’s weakest plane (#329); OpenRocket’s Pods--powered with recovery deployment flies its three complete configurations, two within 1.9% of OpenRocket’s apogee, the third turning over before apogee in both tools | |
| ADR-169: A ring around its tube needs room in the part around it | M4.5k: a centering ring on its tube’s axis whose bore takes the tube’s outside wraps the tube, and is measured in the part around it at its own station that holds it whole; amends how two earlier decisions read the pods examples’ rings, which now fly as saved | |
| ADR-170: A packed part wider than its bore warns | M4.5l: a packed part (a mass component, parachute, streamer or shock cord) drawn wider than the room in its parent warns, by any amount, while its center is in that room, and flies as drawn; its width sets only its own inertia. A ring, tube or packed part centered past the room stays an error. OpenRocket’s Deployable payload flies its five configurations as saved | |
| ADR-171: A parallel stage is a pod set that separates | M4.5m: hpr’s design gains a parallel stage, a stage laid out as a pod set beside a body tube of an axial stage before it, weighed to its own stage and dropped by its own separation as a part that tumbles. The .ork reader reads OpenRocket’s <parallelstage> on a rocket of one axial stage; a motor in it lights as one in that stage does, and a parallel stage with no motor that lights stays on. OpenRocket’s Parallel booster staging flies both configurations as saved, each apogee within 1.3% of OpenRocket’s | |
| ADR-172: A stage’s first burnout, and a booster dropped still burning | M4.5n: a .ork stage whose motors sit in several mounts burns out when its first motor does, by the motors’ ignitions and curves, as OpenRocket 24.12 flies it (measured by a committed probe). The stage above lights there, and the stage separates there, when the file says so. A split at that first burnout may drop the stage’s other motors still burning. The flight then leaves their thrust out of the dropped part’s flight as a point, and says how much impulse that is. OpenRocket aborts its own flight of Pods--powered with recovery deployment’s first configuration, so hpr’s flight of it is checked against OpenRocket’s up to the abort: at the separation and at OpenRocket’s last row, within 5% | |
| ADR-173: A blunt ellipsoid’s subsonic pressure drag, from Hoerner’s measurement | M4.5o: an elliptical nose or shoulder takes Hoerner’s measured forebody pressure drag below Mach 0.8 (a hemisphere 0.01, a round head one diameter long −0.05, a flat face the step’s), held at 0 from 7/12 caliber on, and rises in a straight line from Mach 0.8 to Stoney’s scaled curve at Mach 1.2. Base drag hack (short-wide)’s 0.577-caliber nose gets 0.0008, so its E12-4 stays 7.80% above OpenRocket’s apogee with recovery in both: the 5% bar would need about 0.015, which no measurement supports. Not met, recorded; M4.5 is closed with that gap. | |
ADR-174: The command line’s colors, help: lines and title block | M0.6b: hpr colors its streams by the product system’s cli.md (the --color flag, then NO_COLOR, then FORCE_COLOR or CLICOLOR_FORCE, then auto), in the system’s fs_style.rs roles, copied in unchanged; never in --json output or a file. Every hint is a help: line, and an error document’s help array; clap’s tip: and “For more information” lines are rewritten to match. hpr --version, every --json document (a tool object first), and every file hpr writes name hpr-sim, its version and FS · SW · TOOL 005, where its format keeps them; a CSV’s goes in a .meta.json sidecar. A converted design file names this program, its source kept as read, amending ADR-112 §6. | |
| ADR-175: The plot in the product system’s chart style | M0.6c: hpr sim --plot draws in the light theme’s color roles of the product system’s foundations (Rev A) and no other color; every series is simulated, so dashed in the predicted color, a quantity’s size thick and its vertical part thin; events are dotted lines under numbered balloons with a table of every event’s number, time, altitude and name; the ground is a chain line; axis titles are QUANTITY · unit; no legend box, the line types said once in a caption whose first line, also the SVG’s <desc>, gives the summary’s apogee, its time and top speed. The fall that is not a prediction is hatched, its label outside the hatching. Amends ADR-157 §2, §3 and §5. | |
| ADR-176: The spelling check: what it reads and what it leaves alone | M0.6d is split in two: M0.6d1 adds cargo xtask spelling and clears the pages, the README and the scripts; M0.6d2 widens its scope to the crates, xtask, the schema and the pages’ fenced code blocks. The check reads a file’s writing (a page’s prose, a source file’s comments and strings) and skips code identifiers, string literals that are one bare word, link targets and URLs, HTML tags, links quoting a decision record’s title, and the frozen records, which now include docs/DECISIONS.md. Quotations, source titles and names that keep their spelling sit on a short list in the check, each with the phrase that holds it; the check counts them on every run and fails on an entry that matches nothing. | |
| ADR-177: The spelling check in the crates: words first, em dashes next | M0.6d2 is re-split in two before it shipped: M0.6d2 widens cargo xtask spelling to crates xtask schema and the pages’ fenced code blocks, read by each block’s language, and clears every UK spelling there; M0.6d3 rewrites the 266 em dashes left in them, which the check counts and prints until then. A name in a format string and a key quoted inside a string are identifiers; the check’s own file isn’t read; probe names an oracle’s recording keys by are allowed names. | |
| ADR-178: US names, and the spelling check reads them | M0.6e renames the 63 names that held a word on M0.6d’s list (center_of_pressure_m, MorrisDesign::analyze, VerticalUnit::Meter and the rest, as they are now called) to their US forms, and cargo xtask spelling now reads names as well as writing, so a new one fails CI. Seven serialized types keep each renamed key’s old spelling as a serde alias, read and never written, with tests that read the old form back; the design format’s keys never held a word on the list. GDAL’s own names for a unit are another program’s data and stay. | |
| ADR-179: The envelope flags, and when an angle of attack counts | M1.14a splits in two: a1 the four envelope flags of ADR-143 §1, a2 the warnings for ADR-163 §4’s issues. The flags come from a flight’s summary: three by its top Mach number against 1.1467 (the fastest public reference, pinned to the committed reports by a test), 2.5 and 3.5, and one by a new peak, the largest angle of attack more than 1 s after the rail exit and before apogee or the first deployment, counting only instants whose dynamic pressure is at least a tenth of the largest so far. Each edge is exclusive. The library, hpr sim (text and JSON) and Python all report them. | |
| ADR-180: The drag issue warnings, and M1.14a2’s split | M1.14a2 splits in two: a2 the warnings for the five drag issues on ADR-163 §4’s list (#67, #68, #70, #72, #222), a3 the four stability ones (#87, #120, #121, #172). A drag warning comes from the flight’s top Mach number and the design’s parts: a cone or ogive nose past Mach 0.8 (#67); every rocket past Mach 0.8, saying low from 1.2 (#68); airfoil fins past Mach 1 (#70); a boattail steeper than 10° past Mach 1 (#72); an ogive nose or airfoil fins past Mach 1 (#222). Each Mach edge is exclusive; a NaN top Mach number raises every warning the design’s shape allows. The library, hpr sim (text and JSON) and Python report them. | |
| ADR-181: The stability issue warnings | M1.14a3’s four stability warnings. #87, #120 and #121 warn past Mach 1.2 when hpr_aero’s supersonic body run, which is otherwise silent about why it stops, names that switch as the one that stopped it: a new public SupersonicFallback on AeroModel. #172 states no condition, and its cause is unmeasured, so it warns on every flight on hpr’s own aerodynamics that reports a smallest static margin, quoting the largest measured gap (0.073 calibers high) and no threshold. | |
ADR-182: hpr mc, Monte Carlo from the command line | M4.6 is split: M4.6a hpr mc, M4.6b Python. A Monte Carlo run’s FlightInputs now carry the flight’s separations, so a staged .ork is scattered as hpr sim flies it, and a tumble hpr adds to a separated part is not given a dispersed lag. hpr mc takes one option a dispersion, in the command line’s units, flies its samples on every core, prints the nominal flight beside the apogee’s and landing distance’s spreads and three landing ellipses, counts its failed flights by reason, and exports every flight as a CSV table (hpr_analysis::table::RunTable) whose numbers read back to the run’s bits. | |
| ADR-183: Monte Carlo in Python | hpr.MonteCarlo flies the library’s run on every core and returns its RunTable as NumPy arrays: numbers as float64 with NaN for a missing value, index as uint64, words as string arrays. Its eleven arguments are hpr mc’s options under the names its JSON uses. Rocket.from_file(..., recovery=True) flies a file’s recovery devices as hpr sim does, so a Python run and hpr mc can fly the same design, and a test holds them equal bit for bit with both release builds. | |
| ADR-184: Logged apogees of the private collection | M2.3c1 flies the 83 tier-A flights of hpr-sim-fixtures whose design is a .ork, in hpr and in OpenRocket 24.12, each in its day’s ERA5 weather with nothing deployed, and compares each apogee with the flight’s logged one, turned into the height climbed in that day’s air. A hand-read manifest under the gitignored corpus/ holds what each flight’s free-text row says; only aggregates are published, with the collection’s credit and the Copernicus attribution. | |
| ADR-185: Release 0.1 split, and its first fixes | M10.1 is split in four: a, the flight and design fixes; b, the data, network and Python fixes; c, the release workflow; d, the release notes and ADR-162’s checklist. M10.1a refuses a separation or ejection timed before the rail exit instead of firing it late, records one apogee, counts only errors in SimError::DesignChecks’s message, makes DragTable::with_reference_diameter_m check its diameter (#79’s decision), and measures a part in a nose cone or transition against the room where it sits: an error past the fit tolerance of the widest room along it, a new warning when it fits there but runs into the wall where the profile narrows. | |
| ADR-186: The data, network and Python fixes of release 0.1 | M10.1b fixes five issues. The bundled motor catalog is written from its 32 public-domain curve files alone by cargo xtask motor-catalog, every figure the file’s own (#295). .hprz attachment names are compared after canonical decomposition as well as case folding (#252). Open-Meteo and NOMADS write a site’s coordinates to 5 decimals so a radians round trip keeps the cache key (#272). Three pages’ accuracy figures are the report’s, and the site’s number trace now checks them (#298). A pytest pins Python’s recovery=True flight to hpr sim’s bit for bit (#308). | |
ADR-187: The release workflow, its license texts, and hpr validate left to xtask | M10.1c: a Release workflow builds and smoke-tests the command line’s archives for three operating systems, the Python package’s abi3 wheels and its source package, each carrying both licenses, THIRD-PARTY-NOTICES.md and its dependencies’ license texts written by cargo-about; it publishes only from a dispatch that asks to, after approval in the release environment. Every library crate and hpr-cli become publishable. hpr validate leaves the command line, because a published crate can’t depend on the unpublished harness; cargo xtask validate --check makes the same check. | |
| ADR-188: Release 0.1’s notes, and the flattering-side issues without a warning | Release 0.1’s last increment splits in two. M10.1d1 writes CHANGELOG.md and the install pages, and lists by number every open env-core issue on the flattering side or of unknown sign; M10.1d2 adds a warning for each flattering-side issue that has none (#18, #64, #73, #179, #325, #326, #354, #367), settles or warns each unknown sign, fixes #335, and then shows the whole checklist at a commit on main. The changelog links pages by the site’s address and is held to the site’s link and label checks. | |
| ADR-189: The unstable-under-power flag and four shape warnings; M10.1d2 split in three | M10.1d2 splits in three: d2 the flag for a flight unstable under power (#335) and the warnings read from the design’s shape (#64, #73, #325, #367) with #172’s bound raised to 0.1108 calibers; d3 the warnings for separated parts, laminar friction and kinked fins (#18, #179, #326, #354) and the seven unknown signs; d4 the checklist and its Release dispatch. Each new warning’s condition takes in the unmeasured range next to its measured one. | |
| ADR-190: The friction and freeform fin warnings; M10.1d3 split in three | M10.1d3 splits in three: d3 the warnings read from the design and the drag alone (#18 on every flight on hpr’s drag, #326 on every freeform fin set, both at any speed); d5 the separated parts’ warnings (#179, #354); d6 the seven unknown signs. Each takes in its issue’s unmeasured range. | |
| ADR-191: Neer’s 2026-10-06 ideas: the four web tools, watches, the repo layout and the hardware line | the four FusionSpace web tools (Motor Finder, Charge, Window, Muster) are rebuilt as library code and app screens in M9.6, after mobile; Motor Finder’s scraper stays a hosted service whose API hpr keeps reading. hpr stays one repository with several workspaces, split only by named triggers. Watches wait until after mobile, with the phone as hub. The hardware line is ordered by regulation, and active-control firmware or hardware waits for Neer’s export-control answer. | |
| ADR-192: Neer’s 2026-10-06 follow-up: the best product over the first, no legacy contracts, and three export tiers | Neer’s decisions on ADR-191’s three open questions. The old web tools get no more work and constrain nothing: Motor Finder’s API is not a contract, and hpr’s stock service is designed fresh even if release 0.1’s reader breaks. The best product outranks the first release. Export control sorts the work into three tiers (public, held, never): the simulator and its control models stay public; firmware or hardware that moves a control surface is held off GitHub and out of cloud services until a ruling; target guidance, thrust vector control and lifted GPS caps are never built. | |
| ADR-193: Neer’s 2026-10-07 control scope: drag-only airbrakes, roll-only canards and fin tabs | hpr’s active control, simulated or built, is limited to airbrakes that only add drag and to canards and tail-fin tabs that only roll the rocket, stable with every surface inert and with any one surface stuck. The controller has two commands, brake deployment and roll, through a fixed mixer, so nothing can command pitch or yaw. Active pitch and yaw control joins the never tier; the backlog’s thrust vector control and active fins leave it. Roll tabs come before roll canards, because a tail spanning as much as the canards removed most of their roll in NASA’s supersonic tests. M6.5 becomes roll control; new M13.6 holds the control hardware for a ruling. | |
| ADR-194: Neer’s 2026-10-07 field tools: checklists, equipment and ground tests | Release 0.4 gains M6.8, a field kit in the library and the CLI: a launch checklist and guide, a check of each altimeter’s settings, and a ground-test log that M6.7’s charge sizing reads. M6.7 is tightened by the one measured source found (Fetter, 2025): a packed bay needed several times the calculated charge to separate, so a packed bay is sized to his measured outcomes, never from the empty-bay pressure; the bulkhead load takes the empty-bay peak’s high side; the charge grows with altitude, and above 20,000 ft no black-powder size is printed. M9.7 adds an equipment register and frequency board. M13.7 is a ground-test bench (a pressure logger and a wired firing box), in the public tier. | |
| ADR-195: Neer’s 2026-10-07 guides: rocketry explained, illustrated and live | Neer’s guides to all of high-power rocketry become M0.7, Rocketry explained, a section of the docs site in four increments. M0.7a, right after release 0.1, sets the format and writes four guides on the largest gaps hpr models: stability, fin flutter, drag through Mach 1, and how far to trust a simulation. M0.7b, before release 0.4, adds recovery, wind and rail exit, and motors. M0.7c, after release 0.5, makes the figures live, run by hpr itself in the browser. M0.7d, after 1.0, covers the rest of the hobby. Every number a guide shows comes from hpr or a cited source, every figure is checked for clipping, and nothing is copied from copyrighted or share-alike sources. | |
| ADR-196: Neer’s 2026-10-07 product guides: each product, illustrated | Each of the suite’s products gets a guide on the docs site: a landing page and an illustrated tour that ends on a public real flight, in M0.7’s format and checks. Every picture is made by a command CI reruns, never taken by hand: CLI output as terminal figures, plots from hpr, app screens from end-to-end tests, with phone and watch captures checked against the device’s safe area. M0.8a writes the simulator’s guide after M0.7a; from release 0.2 on, the release checklist requires that release’s guide, read by Neer; each line after 1.0 ships its guide with its first milestone. The roadmap’s budget rises to 40,500 bytes. | |
| ADR-197: Neer’s 2026-10-07 parts catalog: commercial parts, and a catalog of hpr’s own | OpenRocket’s catalog, bundled since M5.5, stays as the base. M5.6 adds a catalog of hpr’s own in four increments. M5.6a adds the format, where every value carries its source and date, plus hpr parts search and a parts list to buy from. M5.6b adds parachutes and recovery hardware, each Cd stored with its reference area and a descent rate given as a range, the flattering side pinned. M5.6c adds motor hardware and rail buttons, never counting a mass twice. M5.6d adds more airframe makers and electronics, masses carried as ranges. Only cited facts go in; no vendor text or photos. M5.6a comes after release 0.5, ahead of M8.2; the rest before 1.0, with M5.6b ahead of M8.1’s parachute sizing. | |
| ADR-198: Neer’s 2026-10-07 project name: Eridanus, its stars, and the design system’s catch-up | the project is Eridanus, FS-ERI, and the repository becomes nrdptel/fusionspace-eridanus when Neer renames it. Each product takes one of Eridanus’s stars as its internal name: the simulator is Achernar (FS-ACHERNAR), the app Zaurak, the flight analyzer Angetenar, avionics Sceptrum, the competition kit Acamar, the motor designer Rana and the recovery designer Cursa. The designation FS · SW · TOOL 005, retired in the design system, becomes FS-ACHERNAR · SW · TOOL 001, and files stamped with the old one still read. GitHub doesn’t redirect a project site after a rename, so the rename comes before release 0.1 publishes anything. M10.1d7 and M10.1d8 do the code side, and catch up with the 21 design-system commits since the pin. | |
| ADR-199: Neer’s 2026-10-07 public name: FusionSpace HPR, on every product and package | the suite’s public name is FusionSpace HPR, and each product is “FusionSpace HPR ·” and its role: Sim, Analyzer, Competition Kit, Motor Designer, Recovery Designer, Avionics, with the app and its store listing called FusionSpace HPR. Packages carry the brand: PyPI fusionspace-hpr imported as fusionspace.hpr, crates fusionspace-hpr and fusionspace-hpr-*, npm @fusionspace/hpr. The command stays hpr, and its help, version and banner open with FusionSpace HPR. Stamps read FusionSpace HPR 0.1.0 · FS-ACHERNAR · SW · TOOL 001, and files stamped by hpr-sim still read. The docs move to hpr.fusionspace.co. M10.1d9 renames everything before release 0.1 publishes, because a published name is permanent. Star names stay internal codes. | |
| ADR-200: The separated parts’ warnings | M10.1d5: #179 warns on every flight with a body aft of a stage boundary flying on its own (a booster, at any speed); #354 on every flight with a body that starts its own flight with nothing open, a device opening at that same instant counting as open. Both read the flight’s bodies, so a drag of the flight’s own keeps them. | |
| ADR-201: The unknown signs | M10.1d6: of the seven issues of unknown sign, #104, #360 and #361 print no wrong number (the first is never printed, the other two are refused), and #8, #106, #213 and #219 err either way by case, so each warns, as a new flight kind: a near-calm wind level that turns, a body part’s damping station inside the supersonic join, a single pod off the axis, and a center of gravity more than 1e-9 m off the axis. | |
| ADR-202: The release files: glibc floor, license copies and a paced publish | #372: the Linux archive and wheel are built with Zig for glibc 2.17 (manylinux2014), checked by objdump and smoke-tested inside a pinned manylinux2014 image; each publishable crate holds byte-identical copies of both licenses, tested; crates go up one at a time through scripts/release/publish-crates.sh, paced to crates.io’s limit on new names and resumable. Amends ADR-187 §4. | |
| ADR-203: The FusionSpace HPR packages | M10.1d9: the 14 published crates are fusionspace-hpr and fusionspace-hpr-*, keeping their Rust library names (hpr, hpr_core, …); the Python distribution is fusionspace-hpr, imported as fusionspace.hpr from an implicit fusionspace namespace; stamps, --version, --help, the site and README titles, the User-Agent, cache folders, release title and archives say FusionSpace HPR; a hpr-sim stamp of either designation still reads. | |
| ADR-204: The no-clipping checks | M0.7a is split in five: the no-clipping checks first (M0.7a1), then the format with the trust guide, then stability, flutter and drag through Mach 1, one guide each. Three checks enforce Neer’s rule that nothing is clipped: xtask figures holds every SVG to its viewBox and its clips, with text measured in the widest of a set of system fonts character by character; the same check fails text over text; xtask site loads every guide page in headless Chrome at each width from 320 to 1,920 px and fails sideways scroll, text past the left or right edge or cut by its box, and text over text. The first run found four real clips, each fixed by layout. | |
| ADR-205: Neer’s 2026-10-08 sweep: one name and one design on every surface, checked by a tool | M10.1d9 renamed the packages, stamps and titles, but the words around them still say hpr-sim: 242 times in 35 of the site’s rendered pages, 113 in the crates, 5 in the README, and in every package’s license, notice and crate descriptions. M0.9a renames them by ADR-199’s rules and adds cargo xtask names, which fails on hpr-sim, or a bare hpr naming the product in prose, outside a narrow allowlist whose entries each give their reason and must match. M0.9b audits every shipped surface against the pinned design system; each rule that applies is met and checked, or has an issue. M0.9a lands before release 0.1 publishes, because a published version’s README and crate docs never change. | |
| ADR-206: The name check in two steps: the packages’ text, then the site | M0.9a is split. M0.9a1 builds cargo xtask names with both of ADR-205’s rules, and holds every surface ADR-205 §1 lists to it except the site’s pages: the text that ships inside a published package (README, crate texts, Python package, schemas, licenses, notices, CHANGELOG) and the banners, plus the landing page, whose first paragraph now names the suite. M0.9a2 adds the pages SUMMARY.md renders and the records page, about 2,300 more mentions. Release 0.1 waits for M0.9a1 only, since a published version’s package text is fixed and the site’s is not. Code compiled only for tests ships nothing and is not checked; a string literal’s hpr is the command when a subcommand, a flag or a placeholder follows it. | |
| ADR-207: The name check on the site’s pages | M0.9a2 holds every page SUMMARY.md renders, and SUMMARY.md itself, to cargo xtask names. About 2,280 mentions were rewritten: comparisons and tables say “HPR Sim”, other prose “the simulator” or “this project”, the command and library hpr in code. Two names keep the old name by rule: a decision record’s file name and the flight engine’s folder in a path, crates/hpr-sim/. On the records page, a decision record’s row inherits the allowance of the record its first cell’s [adr-NNN] link names, and nothing else does. 15 entries keep the site’s anchors, stamps and history, and 73 records up to ADR-205 are allowed whole for their rows. 16 headings that said hpr were rewritten, 15 of them with new anchors. | |
| ADR-208: The design audit: 112 sections against what ships, and three increments to close it | docs/research/design-conformance.md rows all 112 ## sections of the FusionSpace product system’s 14 product/ files at the pinned commit f45454f. 64 sections sit in the eight files for surfaces shipping today. Of those, 8 are met (5 held by named tests, 3 by review), 49 are not met, 3 wait for a later surface and 4 govern nothing the project ships. The 49 gaps are 11 issues, fixed by three new increments: M0.9c (command line), M0.9d (site look) and M0.9e (words). xtask/src/conformance.rs fails on a missing section, a moved pin, a dead test or a closed milestone. Release 0.1 doesn’t wait for the audit (ADR-205 §3), but review.md’s Before release lists (ADR-164 §5) are not all met. | |
| ADR-209: Neer’s 2026-10-08 standard: the best on the market, measured, for every product | Every product aims to be the best available: never worse than the best comparable tool on any axis, decisively better on the two or three its users care most about, with at least one capability no other tool has. A generated scoreboard ratchets, so a release can’t make a number worse without an ADR (M0.10). Accuracy is judged on held-out flights, predictions recorded first (M2.7), and uncertainty on whether ranges hold as often as they say (M2.8). Release 0.3 needs held-out mean absolute apogee error below OpenRocket’s, absolute bias within 3%, and 50% and 90% ranges that hold as often as claimed, or, only once the accuracy campaign ends by its stop rule, an ADR with the miss. | |
| ADR-210: US units in brackets on the command line; no units switch and SI exports until the app | hpr sim, hpr mc, hpr motors show and the plot give US units in brackets after the SI value, in their note: and warning: lines too: feet and feet per second for heights and speeds, mph for wind, inches for CG, CP and motor size, ounces or pounds for masses. hpr motors show gives the class’s impulse range in the standards’ written form, the nominal thrust beside the measured one where they differ, and the propellant’s name where the catalog has it. The command line gets no --units switch, and the CSV and JSON exports stay SI, until the app’s units control (M9.1). Other readouts that still print SI alone are #392. | |
| ADR-211: How far to trust a result: one note, from the largest comparison with real flights | hpr sim and hpr mc mark their figures as simulated and end with a note, How far to trust it: the kind of figure, what its apogee was checked against, and what to rely on instead. The numbers are the committed report’s, when written on 55 logged flights of fliers’ own designs (53 since the recheck of ADR-238: 8.7% above, 26 within 10%, 13 low), the largest and least flattering comparison with real flights: the simulated apogee averaged 9.8% above the logged height climbed, within 10% on 27, low on 14 by at most 20%. A test holds each to the report. The plot ends with the same note; --json carries it as trust, beside kind: "simulated". | |
| ADR-212: Measure against OpenRocket’s newest release, not only 24.12 | OpenRocket’s development branch has merged changes since 24.12 that can move its apogees; two others, a powered base-drag correction and thrust corrected for air pressure, apply only when a nozzle exit diameter is entered (the default, 0, applies neither). Release 0.3’s target, held-out error below OpenRocket’s, would be judged against a version flyers are about to leave, so the comparison follows OpenRocket’s releases. M2.3c3 flies the private collection and the public comparison sets on OpenRocket’s newest release after 24.12 beside 24.12, each version named. Release 0.3 (M10.3) then needs HPR Sim’s held-out error below 24.12’s and below that of any OpenRocket release published before M2.7 is met; with none, 24.12’s alone. Nothing is built from OpenRocket’s source. | |
| ADR-213: US units and a trust note on every readout; M0.9c4 split in four | hpr weather, hpr motors list, search and fetch, and hpr analyze give US units in brackets after the SI, as hpr sim does: a table’s heading names both units (m MSL (ft)), and each cell gives the US figure in brackets after the SI one. hpr weather, hpr analyze and hpr motors show end with the three-part note hpr sim has, and --json carries it as trust, beside a kind with four new values: measured, forecast, reanalysis and copied. Each note says “not yet checked” where nothing has compared its figures with a measurement of what they stand for; the ERA5 note quotes the one comparison with real flights committed for a weather source. | |
| ADR-214: Provenance on the exports: the catalog’s date, the trust note, units in brackets, ASCII JSON | hpr sim --export’s JSON recording, the .meta.json sidecar beside a CSV and hpr mc --export’s sidecar carry the bundled motor catalog’s as-of date (catalog_as_of) and the How far to trust it note as --json has it (kind, trust). hpr sim and hpr mc say “from the bundled catalog, as of 2026-09-17” beside a motor taken from it, and --json gives the date as the source’s as_of. A CSV header gives each column in words with its unit in brackets, time [s], not the time_s the other formats keep. Every JSON document hpr writes, and the library’s JSON and GeoJSON, is ASCII: other characters, the designation’s middle dots among them, are \u escapes. | |
| ADR-215: Errors that name what was typed, and numbers read as typed; M0.9c6 split in two | Every numeric option of hpr reads a number as typed: spaces trimmed, a comma read only as a thousands separator between groups of three digits (1,280 is 1,280, and a note: line says --elevation 1,280 read as 1280 m), any other comma refused with a question (is 3,9 meant as 3.9?), a non-number refused with what a number looks like. hpr sim and hpr mc refuse a launch option the library wouldn’t fly with its name, value and unit, before the library does. hpr motors show with an unknown name says what HPR Sim’s cache of ThrustCurve.org holds. A refusal from inside a flight still has the library’s words and no next step (#405, M0.9c9). | |
| ADR-216: The plot’s type and spacing on the scale, numbers kept with their units; M0.9c7 split in three | The hpr sim --plot figure draws every line at the 12 px label size, balloon numerals included, and its title at the 20 px, weight 600 subtitle size; its caption, balloon rows, event table and indents step on the 4 px scale (8, 16, 24 and 32 px); the time axis is titled at its right end; and a number and its unit are joined by a no-break space in the caption, the notes and the balloons’ tooltips. Each is held by a plot test. Colliding balloons on a leader, banking, a title block and the CSV are M0.9c12; the site’s figure width and the site’s US units (#400) are M0.9c13, both queued after M0.9c9. | |
| ADR-217: Neer’s 2026-10-09 plan: fusionspace.co rebuilt from the ground up | fusionspace.co, FusionSpace’s front page, is rebuilt from the ground up as FS · SITE 001, like the old web tools (M9.6) but sooner: M9.8, queued after the simulator’s guide (M0.8a) so the page can send people to it. It presents FusionSpace and its projects, FusionSpace HPR’s products first, each with its status, its guide, docs and latest release, and the old tools until M9.6 replaces them. It follows fusionspace-design’s web rules, passes the no-clipping checks at every width in both themes, makes no claim of “better” without a committed comparison (ADR-209), and lives in its own public repository, clean of tooling traces from its first commit. Pointing the domain at it is the maintainer’s step. | |
| ADR-218: The plot’s balloons on leaders, banked panels, title block and data file | the hpr sim --plot figure sets its balloons in one row, each that would collide stepped right along a short leader, growing for three-digit numerals; each panel’s height is banked to 45° by Cleveland’s length-weighted average orientation, between 120 and 360 px; the figure ends in an ISO 7200-style title block; and --plot f.svg writes the numbers it draws to f.plot.csv, with a f.plot.meta.json sidecar. Each is held by a test that fails without it. | |
| ADR-219: Figures at their size on the site, US units in the guides’ prose; M0.9c13 split | A figure on the site may reach past the 750 px prose column, up to the product system’s 1,120 px content width, and is shown at its size wherever that holds it; in a narrower window it shrinks and mdBook’s zoom shows it at its size. cargo xtask site’s page check fails a figure shown smaller than drawn with room for it, or without a zoom. Every height, distance and speed in the guides’ prose and tables gives its US units in brackets after the SI, 1,400 m (4,593 ft), and a site check fails one in SI alone or with a bracket that isn’t its conversion. The model, file format and records pages follow in M0.9c16, with millimeters. | |
| ADR-220: The margin bar tightened to 0.2 calibres, M1.14 held to Release 0.3’s target | The bar a stability margin or a center of mass is judged by, against OpenRocket, drops from 0.5 to 0.2 calibers. Every difference measured on both comparison sets but one is within 0.111 calibers, so the old bar let the worst agreement get four times worse with no row changing its standing; the new one catches a doubling. No row changes its standing: margins within it on 52 of 53 public flights and 35 of 35 private, centers of mass on 54 of 54 and 35 of 35. M1.14 now also needs its error on the private flight collection below OpenRocket’s, 24.12’s and its newest release’s, with its bias within 3%. | |
| ADR-221: The site’s defaults split: what the screen’s stylesheets draw first | #383 lists seven classes of mdBook default the product system’s theme doesn’t reach: colors, shape, motion, icons, the head’s metas and accessibility, fonts, and print. M0.9d2 now covers the first three as mdBook’s stylesheets draw them on screen, each held by xtask site’s page check reading every element’s computed style in light and navy and with reduced motion set. The new M0.9d4 keeps the old done-when whole (#383 closed, every class held), after M0.9d3, and takes the rest: icons, metas and accessibility, fonts, print (its link color included), and the smooth scroll mdBook’s script asks for, which no stylesheet can turn off. | |
| ADR-222: Six platforms, each tested on every pull request | CI’s per-platform jobs (the tests, the examples, the Python package and the validation cases) and the release’s archives and wheels now run on six platforms: Linux, macOS and Windows, each on x86-64 and on 64-bit ARM. Each runs natively on its own CPU, and a script fails the job if the toolchain would build for another one. Intel Macs are tested on GitHub’s last Intel image until it retires (fall 2027), then under Rosetta. Windows on ARM tests the Python package from 3.11, its oldest CPython. Static Linux builds, 32-bit ARM, package managers and math that rounds the same everywhere are follow-ups. | |
| ADR-223: The page anatomy split: the page’s frame first | #384 lists eight parts of the product system’s page that the site doesn’t draw. M0.9d3 now covers the frame every page shares: text on the system’s type scale (tabular figures in Archivo, navigation in Cascadia Mono 14 px, the current page underlined 2 px), prose at most 68 characters a line, and gutters of 16 px on a phone and 32 px from 720 px, each held by xtask site’s page check at every width. The new M0.9d5 keeps the old done-when whole (#384 closed, every rule held), after M0.9d4, and takes what changes each page’s markup: title blocks, sheets, the intro, the system’s notes, and every page opening with how far to trust it. | |
| ADR-224: The site’s defaults split again: the head, the keyboard and forced colors first | M0.9d4 now covers what the stylesheets, the head and a script of the site’s own can fix without changing mdBook’s page template: color-scheme and the Paper and Void theme-color metas, the 2 px Ion focus ring, forced colors, scroll-padding-top under the sticky bar, contrast measured, the system’s fonts.css with its fallback faces in every stack, and no smooth scroll, each failing xtask site or a site test when it comes back. The new M0.9d6 keeps the old done-when whole (#383 closed, every class held), adds #443 (Core Web Vitals measured), and takes what needs the template or a print reading: the system’s icons for Font Awesome’s, the favicon, one h1 a page, and print. | |
| ADR-225: The page anatomy split again: the notes first | M0.9d5 now covers one of #384’s six parts: every quote block a page writes is drawn as the product system’s note (.fs-note). Pages write Markdown GitHub renders: a trust note opening with **How far to trust it.**, or a GitHub alert, [!NOTE], [!CAUTION] or [!WARNING]. After mdBook builds the site, cargo xtask site rewrites each as the system’s specimen writes a note, and fails any other quote block or any note whose signal word, strip, fill or border is off the system’s. The new M0.9d7 takes the rest: title blocks, sheets, the intro and every page opening with how far to trust it. | |
| ADR-226: The gap to OpenRocket split by cause before M1.14 starts | on the 55 logged flights of the private collection, FusionSpace HPR’s apogees miss the logs by a mean absolute 13.96% and OpenRocket 24.12’s by 13.08%. Nothing says which of its inputs makes up the 0.88-point gap. M2.3c6 splits each flight’s difference into thrust, mass and drag parts before M1.14 tries to close it. | |
| ADR-227: Phones built on every pull request | CI builds the workspace for iPhone (aarch64-apple-ios), its simulator on Apple silicon (aarch64-apple-ios-sim) and 64-bit Android (aarch64-linux-android, Android 7.0 and later) on every pull request, so the mobile apps (M9.4) start from a core that already builds there. Build only: the tests run on phones when the apps do, and no phone archives or wheels are released. | |
| ADR-228: The site’s defaults split again: the chrome first | M0.9d6 now covers what the page’s chrome draws: after mdBook builds the site, cargo xtask site swaps each Font Awesome glyph for the system’s icon of the same meaning and makes the menu bar’s title a paragraph; a file check fails a glyph left, an icon not the system’s or a second h1; the favicon is the system’s; and the page check fails an icon off 16, 20 or 24 px and a selection off the action role at 22 %. The new M0.9d8 takes print and the Core Web Vitals. The field theme, which the audit counted under #383 but which is no mdBook default, moves to #452. | |
| ADR-229: The page anatomy split again: the frame first | M0.9d7 now covers the page’s frame: after mdBook builds the site, cargo xtask site makes the menu bar a header that draws the system’s one-color horizontal lockup, keeps the sidebar open with no menu button from 720 px, and ends every page with the system’s title block in a footer, its entries written once at the end of the landing page’s source. The page check fails a lockup off 24 px or the ink role or without its clear space, a menu button from 720 px, a sidebar reachable while put away (or not while shown), and a title block off the system’s shape or not last. The new M0.9d9 takes the intro, the sheets and the trust openings. | |
| ADR-230: The site’s defaults split again: print and the text marks first | M0.9d8 now covers print and the marks: the build draws the sidebar’s fold toggle as the system’s chevron, the theme menu underlines the chosen theme, a heading jumped to takes no mark, and the site prints in the light theme’s values with navigation hidden, link addresses shown and rows, notes and the title block kept whole. The page check fails a text mark drawn as an icon, and reads every page with its print rules applied at the run’s width nearest a sheet of paper (720 px), in both themes. The new M0.9d10 keeps the old done-when whole (#383 and #443 closed) and takes the Core Web Vitals. | |
| ADR-231: The page anatomy split again: the drawing first | M0.9d9 now covers what the build can draw on every page: after mdBook builds the site, cargo xtask site opens each page’s intro with the designation tag, makes each h2 section a sheet with SHEET n / N in its rail under a 2 px ink rule, and turns mdBook’s six-theme menu into the system’s segmented switch, in the header from 960 px and at the top of the sidebar below. Checks fail a page without them, a heading that skips a level, or any drawn off the system’s. The new M0.9d11 keeps the old done-when whole (#384 closed, every rule held) and takes the intro’s chip and lead, the sheet count and the trust openings. | |
| ADR-232: The pages’ vitals, measured as a phone on slow 4G | cargo xtask site now loads every page of the guide cold in headless Chrome as Lighthouse’s mobile preset (a 412 px phone, 562.5 ms on every request, 1.5 Mbit/s down) with the CPU slowed to a phone’s by Lighthouse’s BenchmarkIndex, measures LCP, CLS and INP, and fails a page over 2.5 s, 0.1 or 200 ms (the median of three loads for a page over). To pass, every page links one stylesheet and preloads four fonts, two more than the product system’s limit; the theme switch is placed before the first paint; and the print page shows a cover on screen. The page check now also fails anything fixed to the window on paper. | |
| ADR-233: The pages’ own words split again: the intro’s chip and lead first | M0.9d11 now covers the intro: after mdBook builds the site, cargo xtask site sets the title block’s status (IN PREPARATION or RELEASED) in the system’s chip beside the designation tag, and makes the paragraph under every page’s title its lead, which a file check holds to one sentence of at most 25 words; the page check fails a chip or a lead drawn off the system’s. The title block’s version and status, which still read “not yet released” after 0.1.0 shipped on 2026-10-08, now say what the site describes. The new M0.9d12 keeps the old done-when whole (#384 closed, every rule held) and takes the sheets and the trust openings. | |
| ADR-234: The pages’ sheets and trust split again: the sheet count’s check first | M0.9d12 now covers the sheet count’s check: cargo xtask site and a site test count each page’s ## sections, its sheets, and fail a page with fewer than two or more than six, except the 38 pages over six on a list in xtask/src/site/sheets.rs, held exact: a listed page at six or fewer fails until it comes off, and so does a listed page the summary doesn’t hold. The glossary, 187 sections, one a term, now groups its terms in six by first letter, each term a ### heading with the same anchor. The new M0.9d13 keeps the old done-when whole (#384 closed, every rule held) and takes the 38 pages’ grouping and the trust openings. | |
| ADR-235: Every page in two to six sheets and opening with how far to trust it | The 38 pages that had more than six ## sections are grouped into two to six sheets, so the check fails any page outside that range and the list of exceptions is gone. Every page but a model page now holds a trust note, a quote block opening with **How far to trust it.**, between its title’s lead and its first sheet; a model page opens with In short instead. cargo xtask site and a site test fail a page that doesn’t. | |
| ADR-236: Supersonic flights from published comparisons, after Release 0.3 | no public real flight FusionSpace HPR is scored against passes Mach 1, and the private collection’s report doesn’t split its errors by speed. RASAero II’s author publishes 36 flights with measured apogees, and says the designs of most ship with RASAero II. M2.3c7 flies those designs, scores them by Mach band beside RASAero II’s own published errors, and splits the collection’s errors at Mach 1. | |
| ADR-237: One fixture repository: the pin, the labels and a file two packages install | The reference lock pins only the private flight collection, at its master merge commit 7268bcd0, with a second manifest pin for the design library copied inside it. The two older private repositories are read from its byte-exact imported/ copies, and the survey counts the library under that path. The OpenRocket round-trip report was flown again because its record predated a writer change. The Python environment check now accepts a file two packages install when it holds either package’s copy. | |
| ADR-238: The corpus rechecked against the collection’s catalog | Each of the 121 flags the private collection’s catalog raised on 68 of the 83 flights the fixture report draws on was settled against the flight’s log and sources. Four flights changed in the manifest: one launch day, one logged apogee, and two flights left out; every entry also records the tier the catalog proposes. HPR Sim’s mean apogee error over the logs moved from +9.83% (55 flights) to +8.73% (53), OpenRocket’s from +9.00% to +7.79%, with nothing in either simulator changed. Leaving out one flight that tumbled through its climb is more than the whole move. The report adds the errors without the flights the catalog proposes below tier A: +7.84% over 44. | |
| ADR-239: The words to the design: spelling, minus signs, number columns and the READMEs | xtask spelling reads the British forms the design audit found and the others a survey of the pages turned up, and the project now writes them in US English, renamed code names included; the site check fails a hyphen-minus written for a minus sign and a table column of numbers that isn’t right-aligned; the READMEs follow writing.md’s order with a status word and the version, held by a test. What #386 listed beyond M0.9e’s done when moves to #476 and a new increment, M0.9f, before release 0.2. | |
| ADR-240: The scoreboard: its cells, its ratchet, and the cells no milestone measured | cargo xtask scoreboard writes validation/reports/scoreboard.{json,md}: HPR Sim against OpenRocket 24.12 and RocketPy 1.13.0 on accuracy, bias, honest uncertainty, speed, round trips, features and steps to a first answer, each number read by key from a committed report and kept as printed, each unmeasured cell naming the open milestone that measures it. A check in the xtask tests, and in CI against main’s committed scoreboard, fails when one of HPR Sim’s numbers prints worse, counts fewer flights or designs, or a measured cell is no longer measured, unless an accepted ADR names that cell and the next release in a - **Scoreboard:** line. A new milestone, M2.9, measures the other tools’ cells that no milestone did, and every tool’s speed. | |
| ADR-241: Steps to a first answer: what a step is, and a tool that can’t | The scoreboard counts the steps to open a design’s .ork file, fly it once and see its apogee, and get its landing spread, in four rows: commands, script lines, clicks and typed entries. HPR Sim’s commands and Python lines are files a test runs; OpenRocket’s and RocketPy’s steps come from their documentation, each step citing its page. A way in that a tool lacks, or a task it can’t do that way, is a cell that says can’t, with its source. HPR Sim takes 2 commands or 9 script lines; OpenRocket 24.12 opens and flies in 7 clicks but has no Monte Carlo; RocketPy 1.13.0 reads no .ork file. | |
| ADR-242: The guides’ format and the trust guide, every number read from a report | The first guide, How far to trust a simulation, is a top-level page in a new Rocketry explained part of the site. cargo xtask guides holds every number in a guide’s prose to a committed report: a quote fills its holes from the report’s JSON, a page must hold it word for word, and any other number in the prose fails. The guide’s figure, HPR Sim’s apogee misses on 53 logged flights by bin, is drawn from the same report, the band within 10% shaded and the low side marked as the one that flatters a ceiling, tied to a new test of a miss’s sign. | |
| ADR-243: The stability guide: the center of pressure against a wind tunnel, and the guide rocket’s own report | The second guide, Stability in flight, explains how Mach number and angle of attack move the center of pressure. Its numbers come from two committed files: the existing comparison with NASA’s Arcas Robin wind-tunnel tests, and a new report of the guide rocket’s center of pressure, which cargo xtask guides writes and fails when stale. The figure draws the tunnel’s readings against HPR Sim’s line, and marks each speed where HPR Sim’s center of pressure sits aft of the tunnel’s: a margin that reads high, tied to a new test of that sign. The angle section marks no side, since nothing measured checks the whole rocket at an angle. | |
| ADR-244: The flutter guide: the guide rocket’s fins read two ways, and the halved constant marked | The third guide, When fins flutter, explains what flutter is, what Martin’s criterion’s flutter speed depends on, and what its two readings (the ratio of the flutter speed to the airspeed at max q, and Martin’s own chart) say about the guides’ rocket. Its numbers come from a new report, guide-rocket-flutter.json, which cargo xtask guides writes from the design and its flights through hpr sim --json and fails when stale. The figure draws the rocket’s flutter speed against its fins’ thickness, with Martin’s band shaded and the halved constant of Peak of Flight #291 and #411 marked in the caution color: a flutter speed that reads high, tied to a new test in hpr_sim::flutter of that direction. | |
| ADR-245: The drag guide: the guide rocket’s drag through the speed of sound, the tunnel’s high reading marked, and the maintainer’s read apart | The fourth guide, Drag through the speed of sound, explains the drag’s three parts, how HPR Sim’s forebody drag compares with NASA’s Arcas Robin wind tunnel, and which error flatters. Its numbers come from a new report, guide-rocket-drag.json, which cargo xtask guides writes and fails when stale. The figure draws the tunnel’s forebody drag against HPR Sim’s with every speed where HPR Sim’s reads high marked: an apogee that reads low, tied to a new hpr_sim test of that direction. The guide also quotes the logged flights’ mean apogee miss, which leans the other way. M0.7a5’s maintainer-read clause moves word for word to a new increment, M0.7a6, marked blocked on him. | |
| ADR-246: Student Launch by requirement number, and the other tools’ known defects | M6.3’s NASA Student Launch preset takes the College/University division’s 14 numeric limits from the 2027 handbook, each by requirement number and at both ballast settings, with a defined second method for descent time and landing energy beside the simulation, and each check’s error side pinned. M2.9’s cells for the other tools name the release they came from and each open defect that moves that tool’s apogee by more than 0.5%, flown with the public fix too. | |
| ADR-247: The simulator’s guide in four increments, its terminal figures drawn from the CLI’s own runs, and its tour ending on the median public flight | M0.8a, the simulator’s guide, splits four ways, its own done when unchanged: the landing page and a tour of the command line (M0.8a1), the same flight from Python (M0.8a2), the Compared with section ADR-209 §8 asks for (M0.8a3), and the maintainer’s read (M0.8a4, blocked on the maintainer). The guide is a new Product guides part: a landing page, HPR Sim, and A tour of HPR Sim, both held to the guides’ number check. The tour’s pictures are terminal figures: cargo xtask cli draws each from the same run as an example on the page, and --check fails a stale one. The tour ends on the public flight with the median unsigned apogee miss, picked by rule in code. | |
| ADR-248: The simulator’s comparison: a record of capabilities read from each tool’s documentation, written into the guide and counted on the scoreboard | The simulator’s guide gets a third page, Compared with other simulators. Its capability table is written by cargo xtask guides from a committed record, validation/features/simulator.toml, in which each cell of another tool names the documentation page that shows it, the release and the date it was read, and a note for every partly and no; each of HPR Sim’s cells names the page of the site that covers it, or the open milestone that brings it. The reader refuses a cell without its page, a no without its note. The tools are OpenRocket, RocketPy and RASAero II. Only full yes cells count, and the scoreboard’s features.count row counts them for its three tools. | |
| ADR-249: fusionspace.co in two increments, a static page in its own repository, checked in Chrome at every width | M9.8, fusionspace.co rebuilt, splits in two, its own done when unchanged: the page, its checks and the steps that move the domain (M9.8a), and the maintainer’s use (M9.8b, blocked on the maintainer). The page lives in the new public repository nrdptel/fusionspace-site. It is one static page in plain HTML and CSS with one script, on Cloudflare Pages, with no build step. A check written for it drives Chrome over the DevTools protocol from Node, with no packages. It lays each page out at the 41 widths from 320 to 1,920 px in the light, dark and field themes. It fails on anything cut off, scrolled, past an edge, overlapping or covered, and on a font or browser error. | |
| ADR-250: The measure as a median and a maximum, a reading scale that grows with the window, and the column flush left, from the product system’s Rev B | Prose on the site stopped at 24 em, about 384 px, so a desktop window was mostly empty. The product system’s Rev B states the measure as a median line of 60 to 75 characters and none over 80, set as 29.5 em of the text; grows the type scale with the window on a reading page (16 to 18 px body between 1,024 and 1,600 px); sets the column flush left beside the sidebar up to 1,120 px; and ships the code that measures these rules, which the site’s page check now runs unchanged. | |
| ADR-251: Flight log importers in two increments: the record every reader fills, a survey of the sample logs pinned by digest, and the PerfectFlite, AltOS and Raven readers first | The sample logs under refs/ number about 1,000 distinct files in some 20 layouts, too many for one increment. M7.1a builds the flight record every reader fills (every column a channel on its own clock, the logger’s events), a survey that reads every sample and writes a committed report of counts and anonymized ids, and readers for the PerfectFlite text exports, AltOS CSV and the Raven’s FIP CSV; M7.1b reads the rest. A private or unlicensed log is pinned by a digest of what was read from it, never by a snapshot of its values. | |
| ADR-252: The sidebar put away at every width, and page arrows that name their pages, from the product system’s Rev D | A review of the site found two things on a desktop window. The sidebar could be resized but not put away, and the page arrows were easy to miss: small icons at the window’s sides, at the foot of the page, far from the centered column. The product system’s Rev D lets a docs site’s table of contents be put away and brought back at every width, with the menu button or by dragging its edge to the window’s side, and keeps the choice from page to page. It puts the page arrows under the text, inside the column, as bordered buttons that name their pages. | |
| ADR-253: M7.1b in two: the RRC3’s, Eggtimer’s and Blue Raven’s CSV exports first, each unit a header leaves out decided from the file or stated as assumed | M7.1b listed every layout M7.1a left, about 30 families, too many for one increment. It now reads the three CSV exports with the most sample files among them, the RRC3’s, Eggtimer’s and the Blue Raven’s (173 distinct files), into the record M7.1a built; M7.1c reads the rest. A unit a header doesn’t name is decided from the file, such as an RRC3’s altitude from its pressure, or taken from the maker’s manual, and either way stated in a note the survey counts; a Blue Raven’s high-rate file, which holds no altitude, reads with an empty primary track. | |
| ADR-254: M7.1c in two: GPS tracks first (Featherweight’s GPS CSV, KML and NMEA), read with an empty primary track and each point on the clock the file gives it | M7.1c named about 27 families of sample logs, too many for one increment. M7.1c1 reads the three that record a GPS receiver’s track: Featherweight’s GPS tracker and ground-station CSV, KML, and NMEA 0183, 95 distinct sample files. None has a barometer, so each reads with an empty primary track and every column a channel. A point’s time is the one the file gives it, from a column, a sentence, a when or the comment a writer puts beside each point; a KML path that states no time keeps its points with their times as gaps. A KML altitude is in meters, as the KML standard sets, unless the file’s writer is known to write another unit. | |
ADR-255: M7.1c2 in two: four text loggers first (AltimeterCloud, Entacore AIM, PerfectFlite’s .pfa, an Eggtimer TRS’s terminal text), the rest to M7.1c3 | After M7.1c1, 26 families of sample logs, 503 files, still had no reader: binary downloads, spreadsheets, companion summaries, teams’ own CSV and text, and four text layouts a single maker writes. M7.1c2 now reads those four, 54 files: AltimeterCloud’s CSV and Entacore AIM’s, each with the generic csv family’s files in its layout moved to it by id, PerfectFlite’s .pfa and an Eggtimer TRS’s terminal text. M7.1c3 keeps the rest and the parent’s done when, in a planned order: club and app text layouts, raw downloads checked against their makers’ exports, AltOS’s raw files and the RDAS’s, then containers, summaries and the column mapper. | |
| ADR-256: M7.1c3 in two: three self-checking layouts first (AerospaceNU’s SillyGoose logs, Silicdyne Fluctus’s CSV, the ARTS2’s interpreted data), the rest to M7.1c4 | After M7.1c2, 22 families of sample logs, 449 files, still had no reader. ADR-255 ordered what was left: club and app text layouts first. A survey of those found three layouts whose units each file can settle, from its header, its maker’s manual or a check on its own values: AerospaceNU’s SillyGoose flight computer’s logs (14 files), Silicdyne Fluctus’s CSV (6, filed as generic CSV) and the ARTS2’s interpreted data (4, filed as generic CSV). M7.1c3 now reads those 24. The others in that group need a decision the files can’t make yet, and stay in M7.1c4 with the parent’s done when. | |
| ADR-257: Calibrated intervals for the flight readings and fits, and the post-flight comparison | M7.2’s “within the stated error” gains, and M7.3’s “within tolerance” becomes, one test: on at least 1,000 synthetic flights on fixed seeds, each stated 90% interval must miss on each side about 5% of the time and hold the truth about 90%, judged by 99.9% Clopper-Pearson bands, and the test must fail when the intervals are narrowed, widened or shifted. M7.3 also reports, on the public logged flights and the collection, apogee predicted from the log up to burnout beside the forward simulation’s, which fills a new scoreboard row, and draws the predicted and logged flight under launch-day conditions in one command, the analysis NASA Student Launch asks for after a team’s flights. | |
ADR-258: M7.1c4 in two: AerospaceNU’s flight computer board, a phone app’s launch CSV and an Eggtimer’s RTF first, the rest to M7.1c5 | After M7.1c3, 23 families of sample logs, 425 files, still had no reader. M7.1c4 now reads the group ADR-256 left open over unit questions, 52 files: AerospaceNU’s flight computer board’s CSV (20), its ground station’s text (4), a phone app’s launch CSV (27), and the one Eggtimer download saved as RTF (#520); the other two RTF files, a radio telemetry stream, move to M7.1c5. It also makes one rule for every reader: a value that a unit conversion turns infinite is refused (#518). M7.1c5 keeps the rest and the parent’s done when. | |
ADR-259: M7.1c5 in two: the Raven’s .FIPa and the RRC3’s .rff raw downloads first, each checked against its maker’s export; the rest to M7.1c6 | After M7.1c4, 23 families of sample logs, 376 files, were left to M7.1c5, 374 of them read by no reader. M7.1c5 now reads the two raw downloads whose makers’ exports of the same flights sit beside them, 63 files: the Featherweight Raven’s .FIPa (57) and Missile Works’ RRC3 .rff (6). Each raw file with an export beside it must match that export in every sample of every channel the two share: all 55 such .FIPa files and the one such .rff match, 6,019,645 raw samples, with no value off by any step. The rest, ARTS2’s raw data and .odf, the RTx’s files and the families ADR-258 listed, moves to M7.1c6 with the parent’s done when. | |
| ADR-260: M7.1c6 in two: Featherweight’s summaries first, each checked against the file beside it; the rest to M7.1c7 | After M7.1c5, 21 families of sample logs, 312 files, were left to M7.1c6, 310 of them read by no reader. M7.1c6 now reads the Featherweight app’s summaries of a Blue Raven’s or a GPS tracker’s flight, 48 files: every row is kept as a figure, in SI only where the unit it writes is one its name allows, and each summary’s stated maximum and pad altitude are checked against the file of samples beside it. 31 files that aren’t flight logs are filed as such: Debrief’s made-up flights, which say so, teams’ checklists, a Blue Raven’s settings sheets and a flyer’s own program’s reading of a log. The rest goes to M7.1c7. | |
| ADR-261: M7.1c7 in two: zip archives and two readers’ variants first; the rest to M7.1c8 | After M7.1c6, 233 sample logs in 16 families were left to M7.1c7, 231 of them read by no reader. M7.1c7 now unpacks the 8 zip archives, in memory and within a bound, and reads each file inside as a file of its own: 19 files no other source holds, 11 of them a Blue Raven’s files and summaries. It reads PerfectFlite’s text export written with no header row (4 files) and a CSV export that names its temperature Temp (1), and a Blue Raven high-rate file with no date (1). It files 16 more files as not logs, and one hand-edited Blue Raven file as damaged. The rest goes to M7.1c8. | |
| ADR-262: M7.1c8 in two: the R-DAS’s raw text first; the rest to M7.1c9 | After M7.1c7, 209 sample logs were left to M7.1c8, in families that each need a decoder or the column mapper. The largest, 54 files, is one layout: the raw text AED Electronics’ R-DAS flight computer’s Windows software exports, a configuration summary and then a table of the converters’ counts. M7.1c8 now reads it. The file holds no calibration, so every count is kept as written and the record holds no altitude; the clock is held to the configuration’s stated rate. The rest goes to M7.1c9. | |
| ADR-263: M7.1c9 in two: AltOS telemetry first; the rest to M7.1c10 | After M7.1c8, 155 sample logs were left to M7.1c9. Two of them are AltOS radio telemetry, the .telem files AltosUI saves of the packets a TeleDongle hears, and Altus Metrum publishes their layout. M7.1c9 now reads them from that document, with every unit it converts held to a second check, and the rest goes to M7.1c10. The document’s pressure unit is contradicted by the files, which hold pascals, not tenths. | |
| ADR-264: Typeset equations, from the product system’s Rev E | The site’s equations were plain Unicode text, in code blocks and code spans, which reads like a formula typed into a chat. The maintainer asked for equations set as a textbook sets them. Pages now write LaTeX between dollar signs; an mdBook preprocessor in xtask turns each formula into MathML when the site builds, with the math-core converter (MIT, pure Rust); the browser draws it in New Computer Modern Math, the face of LaTeX’s textbooks, served from the site. No script runs and nothing loads from another server. A formula the converter can’t read fails the build, and the page check fails one wider than its box. | |
| ADR-265: M7.1c10 in two: AltOS raw downloads first; the rest to M7.1c11 | After M7.1c9, 153 sample logs were left to M7.1c10. Fourteen of them are AltOS’s .eeprom files, the board’s own log as AltosUI downloads it, and nine have AltosUI’s export of the same flight beside them. M7.1c10 now reads them, their layout worked out from the files and held to those exports, every unit converted resting on a sensor’s data sheet and a second check; the rest goes to M7.1c11. | |
| ADR-266: M7.1c11 in two: ARTS2’s raw data first; the rest to M7.1c12 | After M7.1c10, 137 sample logs were left to M7.1c11. Six of them are an Ozark Aerospace ARTS2’s raw data: three .odf files, as its software DataAnalyzer saves a flight, and three raw CSV exports of the same records, each flight with DataAnalyzer’s interpreted export and an AltOS board’s log beside it. M7.1c11 now reads them, the .odf in units from the calibration it carries, held to its sensors’ data sheets and to a climb check, and to the files beside it; the rest goes to M7.1c12. | |
| ADR-267: M7.1c12 in two: Missile Works’ RTx first; the rest to M7.1c13 | After M7.1c11, 131 sample logs were left unread. Fourteen are a Missile Works RTx GPS tracker’s: five .rtx files, as mDACS saves a download, and nine CSV and text exports, eight of them beside an .rtx with the KML export of the same fixes. M7.1c12 now reads them, the .rtx’s words decoded from the files and held to every export beside them; the rest goes to M7.1c13. | |
| ADR-268: M7.1c13 in two: tables read by their headers first; the rest to M7.1c14 | After M7.1c12, 117 sample logs were left unread, most of them tables from teams’ own flight computers and scripts, each in its own words. Thirty-one of them, among them a Blue Raven file a person edited, name their units in their headers; M7.1c13 now reads such a table by what its header states, holds each unit to the column’s name and values, and takes a caller’s column mapping for the rest; spreadsheets and the other layouts go to M7.1c14. | |
| ADR-269: M7.1c14 in two: Excel workbooks first; the rest to M7.1c15 | After M7.1c13, 87 sample logs were left unread. The largest group one change can read is the 23 .xlsx workbooks: written out sheet by sheet, each cell as the workbook stores it, 16 of them read through the readers that exist; M7.1c14 now reads them, every cell held to an independent reader, and the rest goes to M7.1c15. | |
| ADR-270: M7.1c15 in two: EuRoC exports and mappings a publisher states first; the rest to M7.1c16 | After M7.1c14, 68 sample logs were left unread, in 19 layouts, the largest 7 files. Nine of them need little new code: three exports of known loggers saved by a European locale’s spreadsheet, and six tables whose publisher, RocketPy, states each column’s meaning and unit. M7.1c15 now reads them, refuses an Eggtimer file whose filtered altitude or clock shows its decimal points were lost, and leaves the rest to M7.1c16. | |
| ADR-271: M7.1c16 in two: binary records by a stated layout first; the rest to M7.1c17 | After M7.1c15, 59 sample logs were left unread. Five of them are a team’s binary records with the table the team decoded from them beside each: three captures of a flight computer’s serial shell dumping its flash as base64, and two raw files of records end to end. M7.1c16 reads files like these by a record layout the caller states, the names from that table and the types found from the bytes and that table. All 931,875 fields of the 45,915 records written match the teams’ tables. The rest goes to M7.1c17. | |
| ADR-272: M7.1c17 in two: the Blue Raven’s USB download first; the rest to M7.1c18 | After M7.1c16, 54 sample logs were left unread. Two of them are a Blue Raven’s recording as its USB port downloads it to a terminal, one line a sample, each closed by a CRC, in a layout the maker’s manual describes. M7.1c17 reads these, keeping only the records whose CRC checks, each held to its stated length, and reads each field by the manual where the record holds what the manual lists. All 354,284 values of the 19,636 records read agree with the survey’s own decoding. A third file is filed as a flyer’s copy of a summary, not a log. The rest goes to M7.1c18. | |
| ADR-273: The 2026-10-15 review: OpenRocket’s supersonic ogive drag as a cause | OpenRocket’s issue #3391 (2026-10-14) reports that OpenRocket 24.12 gives a tangent-ogive nose almost no pressure drag above Mach 1: about 0.0007 against about 0.13 at Mach 1.5 by the method its own technical documentation describes. HPR Sim found the same gap on a supersonic flight in its collection (#222) and left open which code was right. M2.3c6 splits the apogee gap to OpenRocket into thrust, mass and drag. Its drag part must now give this term on its own line: a public probe sets the two codes’ nose pressure drag beside the published equivalent-cone value, and the collection’s flights past Mach 1 report how much of the gap the term accounts for, with its sign. | |
| ADR-274: M7.1c18 in six: a course’s Teensy logger first, then the five increments left | After M7.1c17, 51 sample logs were left unread, in five groups. This record plans all of them at once, in six increments, the easiest to check first. M7.1c18 reads the 8 files of a university course’s Teensy data logger, one sensor’s reading a line, in two layouts. Where a file states no unit, the unit is held to the physics the files must keep: on every one of 305,340 Alt lines, the barometer’s altitude follows its pressure by the BMP180’s formula to within 5.4 mm (0.21 in); the accelerometer reads 0.983 to 0.989 g on the pad; and the time to apogee is 0.90 to 1.14 times √(2h/g). The other 43 files go to M7.1c19 to M7.1c23. | |
| ADR-275: Neer’s 2026-10-14 plan: awareness and care on the sites | The docs site, and then fusionspace.co, get a thin banner under the page’s strip and a line in the footer: heritage and awareness months, health and mental health, accessibility, science and space days, and rocketry-safety reminders. One banner at a time, chosen in the reader’s browser by date from a table whose every row names its organizer’s page. A region-specific observance names its region, a solemn day stands alone, nothing looks up where the reader is, and with scripts off nothing shows. A help page lists checked crisis lines, as WHO’s guidance on suicide prevention asks. A second increment adds a code of conduct, a page on getting involved and a way to report a barrier to access. | |
| ADR-276: Neer’s 2026-10-16 plan: a flyer’s own logger and GPX tracks in the analyzer | Release 0.2, the flight analyzer, must read a flyer’s own altimeter or GPS tracker from the command line and Python, not only from Rust, and must read GPX tracks. M7.1d1 reads GPX 1.0 and 1.1; M7.1d2 lets hpr analyze and the Python package read a table by a column mapping and binary records by a record layout, as the library already does. | |
| ADR-277: A track’s own speed, held by its vertical speed before apogee | M7.1c22’s done when names a track’s own speed among the physical checks that hold a mapped table’s units. A track’s ground speed holds none: the 4 tracks’ medians spread 21.34 times. Its vertical speed does. In the 5 s before apogee a coasting rocket slows at g, plus a little drag, so a parabola fitted to a GPS track’s fixes there must slow at 0.6 to 5/3 g. An altitude in feet stated as meters reads 3.28 times too high. The club’s GPS track slows at 0.9925 g, so that part of the done when is met. | |
| ADR-278: An evidence register: what backs each claim, and an open issue until a real sample does | The docs say honestly when a reader, model or check rests on invented samples, an assumption or another program alone, but nothing tracks finding the real evidence later: of the 24 distinct gaps the site stated on 2026-10-17, 12 had no issue, roadmap entry or research topic, 8 of them flight-log readers. Milestone M2.10 adds validation/evidence.toml, one row per claim with the kind of evidence behind it and the kind wanted, and a check that fails when a page states such a gap without a row, or a row short of a real sample has no open needs-sample issue. A report counts the rows by kind on the site, with no combined score. | |
| ADR-279: The 2026-10-17 review: fin flutter held to measurement, and intervals by design | HPR Sim’s fin flutter check, a safety output, is tested only against Martin’s own worked examples, and nothing shows which way it errs on a fin someone else measured (the evidence register’s row G22). A published wind-tunnel test found five identical composite fins fluttering at 19.6–21.5 m/s (64–71 ft/s); on that fin HPR Sim’s flutter speed reads about 10.7 m/s (35 ft/s), on the safe side. M2.11 scores HPR Sim’s flutter readings against at least three distinct measured fins from at least two research groups and against an independent BSD-licensed calculator; it states the largest error on the flattering side and the range the cases cover, and adds a flutter row to the scoreboard. | |
| ADR-280: M7.2 in seven, the synthetic flights first | M7.2 is split in seven: M7.2a draws 2,200 synthetic flights on fixed seeds (a tuning set of 200 and two test sets of 1,000, the second flying a model reshaped in drag, wind shear and thrust), each with its truth and the log one of six simulated loggers would write, by cited noise terms; the readings on every logger, the rest of the readings, the smoother, the 90% intervals, two recordings and stages, and ghost files follow; the readings, the smoother and the intervals are checked on those flights. | |
| ADR-281: Readings on every logger: one height track, a pad its samples can vouch for, and a top that must be a coast’s | The readings (liftoff, apogee, the top speed, landing) now come from every logger that records a barometric altitude or a pressure, each within a bound its error stayed inside on the synthetic flights’ tuning set, logged at every rate from 500 to half a sample a second, at every step to 10 m (33 ft) or 100 Pa, and from cropped starts, or withheld with one of 23 named reasons. A GNSS track gives none. Three rules carry most of the weight (below). On the 1,058 records the sample logs hold, apogee is given on 593, liftoff on 554, the top speed on 354 and landing on 472, and every reason has a case. | |
| ADR-282: The project tests each UI milestone itself | No milestone waits on the maintainer’s use any more. A milestone that adds or changes something a user sees counts as done once its PR records the project’s own acceptance pass: user tasks written before the work and done end to end on the built product by a reviewer that didn’t build it, every screen captured at its real size and shape and checked for clipping, and a cold reader’s run through the guide. The app and the field kit also post a short recording for the maintainer to look at, which informs but never blocks. Turning off his sites, publishing, tags and finding M10.5’s outside flyers stay his. | |
| ADR-283: The rest of the readings: an axial accelerometer settled by three witnesses, burnout where the thrust’s fall ends, and the main found back from landing at the ground’s density | The flight-log readings now add the top acceleration, burnout, the flight time and the descent under each canopy, each within a bound its error stayed inside on the synthetic flights’ tuning set or withheld by name. The top acceleration comes from an accelerometer along the rocket’s axis only. Burnout is read from the thrust’s fall through zero (a floor without an accelerometer), and the main’s opening is found back from landing at the ground’s density (below). Of the 1,058 records the sample logs hold, the top acceleration is given on 161, burnout on 428, the drogue’s descent on 267 and the main’s on 459, and every new reason has a case. | |
| ADR-284: The maintainer’s own voice on every page | The project’s pages read as if they came off a template, not from a person. M0.14 rewrites what people read (the README, the docs site, fusionspace.co, the design system’s writing rules and README, hpr’s own messages and the repositories’ About text) in the maintainer’s plain voice, with a voice section in the writing guide and a cargo xtask voice check. Decision records, the archive and tools due to be replaced stay as they are. | |
| ADR-285: The rest of the site in nine increments, each held to the voice limits as it lands | The 71 site pages M0.14c covers hold 413,377 words, too many for one rewrite. They go in nine increments by the site’s sections. From the first, cargo xtask voice fails when a page M0.14 has rewritten goes over a voice limit or misses the guide’s sentence targets, so a page that passes stays passing while the rest are done. The last increment holds every site page, a new one included. | |
| ADR-286: The 2026-10-20 review: the export bar tightened | In the corpus, the only apogee differences OpenRocket shows between a design and HPR Sim’s export of it are OpenRocket’s own run-to-run spread, 0.00051% on the most sensitive configuration, while a probe that rounded every number to six decimals still passed the 0.5% bar, so the bar is tightened to 0.002% and the planning review places four new ideas. | |
| ADR-287: ThrustCurve.org’s motor records used as published facts | ThrustCurve.org’s motor records are published facts about motors anyone can buy, so the project uses them, from the site, its API or the site’s 2016 sample dump, with ThrustCurve.org’s credit; curve files marked public domain or with no license may be committed too, files marked “free usage” or “other (restricted)” are fetched only when a user asks, and every accuracy check stays. | |
| ADR-288: Every solid motor ships in the package | M5.7 will compile ThrustCurve.org’s solid-motor catalog into hpr-motor: every record, and every curve file HPR Sim reads but a restricted one, so no motor in the snapshot needs a fetch. Each file carries its check against its motor’s published figures. A motor’s default file passes where one does, and flying a failing file warns. hpr motors update adds newer motors and files when online. Until then, 32 motors come built in. | |
| ADR-289: The 2026-10-24 review: the RocketPy speed and apogee gates tightened | In the RocketPy comparisons flown on the same inputs, the burnout, largest, rail-exit and landing speeds agree within 0.056% and the apogees of the six flights with no written model difference within 0.113%, while RocketPy’s own solver moves them by at most 0.0032% and 0.00064%; a 3% gate was 53 times the largest speed difference, so they become 0.2% and 0.5%, and the planning review places four new ideas. | |
| ADR-290: The control abort’s 30° measured from the launch elevation, and TP-1353’s aileron points to Mach 2.96 | The airbrakes and roll surfaces go inert on an attitude more than 30° from the launch elevation, as the IREC student competition’s 2026 rule §7.3.1 words it, not 30° from vertical. M6.5’s supersonic tab check compares against NASA TP-1353’s tail-fin ailerons from Mach 1.6 to 2.96, the range of the report’s Figure 18 points. | |
| ADR-291: The bench’s chamber band from Fetter’s seven printed peaks | The ground-test bench’s (M13.7) seven 0.5 g black-powder shots in an empty chamber must give a mean peak from 23.68 to 33.85 psi (28.76 ± 5.08), the band from the seven peaks in Fetter’s 2025 ejection-testing paper (Fig. 7-5) and their sample deviation; a correct logger lands inside about 93% of the time. The figure’s printed mean and deviation, 28.49 and 4.04 psi, don’t match those peaks. The band is fixed, so a logger whose shots scatter more doesn’t get an easier test. | |
| ADR-292: The program’s words in four increments, the help first | M0.14d covers hpr’s help, its warnings and errors, the Python package’s docs and each crate’s top-level docs. That’s too much for one rewrite: the help is about 4,400 words, but the messages are about 270 error types and 80 to 90 places that push a warning, in 14 crates. They go in four increments. The help comes first, with a snapshot of each command’s --help that cargo xtask voice reads and holds to the voice limits, as the site’s pages are held. | |
| ADR-293: Cavour’s log read to its apogee event | Cavour’s real-flight record reads its log only up to 23.6 s, the first row its ground station tags as the drogue event. After that row the radio telemetry’s filtered height jumps 8 m (26 ft) in 0.2 s, faster than the rocket can climb, about 2 s before the drogue charge most likely fires. So the logged apogee is the coast’s peak, 2,785 m (9,137 ft), not the jump’s 2,789 m (9,150 ft). Cavour’s error rises from +5.63% to +5.78%, and the mean absolute apogee error over the seven flights rises from 6.04% to 6.06%. | |
| ADR-294: The 2026-10-26 review: the RocketPy times, burnout heights and traces tightened | In the RocketPy whole flights flown on the same inputs, the rail-exit times agree within 0.143%, and in the six flights with no written model difference the apogee times within 0.239%, the burnout heights within 0.049% and the height and speed traces within 0.272% of RocketPy’s apogee and 0.153% of its top speed, while RocketPy’s own solver moves the point metrics by at most 2.4e-5 of their value; so those 33 gates go from 3% to between 0.2% and 1%, each at least 3.2 times the largest difference measured. These bound agreement between two codes on RocketPy’s example rockets, not accuracy against a flight. | |
| ADR-295: The rest of the words in four increments, joined names and long warnings first | M0.9f holds the site, the README and hpr sim’s warnings to seven writing rules that #476 lists. Fixing them all is several sessions’ work, and two of the rules add bytes to a search index with 71 bytes to spare. So it goes in four increments: joined names and long warnings first, then long notes and table heads, which make room in the index, then grouped figures and prose dates, and last the no-break space between a figure and its unit, joined in the built pages after mdBook writes its index. | |
| ADR-296: What the words leave: the figures’ digits and the command line’s words, M0.9g | Ten rows of the design audit named M0.9f for gaps outside its done when: figures quoted to more digits than are known (#966), and the command line’s and the plot’s words, which no check reads (#973). M0.9g holds both, queued after M0.13. | |
| ADR-297: A table too wide for its column stacks its rows | A table wider than its column no longer scrolls sideways in its box. Its rows stack, each cell labeled by a copy of its column’s head, and the page check fails a table that still scrolls, at every width from 320 px. | |
| ADR-298: Every solid motor in four increments, each file’s check first | M5.7 compiles ThrustCurve.org’s whole solid catalog into hpr-motor (ADR-288). It is several sessions’ work, and its first bullet needs a fresh snapshot from ThrustCurve.org’s API, which has answered HTTP 503 since 2026-10-25. M5.7a builds each file’s stored check, the default-file rule and the warning on the 32 bundled files first; M5.7b compiles in the fresh snapshot; M5.7c holds every passing file to the oracles; M5.7d adds hpr motors update and the motor page’s figures. | |
| ADR-299: Withdraw the smoother to land it again in order | M7.2d, the smoother, merged in #983 before the captures of the pages it changed were looked at, as ADR-282 requires before a merge. The look found the health card’s lines cut at their box’s edge, which #986 fixed after the merge. Both are reverted, the tree going back to the commit before #983, and one PR lands the two again with every check run before its merge. M7.2d’s roadmap entry goes back to open until then. | |
| ADR-300: The smoother and its check on the synthetic flights | hpr_flightdata::smoother fuses a log’s barometer, accelerometer and GNSS receiver in a Kalman filter run forward and a Rauch-Tung-Striebel pass back, and gives the height and vertical speed at every sample with a standard error. cargo xtask synthetic holds it to the truth of the three synthetic sets at burnout, the top speed, apogee and a drawn moment, and fails unless every cell holds on every set and logger, the pass back solves every step, and trusting the GNSS receiver from liftoff fails on both test sets. Its 90% intervals hold on all three sets: between 94.3% and 99.4% of the truths lie inside each set’s cells. | |
| ADR-301: The whole catalog in two increments, the index before the lookups | ThrustCurve.org’s API answered again on 2026-10-28, and a fresh snapshot was taken: 1,004 solid motors and 1,706 files. Compiling it in is one session’s work; switching every lookup to it is another, because it moves flights, shared names and reports. M5.7b1 compiles the snapshot in, with each file’s check, beside M5.7a’s 32 motors, which the lookups keep using. M5.7b2 switches the lookups to the whole catalog. | |
| ADR-302: Every motor by name, offline | Every lookup now reads the whole bundled catalog: 1,004 motors, 924 of them with a curve file. A name two makers use, by designation or common name, takes its maker (Estes C6); within one maker a designation outranks a common name. Each motor gets a selector, a name that finds it alone. A motor with no curve is listed and refused, not hidden. A bundled default file more than 5% light on propellant warns, as a fetched one does. cargo xtask motor-catalog --check lists and flies every motor offline, with counts from the raw snapshot. | |
| ADR-303: The 2026-10-28 review: the RocketPy peaks tightened | In the RocketPy whole flights flown on the same inputs, the largest Mach numbers agree within 0.235% and the largest accelerations under power, outside Bella Lui’s two flights, within 0.248%, while RocketPy’s own solver moves them by at most 9.1e-6 and 2.7e-4 of their values. Each bound goes from 3% to 1%, 4.3 and 4.0 times the largest difference. Bella Lui keeps 3% on its accelerations for the cause its case file measures. A test pins every bound. | |
| ADR-304: Every passing file held to the oracles | The 1% test against each file’s record and the test against ThrustCurve.org’s own statistics code run over all 412 files stored as passing, with the code’s fixture holding exactly those. HPR Sim reads two samples at one time as a step, and ThrustCurve.org’s code as one averaged point. HPR Sim keeps the step, and the code with its merge turned off matches it to 3e-15 on every file; the test names the 6 files the merge moves. A recount from the raw snapshot, with ThrustCurve.org’s code, agrees with the index on all 1,700 files it holds. cargo xtask motor-catalog --check fails over 1%, worked out again from each file’s bytes, and runs in CI. | |
| ADR-305: Neer’s 2026-10-28 licensing calls: vendors’ published sizes and masses as facts, and which holds stay | Dimensions and masses a parts vendor publishes are facts, used with credit, as ADR-287 reads ThrustCurve.org’s records; no photo, drawing or descriptive text is copied and no vendor is contacted, so M5.6b needs no question to vendors. The motor finder’s real test records come from the 2026-10-28 snapshot hpr-motor ships, and the held catalog file is cleared. CATS’s log layout, RASAero II’s design files and the guide’s real-flight trace each get a route for when their work comes up. Featherweight’s Bluetooth packets, makers’ data sheets, Wyoming soundings and the refused references stay as they are. The orhelper migration idea is dropped. | |
| ADR-306: Withdraw the motor update to land it again in order | M5.7d, hpr motors update, merged in #1040 before the captures of the pages it changed were looked at as ADR-282 requires: the look before the merge took more captures than its limit, before the site’s clipping check. A look done right after the merge found no clipping beyond #1043’s. As with ADR-299, #1040 is reverted and one PR lands it again with every check run before its merge. M5.7d’s roadmap entry goes back to open until then. | |
| ADR-307: Newer motors found by comparing ThrustCurve.org’s whole catalog with the bundle | hpr motors update asks ThrustCurve.org’s search for every motor at once and compares the solid ones with the bundled catalog by id, file count and update day, downloading only the motors that may differ. Its date filters aren’t used: one of them matched nothing on 2026-10-29. A newer motor is found offline after the update; a newer file of a bundled motor is only cached, and the bundled file keeps flying. | |
| ADR-308: M7.2e in four: the intervals by reading, then the surfaces | each reading’s 90% interval runs from the reading less one share of its own bound to the reading less another. The two shares are the 5% and 95% points of the readings’ errors as shares of their bounds, fitted on a calibration set of 2,000 synthetic flights on a seed of its own. cargo xtask synthetic fits them again, holds them to the library’s, and runs ADR-257’s test with its three probes on sets A and B. M7.2e1 does this for the apogee’s height and time; e2 and e3 add the other readings; e4 takes the intervals and the smoother’s health card to hpr analyze and Python. | |
| ADR-309: A fin tab weighed as its file states it | a fin tab may start ahead of its root’s leading edge or end past its trailing edge. | |
| ADR-310: The 2026-10-31 review: the RocketPy rail-exit and landing speeds tightened | In the RocketPy comparisons flown on the same inputs, the rail-exit speeds agree within 0.0144% and the landing speeds within 0.0301%, while RocketPy’s own solver moves them by at most 3.13e-5 and 8.6e-7 of their values. The bounds go from 0.2% to 0.05% and 0.1%, 3.5 and 3.3 times the largest difference. All nine rail-exit speeds read low, the cautious side, for two causes measured here, and a test stops one reading high. These bound agreement between two codes, not accuracy against a flight. | |
| ADR-311: The 2026-10-31 review: every flight OpenRocket flies, and CI’s long checks | On the private collection OpenRocket 24.12 flies 79 of the 83 flights that come from a .ork and HPR Sim 68, which no scoreboard row shows. A new row, coverage.collection, and a milestone before the gap is split by cause, close that. CI’s long report checks now run from an optimized build with debug assertions, split by set over two jobs on every platform, with a test that fails if a set is left out. | |
| ADR-312: Two logs on one timeline: the offset’s error, the new sets, a booster’s truth | two logs of one flight, or one logger to a stage, go on one timeline by a shared | |
| ADR-313: Ghost files: the log’s own height, three formats from one track, outside readers in Node | hpr analyze --ghost writes a flight’s logs as time-synced trajectories in a frame at | |
| ADR-314: M7.3 in five: residuals first, the simulation read as the log is | M7.3 is more than one PR, so it goes in five parts: residuals, the least-squares fit with its coverage test, the Bayesian option under the same test, the report with apogee predicted from the boost, and the post-flight plot. Residuals come first because the rest stand on them. They rest on one rule: the simulated flight is written out as a noise-free log and read by the same reader as the real log, its height as the real log’s sensor would read it, and both clocks are lined up by what that reader calls liftoff. | |
| ADR-315: The 2026-11-01 licensing layers: the engine stays open, hosted services carry their own terms, and M9.0 sets the app’s license | The code that computes and checks FusionSpace HPR’s numbers stays MIT OR Apache-2.0. Hosted services, starting with the motor stock API at motor.fusionspace.co, carry their own terms: free for personal use and for FusionSpace’s own tools, with written permission needed for any other site, app or service and for any commercial use. The app’s license is chosen in M9.0’s decision record, before any app code is public; the leading option is the Functional Source License 1.1 with Apache-2.0 as its future license. Registering a FUSIONSPACE trademark stays deferred. Amended 2026-11-03: the motor stock API is open again, its data under CC BY 4.0 for any site, as before 2026-11-01; §1, §3 and §4 stand. | |
| ADR-316: M7.3b: the least-squares fit, what it solves for and how its intervals are held | Levenberg-Marquardt fits drag, impulse, a constant wind and mass to a log, with the | |
| ADR-317: M7.3c in two: the posterior’s sampler, then the test | the Bayesian option draws each flight’s posterior by importance sampling around the | |
| ADR-318: The 2026-11-02 review: the cause-free apogees tightened | In the RocketPy comparisons flown on the same inputs, the six apogees with no written model difference agree within 0.1123%, while RocketPy’s own solver moves an apogee by at most 6.35e-6 of its value. The bound goes from 0.5% to 0.35%, 3.1 times the largest difference. All nine same-drag apogees read high, the cautious side for a waiver, and a test now stops one reading low. These bound agreement between two codes, not accuracy against a flight. | |
| ADR-319: The 2026-11-04 review: the RocketPy descents tightened | In the RocketPy descents flown from the same state under the same devices, the 17 numbers held here agree within 0.0857%, while RocketPy’s own solver moves them by at most 3.41e-6. The bound goes from 3% to 0.3%, 3.5 times the largest difference. A drag area 1% too large now fails each of the four descents held to 0.3%; at 3% they passed. RocketPy counts the air a parachute drags along and HPR Sim doesn’t: a small difference on these four, a large one on NDRT 2020, whose descent time differs by 0.705%. NDRT 2020’s descent and Valetudo’s drifts, made by the Earth’s rotation alone, keep 3%. These bound agreement between two codes, not accuracy against a flight. | |
| ADR-320: M7.3c2 in two: the Bayesian option draws the wind first and integrates the sensor out; its raw intervals don’t pass yet | M7.3c1’s one Student-t about the least-squares answer kept a median of 14 effective draws in 300 on set A’s first 60 flights, as the wind’s ridge bends on heights alone. So the wind is drawn first and the rest about one Gauss-Newton step in that wind; a pilot widens the proposal where the posterior reaches further; the four linear sensor unknowns integrate out; on heights alone the wind’s shear is drawn, uniform from 0 to 0.2. On 1,000 flights of each set the raw 90% intervals pass 4 of the 10 counts: set A’s drag and set B’s impulse fail, and the wind is too wide on both. So M7.3c3, the option counted, is met; M7.3c4 keeps the intervals passing. | |
| ADR-321: M7.3c4 in three: the track as a receiver reports it, then the drag on heights alone, then every count | ADR-320’s posterior took the track’s noise as the least-squares fit states it, at least 10 m (33 ft), and its wind intervals came out too wide. Its own noise made them too narrow; reading the receiver’s filter, centering the draws and integrating out the pad’s position brought them in. So on a log with a track the posterior now reads the drift through a second-order filter of stated range and integrates out the track’s noise, its run from bin to bin and the pad’s position. The wind’s four counts now pass, and no count that passed before fails. M7.3c4 is split in three: M7.3c5 the wind, M7.3c6 set A’s drag, M7.3c7 every count. | |
| ADR-322: The 2026-11-05 progress review: accuracy before reader-facing work | In the four weeks to 2026-11-05 the measured accuracy did not move: FusionSpace HPR’s mean absolute apogee error on the private collection’s 60 logged flights is 12.07% against OpenRocket 24.12’s 11.26%, a gap of 0.8 to 0.9 points since 10-08, and no aerodynamics fix has closed since 10-15. There are no outside users yet. The work goes to what is hard to add later, correct numbers and accuracy against real flights, and holds what matters only once someone reads it: the 0.2 release, the sites’ calendar banner, the figures’ digit check. Next: M7.3d, its fits split by the held-out halves, then M2.7, M7.5, M2.3c6 and M1.14. | |
| ADR-323: The transonic margin warning, and shorter known-issue lines | From Mach 0.8 the fins’ straight-line join puts the center of pressure aft of a wind tunnel’s, by 0.6794 and 1.343 calibers on two Arcas Robin models at Mach 0.9, so the flight margin reads high, and nothing warned. Every flight with a margin past Mach 0.8 now warns (#1198). To keep the guides’ example output inside the search index’s 10 MB limit, a known issue’s text line leaves its address to one help: line, and the always-on warnings are shorter; #18’s message now says its 3.6% is of the friction, not the drag. #414 comes before any further prose. | |
| ADR-324: One full gate a pull request, and the site step on prose left to CI | The gate (scripts/gate.sh) is the maintainer’s local run of most of CI’s checks; a full gate runs every default step. A pull request passes one full gate before it opens. A later commit, such as a review’s fix, passes the steps it touches and CI on its head, unless main is merged in. Main gets its own full gate, with the checks on the private reference data, on each new tip of main before the next piece of work. The gate’s default run leaves the site step out when a branch changes only the words of pages: CI builds and checks the site at every width on every pull request, and a merge needs it to pass. | |
| ADR-325: M7.3d2, apogee predicted from the boost on the public flights | The 7 public flights’ logs are fitted whole where the apogee reads (6) and up to the boost’s cut where there’s a prediction (2), in each flight’s ERA5 air. Two flights get a prediction, with a mean absolute miss of 3.03% where the forward simulation’s is 6.89%. Only NDRT 2020’s is the case the method is meant for, cut after its burn on a log under the transonic limit: −3.88% against +10.40%. Hartigan’s exact sign-flip interval on the difference is unbounded below 6 flights. On these logs the cut can fall inside the burn: 4 of the 5 cuts do (Bella Lui’s 0.18 s short of its end), Lince’s among them, measured and reported, not fixed here (#1307). | |
| ADR-326: M7.3d3 in four, the halves sealed first | The private collection’s held-out flights are fixed by ADR-322’s encoding, and the SHA-256 of their sorted ids is committed on its own, before any half’s number exists. Each flight’s log is chosen from its pinned logs by the apogee nearest the one the collection states, read and cut at the boost, counted over the whole collection only: of 72 flights not left out, 64 have a barometer’s log the analyzer reads an apogee from, 32 are cut, 30 refused at the transonic limit and 2 for a log slower than 8 Hz. The fix to the cut (#1307), the collection’s errors by halves and the scoreboard row follow, in that order. | |
| ADR-327: M7.3d5, the fall must hold and still fall | The boost’s cut waits until the climb speed’s fall has held 0.75 s and the speed is the lowest of those 0.75 s. On the public logs no cut falls inside the burn now (4 of 5 did): Bella Lui and NDRT 2020 are cut after their burns, and the other 5 reach the transonic limit first. Set A’s cuts come 1.08 s to 2.30 s after burnout, inside the 2.83 s bound; 1,787 of 2,295 dipped synthetic logs fall by the cut’s amount before burnout; each is cut after burnout or refused as transonic. The collection: 26 cut; none of the 20 whose burn and liftoff are known is cut inside its motor’s burn. | |
| ADR-328: The 2026-11-08 review: twelve public flights, predictions first | HPR Sim’s accuracy against public real flights rests on 7 flights, all from RocketPy’s examples. Five more public flights can join them: RocketPy’s Astra, Andromeda and Erebus 11, once their netCDF-4 weather is read and their designs are built from the examples’ inputs, and two MIT-licensed flights of one OpenRocket design. The new milestone merges each new flight’s inputs and predicted apogee in a pull request of its own before any of their errors is computed, then puts accuracy.public and bias.public over the 12. It changes no model and loosens nothing; it raises how many real flights the public numbers rest on, from 7 to 12. | |
| ADR-329: M7.3d6, the collection’s errors by halves | Each private collection flight with a cut log, among the flights the forward report compares, goes to the fit up to its cut, on the flight as fixture-flights flies it in HPR Sim, and is flown on to apogee: 21 predicted, 12 in the calibration half and 9 held out; 1 has too little up to its cut to fit. The prediction’s mean absolute apogee error is 3.22% in the calibration half and 3.56% in the held-out half, against the forward simulation’s 9.35% and 16.86% on the same flights; the paired bootstrap 95% intervals on the difference are −10.07 to −2.70 and −19.01 to −7.97 points. The held-out half’s fit aggregates stay private; their file’s SHA-256 is committed and checked. | |
| ADR-330: M7.3d7, the from-boost scoreboard row | The scoreboard gains accuracy.from-boost, the mean absolute error of the apogee predicted from the log cut after burnout: HPR Sim 3.22% on the 12 calibration-half flights it can predict, with a note on which flights and the forward simulation’s 9.35% on them. OpenRocket and RocketPy say can’t, by their documentation. | |
| ADR-331: Withdraw the from-boost row to land it again | #1365, the scoreboard’s accuracy.from-boost row, merged with seven commits that came after its last review; #1368 then tightened the row’s test. From here, a pull request merges only once each review it needs has read its last commit, so both are withdrawn and land again together with their reviews first. While withdrawn, the scoreboard has no accuracy.from-boost row. | |
| ADR-332: M2.7 in two, the halves and the fits’ guard, then predictions first | The private collection’s report gives its apogee errors over both halves, as aggregates: of the 60 flights compared, 37 are in the calibration half and 23 held out. A fit across the collection’s flights must take its flights through a guard that reads each flight’s half from its id again and refuses a held-out one, so cargo xtask fixture-flights --check fails when a held-out flight reaches a fit that takes it: the calibration half’s fit aggregates, and the report’s calibration half, by which the scoreboard’s check now holds its collection rows. New flights predicted before their logs are compared are the second increment. | |
| ADR-333: M2.7b, new flights predicted first | A flight the private collection’s manifest gains after M2.7a is compared with its log only when the collection holds its prediction, written from the flight’s plan alone, and that file’s SHA-256 sits in validation/reports/predictions.sha256 where the branch last took main, so it merged in an earlier pull request; otherwise fixture-flights refuses it by id. A committed digest of M2.7a’s 83 manifest ids tells a new flight from an old one. Shown on an invented flight; no flight is new yet, so the list is empty. The scoreboard’s held-out rows read the fixture report’s held-out half, HPR Sim 16.32% and OpenRocket 24.12 14.98% over 23 flights (bias +13.42% and +11.68%), shown, not held. | |
| ADR-334: M2.3d1 in three, the EuRoC 2022 predictions first | HPR Sim can’t fly the Macie XL design yet: its stage’s mass override adds to its parts, and HPR Sim holds such a stage back. So the five predictions merge in two pull requests, and no error is computed until both have merged. This record merges the first three, flown from their example notebooks in their launch hours’ ERA5 air: Astra 3,037.1 m (9,964 ft), Andromeda 3,581.0 m (11,749 ft) and Erebus 11 2,714.1 m (8,904 ft), as their altimeters would read them. Andromeda is counted on its team’s thrust file and tagged not traced; the catalog motor’s 3,050.3 m (10,008 ft) is shown beside it and never counted. | |
| ADR-335: A stage’s added mass, as OpenRocket weighs it | The .ork reader no longer holds back a stage whose mass override doesn’t cover its parts. OpenRocket 24.12 adds such a mass to what the parts weigh, as a point: at the center of that stage’s parts, or at the stage’s center of gravity override when that doesn’t cover the parts either. The design holds that mass as the stage’s added mass, and on 19 probes HPR Sim’s structure matches OpenRocket’s: the center within 0.2 µm, the mass and the inertias within 3 parts in a million. A motor aboard doesn’t move the added mass. Where an override covers the parts, the inertia stays HPR Sim’s own rule: on such stages’ probes, from 11.04% under OpenRocket’s to 400.5% over. | |
| ADR-336: M2.3d4 in three, the inertia and the refusals last | A stage in an OpenRocket file can carry a mass override and a center of gravity override, each covering the stage’s parts or not. M2.3d4’s done when holds such a stage’s inertia to OpenRocket’s and has it held back no longer. The merged work fell short twice. Where one override covers the parts and the other doesn’t, HPR Sim kept its own inertia rule: from 11.04% under OpenRocket’s to 400.5% over on eight probe designs. A few such stages are still refused. This record reopens the milestone: M2.3d6 is what merged, M2.3d7 the inertia, M2.3d8 the refusals, and, after ADR-340, M2.3d9 the inertia on a lower stage and with a motor. M2.3d4 is met when the last three are. | |
| ADR-337: The Macie XL predictions, each flight’s stored simulation flown as saved | The last two of the five new public flights are predicted: both flights of Macie XL, one OpenRocket design in a public repository. The repository gives no weather or rail, and of the launch site only each log’s pad height, so each flight is flown as the stored simulation its repository names for it, from the design file as OpenRocket 24.12 saved it. HPR Sim predicts 706.2 m (2,317 ft) for flight 1 and 692.6 m (2,272 ft) for flight 2, as their altimeters would read them. Both are tagged not traced. No error is computed. Flight 1’s motor now flies the bundled curve file the design’s digest names, which is not the catalog’s first file. | |
| ADR-338: The 2026-11-11 review: descent rates held to the logs, predictions first | Every scoreboard row that reads a logged flight reads its apogee. A rocket’s descent rate under its parachutes sets its landing speed and its drift, and HPR Sim’s is held to other simulators and to drop tests, not to flights. The analyzer reads each canopy’s rate from a log. On the five public flights that have both, the simulated rate under the main runs from 7.59 m/s (24.9 ft/s) slower than the log’s to 1.07 m/s (3.5 ft/s) faster. The milestone scores the private collection’s flights likewise, after the comparison’s rule and each flight’s predicted rates are merged, so each prediction is fixed before anyone sees its error. The scoreboard gains rows for the rate’s error and its sign. | |
| ADR-339: M0.17, the docs site at the tool level, queued second | The product system the docs site is pinned to now has three levels: front pages, tools and records. A docs site is a tool: it keeps what the drawing means (line types, trust notes, signal colors, units) and leaves off the drawing’s frame. The site still wears the whole record: a designation tag over each title, sheet numbers and a title block at the foot of every page. Issue #1364 asks for the move, and it is a milestone’s work, not an issue’s. This record adds it as M0.17 in two increments, the frame off and then a fourth color theme, Field, and queues it second, where the maintainer asked for it. | |
| ADR-340: A stage’s overrides leave its parts in place, as OpenRocket weighs them | A .ork stage whose mass or center of gravity override covers its parts now keeps the parts where the design puts them, as OpenRocket 24.12 does. Its inertia is the parts’ about the stage’s center. Before, HPR Sim moved and rescaled the stage as one body. On six of M2.3d7’s eight probes the inertia now matches OpenRocket’s within ADR-336’s bounds; it ran from 11.04% under to 400.5% over. On the two with the override on a lower stage, OpenRocket’s figure is below what the stage’s parts alone have about its center: the rocket’s inertia across the axis is now 4.95% and 3.33% over (it was 1.5% and 18.5%), pinned. The collection’s mean absolute apogee error goes from 12.07% to 12.04%. | |
| ADR-341: M2.3d8 in five, a parallel stage’s added mass first | A parallel stage in an OpenRocket file, boosters strapped beside the core, can carry a mass override that doesn’t cover its parts. HPR Sim warned of one and held the design back. It now reads it as OpenRocket 24.12 weighs it: one mass added to the set of boosters, at their center or at a stated station. Of 49 new probe designs HPR Sim lays out 27, and on the 25 of those with boosters the parallel stage alone matches OpenRocket’s mass, center and both inertias. The probes also show cases this change doesn’t fly, so M2.3d8 is split in five, and four increments stay open. | |
| ADR-342: The errors before the remaining OpenRocket-parity probes | The five public flights whose predictions were merged first are now compared with their logs. cargo xtask real-flights flies all 12 public flights and prints each of the five merged predictions beside its log’s apogee and its error: Astra −6.53%, Andromeda +4.14%, Erebus 11 −9.58%, and the two Macie XL flights −16.20% and −29.16%. Over the 12 the mean absolute apogee error is 9.00% and the mean with its sign is −4.91%; over the seven compared before, they were 6.06% and −0.22%. No prediction was revised. The work left on how an OpenRocket file’s stage overrides are read moves behind the accuracy work: it checks HPR Sim against OpenRocket on probe designs, and the logs are what decide accuracy. | |
| ADR-343: The docs site drawn as a tool: the frame off | The docs site follows the product system at dd7552f, the commit that gave it three levels, and is drawn as a tool. Pages lose the designation tag and the sheet numbers; each ## section is a part under a 2 px rule. Every page but the print page ends with a one-line footer: the mark and “FusionSpace HPR”, the version, the date of issue, the site’s status chip and a link to Start here. Start here keeps the title block as the site’s about box, and the print page still ends with it. Labels, navigation, note heads, chips and the switch are in Archivo, in sentence case, at the system’s web sizes; CAUTION and WARNING keep capitals, in the wide cut. | |
| ADR-344: M0.17b in two: Field first, then the restyle’s acceptance pass | M0.17b asks for two things that each take a session: a fourth color theme, Field, read by the page check at every width as light and dark are, and the acceptance pass for the whole restyle of the docs site. This record ships them one after the other. M0.17b1 adds Field to the theme switch and to the page check. M0.17b2 runs the acceptance pass over M0.17a’s and M0.17b1’s work and closes issue #1364. | |
| ADR-345: The restyle’s acceptance pass and its fixes | A reviewer that didn’t build the restyle ran ADR-344’s six tasks on the built site, and a cold reader did them from the guide alone. At 320 px the keyboard couldn’t reach the menu button, focus rings were cut at the column’s edge, and code blocks hid their lines’ ends. The captures of every page the tasks reach found a code block cut beside the open table of contents and the header left over a page’s end on a phone; checking the cold read found a table of contents shut with reduced motion still a keyboard stop. This record fixes them, adds a page-check rule and canaries for each, and answers the cold read’s findings in the site’s words. | |
| ADR-346: M7.5 in three: the rule before the fit | The correction of the bias the simulators share is two scales: one on the motors’ impulse, pooled from what the calibration half’s logs alone say of the boost, and one on the drag, from those flights’ coasts. Each enters only if its 95% interval excludes 1. It ships only if it lowers the mean absolute error and the absolute bias on the held-out half and makes neither worse on the public flights, with and without the flights whose logs and files disagree by more than NAR’s retest rule allows. This record is merged before that fit is run. Its own increment splits each half’s forward error at the boost’s cut and reads the calibration half’s logs alone. | |
| ADR-347: The 2026-11-14 review: landing points held to tracked landings, predictions first | hpr sim prints how far from the pad a rocket lands, and no report sets that against a real flight. 41 of the private collection’s 83 flights are cataloged with a latitude and a longitude column or as a tracker’s file (no track has been read yet), and each has the day’s winds by height. The milestone reads each track’s pad and landing points, merges them and each flight’s predicted landing point before any error is computed, then scores the miss. The scoreboard gains a row for the miss and a row for whether the predictions land short. A landing predicted nearer the pad than the real one is the flattering side. | |
| ADR-348: M7.5b’s verdict: the shared-bias correction fails on the public flights, and nothing ships | Fitted on the calibration half as ADR-346 fixed it, the correction is an impulse scale of 0.94 with the drag left at 1, in the fit without the flagged flight. It lowers the held-out half’s mean absolute apogee error from 16.26% to 10.91% and its mean error from +13.36% to +5.84%. Both fits pass all four held-out sets. On the 12 public flights it raises the mean absolute error from 9.00% to 12.16% and takes the mean error from −4.91% to −12.01%; the other fit does worse. The rule asks that the public flights get no worse, so the verdict is a fail. The held-out half’s sealed fit aggregates are published, their file matching its committed hash. | |
| ADR-349: M2.3c6 in four: the public nose probe first | The gap to OpenRocket by cause needs four things the tree lacks: a public probe of the tangent-ogive nose’s pressure drag, OpenRocket’s thrust, mass and drag along its own flights with a way for HPR Sim to fly them, the split in the fixture report, and the nose’s own line. Each becomes an increment. The probe ships first: on an invented fineness-3 tangent ogive, OpenRocket 24.12 gives the nose a pressure drag coefficient of 0.00098, 0.00073 and 0.00047 at Mach 1.3, 1.5 and 2, where HPR Sim and the equivalent cone give 0.1557, 0.1303 and 0.1042. | |
| ADR-350: M2.3c13’s result: the tangent-ogive nose’s line, and why #222’s flight is not in it | Five of the 68 flights both simulators fly pass Mach 1 with a tangent-ogive nose, and all five are swapped. With HPR Sim’s pressure drag of the nose replaced above Mach 1 by OpenRocket 24.12’s, the nose’s line is −1.28% of OpenRocket’s apogee on average, inside a drag part of −1.96%. Those flights reach Mach 1.06 on average, so the line is measured just past Mach 1. #222’s flight is not among them: it is in the design-library report, which holds no thrust and mass histories, and the line is defined on those. An open issue, #1497, carries its nose-only swap. No flight of the line has a repeated nose, so none was probed. | |
| ADR-351: M1.14b in eight: the Basic Finner’s normal force first | ADR-143 §6b names nine references for Mach 1.5 to 2.5. Three are refused on what the research notes found; the other six need work the tree lacks, in eight increments. The first ships here: against DREV-TM-9703’s free-flight range fits of the Basic Finner, HPR Sim’s normal-force slope reads 11.2% and 16.1% low at Mach 1.832 and 2.375, and its center of pressure 0.34 and 0.18 calibers forward, the side that understates stability. | |
| ADR-352: The 2026-11-16 review: speed off the rail held to accelerometer logs, predictions first | hpr sim prints how fast a rocket leaves its rail, and no report sets that speed against a real flight: it is held to another simulator flown on the same inputs. 48 of the private collection’s 83 flights are cataloged with an acceleration column. The milestone reads, from each such log, the rocket’s speed after the same travel along the rail, by summing the logged acceleration from rest on the pad. It merges those readings and each flight’s predicted speed before any error is computed, then scores the error. The scoreboard gains a row for the error and a row for whether the predictions run fast. A speed predicted higher than the flight’s is the flattering side. | |
| ADR-353: NASA’s check cases 1 and 2: both differences past the codes’ spread, traced | A free body of the report’s mass and inertia flies NASA/TM-2015-218675’s check cases 1 and 2 on HPR Sim’s gravity, Coriolis force, rigid-body equations and default integrator. In case 1 its altitude ends 19.51 mm (0.77 in) below the codes’, 137 times their spread: WGS 84’s normal gravity holds the terms past J2 that the codes’ gravitation drops, and that accounts for all but 0.1364 mm (0.0054 in). In case 2 its inertial body rates differ by up to 0.01633 deg/s, 12 to 16 times the spread: the rotational equations leave the Earth’s rate out, and that accounts for all but 0.001005 deg/s. Both remainders are inside the spread. | |
| ADR-354: The search index is held to mdBook’s own bar, not to its weight on 2026-11-10 | The site’s search index was held to its weight on 2026-11-10, 1,675,059 bytes compressed. The file stores every section’s text, so that limit held the guide to the words it had that week: a week later main had 2,684 bytes of room, about 920 words. The limit is now 10,000,000 bytes of the file, the size past which mdBook itself calls an index very large. That is room for about 139,000 more words; #1522 decides what follows. | |
| ADR-355: Withdraw NASA’s check cases 1 and 2 to land them again in order | M1.14b3, the free body flown against NASA’s check cases 1 and 2, merged in #1523 before the captures of the pages it changed were looked at, as ADR-282 requires before a merge. A look done right after the merge found nothing cut at an edge. As with ADR-306, #1523 is reverted and one pull request lands it again with every check run before its merge. M1.14b3’s roadmap entry is open until then; ADR-353 and ADR-354 stay, withdrawn with it. | |
| ADR-356: NASA’s check cases 3 and 6 to 10: the test’s loads, and the codes’ own air | The free body flies NASA/TM-2015-218675’s check cases 3 and 6 to 10 under loads the test applies: case 3’s damping moments, and the sphere’s constant drag along its velocity through the air. Case 3’s inertial rates differ from the kept codes past their spread, and the Earth’s rate left out of the rotational equations accounts for all but 0.003176, 0.001123 and 0.0007793 deg/s, inside it. The sphere’s positions in cases 6 to 8 differ from SIM 1 past the spread; the gravity past J2 with each code’s own air density brings them inside it, to 77.57 to 77.68 mm (3.05 to 3.06 in), without explaining SIM 1’s. Cases 9 and 10 are within the spread. | |
| ADR-357: Tip-off, measured with RocketPy’s: past the plan’s bar, the model in two more increments | RocketPy’s tip-off phase, at the merge of its pull request #920, flies thirteen example designs in still air and in a 20 mph (8.94 m/s) crosswind. Turned on, it moves 9 of 26 landing points by more than 1% of the apogee and one apogee by more than 1%, so the plan calls for a tip-off model. Against a rocket guided to its last button, as HPR Sim guides it, the phase moves the landing point by up to 3.765% of the apogee and the apogee by up to 0.414%. The model is M1.14b9’s, and flying it by default is M1.14b10’s. | |
| ADR-358: M1.14b9 in two: the tip-off phase on RocketPy’s normal force first | HPR Sim’s tip-off phase agrees with RocketPy’s on all 26 flights when both fly RocketPy’s normal force, and on the 13 still-air flights on HPR Sim’s own. On its own normal force the 13 crosswind flights are past the bars, because the two codes’ normal forces differ at 9.7° to 25.6° angle of attack: HPR Sim’s coefficient is 1.23 to 2.71 times RocketPy’s, and its moment about the last guide 0.35 to 15.20 times. M1.14b9 stays open on those 13. | |
| ADR-359: Drag below Mach 0.8 next: the drag part of the gap to OpenRocket, by Mach band | Split by the Mach number the drag acts at, the drag part of the gap to OpenRocket 24.12 on the private collection’s 68 flights is largest below Mach 0.8: a mean absolute 0.87% of the apogee there, 0.50% from Mach 0.8 to 1.2 and 0.23% above Mach 1.2. Flown on OpenRocket’s drag below Mach 0.8 alone, HPR Sim’s mean absolute error against the 60 logged apogees falls from 12.04% to 11.65%; on its whole drag, to 11.27%, beside OpenRocket’s 11.26%. M1.14’s increments by Mach number began at Mach 0.8. M1.14i is the band below it, and goes next. | |
| ADR-360: The 2026-11-19 review: drag in the coast held to accelerometer logs, predictions first | Both simulators’ apogees run high on the private collection’s logged flights, by +7.72% and +6.72% on average, and the apogee alone can’t say why: too little drag and too much thrust read the same way. Coasting, an accelerometer along the rocket’s axis reads the air’s force along that axis over the mass, with no thrust and no gravity in the reading. The milestone reads that below Mach 0.8 from each log with an acceleration column, merges the readings and both programs’ predictions before any error is computed, and then scores both programs on new rows, accuracy.coast-drag and bias.coast-drag. | |
| ADR-361: The voice report is built with the site, not committed | In the week to 2026-11-15, more than half of the pull requests (37 of 66) rewrote the committed voice report, so any two that edited pages conflicted on it, and a conflicting pull request gets no CI run. The report is no longer committed. The site’s build writes it onto a stub page, docs/voice-report.md, from the pages each time, and CI still fails a stock phrase, or a held page over a limit or missing a sentence target, as before. A mutation run shows each of the eleven failures still failing CI’s site command, and two branches that edit neighboring pages now merge cleanly where today they conflict. | |
| ADR-362: Base drag behind a boattail below Mach 0.8, held to the Hermes A-3A | Below Mach 0.8 HPR Sim gave the base behind a boattail the whole flat-base drag. On the Hermes A-3A’s measured free flight it read high by 0.050 to 0.064 power off, at least ten times the report’s stated error. The base now keeps of the flat-base value, the base’s diameter over the boattail’s fore diameter, from Stoney’s rule for conical afterbodies (NASA TR R-100, 1961, p. 11). On the reference the mean absolute error falls from 0.0574 to 0.0303, and no row’s error grows. On the private collection’s logged flights HPR Sim’s mean error goes from +7.72% to +8.01% and its mean absolute error from 12.04% to 12.09%. Those flights choose nothing here; they are reported. | |
| ADR-363: M1.14b10 in three: the tip-off reference at RocketPy’s rewritten phase first | RocketPy rewrote its tip-off phase after HPR Sim’s comparison was pinned. Re-pinned at the rewrite, the reference moves by at most 0.000020 deg/s in a turning rate and about 1 mm (0.04 in) in any apogee or landing point, the same flights are past the plan’s bars, and HPR Sim’s phase is inside every bar it was held to. Flying the phase by default reaches the command line, the Python package, the comparisons with other codes and most committed flight reports, so it is split: the reference first, then what the phase moves on the real flights, then the default. | |
| ADR-364: The tip-off phase on the real flights: two small rises, measured | Every real flight HPR Sim compares was flown twice, guided to its last guide as today and with the tip-off phase. Over the seven flights compared first the mean absolute apogee error falls from 6.065% to 5.974%, a fall that rests on Juno III’s rise in its wind. Over the five predicted first it rises by 0.0014 percentage points, and over the private collection’s 60 by 0.0033. Both rises are under the hundredth of a point the reports print. Each is measured to its flights: one is gravity lowering a flight HPR Sim already flies low, the other the phase raising, on net, a set HPR Sim already flies 8% high. M1.14b15 may make the phase the default. | |
| ADR-365: A smoothed track past Earth’s escape speed is withheld as diverged | The nightly census failed on four of its five platforms (#1590). One synthetic flight’s track, smoothed with its GNSS receiver trusted from liftoff, ran away, and the report held its standard error, 2,480,000 m (8,136,483 ft), to three figures the platforms made three ways. The smoother now withholds as diverged any track whose vertical speed passes 11,186 m/s (36,699 ft/s), Earth’s escape speed. The mutation’s diverged logs are counted and leave its cells, and it still fails. The bound also withholds 3 of the 1,058 real sample records, whose runaway tracks hpr analyze printed until now. A branch repairing a failed night may merge on a full run of its own head, main merged in. | |
| ADR-366: The main’s opening at the likeliest single change of the descent’s rate | The canopies reading walked back from landing and stopped at the first rate past the main’s mark, so a swing under the main or a coarse log’s scatter was read as the opening (#903). The main’s descent now starts at the likeliest place for one change in how often the rate is within the mark, the change-point of a two-valued sequence (Hinkley and Hinkley, 1970). On the issue’s real flight the opening moves from 108.45 s to 90.00 s, inside the issue’s 87 to 92 s, and the drogue’s rate from 14.6 to 17.3 m/s (48 to 57 ft/s) against a measured 17.3 m/s (57 ft/s). The committed synthetic census is unchanged (cargo xtask synthetic --check on this branch). |
These rows keep part of their detail here, so the table stays readable.
- ADR-209’s standard is completed by an open benchmark (M2.6), a correction for the bias every simulator shares (M7.5), steps-to-first-answer measurement now (M0.11) and tests by flyers outside the project at release 0.5.
- The check for fusionspace.co (ADR-249) also fails a comparative word with no committed comparison linked beside it, and a file from another site; pages built to fail prove each detector can fire.
- ADR-279 queues M2.11 after release 0.3 and before the IREC prediction table that prints a flutter speed (M6.6). It also has release 0.3’s paired bootstrap interval reported resampled by design, with the number of designs, since resampling single flights treats repeat flights of one design as independent.
- ADR-281’s three rules: the pad is taken only as far as its samples can vouch that the rocket was still on it; a track whose heights are above the pad only by a column’s word must start near its zero; and a top that isn’t a coast’s is withheld, either one the track fell from and climbed back to, or a spike that climbs in and falls out faster than physics allows.
- ADR-283’s top acceleration has its gravity settled by three witnesses (the family’s word, the pad, the coast to apogee) and which way up it reads by three more (the pad, the coast and the thrust, each as written), and is a floor where the part clipped, at its stated range or held flat, or where the accelerometer holds the thrust only in part. Without an accelerometer, burnout is a floor: the top speed’s time less its bound. The main’s opening is found back from landing as Debrief finds it, walked on the rate’s running median at the ground’s density; it was found on 87 tuning flights with a barometer, on their own logs, each within its bound, and no main was named on a flight under one canopy, on any log.
The roadmap
The roadmap is the ordered plan of work. It is split into phases, and each phase into
milestones. A milestone’s id is M, a topic number, a dot and its place in that topic. The topic
is not the phase: 0 is foundations, 1 physics, 2 validation, 3 file formats, 4 library interfaces,
5 online data, 6 Monte Carlo and optimization, 7 flight logs, 8 design help, 9 the app, 10 releases,
11 motor design, 12 parachute design and 13 avionics. Phases
mix topics, so M2.3, the real-flights milestone, sits in Phase 1 beside
M1.8, the second aerodynamics milestone. A milestone too big to ship at once is split
into increments with a letter, and sometimes a digit after it, such as M2.1b2. Each one
ends with done when conditions, and it is checked off only when all of them hold. Every
milestone has a row in the table below.
The roadmap file holds open work only. A queue at its top sets the order of work, and the
project’s automated checks fail if the running progress notes name any other milestone as current.
When a milestone is finished, cargo xtask records moves its entry, word for word, to
the archive of finished work, which opens with an index of one line per milestone.
The work runs in this order: the physics and its validation first, then the ways to use it and the analysis tools, with a release at each product boundary, then the app as release 1.0, then the suite’s new product lines one at a time (ADR-162, the suite and its releases).
- Phase 0: Foundations: the workspace, the reference library, the lessons from Loft and this site.
- Phase 1: Physics core, with validation interleaved: the models on this site, then transonic and supersonic aerodynamics, staging, and flight outputs such as the stability margin, with comparisons against RocketPy, OpenRocket and real flights along the way.
- Phase 2: Library surfaces and interop: a simpler interface, a command-line tool, Python bindings, and design files in and out.
- Phase 3: Uncertainty, optimization, challenges: Monte Carlo runs and design optimization for competitions.
- Phase 4: More formats and embeddings: RockSim, RASAero and RocketPy files, and use from C and the web.
- Phase 5: Flight data and forensics: reading flight logs and taking a flight’s readings off them (planned to work on its own, with no design file and no simulation) and then comparing a real flight with its simulation.
- Phase 6: Design experience: a design assistant for apps to build on.
- Phase 7: UI, 3D, web, mobile: a desktop app, 3D flight replay, a web app and mobile, started once release 0.4 is out.
- Phase 8: Releases: 0.1 the simulator (the library, the command line and Python), 0.2 the flight analyzer, 0.3 accuracy and diagnosis, 0.4 the competition kit, 0.5 an app preview with a 3D replay that draws the simulated flight as a “ghost” beside the real one, and 1.0 the app with its editor.
- Phase 9: The suite’s new lines: after 1.0, one at a time: designing experimental solid motors, then custom parachutes, then avionics (a test bench for flight computers, a ground station, a GPS tracker), then hybrids and liquids. Pad day on a phone (M9.4, mobile) comes after the parachute designer and before avionics.
What is done so far, and what is not, is on Start here. Ideas that are not on the roadmap yet, each with a tier, are in the ideas backlog.
Every milestone
Each milestone and increment has a row here, so a milestone label on any page leads to a line of
plain words. The label in the first column opens its phase in the roadmap, or in the archive once
it is done, where its full plan and its done when conditions are. The rows, their statuses and
those links are written by cargo xtask records; only the plain words are written by hand, and
the site check fails if a row is missing or its status disagrees.
| milestone | what it covers | status |
|---|---|---|
| M0.1 | The code workspace, the automated checks (CI) and the licenses | done |
| M0.2 | The library of published sources and reference programs, each pinned so results can be reproduced | done |
| M0.3 | The lessons from Loft, the project that came before this one | done |
| M0.4 | This documentation site | done |
| M0.4a | The site itself, and the checks on its links and labels | done |
| M0.4b | The model pages’ In short, Accuracy, the Glossary and Checking a claim | done |
| M0.4c | Getting started, and How a flight is simulated | done |
| M0.4d | Publishing the site and the API reference on the web | done |
| M0.4e | A new reader answers ten questions from the site alone, and what they find unclear is fixed | done |
| M0.5 | Leaner bookkeeping: one file per decision record, a roadmap of open work in queue order, shorter planning notes, these tables generated rather than hand-edited, and reviews while CI runs (ADR-144) | done |
| M0.5a | One file per decision record, with a generated index | done |
| M0.5b | A roadmap of open work only, with an explicit queue order, and an archive of what is done | done |
| M0.5c | Short planning notes, with budgets the checks enforce | done |
| M0.5d | Indexes and tables like this one generated, not hand-edited | done |
| M0.5e | Reviews that run while the automated checks (CI) run | done |
| M0.5f | Shorter planning files | done |
| M0.5g | The local checks that need the private reference data run on their own when physics code changes | done |
| M0.5h | The checks on the planning files rewritten to enforce the new rules | done |
| M0.5i | The first 20 pull requests after this milestone, measured against those before it | done |
| M0.6 | The FusionSpace product system: the docs site, the command line, its exports and its plot made to the design rules of FusionSpace, the family of tools this project belongs to, and the pages in US spelling (ADR-164) | done |
| M0.6a | The docs site | done |
| M0.6b | The CLI and exports | done |
| M0.6c | The plot | done |
| M0.6d | US spelling, no em dashes | done |
| M0.6d1 | The check, and the pages | done |
| M0.6d2 | The crates | done |
| M0.6d3 | The crates’ em dashes | done |
| M0.6e | US names | done |
| M0.7 | Rocketry explained: guides to high-power rocketry on the docs site, illustrated, then live (ADR-195) | not yet done |
| M0.7a | The format and four guides | done |
| M0.7a1 | The no-clipping checks | done |
| M0.7a2 | The format and the trust guide | done |
| M0.7a3 | Stability | done |
| M0.7a4 | Fin flutter | done |
| M0.7a5 | Drag through Mach 1 | done |
| M0.7a6 | The maintainer’s read | done |
| M0.7b | Recovery, wind and motors | not yet done |
| M0.7c | Live figures | not yet done |
| M0.7d | The rest of the hobby | not yet done |
| M0.8 | Product guides: a landing page and an illustrated tour for each product, every picture generated (ADR-196) | not yet done |
| M0.8a | The simulator’s guide | done |
| M0.8a1 | The landing page and the CLI tour | done |
| M0.8a2 | Python in the tour | done |
| M0.8a3 | Compared with | done |
| M0.8a4 | The maintainer’s read | done |
| M0.9 | One name, one design | not yet done |
| M0.9a | The name everywhere | done |
| M0.9a1 | The packages’ text | done |
| M0.9a2 | The site’s pages | done |
| M0.9b | The design audit | done |
| M0.9c | The CLI, exports and plot to the design | done |
| M0.9c1 | Diagnostics on stderr | done |
| M0.9c2 | US units in brackets | done |
| M0.9c3 | How far to trust a result | done |
| M0.9c4 | Units and trust notes | done |
| M0.9c5 | Provenance | done |
| M0.9c6 | Errors and typed numbers | done |
| M0.9c7 | The plot’s type and spacing | done |
| M0.9c8 | Provenance on every export | done |
| M0.9c9 | Help, roles and progress | done |
| M0.9c12 | The plot’s balloons, banking and title block | done |
| M0.9c13 | The site’s figures and units | done |
| M0.9c14 | Provenance on the other files | done |
| M0.9c15 | Next steps and waits | done |
| M0.9c16 | US units on the model pages | done |
| M0.9d | The site to the design | done |
| M0.9d1 | The figures in tokens | done |
| M0.9d2 | The site’s colors, corners and motion | done |
| M0.9d3 | The page’s frame | done |
| M0.9d4 | The head, the keyboard and forced colors | done |
| M0.9d5 | The notes | done |
| M0.9d6 | The site’s chrome | done |
| M0.9d7 | The page’s frame | done |
| M0.9d8 | Print and the text marks | done |
| M0.9d9 | The anatomy drawn | done |
| M0.9d10 | The pages’ vitals | done |
| M0.9d11 | The intro’s chip and lead | done |
| M0.9d12 | Two to six sheets: the check | done |
| M0.9d13 | The pages’ sheets and trust | done |
| M0.9e | The words to the design | done |
| M0.9f | The rest of the words | done |
| M0.9f1 | Joined names and long warnings | done |
| M0.9f2 | Short notes and cells, labeled heads | done |
| M0.9f3 | Grouped figures, prose dates and known digits | done |
| M0.9f4 | Units held to their figures | done |
| M0.9g | The figures’ digits and the command line’s words | not yet done |
| M0.10 | The scoreboard | done |
| M0.11 | Steps to a first answer | done |
| M0.12 | Typeset equations | done |
| M0.13 | Awareness and care on the sites | not yet done |
| M0.13a | The banner, the footer line and the help page | not yet done |
| M0.13b | Beyond the banner | not yet done |
| M0.14 | The maintainer’s own voice | done |
| M0.14a | The guide and the check | done |
| M0.14b | The front doors | done |
| M0.14c | The rest of the site | done |
| M0.14c1 | The first guides | done |
| M0.14c2 | Studies, data and logs | done |
| M0.14c3 | The command line and the evidence | done |
| M0.14c4 | Reference and the environment | done |
| M0.14c5 | The rocket and its flight | done |
| M0.14c6 | Aerodynamics | done |
| M0.14c7 | Recovery, staging and readings | done |
| M0.14c8 | The file formats | done |
| M0.14c9 | Flight logs, and every page held | done |
| M0.14d | The program’s words | done |
| M0.14d1 | The help | done |
| M0.14d2 | What the design commands say | done |
| M0.14d3 | What the data commands say | done |
| M0.14d4 | The Python package and the crates’ front pages | done |
| M0.15 | Damaged files refused, never a crash | done |
| M0.16 | The time budget for CI and the gate | done |
| M0.16a | Fixed slices of the flight censuses, and the budget measured | done |
| M0.16a1 | Two slices | done |
| M0.16a2 | The fit’s slice | done |
| M0.16a3 | The budget checked | done |
| M0.17 | The docs site at the tool level | done |
| M0.17a | The frame off | done |
| M0.17b | Field | done |
| M0.17b1 | Field in the theme switch | done |
| M0.17b2 | The restyle’s acceptance pass | done |
| M1.1 | Vectors and rotations, frames, the Earth’s shape and gravity | done |
| M1.2 | The atmosphere and wind | done |
| M1.3 | Solid motors: thrust curves, motor files, and mass through the burn | done |
| M1.4 | The rocket’s design and its mass properties | done |
| M1.4a | Part shapes and materials, and each part’s mass, center of gravity and inertia | done |
| M1.4b | The design tree: where parts sit, motor configurations and design checks | done |
| M1.5 | Aerodynamics below the speed of sound | done |
| M1.5a | Normal force and center of pressure | done |
| M1.5b | Drag, and tables that override it | done |
| M1.6 | The six-degree-of-freedom flight | done |
| M1.6a | The time integrator, and how events such as burnout and apogee are found | done |
| M1.6b | The rigid-body flight: the rail, the equations of motion and the phases of a flight | done |
| M1.7 | Recovery | done |
| M1.7a | Parachutes, and the descent under them | done |
| M1.7b | Streamers and tumble recovery | done |
| M1.7c | Separated bodies, each flown to its own landing | done |
| M1.8 | Transonic and supersonic aerodynamics, damping, and overriding the aerodynamics; closed with its drag target missed, which moves to M1.14 (ADR-143) | done |
| M1.8a | The normal force and center of pressure through Mach 1 | done |
| M1.8b | Drag through Mach 1: the transonic rise and supersonic wave drag | done |
| M1.8b1 | The drag of noses, shoulders and steps through Mach 1, against NASA’s Arcas Robin wind tunnel | done |
| M1.8b2 | Drag against RASAero II’s from Mach 0.1 to 2 | done |
| M1.8b3 | The drag of a boattail faster than sound, and the base behind it | done |
| M1.8c | Roll from canted fins, roll damping, and pitch and yaw damping (kept as each part’s local-flow damping) | done |
| M1.8d | Tables that override the normal force and center of pressure, read from RASAero II | done |
| M1.8e | The body’s normal force faster than sound, which slender-body theory underestimates past Mach 3; closed with its 15% target missed for the body alone (ADR-040, ADR-143) | done |
| M1.8e1 | The second-order shock-expansion method: the lift a body’s cylinder carries behind its nose faster than sound, checked against its report’s tables | done |
| M1.8e2 | The body’s supersonic normal force in a flight: the nose and its cylinder, joined to the subsonic model | done |
| M1.8e3 | Faster than sound: the blend into the shock-expansion method now starts at the exact Mach where the method starts to hold, not rounded to a 0.05 step | done |
| M1.8e4 | Faster than sound: a boattail, and a tube behind it, take their share of the body’s normal force from the shock-expansion method | done |
| M1.8e5 | Faster than sound: how much of the Arcas Robin’s remaining gap each missing effect (crossflow, the blunt tip, and others) explains, measured before modeling | done |
| M1.8e6 | The size of crossflow lift at every speed (Jorgensen) and a boattail’s measured share faster than sound (Washington and Pettis), the causes that measurement ranked first, in flight | done |
| M1.8e7 | Faster than sound: blunt and vertical nose tips (power-series, Haack and elliptical noses) by a Newtonian cap ahead of the shock-expansion method | done |
| M1.8e8 | Faster than sound: the lip behind a boattail, so that the committed Arcas Robin designs fly the shock-expansion method | done |
| M1.8e9 | Faster than sound: a bound on the boattail angle, footnote 8’s size pinned by hand, and the Arcas Robin wind tunnel’s 15% target judged | done |
| M1.8e10 | A lip’s shelter weighed as the drag buildup weighs it, instead of switching the whole body’s model at a threshold, and the size of every switch that remains | done |
| M1.8e11 | Cone slopes from 24° to 30°, from NASA SP-3007, where TN 3527’s own chart stops | done |
| M1.8e12 | What a blunt tip’s handover cap is worth once the cone slopes reach 30°, and what stops it moving there | done |
| M1.8e13 | What puts a marched answer at the mercy of the mesh: the surface pressure crossing its tangent cone’s, counted and told apart from a reduced element | done |
| M1.8e14 | Where the method stops marching a flare, bisected over Mach, and what the edge is made of | done |
| M1.8e15 | What a step in radius still switches, how big it is, and what a model of one would need | done |
| M1.8e16 | A blunt tip’s handover moved past 24°, once the march has a rule for the loading through a crossing (the rest of what M1.8e13 used to be, renumbered so the flare and the step keep their ids). Blocked, and deferred above Mach 4 with issue #108 (ADR-143); the vertical tip’s error goes to M1.14d below Mach 2.5 and M1.14h above | blocked |
| M1.8e17 | A flared body flown through the method where its shock is attached, with nothing jumping across that boundary as the model changes (the second of the three the old M1.8e14 splits into) | done |
| M1.8e18 | NASA TN D-4865 model 2’s readings committed, and what a marched flare is worth (the third of the three the old M1.8e14 splits into) | done |
| M1.8e19 | The band of near-flat flares the march used to refuse, which took the whole body off the method as a shape crossed it (found by M1.8e17); now read by the generalized method | done |
| M1.9 | Staging, clusters and air starts, for COTS motors | done |
| M1.9a | Motors lit at their own times, and a sustainer that flies on after a powered separation while the booster lands on its own, with tests for the ignition times, the mass step, the order of events and a trigger that never fires (ADR-074, Staging) | done |
| M1.9b | Several motors in one mount, their thrusts and masses summed, a motor out turning the rocket as a hand calculation predicts, and a .ork file’s clusters read with every tube where OpenRocket puts it (ADR-075, Clusters) | done |
| M1.9c | A two-stage and a cluster design from .ork files, each within the per-case tolerance of OpenRocket’s flight: every flight of each within 5% in apogee and largest speed (ADR-076, Staging) | done |
| M1.10 | Flight outputs: the stability margin over the flight, the best ejection delay, the peak dynamic pressure, fin flutter and the landing point | done |
| M1.10a | A flight’s peaks, its apogee with the height it counts from, its static and in-flight stability margins from the rail exit to apogee, each motor’s optimum ejection delay and each landing’s latitude and longitude, with None for what didn’t happen (ADR-077, Flight metrics) | done |
| M1.10b | Fin flutter speed and margin from a cited primary source, matching its worked example (ADR-078, Fin flutter) | done |
| M1.10c | Flights written as CSV, JSON, KML and GeoJSON files (Parquet optional), checked by schema and by parsing | done |
| M1.10c1 | A recording written as CSV or JSON, and the flight path with its landings as GeoJSON (checked against the published schema) or KML (checked by parsing) (ADR-079, Exporting a flight) | done |
| M1.10c2 | A recording written as Parquet, behind a cargo feature, and read back the same by Apache’s own Parquet library (ADR-080, Exporting a flight) | done |
| M1.11 | Ejected nose cones, body sections and payloads, each flown to its own landing | done |
| M1.11a | The airframe parting at any joint or around a payload, every piece landed under its own parachute (ADR-085, Recovery: ejected pieces) | done |
| M1.11b | The push of an ejection charge on the pieces, and a tumbling piece (ADR-086, Recovery: ejected pieces) | done |
| M1.12 | Payload mass that moves, or is released, during the flight | done |
| M1.12a | Ballast or a payload that slides along the airframe in flight, with the mass properties, the margin and the equations of motion following it (ADR-087, Moving mass) | done |
| M1.12b | Ballast or a payload released in flight, the rest flying on and the part falling on its own (ADR-088, Released mass) | done |
| M1.13 | Pods: bodies mounted beside the airframe, with or without motors | done |
| M1.13a | A pod’s mass: one pod repeated around the axis, each copy with its parallel-axis term, a motor in a pod one per pod (ADR-089, Pods) | done |
| M1.13b | Pods read from a .ork file | done |
| M1.13b1 | Pods of body components read from a .ork file, placed as OpenRocket 24.12 places them (ADR-090, .ork: Pods) | done |
| M1.13b2 | Pods of no length, which hang fins or a lug off the axis, and an empty pod set, read from a .ork file (ADR-091, .ork: Pods) | done |
| M1.13c | Pod aerodynamics from a cited source, and a pod design against OpenRocket | done |
| M1.13c1 | Pods fly: each pod’s parts with Barrowman’s normal force and their own drag, once per pod (ADR-092, aerodynamics: Pods) | done |
| M1.13c2 | A pod design with bodies and fins against OpenRocket, the limits of both codes’ pod models stated (ADR-093, aerodynamics: Pods) | done |
| M1.14 | Accuracy inside the operating envelope: the core band (Mach 0 to 2.5) first, then the extended band (Mach 2.5 to 3.5) in M1.14h, at angles of attack up to 15° (higher angles are M1.14e’s); real flights within the 5% apogee target, and at least as accurate as OpenRocket on the same flights (ADR-143) | not yet done |
| M1.14a | Four warning flags, each tested at its edge. Beyond the validated range: faster than the fastest public whole-flight reference, any committed comparison of a public flight against an independent reference (OpenRocket’s example at Mach 1.147 today; private flights never set it). At high angle of attack: above 15° more than 1 s after leaving the rail, at any Mach. Outside the core band: past Mach 2.5. Beyond the envelope: past Mach 3.5. And the aerodynamics page split by Mach band | done |
| M1.14a1 | Envelope flags | done |
| M1.14a2 | Drag issue warnings: issues #67, #68, #70, #72 and #222 warn by number when a flight meets their Mach and shape conditions (ADR-180) | done |
| M1.14a3 | Stability issue warnings: issues #87, #120, #121 and #172, where stability reads high, warn by number | done |
| M1.14b | New references from Mach 1.5 to 2.5: a public database of flights with simulator predictions, the free-flight coefficients of a standard finned test body (the Basic Finner), NASA’s six-degree-of-freedom check cases, and the validation uncertainty of each real flight. Two listed sources are refused (the reference note, §3 and §4): the Army Research Laboratory report ARL-TN-1128, which defines a shape, the High-Speed Army Reference Vehicle (HARV), and holds no coefficients; and a Mach 2.45 wind-tunnel drag point, whose authors measured a drag coefficient about a quarter of their own simulation’s and say their force setup should be reconsidered | not yet done |
| M1.14b1 | The Basic Finner’s normal force against DREV’s range | done |
| M1.14b2 | The Basic Finner’s drag and pitch damping against DREV’s range | done |
| M1.14b3 | NASA’s check cases 1 and 2 | done |
| M1.14b4 | NASA’s check cases 3 and 6 to 10 | done |
| M1.14b5 | Tip-off, measured with RocketPy’s | done |
| M1.14b6 | Wind from the GPS descent, against the reanalysis | not yet done |
| M1.14b7 | A validation uncertainty for each real flight | not yet done |
| M1.14b8 | MAPLEAF as a second open oracle | not yet done |
| M1.14b9 | The tip-off pivot, held to RocketPy’s | not yet done |
| M1.14b10 | Tip-off in every flight that has two guides | not yet done |
| M1.14b11 | The tip-off phase, held to RocketPy’s on RocketPy’s normal force | done |
| M1.14b12 | The crosswind tip-off on HPR Sim’s own normal force | not yet done |
| M1.14b13 | The tip-off reference at RocketPy’s rewritten phase | done |
| M1.14b14 | What tip-off moves on the real flights | done |
| M1.14b15 | Tip-off by default | not yet done |
| M1.14c | The normal force and drag near Mach 1, from 0.8 to 1.2, with the row at Mach 1.08 of the Basic Finner’s normal force | not yet done |
| M1.14d | Faster than sound, Mach 1.2 to 2.5. First the four shapes that fall back to slender-body theory and so read more stable than they are: a step in a body’s radius (issue #87), a flare behind a boattail too long for its wake (issue #120), a pointed tip steeper than 30° (issue #121) and a vertical tip steeper than its cap. Then drag, where HPR Sim reads 5.1% to 14.9% below RASAero II on RocketPy’s Calisto rocket, and the body-alone misses M1.8e left from Mach 1.5 to 2.3; and the rows from Mach 1.29 to 2.38 of the Basic Finner’s normal force | not yet done |
| M1.14e | Large angles of attack: what the legal 20 mph wind costs, and a high-angle model if it costs more than 1%; how long the first moments off the rail stay steep, which tests the 1 s the high-angle flag allows; and the issues about high angles | not yet done |
| M1.14f | Missing physics, ranked: misalignments, airframe drag under a parachute, base drag with the motor burning, gusts, parachute opening loads and more | not yet done |
| M1.14g | Generated figures on every accuracy and aerodynamics page, each with its reference and the error shown | not yet done |
| M1.14h | The extended band, Mach 2.5 to 3.5, after the core band: each fixed or re-measured in a decision record. The four switches’ errors as measured at Mach 3, where the center of pressure moves aft and the rocket reads more stable; the near-flat flare’s step at Mach 2.90 to 2.95 (issue #108), which way it errs not yet measured; and M1.8e’s body-alone row at Mach 2.96, 16.9% high in its normal-force slope, which tends toward the conservative side on a finned rocket, whose center of pressure then reads forward; and the two rows above Mach 2.5 of the Basic Finner’s normal force, the slope low and the center of pressure forward | not yet done |
| M1.14i | Drag below Mach 0.8 | done |
| M1.14i1 | The drag part of the gap to OpenRocket, by Mach band | done |
| M1.14i2 | The part below Mach 0.8, by term | done |
| M1.14i3 | Its largest term, held to a measurement | done |
| M2.1 | The validation harness, and comparisons with RocketPy | done |
| M2.1a | The harness itself: cases, reference data, tolerances and reports | done |
| M2.1b | Whole flights against RocketPy, with both codes given the same drag | done |
| M2.1b1 | The script that flies RocketPy’s example rockets from pad to landing, as the reference | done |
| M2.1b2 | HPR Sim’s whole flights compared with that reference | done |
| M2.1c | The same cases flown with each code’s own drag, a CI job, and regenerating references | done |
| M2.1c1 | A CI job that checks every case against its stored reference, and a workflow, run only by hand, that regenerates the references | done |
| M2.1c2 | The same cases flown with each code’s own drag | done |
| M2.1d | The time-series comparison, and where a rocket goes in wind (issue #50, why HPR Sim turned into the wind less) | done |
| M2.1d1 | Each whole flight’s height and speed, compared over time with RocketPy’s | done |
| M2.1d2 | Juno III, Calisto and Bella Lui in still air, as committed cases to measure the wind against (issue #50, why HPR Sim turned into the wind less) | done |
| M2.1d3 | Why HPR Sim turned into the wind less than RocketPy (issue #50): RocketPy’s equations, corrected, and HPR Sim’s body lift | done |
| M2.2 | OpenRocket as a reference program, and a corpus of designs to compare; closed with M2.2f, L19’s tube-fin bar missed and pinned | done |
| M2.2a | Each design’s structure (every stage, no motor): mass, center of mass and inertia against OpenRocket’s | done |
| M2.2b | OpenRocket’s mass conventions and roll inertia, split into M2.2b1 to M2.2b5 below; the stored results moved from the third to the fourth when ADR-062 split the fins off, and to the fifth when ADR-063 split the packed parts off; rolled up in ADR-101 | done |
| M2.2b1 | What a .ork leaves unsaid (a wall or shoulder of no thickness, no thickness written, no material) read as OpenRocket reads it, and which override wins | done |
| M2.2b2 | Fins and rail buttons against OpenRocket: where the roll inertia’s gap comes from, how each fin section is weighed, and where a rail button sits | done |
| M2.2b3 | Packed parts (parachutes, streamers, shock cords, mass components) against OpenRocket: the size one takes when its file writes none, and a mass override on one that weighs nothing | done |
| M2.2b4 | Motor clusters, fin fillets and the parts kept unread | done |
| M2.2b5 | Stored results in a .ork used as a reference only when they are current and plausible | done |
| M2.2c | The motors OpenRocket flies, for the configurations held back for want of a thrust curve, split into M2.2c1 and M2.2c2 below by ADR-066 | done |
| M2.2c1 | Every curve HPR Sim flies integrated as OpenRocket 24.12 integrates it, to the milestone’s 0.1% in total impulse | done |
| M2.2c2 | The curves the reference library embeds, and the configurations held back for want of one, supplied from OpenRocket’s own motor database by ADR-067 | done |
| M2.2d | Flights to apogee on the public designs, against OpenRocket, split into M2.2d1 and M2.2d2 below by ADR-068 | done |
| M2.2d1 | OpenRocket 24.12 flies the public designs; what each of its summary words measures is written down for that version, and other versions’ are withheld; a metric for an event that never happened is never scored | done |
| M2.2d2 | HPR Sim flies the configurations of that record it can fly, in a report against OpenRocket’s apogee, largest speed and stability margin (ADR-069, results) | done |
| M2.2e | The corpus, with a hypothesis for every apogee miss over 5%, split into M2.2e1 to M2.2e10 below by ADR-070, ADR-072, ADR-094, ADR-095, ADR-098 and ADR-100 | done |
| M2.2e1 | The flight report adds how far HPR Sim’s mass and center of mass are from OpenRocket’s, at launch and as the rocket leaves the rod (ADR-070, results) | done |
| M2.2e2 | OpenRocket flies the private designs, kept out of the repository; only counts are published (ADR-071, results) | done |
| M2.2e3 | HPR Sim flies the private designs, in a report of anonymized ids that publishes differences, never a design’s values: 17 flights of 4 of 12 designs, so 9 designs with the public report’s 5 (ADR-072, results) | done |
| M2.2e4 | A written cause for every apogee more than 5% from OpenRocket’s, sized by OpenRocket’s own flight without it: four of the five within 5% after, the fifth +7.80% with the no-drag part removed from both programs (ADR-073, results) | done |
| M2.2e5 | A tilted launch rod flown as OpenRocket records it: its angle from the vertical and the compass bearing it leans toward, checked on four public probe designs (bearing at apogee within 0.03 degrees, the tilt’s apogee loss within 0.27 percentage points) and adding one private design, 15 in all (ADR-094, results) | done |
| M2.2e6 | The single override flag older OpenRocket files use for a part and everything inside it, read as OpenRocket 24.12 reads it, measured on eleven probe designs and held by a test; one more private design flies, 16 in all. Not met for the second design the flag held: it also waits on a stage separation HPR Sim can’t fly (#184) (ADR-095, results) | done |
| M2.2e7 | Fin fillets and an inner tube whose automatic radius has nothing to take, read as OpenRocket reads them, so that the two private designs they hold back fly (#174). Measured on 21 new probes: the fillets’ mass and center of mass to 1e-15, and every part inside a nose cone but one packed mass component (#186) at OpenRocket’s mass to 1e-14 and station to 1e-15. Both designs fly, 18 designs compared across both reports, of the 20 M2.2e10 needs. The one supersonic flight climbs 13.60% higher than OpenRocket’s; on OpenRocket’s own drag it is +1.11%, so its cause is in the drag (#222) (ADR-096, ADR-097, results) | done |
| M2.2e8 | Tube fins whose radius OpenRocket works out from the body, resolved as OpenRocket 24.12 does (#133). Measured on 19 new probes: the radius within 1e-15, the tube fins’ mass to 1e-14; OpenRocket’s tube fin example now reads, its mass within 5e-6 of OpenRocket’s. Its roll and pitch inertia are departures: OpenRocket’s roll is larger than any mass inside the ring could have, and its pitch leaves out how far the tubes sit from the axis. The example’s flight moved to M2.2e9 (ADR-098, results) | done |
| M2.2e9 | Tube fin aerodynamics: a cited method for the normal force and drag of tube fins, pinned by tests, so that OpenRocket’s tube fin example flies within M2.2e4’s bar: an apogee more than 5% off has a sized cause. Each tube flies as a ring wing below Mach 0.8. The example’s apogee is 6.95% above OpenRocket’s, sized as HPR Sim’s drag by flying OpenRocket’s; 19 designs compared across both reports (ADR-099, Tube fins) | done |
| M2.2e10 | At least 20 designs across the two reports with all five spreads (apogee, largest speed, margin, mass and center of mass), the bar M2.2e3 had, unchanged. Met by flying a motor whose ignition never comes unlit and loaded, as OpenRocket does, measured on five probes of its two-stage example: one more private design flies, 0.88% above OpenRocket’s in apogee, 20 in all (ADR-100, the rules) | done |
| M2.2f | The two lessons that kept the comparison open. Cases let off a pass-or-fail bar still count in the error statistics, against both references where a rocket has two (L82): tested. A tube fin set’s center of pressure within a quarter caliber of OpenRocket’s (L19): not met, measured and pinned by a test instead, as L18’s is. HPR Sim’s center is 1.07 calibers forward of OpenRocket’s on its Tube fin rocket, and no measurement says which is nearer (ADR-102) | done |
| M2.3 | Comparisons with real flights | not yet done |
| M2.3a | The weather over a launch site read from an ERA5 file, as RocketPy reads it (ADR-081, ERA5 weather files) | done |
| M2.3b | RocketPy’s logged flights flown in their ERA5 weather and compared with the logs (ADR-082, Accuracy: real flights) | done |
| M2.3c | The private designs that have a flight log, flown in their day’s weather, published as statistics. Blocked until 2026-10-04, when none of the private designs was the rocket of any logged flight (ADR-083); the private flight collection added that day has such pairs (ADR-151) | not yet done |
| M2.3c1 | Logged apogees: the private collection’s logged flights against HPR Sim’s and OpenRocket’s predictions | done |
| M2.3c2 | Logged traces: the same flights’ altitude traces, once their logs are read | not yet done |
| M2.3c3 | OpenRocket’s newest release | not yet done |
| M2.3c4 | One fixture repo | done |
| M2.3c5 | The corpus rechecked | done |
| M2.3c6 | The gap to OpenRocket, by cause | done |
| M2.3c7 | Faster than sound: published flights | not yet done |
| M2.3c9 | Every flight OpenRocket flies | not yet done |
| M2.3c10 | The fineness-3 nose probe | done |
| M2.3c11 | OpenRocket’s inputs along its flights, flown by HPR Sim | done |
| M2.3c12 | The split in the fixture report | done |
| M2.3c13 | The tangent-ogive nose’s line | done |
| M2.3d | Twelve public flights, predictions first | done |
| M2.3d1 | The predictions | done |
| M2.3d2 | The errors | done |
| M2.3d3 | The EuRoC 2022 predictions | done |
| M2.3d4 | A stage’s override that adds to its parts | not yet done |
| M2.3d5 | The Macie XL predictions | done |
| M2.3d6 | A stage’s added mass | done |
| M2.3d7 | The inertia beside an override that covers the parts | done |
| M2.3d8 | The stages an added mass is still refused on | not yet done |
| M2.3d9 | The inertia with a motor aboard | not yet done |
| M2.3d10 | A parallel stage’s added mass | done |
| M2.3d11 | The stage a parallel stage hangs on, weighed with it | not yet done |
| M2.3d12 | An added mass on parts that weigh nothing | not yet done |
| M2.3d13 | Flights that move, release or part | not yet done |
| M2.3d14 | The rocket’s inertia beside a parallel stage’s covering override | not yet done |
| M2.4 | A summary of accuracy for the README, and CI that fails on any regression (ADR-084, Accuracy: the census) | done |
| M2.6 | An open benchmark | not yet done |
| M2.7 | Held-out flights, predictions first | done |
| M2.7a | The halves and the fits’ guard | done |
| M2.7b | New flights predicted first | done |
| M2.8 | Honest uncertainty | not yet done |
| M2.9 | The other tools’ cells | not yet done |
| M2.10 | Evidence register | done |
| M2.11 | Fin flutter held to measurement | not yet done |
| M2.12 | Descent rates against the logs | not yet done |
| M2.12a | The rule and the predictions | not yet done |
| M2.12b | The errors | not yet done |
| M2.13 | Landing points against the tracked landings | not yet done |
| M2.13a | The rule, the readings and the predictions | not yet done |
| M2.13b | The errors | not yet done |
| M2.14 | Speed off the rail against the accelerometer logs | not yet done |
| M2.14a | The rule, the readings and the predictions | not yet done |
| M2.14b | The errors | not yet done |
| M2.15 | Drag in the coast against the logs | not yet done |
| M2.15a | The rule, the readings and the predictions | not yet done |
| M2.15b | The errors | not yet done |
| M3.1 | Reading OpenRocket .ork design files | done |
| M3.1a | The container a .ork arrives in, and its design document read whole | done |
| M3.1b | The component tree: parts, shapes, materials, finishes and overrides into a design | done |
| M3.1b1 | What a .ork value means: dimensions OpenRocket works out for itself, tags written under two names, and overrides | done |
| M3.1b2 | The spine: the stages and the body components stacked in them, with their automatic radii marked for the layout to resolve | done |
| M3.1b3 | The parts on and inside the body, with their positions and the dimensions they take from their parents | done |
| M3.1b4 | The three designs of the 76 whose rocket still did not lay out: a radius with nothing to take, and a document with no design | done |
| M3.1c | Motors, recovery, stages, and what OpenRocket last simulated | done |
| M3.1c1 | A design’s motor configurations, the motors in them, and their thrust curves | done |
| M3.1c2 | When each parachute and streamer opens, and when each stage separates | done |
| M3.1c3 | The launch conditions and results of the simulations OpenRocket stored | done |
| M3.1c4 | Pods, parallel stages, and every part, section, tag and attribute HPR Sim does not read, kept for writing the file back | done |
| M3.1d | The corpus and the cross-check against RocketSerializer | done |
| M3.1d1 | Snapshots of what HPR Sim reads from public .ork designs | done |
| M3.1d2 | Every .ork imports without an error, and the cross-check against RocketSerializer | done |
| M3.2 | Writing OpenRocket .ork files | done |
| M3.2a | The writer: a design written back out as a .ork, reading back as the same design (ADR-109, Writing a .ork) | done |
| M3.2b | OpenRocket 24.12 loading and flying the written files, within 0.5% of the original’s apogee (ADR-110, Checked in OpenRocket) | done |
| M3.3 | The HPR design format, an open design file format of the project’s own | done |
| M3.3a | The document: a design as canonical JSON with its schema, every corpus design through it and back to .ork flying to the same apogee (ADR-111, The HPR design format) | done |
| M3.3b | The zip container (.hprz), the first migration (0.1 to 0.2), the comparison with other formats, and hpr convert and hpr sim taking .hpr and .hprz (ADR-112, The HPR design format) | done |
| M3.3c | TypeScript and Python types generated from the schema, each with a reader that checks a document (ADR-113, TypeScript and Python) | done |
| M4.1 | A simpler interface, with a builder for environments, motors, rockets and flights | done |
| M4.1a | The builder: environments, motors, rockets part by part, and flights, over the crates’ own types (ADR-103, The builder) | done |
| M4.1b | Models of your own: a drag model the flight calls in place of the simulator’s, through a trait, with a guide in the API reference (ADR-104, Models of your own) | done |
| M4.2 | A command-line tool | done |
| M4.2a | The command line’s commands, its JSON output and exit codes, shell completions, and looking up motors (ADR-105, The command line) | done |
| M4.2b | Flying a design from the command line (hpr sim), with its recording exported (ADR-106, The command line) | done |
| M4.2c | Checking the validation cases (hpr validate) and converting motor files (hpr convert) from the command line (ADR-107, hpr convert; hpr validate has since left the published hpr for cargo xtask validate --check, ADR-187, what it checks) | done |
| M4.2d | Reading a flight log from the command line (hpr analyze), with no design file: PerfectFlite’s .pf2 first, and liftoff, apogee, the top speed and landing (ADR-108, Reading a flight log) | done |
| M4.3 | Python bindings | done |
| M4.3a | The hpr Python package: the builder’s environment, motor, rocket and flight, designs read from files, recordings as NumPy arrays, and wheels built and tested on three operating systems (ADR-114, Python) | done |
| M4.3b | A drag table on a flight, and RocketPy’s example rocket, Calisto, flown from Python within 3% of RocketPy (ADR-115, Python) | done |
| M4.3c | Drag and wind models written as Python functions, their exceptions raised in Python (ADR-116, Python) | done |
| M4.5 | Fly my .ork: OpenRocket’s example designs fly as saved in hpr sim, with their recovery, offline after one motor download (ADR-144); Base drag hack’s E12-4 not met (M4.5o) | done |
| M4.5a | Parachutes and streamers from a .ork flown, with their triggers (issue #240) | done |
| M4.5b | A missing motor fetched from ThrustCurve and kept, and the exact command to fetch it printed when offline | done |
| M4.5c | Design checks that warn, with a cited tolerance, on fits builders make every day, and refuse only impossible ones | done |
| M4.5d | Output a person reads: configurations by name, results in sentences, the summary led by margin, apogee and rail exit speed | done |
| M4.5e | hpr sim --plot: a flight’s altitude, speed and acceleration drawn as an SVG figure | done |
| M4.5f | How-to guides: fly your .ork, pick a motor, check stability for a certification flight | done |
| M4.5g | Then unpowered separations, freeform fins and several separations, in order of how many designs each holds back | done |
| M4.5g1 | A powered separation in hpr sim | done |
| M4.5g2 | Several separations | done |
| M4.5g3 | An unpowered separation before apogee | done |
| M4.5g4 | Freeform fins | done |
| M4.5h | A part’s drag override | done |
| M4.5i | A powered pods example | done |
| M4.5j | The CLI’s corpus count | done |
| M4.5k | A ring around its tube | done |
| M4.5l | A packed part wider than its bore | done |
| M4.5m | Parallel booster staging | done |
| M4.5n | Pods--powered’s first configuration | done |
| M4.5o | Base drag hack’s E12-4: an elliptical nose’s subsonic drag taken from Hoerner’s measurement and pinned by a test; the E12-4 stays 7.80% above OpenRocket’s apogee, so the 5% bar is not met (ADR-173) | done |
| M4.6 | Monte Carlo from the CLI and Python: apogee and landing spreads without writing Rust | done |
| M4.6a | hpr mc | done |
| M4.6b | Monte Carlo in Python | done |
| M5.1 | The online layer, with an on-disk cache for working offline | done |
| M5.1a | The cache, its freshness rule and an offline mode that never fetches, tested with a hand-written sample response (ADR-117, Online data and the cache) | done |
| M5.1b | The HTTP transport, with rustls, behind a cargo feature, and the platform’s cache folder, tested against a server on the loopback address (ADR-118, Online data and the cache) | done |
| M5.2 | Weather forecasts, turned into atmosphere and wind profiles | done |
| M5.2a | A launch site’s weather from Open-Meteo, forecast or archived, as a sounding: the ground and the pressure levels above it (ADR-119, Launch-day weather) | done |
| M5.2b | Weather-balloon soundings from the University of Wyoming’s archive, as a sounding: the ground and every level above it (ADR-120, Weather-balloon soundings) | done |
| M5.2c | NOAA’s GFS and RAP forecasts from NOMADS, as a sounding: a small GRIB2 cut around the site, read by the project’s own decoder and checked value for value against ecCodes (ADR-121, NOAA forecasts: GFS and RAP) | done |
| M5.2d | Weather files you download, and the hpr weather command: the command done in M5.2d1; NOAA’s whole files in M5.2d2, complex packing and M5.2d3, JPEG 2000 | done |
| M5.2d1 | hpr weather: a launch site’s profile from Open-Meteo, a Wyoming sounding, GFS, RAP or an ERA5 file, fetched, from the cache, or from a saved answer (ADR-122, The command line) | done |
| M5.2d2 | NOAA’s whole GRIB2 files: complex packing, checked against ecCodes on every value of a whole GFS file (ADR-123, A whole GFS file) | done |
| M5.2d3 | NOAA’s whole GRIB2 files: JPEG 2000, checked against ecCodes on four public RAP fields (ADR-124, Files in JPEG 2000) | done |
| M5.3 | Launch-site data: magnetic declination in M5.3a, ground elevation in M5.3b, distances between places and a user’s elevation file in M5.3c | done |
| M5.3a | Magnetic declination from the World Magnetic Model, WMM2025, checked against NOAA’s test values (ADR-125, The magnetic field) | done |
| M5.3b | A launch site’s ground elevation from Open-Meteo, cached so it works offline after the first lookup (ADR-126, A launch site’s elevation) | done |
| M5.3c | Distance and bearing between two places on the WGS 84 ellipsoid, and a site’s elevation from a GeoTIFF file the user gives; split in two (ADR-127) | done |
| M5.3c1 | Distance and bearing between two places on WGS 84, checked against Karney’s published set of 500,000 geodesics (ADR-127, Geodesy) | done |
| M5.3c2 | A launch site’s elevation from a GeoTIFF file the user gives, checked against GDAL’s reading through rasterio on seven files and a whole USGS tile (ADR-128, A launch site’s elevation) | done |
| M5.4 | Motor stock and prices from motor.fusionspace.co, joined with ThrustCurve.org’s motors; split in three (ADR-129) | done |
| M5.4a | The motor finder’s files (its build, every motor, those in stock, the vendors, one motor’s page) read through the cache, so they work offline, each carrying the credit the site asks for (ADR-129; its CC BY 4.0 credit, ADR-145; Motor stock and prices) | done |
| M5.4b | ThrustCurve.org’s search and a motor’s thrust curve through the cache, and the motors in stock matched to ThrustCurve.org’s by name, with a report of the misses: 282 of 282 matched (ADR-130; the tests’ stand-in searches, ADR-145; Motor stock and prices) | done |
| M5.4c | hpr motors search: motors in stock by class and price, from the network, a saved list or offline, with both sources’ credit on every list (ADR-131, Motors you can buy) | done |
| M5.5 | A catalog of parts: OpenRocket’s parts files, looked up by maker and part number, and parts from them in a design; split in two (ADR-132) | done |
| M5.5a | The 16 .orc parts files OpenRocket ships, bundled and read, every part held to OpenRocket’s own reading: 3,449 parts, 17,911 values to the bit, the rest counted with their causes (ADR-132, OpenRocket .orc parts catalogs) | done |
| M5.5b | Catalog parts in the builder, and a rocket of them flown: all 3,449 parts built and held to what OpenRocket builds, the departures counted with their causes (ADR-133, parts from a catalog) | done |
| M5.6 | A catalog of the project’s own | not yet done |
| M5.6a | Format, search and a parts list | not yet done |
| M5.6b | Parachutes and recovery hardware | not yet done |
| M5.6c | Motor hardware and rail buttons | not yet done |
| M5.6d | More makers and electronics | not yet done |
| M5.7 | Every solid motor, offline | done |
| M5.7a | Each file’s check and the default file | done |
| M5.7b1 | The whole catalog compiled in | done |
| M5.7b2 | Every motor by name, offline | done |
| M5.7c | Every passing file held to the oracles | done |
| M5.7d | Newer motors online, and the bundle described | done |
| M6.1 | Monte Carlo runs and sensitivity; split in four (ADR-134) | done |
| M6.1a | Seeded dispersion of mass, center of mass, drag, motor, wind, rail and recovery delays; each flight the same whatever the run’s size or thread count; failed flights counted; the apogee’s spread (ADR-134, Monte Carlo dispersion) | done |
| M6.1b | Landing ellipses holding a chosen share of the landings, checked against normal spreads with known answers; the next flight’s ellipse; the landings each holds counted (ADR-135, Landing ellipses) | done |
| M6.1c | Sensitivity analysis, Morris screening and Sobol’ indices, checked against functions with known answers within their own standard errors (ADR-136, Sensitivity analysis) | done |
| M6.1d | 10,000 flights of a Level 2 rocket (one on a J, K or L motor) in 10 s or less, timed and recorded: 3.0 s for Valetudo, 9.4 s for a rocket past Mach 1.6, a run’s flights sharing one layout and one supersonic table (ADR-137, How long a run takes) | done |
| M6.2 | Design optimization; split in five (ADR-138) | not yet done |
| M6.2a | CMA-ES over continuous design variables, held to four test functions’ known minima and to pycma, its author’s implementation; a rocket’s ballast and body length found for a 3,048 m (10,000 ft) apogee and a 2.2-caliber margin, and checked by flying it again (ADR-138, Optimization) | done |
| M6.2b | Discrete choices (a motor, a catalog part) and limits such as a minimum stability margin; split in two (ADR-139) | done |
| M6.2b1 | Limits on a design, such as a minimum stability margin: candidates that break one rank below those that don’t (Deb’s rules); held to three test problems whose limited minima are known | done |
| M6.2b2 | Discrete choices (a motor, a catalog part) as whole-number variables, by CMA-ES with margin; held to three mixed test functions’ known minima and to an outside implementation; a motor and a Madcow nose cone chosen for a 3,048 m (10,000 ft) apogee under margin and rail-exit limits, and checked by flying the winner again (ADR-140, Optimization) | done |
| M6.2c | Several goals at once: NSGA-II finds a Pareto front; held to the known fronts of three standard test problems (ZDT1 to ZDT3) and to an outside implementation (pymoo), and a rocket’s trade-off between apogee and static margin, flown again and checked against CMA-ES (ADR-141, Optimization) | done |
| M6.2d | Bayesian optimization (EGO) for costly flights, split d1, d2 (ADR-142) | done |
| M6.2d1 | EGO: a surrogate (kriging) fitted to the designs tried, and the next design where it expects the most improvement; Branin’s and Hartmann 3’s minima within 1% in 50 evaluations from 20 seeds (ADR-142, Optimization) | done |
| M6.2d2 | EGO on Hartmann 6, a six-variable test function whose local minimum traps M6.2d1’s EGO in 7 runs of 10; one attempt (ADR-142, ADR-144, Optimization) | done |
| M6.2e | Robust designs: a Monte Carlo run inside the optimizer | not yet done |
| M6.3 | Competition rules as files, with scoring, limits and presets | not yet done |
| M6.4 | Airbrakes, with a controller that aims for a target apogee | not yet done |
| M6.5 | Roll control, roll only: tail-fin tabs first, then canards | not yet done |
| M6.6 | Submission packs: the numbers Student Launch and IREC ask for, from one design | not yet done |
| M6.7 | Ejection charges: black-powder size for a bay, always “ground test first” | not yet done |
| M6.8 | Field kit: checklists, the settings check and the ground-test log | not yet done |
| M3.4 | RockSim .rkt files in and out | not yet done |
| M3.5 | RASAero .CDX1 files in and out | not yet done |
| M3.6 | RocketPy scripts and files in and out | not yet done |
| M4.4 | Use from C, and in the browser through WebAssembly | not yet done |
| M7.1 | Reading flight logs from altimeters and trackers, with no design file and no simulation | done |
| M7.1a | The flight record every reader fills, a survey of the sample logs, and the PerfectFlite, AltOS and Raven readers | done |
| M7.1b | The RRC3’s, Eggtimer’s and the Blue Raven’s CSV, each unit a header leaves out decided from the file or stated as assumed | done |
| M7.1c | The other loggers’ formats, spreadsheets and generic CSV | done |
| M7.1c1 | GPS tracks | done |
| M7.1c2 | The rest | done |
| M7.1c3 | Club layouts | done |
| M7.1c4 | AerospaceNU’s board, a phone app’s CSV, Eggtimer RTF | done |
| M7.1c5 | Raw downloads, checked against their makers’ exports | done |
| M7.1c6 | Featherweight’s summaries | done |
| M7.1c7 | Archives and two readers’ variants | done |
| M7.1c8 | The R-DAS’s raw text | done |
| M7.1c9 | AltOS telemetry | done |
| M7.1c10 | AltOS raw downloads | done |
| M7.1c11 | ARTS2 raw data | done |
| M7.1c12 | Missile Works’ RTx GPS tracker | done |
| M7.1c13 | Tables read by their headers | done |
| M7.1c14 | Excel workbooks | done |
| M7.1c15 | EuRoC exports and mappings a publisher states | done |
| M7.1c16 | Binary records by a stated layout | done |
| M7.1c17 | The Blue Raven’s USB download | done |
| M7.1c18 | A course’s Teensy data logger | done |
| M7.1c19 | Radio packets, 255:…:254 | done |
| M7.1c20 | Workbooks with a reading beside | done |
| M7.1c21 | Altimeters’ other text | done |
| M7.1c22 | Tables by mapping, and files that aren’t logs | done |
| M7.1c23 | The last binaries; formats with no sample | done |
| M7.1d | A flyer’s own logger and GPX tracks | done |
| M7.1d1 | GPX tracks | done |
| M7.1d2 | Your own logger from the command line and Python | done |
| M7.2 | The readings a flight gives, each with where it came from, and reconstructing the flight from its log | done |
| M7.2a | The synthetic flights, each with its truth and its logger’s log | done |
| M7.2b | The readings on every logger | done |
| M7.2c | The rest of the readings | done |
| M7.2d | Reconstructing the flight: a smoother over the barometer, accelerometer and GNSS | done |
| M7.2e | 90% intervals on the readings, tested on the synthetic flights | done |
| M7.2e1 | The test, on the apogee | done |
| M7.2e2 | The height track’s other readings | done |
| M7.2e3 | The accelerometer’s readings and the canopies’ | done |
| M7.2e4 | The intervals in hpr analyze and Python | done |
| M7.2f | Two recordings of one flight, and stages | done |
| M7.2g | Ghost files: the flight as JSON, CZML and glTF | done |
| M7.3 | A flight against its simulation: residuals, and fitting drag, mass, impulse and wind to the log | not yet done |
| M7.3a | Residuals | done |
| M7.3b | The least-squares fit | done |
| M7.3c | The Bayesian option | not yet done |
| M7.3c1 | The posterior’s sampler | done |
| M7.3c2 | The Bayesian fit under the test | not yet done |
| M7.3c3 | The Bayesian option, counted | done |
| M7.3c4 | The Bayesian intervals pass | not yet done |
| M7.3c5 | The wind on a track | done |
| M7.3c6 | The drag on heights alone | not yet done |
| M7.3c7 | Every count | not yet done |
| M7.3d | From the boost | done |
| M7.3d1 | The prediction from the boost | done |
| M7.3d2 | The public flights | done |
| M7.3d3 | The collection by halves | done |
| M7.3d4 | The halves sealed | done |
| M7.3d5 | The cut on a real barometer | done |
| M7.3d6 | The collection’s errors by halves | done |
| M7.3d7 | The scoreboard row | done |
| M7.3e | The post-flight comparison | not yet done |
| M7.4 | Diagnosing what went wrong in a flight | not yet done |
| M7.5 | The bias every simulator shares | done |
| M7.5a | The rule before the fit | done |
| M7.5b | The correction, fitted and judged | done |
| M8.1 | A design assistant | not yet done |
| M8.2 | An editing model for apps: commands, undo and stable ids | not yet done |
| M8.3 | CAD interop: parts and designs out to meshes, drawings, FreeCAD and STEP, and meshes or STEP solids in as custom parts, through files only (ADR-144) | not yet done |
| M8.3a | Any part or the whole design written as a watertight mesh in millimeters: STL, 3MF or OBJ | not yet done |
| M8.3b | Dimensioned drawings (SVG, DXF, PDF): fins with bevels, rings, nose profiles and tube cut lists | not yet done |
| M8.3c | A generated FreeCAD script that rebuilds the design as a parametric feature tree, driven by a spreadsheet of its dimensions | not yet done |
| M8.3d | STEP export as solids, through a permissively licensed geometry kernel | not yet done |
| M8.3e | A mesh read in as a custom part: its mass properties computed exactly from the closed mesh and a material, its aerodynamics recognized as a body profile, a fin or a protuberance, or else marked as not modeled | not yet done |
| M8.3f | STEP solids read in as custom parts, once a reader with a suitable license is found | not yet done |
| M8.3g | Warnings for parts printed on a 3D printer: heat limits, layer direction, unvalidated flutter | not yet done |
| M9.0 | Choosing how the app is built, with trial builds | not yet done |
| M9.1 | A desktop app | not yet done |
| M9.2 | 3D flight replay, the real flight beside the simulated one | not yet done |
| M9.3 | A web app that works offline | not yet done |
| M9.4 | Mobile apps | not yet done |
| M9.5 | Optional accounts that save designs and flights and sync them across devices | not yet done |
| M9.6 | Neer’s four web tools (Motor Finder, Charge, Window, Muster) rebuilt as library code and app screens | not yet done |
| M9.7 | Field equipment and frequencies | not yet done |
| M9.8 | fusionspace.co, rebuilt | done |
| M9.8a | The page and its checks | done |
| M9.8b | The maintainer’s use | done |
| M10.1 | Release 0.1: the simulator | done |
| M10.1a | The flight and design fixes | done |
| M10.1b | The data, network and Python fixes | done |
| M10.1c | The release workflow | done |
| M10.1d1 | The release notes and the install pages | done |
| M10.1d2 | The missing warnings and the checklist | done |
| M10.1d3 | The friction and freeform fin warnings | done |
| M10.1d4 | The checklist | done |
| M10.1d5 | The separated parts’ warnings | done |
| M10.1d6 | The unknown signs | done |
| M10.1d7 | The designation and the design pin | done |
| M10.1d8 | The new name’s URLs | done |
| M10.1d9 | FusionSpace HPR | done |
| M10.2 | Release 0.2: the flight analyzer | not yet done |
| M10.3 | Release 0.3: accuracy and diagnosis | not yet done |
| M10.4 | Release 0.4: the competition kit | not yet done |
| M10.5 | Release 0.5: the app preview | not yet done |
| M10.6 | Release 1.0: the app | not yet done |
| M11.1 | A motor of your own | not yet done |
| M11.2 | Experimental solids | not yet done |
| M11.3 | Certified hybrids | not yet done |
| M11.4 | Nitrous blowdown | not yet done |
| M11.5 | Hybrid and liquid design | not yet done |
| M12.1 | Gores | not yet done |
| M12.2 | Opening loads | not yet done |
| M13.1 | Ground station | not yet done |
| M13.2 | GPS tracker logic | not yet done |
| M13.3 | Flight computer logic | not yet done |
| M13.4 | Hardware | not yet done |
| M13.5 | More tracker and flight-computer boards on one firmware | not yet done |
| M13.6 | Control hardware: drag-only airbrakes and roll-only tabs, held for a ruling | not yet done |
| M13.7 | Ground-test bench | not yet done |
Lessons from Loft
Loft was the project that came before this one. Its mistakes are listed as numbered lessons, such as Loft lesson L18, its made-up transonic drag curve, each with the test that guards against it here, or the milestone that will add one. The list of lessons says what went wrong, where in Loft, and how this project avoids it.
The lessons these pages name
Each lesson that a page of this site names has a row here. Its label opens its section of the list of lessons, which gives Loft’s evidence and the name of the test that guards it; the last column is the milestone that added or will add that test.
| lesson | what went wrong in Loft, or what the lesson records | guarded by |
|---|---|---|
| L1 | Loft used one constant gravity on a flat Earth, so it read low against RocketPy | M1.1 |
| L2 | Loft treated geometric altitude as geopotential, so its temperature and pressure were off at 11 km (6.8 mi) | M1.2 |
| L3 | Loft’s atmosphere had four layers, and its last temperature gradient ran on forever: 335 K at 70 km (43 mi), against 219.6 K | M1.2 |
| L4 | Loft’s air viscosity constants weren’t the 1976 standard’s, 1.3% high at sea level | M1.2 |
| L5 | Loft’s “today’s conditions” kept the standard temperature gradient above the field, with dry air and no sounding temperatures | M1.2 |
| L6 | Loft flew one wind vector; forecast profiles stepped at the lowest level; no gusts | M1.2 |
| L7 | Loft’s fin lift had no compressibility factor, so its slope and center of pressure never changed with Mach | M1.8a |
| L8 | Loft’s fin lift grew in proportion to the fin count, with no correction for 5 to 8 fins | M1.5a |
| L9 | Loft used the conical transition’s center-of-pressure formula for every transition shape | M1.5a |
| L10 | Loft took elliptical fins’ lift from an equal-area trapezoid with the wrong sweep | M1.5a |
| L11 | Loft merged fin sets into one for drag, so the result depended on their order | M1.5b |
| L12 | Loft’s drag used uncited constants, such as a body form factor of 1.95 where Niskanen gives 1.13 | M1.5b |
| L13 | Loft had no power-on base drag relief, which Niskanen’s drag method includes | M1.5b |
| L14 | Loft’s launch-lug drag was uncited, and rail buttons dragged as lugs | M1.5b |
| L15 | Loft gave a bare step in diameter no drag, and shoulder drag jumped to zero as a transition shrank | M1.5b |
| L16 | Loft silently capped the drag coefficient at 10, which hid malformed designs | M1.5b |
| L17 | Loft froze the fins’ leading-edge drag at its Mach 1 value, and gave nose and shoulder pressure drag no Mach term | M1.8 |
| L18 | Loft’s transonic wave drag was an invented curve, never checked against RASAero | M1.8 |
| L19 | Loft put a tube fin set’s center of pressure about 0.9 calibers forward of OpenRocket’s, and left out ring tails (a ring joining the fins’ tips). HPR Sim’s is 1.07 calibers forward, measured and pinned, not within the lesson’s quarter caliber (ADR-102) | M2.2f |
| L20 | Loft flew in 3-DOF: no angle of attack, body lift, damping or roll, and no weathercocking | M1.6b |
| L21 | Loft stepped with RK4 without error control, and never tested that the apogee converges | M1.6a |
| L22 | Loft didn’t locate events exactly: apogee fell on a step, altitude deployments overshot, landings were below ground | M1.6a |
| L23 | Loft let discontinuities such as burnout fall inside steps, and checked its vacuum case to only ±2% | M1.6a |
| L24 | Loft’s simulate() changed its inputs, so a second run of the same flight differed from the first | M1.6b |
| L25 | Loft labeled any early stop “step budget”, even a rocket that never lifted off | M1.6b |
| L26 | Loft’s launch rail had no friction and no button geometry | M1.6b |
| L30 | Loft fixed the staging before the flight, so an apogee or height separation fell back to the burnout, and it never flew the booster | M1.9a |
| L31 | Loft’s clusters sat on the axis only, so a motor out turned nothing, and it sent a mixed cluster to its oracle as copies of the first motor | M1.9b |
| L32 | Loft’s flutter constant was half of NACA TN 4197’s, so its flutter speeds were √2 too high, on the unsafe side, and 7 of its shear moduli had no source | M1.10b |
| L33 | Loft published static margins of ±12 to 15 calibers where the normal-force slope had all but cancelled and the margin meant nothing | M1.10a |
| L34 | Loft counted the opening shock as the peak acceleration, and read thrust spikes low from a finite difference of the speed | M1.10a |
| L35 | Loft used zeros for “never happened”, and never said which height apogee was measured from | M1.10a |
| L36 | Loft’s .eng reader read only the first header, and appended a second motor’s points to the first curve | M1.3 |
| L37 | Loft’s delay parsing lost P (plugged) and lists of delays, and read marker values as seconds | M1.3 |
| L38 | Loft’s impulse class letter was off by one at the top of each band | M1.3 |
| L39 | Loft didn’t check that a curve’s times increase, and took the last point as burnout instead of NFPA 1125’s rule | M1.3 |
| L40 | Loft fixed the motor’s center of gravity at the casing’s middle, with no inertia of its own | M1.3 |
| L41 | Loft bundled thrust curves under mixed or unknown licenses | M1.3 |
| L42 | Loft’s impulse checks were loose (±8%); a mis-sourced curve flew about 26% high until caught | M1.3 |
| L43 | ThrustCurve’s data must override a .eng header’s size: one listed a 54 mm motor as a 75 mm motor | M1.3 |
| L56 | Loft told a design file’s container apart by its first bytes, and a malformed one had to give an error rather than crash | M3.1a |
| L57 | Loft threw away the thrust curves stored inside a .ork archive | M3.1a, M3.1c1 |
| L59 | Loft resolved an automatic radius within a stage only, so a booster’s first component took a stale number | M3.1b2 |
| L60 | Loft resolved automatic dimensions as it walked the tree, so a ring’s bore depended on sibling order and a bulkhead inside a coupler stayed NaN | M3.1b3 |
| L61 | Loft weighed a ring with an automatic bore at 0 g, and dropped a stated wall when the outer radius was automatic | M3.1b2, M3.1b3 |
| L58 | Loft kept an automatic dimension’s number but lost the flag, so saving turned it into a hand-typed one | M3.1b1 |
| L62 | Loft met a tag written under two names, and read a stated 0 as a missing value | M3.1b1 |
| L63 | Loft read neither the drag override nor the subcomponent flags, so a part set to no drag was still charged drag | M3.1b1 |
| L64 | Loft read the wind’s direction from the launch rod’s, and dropped it from the stored conditions | M3.1c3 |
| L65 | Loft read a configuration from only one of the two places a .ork keeps it, and fired a motor whose mount it could not find from the top stage | M3.1c1 |
| L66 | Loft dropped pods, parallel stages and booster sets, and its export then lost the note that the rocket was reduced | M3.1c4 |
| L67 | Loft exported a plugged delay as 0 s, ignition only for the whole mount, no launch conditions, and masses it had worked out as overrides | M3.2a |
| L68 | Loft exported a freeform fin as a trapezoid of the same area (42% too big), lost a cluster’s scale and rotation, and rounded every number to six decimals | M3.2a |
| L44 | Loft’s inertia was pitch only, with simplified formulas, and zero for rings and masses | M1.4a |
| L45 | Loft put a hollow transition’s center of gravity at the solid’s centroid | M1.4a |
| L46 | Loft never read fin tabs (100 to 120 g lost on two designs), and rail buttons weighed nothing | M1.4a |
| L47 | Loft’s reference diameter was the widest part, even an internal one | M1.4b |
| L48 | Loft had tangent ogives only, a silent default nose shape, and swapped Haack names | M1.4a |
| L49 | Loft’s transitions used a kinked profile, never checked against what OpenRocket means | M1.4a, M3.1 |
| L50 | Loft let a motor wider than its mount fly (+69% apogee), and fins could sit off the airframe | M1.4b |
| L51 | Loft’s rule for which center-of-gravity override wins was unsettled (up to 133 mm (5.2 in)) and came from OpenRocket’s source | M2.2b1 |
| L75 | Loft’s RocketPy check wasn’t like for like: a different atmosphere, unstated latitude and gravity, and Loft’s own drag and mass fed to RocketPy | M2.1b, M2.1b2 |
| L76 | Loft’s advice to regenerate a reference when a check failed let the reference follow Loft’s own drag | M2.1a |
| L77 | Loft shipped hand-written “stored” results, one set inconsistent with itself | M2.1a |
| L78 | Loft’s test suites skipped themselves when their data was missing, and still reported a pass | M2.1a |
| L79 | Only 2 of Loft’s 12 metrics had a tolerance per case; a deployment speed 204% off passed as “ungated” | M2.1a |
| L80 | Same word, different quantity: Loft found the deployment and ground-hit speeds and the optimum delay differ by tool and OpenRocket version; this project has measured OpenRocket 24.12 only | M2.2d1 |
| L81 | Metrics for events that never happened, such as a deployment speed with no deployment, were scored as 0 | M2.2d1 |
| L82 | References 60% apart were excused as “no single target”, and known issues excused the two largest misses. Tested: every compared case counts, whatever explains a miss, against both references where a rocket has two | M2.2f |
| L84 | Loft wrote its counts by hand, for populations it didn’t name, and counted one disagreement 15 times | M2.4 |
| L85 | Loft’s check that a known gap had closed used half the tolerance, so it missed gaps that closed in between | M2.1b2, M2.4 |
| L86 | Loft published a headline accuracy figure without saying what it was compared with, over which rockets, or at what speeds | M2.4 |
| L88 | Loft’s only independent check held drag equal, so its own aerodynamics were never held to another code | M2.4 |
| L89 | Barrowman’s hand-worked values for a cone, a conical transition and an elliptical fin, which the project’s tests check | M1.5a |
| L90 | Properties any drag model must keep, such as split fin sets dragging like one set, which the project’s tests check | M1.5b |
| L91 | Exact volumes of nose cones (cone, tangent ogive, Haack), which the project’s tests check | M1.4a |
| L93 | Staging: the sustainer lights at the booster’s burnout plus its delay, the mass steps at the separation, and a trigger never reached lights nothing | M1.9a |
| L94 | The optimum ejection delay must come out the same whether the delay flown opens the parachute early or late | M1.10a |
| L95 | A degenerate design, with a zero radius, a NaN, no fins or a negative mass, must be refused or fly to finite numbers, never to a NaN | M4.1a |