Install

Grab a binary from the table:

<table> <tr><th></th><th>Windows</th><th>Linux</th><th>Mac classic (High Sierra or above)</th><th>Mac M1</th></tr> <tr> <th>Matlab</th> <td><a href="https://github.com/casadi/casadi/releases/download/3.8.0/casadi-3.8.0-windows64-matlab2018b.zip">R2018b</a> or later</td> <td><a href="https://github.com/casadi/casadi/releases/download/3.8.0/casadi-3.8.0-linux64-matlab2018b.zip">R2018b</a> or later</td> <td><a href="https://github.com/casadi/casadi/releases/download/3.8.0/casadi-3.8.0-osx64-matlab2018b.zip">R2018b</a> or later</td> <td><a href="https://github.com/casadi/casadi/releases/download/3.8.0/casadi-3.8.0-osx_arm64-matlab2018b.zip">R2023b</a> or later (Apple Silicon)<br/><a href="https://github.com/casadi/casadi/releases/download/3.8.0/casadi-3.8.0-osx64-matlab2018b.zip">R2018b</a> or later (Rosetta)</td> </tr> <tr> <th>Octave (<10)</th> <td><a href="https://github.com/casadi/casadi/releases/download/3.8.0/casadi-3.8.0-windows64-octave7.3.0.zip">6.2.0</a> or later</td> <td><a href="https://github.com/casadi/casadi/releases/download/3.8.0/casadi-3.8.0-linux64-octave7.3.0.zip">6.2.0</a> or later</td> <td><a href="https://github.com/casadi/casadi/releases/download/3.8.0/casadi-3.8.0-osx64-octave7.3.0.zip">6.2.0</a> or later</td> <td><a href="https://github.com/casadi/casadi/releases/download/3.8.0/casadi-3.8.0-osx_arm64-octave7.3.0.zip">6.2.0</a> or later</td> </tr> <tr> <th>Python</th> <td colspan="4"><code>pip install casadi</code> (needs <code>pip -V</code>>=8.1)</td> </tr> <tr> <th>Javascript</th> <td colspan="4"><code>npm install @casadi/casadi-wasm</code></td> </tr> </table>

For Matlab/Octave, unzip in your home directory and adapt the path:

<pre> <code> addpath('&lt;yourpath>/casadi-3.8.0-windows64-matlab2018b') </code> </pre>

Check your installation:

<table> <tr><th>Matlab/Octave</th><th>Python</th><tr> <tr><td> <pre> <code> import casadi.* x = MX.sym('x') disp(jacobian(sin(x),x)) </code> </pre> </td><td>

<pre> <code> from casadi import * x = MX.sym("x") print(jacobian(sin(x),x)) </code> </pre>

</td></tr> </table>

Get started with the example pack. Onboarding pointers have been gathered by the community at our wiki.

Troubleshooting

Release notes

New frontends

CasADi gains two new language front-ends, each with a set of examples under docs/examples shipped in the example pack. This is experimental work. Users are encouraged to try it out and post any bugs.

Julia

CasADi can now be driven from Julia without Python intermediary, thanks to an extension of SWIG. The example docs/examples/julia/simple_nlp.jl should look fairly familiar to seasoned CasADi Python users:

import CasADi as ca

x = ca.SX.sym("x", 2)
f = x[1]^2 + x[2]^2          # objective
g = x[1] + x[2] - 10         # constraint:  x0 + x1 - 10 >= 0
nlp = Dict("x" => x, "f" => f, "g" => g)

solver = ca.nlpsol("solver", "ipopt", nlp)
sol = solver(lbg = 0)
println("primal solution = ", sol["x"])

JavaScript / WebAssembly

