Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

OpenRocket .orc parts catalogs

Look up a maker’s parts by part number in the OpenRocket .orc catalogs built into HPR Sim, and see how each value is read.

A .orc file is a parts catalog for OpenRocket, which calls its parts component presets. It lists nose cones, body tubes, couplers, centering rings, bulkheads, transitions, launch lugs, parachutes and streamers, as their makers sell them. Each part is under its maker and part number, with its sizes and its material. OpenRocket 24.12 ships 16 of these files, from the openrocket-database project: 3,449 parts from Estes, LOC Precision, Giant Leap, Madcow, SEMROC and others.

HPR Sim has those 16 files built in. A program can look a part up by maker and part number, or search for one. This page is the reference for that reader: what a file holds, how each value is read, and where HPR Sim’s reading differs from OpenRocket’s.

Building with it. The builder makes a rocket’s parts from catalog parts. It weighs each one as OpenRocket does, with the few differences it names (Parts from a catalog, written for M5.5b). A part that states its mass weighs that mass: its density is scaled to give it.

Code: hpr_io::orc (API reference), written for M5.5a, the parts reader. The decisions are in ADR-132: OpenRocket’s parts catalogs.

From a program

hpr_io::orc::bundled() is the built-in catalog. find takes a maker and a whole part number; search finds every part whose number or description holds some text. This program looks up a LOC Precision nose cone and a Giant Leap parachute, then searches Estes’ parts:

//! Parts from the catalog OpenRocket ships: a nose cone and a parachute found by maker and part
//! number, a search by a piece of a part number, and what the catalog holds.
//!
//! Run it from anywhere in the repository:
//!
//! ```text
//! cargo run --example parts_catalog -p fusionspace-hpr-io
//! ```
//!
//! The guide's page *OpenRocket `.orc` parts catalogs* (`docs/format/orc.md`) quotes it and what
//! it prints, which is kept next to it in `parts_catalog.output.txt`; CI checks that the two still
//! agree (`cargo xtask examples --check`).

#![allow(
    clippy::print_stdout,
    reason = "the project's lints forbid printing in library code, and this program exists to print"
)]

use hpr_io::orc::{PartKind, bundled};

fn main() {
    let catalog = bundled();
    println!(
        "{} parts from {} makers",
        catalog.parts.len(),
        catalog.manufacturers().len()
    );

    // One part, by maker and its whole part number. Its sizes are in meters; print millimeters.
    for part in catalog.find("LOC Precision", "PNC-3.00") {
        println!(
            "\n{} {}: {}",
            part.manufacturer, part.part_number, part.description
        );
        if let PartKind::NoseCone(nose) = &part.kind {
            println!(
                "  {:?}, {:.1} mm long, {:.1} mm across",
                nose.shape,
                nose.length_m * 1e3,
                nose.outer_diameter_m * 1e3,
            );
            // A nose is hollow with a wall, or filled. The file may give `Filled`, a wall or both;
            // the ten built-in parts that give both say `Filled` is false.
            match (nose.filled, nose.thickness_m) {
                (Some(true), _) => println!("  filled"),
                (_, Some(wall_m)) => println!("  wall {:.2} mm", wall_m * 1e3),
                _ => println!("  wall not given"),
            }
            println!(
                "  shoulder {:.1} mm long, {:.1} mm across",
                nose.shoulder_length_m * 1e3,
                nose.shoulder_diameter_m * 1e3,
            );
            match nose.material.density {
                Some(density) => println!("  {}, {density} kg/m³", nose.material.name),
                None => println!("  {}, density not given", nose.material.name),
            }
        }
    }

    // A parachute that states its own mass.
    for part in catalog.find("Giant Leap", "TAC-24") {
        println!(
            "\n{} {}: {}",
            part.manufacturer, part.part_number, part.description
        );
        if let PartKind::Parachute(chute) = &part.kind {
            println!(
                "  {:.0} mm across, {} sides, {} lines of {:.0} mm",
                chute.diameter_m * 1e3,
                chute.sides,
                chute.line_count,
                chute.line_length_m * 1e3,
            );
        }
        if let Some(mass_kg) = part.mass_kg {
            println!("  stated mass {:.1} g", mass_kg * 1e3);
        }
    }

    // Estes writes two numbers in one, `BT-20, 30316`: a search finds it by either.
    println!("\nEstes parts numbered with 30316:");
    for part in catalog.search(Some("Estes"), "30316") {
        println!("  {}: {}", part.part_number, part.description);
    }
}

