Clarabel: An interior-point solver for conic programs

with quadratic objectives

Paul J. Goulart, Yuwen Chen

Department of Engineering Science, University of Oxford, Oxford, UK

May 21, 2024

Abstract
arXiv:2405.12762v1 [math.OC] 21 May 2024

We present a general-purpose interior-point solver for convex optimization problems with conic
constraints. Our method is based on a homogeneous embedding method originally developed for
general monotone complementarity problems and more recently applied to operator splitting meth-
ods, and here specialized to an interior-point method for problems with quadratic objectives. We
allow for a variety of standard symmetric and non-symmetric cones, and provide support for chordal
decomposition methods in the case of semidefinite cones. We describe the implementation of this
method in the open-source solver Clarabel, and provide a detailed numerical evaluation of its per-
formance versus several state-of-the-art solvers on a wide range of standard benchmarks problems.
Clarabel is faster and more robust than competing commercial and open-source solvers across a
range of test sets, with a particularly large performance advantage for problems with quadratic objec-
tives. Clarabel is currently distributed as a standard solver for the Python CVXPY optimization
suite.

1 Introduction
We consider throughout the following convex conic optimization problem:
1 ⊤
min 2x Px + q⊤x
x,s

subject to: Ax + s = b (P)

s ∈ K,
with decision variables x ∈ Rn
and s ∈ Rm ,
and problem data A ∈ Rm×n , b ∈ Rm , q ∈ Rn and
P ∈ Rn×n . We assume that P is symmetric and positive semidefinite (possibly zero) and that the set
K is a closed and convex cone. We will denote the optimal value of this problem as p∗ and an optimizer
(when it exists) as (x∗ , s∗ ).
It can be shown that the problem dual to P is
max − 12 x⊤P x − b⊤z
x,z

subject to: P x + A⊤z = −q, (D)

z ∈ K∗
where K∗ is the dual cone of K. We will denote its optimal value as d∗ and an optimizer (when it exists)
as (x∗ , z ∗ ). We will assume throughout that strong duality holds between P and D, i.e. that p∗ = d∗ .
The problem P is very general and can model most convex optimization problems of practical inter-
est. Such problems appear in a huge range of applications including constrained optimal control [1]
and moving horizon estimation [2], limit analysis of engineering structures [3], [4] and fluid flows [5],
image processing [6], support vector machines [7], lasso problems [8], [9], circuit design [10], portfolio
optimization [11], [12], and many others. The numerical solution of convex problems in the form P
also underpins many nonconvex optimization methods, including those based on sequential quadratic
programming [13, Ch. 18][14] and branch-and-bound methods within mixed-integer methods [15], [16].

1
1.1 Solution methods
Considerable research effort has focused on the development of solution techniques for P over many
decades. If the cone K is the positive orthant, then P represents a linear program (LP) if P = 0 or a
quadratic program (QP) otherwise. This case in particular has a long history, dating to the landmark
work of Kantorovich [17] and Koopmans [18], [19] in the LP case, and Frank and Wolfe in the QP case
[20]. Of particular significance was the development of numerical solution methods for such problems,
and in particular simplex or active-set methods for the solution of LP [21] and QP [22] instances. Active
set methods still form the basis of many modern LP and QP solvers, including commercial solvers such
as Gurobi [23] and open-source solvers such as qpOASES [24] and HiGHS [25].
However, since active set methods are based on the iterative updating of a basis of active constraints
and rely heavily on the polyhedral structure of systems of linear equalities and inequalities, they do
not generalize well to the case of non-polyhedral constraints. Recent advances for more general conic
programs, i.e. optimization problems where the set K is a more general convex cone, have therefore
focussed instead on either operator splitting methods such as the alternating direction method of
multipliers (ADMM) [26] or on interior-point methods [27]. ADMM methods in particular are attractive
in cases where only moderate accuracy is required, since ADMM is known to be prone to poor ‘tail
convergence’ at high precision [28]. Nevertheless, ADMM based methods are widely used in practice
for both their scalability and simplicity of implementation and form the basis of several open-source
solvers for P, including the open source solvers OSQP [29], SCS [30] and COSMO [31].

Primal-dual interior-point methods In this work we focus instead on primal-dual interior-point

methods [32], since such methods are known to perform better than operator splitting methods at high
precision and, unlike active set methods, can support general conic constraints. A significant milestone
in the development of solution algorithms for P was Karmarkar’s method [33], which provided the first
practically useful polynomial-time solution method for linear programs, followed by the path following
method of Renegar [34].
An advantage of interior-point methods is that they can be extended to the case of general conic
constraints K in P. Of particular importance in the development of efficient conic interior-point solvers
was the development of solvers based on cones and associated barrier functions that have the self-scaling
property [35], [36]. The family of self-scaled cones include those that are generally considered the most
important constraint types in practice, i.e. the nonnegative orthant, second-order cone and positive
semidefinite (PSD) cone. Conic problems defined over self-scaled cones can be solved efficiently using
primal-dual interior-point methods based on the Nesterov-Todd (NT) scaling strategy [35], [36].
Nonsymmetric cones that do not have the self-scaling property have been the subject of increasing
recent interest for interior-point methods [37], [38]. The exponential cone and the power cone are the
two most studied and are supported in commercial solvers such as Mosek [39]. In certain cases it is
also attractive to formulate problems in terms of more exotic nonsymmetric cones that can be solved
more efficiently by exploiting their special structure [40]–[42]. Since the NT scaling method does not
apply to nonsymmetric cones, alternative strategies have been proposed based on either primal or dual
iterates [41], [43], [44] or both primal and dual iterates together [39], [42].
Alongside these developments, a further innovation was the development of the homogeneous self-dual
embedding (HSDE) [45]. This method embeds a conic program with linear objectives into a slightly
larger feasibility problem, which is always feasible regardless of the feasibility of the original problem.
Once a feasible point is found, it can be used to construct either an optimizer for the original problem
or a primal or dual certificate of infeasibility. The HSDE is at the heart of many modern interior-point
solvers including CVXOPT [46], ECOS [47], SCS [30] and MOSEK [48]. A downside of this approach
is that it does not naturally support problems with quadratic objectives, since the standard embedding
method applied to such cases does not produce a self-dual problem.

Monotone complementarity problems (MCPs) Extensions of the HSDE method were quickly
developed for the linear complementary problem (LCP) [49], and later for the more general monotone

2
complementary problem (MCP) [50] with linear constraints. The homogeneous embedding for MCPs
was also extended to problems defined over more general symmetric cone constraints [51], [52].
The practical performance of the homogeneous embedding in the case of convex quadratically con-
strained quadratic programming (QCQP) problems was investigated in [53]. More recently, [54] pro-
posed a maximal monotone operator specialized for the LCP based on the monotone operator in [50] to
produce a first-order solver for problems with convex quadratic objectives and general conic constraints.

2 Algorithmic approach
In this paper we adopt the approach of [53], [54] by specializing the homogeneous embedding method
of [50] to convex problems with quadratic objectives. We will use this embedding as the basis for a
general purpose primal-dual interior-point solver that handles both symmetric and nonsymmetric cone
constraints.
The standard Karush-Kuhn-Tucker (KKT) conditions for problem P are

Ax + s = b
P x + A⊤z = −q
(1)
s⊤z = 0
(s, z) ∈ K × K∗ .

We define the duality gap γ as

   
1 ⊤ ⊤ 1 ⊤ ⊤
γ := x Px + q x − − x Px − b z
2 2
= x⊤P x + q⊤x + b⊤z = s⊤z,

where the final equality follows from substitution in the KKT conditions (1). The duality gap γ is
nonnegative for any feasible point since (s, z) are constrained to the dual pair of cones (K, K∗ ), and is
zero at an optimal point (x∗ , s∗ , z ∗ ) when strong duality holds.
Taking problems P and D together with an objective minimizing the duality gap, we can rewrite our
problem in the form

min s⊤z
(x,s,z)

subject to: x⊤P x + q⊤x + b⊤z = 0

P x + A⊤z + q = 0 (2)

Ax + s − b = 0
(s, z) ∈ K × K∗ .

This problem is of course infeasible whenever either P or D is infeasible or the pair is not strongly dual.
If we define nonnegative scalars (τ, κ) and apply a change of variables x → x/τ , z → z/τ and s → s/τ ,
then we can rewrite the feasibility problem (2) as

min s⊤z + τ κ
(x,s,z,τ,κ)
1 ⊤
subject to: x P x + q⊤x + b⊤z = −κ
τ
(H)
P x + A⊤z + qτ = 0
Ax + s − bτ = 0
(s, z, τ, κ) ∈ K × K∗ × R+ × R+ .

3
The problem H is equivalent to the widely-used homogeneous self-dual embedding (HSDE) [55] in the
special case P = 0. The most common approach to solving P is therefore to eliminate the quadratic term
in the objective function, replacing it with an epigraphical upper bound and an additional second-order
cone constraint in the objective [56]. This amounts to rewriting P as

min w + q⊤x
x,s,w

subject to: Ax + s = b
 1  (3)
2P 2 x
≤w+2
w−2 2
s ∈ K, w ≥ 0,

which is a conic optimization problem with a purely linear cost and an additional second-order cone
constraint.
If we instead keep the quadratic term in the objective then H remains homogeneous but is no longer self-
dual, in addition to featuring the seemingly awkward τ1 x⊤P x term in the first equality. Our approach
will nevertheless amount to a direct solution of H using a primal-dual type interior-point method, and
we will show that significant performance improvements are possible with this approach in many cases
relative to standard HSDE-based interior-point methods.

2.1 Existence of solutions and infeasibility detection

Before proceeding to the details of our algorithm, we address briefly the existence and interpretation
of solutions to H. As in the case of the HSDE, an advantage of our reformulation is that solutions
will produce either a solution to the original problem P or D, or (asymptotically) a certificate of either
primal or dual infeasibility. We first define the following sets of infeasibility certificates for P and D:
n o
P := x P x = 0, Ax ∈ K, q⊤x < 0
n o
D := z A⊤z = 0, z ∈ K∗ , b⊤z < 0 .

The problem P is infeasible if and only if there exists some x̄ ∈ D, while the problem D is infeasible if
and only if there exists some z̄ ∈ P. Similar conditions have appeared in [31], [54], [57] in the context
of conic optimization with quadratic objectives.
Solving the problem H amounts to finding a root of the nonlinear system of equations

P A⊤
      
0 q x 0
G(x, z, s, τ, κ) :=  s  −  −A 0 b z  +  0  = 0 (4)
κ −q⊤ −b⊤ 0 τ 1 ⊤
τ x Px

subject to the conic constraint

(x, z, s, τ, κ) ∈ C := Rn × K × K∗ × R+ × R+ .

These conditions are identical to those in [54, (4.1)], where they were developed in terms of specialization
of the homogeneous embedding of monotone complementary problems developed in [50] to an LCP.
We can define a more compact notation v := (x, z, s, τ, κ) for convenience, so that H is equivalent to

min s⊤z + τ κ
v
(5)
subject to: G(v) = 0, v ∈ C.

4
As in [50], we say that the problem H (equivalently (5)) is asymptotically feasible if there exists a
bounded sequence {v k } ⊂ C, k = 1, 2, . . . , such that

lim G(v k ) = 0,
k→∞

and call any limit point v̂ := (x̂, ẑ, ŝ, τ̂ , κ̂) of such a sequence an asymptotically feasible point. We will
call any such point with ŝ⊤ẑ + τ̂ κ̂ = 0 an (asymptotically) complementary or optimal solution.
We can now develop some basic results about solutions to the problem H in the spirit of [50, Thm. 1]:
Lemma 2.1. The problem H is (asymptotically) feasible and every (asymptotically) feasible point is
(asymptotically) complementary.

Proof. We can construct an asymptotically feasible sequence by defining xk = ( 21 )k 1 √1n , sk = ( 21 )k eK ,

z k = ( 12 )k eK∗ , τ k = ( 21 )k and κk = ( 12 )k , where (eK , eK∗ ) is any vector pair in K × K∗ . It is then
straightforward to show that G(v k ) → 0, noting in particular that the sequence
1 k⊤ k
(x ) P x ≤ ( 12 )k σ̄(P ) → 0
τk
where σ̄(P ) is the maximum singular value of P , and is lower bounded by zero since P is positive
semidefinite. To show the second part, observe that
 ⊤
x
 z  G(v) = s⊤z + τ κ
τ

for any v ∈ C, so (sk )T (z k ) + τ k κk → 0 since G(v k ) → 0 and all sequences are bounded.

Lemma 2.2. Suppose that v ∗ := (x∗ , z ∗ , s∗ , τ ∗ , κ∗ ) is an asymptotically complementary solution to H.

Then:
i) If τ ∗ > 0 then (x∗ /τ ∗ , s∗ /τ ∗ ) is an optimal solution to P and (x∗ /τ ∗ , z ∗ /τ ∗ ) is an optimal solution
to D.
ii) If κ∗ > 0 then at least one of the following holds:
• P is infeasible and z ∗ ∈ D.
• D is infeasible and x∗ ∈ P.

Proof. For (i), note that κ∗ → 0 since the solution is assumed asymptotically complementary. Then
any point satisfying G(v ∗ ) = 0 also satisfies the KKT conditions (1) following rescaling of (x∗ , s∗ , z ∗ )
by τ ∗ .
For (ii), suppose that {v k } ∈ C, k = 1, 2, . . . , is any bounded sequence with limit v ∗ . Since τ k → 0 by
assumption, it follows that (xk )⊤P xk → 0 since τ1k xk P xk must remain bounded. Hence P x∗ = 0 since
P is assumed positive semidefinite, and both Ax∗ − s∗ = 0 and A⊤z ∗ = 0. Since {sk , z k } ∈ K × K∗ by
assumption and both cones are closed, z ∗ ∈ K∗ and Ax∗ ∈ K. Since q⊤x∗ + b⊤z ∗ = −κ∗ with κ∗ > 0,
then at least one of the inner product terms must be negative. Consequently, if q⊤x∗ < 0 then x∗ ∈ P
and D is infeasible, and if b⊤z ∗ < 0 then z ∗ ∈ D and P is infeasible.

2.2 Supported constraint types and barrier functions

Our interior-point method supports a variety of cones of both symmetric (i.e. self dual) and nonsym-
metric type, and we allow the cone K in problem P to be any arbitrary composition of the basic cone
types we describe in this section. For the symmetric case, we support the following cones:
• The nonnegative cone Rn+ := {x ∈ Rn | x ≥ 0 }.

5
 • The second order cone Qn := (u, v) ∈ R × Rn−1 | ∥v∥2 ≤ u .


• The positive semidefinite cone Sn := x ∈ Rn(n+1)/2 | mat(x) ⪰ 0 .



Our implementation for Sn uses the standard scaled and vectorized ‘triangular’ format. Given some
symmetric matrix M ∈ Rn×n√ , we define an operator svec(·) that extracts the upper triangular part and
scales off-diagonal terms by 2, i.e.
√ √ √ √
svec(M ) := (M1,1 , 2M1,2 , M2,2 , · · · , 2Mn−2,n−1 , Mn−1,n−1 , 2M1,n , · · · , 2Mn−1,n , Mnn ).
The inverse operation mat(·) then restores the original matrix, i.e. M = mat(svec(M )). This scaling
is necessary to preserve inner products, i.e. tr(L⊤M ) = svec(L)⊤svec(M ) for matrices of compatible
dimension.
We also support two nonsymmetric cones, both defined as subsets of R3 :
• The exponential cone Kexp := (s1 , s2 , s3 ) ∈ R3 s2 · es1 /s2 ≤ s3 , s2 > 0 .


• The power cone Kpow := (s1 , s2 , s3 ) ∈ R3 sα1 s21−α ≥ |s3 |, s1 ≥ 0, s2 ≥ 0 .



For these two nonsymmetric cones the corresponding dual cones are
n o
∗
Kexp := (z1 , z2 , z3 ) ∈ R3 z3 ≥ −z1 · ez2 /z1 −1 , z3 > 0, z1 < 0
( )
 z α  z 1−α
∗ 3 1 2
Kpow := (z1 , z2 , z3 ) ∈ R · ≥ |z3 |, z1 , z2 ≥ 0 .
α 1−α

Finally, we support the zero cone Zn := {0}n to enable modelling of problems with equality constraints.

Barrier functions
For each nonzero cone we define a strictly convex barrier function f : K → R and its associated conjugate
barrier f ∗ : K∗ → R. In particular, we use barrier functions that meet the following definition:
Definition 2.3 ([39], [58]). A function f : K → R is called a logarithmically homogeneous self-
concordant barrier with degree ν ≥ 1 (ν–LHSCB) for the cone K if it satisfies the following properties:

3/2
|∇3 f (x)[r, r, r]| ≤ 2 ∇2 f (x)[r, r] ∀x ∈ int K, r ∈ Rd ,
f (λx) = f (x) − ν log(λ) ∀x ∈ int K, λ > 0.

The conjugate function f ∗ : K∗ → R is defined as

f ∗ (y) := sup{−y⊤x − f (x)}. (6)
x∈K

The function f ∗ is also ν–LHSCB for K∗ if f is [35]. The primal gradient ∇f satisfies
x⊤ ∇f (x) = −ν, ∀x ∈ int K. (7)
In cases where the conjugate barrier function is known only through the definition (6) (i.e. rather than
being representable in closed-form), we can compute its gradient as the solution to
∇f ∗ (y) := − arg sup {−y⊤x − f (x)}. (8)
x∈int K

The relations (6)–(8) then collectively ensure that

f ∗ (y) = −y⊤(−∇f ∗ (y)) − f (−∇f ∗ (y))

= −ν − f (−∇f ∗ (y)).
and also
−∇f ∗ (−∇f (x)) = x, ∀x ∈ int K, −∇f (−∇f ∗ (y)) = y, ∀y ∈ int K∗ .

6
2.3 The central path
We assume that f : K → R is a ν–LHSCB function on K with conjugate barrier f ∗ for some ν ≥ 1.
Given any initial v 0 ∈ C, we define the central path v ∗ (µ) as the unique solution to

G(v) = µG(v 0 ) (9a)

∗
s = −µ∇f (z), z = −µ∇f (s), (9b)

which implies that

s⊤z/ν = µ.
If the cone K is symmetric, then we can replace the condition (9b) with a simpler condition defined in
terms of the Jordan product [46], [59] on K:

s ◦ z = µe, (9c)

where e is the standard idempotent for K. The core of our interior-point algorithm amounts to a
Newton-like method for computing a solution to the system of equations (9). We describe the calculation
of step directions for this method in §3. Before doing so, we address solver initialization, termination
and preprocessing steps in the remainder of this section.

2.4 Solver initialization

Before solving we perform an equilibration step on all matrix-valued data using the Ruiz equilibration
technique described in [60]. We refer the reader to [31, §3.5] and [29, §5.1] for implementation details.
We have several strategies for choosing an initial iterate in the interior of our problem’s conic constraints
while being sufficiently near to the central path.

2.4.1 Symmetric cones

In the symmetric case, i.e. when K is self-dual, our method follows the approach of [46] for initialization
and we distinguish between the cases P = 0 and P ̸= 0. Although the zero cone is not itself symmetric,
we treat problems where K is a composition of symmetric and zero cones as symmetric for the purposes
of initialization.
If P ̸= 0, we first solve the linear system
P A⊤
    
x −q
= ,
A −I z b
which is the solution to the problem
1 ⊤ 1
min x P x + q ⊤ x + ∥Ax − b∥22 .
2 2
We set x0 = x and

0 −z, αp < −ϵ
s =
−z + (ϵ + αp )e otherwise,

where αp = inf{α | − z + αe ∈ K}. We introduce a threshold ϵ > 0 to ensure that s0 is in the strict
interior of the cone K. Likewise, z 0 is set to

0 z, αd < −ϵ
z =
z + (ϵ + αd )e otherwise,
where αd = inf{α | z + αe ∈ K}.
If P = 0, we instead solve the linear system
0 A⊤
    
x 0
= ,
A −I s b

7
in an effort to minimize the linear residuals. We set x0 = x and

0 −s, αp < −ϵ
s =
−s + (ϵ + αp )e otherwise,

where αp = inf{α | − s + αe ∈ K}. We then solve the system

0 A⊤
    
x −q
= ,
A −I z 0
which is equivalent to
1
min ∥z∥22
z 2
s.t. A⊤ z + q = 0.
Finally, we set

0 z, αd < −ϵ
z =
z + (ϵ + αd )e otherwise,

