Overview and status · RustCore docs

Beta software. RustCore is in beta. Get it from the downloads page; once installed it updates itself. This page describes the beta as it is now; details will change before release.

What RustCore is

RustCore designs the propellant grains and core of a solid rocket motor, and optimizes the core’s geometry before you export the motor to openMotor or BurnSim. It is a sibling of RustPEP, by Geoffrey Huber at RocketSalvo.

It was built around one idea: in a long, slender motor, keep the mass flux down the core below the erosive-burning threshold along its whole length and for the whole burn, by shaping the core. A double taper (wide at the head, narrowing to a waist, then opening toward the nozzle) is the classic answer, and RustCore grew out of a spreadsheet that designed one. RustCore does the same job with any mix of shapes.

The usual workflow

Fit your propellant’s burn rate, r = a·Pⁿ, from test firings in RustPEP, then press Add to RustCore library on its Export page (RustPEP 0.39.0 or later). The propellant comes across with its density, burn-rate fit, c* and c* efficiency, gamma, flame temperature, molar mass and test firings, and RustCore lists it on its Propellant page. RustPEP’s Save for RustCore saves the same .rsprop file anywhere, to copy or share. Propellants from openMotor or BurnSim import too.
On the Design page, stack the grains and build each core from sections: round, star, finocyl or moon, each straight or tapered. A D grain (a flat slot down the grain, straight or tapered) takes a grain to itself. An end burner starts with a Solid section and burns from its nozzle end only; that end can be flat, or have a cone or drilled hole for more thrust at ignition. It must be the first grain, with its head end inhibited. Each grain’s end faces either burn or are inhibited. Results update as you type.
Set the throat to size itself for a target Kn or pressure, and set the mass flux limit.
On Studies, let RustCore find the core sizes that give the most impulse while staying under the limit, sweep one or two settings, or shape a constant-flux taper.
Check the burn on the Burn page, then export the motor to openMotor or BurnSim, a thrust curve for OpenRocket or RockSim, and the casting mandrel as STL or STEP.

Studies

Studies are what set RustCore apart: instead of telling you how the core you drew performs, they search the geometry for the core that best meets a goal while staying safe.

Find the best. Tick the dimensions that may change and give each a range: each section’s sizes at each end, where sections meet, and the nozzle’s target. Pick a goal: most total impulse, most propellant, lowest peak mass flux, flattest thrust curve, total impulse closest to a target, longest burn, or burn time closest to a target. Longest burn suits sustainers such as D grains, moons and end burners; the result warns if the design runs below the pressures the burn rate was fitted from. Tick the limits that must hold: mass flux under your limit (the highest anywhere along the core at any moment of the burn), chamber pressure under your limit, and port-to-throat ratio above your minimum. RustCore scans the ranges, then refines from the best point. If nothing in the ranges meets every limit, it shows the closest design and says so.
Sweep. Step one setting across its range for a chart, or two for a map, of peak flux, total impulse, peak pressure, propellant mass, peak Kn or burn time.
Constant-flux taper. Reshape a round core into short tapers that bring the worst flux to the same target all along it. Simplify that ideal shape to a double taper you can make, then fine-tune it with Find the best.

Every candidate is a full burn simulation. With the throat set to size itself, every candidate runs at the same Kn or pressure, so “most impulse under the flux limit” finds the tightest core the propellant can take. Studies run at draft resolution for speed, and the result is re-checked at the design’s own resolution. Use this design puts the result on the Design page; Ctrl+Z undoes it.

Mass flux

The mass flux at a point in the core is the mass of gas flowing past it each second, divided by the port area there. Gas made along the whole core funnels toward the nozzle, so in a long motor the flux climbs toward the aft end. Above a threshold, the fast gas makes the propellant burn faster than its burn-rate law says. That is erosive burning, and it brings pressure spikes and lost performance.

The original spreadsheet aimed under 1 lb/in²·s. About 2 lb/in²·s is a common upper guideline for hobby propellants. When a design is over the limit, RustCore gives the smallest aft port that would hold it; if that is close to the grain’s outside diameter, no core shape can meet the limit at that Kn or pressure.

Predicting erosive burning

From version 0.16.0, RustCore can predict what erosive burning does to a motor rather than only helping you design around it. Pick a method on the Erosive burning card of the Burn page and press Predict. Each station along the core burns at its own rate, and the chamber pressure follows the burning area weighted by erosion rather than the plain Kn. The prediction is drawn beside the standard simulation, never in place of it.