It prints:

3449 parts from 16 makers

LOC Precision PNC-3.00: Nose cone, polypropylene, PNC-3.00, ogive, 12.5"
  Ogive, 285.8 mm long, 78.7 mm across
  wall 1.96 mm
  shoulder 95.2 mm long, 75.9 mm across
  Polypropylene, bulk, 946 kg/m³

Giant Leap TAC-24: Parachute, TAC-1 type, 24 in., 4 shrouds
  610 mm across, 4 sides, 4 lines of 914 mm
  stated mass 153.1 g

Estes parts numbered with 30316:
  BT-20, 30316: Body tube, BT-20, 18 in.

Every size comes back in meters, every mass in kilograms, and every density in kg/m³ (solids), kg/m² (fabric) or kg/m (cord), all SI units. A file of your own reads with hpr_io::orc::read(text, name). Here text is the file’s contents, and name is the file’s name. Each part keeps the name, so you can tell where it came from. The program does the reading from disk; the reader itself does no I/O.

Two things to know when looking parts up:

  • A part number is matched whole. Many makers write several numbers in one. Estes’ BT-20 is BT-20, 30316, so find("Estes", "BT-20") finds nothing; search finds it by either piece. The maker matches in any case.
  • A few numbers name two parts. In the built-in files, 21 part numbers name two parts of the same kind; 3 of those pairs are identical. find returns all of them, in file order.

What a file holds

A .orc file is XML with three parts:

  • <Version>: 0.1 in 15 of the built-in files, 1.0 in one.
  • <Materials>: each material’s name, its density, the density’s units and its kind. The kind is BULK (per volume, for solid parts), SURFACE (per area, for canopy and streamer fabric) or LINE (per length, for shroud lines).
  • <Components>: the parts. Each names its maker, part number and description, and its material by name and kind. That material must be defined in the same file.

Each size carries its own Unit attribute, such as <Length Unit="in">10</Length>. There is no published schema. The fields and units below are the ones the database project documents in its docs/TechnicalInfo.md, and their meaning is what OpenRocket does with them.

partsizes it givesin the built-in files
BodyTube, TubeCoupler, EngineBlock, CenteringRing, LaunchLuginside and outside diameter, length1,089, 237, 38, 499 and 59
BulkHeadoutside diameter, length115
NoseConeshape, length, base diameter, shoulder diameter and length, filled or a wall thickness855
Transitionshape, length, each end’s diameter, shoulder diameter and shoulder length, filled or a wall thickness360
Parachutediameter, number of sides, number and length of shroud lines, the lines’ material151
Streamerlength, width, thickness46

Any part may also state its Mass. 229 of the built-in parts do: 207 solid parts, and 22 parachutes and streamers. A parachute’s or streamer’s stated mass leaves its fabric’s density as written, in HPR Sim’s reading and in OpenRocket’s. A solid part’s stated mass doesn’t do that in OpenRocket’s reading (see Where the simulator’s reader and OpenRocket’s differ). When the part goes into a rocket, OpenRocket gives a parachute its stated mass as an override and ignores a streamer’s. The builder scales either one’s density to give it.

A centering ring’s length is its thickness. A coupler with an inside diameter of zero is a solid nose block.

The units read are the ones OpenRocket 24.12 reads:

quantityunits
lengthm, cm, mm, in, ft
masskg, g, oz, lb
bulk densitykg/m3, g/cm3, kg/dm3, lb/ft3
surface densitykg/m2, g/m2, g/cm2, oz/in2, oz/ft2, lb/ft2
line densitykg/m, g/m, g/cm, oz/ft

A value with no unit is in SI, as OpenRocket reads it. Each unit is its exact definition (NIST Handbook 44, Appendix C). The inch is 0.0254 m (0.083 ft), and the foot is 0.3048 m (1.000 ft). The pound is 0.45359237 kg, and the ounce is a sixteenth of that, 0.028349523125 kg.

