ProxSuite solves the quadratic programs that appear twice in every robot stack

Primal-dual proximal algorithms as the common core

ProxSuite is a collection of numerically careful solvers for linear programs, quadratic programs and related problems, rooted in revisited primal-dual proximal algorithms. The word that matters is proximal. A proximal method handles a regularisation term or a constraint set by an update that is a combination of a gradient step and a projection or proximal step, and the primal-dual form handles the equality constraints alongside it. The consequence for a user is a solver family that does not need a separate interior-point or active-set implementation for every problem shape, because the same algorithmic structure covers dense, sparse and matrix-free variants. The stated aim is to offer scalable optimizers that deal with dense, sparse or matrix-free problems. The first targeted application is robotics, and the README is explicit that it can be used in other contexts without limits, which is the right way to read the robotics emphasis: it is where the requirements came from, not a boundary on the library.

The specialised paths are the actual differentiator

Most of what makes this more than a generic QP solver sits in the list of dedicated features. There is handling for box constraints, for linear programs, for QPs with a diagonal Hessian, and for QPs with far more constraints than primal variables, which is a common shape in whole-body control where the contact constraints outnumber the degrees of freedom. It solves nonconvex QPs, and it solves batches of QPs in parallel, which matters when a controller evaluates many candidate trajectories per cycle. Two of these are unusual. The solver can find the closest feasible QP if the problem appears to be primal infeasible, so a badly specified constraint set produces a usable answer instead of a hard failure. And it can differentiate feasible and infeasible QPs, which is the operation a trajectory optimiser needs when it takes a gradient of the solution with respect to the problem data. That last one is the feature most likely to matter to an advanced user, because without it an outer loop optimising over solver outputs has nothing to differentiate through.

A header only library with Python and Julia bindings

ProxSuite is written as a C++ template library and is header only, so there is no build step to link against beyond your own compile flags, and the README lists it as C++ 14, 17 and 20 compliant. The C++ side is described as cache-friendly, and the recommended compile line for the dense example enables vectorisation. Python and Julia bindings are provided for prototyping without giving up performance, and the repository has example directories for C++, Python and Julia. The dependency set in the Python package metadata is deliberately small, numpy at 1.24 or newer and scipy at 1.8 or newer, and Python 3.10 is the floor. The README characterises the library as fast, versatile, flexible and extensible, and as reliable and extensively tested, showing the best performances on the hardest problems of the literature. Whatever you make of the adjectives, the structural claims are the checkable ones: templates, header only, bindings, and a build that produces no library artefact to link.

Installing from pip, conda, brew or pixi

The distribution is broad, which is the point of a library that other tools depend on. The Python install is a single command, and it works on Linux, Windows and Mac OS X.

   pip install proxsuite

Conda users get the same package from conda-forge.

   conda install proxsuite -c conda-forge

And there is a Homebrew route, available on Linux and Mac OS X.

   brew install proxsuite

For development, the project uses pixi, with a build target and a test target.

pixi run build

pixi run test

That approach is described as available on Linux, Windows and MacOS on both Intel and Apple Silicon. Installation from source is documented separately, in the installation page of the project documentation, and the repository also carries a `flake.nix` and `flake.lock`, a `pixi.toml` and `pixi.lock`, a `CMakeLists.txt` at the root, a `cmake/` directory, and `pyproject.toml` and `setup.cfg` for the Python package.

Compiling an example and consuming the library from CMake

The README gives a compile line for the dense example that turns on optimisation and vectorisation, and it pulls the include paths from the installed package with pkg-config.

g++ -O3 -march=native -DNDEBUG -std=gnu++17 -DPROXSUITE_VECTORIZE examples/first_example_dense.cpp -o first_example_dense $(pkg-config --cflags proxsuite)

The CMake path is the one you want for a real project, and the example is short enough to read in full.

cmake_minimum_required(VERSION 3.10)

project(Example CXX)
find_package(proxsuite REQUIRED)
set(CMAKE_CXX_STANDARD 17) # set(CMAKE_CXX_STANDARD 14) will work too

add_executable(example example.cpp)
target_link_libraries(example PUBLIC proxsuite::proxsuite)

Two details are worth copying. The imported target is `proxsuite::proxsuite`, so the include directories and compile definitions travel with the target rather than being set by hand, and the C++ standard is a choice you make in your own project, with 14 noted as working too. The comment about vectorisation support in the README continues past the visible excerpt, so the full list of `PROXSUITE_VECTORIZE` options is worth reading in the project documentation before you commit to a flag set.

Already embedded in three optimisation ecosystems

The strongest argument for adopting ProxSuite is that other projects have already adopted it. It is integrated into CVXPY, the modelling language for convex optimisation problems, which means you can reach the solver from a Python modelling layer rather than calling it directly. It is integrated into CasADi's symbolic framework for numerical optimisation and optimal control, where ProxQP is available as a plugin to solve quadratic programs. And it is integrated into TSID, the robotic software for efficient robot inverse dynamics with contacts, which is built on Pinocchio. That last integration is the most telling, because inverse dynamics with contacts is exactly the regime where the specialised features matter: the problem is a QP with many more constraints than degrees of freedom, and it is solved repeatedly inside a control loop. Being the solver underneath TSID is a stronger statement about fitness for robotics than any benchmark in the README, and the README notes the maintainers are ready to integrate ProxSuite into other optimisation ecosystems.

Maintenance, governance and what the licence lets you do

ProxSuite is actively developed and supported by the Willow and Sierra research groups, which are joint research teams between Inria, École Normale Supérieure de Paris and the CNRS in France, and the README links to both groups. The release history shows v0.8.0 on 2026-10-19, v0.7.3 on 2026-05-11 and v0.7.2 on 2025-03-12, and the last push to the repository was on 2026-10-19, with the default branch named `devel`. The licence is BSD-2-Clause, which is permissive, requires that the copyright notice and licence text travel with copies, and adds no copyleft obligation to code you link against it. For a solver that other people's frameworks wrap, that is the licence that lets it be embedded without friction. The repository also carries a `CHANGELOG.md`, citation files in both `CITATION.bib` and `CITATION.cff` formats, and the documentation asks you to cite ProxQP and QPLayer specifically, which suggests the project expects academic and industrial users to reference the individual solvers rather than the umbrella library.

Editorial conclusion

Adopt ProxSuite when your control stack solves quadratic programs often enough that solver choice changes your loop time, and you want a single API across dense, sparse and matrix-free formulations. Skip it if your problem is small and well conditioned, since the specialised paths only pay off at scale, or if you need global optimality guarantees for a nonconvex problem. Before you commit, benchmark against the solver you already use on your own formulation, and read the infeasibility and differentiation features carefully, because a solver that returns the closest feasible problem instead of failing is a different contract from one that reports infeasibility.

Frequently asked questions

Official sources

1. Issues
2. License: BSD-2-Clause
3. README
4. Releases
5. Simple-Robotics/proxsuite on GitHub