Four methods compute: a control that applies no erosion, Lenoir-Robillard, Mukunda-Paul, and a threshold-linear empirical fit. Two more, King and Ma et al. (2020), are listed so you can check your inputs against them, but RustCore cannot run them.

From version 0.19.0, Fit from tests… on the Burn page takes one or more samples.csv traces from your own static firings and fits the selected method’s parameters against the whole pressure curve, rather than against a summary figure. It reports the parameters with their units, the residual as a percentage of peak pressure with the sample count behind it, and the flux and pressure range the fit actually covered, so you can judge the fit instead of taking it on trust. Predict with these then runs the prediction on the fitted values.

The fit refuses what it cannot judge: a base-rate firing is turned away by name, because a low-flux firing carries no information about erosion; a method whose constants are published has nothing to fit; and a trace with uneven sample spacing is refused rather than quietly fitted against a stretched time axis.

Fitted parameters stay in RustCore. RustPEP owns what a formulation carries, so enter them there to keep them.

A prediction is not the baseline with bigger numbers. Erosion is worst where the flux is highest, near the nozzle, so that end of the grain burns through first. The motor can therefore reach a lower peak pressure than the no-erosion simulation while being in worse shape, because the late rise in burning area never happens. Where that occurs, the card says so.

The guide drawer, opened by the ? beside the method picker, holds a page on each method, an end-to-end walkthrough and a glossary. Its checklist lists every input the method needs, whether your propellant has it, where each value came from, and where to supply anything missing.

Research only. No method’s citation has yet been checked against its source paper, so every method is marked unverified in the program, and nothing has been validated against real firings. Every prediction carries the provenance of the inputs it needed and shows a banner when any of them is fictitious or synthetic. Do not design a motor from these numbers; confirm by static test.

Fitting a method to your own traces does not change this. It fits that method to your data; it does not establish that the method describes a motor.

One trap is worth knowing before you gather data: fit the burn-rate coefficient and exponent from low-flux firings, and the erosive parameters from high-flux ones. Not because an eroding firing inflates the measured burn rate — it does not, and it is worth knowing why. Burn time is set by the slowest part of the grain, and erosion spends the aft web first, so the aft end burns through while the head end runs on at very nearly its unaffected rate; on a strongly erosive test the measurement still comes back at 0.993 of the non-erosive law. What the erosion does inflate is the measured pressure, which shifts each point on the log-log plot and biases the law slightly downward. The reason to separate the campaigns is simpler and harder to argue with: a burn law is meant to describe the propellant with nothing flowing over it, and a firing with crossflow is not a measurement of that.

Exports

openMotor .ric: the whole motor. Round tapers become conical grains, and end burners become openMotor’s End Burner (a cone or hole in its end is only roughly matched). BurnSim 4 also opens .ric files.
BurnSim 3 .bsx: BurnSim 3 has no tapers, so tapers are cut into short stepped grains. Stars and end burners cannot be written; use the .ric.
RASP .eng: a thrust curve for OpenRocket and RockSim.
STL and STEP: the grains, or the casting mandrel. A double-taper core cannot come out in one piece, so the mandrel is split where each piece can slide out of its own end.
CSV: the burn step by step, or the core diameter every millimetre for turning a mandrel.

Every export lists anything it had to approximate.

Accuracy and limits

Round cores, including tapers and steps, are computed exactly. Stars, finocyls, moons and D grains use a 3D grid that is within about 1 to 2% of closed-form BATES results.
The test suite reproduces the original spreadsheet: core area 289.8 in², starting Kn 178 and mass flux 0.98 lb/in²·s at the aft end.
Exported motors run in openMotor 0.6.2 agreed with RustCore within about 1% on Kn and peak pressure.
The standard simulation is steady-state, and the ignition and tail-off transients are not modelled. Erosive burning is not in it either: it is predicted separately, as above, and shown beside it.
Pressure is lumped, so there is no axial pressure gradient and no separate aft-end pressure.
All 64 values of the shared erosive-burning fixture set pass — 24 point checks and 40 station checks, to one part in a million, against an independent reference that RustPEP and RustStand also check against. That is a check of the arithmetic, not evidence that any method describes a real motor.

Results are predictions from ideal models. Check them against static tests, and follow your rocketry organization’s safety code.