CasADi now runs in the browser and in Node.js as a WebAssembly module (#4355), distributed on npm. As JavaScript has no operator overloading, expressions are built with functional forms such as ca.plus/ca.times (from docs/examples/javascript/simple_nlp.js):

const ca = await require("@casadi/casadi-wasm")();   // load the WebAssembly module

const x = ca.SX.sym("x", 2);
const [x0, x1] = ca.vertsplit(x);
const nlp = { x: x,
              f: ca.plus(ca.times(x0, x0), ca.times(x1, x1)),  // objective
              g: ca.minus(ca.plus(x0, x1), ca.SX(10)) };       // x0 + x1 - 10 >= 0

const solver = ca.nlpsol("solver", "ipopt", nlp);
const sol = solver.call({ lbg: ca.DM(0) });
console.log("primal solution = " + sol["x"]);

The same module loads straight from a CDN (e.g. unpkg.com/@casadi/casadi-wasm), so if you are into vibecoding self-contained HTML pages, you can now drop a full CasADi optimization - IPOPT and all - into a single static .html file with no build step (see docs/examples/javascript/unpkg_demo.html).

ONNX interoperability

CasADi can now bridge to the ONNX ecosystem in two complementary ways, so that trained neural networks and other ONNX graphs can participate directly in CasADi computations:

• Black-box evaluation (#4209): an ONNX model can be loaded and evaluated as a CasADi Function, backed by ONNX Runtime. The model is treated as an opaque, dtype-aware box; derivatives are provided through finite differences, or by AD if the ONNX writer augmented the graph with appropriately-named output nodes.
• Symbolic translation (#4246): an ONNX graph can instead be imported into native CasADi expressions, and CasADi expressions can be exported back to ONNX. Imported this way, a model is differentiated analytically by CasADi like any other expression and takes part in code generation.

Both modes are driven through a new GraphBuilder class:

# Black-box: load an ONNX model and evaluate it as a CasADi Function
f = ca.GraphBuilder("model.onnx").create("f")
print(f(ca.vertcat(0.5, 1.0, -2.0)))

# Symbolic: import the model into native, differentiable CasADi expressions ...
g = GraphBuilder("model.onnx").create("g", {"symbolic": True})
# ... or export a CasADi Function back to ONNX
GraphBuilder(f).export_onnx("roundtrip.onnx")

This is a new capability and still evolving. The symbolic translation is available when CasADi is built with WITH_ONNX; the ONNX Runtime black-box backend additionally requires WITH_ONNX_RUNTIME (which forces WITH_ONNX).

More efficient matrix multiplication

CasADi was historically targeted at small/medium heterogeneous dynamic systems, where dense-dense multiplication is typically rare and not a computational bottleneck (though large sparse-sparse products do play an important role). This release closes the remaining gaps so that dense-heavy workloads are no longer penalized:

• The CasADi runtime now has a specialization for dense-dense multiplication (previously only the code generator had one) (#4292).
• The CasADi runtime and code generator now have a specialization for dense-sparse multiplication.
• mtimes, in both the runtime and the generated code, now takes an extra "BLAS argument" that selects which multiplication kernel is used. For dense problems you can choose between the built-in reference kernel, whatever BLAS CasADi was built against, and blasfeo:

  mtimes(A, B)                # default: built-in reference kernel (triple loop)
  mtimes(A, B, "reference")   # same -- explicit
  mtimes(A, B, "classic")     # whatever was built into CasADi via WITH_LAPACK (typically OpenBLAS)
  mtimes(A, B, "blasfeo")     # uses blasfeo

The blas argument is ignored when either operand is sparse.

Symbolic expressions

• det(A, lsolver) computes a determinant through a linear-solver factorization (e.g. CSparse LU, symbolic_qr) instead of cofactor expansion, making determinants of large, sparse matrices practical (#2821). Thanks @nielsvd (Niels van Duijkeren).
• B-splines now accept symbolic knots: the bspline constructor takes its knots (and coefficients) as MX, so knot positions can be supplied or differentiated at evaluation time rather than baked in at construction.
• The specialized blazing_spline now supports up to five input dimensions and a parametric-knots variant whose knots are a symbolic input.
• A new dump node provides an alternative to monitor for inspecting intermediate values during evaluation (#4306).
• kron (Kronecker product) is now backed by a dedicated MX node (#939).
• breaking: comparing an SX and an MX with == now raises an error instead of silently returning False (#2817).
• Reverse-mode derivatives of Functions with structurally-sparse (e.g. upper-triangular) inputs now behave consistently between SX and MX (#4345).
• Using linspace with MX symbols as start/end points no longer causes the number of nodes to blow up (#3531).
• Computing the Jacobian of a subset of constraints no longer produces more nodes than the Jacobian of all constraints in certain cases (#4354).
• Multiplying with a complex matrix now raises a TypeError instead of segfaulting (#4216).
• Fixed a zero-by-N inconsistency (#3977) and a non-identity transform issue in eval_mx (#2934).
• SX::set_precision is now respected when printing SX (#4326), and print_instructions is harmonized across SX and MX (#4170).

Graph optimization with transform

Expression and Function graphs can now be optimized through a single, ordered pipeline of passes, exposed as Function.transform (and as a free function transform on expressions). This is the new, consistent entry point for graph simplification, replacing the older per-type simplify methods (#4227); the simplification engine underneath has itself been substantially reworked and extended (#2069, #4219).

The syntax takes the form of a list of verbs such as combine_terms prefixed with "simplify".

# on an expression (or list of expressions):
transform(8*y - 3*y, [["simplify", "combine_terms"]])   # -> 5*y

# on a Function — an explicit pipeline, or the default flow with no arguments:
f.transform([["simplify", "combine_terms"]])
f.transform()        # default: cse + ref_count + const_folding + empty_inputs

The currently available verbs are:

• combine_terms: (old simplify) like terms are collected into a single weighted term:

  transform(8*y - 3*y, [["simplify", "combine_terms"]])   # -> 5*y
  transform(8*(5*x) - 3*(x + 3 + (12*x - x) - 17*x),
            [["simplify", "combine_terms"]])               # -> 55*x - 9
  

• const_folding: constant subgraphs are evaluated once, at build time. A product of constant matrices collapses to a single constant matrix, leaving only the symbol-dependent work (see the worked example below), and call nodes that invariably evaluated to zero are dropped (#172, #2574, #3019):

  A = MX(DM([[2, 0], [1, 3]]))
  transform(A @ A @ x, [["simplify", "const_folding"]])   # A@A precomputed to [[4,0],[5,9]]
  

• ref_count: a long-awaited class of simplifications that can make use of reference counting. There have been a great deal of on-the-fly simplifications such a+b-a -> b since a long while in CasADi. These are restricted to situations where the resultant nodes set is unconditionally beneficial. As an example, a transformation -(a-b) -> b-a is only beneficial if a-b is not used somewhere else in the graph. The list of reference-counting aware simplifications is fairly limited for now, but is expected to grow in the future.

  transform(-(a - b), [["simplify", "ref_count"]])        # -> b - a
  

• cse: common subexpression elimination: a repeated subexpression is computed once and shared rather than recomputed per use (also available as cse):

  transform(sin(x)+1/sin(x), [["simplify", "cse"]])       # sin(x) evaluated once, shared
  

• empty_inputs: a Function argument that never reaches an output is replaced by a structurally-empty matrix, flagging it as unused (#4214):

  f = Function("f", [x, p], [x**2])              # p never reaches the output
  g = f.transform([["simplify", "empty_inputs"]])
  g.nnz_in(1)                                    # 3 -> 0: input p is now empty
  

Two further pipeline verbs compose with these: expand lowers an MX Function to an SXFunction, and external applies a transform supplied by an external shared library (for plugin-defined optimizations).

Passes run in the order given; an integer before a task sets how many times it runs - a positive count runs it that many times, and 0 runs it until a fixed point - so a pipeline can be iterated to convergence.

For example, the following commands runs an unlimited amount "ref_count" passes, followed by 2 "constant_folding" passes.

f.transform("g", [["simplify",0,"ref_count",2,"const_folding"]])

Function

• A new Function.activity(mask) propagates an input "activity" mask (which input nonzeros may be nonzero) to the outputs, exploiting annihilation - an inactive operand of a multiplication kills the product - so it is strictly sharper than ordinary sparsity propagation (#3019).
• get_function() now raises a clear error instead of crashing when given an unknown name (#4238), and find_functions now descends into the oracle (#4033).
• expand now honours the expand option/generate_options (#4236), and the detect_simple_bounds helper now observes the expand option (#4235). For example, a Function constructed with 'print_instructions' now still prints the instructions after an .expand() pass.

Code generation

It is now thread-safe to evaluate code-generated non-trivial Functions (i.e. those carrying memory objects, such as NLP/QP solvers) from multiple threads at once (#2463). To make a generated Function thread-safe:

• Make sure the consumer of the generated code calls incref/decref from the main thread.
• Pass the thread_safe option as true in the code-generation step. This injects generic mutex facilities into the generated code.
• When compiling, choose one of these compiler definitions to select the threading primitive: -DCASADI_THREAD_TYPE=CASADI_THREAD_TYPE_POSIX, -DCASADI_THREAD_TYPE=CASADI_THREAD_TYPE_C11, -DCASADI_THREAD_TYPE=CASADI_THREAD_TYPE_OMP, or -DCASADI_THREAD_TYPE=CASADI_THREAD_TYPE_WINDOWS.
• When compiling, specify the maximum number of threads, e.g. -DCASADI_MAX_NUM_THREADS=2.

Related thread-safety fixes: a memory leak in JIT-compiled Functions that mixed incref/decref (#4331), and a crash of the Windows binaries when thread-mapping a Function with memory objects (#4274).

Other code-generation changes:

• Code-generated memory handling has been refactored (#4250). breaking: the generated C API no longer exposes the legacy alloc_mem/init_mem/free_mem entry points. They were always ignored by external so it is unlikely that any code relied on theire presence. Memory was always managed through checkout/release (#4249, #3764).
• Code-generated subroutines that were missing the CASADI_PREFIX are now correctly prefixed (#4245).
• Sliced get/set/assign of nonzeros now generates efficient code rather than a nested loop (#4264).
• dump_in is now implemented in code generation (#3971).

Integrators and events

• The integrator class now supports events (zero-crossings), making it possible to simulate hybrid systems. A zero-crossing field can be added to the DAE oracle, and an option bounds the maximum number of events for which memory is allocated (#3682).
• Finite differences now respect is_diff_in (#4278).
• Fixed a regression in collocation derivatives (#3371), sparsity issues in the integrator (#3353), and a multipoint-collocation Jacobian error (#3190).

DaeBuilder / FMI interoperability

• The DaeBuilder public API has been streamlined for consistency (#4319): consistent category names (e.g. y for outputs, alg for residual variables), a generalized all, and a single generic outputs(cat) replacing the per-category shorthands (ydef(), wdef(), ...).
• DaeBuilder.export_fmu has been streamlined (#4165) and now returns a dictionary giving the relative path of each generated file, instead of just a list of generated files. Two companion methods close the loop entirely within CasADi: compile_fmu compiles the exported sources into a binary, and pack_fmu packs the file map into a single distributable .fmu archive.
• FMUs exported from CasADi now contain the serialized CasADi expressions that define them, following a so-called FMI Layered Standard (#4023). When such an FMU is imported back into CasADi, a symbolic DaeBuilder instance is created instead of a standard (black-box C API) instance.
• DAEs are now supported in FMUs (#4307), quadrature states are detected in standard FMUs (splitting states into x and q, #4100), and a time transformation can redesignate the independent variable (#4103).
• FMU options are now mutable (#4310), and resources can be unzipped to a custom temporary directory (#4175).
• Continued work on Base Modelica import (#4024).
• Fixes: incorrect sparsity in generated FMUs (#4367), an FMI model structure regression (#4210), and an incorrect FMU resource path under FMI 3 (#4309).

Solvers / plugins

New solver interfaces:

• FICO Xpress, a new conic interface for LP/MIP/QP (#2797, #4360; contribution by @brunoficoxpress, Bruno Vieira). It can extract an irreducible infeasible set (IIS) - a minimal subset of constraints and bounds that together make a model infeasible - to help diagnose infeasible problems.
• Mosek, a new conic interface.
• PIQP, a new conic interface wrapping the PIQP proximal interior-point QP solver.
• ccopt, a new nlpsol plugin for mathematical programs with complementarity constraints (MPCC), built on the madNLP backend. Complementarity pairs (0 <= x ⊥ y >= 0) are declared through the ind_cc option; see docs/examples/cplusplus/basic_mpcc.cpp.
• UNO, a new nlpsol interface (#3908; contribution by @david0oo, David Kiessling).

New capabilities on existing solvers:

• Major upgrade of the madNLP interface (by @apozharski, Anton Edvinovich Pozharskiy).
• The Gurobi interface accepts a user-supplied CasADi Function via a new lazy_constraints_callback option. Gurobi calls it at each new integer-feasible solution (a MIPSOL event) with the current solution, and the function returns lazy constraints that are injected into the branch-and-bound on the fly — enabling cutting-plane workflows such as subtour elimination (contribution by @aghezz1, Andrea Ghezzi).
• The DAQP interface now supports binary variables (MIQP) (#4258; contribution by @aghezz1, Andrea Ghezzi).
• Fixed SLEQP memory issues (#3312), a bonmin malloc error on macOS (#4198), and improved diagnostics when IPOPT cannot be found (#3090).

Opti

• breaking Fix in opti.dual return values (#4020).

Python

NumPy interoperability

CasADi now works much more naturally alongside NumPy, through two new facilities.

A numpy-style array view, casadi.array (a.k.a. casadi.ArrayInterface). This wraps a DM, SX or MX and gives it NumPy semantics: a logical ndim, NumPy-style indexing (so A[0] is the first row, where a plain CasADi M[0] is the first element), axis-aware reductions, and the usual operators. Call .to_casadi() to get the native CasADi value back. This settles the long-standing confusion that CasADi indexing did not match NumPy (#2959):

import casadi as ca
A = ca.array([[1, 2, 3], [4, 5, 6]])   # ca.array is ca.ArrayInterface
A.ndim                                 # 2
A[0]                                   # first row [1, 2, 3]  (NumPy-style)
A.to_casadi()                          # back to a native DM / SX / MX

Opt-in NumPy dispatch via GlobalOptions.setNumpyMode(1).

With this enabled, calling a NumPy function on a CasADi value follows NumPy's shape/axis contract and returns a casadi.array, instead of the old behaviour of silently densifying. A large set of NumPy ufuncs (__array_ufunc__, NEP 13) and array-functions (__array_function__, NEP 18) now dispatch natively on CasADi types — np.concatenate, np.where, np.reshape, np.dot/np.matmul/np.kron, the reductions (np.sum, np.cumsum, np.max, ...), and np.linalg.* (solve, det, inv, cholesky, norm) - including symbolic SX/MX inputs (#2626, partly inspired by aerosandbox, #2762):

import numpy as np
from casadi import SX, DM, GlobalOptions
GlobalOptions.setNumpyMode(1)          # opt in (temporary - becomes the default later)

x = SX.sym("x", 3)
np.concatenate([x, x])                          # dispatches on a symbolic (NEP 18)
np.sum(DM([[1, 2], [3, 4]]), axis=0)            # [4, 6] — true NumPy axis semantics
np.linalg.solve(DM([[2, 0], [0, 4]]), DM([2, 8]))  # np.linalg.* handled natively -> [1, 2]

The mode is a transitional feature: 0 (default) keeps the old behaviour but warns, -1 keeps it silently, 1 opts into the new NumPy-aware behaviour. As the mode may disappear in the future, it is best to probe availability with hasattr(casadi.GlobalOptions, "setNumpyMode").

NumPy bug

breaking The behavior of np.remainder/np.mod/% applied on CasADi types was fixed to be in align with numpy expectations.

All of the below return 1 in Python.

print(np.remainder(3,2))
print(np.mod(3,2))
print(3 % 2)

Now consider the CasADi variants:

print(np.remainder(ca.DM(3),ca.DM(2)))
print(np.mod(ca.DM(3),ca.DM(2)))
print(ca.DM(3) % np.array(2))

These returned -1 in prior CasADi versions, and now return 1.

Other Python changes

• Python wheels now ship with type stubs, and the SWIG bindings are checked with pyright in CI (#4315). Thanks to @ghorn (Greg Horn) for suggesting this.
• Fixed a crash under Python 3.10 (#3878) and dimension-mismatch errors that were swallowed under SWIG 4 (#2628).

MATLAB / Octave

• Custom Callback objects work in MATLAB again: a long-standing regression that made MATLAB callbacks segfault has been fixed (#1720).
• Added vcat/hcat and friends for MATLAB (#4338).
• Error messages are no longer clipped in MATLAB (#3806) or Octave (#3044).
• Fixed a missing string typemap for MATLAB (#4205) and issues with the Octave 10.2 binary package (#4193).

Building and distribution

• Plugins can now be located via a new CASADI_PLUGIN_SEARCH_PATH environment variable (#4339), and the Windows DLL search has been refined (#4340).
• The directory CasADi uses for temporary/scratch files (JIT and shell compilation, code generation, FMU unzipping) can now be redirected with GlobalOptions.setTempWorkDir() (#4175).
• The source-build instructions have been updated (#3061).
• Fixed an RTLD_DEEPBIND/environ workaround that corrupted the environment for loaded libraries (#4317), a build bug with -DWITH_BUILD_MUMPS and a missing METIS_DIR (#4328), and a SWIG issue on Apple Silicon (#2992).

Binaries

• breaking: Support for Python 2.7 and 3.6 is dropped.
• Python binaries for 3.11 and upwards now use the Python stable ABI (#4289), so a single wheel keeps working across future Python versions. Thanks to @jackvreeken (Tjerk Vreeken) for suggesting this.
• Python, MATLAB and Octave binaries targeting Linux are now compiled with manylinux_2_28 (previously manylinux2014). manylinux2014 Python wheels are still supplied in parallel for backwards compatibility.
• breaking: As a consequence, we no longer build with CXX_USE_CXX11_ABI=0 (#4222). C++ code that links against the binaries must now be built with the new libstdc++ ABI to match.
• breaking: Python binaries are no longer distributed as zip files; wheels are now the sole mode of distribution.
• macOS builds switched to macos-14 (#4184), fixing broken wheels on macOS 15.4+ (#4189).

Contributors

Thanks to everyone who contributed pull requests to this release. Beyond the items credited inline above, this release includes community contributions from @sixpearls (Ben Margolis — Python mtimes dispatch, #4268), @barracuda156 (Sergey Fedorov — PowerPC/Darwin build fixes, #4112, #4113), @qbisi (FindMUMPS.cmake fix, #3899), @nim65s (Guilhem Saurel — a missing include, #4192), @jarsarasty (HiGHS v1.13.1 upgrade, #4299), @billtubbs (Bill Tubbs — Python semicolons and asserts, #3968), @adrian-nilsson-fcc (Adrian Nilsson — FMU demo notebook, #3900), and @josipkh (Josip Kir Hromatko — typo fixes, #3848).

The full list of closed issues for this release is available on the 3.8 milestone.

Plugin versions used in binaries

3.8.0

• uno-sourcebuild, Build UNO (BUILD_UNO_VERSION=f311df65f2acd1745175d3b49db4a5bdca15ce16) from downloaded source (BUILD_UNO_GIT_REPO=https://github.com/jgillis/Uno.git).
• piqp-sourcebuild, Build PIQP (BUILD_PIQP_VERSION=v0.6.3) from downloaded source (BUILD_PIQP_GIT_REPO=https://github.com/PREDICT-EPFL/piqp.git).
• highs-sourcebuild, Build HiGHS (BUILD_HIGHS_VERSION=v1.13.1) from downloaded source (BUILD_HIGHS_GIT_REPO=https://github.com/ERGO-Code/HiGHS).
• daqp-sourcebuild, Build DAQP (BUILD_DAQP_VERSION=master) from downloaded source (BUILD_DAQP_GIT_REPO=https://github.com/jgillis/daqp.git).
• proxqp-sourcebuild, Build PROXQP (BUILD_PROXQP_VERSION=v0.7.2) from downloaded source (BUILD_PROXQP_GIT_REPO=https://github.com/Simple-Robotics/proxsuite.git).
• osqp-sourcebuild, Build OSQP (BUILD_OSQP_VERSION=v1.0.0) from downloaded source (BUILD_OSQP_GIT_REPO=https://github.com/osqp/osqp.git).
• superscs-sourcebuild, Build SuperSCS (BUILD_SUPERSCS_VERSION=4d2d1bd03ed4cf93e684a880b233760ce34ca69c) from downloaded source (BUILD_SUPERSCS_GIT_REPO=https://github.com/jgillis/scs.git).
• sleqp-sourcebuild, Build SLEQP (BUILD_SLEQP_VERSION=patch-1) from downloaded source (BUILD_SLEQP_GIT_REPO=https://github.com/jgillis/sleqp.git).
• bonmin-sourcebuild, Build BONMIN (BUILD_BONMIN_VERSION=releases/1.8.9) from downloaded source (BUILD_BONMIN_GIT_REPO=https://github.com/coin-or/Bonmin.git).
• ipopt-sourcebuild, Build IPOPT (BUILD_IPOPT_VERSION=3.14.19.mod) from downloaded source (BUILD_IPOPT_GIT_REPO=https://github.com/jgillis/Ipopt-1.git).
• cbc-sourcebuild, Build CBC (BUILD_CBC_VERSION=releases/2.10.12) from downloaded source.
• clp-sourcebuild, Build CLP (BUILD_CLP_VERSION=releases/1.17.10) from downloaded source (BUILD_CLP_GIT_REPO=https://github.com/coin-or/Clp.git).
• mumps-sourcebuild, Build MUMPS (BUILD_MUMPS_TP_VERSION=gate-unconditional-use-omp-lib) from downloaded source (BUILD_MUMPS_TP_GIT_REPO=https://github.com/jgillis/ThirdParty-Mumps.git).
• spral-sourcebuild, Build SPRAL (BUILD_SPRAL_VERSION=d385d2c9e858366d257cafaaf05760ffa6543e26) from downloaded source (BUILD_SPRAL_GIT_REPO=https://github.com/ralna/spral.git).
• metis-sourcebuild, Build METIS (BUILD_METIS_TP_VERSION=bugfix2) from downloaded source.
• fatrop-sourcebuild, Build FATROP (BUILD_FATROP_VERSION=v1.1.8.mod) from downloaded source (BUILD_FATROP_GIT_REPO=https://github.com/jgillis/fatrop.git).
• hpipm-sourcebuild, Build HPIPM (BUILD_HPIPM_VERSION=5aac723660da0e1c9c47a9b98a0a80c5789aaed4) from downloaded source (BUILD_HPIPM_GIT_REPO=https://github.com/jgillis/hpipm.git).
• trlib-sourcebuild, Build TRLIB (BUILD_TRLIB_VERSION=1599192a02aee4e0cbe47ad1dbb81c7b06ff4f17) from downloaded source (BUILD_TRLIB_GIT_REPO=https://github.com/jgillis/trlib.git).
• blasfeo-sourcebuild, Build BLASFEO (BUILD_BLASFEO_VERSION=fb39d77a8c2d87805d38d41635a1402b5bcb9e18) from downloaded source (BUILD_BLASFEO_GIT_REPO=https://github.com/giaf/blasfeo.git).
• lapack-sourcebuild, Download and install OpenBLAS for LAPACK+BLAS
• eigen3-sourcebuild, Build Eigen (BUILD_EIGEN3_VERSION=3.4.0) from downloaded source (BUILD_EIGEN3_GIT_REPO=https://gitlab.com/libeigen/eigen.git).
• simde-sourcebuild, Build Simde (BUILD_SIMDE_VERSION=v0.7.2) from downloaded source.
• lacemodelica-sourcebuild, Build LaceModelica (BUILD_LACEMODELICA_VERSION=main) from downloaded source (BUILD_LACEMODELICA_GIT_REPO=https://github.com/yacoda/lacemodelica.git).
• onnx-sourcebuild, Build ONNX (BUILD_ONNX_VERSION=v1.18.0) from downloaded source (BUILD_ONNX_GIT_REPO=https://github.com/onnx/onnx).
• protobuf-sourcebuild, Build Protobuf from source
• libzip-sourcebuild, Build LIBZIP (BUILD_LIBZIP_VERSION=v1.11.3) from downloaded source (BUILD_LIBZIP_GIT_REPO=https://github.com/nih-at/libzip).
• zlib-sourcebuild, Build ZLIB (BUILD_ZLIB_VERSION=v1.3.1) from downloaded source (BUILD_ZLIB_GIT_REPO=https://github.com/madler/zlib).
• coinutils-sourcebuild, Build COINUTILS (BUILD_COINUTILS_VERSION=releases/2.11.12) from downloaded source.
• osi-sourcebuild, Build OSI (BUILD_OSI_VERSION=releases/0.108.11) from downloaded source.
• cgl-sourcebuild, Build CGL (BUILD_CGL_VERSION=releases/0.60.9) from downloaded source.