Software · Motor core and grain design
Design the grains and core of a solid rocket motor, then let RustCore’s Studies optimize the geometry for performance and safety: the most impulse, or another goal, with mass flux, chamber pressure and port-to-throat ratio held inside your limits through the whole burn. Bring the propellant straight from RustPEP with its measured burn rate, and export the result to openMotor or BurnSim. Round, star, finocyl, moon and D grain cores, straight or tapered, and end burners. It is in beta.
The RocketSalvo family
The two programs share one propellant library. What you learn about a propellant in RustPEP comes across to RustCore whole, so the core is designed around the burn rate you actually measured.
RustPEP
Predict the recipe’s performance, fit the burn-rate law r = a·Pⁿ from your BATES test firings, and get the c* efficiency your motors deliver. Then press Add to RustCore library on the Export page.
About RustPEPRustCore
The propellant is waiting on the Propellant page with its density, burn-rate fit, c*, gamma, flame temperature, molar mass and test firings. Refit it in RustPEP and add it again, and the library copy is replaced.
How it worksNeeds RustPEP 0.39.0 or later. RustPEP can also save the propellant as a .rsprop file to copy to another computer or share.
Why it exists
In a long motor, all the gas made along the core has to rush out past the aft end. When that flow gets too fast, the propellant burns faster than its burn rate says it should. That is erosive burning, and it brings pressure spikes and lost performance.
RustCore began as a spreadsheet that solved this with a double-taper core, shaped so the mass flux stays under 1 lb/in²·s from one end of the motor to the other. RustCore takes the same idea to any core shape and checks it through the whole burn, not just at ignition. Its test suite still reproduces the spreadsheet’s results.
What sets it apart · Studies
A motor simulator tells you how the core you drew will perform. RustCore’s Studies work the other way round: say what you want from the motor and what it must never do, and RustCore searches the geometry for the core that delivers it. Every candidate is a full burn simulation, checked from ignition to burnout, not just at the first instant.
Performance · the goal
Safety · the limits
Results warn when the design found runs below the pressures its burn rate was fitted from. Designs that break a ticked limit are rejected. If nothing in your ranges meets every limit, RustCore shows the closest design and says so.
Tick the dimensions that may change and give each a range. RustCore scans the ranges, then refines from the best point, and shows the winner beside your design. Use this design takes it; Ctrl+Z undoes it.
Step one dimension 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. See where the limits bite before you search.
Reshape a round core into short tapers that bring the worst flux to the same target all along it. That is the ideal shape; simplify it to a double taper you can make, and fine-tune that with Find the best.
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: the original double-taper spreadsheet’s method, carried through the whole burn and to any core shape. Studies run at draft resolution for speed, and the result is re-checked at your design’s own resolution.
From propellant to motor
1 · Propellant
Fit the burn rate from your test firings in RustPEP and add the propellant to RustCore’s library with one button. Propellants from openMotor or BurnSim import too.
2 · Design
Stack grains and build each core from sections: round, star, finocyl or moon, straight or tapered, or make it a D grain or an end burner. Results update as you type.
3 · Optimize
Set the throat to size itself for your Kn or pressure, set a mass flux limit, and search for the core that gives the most impulse within it.
4 · Export
Check the burn, then save the motor for openMotor or BurnSim, a thrust curve for OpenRocket, and the casting mandrel for printing or machining.
What it does
01
Tick the dimensions that may change, pick a goal (most impulse, most propellant, lowest peak flux, flattest thrust curve, a target impulse, longest burn or a target burn time) and the limits that must hold, and Find the best searches for the core. Every candidate is a full burn simulation, kept under your mass flux and pressure limits and above your port-to-throat minimum. Sweep one setting for a chart, or two for a map.
02
Fit the burn rate from your test firings in RustPEP, then press Add to RustCore library on its Export page. The propellant arrives with its density, burn-rate fit, c* and efficiency, gamma, flame temperature, molar mass and the firings themselves, ready to pick on RustCore’s Propellant page. Refit it in RustPEP and add it again to update it.
03
A grain’s core is a chain of sections, each round, star, finocyl or moon, and each straight or tapered, so a taper at the head end and a finocyl at the nozzle end can be one grain. A D grain, a flat slot down the grain that can also taper, takes a grain to itself. An end burner starts with a solid section and burns from its nozzle end only, which can be flat or have a cone or drilled hole for more thrust at ignition. Grains stack, and each end face either burns or is inhibited. Moon and D-grain cores are drawn in cross-section to scale as you set them, with sliders that move the offset live and the web thicknesses written out.
04
Gas made along the core funnels toward the nozzle, so in a long motor the mass flux climbs toward the aft end, and above a threshold erosive burning sets in. RustCore charts the flux along the motor at ignition and at its worst during the burn, against your limit, and gives the smallest aft port that holds it.
05
The Design page shows every result twice when you ask it to: the standard simulation, and beneath each number the same motor with erosive burning — designation, peak pressure, mass flux, burn time and peak thrust, with how far each moved. The limit check judges both, so a motor that stays under its case rating only because erosion was left out is flagged. Once predicted, the erosive figures follow your changes until you press Stop. Before that, the page says plainly that its numbers leave erosion out, and more firmly as the mass flux nears your limit. A prediction is not the baseline with bigger numbers: erosion is worst near the nozzle, so that end burns through first, and the peak pressure can come out lower than the no-erosion figure while the motor is in worse shape. The Burn page has the full picture: the burn rate along the core, both curves drawn together, and a checklist of what the chosen method still needs, where every missing input has somewhere to go — nothing is ever reported as having no place to enter it. Where that input is a propellant property only RustPEP can supply, **Open in RustPEP** takes you straight to that field of the recipe in RustPEP, on the right page with the entry box already open; it needs an installed RustPEP 0.64 or later that has been started once, since the portable copy does not register the link and the button stays hidden there. One button calibrates a method against your own erosive firings or validates it, whichever the method calls for. Research only — no method’s citation has been checked against its source paper, and fitting a method to your data does not establish that it describes a motor. Confirm by static test before you design around it.
06
Chamber pressure, thrust, Kn and the flux at every station along the motor, step by step through the burn, with the motor class, total impulse and delivered Isp. Move a slider through the burn to see the port and a slice of the grain burning back.
07
Let the throat size itself for a target peak Kn, starting Kn or peak pressure while you shape the core, so every core is compared at the same Kn. Switch to a fixed diameter once you have a real nozzle.
08
Reshape a round core into short tapers that bring the worst flux to the same target at every point along it. Use it to see the ideal shape, then simplify it to a double taper you can make.
09
A live 3D model with grain, cutaway and mandrel views. A double-taper core cannot be pulled out in one piece, so RustCore splits the mandrel where each piece can slide out of its own end, or says to use a lost core. Save the grains or the mandrel as STL or STEP.
10
Save the whole motor as an openMotor .ric file, which BurnSim 4 also opens, or as a BurnSim 3 .bsx file. Also a RASP .eng thrust curve for OpenRocket and RockSim, and CSV. Every export lists anything it had to approximate.
11
Import a propellant from openMotor’s library or a .ric motor, or from BurnSim’s propellant list or a .bsx motor. A design keeps its own copy of its propellant, so changing the library never changes a saved motor.
A look around
Screenshots from alpha 0.1.0, using example motors that go past their limits, so the warnings show. Click one to see it full size.
Specifications
| Application | |
|---|---|
| Current version | 0.24.0 beta |
| Platform | Windows, 64-bit (x64) |
| Units | Inches, psi and pounds, or millimetres, MPa and kilograms |
| Design file | RustCore design (.rcore), JSON in SI units |
| Other platforms | To be determined |
| Windows packages | Setup program (.exe), MSI installer, portable .zip; code-signed; updates itself |
| Geometry | |
|---|---|
| Core shapes | Round, star, finocyl and moon; each section straight or tapered. D grain, straight or tapered, as a grain of its own. End burner (solid section), flat or with a cone or drilled hole at its nozzle end |
| Grains | Any number, stacked; each end face burns or is inhibited; the outside is bonded to the tube |
| Burnback, round cores | Exact, as bodies of revolution, including tapers and steps |
| Burnback, other cores | 3D distance field refined against the outline; within about 1 to 2% of closed-form BATES results |
| Ballistics | |
|---|---|
| Model | Steady-state; burn rate r = a · Pn, with pressure ranges if the exponent changes |
| Results | Chamber pressure, thrust, Kn, port-to-throat ratio and mass flux along the motor through the burn; motor class, total impulse, burn time and delivered Isp |
| Nozzle | Throat sized for a target Kn or pressure, or fixed; nozzle efficiency and cone half-angle |
| Erosive burning | Predicted by a coupled march over time: each station burns at its own rate, and chamber pressure follows the burning area weighted by erosion rather than the plain Kn. Five methods compute — a control applying none, Lenoir-Robillard, Mukunda-Paul, a threshold-linear fit, and Ma et al. (2020), which matches all twenty of its reference points to one part in a million and needs no calibration of its own. King is registered as provisional and computes nothing: its papers have not been read, so there are no equations to implement, and it carries its requirement list so you can see what it would need rather than finding it silently missing. Research only: no method’s citation has been checked against its source paper, and nothing has been validated against real firings |
| Fitting erosive parameters | Fit a method’s parameters to your own static-test traces, against the whole pressure curve, with a residual you can judge. A base-rate firing is refused by name, since a low-flux firing carries no information about erosion. Fitted values stay in RustCore until you enter them in RustPEP, which owns what a formulation carries. Propellant properties you enter in RustCore, such as the burning-surface temperature, can be sent to RustPEP as a suggestion you accept or decline there; RustCore clears its own copy once RustPEP’s library carries the value. Fitting a method to your data does not establish that the method describes a motor |
| Not modelled | The axial pressure gradient — pressure is lumped, so there is no separate aft-end pressure — and the ignition and tail-off transients |
| Checked against | The original double-taper spreadsheet (core area, Kn and aft mass flux reproduced); openMotor 0.6.2 (Kn and peak pressure within about 1%); all 64 values of the shared erosive-burning fixture set, 24 point and 40 station checks, to one part in a million against an independent reference RustPEP and RustStand also check against |
| Studies | |
|---|---|
| Find the best | Most total impulse, most propellant, lowest peak flux, flattest thrust curve, a target impulse, longest burn or a target burn time; within mass flux, pressure and port-to-throat limits; coarse scan, then Nelder-Mead refinement |
| Sweep | One setting for a chart, two for a map |
| Constant-flux taper | A round core reshaped so the worst flux meets a target along its length |
| Exchange | |
|---|---|
| Motor export | openMotor .ric (BurnSim 4 opens it too); BurnSim 3 .bsx; RASP .eng |
| CAD export | STL and STEP, for the grains or the casting mandrel in its pieces |
| Data export | CSV of the burn, and of the core diameter every millimetre for turning a mandrel |
| Propellant import | RustPEP 0.39.0 or later, straight into the shared propellant library or as a RocketSalvo propellant file (.rsprop); openMotor library or .ric motor; BurnSim propellant list or .bsx motor |
Works with
RustCore designs the core; openMotor and BurnSim remain the place to simulate and share the finished motor. Tapered round cores go to openMotor as conical grains. BurnSim 3 has no tapers, so they are cut into short stepped grains for it.
openMotor, BurnSim, OpenRocket and RockSim are separate programs by their own authors. RocketSalvo is not affiliated with any of them.
RustCore needs a measured burn rate. RustPEP fits one from your test firings.