Reactor Physics

Every other Neutronics page tells you what to do. This one tells you what the simulation actually computes to decide the outcome. A reactor isn't a number that ticks up — it's a small neutron-transport-and-heat model solved from your actual block layout every tick. Read this if you want to know why a packed cube breeds and a spread core doesn't, why the k gauge dips as xenon builds, or why pushing past cruise runs the fuel hot instead of just faster.

Nothing here changes how you play — it's the model under the meters. If you only want to run a reactor safely, the overview and Fuel & Isotopes are enough.

What a tick computes

Each tick the engine takes the persisted heat + neutronics state, your scanned block lattice, and the elapsed time, and returns the next state plus effects as pure data — no hidden state, fully deterministic. A single tick simulates at most a few minutes of elapsed time (the online-gating grace window); longer gaps resume where they left off, so nothing accrues while nobody's home.

Long elapsed times are split into sub-steps of at most one second each for numerical stability, and the whole pipeline below runs per sub-step. Heat is conserved to a rounding epsilon end to end: every unit produced is either captured to the coolant loop, vented, radiated from the hull, or still sitting in a cell — none vanishes or appears.

The tick, step by step

The flux field is solved once at the top of the tick; the thermal and kinetics pipeline then runs each sub-step against it.

1. Flux solve → criticality (k-eff)

The engine solves the neutron flux shape across your lattice by fission-source power iteration — a few Jacobi sweeps (more on a cold start, fewer when warmed from the persisted flux). Fuel cells are neutron sources (scaled by their adjacency amplification); every cell absorbs (fuel, moderator, coolant, inserted control rods, and any accrued xenon) and leaks neutrons from its faces that touch open space (reflectors return a fraction of that leakage).

From that converged shape it computes k-eff — the dominant eigenvalue, production ÷ loss. k > 1 is supercritical, < 1 subcritical, = 1 exactly critical. This is a stable geometry property: a well-reflected, low-leakage core is inherently more reactive than a leaky one. Loading fertile material adds absorption, which lowers k — that's the "attention tax," power traded for breeding, and it falls straight out of the eigenvalue balance.

2. Doppler self-limit

As fuel heats, reactivity falls: the feedback term is −alphaD × (meanFuelTemp − tRef). This is the reactor's built-in brake. Throttle up, the fuel warms, k drifts down, and the core settles at a steady power instead of running away. It's why a burner at cruise holds itself — you're not balancing on a knife-edge, the physics pulls back toward equilibrium on its own.

3. Point kinetics + the demand-follower servo

Amplitude A is the throughput dial — the actual power level the flux shape is running at. How it updates depends on one config knob, amplitudeRestore:

• Shipped default (amplitudeRestore > 0). The control rods act as a demand-follower: a stable first-order relaxation trims A toward the throttle set-point, and the physical feedback (Doppler − xenon) rides on top as a small power defect. This is a reactor operator holding a power level by trimming rods — a control action, not a prompt excursion. It's what keeps a cruising reactor self-holding and idle-safe.
• Pure point kinetics (amplitudeRestore = 0). No servo; the flux-derived reactivity drives the amplitude directly through the delayed-neutron kinetics. This is the mode the criticality/Doppler/prompt-critical physics tests run in, not the shipped game.

What the console k gauge really shows. Under the shipped servo, the gauge is not the raw eigenvalue — a fully-enclosed core has almost no leakage and its raw eigenvalue reads absurdly supercritical, which would scream "prompt critical!" on a perfectly healthy reactor. Instead the gauge reads 1 + the feedback deviation (Doppler + xenon around critical): it sits near 1.0 and dips as poison builds, exactly what a real operator watches. The servo holds the power; the gauge shows how far feedback has pushed the core off critical.

When reactivity outruns the delayed-neutron margin (ρ ≥ β) the tick fires a one-shot prompt-critical event — that's the source of the white-blaze + klaxon, never a meter diffed across ticks.

4. Xenon dead-time (I-135 → Xe-135)

Fission stages iodine-135, which decays into xenon-135 — a strong neutron poison that also burns off under flux. The pool follows the real coupled ODEs (build from direct fission + iodine decay; loss from decay + flux burn-off) per zone. This produces the classic behaviours: a dip-then-rise after a power change, and a dead-time peak after shutdown, when the flux that was burning xenon off vanishes but iodine keeps decaying into more of it.

