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.

Single-instance

Energy

Multi-Period OPF

134K variables · 293K 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

Energy

Solar Data-Fitting

102K variables · 104K constraints · SOCP

90× faster

than Clarabel

Moreau 8 s

Clarabel 12 min

Batched

Control

Robotics MPC

1K variables · 1K constraints · QP · batch of 512

162× faster

than Clarabel

370× faster

than Mosek

Moreau 79 ms

Mosek 29.2 s

Clarabel 12.8 s

Finance

Portfolio

2K variables · 2K constraints · QP · batch of 1000

160× faster

than Mosek

270× faster

than Clarabel

Moreau 200 ms

Mosek 32 s

Clarabel 54 s

Forward pass only, compile time excluded. Moreau CUDA on H100 vs Mosek 11 and Clarabel on AMD EPYC 9554P (64-core, bare metal). Batched Mosek/Clarabel times are multithreaded solves.

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

info@optimalintellect.com

Moreau

Core Capabilities

Solve thousands of problems at once

Backpropagate through the solve

Benchmarks

Multi-Period OPF

HVAC MPC

Solar Data-Fitting

Robotics MPC

Portfolio

Drop-in API

On-Prem Deployment

Native Framework APIs

Code Generation Coming

Estimation & Control Coming