where αd = inf{α | z + αe ∈ K}. In either case, we set the scalars (τ 0 , κ0 ) to 1.

2.4.2 Nonsymmetric cones

When K contains any nonsymmetric cone, we instead apply a unit initialization strategy as in [39],
[43]. In this case, we initialize both primal and dual variables at a point on the central path satis-
fying z = s = −∇f ∗ (z) (corresponding to µ0 = 1). This is equivalent to solving the unconstrained
optimization
1
min z 2 + f ∗ (z),
z 2
which is strictly convex and has a unique solution. It yields s0sym = zsym
0 = e for symmetric cones,

s0exp = zexp
0
≈ (−1.051383, 0.556409, 1.258967)

for exponential cones, and

√ √
s0pow = zpow
0
= ( 1 + α, 2 − α, 0)

for power cones of parameter α.

2.5 Chordal Decomposition

For semidefinite programs (SDPs) we follow the chordal-decomposition and clique merging strategy
developed as part of the COSMO solver [31]. We implement both a ‘parent-child’ merge strategy based
on the clique-tree analysis method of [61] and the clique-graph merge strategy described in [31, §5].
We reformulate problems decomposed using either of these methods using the so-called ‘compact’ or
‘range-space’ conversion method described in [62, §5].
When implementing the clique-graph based merge strategy, we use the same edge-weight metric as
in [31] to determine when candidate clique merges are accepted. Given a clique graph with V vertices
and two cliques Ci and Cj , we define an edge weight function e : 2V × 2V → R as

e(Ci , Cj ) = |Ci |3 + |Ci |3 − |Ci ∪ Cj |3 ,

and merge candidate cliques when this metric is positive. We note that this metric was used in the
ADMM-based solver [31, §5] because it relates directly to the computational complexity of projections
onto the positive semidefinite cone. In our case the size of a Hessian block generated by a conic
variable in Sn has dimension R(n(n+1)/2)×(n(n+1)/2) , with the resulting KKT factorization time further
complicated by the linking variables generated between overlapping cliques. We note therefore that it
is likely that more efficient merge metrics are possible.

8
2.6 Termination Criteria
All termination criteria are based on unscaled problem data and iterates, i.e. after the Ruiz scaling
described in §2.4 has been reverted. For checks of primal and dual feasibility, we first define normalized
variables x̄ = x/τ, s̄ = s/τ, z̄ = z/τ and then define primal and dual residuals as

rp := Ax̄ − s̄ + b
rd := P x̄ + A⊤ z̄ + q

and primal and dual objectives as

1
gp := x̄⊤ P x̄ + q⊤x
2
1
gd := − x̄⊤ P x̄ − b⊤z̄.
2

We then declare convergence if each of the following three conditions holds:

∥rp ∥ < ϵf · max{1, ∥b∥∞ + ∥x̄∥ + ∥s̄∥}

∥rd ∥ < ϵf · max{1, ∥q∥∞ + ∥x̄∥ + ∥z̄∥}
|gp − gd | < ϵf · max{1, min{|gp |, |gd |}}.

We specify a default value of ϵf = 10−8 in our implementation, and a weaker threshold of ϵ = 10−5
when testing for ‘near optimality’ in cases of early termination (e.g. lack of progress, timeout, iterations
limit).
When testing for infeasibility certificates, we do not normalize iterates, but rather work directly with
the unscaled variables since infeasibility corresponds to the case where τ → 0. We declare primal
infeasibility if

A⊤z < −ϵi,r · max(1, ∥x∥ + ∥z∥) · (b⊤z)

b⊤z < −ϵi,a ,

and dual infeasibility if

∥P x∥ < −ϵi,r · max(1, ∥x∥) · (b⊤z)

∥Ax + s∥ < −ϵi,r · max(1, ∥x∥ + ∥s∥) · (q⊤x)
q⊤x < −ϵi,a .

We again set ϵi,r = ϵi,a = 10−8 as default values, and allow for weaker thresholds to declare ‘near
infeasibility’ certificates in cases of early termination.

3 Computing step directions

Our interior-point method computes Newton-like search directions using a linearization of (9) given
some right-hand side residual d := (dx , dz , dτ , ds , dκ ). This produces a linear system in the form

A⊤
      
0 P q ∆x dx
 ∆s  −  −A 0 b   ∆z  = − dz  (10a)
∆κ −(q + 2P ξ)⊤ −b⊤ ξ⊤P ξ ∆τ dτ

H∆z + ∆s = −ds , κ∆τ + τ ∆κ = −dκ , (10b)

where ξ := xτ −1 and H ∈ Rm×m is a positive definite matrix that we will refer to as the scaling matrix.
The choice of both the scaling matrix and the right-hand side terms d in (10) depend on the search

9
direction, the symmetry or asymmetry of the cone K and the particular choice of scaling strategy. We
defer more precise definitions of these terms to later in this section.
Our approach to solving (10) follows that of [46], [47], but differs in the fact that some blocks in the
coefficient matrix of (10a) include an additional term when P ̸= 0. We first eliminate the variables
(∆s, ∆κ) to obtain the reduced system

A⊤
    
P q ∆x dx
 −A H b   ∆z  =  dz − ds  (11a)
−(q + 2P ξ) ⊤ −b⊤ ⊤ κ
ξ Pξ + τ ∆τ dτ − dκ /τ

∆s = −ds − H∆z, ∆κ = −(dκ + κ∆τ )/τ. (11b)

To solve (11) we solve a pair of linear systems with a common left-hand side

P A⊤
    
∆x1 ∆x2 dx −q
= (12)
A −H ∆z1 ∆z2 −(dz − ds ) b

and then recover (∆τ, ∆x, ∆z) using

dτ − dκ /τ + (2P ξ + q)⊤ ∆x1 + b⊤ ∆z1

∆τ =
κ/τ + ξ ⊤ P ξ − (2P ξ + q)⊤ ∆x2 − b⊤ ∆z2
dτ − dκ /τ + q ⊤ ∆x1 + b⊤ ∆z1 + 2ξ ⊤ P ∆x1
= ,
∥∆x2 − ξ∥2P − ∥∆x2 ∥2P − q ⊤ ∆x2 − b⊤ ∆z2

and

∆x = ∆x1 + ∆τ · ∆x2 , ∆z = ∆z1 + ∆τ · ∆z2 .

Finally, we recover (∆s, ∆κ) from (11b). After obtaining the search direction (∆s, ∆z, ∆τ, ∆κ), we
compute the maximal step size α ensuring that the new update resides in the interior of conic con-
straints. In cases where any part of K is nonsymmetric, we also choose α sufficiently small so that the
updated values (s + α∆s, z + α∆z) remain within a neighborhood of the central path (9) using the
proximity metric described in [39].

3.1 Scaling matrices

The choice of scaling matrix H in (10) depends on the way in which we linearize the central path
equations as defined in Section 2.3. For symmetric cones the most common choice is the NT scaling [35],
[36], which we also employ. For nonsymmetric cones, the central path is defined by the set of point
satisfying (9b), and both symmetric scaling [39] or the nonsymmetric scaling strategies [44] have been
implemented in state-of-the-art solvers. We set H = 0 for the zero cone.

3.1.1 Symmetric cones

For symmetric cones we linearize the central path equation (9c). The NT scaling method exploits
the self-scaled property of symmetric cone K to define, for (s, z) ∈ K, a unique scaling point w ∈ K
satisfying
H(w)s = z.
The matrix H(w) can be factorized as H −1 (w) = W ⊤ W , and we set H = H −1 (w) in (10). The factors
w, W are then computed following [46] except in the case of second-order cones, where we instead
apply a modified version of the sparse factorization strategy of [47] for second-order cones of dimension
greater than 4.

10
3.1.2 Nonsymmetric cones
In the nonsymmetric case the self-scaled property does not hold and the central path can’t be formulated
as in (9c) due to the lack of a Jordan algebra, so we instead linearize (9b). A general primal-dual scaling
strategy suitable for nonsymmetric cones was consequently proposed in [63], and used later in [39], which
relies on the satisfaction of two secant equations

Hz = s, H∇f (s) = ∇f ∗ (z).

Suppose we define shadow iterates as

z̃ := −∇f (s), s̃ := −∇f ∗ (z),

with

µ̃ = ⟨s̃, z̃⟩/ν.

A scaling matrix H can then be obtained from the rank-4 Broyden-Fletcher-Goldfarb-Shanno (BFGS)
update, which is commonly used in quasi-Newton methods,

H := HBFGS := Z(Z ⊤ S)−1 Z ⊤ + Ha − Ha S(S ⊤ Ha S)−1 S ⊤ Ha ,

where Z := [z, z̃], S := [s, s̃], z̃ := −∇f (s), s̃ := −∇f ∗ (z) and Ha ≻ 0 is an approximation of the
Hessian. In our implementation, we choose Ha = µ∇2 f ∗ (z) following [39] and the calculation of HBFGS
reduces to a rank-3 update,
 T  
2 ∗ 1 1 1 1
HBFGS =µ∇ f (z) + δs s + µs̃ + δs + s + µs̃ + δs δsT
2µν µµ̃ − 1 2µν µµ̃ − 1

T
∇2 f ∗ (z)z̃ − µ̃s̃ ∇2 f ∗ (z)z̃ − µ̃s̃


−µ .
⟨z̃, ∇2 f ∗ (z)z̃⟩ − ν µ̃2
More details about the primal-dual scaling of nonsymmetric cones can be found in [39].

3.2 The affine and centering directions

At every interior-point iteration, our method requires us to solve the linear system (10) for each of
two different right-hand side terms (dx , dz , dτ , ds , dκ ). This amounts to a single factorization of the
condensed system (12) followed by three linear solves, noting the common right-hand-side term (−q, b)
in (12).
The first of these two choices produces the affine step direction, where we compute the search direction
(∆x, ∆s, ∆z, ∆κ, ∆τ ) to eliminate the linear residuals in (4), i.e. by computing a pure Newton step
direction for (9) with µ = 0. The second is called the combined step, which is the affine step plus a
centering correction toward the central path. In practice, the estimated direction (∆x, ∆s, ∆z, ∆κ, ∆τ )
from the affine step is used to determine the right-hand side (dx , dz , dτ , ds , dκ ) for the combined step to
compute a higher-order correction for acceleration. In the language of predictor-corrector algorithms,
the affine step is the predictor while the centering step as the corrector.
Computation of a higher-order correction term η is a heuristic technique that is known to accelerate
the convergence of IPMs significantly. The choice of this term varies depending on the choice of the
scaling matrix H and whether a given cone constraint is symmetric. For our method (dx , dz , dτ , ds , dκ )
is defined as

dx = rx , dz = rz , dτ = rτ , dκ = κτ, ds = s,

in the affine step, and

dx = (1 − σ)rx , dz = (1 − σ)rz , dτ = (1 − σ)rτ , dκ = κτ + ∆κ∆τ − σµ,
W ⊤ (λ\ (λ ◦ λ + η − σµe)) (symmetric)

ds =
s + σµ∇f ∗ (z) + η (nonsymmetric),

11
in the combined step. For symmetric cones we use the Mehrotra correction η = (W −1 ∆s) ◦ (W ∆z)
[46], while for nonsymmetric cones we compute η using the 3rd-order correction method from [39], i.e.
1
η = − ∇3 f ∗ (z)[∆z, ∇2 f ∗ (z)−1 ∆s].
2
We choose σ = (1 − αaff )3 , where αaff is the step size from the affine step.

3.3 Linear solve method

Nearly all of the cost of computing step directions in §3 typically comes when solving the symmetric
linear system (12). To solve this system we add a small regularization term ϵs and then compute a
direct factorization
A⊤
 
P + ϵs I
K := = LDL⊤.
A −(H + ϵs I)
This static regularization ensures that the matrix K is quasidefinite [64] even if P is rank deficient, and
consequently that the factor D is diagonal with Dii ̸= 0 when computing the Cholesky-like factorization
LDLT [65]. This approach also ensures that the sparsity pattern of the factor L depends only on
the problem’s sparsity pattern, so the method is allocation-free after the first factorization. When
computing the LDL factorization we also employ a dynamic regularization strategy by bounding pivots
away from zero by an amount ϵd to ensure that the factorization is numerically stable. We have
extended the open-source package QDLDL, original developed for OSQP and based on [66], to support
this regularization strategy.
The improved numerical efficiency of our scheme relative to the standard HSDE method can be seen
by consideration of the linear system in (12). If we had started instead from the epigraphical reformu-
lation (3), then the coefficient matrix in (12) would have been
 1

0 AT [2P 2 ]T
 A −H (13)
 

1
2P 2 −HK

with HK a scaling matrix appropriate for the additional second order cone constraint introduced in (3).
Direct factorization of (13) can produce significantly more fill-in than for coefficient matrix (12), par-
1
ticular when the matrix factor P 2 already has substantial fill-in.

4 Implementation: the Clarabel solver

We have implemented our approach in the Clarabel solver, an open-source and liberally licensed
software package with separate implementations in both the Rust [67] and Julia [68] programming
languages. Both implementations, along with extensive documentation, are available under the Apache
v2.0 license and are publicly available via our main project site at
https://clarabel.org/
Our Rust implementation is intended for most academic and industrial end users. This implementation
can also be accessed via other common languages through standard foreign function interfaces (FFIs)
and wrappers, and we currently provide such wrappers for Python, C, C++ and R. We also provide
interfaces in Python to the standard modelling package CVXPY [69], [70]. Clarabel is installed as part
of the standard CVXPY distribution [71] and is the default solver in CVXPY for linear and second-order
cone programs as of version 1.5.
The Rust version of Clarabel provides its own internal implementation of most linear algebra func-
tionality, including a standalone Rust reimplementation of the quasidefinite linear solver QDLDL with
regularization features as described in §3.3. We use Rust interfaces to user-selectable BLAS [72] im-
plementations (e.g. [73], [74]) for solving conic programs on the semidefinite cone. We also allow for

12
the use of alternative direct linear solvers, and provide optional support for a 3rd-party multithreaded
supernodal LDL factorization method implemented in native Rust as part of the faer-rs package [75].
The Julia implementation is intended for use both as a standalone solver for users of the Julia language
and as a prototyping platform for future algorithmic development. The Julia implementation relies
heavily on native Julia functions for most linear algebra functionality, aside from a Julia implementation
of QDLDL which we provide as a standalone package. In Julia, we also provide the option of using
alternative linear solve methods including CHOLMOD [76], Pardiso [77] and the HSL MA57 [78] solver.
Both implementations provide the same functionality and support the same set of conic constraints.
We also provide support for different floating point data types in both languages, e.g. for standard
32- or 64-bit single or double precision floating point types [79] or for extended precision types such
as the Julia BigFloat type. Our implementation is inspired by the modular design pattern of the
interior-point solver OOQP [80], in the sense that all internal data types are defined as abstract types
that can be extended or customized by end users to specific problem classes to exploit domain-specific
structure. In the Rust implementation this functionality relies heavily on Rust’s trait-based type system
and generics, while in Julia we instead rely on Julia’s dynamic dispatch and “duck typing” [81].
For more detail we refer the reader to the documentation available on the Clarabel project website.

5 Numerical Experiments
We have benchmarked our implementation of Clarabel against a variety of open-source and commercial
solvers: the open-source interior-point solver ECOS [47], the open-source dual-simplex base solver
HiGHS [25], and the commercial interior-point solvers Mosek [48] and Gurobi [23]. All benchmarks are
executed with all default settings for all solvers enabled, but with pre-solve disabled where applicable
to ensure that the solvers are solving equivalent problems. We do not impose any iteration limits other
than those specified within each solver’s internal defaults. We set the maximum solve time to 300
seconds unless otherwise stated.
Our two implementations of Clarabel use our native implementations of the direct LDL linear solver
QDLDL for all tests unless otherwise stated. The QDLDL solver is relatively unsophisticated relative
to the multithreaded methods used in commercial solvers, but is lightweight, open-source and does not
rely on any external libraries.
All experiments were carried out on the Oxford University Advanced Research Computing (ARC)
Facility [82]. For each test problem in our benchmarks results, solver were run single threaded on an
Intel Xeon Platinum 8268 CPU @ 2.90 GHz with 64 GB RAM. All benchmarks tests are scripted in
Julia and access solver interfaces via JuMP [83]. We use Rust compiler version 1.72.0 and Julia version
1.9.2. The code for all numerical examples is publicly available [84].
For each set of benchmark problems in our results we exclude problems for which none of the bench-
marked solvers produced a valid solution. We provide a summary of the results for all benchmarked
solvers appropriate to each problem class in the form of shifted geometric means and performance
profiles in the remainder of this section.
For all benchmark tests sets, we provide more detailed numerical results for our Rust and Julia imple-
mentations as well as the solvers Mosek and ECOS (where applicable) in Appendix A, including solve
times and iteration counts. We include only this subset of solvers in our detailed reporting since all are
interior-point based methods and therefore have iteration counts that are directly comparable.

13
Shifted geometric means We follow the standard benchmarking convention of using a normalized
shifted geometric mean for comparison of solve time across different solvers [85]. For a set of N test
problems, we define the shifted geometric mean solve time gs for solver s as
 1
N N
Y
gs :=  (tp,s + k) − k,
p=1

where tp,s is the time in seconds for solver s to solve problem p, and k = 1 is the shift. The normalized
shifted geometric mean is then defined as
gs
rs := ,
mins gs
so that the solver with the lowest shifted geometric mean solve time has a normalized score of 1. For
those problems for which a given solver fails, we assign a solve time tp,s equal to the maximum allowable
solve time for the relevant benchmark.

Performance profiles We also provide performance profiles [86] to compare both the relative and
absolute performance of different solvers. For a set of N test problems, we define the relative perfor-
mance ratio for solver s and problem p as
tp,s
up,s = .
mins tp,s

The performance profile for the solver s is then a plot of the function fsr : R+ 7→ [0, 1] defined as
1 X
fsr (τ ) := I≤τ (up,s ),
N p

where I≤τ = 1 if τ ≤ tp,s and I≤τ = 0 otherwise. The relative performance profile therefore shows, at
each level τ , the fraction of problems solved by solver s in time within a factor τ of the solve time of
the best solver.
Since the relative performance profile for a given solver can change depending on the overall collection of
solvers being benchmarked, we further compute an absolute performance profile by plotting a function
fsa : R+ 7→ [0, 1] as
1 X
fsa (τ ) := I≤τ (tp,s ).
N p

The absolute performance profile then shows, at each level τ , the fraction of problems solved by solver
s within τ seconds and is independent of the other solvers benchmarked.

5.1 Benchmark problems with quadratic objectives

In this section we present benchmark results for quadratic programming (QP) problems in the standard
form P with the set K restricted to the composition of the zero cone (i.e. modelling linear equality
constraints) and the nonnegative orthant. We consider example problems taken or generated from
standard open-source problem collections and covering a wide range of problem dimensions.

5.1.1 The Maros-Meszaros test set

We consider first the standard benchmark collection of 138 quadratic programs from the Maros-
Meszaros test set [87]. This collection of QPs includes a wide range of problem sizes and contains
a number of difficult test cases due to numerical ill-conditioning, rank deficiency or poor scaling.
Results Results for this benchmark set are shown in Figure 1 for all solvers. Clarabel is the fastest
overall solver on this benchmark set, with the Rust implementation marginally faster as expected.

14
We observe that the seemingly large gap in the relative performance profile of our Rust and Julia
implementations is almost entirely attributable to faster solve times among the smallest examples in
this test set. All solvers fail on at least some subset of these benchmarks, with Gurobi the lowest failure
rate at full accuracy, and Clarabel the lowest failure rate at reduced accuracy.
Of particular note in this benchmark set is the high failure rate of the ECOS and Mosek solvers, since
both are interior-point methods broadly similar to Clarabel. In the case of ECOS these failures are
partly attributable to the solvers’ requirement to reformulate QP problems in the conic form (13), since
ECOS does not support quadratic objectives natively. This leads to immediate failures in a substantial
number of cases due to ill-conditioning of the matrix P , resulting in a failed attempt to compute the
1
Cholesky factor P 2 in (13) when P is either semidefinite or contains very small negative eigenvalues.
Mosek handles this case more robustly, but is still not able to solve a substantial number of problems
to full accuracy within the benchmark time limit.

Figure 1: Performance profiles for the Maros-Meszaros problem set

(a) Relative performance profile (b) Absolute performance profile

ClarabelRs Clarabel ECOS Gurobi HiGHS Hypatia Mosek