What a file leaves unsaid

  • A shape’s parameter. A nose cone’s or transition’s shape is one of CONICAL, OGIVE, ELLIPSOID, PARABOLIC, HAACK and POWER (OGIVE is a tangent ogive). The last four have a parameter (an ogive’s radius, a Haack series’ C), but no .orc field can give it. OpenRocket uses its own default when the part goes into a design.
  • A shoulder’s wall. A shoulder has a diameter and a length but no wall thickness, and no end cap. For a hollow part, OpenRocket gives it no wall, so it weighs nothing. The database’s own usage notes say so, and the builder’s test confirms it from OpenRocket’s own output. The builder gives the shoulder the part’s wall instead (What the catalog leaves unsaid). For a filled part, OpenRocket weighs the shoulder as a solid cylinder: the check of stated masses below uses that volume, and it agrees.
  • A parachute’s drag. No field gives a drag coefficient.
  • A filled part’s walls. Filled says a nose cone or transition is solid. Where it is absent, a Thickness gives the wall instead. Eight nose cones and two transitions give both, and all ten say Filled is false, so they agree: a hollow part with that wall. A file that said filled with a wall would leave which one counts open; HPR Sim keeps both, as OpenRocket’s reading does.

Where the simulator’s reader and OpenRocket’s differ

The test crates/hpr-io/tests/orc_openrocket.rs reads every built-in part and compares it with OpenRocket 24.12’s reading, value by value. The two agree everywhere except in these places. Each is counted, and each count is checked:

whatpartsHPR SimOpenRocket
a mass stated in ounces185the exact ounce, 0.028349523125 kg0.0283495231 kg, so 8.8 parts in 10 billion lighter
two makers’ names252as the file writes them“LOC/Precision” and “Public Missiles, Ltd.” for “LOC Precision” and “Public Missiles”
a solid part that states its mass207the material keeps the file’s density; the part keeps its stated massreplaces the density with the one that gives the part that mass
a material the file names but doesn’t define3no densitya density of zero

The third row is the one that matters for a rocket’s weight. For example, an Estes balsa nose cone that states its mass gets, in OpenRocket, a balsa density that makes the cone weigh exactly that. HPR Sim keeps both numbers.

The test shows that a stated mass is the cause on all 207. The oracle also reads each file with every <Mass> taken out, and then OpenRocket’s density equals HPR Sim’s on every part, these 207 included. On the 54 of them that are simple solids, the test also checks the stated mass. It checks that OpenRocket’s replaced density times the part’s volume gives it, to 1 part in 10¹⁵. The 54 are 7 body tubes, 4 bulkheads, and 43 filled conical parts: 34 nose cones and 9 transitions. The builder (Parts from a catalog) makes a part that states its mass weigh that mass. It scales the density to do so, as OpenRocket does for rigid parts.

OpenRocket also rounds a few other imperial factors. They are pounds per cubic foot, ounces per square inch or foot, pounds per square foot, and ounces per foot. No built-in file uses them.

Warnings, not failures

Only three things make HPR Sim refuse a whole file. They are text that isn’t XML, a top element that isn’t <OpenRocketComponent>, and elements nested more than 16 deep. No catalog needs that depth, and a file that deep is refused before the XML is read. Anything else that can’t be read is left out with a warning, and reading goes on:

  • A part is left out for a missing, unreadable or negative size, or for a unit or shape the format doesn’t have. It is also left out for a material of the wrong kind or a value with an element inside it. So is an element that isn’t a kind of part. OpenRocket 24.12 refuses the whole file for three of these: a missing size, an unknown unit and an unknown shape. It reads an unreadable size as zero. It reads a material of the wrong kind with a density of zero, and a part number written BT<b>-</b>20 as 20. It skips an element that isn’t a part. What it does with a negative size is not probed.
  • A material is left out for an unknown unit or kind, no density, or an element inside its name. It is also left out for a density below zero or too large for a 64-bit number. Parts that name it read with no density.
  • A field a part’s kind doesn’t have is left out, with a warning. The 37 built-in nose cones that state an inside diameter read this way.
  • A field stated twice keeps the last, as OpenRocket does. Three built-in parts state two descriptions.
  • A material defined twice with two densities: parts take the first, as in OpenRocket.
  • A list stated twice: the last <Materials> and the last <Components> are read, as OpenRocket reads them. Anything else beside the lists is left out.
  • A value that is read as written but looks wrong:
    • a tube whose inside diameter is not less than its outside diameter;
    • a solid lighter than air (under 1 kg/m³);
    • a fabric lighter than 1 g/m². The lightest correctly labeled fabric in the built-in files, a polyethylene film, is 7.05 g/m². Their ripstop nylons are tens of g/m². So this is almost certainly a kg/m² value labeled g/m2, 1,000 times too light.