Real xenon dead-time is ~9 hours; the sim compresses it (xenonTimeScale) into a playable band so you actually see it in a session. The core is partitioned into up to two xenon zones along its longest axis (only once it has enough fuel — below a fixed fuel-count floor it's one lumped zone); a zoned core can show flux oscillating between halves. The zone count and the fuel floor are fixed engine structure, not config knobs.

5. Per-cell thermal + meltdown

Each cell stores energy; its temperature is energy ÷ heatCap. Within the sub-step, in order: fuel produces heat (∝ amplitude × its adjacency amplification); heat conducts between neighbours (symmetric, conservative); capable exchangers pull heat from a shared pool of all hot fuel into the coolant loop; turbines convert loop heat into Drive Cells; vents remove heat to open space (wasted but safe); then over-cap cells melt, over-threshold heat bleeds into the hull pool, and the hull sheds a little to ambient (the passive cruise-holding term).

Meltdown is per-cell first: a cell past its own melt cap breaks, dumping its heat into the hull and its neighbours. When the hull pool reaches its ceiling, the core breaches. Plating raises that ceiling only modestly — the base ceiling stays the dominant term, so a thick shell does not buy you out of running hot. Capture rate-limits per step on purpose: at high throttle the fuel runs hotter than capture can instantly bleed off, which is exactly the overclock danger — push for more output and the core heats toward the redline.

Breeding

Breeding is gated by geometry, not a mode switch. Each fuel cell computes a net packing figure:

net        = (fuel neighbours) − (moderator neighbours)
breedFactor = clamp((net − 1.5) / 1.5, 0, 1)

• A breeder's packed 2×2×2 fuel cube gives each cell 3 fuel neighbours and 0 moderator neighbours → net 3 → (3 − 1.5) / 1.5 = 1.0 → full breeding.
• A burner — spread out and well-moderated — sits at or below the floor → breedFactor ≈ 0 → breeds essentially nothing.

The breed rate is amplitude × fluxShape × captureXS × fertile × breedScale × breedFactor, so breeding needs the packed geometry and the core run hot. Fertile (U-238) captures neutrons and transmutes to staged bred fissile (Pu-239) — and because fertile absorbs, loading it lowers k. That's the trade: the eigenvalue solve itself allocates the neutron budget between power and breeding. What you breed is worth it: a Pu-239 rod's productionScale is wired to 1.5×, so it makes half again the Drive Cells per rod that a U-235 rod does. Burn tracks fissions, so the rod lasts just as long — it simply produces more per fission — while its low delayed-neutron fraction (β ≈ 0.0021) makes it twitchier to drive. Pu-239 is premium for both reasons: more power and harder to hold, not merely because it's a hassle to breed.

The over-breed walk. Left cooking under flux, bred Pu-239 doesn't just stop at a poison — it walks the full actinide chain: Pu-240 (a poison whose spontaneous fission leaves an amplitude floor that resists SCRAM) → Pu-241 → Am-241, which forks into Cm-244 and Pu-238. Those are the deep actinides. Of the four, Am-241 and Pu-238 are usable — they withdraw as themselves for dedicated uses (neutron source / RTG) rather than consolidating to waste; the rest are poisons or waste. The walk is keyed off the bred stock, so withdrawing your Pu-239 stops it. Breeding is therefore a harvest-timing skill: pull the Pu-239 before it degrades. See Fuel & Isotopes for the handling side of this.

Every breeding term is proportional to a per-cell fertile / bred / actinide-walk stock, so a burner (which holds none) is byte-for-byte the non-breeding path — breeding never perturbs a reactor that isn't set up for it.

Status thresholds

The console light is driven by heat vs. redline — the greater of the hull pool's fraction of its ceiling and the hottest single cell's fraction of its own melt cap. (Hull alone is a lagging indicator — it only fills right before a breach — so the hottest-cell term keeps the gauge honest while the core is visibly running hot.)

The numbers, in full

Every knob the sim runs on. Most read live from game.yml (reactor:) — your server may retune any of them, and this table is generated from the same config the simulation reads, so it never drifts. It's grouped in advance() order, so you can read it alongside the tick walkthrough above.

Two blocks — Breeding and Fission products — have no game.yml override and show the engine defaults (flagged as such): they scale terms that are exactly zero for a burner, so they tune the breeder and the byproduct smorgasbord without ever touching a plain burner tick.

Production: reactor.production

Amplification (superlinear clustering): reactor.amplification

Point kinetics & feedback: reactor.neutronics / reactor.feedback

Xenon poison: reactor.xenon

Heat capture → Drive Cells: reactor.capture

Thermal & meltdown: reactor.thermal

Breeding — engine default, no game.yml override: Breeding

Fission products — engine default, no game.yml override (real thermal-U-235 cumulative yields): FissionProducts

Behaviour, charted

Two schematic curves for the behaviours that trip people up most. Both are illustrative shapes — they show why the model behaves as it does, not exact sim output for any one build.

See also

• Neutronics: the overview and where this fits
• Fuel & Isotopes: the fuel chain, β per fuel type, the over-breed walk, and byproducts
• Building a Reactor: the blocks, the commission gate, and burner vs. breeder geometry
• Power & Output: capture → turbine → Drive Cells and the cruise/push/redline bands
• Waste: what the byproducts consolidate into
• Neutronics Roster: every fuel, isotope, and byproduct
• Troubleshooting & FAQ: symptoms and fixes