The solver under the stack.

Power-system optimisation problems have structure a generic solver ignores. CEMeridian is our own engine, built in Rust for exactly those shapes — and measured, publicly and honestly, against the best open and commercial baselines. Several CE products run on it in production.

Talk to us Licensing

5 native engines + autoCertified independent KKT checksRust no runtime dependencies

What it does

Fast where it matters, honest where it isn’t.

Built for power systems

Grid dispatch, nodal markets, unit commitment, contingency security, capacity expansion — the engine exploits the structure these problems share, while staying a fully general LP/MILP solver.

Auto routing

One entry point reads the model and routes it to the measured-winning engine — interior point, simplex, first-order, branch-and-cut or decomposition — and reports why, so the choice is auditable.

Certified, not just fast

An independent verifier with no solver code in its call graph re-checks answers; claimed-optimal solutions that fail certification return a non-zero exit code, so your CI can gate on honesty.

The certifier

A solver should prove what it reports.

Solvers fail quietly. A stale factorisation. A tolerance met in scaled units but not in yours. A status code that flatters the run. So we built CEMeridian with the claim and the check as separate machinery. When they disagree, the check wins.

Optimal means checkedAn independent certifier re-checks Optimal claims in your model’s own units — not in scaled internal ones — against a fixed default tolerance of 1e-5. Primal feasibility, bounds, dual feasibility, complementarity, and the objective, all recomputed. Corrupt model data is refused at every door with a named error rather than solved.
Unproved answers refuseA solution that can’t be certified comes back as a diagnostic with the failing residual named. It is never reported as Optimal.
DeterministicRun the same model twice, you get the same answer — for a given configuration, bit for bit. Re-verified under sixteen-way co-tenancy on one box: outputs identical. A result you signed off is a result you can reproduce.
Self-escalatingCertified auto mode runs a ladder: the fast rung first, and if the certifier refuses that answer, the solver escalates itself rather than shipping it. One switch, no per-model hand-tuning.

In production today

This is what our products run on.

CEMeridian is the engine inside CECadence. It also solves GridSight’s Stage-1 dispatch LPs in production — the ~1M-variable class. Every number below is a recorded measurement: our hardware, our own products’ workloads.

8 / 55 msWarm re-solve medians on CECadence’s two production model sizes. Fleet dispatch runs on resident sessions — the factorised model stays in memory and re-solves the moment bounds change.
Bit-identicalObjectives matching the prior engine’s baselines across the full 518-test product suite.
2.03×GridSight market dispatch vs the open-source incumbent — a 942k-variable balancing LP from the GridSight stack, solve wall 99.4 s vs 202.2 s, same machine, objective agreement to 5×10⁻⁹ relative. Production serving runs on the certified Stage-1 class.
2.0×Half the factorisation work on a certified warm re-solve of a large planning block — 61 matrix factorisations vs 122 cold, a hardware-independent count.

The certified board

Eight hard blocks. One door. Eight certificates.

A capacity-expansion sweep is only as trustworthy as its worst block. So we took eight large blocks from a real continental-scale planning study — including the ones that had defeated us before — and ran them through certified auto: one setting, zero per-block tuning, the solver’s own ladder deciding how hard to work on each. Every one came back Optimal and certified. In late August 2026 the board stood at eight of eight, up from four of six earlier the same month.

133 sThe flagship block certifies on the first rung in 133 s, agreeing with its reference anchor to 9.5×10⁻¹⁰. Three more clear that same first rung at 110 s, 116 s and 203 s; a fourth is refused there, escalates itself, and certifies at 433 s.
refused → certifiedOn four of the eight blocks the fast rung produced an answer the certifier refused. None of those answers shipped. The solver escalated and came back with a certificate on each.
≤ 4×10⁻⁸Seven blocks carry a cross-validated reference anchor. Our certified objective agrees with all seven to within 4×10⁻⁸ relative, and with five of them to 10⁻¹⁵ or exactly.

For the quants

Measured results, every number traceable.

Large networks1.7–4.4× the leading open-source solver on real multi-period grid cases, objectives matching to 1e-10; 5.9× on a 6,626-bus European dispatch leaf.
DecompositionWarm-started multi-cut Benders that beats both the monolith and the baselines on multi-scenario expansion — and returns a certified bound with a feasible plan on continental cases where open and leading commercial solvers alike time out.
Contingency screeningA GPU-resident N-1 screener runs 31× faster than a single core — a capability with no open-source analogue.
Honest negativesSmall dispatch LPs and some monolith relaxations still favour the incumbents — measured, published, and on the roadmap rather than hidden.
InterfacesRust and CLI; Python over SciPy sparse arrays; a panic-safe C ABI; a JuMP/Julia binding. No JSON on the hot path.
ProvenanceEvery algorithm traces to public literature; the leading open solver is kept permanently as the correctness oracle. No reverse engineering.

Commercial licensing: CEMeridian ships inside CE products and is licensed separately to teams that want the engine under their own models. Every benchmark claim traces to a saved, reproducible measurement.

Licensed access

Licence the engine.

For desks and vendors with their own models: bindings for Python, C and Julia, benchmark support against your actual problems, and engineering time to wire it in.

hello@compoundingenergy.com Contact