A file with more than 1,000 warnings lists the first 1,000 and then says how many more there were.

The project’s notes list in/64 (sixty-fourths of an inch) as a length unit. HPR Sim refuses it, because OpenRocket reads it as whole inches: 3 in in/64 would come out as 3 inches.

On the built-in files there are 55 warnings, all of kinds listed above:

warningcount
a nose cone’s inside diameter, ignored37
a description stated twice3
a material not defined (Carpet Thread twice in mpc.orc, and a balsa in semroc.orc)3
a tube-like part no narrower inside than out (one Quest, two SEMROC)3
a solid lighter than air (Paper, bulk at 0.0011 kg/m³ in BMS.ORC and ROCKETARIUM.ORC, an elastic in generic_materials.orc)3
a fabric under 1 g/m² (five in generic_materials.orc, one in giantleaprocketry.orc)6

Nothing is changed on account of them: each such part reads as written, as OpenRocket reads it. The 18 parts made of that paper (centering rings and engine blocks) would weigh about a millionth of a real one. Paper is roughly 1,000 kg/m³. The six Giant Leap parachutes on the light fabric all state their mass, so use that. bundled() drops these warnings; read each of BUNDLED_FILES to see them.

Checked against OpenRocket

validation/oracles/openrocket/orc_presets.py runs OpenRocket 24.12’s preset loader, its public API (run, never read: its source is GPL), on each of the 16 files. It first checks that the jar’s copy of each file is byte for byte the one built into HPR Sim. It records every value of every part to crates/hpr-io/tests/fixtures/orc/openrocket-presets.json, one part to a line. Each part’s densities are recorded too, as OpenRocket reads the file with its masses taken out.

It also has OpenRocket read 37 small .orc probe files, each asking one question. The questions cover every unit above, values with no units, and a part or a file OpenRocket can’t read. They also cover what it does with a material or a list stated twice. The probe test in the same file reads each probe:

probesresult
23read as OpenRocket reads them, to the bit
6in a unit whose factor OpenRocket rounds: within 2 parts in 10⁹, by HPR Sim’s exact factor
4OpenRocket refuses the file; HPR Sim leaves the part out (for oz/in, ounces per inch, a cord density neither reads, HPR Sim leaves the material out and reads the part without the cord’s density)
4OpenRocket reads the part (in/64 as inches, a length of ten as zero, a material of the wrong kind with a density of zero, BT<b>-</b>20 as 20); HPR Sim leaves it out

As a check that the tests can fail, HPR Sim’s inch was changed by hand. It was moved to the next number a 64-bit float can hold above 0.0254. Both the catalog comparison and the probe test failed.

Sources and license

  • The files: openrocket/openrocket-database, https://github.com/openrocket/openrocket-database, at commit 1512874a (July 27, 2025), pinned as openrocket-database in the reference lock file. Apache License 2.0. Created by Dave Cook and maintained by the OpenRocket team. They are built into HPR Sim unchanged, in crates/hpr-io/data/openrocket-database/ with the project’s LICENSE.
  • The format: the project’s docs/TechnicalInfo.md and docs/Usage.md at that commit.
  • The units: NIST Handbook 44 (2024), Appendix C, General Tables of Units of Measurement.
FusionSpace HPRVersion 0.1.0Issued 2026-11-21In preparationAbout HPR Sim