By the creators of CVXPY & CvxpyLayers

Moreau

Problem Data

CPU · GPU

Moreau

batched · differentiable

Solution

The fastest differentiable convex solver for production systems.

Commercial licensing. Academic access by request.

Request Access

Solve thousands of problems at once

Compiled KKT factorization with all memory allocated upfront. Run parallel sparse solves on CPU or GPU with zero per-solve overhead.

Interior-point method. One compile, many solves.

Backpropagate through the solve

Get exact gradients via implicit differentiation on KKT conditions. The backward pass reuses the forward factorization, so differentiation is nearly free.

Deterministic. Same API on CPU and GPU.

Deterministic / CPU + GPU / Allocation-free

Benchmarks

NVIDIA H100 80GB. Compile time excluded. All times in ms.

Energy

Multi-Period OPF

54K variables · 127K constraints · LP

24× faster

than Mosek

43× faster

than Clarabel

Moreau 0.25 s

Mosek 5.9 s

Clarabel 10.7 s

Control

HVAC MPC

123K variables · 181K constraints · QP

28× faster

than Mosek

39× faster

than Clarabel

Moreau 3.8 s

Mosek 107 s

Clarabel 146 s

Finance

Multi-Period Portfolio

45K variables · 72K constraints · QP

7× faster

than Mosek

16× faster

than Clarabel

Moreau 0.19 s

Mosek 1.3 s

Clarabel 3.1 s

Single solve, forward pass. Moreau CUDA on H100 vs Mosek 11 and Clarabel on AMD EPYC 9554P (64-core, bare metal).

Drop-in API

import moreau

solver = moreau.Solver(P, q, A, b, cones)
solution = solver.solve()
print(solution.x, solver.info.status)

import cvxpy as cp

x = cp.Variable(n)
objective = cp.Minimize(0.5 * cp.quad_form(x, P) + q @ x)
constraints = [x >= 0, cp.sum(x) == 1]
problem = cp.Problem(objective, constraints)

problem.solve(solver=cp.MOREAU)       # compiled solve (CPU or GPU)

from cvxpylayers.torch import CvxpyLayer

x = cp.Variable(n)
q_param = cp.Parameter(n)
objective = cp.Minimize(cp.sum_squares(x) + q_param @ x)
constraints = [x >= 0]
problem = cp.Problem(objective, constraints)

layer = CvxpyLayer(problem, parameters=[q_param],
                    variables=[x], solver="MOREAU")
x_opt, = layer(q_val)                # differentiable forward pass
x_opt.sum().backward()               # gradients flow through

from moreau.torch import Solver

solver = Solver(n, m, P_row_offsets, P_col_indices,
                A_row_offsets, A_col_indices, cones)
solver.setup(P_values, A_values)
solution = solver.solve(q, b)
solution.x.sum().backward()           # gradients through the solve

from moreau.jax import Solver

solver = Solver(n, m, P_row_offsets, P_col_indices,
                A_row_offsets, A_col_indices, cones)
solution = solver.solve(P_data, A_data, q, b)

def loss(q):
    return solver.solve(P_data, A_data, q, b).x.sum()
grad_q = jax.grad(loss)(q)

View Docs

On-Prem Deployment

Runs fully air-gapped inside your VPC with no external network calls.

Native Framework APIs

First-class support for Python, PyTorch, JAX, C++, and Rust.

Code Generation Coming

Compile a CVXPY problem into a standalone Rust or C++ binary via moreaugen. Zero Python runtime overhead.

Estimation & Control Coming

High-level frontends for MPC, MHE, and trajectory optimization via moreau-control.

Enterprise use requires a commercial license. Academic access by request.

Request Access

[email protected]

Moreau

Core Capabilities

Solve thousands of problems at once

Backpropagate through the solve

Benchmarks

Multi-Period OPF

HVAC MPC

Multi-Period Portfolio

Drop-in API

On-Prem Deployment

Native Framework APIs

Code Generation Coming

Estimation & Control Coming