Verifiable Simulation Platform for Advanced Reactors
Simulation outputs aren't enough. Regulators, reviewers, and partners need evidence.
Take a small modular reactor from concept to a full-core design, the safety numbers, and a cost estimate — in one auditable run. Every result ships as a verifiable evidence bundle a colleague, reviewer, or regulator can reproduce offline. Screen fast in pure Python, then escalate the same inputs to a lab-grade Monte Carlo code (OpenMC) when a number has to hold up. Prove every number. Reproduce it offline. Screen fast — escalate when it counts.
Currently in private beta. Access is request-only during the beta, and install is from source (Python 3.11+) — a public package is on the roadmap, not yet on PyPI. Email us for early access.
Concept to core design, in one auditable loop.
Most fast reactor-physics tools model a single fuel slice and extrapolate. SMRFORGE's nodal engine already gives you the whole core — a real full-core power shape, validated to +19 pcm on the analytic IAEA-2D benchmark, free in the Community tier. Pro turns that core model into a design: it couples thermal-hydraulics and multi-cycle burnup into the loop, escalates to advanced deterministic transport where fidelity has to be defensible, and hands you the control and safety numbers you actually design against — rod worth, shutdown margin, and reactivity coefficients — plus a cost estimate and the assurance bundles regulators read.
Lattice → few-group homogenization → full-core 3-D nodal diffusion, with transverse-integrated nodal-expansion (NEM) intra-node flux moments and CMFD acceleration. The same engine solves hex (SFR/LFR, prismatic HTGR, heat-pipe micro), Cartesian, and R-Z cylindrical cores — a real power shape, not a pin-cell guess. Closes the analytic IAEA-2D benchmark to +19 pcm; the hex engine's leakage is Monte-Carlo-validated against OpenMC.
Rod worth, shutdown margin, reactivity coefficients, coupled thermal-hydraulics with safety margins, and multi-cycle fuel burnup — the outputs a safety case is built on.
Sweep hundreds of core options in seconds to minutes at screening fidelity — no HDF5, MPI, or license server. Then spend the minutes-to-hours of high-fidelity Monte Carlo (OpenMC) only on the few that have to be defensible. Same inputs, both results, one bundle.
The strongest test of a reactor model is a real reactor.
SMRFORGE's full-core nodal engine closes the analytic IAEA-2D PWR benchmark to +19 pcm and conserves lattice-to-core reactivity to about 1 pcm — code-vs-published-reference results you can reproduce yourself in the free, MIT-licensed Community tier. On a real commercial-PWR benchmark, BEAVRS Cycle-1, the reference-grade OpenMC oracle matches the measured critical boron to about +18 ppm (C/E 1.019) with the geometry modeled to BEAVRS spec; we publish the residual, not just the headline.
Full-core nodal solver — transverse-integrated NEM intra-node moments with CMFD acceleration — vs the published analytic reference. Well under a tenth of a percent.
The homogenization step conserves reactivity from the detailed lattice to the core model on real data.
Reference-grade OpenMC oracle: 993 ppm computed vs 975 ppm measured (+18 ppm), geometry to BEAVRS spec (annular Pyrex, exact BPRA patterns). A strong match on a real commercial-PWR measurement — residual published, not hidden.
Straight talk on scope. The measurement anchor above comes from the full-core design pipeline. The in-tree Monte Carlo is screening-grade by design — fast and auditable, not a high-fidelity solver. When you need a licensing-grade number, escalate to OpenMC. We publish where the fast path agrees with reference codes and where it doesn't, rather than hide it.
Reproducibility is the product, not a feature.
Every k-eff calc, every benchmark, every report ships as a verifiable evidence bundle. A SHA-256 manifest of inputs and outputs. A reproducibility block — Python version, dependency-lock hash, ENDF library, container digest, build provenance. A schema-versioned audit trail of every action that produced the result.
Hand the bundle to a colleague, a reviewer, or a regulator. They run
smrforge verify <bundle> offline and either reproduce your
number or refute it — checked against the open, independently-implementable
Evidence Envelope schema (a versioned spec, JSON Schema, and conformance
vectors), not a SMRFORGE-proprietary format. No "trust me, it ran on my machine."
Versioned, hashable, schema-checked. The same plumbing the dashboard uses internally is what regulators and reviewers receive — no separate export pipeline to maintain.
Dashboard built into the wheel. Zero CDN fetches at runtime. K8s manifests included. Works on a laptop with no internet, in a SCIF, or behind an enterprise firewall. The first-run demo path (smrforge first-run) ships its cross sections inside the wheel — no nuclear-data download is required to reach a k-effective number. Advanced ENDF-driven workflows stage their data separately; Pro adds verified air-gapped deployment bundles for those.
OpenAPI spec committed and CI-enforced. 6,500+ tests, golden snapshots, brand and lint gates. Every change to the public surface is reviewed before it ships.
Dashboard, API, AI tools — one process you can audit.
The SMRFORGE gateway is a single FastAPI service that fronts everything: the
React dashboard, the public REST API, and the MCP tool catalog your AI agents
call. One process, one port, one OpenAPI spec, one audit log. Launch with
smrforge serve and you're running the same surface that ships with Pro.
Dashboard, API, and tools served from a single FastAPI process on port 8765. API-key auth out of the box. K8s manifests included for on-prem and air-gapped clusters. Nothing to wire together.
Every public capability is exposed as an MCP tool. Browse the catalog from the dashboard, or call the same tools from your own agent or notebook. Pro AI Agents are clients of this catalog — your agents can be too.
Every gateway action emits a schema-versioned event into the audit trail. No CDN runtime fetches. No telemetry. The dashboard ships inside the wheel, so the whole surface runs behind any firewall — or no network at all.
The teams advancing the next generation of nuclear energy — and the workflows they run.
MIT · Open Source
Open-source neutronics, a full-core nodal engine (transverse-integrated NEM + CMFD, validated to +19 pcm on the IAEA-2D benchmark), Monte Carlo transport, thermal-hydraulics, safety, burnup, visualization, CLI, and a one-command React dashboard (smrforge serve) — all wired through the same evidence-bundle plumbing. Every run produces a verifiable bundle you can hand to a reviewer. Community is an evaluation-grade integration surface — production work generally pairs it with OpenMC (open source) or your own licensed Serpent or MCNP.
Source-available (FSL-1.1-MIT) · Licensed · Enterprise
Built on the same evidence-bundle plumbing as Community. Pro adds the templates, the workflows, and the support to take that evidence into a regulatory submission.
From lattice physics to a full-core design, coupled safety, and burnup — every capability shipped with the same evidence-bundle plumbing. The in-tree solvers are fast, auditable, and built for screening and design iteration; when you need reference accuracy, escalate the same model to OpenMC (open source), or export input decks for your own licensed Serpent or MCNP (Pro).
smrforge verify <bundle> reproduces or refutes the claim offline. The dashboard ships its own build-provenance JSON so you can verify the UI bytes match the wheel.git clone + pip install -e ., Python 3.11+). Our open work is public now at gitlab.com/smrforge: the Evidence Envelope standard, its reference verifier, and the reviewer kit. A package-manager-friendly pip install distribution is on the roadmap.smrforge serve. The React dashboard opens at http://127.0.0.1:8765 in one process — the same FastAPI gateway serves the SPA, the API, and the MCP tool catalog. The dashboard ships inside the package with no CDN runtime fetches, so it works in fully air-gapped environments.Pro licensing, partnerships, or support. Build the software that builds reactors.
support@smrforge.io