GPU-native convex optimization

Moreau

A compiled solver for conic programs.
Differentiable. Batched. PyTorch and JAX native.

import moreau

solver = moreau.Solver(P, q, A, b, cones=cones)
solution = solver.solve()

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)       # GPU-accelerated solve

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(P, q, A, b, cones=cones)
solution = solver.solve()
solution.x.sum().backward()           # gradients through the solve

from moreau.jax import Solver

solver = Solver(P, q, A, b, cones=cones)
solution = solver.solve()

def loss(q):
    return Solver(P, q, A, b, cones=cones).solve().x.sum()
grad_q = jax.grad(loss)(q)

GPU-Native

Interior-point method on GPU via cuDSS. Up to 100× faster than CPU solvers on an H100.

Batched

Solve many instances in parallel. One compile, many solves.

Differentiable

Exact gradients through KKT conditions. Forward and backward pass on GPU. PyTorch and JAX native.

Up to 100× faster on H100

4–14×

faster

Power Systems

9–35×

faster

Model Predictive Control

25–99×

faster

Portfolio Optimization

vs. state-of-the-art CPU solvers.

Applications

Moreau is relevant wherever convex optimization appears in a loop.

Control

MPC and MHE for robotics, buildings, autonomous systems.

Finance

Portfolio optimization, risk management, trading.

Energy

Optimal power flow, dispatch, grid operations.

Optimization Layers

Embed constrained optimization inside neural network training loops.

Optimization Layers

A layer in your neural network that solves an optimization problem

An optimization layer maps inputs to the solution of a convex optimization problem. The layer is differentiable, so gradients flow through the solve and the entire network trains end-to-end.

This lets neural networks make decisions that respect hard constraints — physics, budgets, safety limits — by construction, not by hope.

Learn more →

Neural Network Layer

Optimization Layer

minimize f(x; θ)

s.t. g(x; θ) ≤ 0

Loss

∇ gradients

Team