Built · CEMeridian
By Compounding Energy
Built · measured wins The solver core under CEGridSight, CECadence, CEForesight and CENovaSage.

A native, energy-specialised LP/MILP solver — faster than HiGHS on the shapes power systems actually produce.

Generic backends treat every problem as an arbitrary sparse matrix. Power-system optimisation isn't arbitrary: DC-OPF, nodal markets, unit commitment, N-1 security and the stochastic capacity-expansion problems underneath them have structure a solver can exploit. CEMeridian is five native engines plus decomposition and a GPU N-1 screen, with structure-aware auto routing that reads the model and picks the measured-winning engine — while staying a fully general LP/MILP solver.

Get on the early-access list See where it's used
Why this exists

A solver should know what problem it's solving.

Power-system dispatch has a per-zone block structure, predictable temporal coupling, and a small set of binary decisions that explain almost all of the integrality gap. CEMeridian is built around that structure — energy-aware cut families, symmetry handling for identical generators, decomposition primitives sized for stochastic expansion — rather than against it. HiGHS is kept strictly as the comparison and correctness oracle; it is never a product backend.

Measured against HiGHS and CPLEX

Every number traces to a saved benchmark.

Release builds, objectives matching to ≤1e-6, on the problem classes the platform runs. Approaches that measured worse are recorded as negatives so they're never re-tried — and the cells where CEMeridian is honestly behind are published with the lever to flip them.

1.9–4.4×

DC-OPF on large networks (multi-period) — IPM, augmented KKT + supernodal

2.2×

Small dispatch LPs — dual simplex, auto-routed

1.5–1.7×

Decomposed capacity expansion — multi-cut Benders, warm-started master

31×

N-1 contingency screen — GPU-resident LODF/PTDF (no HiGHS analogue)

Benchmarked head-to-head against CPLEX 22.1.2 too: on large multi-period DC-OPF it matches single-thread CPLEX (10,000-bus: 7.2 s vs 6.95 s) and beats full 24-core CPLEX on the largest network — while running ~5× faster than HiGHS on the same case. On the largest unit-commitment monolith, CPLEX does not finish (timed out past 90 minutes) where CEMeridian's decomposed, rolling-horizon path returns feasible solutions. CPLEX still leads on small UC LPs — the cell we're closing, named openly in the forward plan.

Also measured: unit-commitment MIPs cut from 24,555 nodes to 7 via gated root cuts; very large / matrix-free LP at 3.4× via GPU PDHG. Honestly behind on small monolithic DC-OPF and capex LPs (0.3–0.75×) — the factor wall at small dimension, with the lever named in the forward plan.

The engines, and auto

Five native engines plus decomposition — each winning a different shape.

backend = "auto" reads the model and routes it to the measured-winning engine — integers to MIP, small LPs to dual simplex, dense PTDF rows to simplex, sparse network LPs to interior point — and reports the choice and the reason so the routing is auditable. The selector is density-aware, measured-data-driven, and now the default.

Interior point

The large-network workhorse

Mehrotra predictor-corrector with Gondzio correctors, Ruiz equilibration, auto-selected Newton system (normal vs augmented KKT), supernodal Cholesky, warm starts and crossover.

Simplex

Small-LP & warm re-solve

Revised primal (EXPAND anti-degeneracy) and dual (warm solve_from_basis reoptimisation) — the engine for warm re-solves and crossover.

PDHG / PDLP

Past factorisation

Matrix-free first-order with restarts, adaptive steps, primal-weight balancing, infeasibility certificates, and a working GPU device with fused mega-kernel iterations.

MIP

Energy-aware branch & cut

Best-first B&B with reliability branching, node warm-starts, feasibility-pump / diving / RINS, and gated root cuts (lifted covers, MIR/CMIR, flow-cover, clique, GMI) with per-cut validity proofs.

Decomposition

Block-angular structure

Single- and multi-cut Benders with Farkas feasibility cuts, per-block parallel subproblems, and a warm-started master — the change that made decomposed expansion beat both the monolith and HiGHS.

GPU N-1 screen

Security at speed

A GPU-resident LODF/PTDF contingency screener for security-constrained workflows — 31× on one core, with no HiGHS analogue.

Interfaces

One solver, four ways in — no JSON on the hot path.

The CSC array feed is the universal solver convention (HiGHS / Gurobi / OSQP-style); row duals (LMPs / shadow prices) come back exact from the vertex engines and are validated against HiGHS.

Rust / CLI

cemeridian solve with MPS and a fast binary format; convert and --relax built in.

Python

A maturin-built wheel: cemeridian.solve_lp(...) over SciPy CSC, returning primal, row duals and reduced costs.

C ABI

A panic-safe, C-validated header — CSC arrays + duals, a typed problem builder, the decomposition entry point and the GPU N-1 screen.

Julia / JuMP

A MathOptInterface optimiser over the CSC C ABI — Model(CEMeridian.Optimizer), drop-in.

Scope & provenance

A solver, not a model — and an honest one.

Three tiers: the solver (domain-agnostic engines + decomposition), a shared energy-physics layer (PTDF/LODF, dispatch, commitment, storage, investment — composing the problem plus the decomposition structure the solver exploits), and the products that own the data and UX and call in via the bindings. The energy specialisation also lives inside the solver: UC-aware cuts, generator symmetry handling, stochastic-expansion primitives.

Every algorithmic piece traces to public references — papers, theses, permissively-licensed implementations. CEMeridian does not reverse-engineer commercial solvers. Correctness is held by oracle tests against HiGHS on objectives, duals and reduced costs, per-cut integer-hull proofs in the MIP, and never-wrong-to-be-fast fallbacks on every warm path.

Status

Built — measured wins.

Pre-1.0, with test suites green across the workspace and the structure-aware auto selector shipped as the default. It runs behind the platform today as a selectable, cross-validated backend: each product can call CEMeridian or HiGHS interchangeably, the LP-value-and-duals correctness gate runs in CI on every push, and CEMeridian becomes a product default per workload once its performance gate is signed off in production.

Request early access CECadence runs on it Back to all products