Shifted GM Full Acc. 1.0 1.02 15.49 1.64 17.92 36.61 32.67
Low Acc. 1.0 1.1 19.8 2.9 39.99 42.99 4.07
Failure Rate (%) Full Acc. 8.8 8.8 48.2 7.3 45.3 56.9 59.9
Low Acc. 2.2 2.9 38.0 3.6 45.3 42.3 10.2

(c) Benchmark timings as shifted geometric mean and failure rates

5.1.2 Least-squares problems with SuiteSparse matrices

We next consider a collection of 23 sparse least-squares problems Ax ≈ b derived from matrices taken
from the SuiteSparse Matrix Collection [88], following the equivalent set of benchmark examples from
[29]. For each case we compute an approximate solution by solving a constrained QP using two standard
methods:

Huber Problem: The Huber fitting [89], [90] or robust least squares problem for a given matrix A
and vector b is defined as
Xm
min ϕ(aTi x − bi ),
x
i=1

where a⊤i is the ith row of A and the Huber loss function ϕ : R → R is defined as
(
w2 |w| ≤ M
ϕ(w) =
M (2|w| − M ) |w| > M.

15
 Figure 2: Performance profiles for the SuiteSparse least-squares problem set

(a) Relative performance profile (b) Absolute performance profile

ClarabelRs Clarabel ECOS Gurobi HiGHS Mosek

Shifted GM Full Acc. 1.0 1.06 7.12 1.79 21.5 6.31
Low Acc. 1.0 1.06 5.43 1.79 21.5 1.68
Failure Rate (%) Full Acc. 0.0 0.0 43.5 0.0 60.9 34.8
Low Acc. 0.0 0.0 39.1 0.0 60.9 0.0

(c) Benchmark timings as shifted geometric mean and failure rates

We set M = 1 for all test cases. This problem is equivalent [91] to the following quadratic program:

min u⊤u + 2M 1⊤(r + s)

x,u,r,s

subject to: Ax − b − u = r − s
(r, s) ≥ 0.

LASSO Problem: The least absolute shrinkage and selection operator (LASSO) problem [8], [9] for
a given matrix A and vector b is defined as

min ∥Ax − b∥22 + λ ∥x∥1 .

x

We set λ = A⊤b ∞
for all test cases. This problem is equivalent [91] to the following quadratic
program:

min y⊤y + λ1⊤t

y,x,t

subject to: Ax − b = y
− t ≤ x ≤ t.

Results Results for this benchmark set of 46 problems are shown in Figure 2. Clarabel is again the
fastest solver overall with the Rust implementation marginally faster. In this test set only the Clarabel
and Gurobi solvers are able to solve all cases to full accuracy.

5.1.3 Constrained optimal control

Finally, we consider finite-horizon constrained optimal control problems with quadratic objectives.
Problems of this type are of particular interest in embedded control systems, since the repeated online
solution of such problems is the basis of the model predictive control (MPC) method [1]. We con-
sider a collection of 72 such problems taken from the benchmark collection of industrial and academic

16
 Figure 3: Performance profiles for the optimal control problem set

(a) Relative performance profile (b) Absolute performance profile

ClarabelRs Clarabel ECOS Gurobi HiGHS Hypatia Mosek

Shifted GM Full Acc. 1.0 1.06 197.57 70.48 185.45 54.95 511.01
Low Acc. 1.0 1.06 14.97 60.07 185.45 37.36 8.26
Failure Rate (%) Full Acc. 0.0 0.0 23.6 12.5 19.4 2.8 37.5
Low Acc. 0.0 0.0 2.8 11.1 19.4 0.0 0.0

(c) Benchmark timings as shifted geometric mean and failure rates

applications in [92]. Problems in this collection are in the form

N −1   y ⊤ 
yi − yir yi − yir yi − yir
   
X Qk Sk gk
min + k
{xi },{yi },{ui } ui − uri SkT Rk ui − uri gu ui − uri
i=0
+ (xN − xrN )⊤P (xN − xrN )

subject to: xk+1 = Ak xk + Bk uk + fk 


yk = Ck xk + Dk uk + ek


k = 0...N − 1
dℓk ≤ Mk xk + Nk uk ≤ duk 


uk ∈ Uk , yk ∈ Yk


T xn ∈ T ,

where the constraint sets Uk , Yk and T are interval constraints. All problems have Qk ⪰ 0, Rk ⪰ 0 and
P ≻ 0, which ensures that the problems are all convex QPs. As is typical of optimal control problems
for embedded systems, the dimension of the states xk and inputs uk are relatively small (max 12 and
4, respectively), with horizons N up to 100.

Results Results for this benchmark set are shown in Figure 3. Clarabel is the fastest solver overall,
and is the only solver tested with a 100% success rate in solving problems to full accuracy.

5.2 Benchmark problems with linear objectives

In this section we present benchmark results for optimization problems without quadratic objective
terms, i.e. with P = 0 in P. We again consider example problems taken or generated from standard
open-source problem collections and covering a wide range of problem dimensions. Our test set covers
cases with constraints on the positive orthant (i.e. linear programs), as well as both second-order and
exponential cone programs.

17
5.2.1 NETLIB LP problems
We first consider linear programming (LP) problems taken from the NETLIB collection, a standard
collection of benchmark LPs [93], [94]. Our benchmark test set includes 117 feasible and 29 infeasible
test cases, representing all NETLIB LP problem instances with source files not exceeding 2.5 MB.
Results for the feasible and infeasible test sets are shown in Figures 4 and 5, respectively. For these cases
Clarabel has performance broadly similar to both Mosek and Gurobi for the feasible set, and somewhat
slower for the infeasible set. This result is to be expected since most of the potential performance
advantage of our method arises from improved handling of quadratic objectives, but illustrates that
our implementation is, in the LP case, still broadly comparable.

Figure 4: Performance profiles for the NETLIB Feasible LP problem set

(a) Relative performance profile (b) Absolute performance profile

ClarabelRs Clarabel ECOS Gurobi HiGHS Mosek

Shifted GM Full Acc. 1.0 1.04 2.13 1.3 1.79 1.2
Low Acc. 1.0 1.04 1.08 1.3 1.79 1.2
Failure Rate (%) Full Acc. 0.9 0.9 6.5 0.0 1.9 0.0
Low Acc. 0.9 0.9 0.9 0.0 1.9 0.0

(c) Benchmark timings as shifted geometric mean and failure rates

5.2.2 CBLIB exponential cone problems

We consider a collection of 39 exponential cone programs from the CBLIB benchmark collection [95]
in order to test performance on nonsymmetric cone programs. For these problems our implementation
has broadly similar performance to Mosek, with slightly faster solve times in the Rust implementation
despite a generally higher iteration count.

18
 Figure 5: Performance profiles for the NETLIB Infeasible LP problem set

(a) Relative performance profile (b) Absolute performance profile

ClarabelRs Clarabel ECOS Gurobi HiGHS Mosek

Shifted GM Full Acc. 1.89 1.92 1.85 1.0 12.19 2.49
Low Acc. 1.89 1.92 1.85 1.0 12.19 2.49
Failure Rate (%) Full Acc. 3.4 3.4 3.4 0.0 13.8 3.4
Low Acc. 3.4 3.4 3.4 0.0 13.8 3.4

(c) Benchmark timings as shifted geometric mean and failure rates

Figure 6: Performance profiles for the CBLIB Exponential Cone problem set

(a) Relative performance profile (b) Absolute performance profile

ClarabelRs Clarabel ECOS Mosek

Shifted GM Full Acc. 1.45 1.49 2.68 1.0
Low Acc. 1.0 1.08 3.28 2.14
Failure Rate (%) Full Acc. 2.6 2.6 5.3 0.0
Low Acc. 0.0 0.0 2.6 0.0

(c) Benchmark timings as shifted geometric mean and failure rates

19
5.2.3 Optimal power flow
We next consider a collection of optimal power flow problems based on power networks from IEEE
PLS PGLib-OPF benchmark library [96] and constructed using the PowerModels.jl benchmark test
framework [97]. This framework allows for the generation of optimal power flow problems with various
modelling assumptions and convex relaxations applied [98], [99]. We consider in particular linear
programming problems based on linearized (i.e. direct current (DC)) power flow models [100], and
SOCPs arising from second-order cone relaxations of AC models [101]. Results from these benchmarks
are shown in Figures 7 and 8, respectively.
For both of these test sets Clarabel outperforms the other solvers tested, albeit with a slightly higher
failure rate for the LP benchmark tests relative to Gurobi (i.e. 3.3% vs 0% at full accuracy). For the
SOCP benchmark tests in particular our success rate is substantially better than the other solvers
tested. All solvers in our benchmark group struggled to some extent in solve large scale SOCPs to full
accuracy. Our Rust implementation is able to solve to at least its reduced accuracy level for more than
99% of test cases though, a success rate considerably higher than ECOS or Mosek, both of which failed
even at reduced accuracy on more than 50% of cases.
We note also that our success rates differ slightly between our Julia and Rust implementations, even
though the implementation of our algorithm is (nearly) identical between the cases. We believe that
this difference is attributable to minor differences in compiled code vectorizations and optimizations,
which in some very difficult problems lead to slight differences in behavior at high accuracy.

Figure 7: Performance profiles for the LP Optimal Power Flow problem set

(a) Relative performance profile (b) Absolute performance profile

ClarabelRs Clarabel ECOS Gurobi HiGHS Mosek

Shifted GM Full Acc. 1.0 1.04 3.27 4.48 17.73 17.58
Low Acc. 1.0 1.07 2.89 5.57 22.04 21.85
Failure Rate (%) Full Acc. 3.3 2.6 15.0 0.0 35.3 36.6
Low Acc. 1.3 0.7 9.8 0.0 35.3 36.6

(c) Benchmark timings as shifted geometric mean and failure rates

5.3 Semidefinite program benchmarks

Finally, we test performance on large-scale SDPs using the SDPLIB benchmark collection [102]. We
consider a collection of 64 problems from this collection, where problems from the collection are included
if they are known to be feasible and could be solved on our testing platform using the reference solver
Mosek. Since some of these problems are large, we set a time limit of 30 minutes for each problem.
For this set of benchmarks we compare only our Rust implementation of Clarabel with Mosek and use
the supernodal factorization method of [75]. We provide results for Clarabel both with and without
the chordal decomposition described in §2.5 enabled.

20
 Figure 8: Performance profiles for the SOCP Optimal Power Flow problem set

(a) Relative performance profile (b) Absolute performance profile

ClarabelRs Clarabel ECOS Mosek

Shifted GM Full Acc. 1.0 1.07 8.25 10.02
Low Acc. 1.0 1.33 8.62 20.48
Failure Rate (%) Full Acc. 16.7 13.8 68.8 70.3
Low Acc. 0.7 2.2 55.8 70.3

(c) Benchmark timings as shifted geometric mean and failure rates

For this set of benchmarks we find that Clarabel outperforms Mosek overall, particularly when con-
sidering problems solved to full accuracy solutions. Clarabel also outperforms Mosek, sometimes very
substantially, for those test cases with a considerable amount of sparsity that are amenable to chordal
decomposition. We include in Appendix A a detailed breakdown of the results for this benchmark set,
including performance both with and without chordal decomposition enabled. For problems in which
no chordal structure could be identified, there is very little difference in performance between our two
solver configurations. However, some problems (e.g. the series of problems ‘ARCH0’–‘ARCH8’) show
improvements in computation time of nearly 100x when chordal decomposition is enabled. We note that
further improvements are likely possible in our implementation of chordal decomposition, particularly
if more sophisticated clique-merging scoring methods are employed.

6 Conclusions
We have presented a novel interior-point solver for conic optimization problems with quadratic objec-
tives. Our method uses a homogeneous embedding inspired by previous work on monotone complemen-
tarity problems, but not previously applied to interior-point conic optimization in any widely available
solver. We have shown that our method is competitive with state-of-the-art solvers for a wide range
of problem classes, and in particular outperforms state-of-the-art solvers in problems with quadratic
objectives (QPs), large-scale SOCPs, and SDPs with significant sparsity structure.
Our implementation of Clarabel is available as open-source software in both Rust and Julia, with several
other language interfaces, and is available as a standard solver in the CVXPY modelling package.
Clarabel already has growing base of both academic and industrial users and has been downloaded
several million times since its initial release.

21
Figure 9: Performance profiles for the SDPLIB Semidefinite Programming problem set

(a) Relative performance profile (b) Absolute performance profile

ClarabelRs ClarabelRs Mosek

(no decomp)
Shifted GM Full Acc. 1.0 2.53 9.95
Low Acc. 1.0 2.17 1.26
Failure Rate (%) Full Acc. 10.2 22.0 57.6
Low Acc. 1.7 10.2 1.7

(c) Benchmark timings as shifted geometric mean and failure rates

22
References
[1] F. Borrelli, A. Bemporad, and M. Morari, Predictive control for linear and hybrid systems.
Cambridge University Press, 2017.
[2] D. A. Allan and J. B. Rawlings, “Moving horizon estimation,” in Handbook of Model Predictive
Control. Cham: Springer International Publishing, 2019, pp. 99–124.
[3] A. Makrodimopoulos and C. M. Martin, “Lower bound limit analysis of cohesive-frictional ma-
terials using second-order cone programming,” International Journal for Numerical Methods in
Engineering, vol. 66, no. 4, pp. 604–634, 2006.
[4] A. Makrodimopoulos and C. M. Martin, “Upper bound limit analysis using simplex strain ele-
ments and second-order cone programming,” International Journal for Numerical and Analytical
Methods in Geomechanics, vol. 31, no. 6, pp. 835–865, 2007.
[5] P. J. Goulart and S. Chernyshenko, “Global stability analysis of fluid flows using sum-of-squares,”
Physica D: Nonlinear Phenomena, vol. 241, no. 6, pp. 692–704, 2012.
[6] P. Combettes, The convex feasibility problem in image recovery, P. W. Hawkes, Ed., 1996.
[7] C. Cortes and V. Vapnik, “Support-vector networks,” Machine Learning, vol. 20, no. 3, pp. 273–
297, 1995.
[8] R. Tibshirani, “Regression shrinkage and selection via the Lasso,” Journal of the Royal Statistical
Society: Series B, vol. 58, no. 1, pp. 267–288, 1996.
[9] E. J. Candés, M. B. Wakin, and S. Boyd, “Enhancing sparsity by reweighted ℓ1 minimization,”
Journal of Fourier Analysis and Applications, vol. 14, no. 5, pp. 877–905, 2008.
[10] S. Boyd, S.-J. Kim, L. Vandenberghe, and A. Hassibi, “A tutorial on geometric programming,”
Optimization and Engineering, vol. 8, no. 1, pp. 67–127, 2007.
[11] G. Cornuejols and R. Tütüncü, Optimization Methods in Finance (Mathematics, Finance and
Risk). Cambridge University Press, 2006.
[12] H. Markowitz, “Portfolio selection,” The Journal of Finance, vol. 7, no. 1, pp. 77–91, 1952.
[13] J. Nocedal and S. J. Wright, Numerical optimization (Springer Series in Operations Research
and Financial Engineering). Berlin: Springer, 2006.
[14] P. T. Boggs and J. W. Tolle, “Sequential quadratic programming,” Acta Numerica, vol. 4, pp. 1–
51, 1995.
[15] D. Bertsimas and R. Weismantel, Optimization over integers. Athena Scientific, 2005.
[16] D. R. Morrison, S. H. Jacobson, J. J. Sauppe, and E. C. Sewell, “Branch-and-bound algorithms: A
survey of recent advances in searching, branching, and pruning,” Discrete Optimization, vol. 19,
pp. 79–102, 2016.
[17] L. Kantorovich, “Mathematical methods of organizing and planning production,” Management
Science, vol. 6, no. 4, pp. 366–422, 1960, English translation.
[18] T. Koopmans, “Exchange ratios between cargoes on various routes (non-refrigerated dry car-
goes),” Memorandum for the Combined Shipping Adjustment Board, 1942, Reprinted in Scientific
Papers of Tjalling C. Koopmans, Springer Verlag, 1970.
[19] T. Koopmans, “Optimum utilization of the transportation system,” Econometrica, vol. 17,
pp. 136–146, 1949.
[20] M. Frank and P. Wolfe, “An algorithm for quadratic programming,” Naval Research Logistics
Quarterly, vol. 3, no. 1-2, pp. 95–110, 1956.
[21] G. B. Dantzig, Linear programming and extensions. Princeton University Press Princeton, N.J.,
1963.
[22] P. Wolfe, “The simplex method for quadratic programming,” Econometrica, vol. 27, no. 3,
pp. 382–398, 1959.
[23] Gurobi Optimization, LLC, Gurobi Optimizer Reference Manual, 2023.
[24] H. J. Ferreau, C. Kirches, A. Potschka, H. G. Bock, and M. Diehl, “qpOASES: A paramet-
ric active-set algorithm for quadratic programming,” Mathematical Programming Computation,
vol. 6, no. 4, pp. 327–363, 2014.
[25] Q. Huangfu and J. A. J. Hall, “Parallelizing the dual revised simplex method,” Mathematical
Programming Computation, vol. 10, no. 1, pp. 119–142, 2018.

23
[26] S. Boyd, N. Parikh, E. Chu, B. Peleato, and J. Eckstein, “Distributed optimization and statistical
learning via the alternating direction method of multipliers,” Foundations and Trends in Machine
Learning, vol. 3, no. 1, pp. 1–122, 2011.
[27] S. J. Wright, Primal-Dual Interior-Point Methods. Society for Industrial and Applied Mathe-
matics, 1997.
[28] B. He and X. Yuan, “On the O(1/n) convergence rate of the Douglas–Rachford alternating
direction method,” SIAM Journal on Numerical Analysis, vol. 50, no. 2, pp. 700–709, 2012.
[29] B. Stellato, G. Banjac, P. Goulart, A. Bemporad, and S. Boyd, “OSQP: An operator splitting
solver for quadratic programs,” Mathematical Programming Computation, vol. 12, no. 4, pp. 637–
672, 2020.
[30] B. O’Donoghue, E. Chu, N. Parikh, and S. Boyd, “Conic optimization via operator splitting and
homogeneous self-dual embedding,” Journal of Optimization Theory and Applications, vol. 169,
no. 3, pp. 1042–1068, 2016.
[31] M. Garstka, M. Cannon, and P. Goulart, “COSMO: A conic operator splitting method for convex
conic problems,” Journal of Optimization Theory and Applications, vol. 190, no. 3, pp. 779–810,
2021.
[32] A. S. Nemirovski and M. J. Todd, “Interior-point methods for optimization,” Acta Numerica,
vol. 17, pp. 191–234, 2008.
[33] N. Karmarkar, “A new polynomial-time algorithm for linear programming,” in Proceedings of
the Sixteenth Annual ACM Symposium on Theory of Computing, ser. STOC ’84, New York, NY,
USA: Association for Computing Machinery, 1984, pp. 302–311.
[34] J. Renegar, “A polynomial-time algorithm, based on Newton’s method, for linear programming,”
Mathematical Programming, vol. 40, no. 1, pp. 59–93, 1988.
[35] Y. E. Nesterov and M. J. Todd, “Self-scaled barriers and interior-point methods for convex
programming,” Mathematics of Operations Research, vol. 22, no. 1, pp. 1–42, 1997.
[36] Y. E. Nesterov and M. J. Todd, “Primal-dual interior-point methods for self-scaled cones,” SIAM
Journal on Optimization, vol. 8, no. 2, pp. 324–364, 1998.
[37] P. R. Chares, “Cones and interior-point algorithms for structured convex optimization involving
powers and exponentials,” Ph.D. dissertation, Université Catholique de Louvain, 2009.
[38] Y. Nesterov, “Towards non-symmetric conic optimization,” Optimization Methods and Software,
vol. 27, no. 4-5, pp. 893–917, 2012.
[39] J. Dahl and E. D. Andersen, “A primal-dual interior-point algorithm for nonsymmetric exponential-
cone optimization,” Mathematical Programming, 2021.
[40] D. Papp and S. Yildiz, “Sum-of-squares optimization without semidefinite programming,” SIAM
Journal on Optimization, vol. 29, no. 1, pp. 822–851, 2019.
[41] C. Coey, L. Kapelevich, and J. P. Vielma, “Solving natural conic formulations with Hypatia.jl,”
INFORMS Journal on Computing, vol. 34, no. 5, pp. 2686–2699, 2022.
[42] M. Karimi and L. Tunçel, “Domain-driven solver (DDS) version 2.1: A MATLAB-based software
package for convex optimization problems in domain-driven form,” Mathematical Programming
Computation, Oct. 2023.
[43] A. Skajaa and Y. Ye, “A homogeneous interior-point algorithm for nonsymmetric convex conic
optimization,” Mathematical Programming, vol. 150, no. 2, pp. 391–422, 2015.
[44] S. A. Serrano, “Algorithms for unsymmetric cone optimization and an implementation for prob-
lems with the exponential cone,” Ph.D. dissertation,
√ Stanford University, 2015.
[45] Y. Ye, M. J. Todd, and S. Mizuno, “An O( nL)-iteration homogeneous and self-dual linear
programming algorithm,” Mathematics of Operations Research, vol. 19, no. 1, pp. 53–67, 1994.
[46] L. Vandenberghe, The cvxopt linear and quadratic cone program solvers, 2010.
[47] A. Domahidi, E. Chu, and S. Boyd, “ECOS: An SOCP solver for embedded systems,” in 2013
European Control Conference (ECC), 2013, pp. 3071–3076.
[48] M. ApS, Mosek optimization suite 10.0, 2023.
[49] Y. Ye, “On homogeneous and self-dual algorithms for LCP,” Mathematical Programming, vol. 76,
no. 1, pp. 211–221, Jan. 1997.
[50] E. D. Andersen and Y. Ye, “On a homogeneous algorithm for the monotone complementarity
problem,” Mathematical Programming, vol. 84, no. 2, pp. 375–399, 1999.

24
[51] A. Yoshise, “Interior point trajectories and a homogeneous model for nonlinear complementarity
problems over symmetric cones,” SIAM Journal on Optimization, vol. 17, no. 4, pp. 1129–1153,
2007.
[52] A. Yoshise, “Homogeneous algorithms for monotone complementarity problems over symmetric
cones,” Pacific Journal of Optimization, vol. 5, Jan. 2007.
[53] C. Meszaros, “The practical behavior of the homogeneous self-dual formulations in interior point
methods,” Central European Journal of Operations Research, vol. 23, no. 4, pp. 913–924, Dec.
2015.
[54] B. O’Donoghue, “Operator splitting for a homogeneous embedding of the linear complementarity
problem,” SIAM Journal on Optimization, vol. 31, no. 3, pp. 1999–2023, 2021.
[55] Y. Nesterov, M. J. Todd, and Y. Ye, “Infeasible-start primal-dual methods and infeasibility
detectors for nonlinear programming problems,” Mathematical Programming, vol. 84, no. 2,
pp. 227–267, 1999.
[56] M. S. Lobo, L. Vandenberghe, S. Boyd, and H. Lebret, “Applications of second-order cone pro-
gramming,” Linear Algebra and its Applications, vol. 284, no. 1, pp. 193–228, 1998, International
Linear Algebra Society (ILAS) Symposium on Fast Algorithms for Control, Signals and Image
Processing.
[57] G. Banjac, P. Goulart, B. Stellato, and S. Boyd, “Infeasibility detection in the alternating
direction method of multipliers for convex optimization,” Journal of Optimization Theory and
Applications, vol. 183, no. 2, pp. 490–519, 2019.
[58] Y. Nesterov and A. Nemirovskii, Interior-Point Polynomial Algorithms in Convex Programming.
Society for Industrial and Applied Mathematics, 1994.
[59] J. F. Sturm, “Implementation of interior point methods for mixed semidefinite and second order
cone optimization problems,” Optimization Methods and Software, vol. 17, no. 6, pp. 1105–1154,
2002.
[60] D. Ruiz, “A scaling algorithm to equilibrate both rows and columns norms in matrices,” Ruther-
ford Appleton Laboratory, Oxon, UL, Tech. Rep. RAL-TR-2001-034, 2001.
[61] Y. Sun, M. S. Andersen, and L. Vandenberghe, “Decomposition in conic optimization with
partially separable structure,” SIAM Journal on Optimization, vol. 24, no. 2, pp. 873–897, 2014.
[62] S. Kim, M. Kojima, M. Mevissen, and M. Yamashita, “Exploiting sparsity in linear and nonlinear
matrix inequalities via positive semidefinite matrix completion,” Mathematical Programming,
vol. 129, no. 1, pp. 33–68, 2011.
[63] L. Tunçel, “Generalization of primal-dual interior-point methods to convex optimization prob-
lems in conic form,” Foundations of Computational Mathematics, vol. 1, no. 3, pp. 229–254,
2001.
[64] R. J. Vanderbei, “Symmetric quasidefinite matrices,” SIAM Journal on Optimization, vol. 5,
no. 1, pp. 100–113, 1995.
[65] P. E. Gill, M. A. Saunders, and J. R. Shinnerl, “On the stability of Cholesky factorization for
symmetric quasidefinite systems,” SIAM Journal on Matrix Analysis and Applications, vol. 17,
no. 1, pp. 35–46, 1996.
[66] T. A. Davis, “Algorithm 849: A concise sparse Cholesky factorization package,” ACM Transac-
tions on Mathematical Software, vol. 31, no. 4, pp. 587–591, Dec. 2005.
[67] S. Klabnik and C. Nichols, The Rust programming language. No Starch Press, 2023.
[68] J. Bezanson, A. Edelman, S. Karpinski, and V. B. Shah, “Julia: A fresh approach to numerical
computing,” SIAM review, vol. 59, no. 1, pp. 65–98, 2017.
[69] S. Diamond and S. Boyd, “CVXPY: A Python-embedded modeling language for convex opti-
mization,” Journal of Machine Learning Research, vol. 17, no. 83, pp. 1–5, 2016.
[70] A. Agrawal, R. Verschueren, S. Diamond, and S. Boyd, “A rewriting system for convex opti-
mization problems,” Journal of Control and Decision, vol. 5, no. 1, pp. 42–60, 2018.
[71] CVXPY, https://www.cvxpy.org/.
[72] L. S. Blackford, A. Petitet, R. Pozo, et al., “An updated set of basic linear algebra subprograms
(BLAS),” ACM Transactions on Mathematical Software, vol. 28, no. 2, pp. 135–151, 2002.
[73] Intel Corporation, Intel math kernel library, https://www.intel.com/content/www/us/en/
developer/tools/oneapi/onemkl.html.

25
 [74] OpenBLAS: An optimized BLAS library, https://www.openblas.net/.
[75] A linear algebra foundation for the Rust programming language, https://github.com/sarah-
ek/faer-rs.
[76] Y. Chen, T. A. Davis, W. W. Hager, and S. Rajamanickam, “Algorithm 887: CHOLMOD,
supernodal sparse Cholesky factorization and update/downdate,” ACM Trans. Math. Softw.,
vol. 35, no. 3, Oct. 2008.
[77] O. Schenk and K. Gärtner, “Pardiso,” in Encyclopedia of Parallel Computing. Boston, MA:
Springer US, 2011, pp. 1458–1464.
[78] I. S. Duff, “MA57—a code for the solution of sparse symmetric definite and indefinite systems,”
ACM Trans. Math. Softw., vol. 30, no. 2, pp. 118–144, Jun. 2004.
[79] W. Kahan, “IEEE standard 754 for binary floating-point arithmetic,” Lecture Notes on the
Status of IEEE, vol. 754, no. 94720-1776, p. 11, 1996.
[80] E. M. Gertz and S. J. Wright, “Object-oriented software for quadratic programming,” ACM
Transactions on Mathematical Software (TOMS), vol. 29, no. 1, pp. 58–81, 2003.
[81] N. Milojkovic, M. Ghafari, and O. Nierstrasz, “It’s duck (typing) season!” In 2017 IEEE/ACM
25th International Conference on Program Comprehension (ICPC), 2017, pp. 312–315.
[82] A. Richards, University of oxford advanced research computing, Aug. 2015.
[83] M. Lubin, O. Dowson, J. D. Garcia, J. Huchette, B. Legat, and J. P. Vielma, “Jump 1.0:
Recent improvements to a modeling language for mathematical optimization,” Mathematical
Programming Computation, 2023.
[84] P. Goulart and Y. Chen, Clarabel solver Benchmark suite, https://github.com/oxfordcontrol/
ClarabelBenchmarks, 2024.
[85] H. Mittelmann, Benchmarks for optimization software, http://plato.asu.edu/bench.html.
[86] E. D. Dolan and J. J. Moré, “Benchmarking optimization software with performance profiles,”
Mathematical Programming, vol. 91, no. 2, pp. 201–213, Jan. 2002.
[87] I. Maros and C. Mészáros, “A repository of convex quadratic programming problems,” Opti-
mization Methods and Software, vol. 11, no. 1-4, pp. 671–681, 1999.
[88] T. A. Davis and Y. Hu, “The University of Florida Sparse Matrix Collection,” ACM Transactions
on Mathematical Software, vol. 38, no. 1, 1:1–1:25, Dec. 2011.
[89] P. J. Huber, “Robust estimation of a location parameter,” The Annals of Mathematical Statistics,
vol. 35, no. 1, pp. 73–101, 1964.
[90] P. J. Huber, Robust Statistics. John Wiley & Sons, 1981.
[91] O. L. Mangasarian and D. R. Musicant, “Robust linear and support vector regression,” IEEE
Transactions on Pattern Analysis and Machine Intelligence, vol. 22, no. 9, pp. 950–955, 2000.
[92] D. Kouzoupis, A. Zanelli, H. Peyrl, and H. J. Ferreau, “Towards proper assessment of QP algo-
rithms for embedded model predictive control,” in 2015 European Control Conference (ECC),
2015, pp. 2609–2616.
[93] J. J. Dongarra and E. Grosse, “Distribution of mathematical software via electronic mail,”
Communications of the ACM, vol. 30, no. 5, pp. 403–407, 1987.
[94] Netlib LP test collection, https://netlib.org/lp.
[95] H. A. Friberg, “Cblib 2014: A benchmark library for conic mixed-integer and continuous opti-
mization,” Mathematical Programming Computation, vol. 8, no. 2, pp. 191–214, 2016.
[96] S. Babaeinejadsarookolaee, A. Birchfield, R. D. Christie, et al., “The power grid library for
benchmarking AC optimal power flow algorithms,” arXiv:1908.02788, 2019.
[97] C. Coffrin, R. Bent, K. Sundar, Y. Ng, and M. Lubin, “Powermodels.jl: An open-source frame-
work for exploring power flow formulations,” in 2018 Power Systems Computation Conference
(PSCC), Jun. 2018, pp. 1–8.
[98] D. K. Molzahn and I. A. Hiskens, “A survey of relaxations and approximations of the power
flow equations,” Foundations and Trends in Electric Energy Systems, vol. 4, no. 1-2, pp. 1–221,
2019.
[99] C. J. Coffrin and L. A. Roald, Convex relaxations in power system optimization, a brief intro-
duction, Jul. 2018.
[100] B. Stott, J. Jardim, and O. Alsac, “DC power flow revisited,” IEEE Transactions on Power
Systems, vol. 24, no. 3, pp. 1290–1300, Aug. 2009.

26
[101] R. A. Jabr, “Radial distribution load flow using conic programming,” IEEE Transactions on
Power Systems, vol. 21, no. 3, pp. 1458–1459, Aug. 2006.
[102] B. Borchers, “SDPLIB 1.2, a library of semidefinite programming test problems,” Optimization
Methods and Software, vol. 11, no. 1-4, pp. 683–690, 1999.

A Detailed benchmark results

27
 Table 1: Solve times and iteration counts for the Maros-Meszaros problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
TAME 3 2 4 3 5 6 3 1.16e-05 7.36e-06 0.000154 5.81e-05 4.41e-05 0.000461
HS21 5 2 6 2 9 11 11 6.19e-06 6.63e-06 0.000105 5.57e-05 7.29e-05 0.00115
HS35 4 3 6 5 7 9 9 7.64e-06 9.51e-06 0.000105 5.35e-05 8.56e-05 0.000944
HS35MOD 4 3 6 5 12 15 14 5.37e-06 7.67e-06 9.91e-05 6.45e-05 0.000115 0.00139
QPTEST 5 2 7 3 8 9 8 8.01e-06 9.51e-06 0.000158 6.41e-05 8.56e-05 0.00126
HS51 3 5 7 7 0 9 9 0 8.83e-06 0.000104 3.2e-05 7.95e-05 0.000934
HS52 3 5 7 7 0 7 5 0 1.06e-05 0.000121 5.51e-05 7.43e-05 0.000607
ZECEVIC2 6 2 8 1 8 8 7 8.3e-06 7.49e-06 0.000115 6.64e-05 6e-05 0.000806
HS268 5 5 25 15 12 17 - 7.78e-06 1.24e-05 - 9.33e-05 0.000211 -
S268 5 5 25 15 12 17 - 8.49e-06 1.23e-05 - 0.000102 0.00021 -
HS76 7 4 14 6 6 9 8 1.05e-05 1.08e-05 0.000115 6.31e-05 9.69e-05 0.000919
GENHS28 8 10 24 19 0 10 6 0 1.3e-05 0.00014 4.27e-05 0.00013 0.000842
HS53 13 5 17 7 6 15 7 9.67e-06 8.26e-06 0.000133 5.8e-05 0.000124 0.00093
LOTSCHD 19 12 66 6 9 19 19 1.52e-05 1.9e-05 0.000382 0.000137 0.000361 0.00727
HS118 59 15 93 15 11 10 12 2.19e-05 3.16e-05 0.000134 0.000241 0.000316 0.00161
QAFIRO 59 32 115 6 14 14 13 2.68e-05 2.9e-05 0.000185 0.000376 0.000407 0.00241
DPKLO1 77 133 1575 77 0 14 6 0 0.000317 0.00143 0.000602 0.00443 0.00856
DUAL4 151 75 225 2799 12 12 14 0.000287 0.000391 0.000601 0.00345 0.0047 0.00842
QPCBLEND 157 83 574 83 17 18 15 0.0001 0.000137 0.000983 0.00171 0.00246 0.0148
DUALC1 233 9 1953 45 12 24 - 0.000147 0.00014 - 0.00176 0.00336 -
28

DUALC2 243 7 1617 28 11 - - 0.000122 - - 0.00134 - -

QADLITTL 153 97 480 87 14 27 - 9.36e-05 9.02e-05 - 0.00131 0.00244 -
QSHARE2B 175 79 773 55 16 27 - 0.000125 0.000144 - 0.002 0.00389 -
DUAL1 171 85 255 3558 12 15 11 0.000374 0.00044 0.0007 0.00448 0.0066 0.0077
DUAL2 193 96 288 4508 11 15 13 0.000489 0.000576 0.000796 0.00538 0.00864 0.0104
DUALC5 294 8 2240 36 10 17 15 0.000165 0.000206 0.000185 0.00165 0.00351 0.00278
CVXQP2 S 225 100 274 386 10 - - 0.000138 - - 0.00138 - -
DUAL3 223 111 333 6108 12 19 12 0.000673 0.000836 0.00224 0.00808 0.0159 0.0269
CVXQP1 S 250 100 348 386 9 - - 0.000175 - - 0.00157 - -
CVXQP3 S 275 100 422 386 11 - - 0.000204 - - 0.00224 - -
QSCAGR7 269 140 560 25 16 - - 0.000121 - - 0.00194 - -
PRIMAL1 86 325 5816 324 10 20 10 0.000912 0.000898 0.00297 0.00912 0.018 0.0297
QRECIPE 340 180 912 50 17 21 23 0.00015 0.000151 0.00137 0.00256 0.00318 0.0316
QPCBOEI2 382 143 1480 143 20 - - 0.000328 - - 0.00657 - -
DUALC8 519 8 4040 36 9 - - 0.000304 - - 0.00273 - -
QSHARE1B 342 225 1376 39 32 - 32 0.000203 - 0.00174 0.0065 - 0.0557
PRIMALC5 286 287 2574 286 14 14 14 0.000234 0.000319 0.00268 0.00328 0.00446 0.0376
VALUES 405 202 606 3822 13 - - 0.000376 - - 0.00489 - -
QSC205 408 203 754 21 19 18 18 0.000161 0.000166 0.000662 0.00307 0.00299 0.0119
QBEACONF 435 262 3637 27 28 28 21 0.000496 0.000505 0.00179 0.0139 0.0141 0.0375
QBRANDY 469 249 2397 65 19 32 - 0.000466 0.000412 - 0.00884 0.0132 -
PRIMAL2 97 649 8043 648 8 16 8 0.00146 0.00148 0.00332 0.0117 0.0237 0.0265
QE226 505 282 2860 964 24 26 22 0.000645 0.000874 0.00271 0.0155 0.0227 0.0596
PRIMAL3 112 745 21548 744 9 18 10 0.004 0.00308 0.00622 0.036 0.0554 0.0622
QBORE3D 559 315 1755 78 27 25 21 0.000372 0.000388 0.00249 0.01 0.00969 0.0523
KSIP 1001 20 19898 20 14 20 12 0.00135 0.00121 0.000778 0.0189 0.0242 0.00934
 Table 1: Solve times and iteration counts for the Maros-Meszaros problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
QGROW7 721 301 3193 357 22 22 - 0.000566 0.00063 - 0.0125 0.0139 -
QFORPLAN 604 421 5006 582 21 - - 0.000817 - - 0.0172 - -
PRIMALC8 511 520 4663 519 12 - - 0.000574 - - 0.00689 - -
QCAPRI 741 353 2237 894 32 - - 0.000672 - - 0.0215 - -
QSCORPIO 746 358 1784 40 11 15 16 0.000353 0.00046 0.00305 0.00388 0.0069 0.0487
QSCFXM1 787 457 3046 733 26 - - 0.00072 - - 0.0187 - -
QBANDM 777 472 2966 41 21 37 - 0.000602 0.000618 - 0.0126 0.0229 -
QSCTAP1 780 480 2172 153 19 24 24 0.000405 0.000469 0.00274 0.0077 0.0113 0.0659
QPCSTAIR 823 467 4323 467 22 - - 0.000988 - - 0.0217 - -
QSTAIR 823 467 4323 1018 31 - - 0.00124 - - 0.0386 - -
QPCBOEI1 980 384 4359 384 17 42 - 0.000906 0.00102 - 0.0154 0.0429 -
QSCAGR25 971 500 2054 128 20 - - 0.000395 - - 0.0079 - -
PRIMAL4 76 1489 16032 1488 10 21 13 0.00304 0.00309 0.0063 0.0304 0.065 0.0819
QSCSD1 837 760 3148 745 10 12 12 0.0006 0.000702 0.00244 0.006 0.00843 0.0293
QETAMACR 1223 688 3232 4447 20 33 - 0.00467 0.00458 - 0.0934 0.151 -
QGROW15 1545 645 6865 500 22 22 - 0.00115 0.00121 - 0.0253 0.0266 -
QFFFFF80 1378 854 7081 1916 27 52 - 0.00247 0.00263 - 0.0668 0.137 -
MOSARQP2 1500 900 3830 945 10 22 18 0.00143 0.00189 0.0101 0.0143 0.0416 0.181
GOULDQP2 1747 699 2445 697 14 - - 0.000596 - - 0.00835 - -
GOULDQP3 1747 699 2445 1395 7 - - 0.00067 - - 0.00469 - -
29

QSCFXM2 1574 914 6097 1131 32 - - 0.00143 - - 0.0458 - -

QSTANDAT 1538 1075 4210 804 18 28 20 0.000859 0.000826 0.00856 0.0155 0.0231 0.171
QSCRS8 1659 1169 4351 121 33 30 31 0.000978 0.00102 0.0061 0.0323 0.0305 0.189
QSCSD6 1497 1350 5666 1404 13 17 19 0.00102 0.00129 0.00465 0.0133 0.0219 0.0884
LASER 2000 1002 6000 3231 11 28 - 0.000896 0.0013 - 0.00985 0.0363 -
QGFRDXPN 1966 1092 3727 162 22 - - 0.000811 - - 0.0178 - -
QSEBA 2057 1028 5902 646 30 - - 0.00107 - - 0.032 - -
QGROW22 2266 946 10078 852 27 30 - 0.00167 0.00168 - 0.0451 0.0503 -
CVXQP2 M 2250 1000 2749 3984 10 - - 0.00502 - - 0.0502 - -
QSHIP04S 1860 1458 5810 56 15 35 - 0.00101 0.000906 - 0.0151 0.0317 -
CVXQP1 M 2500 1000 3498 3984 10 - - 0.0077 - - 0.077 - -
QSCFXM3 2361 1371 9148 1221 34 - - 0.00202 - - 0.0688 - -
CVXQP3 M 2750 1000 4247 3984 12 - - 0.00892 - - 0.107 - -
Q25FV47 2391 1571 11971 59499 26 - - 0.0135 - - 0.351 - -
QSHELL 2428 1775 5448 34790 35 - - 0.00698 - - 0.244 - -
QSHIP04L 2520 2118 8450 56 15 39 - 0.0014 0.00126 - 0.021 0.049 -
QSCTAP2 2970 1880 8594 777 12 20 15 0.00202 0.00247 0.0115 0.0242 0.0495 0.172
AUG3D 1000 3873 6546 2673 0 - 10 0 - 0.0186 0.00577 - 0.186
AUG3DC 1000 3873 6546 3873 0 - - 0 - - 0.00582 - -
QSHIP08S 3165 2387 9501 11677 15 36 - 0.00398 0.00535 - 0.0598 0.193 -
QPILOTNO 3487 2172 15569 485 31 - - 0.00652 - - 0.202 - -
MOSARQP1 3200 2500 5922 2545 10 23 19 0.00192 0.00334 0.0325 0.0192 0.0769 0.618
QSCSD8 3147 2750 11334 2510 11 18 17 0.00213 0.00348 0.0158 0.0235 0.0627 0.269
QSCTAP3 3960 2480 11354 1047 12 22 - 0.00255 0.00355 - 0.0306 0.078 -
QSHIP12S 3914 2763 10941 17403 15 39 - 0.00434 0.0057 - 0.0652 0.222 -
QSIERRA 5279 2036 11354 183 35 51 - 0.00203 0.00224 - 0.0709 0.114 -
 Table 1: Solve times and iteration counts for the Maros-Meszaros problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
STADAT1 5999 2001 13997 2000 15 - - 0.00176 - - 0.0265 - -
STADAT2 5999 2001 13997 2000 45 22 23 0.00193 0.0052 0.0119 0.0867 0.114 0.275
AUG3DCQP 4873 3873 10419 3873 11 29 - 0.00407 0.00668 - 0.0448 0.194 -
AUG3DQP 4873 3873 10419 2673 13 - - 0.0039 - - 0.0507 - -
QSHIP08L 5061 4283 17085 34965 16 36 - 0.0165 0.0229 - 0.264 0.826 -
CONT-050 7595 2597 17199 2597 9 21 20 0.00992 0.0109 0.0425 0.0893 0.229 0.85
EXDATA 7501 3000 12000 1125750 22 21 16 0.548 0.859 0.127 12 18 2.03
QSHIP12L 6578 5427 21597 62228 16 36 - 0.0246 0.0348 - 0.394 1.25 -
STCQP1 10246 4097 21532 26603 7 - - 0.0127 - - 0.0892 - -
STCQP2 10246 4097 21532 26603 9 - - 0.0248 - - 0.223 - -
STADAT3 11999 4001 27997 4000 54 18 24 0.00379 0.00507 0.0237 0.205 0.0912 0.569
HUES-MOD 10002 10000 30000 10000 13 - - 0.00595 - - 0.0774 - -
HUESTIS 10002 10000 30000 10000 9 - - 0.0111 - - 0.1 - -
LISWET2 10000 10002 30000 10002 18 - - 0.00483 - - 0.0869 - -
LISWET3 10000 10002 30000 10002 23 - - 0.00474 - - 0.109 - -
LISWET4 10000 10002 30000 10002 27 - - 0.00452 - - 0.122 - -
LISWET5 10000 10002 30000 10002 11 - - 0.0055 - - 0.0605 - -
LISWET6 10000 10002 30000 10002 18 - - 0.00485 - - 0.0873 - -
DTOC3 10000 14999 34995 14997 0 - 9 0 - 0.067 0.0168 - 0.603
AUG2D 10000 20200 40000 19800 0 - - 0 - - 0.0327 - -
30

AUG2DC 10000 20200 40000 20200 0 - - 0 - - 0.0334 - -

CVXQP2 L 22500 10000 27499 39984 10 - - 1.77 - - 17.7 - -
CVXQP1 L 25000 10000 34998 39984 11 - - 3.14 - - 34.5 - -
CVXQP3 L 27500 10000 42497 39984 11 - - 3.52 - - 38.8 - -
CONT-100 30195 10197 69399 10197 9 19 14 0.076 0.0866 0.167 0.684 1.64 2.34
CONT-101 30492 10197 69993 2700 12 - 14 0.0761 - 0.143 0.913 - 2.01
UBH1 24018 18009 60018 6003 16 - 35 0.00949 - 0.0979 0.152 - 3.43
AUG2DCQP 30200 20200 60200 20200 12 - - 0.0236 - - 0.283 - -
AUG2DQP 30200 20200 60200 19800 14 - - 0.0231 - - 0.324 - -
CONT-200 120395 40397 278799 40397 13 25 16 0.572 0.744 0.918 7.43 18.6 14.7
CONT-201 120992 40397 279993 10400 12 - 16 0.743 - 0.608 8.92 - 9.73
BOYD1 93279 93261 652246 93261 35 - - 0.0996 - - 3.49 - -
CONT-300 271492 90597 629993 23100 12 - 13 2.86 - 1.6 34.4 - 20.8
 Table 2: Solve times and iteration counts for the Optimal Control problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
pendulum 3 28 23 83 23 5 11 11 2.71e-05 3.17e-05 0.000182 0.000136 0.000349 0.002
fiordosExample 1 32 27 67 18 8 12 12 1.93e-05 3.05e-05 0.000188 0.000155 0.000367 0.00226
fiordosExample 3 32 27 67 18 8 - - 2.07e-05 - - 0.000166 - -
forcesExample 1 38 29 83 28 9 14 11 2.07e-05 3.59e-05 0.000235 0.000186 0.000502 0.00258
forcesExample 2 38 29 83 27 8 13 10 2.38e-05 3.57e-05 0.000244 0.00019 0.000464 0.00244
forcesExample 3 42 32 92 31 9 12 11 2.32e-05 4.21e-05 0.00024 0.000209 0.000506 0.00264
toyExample 1 42 32 102 31 7 - 16 2.57e-05 - 0.000318 0.00018 - 0.00509
toyExample 3 42 32 102 31 9 - - 2.31e-05 - - 0.000208 - -
helicopter 1 48 30 96 39 6 - 21 3.39e-05 - 0.000298 0.000204 - 0.00626
fiordosExample 2 52 27 87 18 7 13 13 2.74e-05 3.3e-05 0.000188 0.000192 0.000428 0.00244
nonlinearCstr 3 64 54 204 30 10 - 12 3.94e-05 - 0.000294 0.000394 - 0.00353
robotArm 1 84 54 174 34 6 - 27 6.23e-05 - 0.000468 0.000374 - 0.0126
pendulum 1 78 63 243 63 6 12 6 5.89e-05 8.41e-05 0.000444 0.000353 0.00101 0.00266
pendulum 2 78 63 243 60 7 14 8 5.38e-05 7.82e-05 0.000406 0.000377 0.0011 0.00325
forcesExample 4 82 62 182 61 7 15 7 4.53e-05 6.95e-05 0.000468 0.000317 0.00104 0.00327
toyExample 2 82 62 202 61 7 18 10 4.54e-05 6.3e-05 0.000476 0.000318 0.00113 0.00476
aircraft 3 104 84 364 20 8 16 12 7.14e-05 0.000113 0.000326 0.000571 0.0018 0.00391
doubleInvertedPendulum 1 104 84 364 50 7 14 9 8.58e-05 0.0001 0.00051 0.000601 0.0014 0.00459
doubleInvertedPendulum 2 104 84 364 50 8 15 10 8.92e-05 8.65e-05 0.000457 0.000714 0.0013 0.00457
helicopter 3 118 86 278 80 7 22 - 8.09e-05 8.37e-05 - 0.000567 0.00184 -
31

aircraft 1 144 84 404 20 9 10 9 6.6e-05 0.000115 0.000462 0.000594 0.00115 0.00416

aircraft 2 144 84 404 40 9 10 9 6.68e-05 0.000133 0.000525 0.000601 0.00133 0.00472
aircraft 4 144 84 404 20 9 10 9 6.7e-05 0.000114 0.000459 0.000603 0.00114 0.00413
doubleInvertedPendulum 3 144 84 404 50 6 18 8 0.000105 9.56e-05 0.000544 0.000632 0.00172 0.00435
ballOnPlate 1 152 77 257 47 8 15 10 7.75e-05 8.85e-05 0.000745 0.00062 0.00133 0.00745
ballOnPlate 2 152 77 257 47 7 14 7 7.83e-05 8.94e-05 0.000571 0.000548 0.00125 0.004
ballOnPlate 3 152 77 257 47 7 17 9 7.9e-05 0.000106 0.000541 0.000553 0.00179 0.00487
dcMotor 1 144 94 424 32 9 - - 8.2e-05 - - 0.000738 - -
aircraft 10 164 104 444 20 9 10 10 8.14e-05 0.000127 0.00055 0.000733 0.00127 0.0055
aircraft 11 164 104 444 64 9 12 - 8.04e-05 8.75e-05 - 0.000724 0.00105 -
aircraft 12 164 104 444 64 9 12 - 7.58e-05 8.7e-05 - 0.000682 0.00104 -
toyExample 4 202 152 502 151 9 - - 9.52e-05 - - 0.000856 - -
ballOnPlate 4 252 127 427 77 9 19 11 0.00011 0.000155 0.0013 0.000989 0.00294 0.0143
helicopter 2 218 166 538 175 6 21 - 0.000164 0.000165 - 0.000983 0.00347 -
shell 1 249 159 559 60 7 15 8 0.00018 0.000226 0.00147 0.00126 0.00339 0.0118
shell 3 249 159 559 60 11 20 15 0.000151 0.000216 0.00139 0.00166 0.00433 0.0208
nonlinearCstr 1 244 204 804 120 10 - 22 0.000138 - 0.00209 0.00138 - 0.0459
nonlinearCstr 2 244 204 804 120 10 - 22 0.000134 - 0.00208 0.00134 - 0.0459
dcMotor 2 284 184 844 62 10 16 21 0.000166 0.000142 0.00139 0.00166 0.00227 0.0292
dcMotor 5 284 184 844 62 10 16 - 0.000148 0.000146 - 0.00148 0.00234 -
dcMotor 6 284 184 844 62 9 16 - 0.000155 0.00015 - 0.0014 0.0024 -
robotArm 2 324 204 684 124 8 - - 0.000246 - - 0.00197 - -
spacecraft 1 367 187 807 110 10 18 14 0.000165 0.000198 0.00201 0.00165 0.00356 0.0282
spacecraft 2 367 187 807 110 10 18 14 0.000165 0.000197 0.00201 0.00165 0.00354 0.0281
binaryDistillationColumn 1 311 266 2666 90 9 18 13 0.000381 0.000386 0.00221 0.00343 0.00694 0.0287
binaryDistillationColumn 2 311 266 2666 90 9 18 13 0.000379 0.000431 0.0022 0.00341 0.00776 0.0286
 Table 2: Solve times and iteration counts for the Optimal Control problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
quadcopter 1 382 292 1162 110 8 16 10 0.00026 0.000389 0.00245 0.00208 0.00623 0.0245
quadcopter 6 382 292 1162 172 8 16 12 0.000293 0.000366 0.00259 0.00235 0.00585 0.031
toyExample 5 402 302 1002 301 10 27 - 0.000185 0.000259 - 0.00185 0.007 -
shell 2 489 309 1109 120 7 15 9 0.000344 0.000435 0.0035 0.00241 0.00653 0.0315
tripleInvertedPendulum 1 456 366 2166 201 8 - 16 0.000579 - 0.00391 0.00463 - 0.0625
springMass 2 566 286 1646 181 7 18 18 0.000312 0.000353 0.00377 0.00219 0.00635 0.0679
springMass 3 566 286 1646 166 8 21 - 0.000293 0.00032 - 0.00234 0.00672 -
tripleInvertedPendulum 2 636 366 2346 201 8 21 13 0.000658 0.000381 0.00452 0.00527 0.00801 0.0588
tripleInvertedPendulum 3 636 366 2346 201 9 24 - 0.000648 0.000363 - 0.00583 0.00872 -
quadcopter 5 572 572 2212 220 27 - - 0.000473 - - 0.0128 - -
aircraft 13 804 504 2204 304 11 23 - 0.000367 0.00048 - 0.00403 0.011 -
quadcopter 2 752 572 2312 220 8 18 11 0.000484 0.000879 0.00437 0.00387 0.0158 0.0481
quadcopter 4 752 572 2312 220 12 19 16 0.000465 0.000739 0.00396 0.00558 0.0141 0.0634
springMass 4 1126 566 3286 341 8 17 15 0.00062 0.000631 0.0058 0.00496 0.0107 0.087
dcMotor 3 1404 904 4204 302 11 - - 0.000801 - - 0.00881 - -
dcMotor 4 1404 904 4204 302 11 25 - 0.000734 0.000634 - 0.00807 0.0159 -
quadcopter 3 1862 1412 5762 550 8 20 10 0.00121 0.00238 0.00935 0.00968 0.0476 0.0935
nonlinearChain 13 2457 2397 30857 660 9 22 - 0.00537 0.00579 - 0.0483 0.127 -
nonlinearChain 3 2457 2397 30857 660 9 22 - 0.00536 0.0058 - 0.0483 0.128 -
nonlinearChain 14 2637 2397 31037 660 10 23 - 0.00532 0.00663 - 0.0532 0.153 -
32

nonlinearChain 4 2637 2397 31037 660 10 23 - 0.00535 0.00666 - 0.0535 0.153 -

springMass 1 5606 2806 16406 1621 12 - - 0.00444 - - 0.0532 - -
nonlinearChain 1 9657 9417 123257 2640 8 28 - 0.0225 0.0232 - 0.18 0.649 -
nonlinearChain 11 9657 9417 123257 2640 8 28 - 0.0223 0.0229 - 0.178 0.642 -
nonlinearChain 12 10377 9417 123977 2640 9 - - 0.0219 - - 0.197 - -
nonlinearChain 2 10377 9417 123977 2640 9 - - 0.022 - - 0.198 - -
 Table 3: Solve times and iteration counts for the SuiteSparse least-squares problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
NYPA Maragal 1 lasso 60 60 322 32 9 15 10 5.02e-05 6.17e-05 0.000325 0.000452 0.000925 0.00325
NYPA Maragal 1 huber 96 110 394 32 6 10 5 5.97e-05 8.64e-05 0.000603 0.000358 0.000864 0.00301
HB ash85 lasso 255 255 948 85 8 18 15 0.00018 0.000325 0.00169 0.00144 0.00585 0.0253
HB ash85 huber 255 340 948 85 6 6 12 0.000297 0.000344 0.00199 0.00178 0.00206 0.0238
HB ash219 lasso 389 389 997 219 8 18 16 0.000247 0.000354 0.00255 0.00198 0.00637 0.0408
HB ash331 lasso 539 539 1409 331 7 18 21 0.000503 0.0005 0.00402 0.00352 0.009 0.0845
HB abb313 lasso 665 665 2574 313 9 22 - 0.000607 0.000686 - 0.00546 0.0151 -
HB ash219 huber 657 742 1533 219 9 16 16 0.0003 0.000711 0.00417 0.0027 0.0114 0.0667
HB ash292 lasso 876 876 3668 292 8 24 19 0.000848 0.000992 0.00617 0.00678 0.0238 0.117
HB ash608 lasso 984 984 2576 608 8 - - 0.00047 - - 0.00376 - -
HB ash292 huber 876 1168 3668 292 6 11 15 0.000914 0.00138 0.00502 0.00549 0.0152 0.0753
HB abb313 huber 939 1115 3122 313 9 19 17 0.000498 0.000995 0.0062 0.00448 0.0189 0.105
HB ash331 huber 993 1097 2317 331 8 16 15 0.000434 0.00104 0.00546 0.00347 0.0166 0.082
NYPA Maragal 2 lasso 1255 1255 6312 555 7 14 11 0.00122 0.00185 0.011 0.00854 0.0259 0.121
HB ash958 lasso 1542 1542 4042 958 7 - 21 0.000786 - 0.00901 0.00551 - 0.189
HB illc1033 lasso 1673 1673 7032 1033 19 - - 0.000932 - - 0.0177 - -
HB well1033 lasso 1673 1673 7045 1033 13 - - 0.000894 - - 0.0116 - -
NYPA Maragal 2 huber 1665 2015 7132 555 8 16 12 0.00127 0.0029 0.00951 0.0101 0.0463 0.114
HB ash608 huber 1824 2012 4256 608 9 18 16 0.000756 0.00127 0.00938 0.00681 0.0228 0.15
HB ash958 huber 2874 3166 6706 958 9 17 18 0.00131 0.00208 0.0154 0.0118 0.0354 0.277
33

HB illc1033 huber 3099 3419 9884 1033 7 11 7 0.002 0.00306 0.0177 0.014 0.0337 0.124
HB well1033 huber 3099 3419 9897 1033 7 12 7 0.00168 0.00387 0.0175 0.0118 0.0465 0.123
HB illc1850 lasso 3274 3274 13334 1850 13 - - 0.00212 - - 0.0275 - -
HB well1850 lasso 3274 3274 13453 1850 12 - - 0.00201 - - 0.0241 - -
NYPA Maragal 3 lasso 3410 3410 23521 1690 7 15 9 0.00921 0.0102 0.0367 0.0645 0.153 0.33
NYPA Maragal 4 lasso 4032 4032 32819 1964 6 17 9 0.0228 0.0253 0.0427 0.137 0.429 0.384
NYPA Maragal 3 huber 5070 5930 26841 1690 8 18 11 0.00971 0.0112 0.0477 0.0777 0.202 0.524
HB illc1850 huber 5550 6262 17886 1850 7 11 13 0.00343 0.00722 0.0297 0.024 0.0795 0.386
HB well1850 huber 5550 6262 18005 1850 7 11 13 0.00342 0.00718 0.034 0.024 0.079 0.441
NYPA Maragal 4 huber 5892 6926 36539 1964 7 18 13 0.0252 0.0245 0.0437 0.177 0.441 0.568
NYPA Maragal 5 lasso 11294 11294 111025 4654 8 21 9 0.156 0.168 0.168 1.25 3.53 1.51
NYPA Maragal 5 huber 13962 17282 116361 4654 8 20 - 0.17 0.168 - 1.36 3.36 -
NYPA Maragal 6 lasso 41559 41559 599557 21255 7 - 8 4.88 - 1.4 34.1 - 11.2
NYPA Maragal 6 huber 63765 73917 643969 21255 7 - - 5.41 - - 37.9 - -
Pereyra landmark lasso 77360 77360 1229616 71952 8 - - 0.185 - - 1.48 - -
NYPA Maragal 7 lasso 99973 99973 1353638 46845 7 - - 11 - - 76.7 - -
NYPA Maragal 8 huber 99636 174713 1474475 33212 8 - 16 6.5 - 1.41 52 - 22.5
NYPA Maragal 7 huber 140535 167099 1434762 46845 10 - - 10.9 - - 109 - -
NYPA Maragal 8 lasso 183366 183366 1641935 33212 7 - - 6.59 - - 46.1 - -
Pereyra landmark huber 215856 218560 1506608 71952 82 - - 0.176 - - 14.4 - -
ANSYS Delor64K huber 194157 1979502 975735 64719 7 - 14 0.636 - 1.61 4.45 - 22.5
ANSYS Delor338K huber 1029708 1916766 5927779 343236 8 - 4 1.46 - 18.1 11.7 - 72.5
ANSYS Delor295K huber 887202 2711130 3879993 295734 8 - 4 1.35 - 20 10.8 - 80.2
ANSYS Delor338K lasso 2117352 2117352 8103067 343236 7 - - 2.14 - - 15 - -
ANSYS Delor64K lasso 3635409 3635409 7858239 64719 8 - - 2.61 - - 20.9 - -
ANSYS Delor295K lasso 3943590 3943590 9992769 295734 8 - - 3.17 - - 25.4 - -
 Table 4: Solve times and iteration counts for the NETLIB Feasible LP problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
afiro 78 51 153 0 8 9 11 3.91e-05 3.05e-05 0.000263 0.000312 0.000275 0.00289
kb2 120 68 390 0 16 16 28 6.83e-05 6.32e-05 0.000208 0.00109 0.00101 0.00583
sc50a 128 78 238 0 9 11 11 6e-05 4.84e-05 0.000276 0.00054 0.000532 0.00304
sc50b 128 78 226 0 8 10 9 6.27e-05 4.58e-05 0.000305 0.000502 0.000458 0.00274
blend 188 114 636 0 11 12 14 0.000115 0.000102 0.00102 0.00126 0.00122 0.0143
adlittle 194 138 562 0 12 12 16 0.000115 9.69e-05 0.000976 0.00137 0.00116 0.0156
share2b 258 162 939 0 11 13 13 0.000166 0.000143 0.00128 0.00182 0.00186 0.0166
sc105 268 163 503 0 10 12 12 0.00012 0.000103 0.000518 0.0012 0.00123 0.00622
stocfor1 282 165 666 0 16 15 26 0.000138 0.000126 0.00124 0.00222 0.00189 0.0323
scagr7 314 185 650 0 15 15 15 0.00012 0.00011 0.00125 0.0018 0.00165 0.0187
recipe 364 204 960 0 10 11 7 0.000179 0.000149 0.00184 0.00179 0.00164 0.0129
share1b 370 253 1432 0 22 27 45 0.000286 0.000228 0.00177 0.0063 0.00616 0.0798
nug05 435 225 1275 0 7 7 7 0.000949 0.000839 0.00199 0.00664 0.00587 0.014
beaconfd 468 295 3703 0 9 10 14 0.000702 0.000561 0.0026 0.00632 0.00561 0.0365
israel 490 316 2759 0 19 23 33 0.000457 0.000398 0.0024 0.00868 0.00915 0.0793
brandy 523 303 2505 0 15 18 24 0.000513 0.000448 0.00245 0.0077 0.00806 0.0587
sc205 522 317 982 0 13 13 13 0.000231 0.000247 0.00145 0.003 0.00321 0.0189
lotfi 519 366 1502 0 19 20 17 0.000302 0.000247 0.00212 0.00574 0.00495 0.036
bore3d 578 334 1793 0 19 20 40 0.000401 0.000339 0.00244 0.00762 0.00679 0.0977
vtp base 608 346 1461 0 31 33 19 0.000283 0.000269 0.00267 0.00877 0.00888 0.0507
34

grow7 721 301 3193 0 13 12 12 0.000614 0.000547 0.00483 0.00798 0.00657 0.058
e226 695 472 3240 0 22 24 40 0.000588 0.000525 0.00284 0.0129 0.0126 0.114
bandm 777 472 2966 0 18 21 24 0.000618 0.000656 0.00339 0.0111 0.0138 0.0813
scorpion 854 466 2000 0 12 12 12 0.000478 0.000416 0.00238 0.00574 0.00499 0.0286
nug06 858 486 2718 0 7 7 7 0.00302 0.00287 0.00456 0.0211 0.0201 0.032
capri 870 482 2495 0 21 22 16 0.000579 0.000522 0.00397 0.0122 0.0115 0.0635
scfxm1 930 600 3332 0 19 22 18 0.000767 0.000702 0.00401 0.0146 0.0154 0.0722
stair 970 614 4617 0 22 23 15 0.000999 0.000898 0.00704 0.022 0.0206 0.106
scsd1 837 760 3148 0 10 11 13 0.000506 0.000453 0.0028 0.00506 0.00499 0.0364
tuff 985 628 5213 0 21 - 22 0.00113 - 0.00488 0.0237 - 0.107
sctap1 960 660 2532 0 26 25 16 0.00043 0.000402 0.00365 0.0112 0.0101 0.0584
agg 1103 615 3477 0 45 43 43 0.000834 0.000554 0.00246 0.0375 0.0238 0.106
scagr25 1142 671 2396 0 17 18 19 0.000397 0.000376 0.00411 0.00675 0.00676 0.0781
degen2 1201 757 4958 0 11 12 11 0.00177 0.0016 0.00936 0.0195 0.0192 0.103
agg2 1274 758 5498 0 26 28 26 0.0019 0.00188 0.00569 0.0494 0.0526 0.148
agg3 1274 758 5514 0 25 29 27 0.00187 0.00182 0.00609 0.0468 0.0529 0.165
etamacro 1351 816 3488 0 25 33 33 0.00175 0.00142 0.00608 0.0438 0.047 0.201
grow15 1545 645 6865 0 13 13 14 0.0013 0.00111 0.00946 0.0168 0.0145 0.132
nug07 1533 931 5145 0 11 11 9 0.00895 0.00919 0.0178 0.0984 0.101 0.16
fffff800 1552 1028 7429 0 36 49 25 0.0023 0.00202 0.0076 0.0829 0.0992 0.19
finnis 1597 1064 3860 0 36 44 26 0.000909 0.000707 0.00631 0.0327 0.0311 0.164
pilot4 1692 1123 6546 0 39 72 37 0.0016 0.00114 0.00793 0.0625 0.0821 0.294
scsd6 1497 1350 5666 0 13 13 13 0.000832 0.000806 0.00487 0.0108 0.0105 0.0633
standata 1737 1274 4608 0 12 15 20 0.000954 0.000763 0.00566 0.0114 0.0115 0.113
scrs8 1765 1275 4563 0 28 29 37 0.00104 0.000916 0.00643 0.0292 0.0266 0.238
scfxm2 1860 1200 6669 0 22 23 20 0.00149 0.00144 0.00768 0.0328 0.0331 0.154
 Table 4: Solve times and iteration counts for the NETLIB Feasible LP problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
standmps 1845 1274 5256 0 17 18 29 0.0011 0.000879 0.00609 0.0187 0.0158 0.176
fit1d 2099 1049 15502 0 28 30 26 0.00173 0.00163 0.00294 0.0484 0.0489 0.0763
gfrd pnc 2034 1160 3863 0 14 17 24 0.000869 0.000767 0.00664 0.0122 0.013 0.159
grow22 2266 946 10078 0 14 14 14 0.00184 0.00155 0.0136 0.0257 0.0217 0.19
standgub 1848 1383 4825 0 12 15 21 0.00101 0.000816 0.00573 0.0121 0.0122 0.12
ship04s 1908 1506 5906 0 17 16 28 0.00119 0.00111 0.00571 0.0202 0.0177 0.16
bnl1 2229 1586 7118 0 57 58 36 0.00183 0.00182 0.00851 0.104 0.105 0.306
perold 2309 1506 7832 0 51 - 44 0.003 - 0.00978 0.153 - 0.43
modszk1 2305 1620 4786 0 27 31 27 0.00125 0.000878 0.00783 0.0337 0.0272 0.211
nug08 2544 1632 8928 0 9 9 7 0.0294 0.0307 0.0389 0.264 0.277 0.272
qap8 2544 1632 8928 0 9 9 7 0.031 0.032 0.0333 0.279 0.288 0.233
shell 2430 1777 5452 0 17 18 16 0.00123 0.00108 0.00895 0.0209 0.0195 0.143
fit1p 2703 1677 11944 0 18 23 21 0.00166 0.00137 0.00862 0.0298 0.0315 0.181
25fv47 2697 1876 12581 0 27 28 29 0.00437 0.00442 0.0122 0.118 0.124 0.355
scfxm3 2790 1800 10006 0 22 24 20 0.00221 0.00214 0.0117 0.0486 0.0514 0.234
ship04l 2568 2166 8546 0 17 19 23 0.00156 0.00141 0.00764 0.0265 0.0268 0.176
maros 2812 1966 12103 0 28 34 36 0.00405 0.00325 0.0111 0.113 0.11 0.398
ganges 3412 1706 9040 0 31 37 16 0.00204 0.00181 0.0148 0.0634 0.0668 0.236
wood1p 2839 2595 72811 0 16 18 14 0.00935 0.0085 0.0257 0.15 0.153 0.36
ship08s 3245 2467 9661 0 16 17 20 0.00198 0.00185 0.0104 0.0317 0.0315 0.207
35

pilot ja 3458 2267 17495 0 59 - 35 0.00599 - 0.0169 0.354 - 0.593

scsd8 3147 2750 11334 0 11 12 12 0.00183 0.00155 0.0106 0.0201 0.0186 0.128
sctap2 3590 2500 9834 0 16 16 28 0.00185 0.00174 0.0115 0.0296 0.0278 0.322
pilotnov 3761 2446 16117 0 21 22 22 0.00658 0.0063 0.0188 0.138 0.139 0.413
degen3 4107 2604 28036 0 14 15 11 0.014 0.0139 0.0468 0.196 0.209 0.515
pilot we 3864 2928 12407 0 61 73 59 0.00305 0.00259 0.0133 0.186 0.189 0.785
ship12s 4020 2869 11153 0 21 23 25 0.00224 0.00209 0.0117 0.047 0.0482 0.294
czprob 4491 3562 14270 0 43 43 25 0.00236 0.00213 0.0135 0.101 0.0916 0.338
sctap3 4820 3340 13074 0 16 16 35 0.00251 0.00239 0.0155 0.0401 0.0382 0.542
stocfor2 5202 3045 12402 0 28 27 32 0.00275 0.00283 0.0136 0.0771 0.0765 0.436
sierra 5978 2735 12752 0 18 21 35 0.00264 0.00283 0.0212 0.0474 0.0595 0.742
cycle 5344 3371 24675 0 38 - 47 0.00677 - 0.0241 0.257 - 1.13
ship08l 5141 4363 17245 0 18 19 21 0.00345 0.00319 0.0157 0.062 0.0607 0.329
bnl2 6810 4486 19482 0 34 38 33 0.00949 0.0094 0.0284 0.323 0.357 0.939
pilot 7341 4860 50275 0 65 - 59 0.0274 - 0.0368 1.78 - 2.17
ship12l 6684 5533 21809 0 29 28 22 0.00398 0.00401 0.0201 0.115 0.112 0.441
d6cube 6599 6184 43888 0 18 - 12 0.0125 - 0.0469 0.225 - 0.562
ken 07 9630 3602 15608 0 17 16 20 0.00336 0.00346 0.0327 0.0572 0.0553 0.654
d2q06c 8002 5831 38912 0 32 48 48 0.0203 0.0192 0.0338 0.65 0.92 1.62
greenbeb 8277 5598 36955 0 66 69 47 0.0166 0.0178 0.0331 1.1 1.23 1.56
greenbea 8280 5598 36958 0 42 44 55 0.0167 0.0174 0.0329 0.703 0.767 1.81
cre c 9479 6411 22388 0 27 32 23 0.00567 0.00595 0.0356 0.153 0.19 0.819
pilot87 10288 6680 83207 0 100 - 94 0.11 - 0.0648 11 - 6.09
woodw 9516 8418 45905 0 26 32 19 0.00939 0.00846 0.0351 0.244 0.271 0.667
cre a 10764 7248 25416 0 22 26 40 0.00663 0.00682 0.0363 0.146 0.177 1.45
truss 9806 8806 36642 0 20 20 20 0.00879 0.00893 0.036 0.176 0.179 0.72
 Table 4: Solve times and iteration counts for the NETLIB Feasible LP problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
pds 02 12803 7716 26421 0 34 32 24 0.00671 0.00721 0.0474 0.228 0.231 1.14
nug12 12048 8856 47160 0 20 20 16 1.05 1.1 0.192 21 22.1 3.07
qap12 12048 8856 47160 0 20 20 16 1.03 1.14 0.217 20.5 22.9 3.47
maros r7 12544 9408 154256 0 14 15 13 0.274 0.281 0.116 3.84 4.21 1.51
80bau3b 17309 12061 38311 0 37 41 25 0.00935 0.011 0.0579 0.346 0.45 1.45
dfl001 18314 12230 47875 0 - 47 35 - 0.871 0.127 - 40.9 4.46
fit2d 21049 10524 150066 0 24 27 27 0.0138 0.0154 0.0205 0.33 0.417 0.553
fit2p 24025 13525 71309 0 21 23 21 0.0129 0.0107 0.0624 0.27 0.247 1.31
nug15 28605 22275 117225 0 24 24 15 10.4 10.4 4.49 249 251 67.4
qap15 28605 22275 117225 0 24 24 17 10.5 11.3 3.82 251 270 65
osa 07 26185 25067 169879 0 23 24 27 0.0347 0.0295 0.0988 0.797 0.708 2.67
stocfor3 40216 23541 96262 0 42 47 61 0.024 0.027 0.0805 1.01 1.27 4.91
pds 06 48472 29351 101811 0 46 45 31 0.136 0.144 0.204 6.25 6.46 6.33
ken 11 57392 21349 91756 0 25 25 21 0.0279 0.03 0.101 0.699 0.75 2.12
pds 10 82638 49932 173685 0 61 64 38 0.507 0.509 0.39 30.9 32.6 14.8
ken 13 113950 42659 182564 0 27 27 29 0.0674 0.0691 0.196 1.82 1.86 5.68
36
 Table 5: Solve times and iteration counts for the NETLIB Infeasible LP problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
lpi itest2 22 13 39 0 6 6 4 1.63e-05 1.2e-05 0.00019 9.75e-05 7.23e-05 0.00076
lpi galenet 30 14 44 0 6 5 4 2.2e-05 1.5e-05 0.000187 0.000132 7.5e-05 0.000749
lpi itest6 28 17 46 0 5 8 4 2.42e-05 1.67e-05 0.00024 0.000121 0.000134 0.000961
lpi bgprtr 60 40 110 0 8 9 7 3.33e-05 2.84e-05 0.000262 0.000266 0.000256 0.00183
lpi woodinfe 138 89 243 0 7 8 6 7.6e-05 5.56e-05 0.000569 0.000532 0.000445 0.00342
lpi klein1 162 108 858 0 18 18 21 0.000178 0.000164 0.000433 0.00321 0.00296 0.00909
lpi forest6 202 131 382 0 8 9 10 9.06e-05 8.71e-05 0.000913 0.000725 0.000784 0.00913
lpi ex73a 404 211 668 0 7 6 15 0.000207 0.000179 0.00115 0.00145 0.00107 0.0172
lpi ex72a 412 215 682 0 7 6 17 0.000223 0.000205 0.00112 0.00156 0.00123 0.0191
lpi box1 492 261 912 0 8 7 4 0.000217 0.000238 0.00294 0.00174 0.00166 0.0118
lpi qual 1032 464 2355 0 61 55 51 0.000537 0.000495 0.00259 0.0327 0.0272 0.132
lpi refinery 1032 464 2335 0 19 20 23 0.000533 0.000469 0.00243 0.0101 0.00938 0.0558
lpi vol1 1032 464 2355 0 56 57 43 0.000539 0.000499 0.0024 0.0302 0.0285 0.103
lpi klein2 1008 531 5593 0 14 16 41 0.000917 0.000958 0.00219 0.0128 0.0153 0.09
lpi bgdbg1 1022 629 2336 0 9 8 9 0.00062 0.000602 0.00432 0.00558 0.00481 0.0388
lpi pang 1117 741 3689 0 24 24 27 0.000852 0.000788 0.00465 0.0205 0.0189 0.126
lpi chemcom 1176 744 2478 0 7 8 7 0.000791 0.000697 0.00525 0.00554 0.00557 0.0367
lpi mondou2 1393 604 2289 0 1 12 22 0.00196 0.000402 0.00322 0.00196 0.00482 0.0709
lpi bgetam 1351 816 3488 0 7 8 8 0.00206 0.00189 0.00958 0.0144 0.0152 0.0766
lpi reactor 1674 808 3947 0 29 29 22 0.000933 0.000956 0.00695 0.0271 0.0277 0.153
37

lpi pilot4i 1692 1123 6546 0 27 30 23 0.00186 0.00138 0.0104 0.0503 0.0413 0.238
lpi klein3 2076 1082 14183 0 18 17 28 0.00224 0.00208 0.00477 0.0404 0.0354 0.134
lpi gran 5707 2525 23160 0 10 13 46 0.00835 0.00683 0.0128 0.0835 0.0887 0.591
lpi ceria3d 7152 4400 24754 0 15 11 10 0.00586 0.00561 0.0557 0.0879 0.0618 0.557
lpi cplex1 8447 5224 16389 0 6 11 22 0.00679 0.00279 0.0152 0.0407 0.0307 0.335
lpi greenbea 8290 5596 36971 0 29 32 17 0.0177 0.0183 0.0371 0.513 0.587 0.63
lpi bgindy 13551 10880 77146 0 7 9 9 0.0377 0.0294 0.072 0.264 0.265 0.648
lpi gosh 17005 13455 113166 0 41 36 24 0.0498 0.0459 0.0612 2.04 1.65 1.47
 Table 6: Solve times and iteration counts for the LP Optimal Power Flow problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
case3 lmbd 25 9 43 2 8 18 - 1.55e-05 1.27e-05 - 0.000124 0.000229 -
case3 lmbd api 25 9 43 2 8 16 - 1.53e-05 1.58e-05 - 0.000122 0.000254 -
case3 lmbd sad 25 9 43 2 8 18 - 1.51e-05 1.59e-05 - 0.000121 0.000286 -
case5 pjm 46 16 82 0 7 8 8 2.61e-05 2.52e-05 0.000194 0.000183 0.000202 0.00155
case5 pjm api 46 16 82 0 9 9 10 2.49e-05 3.01e-05 0.000186 0.000224 0.000271 0.00186
case14 ieee 125 39 236 0 7 7 7 6.64e-05 5.97e-05 0.000326 0.000465 0.000418 0.00228
case14 ieee api 125 39 236 0 11 11 11 5.6e-05 6.03e-05 0.000248 0.000616 0.000663 0.00273
case30 as 248 77 470 6 8 16 15 9.86e-05 0.000131 0.000305 0.000789 0.0021 0.00457
case30 as api 248 77 470 6 9 20 24 0.000103 0.000118 0.000305 0.000924 0.00236 0.00733
case30 ieee 248 77 470 0 8 8 8 0.000121 0.000114 0.00037 0.000966 0.000911 0.00296
case30 ieee api 248 77 470 0 7 8 9 0.000127 0.000112 0.000346 0.000887 0.000894 0.00311
case24 ieee rts 273 95 502 22 9 22 - 0.000108 0.00012 - 0.000969 0.00263 -
case24 ieee rts api 273 95 502 22 11 23 - 0.000101 0.000108 - 0.00111 0.00247 -
case24 ieee rts sad 273 95 502 22 12 27 - 0.000102 0.00012 - 0.00122 0.00325 -
case39 epri 290 95 537 0 9 9 13 0.000126 0.00012 0.000365 0.00113 0.00108 0.00474
case39 epri api 290 95 537 0 9 10 10 0.000131 0.000118 0.000401 0.00118 0.00118 0.00401
case39 epri sad 290 95 537 0 18 20 13 0.000119 0.000122 0.000356 0.00215 0.00243 0.00463
case57 ieee 468 144 894 0 8 9 10 0.000217 0.000196 0.000506 0.00174 0.00177 0.00506
case57 ieee api 468 144 894 0 10 12 11 0.000213 0.000194 0.000507 0.00213 0.00233 0.00558
case60 c 515 171 974 0 8 8 9 0.00023 0.000237 0.000782 0.00184 0.00189 0.00704
38

case60 c api 515 171 974 0 14 19 13 0.000201 0.000198 0.000606 0.00282 0.00377 0.00788
case73 ieee rts 848 292 1570 66 9 25 - 0.000337 0.000391 - 0.00303 0.00977 -
case73 ieee rts api 848 292 1570 66 12 25 - 0.000307 0.000349 - 0.00368 0.00871 -
case73 ieee rts sad 848 292 1570 66 13 47 - 0.000301 0.000366 - 0.00392 0.0172 -
case89 pegase 1156 311 2331 0 9 8 29 0.000526 0.000513 0.00201 0.00474 0.0041 0.0582
case89 pegase api 1156 311 2331 0 14 14 35 0.000601 0.000529 0.002 0.00841 0.00741 0.0701
case118 ieee 1143 358 2181 0 12 12 12 0.000492 0.000485 0.00226 0.00591 0.00583 0.0271
case118 ieee api 1143 358 2181 0 14 14 16 0.000554 0.00059 0.00214 0.00776 0.00826 0.0342
case179 goc 1471 471 2817 0 13 12 18 0.000559 0.000546 0.0026 0.00727 0.00656 0.0468
case179 goc api 1471 471 2817 0 13 13 23 0.000632 0.000714 0.00255 0.00822 0.00928 0.0586
case200 activ 1502 483 2810 31 10 21 16 0.000567 0.000735 0.00371 0.00567 0.0154 0.0593
case200 activ api 1502 483 2810 31 11 19 26 0.000571 0.000807 0.00308 0.00628 0.0153 0.0801
case162 ieee dtc 1599 458 3145 0 14 14 18 0.000739 0.000782 0.00309 0.0104 0.0109 0.0557
case162 ieee dtc api 1599 458 3145 0 16 14 16 0.000769 0.000835 0.00312 0.0123 0.0117 0.0499
case162 ieee dtc sad 1599 458 3145 0 18 19 16 0.000746 0.000851 0.00316 0.0134 0.0162 0.0506
case197 snem 1572 518 3000 0 9 10 9 0.000645 0.000604 0.00332 0.0058 0.00604 0.0299
case197 snem api 1572 518 3000 0 12 13 16 0.000684 0.0007 0.00268 0.00821 0.0091 0.0428
case300 ieee 2490 780 4721 0 12 13 18 0.00114 0.0012 0.00416 0.0136 0.0156 0.075
case300 ieee api 2490 780 4721 0 14 13 16 0.00124 0.00127 0.0044 0.0173 0.0165 0.0704
case300 ieee sad 2490 780 4721 0 14 16 19 0.0013 0.00121 0.00481 0.0182 0.0193 0.0914
case240 pserc 2567 831 4958 0 13 14 23 0.00142 0.00133 0.00496 0.0184 0.0186 0.114
case240 pserc api 2567 831 4958 0 12 12 14 0.00129 0.00146 0.00527 0.0155 0.0175 0.0738
case588 sdet 4191 1369 7796 0 14 13 14 0.00216 0.00264 0.00722 0.0302 0.0343 0.101
case588 sdet api 4191 1369 7796 0 13 12 13 0.00232 0.00244 0.00753 0.0302 0.0292 0.0979
case500 goc 4327 1399 8210 60 15 22 - 0.00174 0.00185 - 0.0261 0.0407 -
case500 goc api 4327 1399 8210 60 18 33 - 0.00167 0.00184 - 0.0301 0.0608 -
 Table 6: Solve times and iteration counts for the LP Optimal Power Flow problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
case793 goc 5535 1803 10299 48 16 28 - 0.00224 0.00277 - 0.0358 0.0776 -
case793 goc api 5535 1803 10299 48 15 35 - 0.0022 0.0028 - 0.0331 0.0981 -
case1354 pegase 11268 3605 21558 0 13 13 28 0.00533 0.00671 0.0197 0.0693 0.0872 0.551
case1354 pegase api 11268 3605 21558 0 14 14 27 0.00603 0.00734 0.0198 0.0844 0.103 0.534
case1888 rte 14678 4709 27820 0 12 13 36 0.00737 0.00827 0.023 0.0884 0.108 0.83
case1888 rte api 14678 4709 27820 0 16 16 32 0.00755 0.00804 0.0242 0.121 0.129 0.773
case1888 rte sad 14678 4709 27820 0 13 13 25 0.00708 0.00901 0.0242 0.0921 0.117 0.606
case1803 snem 15041 4828 29036 0 17 18 32 0.00734 0.00927 0.0241 0.125 0.167 0.771
case1803 snem api 15041 4828 29036 0 20 30 39 0.00818 0.00713 0.024 0.164 0.214 0.935
case1951 rte 15222 4913 28771 0 14 14 33 0.00724 0.0097 0.0246 0.101 0.136 0.811
case1951 rte api 15222 4913 28771 0 17 17 36 0.00882 0.00788 0.0257 0.15 0.134 0.926
case2312 goc 17464 5551 33090 42 22 27 - 0.0076 0.00911 - 0.167 0.246 -
case2312 goc api 17464 5551 33090 42 18 62 - 0.00764 0.00818 - 0.138 0.507 -
case2383wp k 17498 5606 32798 0 21 23 25 0.0104 0.0102 0.0294 0.219 0.235 0.734
case2383wp k api 17498 5606 32798 0 12 10 13 0.0088 0.0119 0.0401 0.106 0.119 0.522
case2000 goc 18988 5871 37370 122 14 36 - 0.00782 0.00847 - 0.109 0.305 -
case2000 goc api 18988 5871 37370 122 18 37 - 0.00797 0.00844 - 0.143 0.312 -
case2737sop k 19509 6225 36593 0 16 18 20 0.0105 0.0137 0.036 0.168 0.247 0.719
case2737sop k api 19509 6225 36593 0 15 17 25 0.0107 0.0139 0.0332 0.161 0.236 0.83
case2736sp k 19610 6275 36746 0 13 13 23 0.01 0.0125 0.0351 0.13 0.163 0.807
39

case2736sp k api 19610 6275 36746 0 19 23 23 0.0117 0.0124 0.0345 0.222 0.285 0.793
case2746wp k 20042 6481 37414 0 15 17 27 0.0103 0.013 0.0351 0.154 0.221 0.947
case2746wp k api 20042 6481 37414 0 25 20 26 0.00833 0.0108 0.0358 0.208 0.215 0.93
case2746wop k 20128 6484 37639 0 14 15 23 0.0106 0.0138 0.0362 0.149 0.207 0.833
case2746wop k api 20128 6484 37639 0 18 20 22 0.0122 0.0111 0.0361 0.22 0.222 0.794
case3012wp k 21631 6969 40424 0 16 20 25 0.0135 0.0131 0.0378 0.215 0.262 0.945
case3012wp k api 21631 6969 40424 0 24 37 27 0.013 0.0101 0.0381 0.312 0.375 1.03
case2848 rte 22083 7135 41734 0 13 13 32 0.0109 0.0123 0.0362 0.142 0.16 1.16
case2848 rte api 22083 7135 41734 0 15 16 26 0.0112 0.0127 0.0384 0.168 0.204 0.999
case3120sp k 22164 7111 41482 0 17 18 27 0.0132 0.0128 0.0376 0.225 0.231 1.02
case3120sp k api 22164 7111 41482 0 17 26 26 0.0138 0.0117 0.0391 0.235 0.304 1.02
case2868 rte 22357 7237 42224 0 14 15 29 0.0112 0.0157 0.0373 0.156 0.235 1.08
case2868 rte api 22357 7237 42224 0 17 16 34 0.012 0.0128 0.0373 0.204 0.204 1.27
case2853 sdet 23525 7593 44445 0 19 20 24 0.0117 0.0127 0.0368 0.223 0.255 0.884
case2853 sdet api 23525 7593 44445 0 41 - 49 0.00887 - 0.0359 0.364 - 1.76
case3022 goc 23816 7484 45395 110 22 40 - 0.0114 0.013 - 0.251 0.521 -
case3022 goc api 23816 7484 45395 110 23 73 55 0.00994 0.0111 0.0486 0.229 0.809 2.67
case3022 goc sad 23816 7484 45395 110 22 43 - 0.0115 0.0126 - 0.253 0.542 -
case2742 goc 25136 7597 49278 48 15 56 - 0.0114 0.0119 - 0.171 0.665 -
case2742 goc api 25136 7597 49278 48 19 74 - 0.0117 0.0129 - 0.223 0.952 -
case2742 goc sad 25136 7597 49278 48 15 62 - 0.0117 0.0107 - 0.176 0.666 -
case3375wp k 24952 8014 46837 0 16 15 27 0.0132 0.0184 0.0432 0.212 0.276 1.17
case3375wp k api 24952 8014 46837 0 18 19 38 0.0142 0.0133 0.0426 0.256 0.252 1.62
case3375wp k sad 24952 8014 46837 0 17 16 30 0.0139 0.0164 0.0416 0.236 0.263 1.25
case2869 pegase 25572 7961 49477 0 16 15 38 0.0119 0.0173 0.0394 0.19 0.26 1.5
case2869 pegase api 25572 7961 49477 0 16 16 37 0.0134 0.02 0.0404 0.215 0.32 1.5
 Table 6: Solve times and iteration counts for the LP Optimal Power Flow problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
case4661 sdet 35603 11382 67156 0 17 20 27 0.0269 0.0245 0.0566 0.457 0.49 1.53
case4661 sdet api 35603 11382 67156 0 17 31 35 0.0246 0.0199 0.06 0.419 0.618 2.1
case3970 goc 36084 10994 70485 65 15 67 - 0.0163 0.0244 - 0.244 1.64 -
case3970 goc api 36084 10994 70485 65 18 - - 0.0169 - - 0.304 - -
case4020 goc 37867 11360 74329 23 26 36 40 0.0179 0.0244 0.0669 0.466 0.879 2.67
case4020 goc api 37867 11360 74329 23 20 - - 0.0195 - - 0.389 - -
case4917 goc 38604 12210 73532 193 21 69 - 0.0215 0.0174 - 0.451 1.2 -
case4917 goc api 38604 12210 73532 193 22 - - 0.017 - - 0.375 - -
case4917 goc sad 38604 12210 73532 193 22 68 - 0.018 0.0178 - 0.396 1.21 -
case4601 goc 39625 12208 76838 62 16 75 - 0.0176 0.0231 - 0.282 1.73 -
case4601 goc api 39625 12208 76838 62 19 - - 0.0186 - - 0.354 - -
case4601 goc sad 39625 12208 76838 62 21 - - 0.0204 - - 0.429 - -
case4837 goc 42041 12934 81840 50 17 51 - 0.0199 0.0236 - 0.339 1.2 -
case4837 goc api 42041 12934 81840 50 21 67 - 0.0188 0.0211 - 0.395 1.42 -
case4619 goc 44438 13116 87440 29 18 53 - 0.0209 0.0222 - 0.375 1.18 -
case4619 goc api 44438 13116 87440 29 20 - - 0.0243 - - 0.486 - -
case5658 epigrids 49549 15204 96379 0 17 16 39 0.0265 0.0376 0.0732 0.451 0.602 2.85
case5658 epigrids api 49549 15204 96379 0 14 16 40 0.0297 0.0384 0.074 0.416 0.615 2.96
case6468 rte 50397 15867 96458 0 15 16 61 0.0275 0.0347 0.0686 0.412 0.556 4.18
case6468 rte api 50397 15867 96458 0 18 18 55 0.0274 0.0359 0.0659 0.494 0.646 3.62
40

case6468 rte sad 50397 15867 96458 0 15 17 61 0.0272 0.0368 0.0673 0.408 0.626 4.1
case6495 rte 51081 16194 97510 0 18 19 70 0.0271 0.0474 0.0731 0.487 0.9 5.11
case6495 rte api 51081 16194 97510 0 17 18 58 0.03 0.0311 0.0734 0.509 0.56 4.26
case6495 rte sad 51081 16194 97510 0 18 19 65 0.0264 0.0393 0.0745 0.475 0.747 4.84
case6470 rte 51140 16236 97583 0 16 16 48 0.0272 0.0479 0.0702 0.435 0.767 3.37
case6470 rte api 51140 16236 97583 0 16 16 40 0.0298 0.0309 0.0736 0.477 0.495 2.94
case6470 rte sad 51140 16236 97583 0 16 16 45 0.0271 0.0495 0.0704 0.434 0.792 3.17
case6515 rte 51203 16236 97728 0 18 20 58 0.0305 0.0362 0.0673 0.549 0.723 3.9
case6515 rte api 51203 16236 97728 0 18 18 49 0.0314 0.0263 0.0696 0.565 0.474 3.41
case6515 rte sad 51203 16236 97728 0 18 19 58 0.0294 0.0359 0.0697 0.53 0.683 4.04
case7336 epigrids 63100 19539 122362 0 16 18 37 0.0365 0.0507 0.0962 0.585 0.913 3.56
case7336 epigrids api 63100 19539 122362 0 17 19 40 0.0465 0.0457 0.0996 0.791 0.868 3.99
case10000 goc 79096 25209 149368 511 25 44 - 0.0369 0.0513 - 0.923 2.26 -
case10000 goc api 79096 25209 149368 511 25 - - 0.0385 - - 0.963 - -
case8387 pegase 81791 24813 159503 0 23 27 31 0.0561 0.0751 0.159 1.29 2.03 4.93
case8387 pegase api 81791 24813 159503 0 23 26 35 0.0579 0.0575 0.14 1.33 1.49 4.9
case8387 pegase sad 81791 24813 159503 0 23 31 32 0.0575 0.0675 0.145 1.32 2.09 4.64
case9591 goc 86151 25871 168669 55 20 - - 0.0486 - - 0.972 - -
case9591 goc api 86151 25871 168669 55 24 - - 0.0519 - - 1.25 - -
case9241 pegase 88693 26735 173507 0 108 - 71 0.0347 - 0.152 3.75 - 10.8
case9241 pegase api 88693 26735 173507 0 19 19 57 0.0557 0.0742 0.15 1.06 1.41 8.54
case10192 epigrids 92051 27914 180020 697 18 63 - 0.052 0.0656 - 0.935 4.14 -
case10192 epigrids api 92051 27914 180020 697 18 80 - 0.0502 0.057 - 0.904 4.56 -
case10480 goc 99926 29816 196673 276 21 82 - 0.0591 0.0755 - 1.24 6.19 -
case10480 goc api 99926 29816 196673 276 19 - - 0.0605 - - 1.15 - -
case13659 pegase 120495 38218 230046 0 126 - 43 0.0473 - 0.216 5.96 - 9.3
 Table 6: Solve times and iteration counts for the LP Optimal Power Flow problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
case13659 pegase api 120495 38218 230046 0 45 54 37 0.0526 0.0754 0.214 2.37 4.07 7.91
case20758 epigrids 182928 56275 355508 1881 19 53 - 0.123 0.16 - 2.34 8.46 -
case20758 epigrids api 182928 56275 355508 1881 19 70 - 0.118 0.149 - 2.24 10.4 -
case19402 goc sad 184959 55077 364846 249 23 - - 0.127 - - 2.93 - -
case30000 goc 213698 68919 399262 372 39 51 - 0.118 0.154 - 4.59 7.87 -
case30000 goc api 213698 68919 399262 372 31 95 - 0.13 0.152 - 4.02 14.5 -
case30000 goc sad 213698 68919 399262 372 26 - - 0.119 - - 3.1 - -
case78484 epigrids 685984 211266 1334253 0 30 - - 0.906 - - 27.2 - -
case78484 epigrids api 685984 211266 1334253 0 27 - 122 0.919 - 2.29 24.8 - 280
case78484 epigrids sad 685984 211266 1334253 0 31 - - 0.9 - - 27.9 - -
41
 Table 7: Solve times and iteration counts for the SOCP Optimal Power Flow problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
case3 lmbd 124 29 190 0 13 15 15 5.42e-05 5.95e-05 0.000252 0.000705 0.000893 0.00378
case3 lmbd api 124 29 190 0 13 14 14 5.68e-05 6.21e-05 0.000255 0.000739 0.00087 0.00357
case3 lmbd sad 124 29 190 0 13 16 14 5.3e-05 5.95e-05 0.00026 0.000688 0.000952 0.00364
case5 pjm 220 51 352 0 16 19 27 9.52e-05 0.000116 0.000342 0.00152 0.0022 0.00924
case5 pjm api 220 51 352 0 17 20 29 0.000103 0.000123 0.000343 0.00175 0.00247 0.00996
case5 pjm sad 220 51 352 0 14 18 22 0.0001 0.000135 0.00036 0.0014 0.00243 0.00793
case14 ieee 676 144 1069 0 14 18 28 0.000283 0.000359 0.00183 0.00396 0.00647 0.0512
case14 ieee api 676 144 1069 0 16 26 31 0.000285 0.000395 0.00187 0.00456 0.0103 0.0578
case14 ieee sad 676 144 1069 0 17 22 31 0.000283 0.000363 0.00183 0.00482 0.00798 0.0566
case30 ieee 1374 288 2188 0 25 28 35 0.000629 0.000628 0.00335 0.0157 0.0176 0.117
case30 ieee api 1374 288 2188 0 22 29 37 0.000653 0.000604 0.0034 0.0144 0.0175 0.126
case30 ieee sad 1374 288 2188 0 - - 45 - - 0.00345 - - 0.155
case30 as 1404 294 2218 0 21 25 32 0.000567 0.000843 0.00355 0.0119 0.0211 0.114
case30 as api 1404 294 2218 0 25 31 40 0.000602 0.0007 0.00349 0.0151 0.0217 0.14
case30 as sad 1404 294 2218 0 19 28 46 0.000579 0.000954 0.00346 0.011 0.0267 0.159
case24 ieee rts 1430 332 2253 0 18 23 40 0.000661 0.000699 0.00367 0.0119 0.0161 0.147
case24 ieee rts api 1430 332 2253 0 19 23 40 0.00067 0.000723 0.00361 0.0127 0.0166 0.145
case24 ieee rts sad 1430 332 2253 0 17 22 43 0.000648 0.000802 0.00363 0.011 0.0176 0.156
case39 epri 1576 335 2506 0 24 36 53 0.000712 0.00112 0.00365 0.0171 0.0405 0.193
case39 epri api 1576 335 2506 0 25 40 53 0.000718 0.000899 0.00359 0.0179 0.0359 0.19
42

case39 epri sad 1576 335 2506 0 28 42 61 0.000706 0.000771 0.00365 0.0198 0.0324 0.222
case57 ieee 2632 547 4171 0 23 30 43 0.00126 0.00129 0.00625 0.0289 0.0387 0.269
case57 ieee api 2632 547 4171 0 22 29 41 0.00124 0.00133 0.00641 0.0273 0.0385 0.263
case57 ieee sad 2632 547 4171 0 26 37 58 0.00127 0.00115 0.00618 0.033 0.0426 0.358
case60 c 2780 602 4310 0 21 27 38 0.00115 0.00143 0.00668 0.0242 0.0385 0.254
case60 c api 2780 602 4310 0 26 40 - 0.00123 0.00158 - 0.032 0.063 -
case60 c sad 2780 602 4310 0 24 31 - 0.00128 0.00153 - 0.0308 0.0474 -
case73 ieee rts 4474 1033 7067 0 22 26 45 0.00203 0.00264 0.0113 0.0448 0.0685 0.51
case73 ieee rts api 4474 1033 7067 0 20 - 43 0.00203 - 0.0114 0.0407 - 0.491
case73 ieee rts sad 4474 1033 7067 0 19 25 47 0.00219 0.00229 0.011 0.0416 0.0573 0.516
case118 ieee 6184 1328 10052 0 24 29 63 0.00284 0.00384 0.0149 0.0683 0.111 0.939
case118 ieee api 6184 1328 10052 0 23 28 62 0.00298 0.00303 0.0148 0.0686 0.0848 0.919
case118 ieee sad 6184 1328 10052 0 21 27 66 0.00312 0.00325 0.015 0.0655 0.0876 0.987
case89 pegase 6656 1365 11100 0 38 - - 0.0034 - - 0.129 - -
case89 pegase api 6656 1365 11100 0 35 40 - 0.00336 0.00275 - 0.118 0.11 -
case89 pegase sad 6656 1365 11100 0 50 - - 0.00296 - - 0.148 - -
case179 goc 8230 1733 12996 0 25 26 - 0.00413 0.00553 - 0.103 0.144 -
case179 goc api 8230 1733 12996 0 54 - - 0.00426 - - 0.23 - -
case179 goc sad 8230 1733 12996 0 25 27 77 0.00393 0.00583 0.0193 0.0983 0.158 1.49
case200 activ 8457 1777 13527 0 38 34 42 0.00381 0.00404 0.0194 0.145 0.137 0.815
case200 activ api 8457 1777 13527 0 48 - 67 0.00394 - 0.0191 0.189 - 1.28
case200 activ sad 8457 1777 13527 0 40 42 - 0.00379 0.00395 - 0.152 0.166 -
case197 snem 8752 1857 14224 0 - - 25 - - 0.0221 - - 0.551
case197 snem api 8752 1857 14224 0 32 - 49 0.00403 - 0.0204 0.129 - 0.998
case197 snem sad 8752 1857 14224 0 - - 24 - - 0.02 - - 0.48
case162 ieee dtc 9168 1882 14920 0 48 54 - 0.00449 0.00481 - 0.215 0.26 -
 Table 7: Solve times and iteration counts for the SOCP Optimal Power Flow problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
case162 ieee dtc api 9168 1882 14920 0 47 68 90 0.00464 0.00441 0.023 0.218 0.3 2.07
case162 ieee dtc sad 9168 1882 14920 0 46 59 95 0.00453 0.00472 0.0229 0.208 0.278 2.18
case300 ieee api 13782 2900 21993 0 51 - - 0.00576 - - 0.294 - -
case300 ieee sad 13782 2900 21993 0 85 - - 0.00528 - - 0.449 - -
case240 pserc 13772 3014 22076 0 28 35 - 0.00717 0.00575 - 0.201 0.201 -
case240 pserc api 13772 3014 22076 0 26 39 - 0.00745 0.00706 - 0.194 0.275 -
case240 pserc sad 13772 3014 22076 0 29 39 - 0.00735 0.00583 - 0.213 0.227 -
case588 sdet 23204 4876 37012 0 77 - - 0.0093 - - 0.716 - -
case588 sdet api 23204 4876 37012 0 68 - - 0.0103 - - 0.699 - -
case588 sdet sad 23204 4876 37012 0 78 - - 0.00965 - - 0.753 - -
case500 goc 23888 5114 38653 0 45 - - 0.0137 - - 0.616 - -
case500 goc api 23888 5114 38653 0 37 - - 0.012 - - 0.445 - -
case500 goc sad 23888 5114 38653 0 43 - - 0.0136 - - 0.584 - -
case793 goc 31082 6495 49764 0 48 - - 0.0136 - - 0.654 - -
case793 goc api 31082 6495 49764 0 56 - - 0.014 - - 0.782 - -
case1354 pegase 62814 13258 103260 0 99 - - 0.0281 - - 2.78 - -
case1354 pegase api 62814 13258 103260 0 66 - - 0.0327 - - 2.16 - -
case1354 pegase sad 62814 13258 103260 0 85 - - 0.0289 - - 2.45 - -
case1888 rte api 81966 17208 131225 0 90 - - 0.0384 - - 3.46 - -
case1888 rte sad 81966 17208 131225 0 65 - - 0.049 - - 3.19 - -
43

case1951 rte 84496 17817 134660 0 79 - - 0.0486 - - 3.84 - -

case1951 rte api 84496 17817 134660 0 72 - - 0.053 - - 3.82 - -
case1951 rte sad 84496 17817 134660 0 80 - - 0.0478 - - 3.83 - -
case1803 snem 84794 17835 138430 0 85 - - 0.0389 - - 3.3 - -
case2383wp k api 97600 20393 155950 0 22 32 - 0.0692 0.0529 - 1.52 1.69 -
case2383wp k sad 97600 20393 155950 0 104 - - 0.0479 - - 4.98 - -
case2000 goc 108628 22742 178538 0 53 - - 0.0774 - - 4.1 - -
case2000 goc api 108628 22742 178538 0 51 - - 0.0699 - - 3.57 - -
case2737sop k 109822 22777 176602 0 71 - - 0.053 - - 3.76 - -
case2737sop k api 109822 22777 176602 0 85 - - 0.0491 - - 4.18 - -
case2736sp k 110022 22878 176901 0 71 - - 0.0502 - - 3.57 - -
case2736sp k sad 110022 22878 176901 0 77 - - 0.0521 - - 4.01 - -
case2746wp k api 111106 23320 178556 0 - - 36 - - 0.258 - - 9.29
case2746wp k sad 111106 23320 178556 0 78 - - 0.0505 - - 3.94 - -
case2746wop k 111822 23434 179829 0 69 - - 0.0563 - - 3.89 - -
case2746wop k sad 111822 23434 179829 0 66 - - 0.0524 - - 3.46 - -
case3012wp k 120676 25202 193907 0 111 - - 0.0565 - - 6.27 - -
case3012wp k sad 120676 25202 193907 0 117 - - 0.0563 - - 6.58 - -
case2848 rte 122708 25858 197228 0 81 - - 0.0742 - - 6.01 - -
case2848 rte api 122708 25858 197228 0 87 - - 0.084 - - 7.31 - -
case2848 rte sad 122708 25858 197228 0 70 - - 0.0722 - - 5.05 - -
case2868 rte 123912 26164 198869 0 85 - - 0.0796 - - 6.77 - -
case2868 rte api 123912 26164 198869 0 77 - - 0.0779 - - 6 - -
case2868 rte sad 123912 26164 198869 0 83 - - 0.0757 - - 6.28 - -
case2853 sdet sad 128886 27445 206896 0 105 - - 0.0532 - - 5.58 - -
case3375wp k 139126 29112 223999 0 93 - - 0.0595 - - 5.54 - -
 Table 7: Solve times and iteration counts for the SOCP Optimal Power Flow problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
case3375wp k sad 139126 29112 223999 0 110 - - 0.0583 - - 6.42 - -
case2869 pegase api 143608 30153 236217 0 55 - - 0.0994 - - 5.47 - -
case2869 pegase sad 143608 30153 236217 0 52 - - 0.102 - - 5.32 - -
case2742 goc 144110 29856 236467 0 113 - - 0.103 - - 11.6 - -
case2742 goc sad 144110 29856 236467 0 109 - - 0.102 - - 11.1 - -
case4661 sdet api 198498 41599 320728 0 131 - - 0.107 - - 14 - -
case3970 goc 205819 42789 337328 0 142 - - 0.143 - - 20.4 - -
case4020 goc 216455 44877 355706 0 197 - - 0.154 - - 30.3 - -
case4917 goc sad 218213 45522 352833 0 - - 177 - - 0.458 - - 81
case4601 goc 225588 46885 368445 0 178 - - 0.153 - - 27.2 - -
case4601 goc sad 225588 46885 368445 0 182 - - 0.148 - - 26.9 - -
case4837 goc sad 240160 49855 392884 0 132 - - 0.198 - - 26.1 - -
case4619 goc 254753 52616 419210 0 154 - - 0.215 - - 33.1 - -
case4619 goc sad 254753 52616 419210 0 150 - - 0.214 - - 32.1 - -
case5658 epigrids 282180 58620 461724 0 162 - - 0.222 - - 35.9 - -
case5658 epigrids api 282180 58620 461724 0 165 - - 0.261 - - 43.1 - -
case5658 epigrids sad 282180 58620 461724 0 160 - - 0.216 - - 34.5 - -
case6468 rte api 286248 59396 463599 0 91 - - 0.22 - - 20 - -
case6468 rte sad 286248 59396 463599 0 101 - - 0.208 - - 21 - -
case6470 rte 287806 60144 465757 0 115 - - 0.201 - - 23.1 - -
44

case6470 rte api 287806 60144 465757 0 89 - - 0.222 - - 19.8 - -

case6495 rte 288050 60099 465939 0 124 - - 0.195 - - 24.2 - -
case6495 rte api 288050 60099 465939 0 111 - - 0.197 - - 21.9 - -
case6495 rte sad 288050 60099 465939 0 112 - - 0.193 - - 21.6 - -
case6515 rte sad 288710 60239 466922 0 93 - - 0.207 - - 19.3 - -
case7336 epigrids api 358450 74618 585766 0 151 - - 0.333 - - 50.3 - -
case10000 goc api 440997 92799 712177 0 67 - - 0.392 - - 26.2 - -
case10480 goc sad 573754 118760 943278 0 166 - - 0.548 - - 91 - -
 Table 8: Solve times and iteration counts for the CBLIB Exponential Cone problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
bss1 14 11 23 0 8 14 9 1.28e-05 8.13e-06 0.000153 0.000102 0.000114 0.00138
demb782 14 11 23 0 6 14 8 1.52e-05 7.99e-06 0.000154 9.1e-05 0.000112 0.00123
bss2 20 15 33 0 8 14 9 1.59e-05 1.07e-05 0.000158 0.000127 0.000149 0.00142
demb781 26 19 40 0 10 16 7 1.72e-05 1.45e-05 0.000173 0.000172 0.000232 0.00121
gptest 32 24 48 0 8 16 9 2.12e-05 1.5e-05 0.000168 0.00017 0.00024 0.00152
rijc781 32 24 48 0 8 16 9 2.15e-05 1.5e-05 0.000176 0.000172 0.00024 0.00158
rijc784 40 29 66 0 10 18 10 2.46e-05 2.25e-05 0.000186 0.000246 0.000404 0.00186
rijc785 44 33 83 0 10 17 9 2.77e-05 2.45e-05 0.000201 0.000277 0.000416 0.00181
rijc786 44 33 83 0 8 18 8 3.01e-05 2.38e-05 0.00021 0.000241 0.000428 0.00168
rijc782 56 40 87 0 12 17 11 3.13e-05 2.98e-05 0.00021 0.000376 0.000507 0.00231
rijc783 74 53 124 0 9 17 11 4.34e-05 3.84e-05 0.000232 0.00039 0.000653 0.00256
beck751 113 80 236 0 11 21 11 6.17e-05 5.58e-05 0.000271 0.000678 0.00117 0.00298
beck752 113 80 236 0 13 23 12 6e-05 5.8e-05 0.000294 0.00078 0.00133 0.00352
beck753 113 80 236 0 11 22 11 6.16e-05 5.41e-05 0.00027 0.000677 0.00119 0.00297
fiac81b 122 87 201 0 13 25 13 6.23e-05 6.22e-05 0.000305 0.00081 0.00156 0.00396
fang88 165 119 252 0 14 24 14 8.06e-05 8.44e-05 0.00033 0.00113 0.00203 0.00462
demb761 183 131 284 0 15 20 15 9.36e-05 9.3e-05 0.000352 0.0014 0.00186 0.00529
demb762 183 131 284 0 14 22 14 9.1e-05 9.1e-05 0.000361 0.00127 0.002 0.00505
demb763 183 131 284 0 15 20 14 8.68e-05 9.12e-05 0.000356 0.0013 0.00182 0.00499
fiac81a 289 191 496 0 13 22 10 0.000138 0.000138 0.000544 0.0018 0.00303 0.00544
45

rijc787 296 200 510 0 12 23 10 0.000143 0.000133 0.000567 0.00171 0.00306 0.00567
car 865 601 1584 0 19 26 10 0.00041 0.000424 0.00193 0.00779 0.011 0.0193
gp dave 1 1441 705 3686 0 26 32 20 0.000683 0.000732 0.00438 0.0178 0.0234 0.0876
jha88 1691 1131 3005 0 14 24 13 0.000813 0.000736 0.00509 0.0114 0.0177 0.0662
varun 2013 1346 6788 0 24 47 24 0.00131 0.00106 0.00562 0.0315 0.05 0.135
gp dave 2 2489 1219 6752 0 28 37 22 0.00129 0.00133 0.00731 0.0362 0.0493 0.161
LogExpCR n20 m400 3223 2022 13238 0 30 25 18 0.0017 0.00148 0.0061 0.0511 0.0369 0.11
gp dave 3 3537 1733 9818 0 - 40 24 - 0.00198 0.0117 - 0.0793 0.281
LogExpCR n100 m400 3303 2102 45314 0 31 27 19 0.00569 0.00508 0.00782 0.176 0.137 0.148
mra01 5513 3681 10680 0 25 - 14 0.00271 - 0.0173 0.0678 - 0.242
LogExpCR n20 m800 6423 4022 26411 0 27 28 21 0.00352 0.00295 0.013 0.0951 0.0827 0.272
LogExpCR n100 m800 6503 4102 90322 0 34 30 23 0.0118 0.0107 0.0168 0.401 0.322 0.387
LogExpCR n20 m1200 9623 6022 39574 0 27 27 21 0.00561 0.00492 0.0193 0.151 0.133 0.406
LogExpCR n20 m1600 12823 8022 52729 0 28 29 20 0.00775 0.0105 0.0254 0.217 0.306 0.507
LogExpCR n20 m2000 16023 10022 65872 0 31 33 23 0.00994 0.0133 0.0314 0.308 0.44 0.721
mra02 21965 14606 50050 0 28 - 17 0.0121 - 0.0549 0.339 - 0.933
cx02 100 31087 20693 56430 0 19 28 13 0.0159 0.017 0.0822 0.301 0.477 1.07
cx02 200 122187 81393 222880 0 22 35 13 0.0762 0.0887 0.36 1.68 3.11 4.68
 Table 9: Solve times and iteration counts for the CBLIB Second-Order Cone problem set
iterations time per iteration(s) total time (s)

Problem vars. cons. nnz(A) nnz(P) ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek ClarabelRs ECOS Mosek
sambal 63 31 87 0 11 14 13 3.12e-05 3.36e-05 0.000231 0.000343 0.00047 0.00301
nb 2506 2383 193902 0 20 - 12 0.0332 - 0.0113 0.664 - 0.136
nb L2 bessel 2764 2641 211458 0 10 17 7 0.0381 0.0477 0.0145 0.381 0.81 0.101
nb L1 4091 3176 195488 0 16 18 10 0.0355 0.0363 0.0203 0.568 0.653 0.203
nql30 6380 4501 20569 0 13 19 12 0.00795 0.00841 0.0361 0.103 0.16 0.434
sched 50 50 scaled 7503 4977 32962 0 19 29 18 0.00667 0.00704 0.0128 0.127 0.204 0.231
sched 50 50 orig 7506 4979 30467 0 - - 28 - - 0.0133 - - 0.373
chainsing 1000 3 10984 6991 18971 0 14 18 10 0.00558 0.00642 0.0204 0.0781 0.116 0.204
qssp30 11255 7565 44414 0 16 18 13 0.012 0.0145 0.0506 0.192 0.26 0.658
sched 100 50 scaled 14587 9744 70032 0 26 37 17 0.0152 0.0135 0.0234 0.394 0.498 0.399
sched 100 50 orig 14590 9746 65037 0 33 - - 0.0136 - - 0.448 - -
chainsing 1000 2 14976 9985 25957 0 15 16 14 0.00646 0.00868 0.0294 0.0968 0.139 0.411
chainsing 1000 1 18964 12976 32936 0 9 12 9 0.00829 0.00928 0.0366 0.0746 0.111 0.33
nql60 25360 18001 82539 0 13 22 11 0.0459 0.053 0.143 0.597 1.17 1.57
qssp60 44105 29525 178814 0 18 22 16 0.0806 0.12 0.195 1.45 2.65 3.12
nql90 56940 40501 185909 0 15 22 11 0.17 0.184 0.353 2.54 4.06 3.89
chainsing 10000 3 109984 69991 189971 0 - - 16 - - 0.218 - - 3.48
chainsing 10000 2 149976 99985 259957 0 19 - - 0.0852 - - 1.62 - -
chainsing 10000 1 189964 129976 329936 0 10 12 9 0.104 0.134 0.372 1.04 1.6 3.35
46
 Table 10: Solve times and iteration counts for the SDPLIB Semidefinite Programming problem set
iterations time per iteration(s) total time (s)

ClarabelRs ClarabelRs ClarabelRs

Problem vars. cons. nnz(A) nnz(P) ClarabelRs Mosek ClarabelRs Mosek ClarabelRs Mosek
(no decomp) (no decomp) (no decomp)
truss1 19 6 25 0 11 11 10 7.8e-05 8.02e-05 0.00015 0.000858 0.000882 0.0015
truss4 37 13 52 0 10 10 9 0.00014 0.000131 0.000295 0.0014 0.00131 0.00265
hinf1 50 25 116 0 28 26 - 0.000147 0.000134 - 0.00413 0.00348 -
hinf2 65 31 154 0 - 18 - - 0.000171 - - 0.00308 -
hinf3 65 31 154 0 - 19 - - 0.000168 - - 0.00319 -
hinf4 65 31 154 0 24 22 - 0.000176 0.000162 - 0.00422 0.00356 -
hinf5 65 31 154 0 24 - - 0.000185 - - 0.00443 - -
hinf6 65 31 154 0 23 24 - 0.000182 0.000168 - 0.00419 0.00403 -
hinf8 65 31 154 0 - 19 - - 0.000167 - - 0.00318 -
hinf9 65 31 154 0 24 - - 0.000191 - - 0.00459 - -
control1 81 36 375 0 54 26 - 0.000415 0.000348 - 0.0224 0.00905 -
truss3 89 28 120 0 12 12 10 0.000356 0.000349 0.000609 0.00427 0.00419 0.00609
hinf10 95 57 262 0 26 - - 0.000253 - - 0.00658 - -
hinf11 156 101 557 0 25 - - 0.000465 - - 0.0116 - -
hinf12 219 158 809 0 45 45 - 0.00064 0.000636 - 0.0288 0.0286 -
truss2 298 124 699 0 14 16 - 0.00121 0.000999 - 0.017 0.016 -
control2 311 121 2700 0 25 25 - 0.00337 0.00333 - 0.0843 0.0833 -
qap5 351 136 1026 0 9 9 9 0.00672 0.00643 0.0025 0.0605 0.0578 0.0225
truss7 451 86 863 0 22 22 20 0.0016 0.00158 0.00273 0.0353 0.0348 0.0547
703 229 1981 0 23 23 - 0.0205 0.0221 - 0.47 0.507 -
47

qap6
control3 691 256 8850 0 29 29 - 0.0129 0.0142 - 0.373 0.411 -
truss6 901 172 1726 0 25 25 22 0.00321 0.00312 0.00816 0.0803 0.0779 0.179
theta1 1275 104 153 0 12 12 8 0.0726 0.0707 0.0255 0.871 0.849 0.204
qap7 1275 358 3480 0 30 - - 0.0696 - - 2.09 - -
mcp124 1 974 662 1200 0 12 13 7 0.00396 4.74 2.09 0.0475 61.7 14.6
control4 1221 441 20700 0 32 32 - 0.0393 0.0392 - 1.26 1.26 -
truss5 1816 208 2823 0 18 18 16 0.0336 0.0332 0.0099 0.605 0.597 0.158
control5 1901 676 40125 0 30 30 - 0.104 0.101 - 3.11 3.03 -
qap8 2145 529 5697 0 32 32 - 0.22 0.214 - 7.03 6.86 -
control6 2731 961 69000 0 36 36 - 0.223 0.231 - 8.03 8.31 -
control7 3711 1296 109200 0 38 38 - 0.449 0.445 - 17.1 16.9 -
gpp100 5050 101 5150 0 26 26 - 1.66 1.68 - 43.2 43.7 -
mcp100 3168 2207 4314 0 11 11 7 0.0378 1.65 0.727 0.416 18.2 5.09
theta2 5050 498 597 0 10 10 9 1.78 1.81 0.706 17.8 18.1 6.36
mcp250 1 3307 2289 4328 0 12 - 9 0.0277 - 94.5 0.333 - 850
qap10 5151 1021 13101 0 25 25 - 1.74 1.72 - 43.6 43 -
control8 4841 1681 162600 0 40 40 - 0.844 0.864 - 33.8 34.5 -
truss8 6271 496 8286 0 - - 14 - - 0.0606 - - 0.849
mcp124 2 4120 2837 5550 0 11 12 8 0.0852 4.77 2.04 0.937 57.3 16.3
gpp124 1 7750 125 7874 0 30 30 - 4.74 4.7 - 142 141 -
gpp124 2 7750 125 7874 0 28 28 26 4.75 4.71 1.82 133 132 47.4
gpp124 3 7750 125 7874 0 - - 24 - - 1.83 - - 43.9
gpp124 4 7750 125 7874 0 33 33 28 4.64 4.6 1.82 153 152 51
control9 6121 2116 231075 0 35 35 - 1.49 1.47 - 52.2 51.4 -
control10 7551 2601 316500 0 43 43 - 2.4 2.38 - 103 102 -
 Table 10: Solve times and iteration counts for the SDPLIB Semidefinite Programming problem set
iterations time per iteration(s) total time (s)

ClarabelRs ClarabelRs ClarabelRs

Problem vars. cons. nnz(A) nnz(P) ClarabelRs Mosek ClarabelRs Mosek ClarabelRs Mosek
(no decomp) (no decomp) (no decomp)
theta3 11325 1106 1255 0 10 10 9 15.7 13.6 5.84 157 136 52.6
arch2 9230 6225 15522 0 24 23 - 0.14 19.2 - 3.36 441 -
arch4 9230 6225 15522 0 20 23 - 0.143 19.1 - 2.85 440 -
arch8 9230 6225 15522 0 24 23 - 0.139 19.5 - 3.35 448 -
mcp124 3 9530 6634 13144 0 14 13 8 0.439 4.74 2.04 6.15 61.6 16.3
theta4 20100 1949 2148 0 10 10 11 63.5 63.2 26.2 635 632 288
mcp250 2 13678 9449 18648 0 11 - 8 0.785 - 95.7 8.64 - 766
control11 14105 9296 433070 0 40 45 - 3.9 4.46 - 156 201 -
arch0 13743 10172 23026 0 22 26 - 0.372 19.1 - 8.17 496 -
mcp124 4 14594 9546 18968 0 12 12 7 1.85 4.74 2.11 22.2 56.9 14.8
theta5 31375 3028 3277 0 - - 10 - - 94.1 - - 941
mcp250 3 40617 29866 59482 0 13 - 8 11.1 - 95.4 145 - 763
mcp250 4 59628 41799 83348 0 14 - 9 47.4 - 94.4 664 - 850
48