Written and maintained by CASRAI Editorial Board
Published
On this page
Ipopt (Interior Point Optimizer, pronounced Eye-Pea-Opt) is an open source software package for large-scale nonlinear optimization. You give it an objective function and constraints that are twice continuously differentiable, and it searches for a local solution using an interior point line search filter method. It is a solver library rather than a modelling language: you reach it through an interface such as AMPL, CasADi or a Python wrapper, and you must also supply derivative information and a sparse linear solver.
Ask CASRAI · free to tryQuestion about this guide? Ask CASRAI answers with linked sources. 2 free questions a day, no account.
Short answer
Ipopt is a general-purpose solver for continuous, nonlinear, possibly nonconvex, constrained optimization problems. Its documentation describes it as mainly written for large-scale problems with up to millions of variables and constraints, provided the derivatives are sparse. It returns a local solution, so for nonconvex problems the answer depends on where the search starts. It is free to use, including commercially, under the Eclipse Public License (EPL), but the third-party components it needs may carry their own licences.
Definition and scope
Ipopt solves problems of the form: minimise f(x) subject to gL ≤ g(x) ≤ gU and xL ≤ x ≤ xU. The functions f and g can be linear or nonlinear, convex or non-convex, but they should be twice continuously differentiable. Equality constraints are expressed by setting the lower and upper bound of a constraint equal (gL = gU), so one problem statement covers equalities, inequalities and simple bounds on the variables.
The scope is therefore continuous nonlinear programming. The FAQ describes the algorithm as an interior-point method for continuous, nonlinear, nonconvex, constrained problems. Problems with integer or binary decision variables are a different class; for that class see the CASRAI guide to mixed-integer programming. For related optimisation tooling on this site, see the CVXPY guide.
Ipopt began as a Fortran 77 code written by Andreas Wächter at Carnegie Mellon University. The C++ version, released on 26 August 2005, is the primary version today. According to the FAQ, the C++ version added general inequality constraints handled with slack variables and an adaptive update of the barrier parameter mu.
How it works in practice
The project documentation states that Ipopt implements an interior point line search filter method that aims to find a local solution. Two parts of that description matter to a user.
Search direction from a linear system
At each iteration the search direction is computed from a full-space symmetric linear system. That is why a sparse symmetric indefinite linear solver is a required component: the solver you pick is where much of the run time is spent, and the documentation says performance and robustness depend on that choice. The linear solver must provide inertia information, which not every symmetric solver exposes.
Filter line search for global convergence
Global convergence is promoted through a filter line search. The documentation frames the outcome as a local solution, not a certificate of global optimality.
Derivatives: exact or quasi-Newton
Ipopt uses second derivatives of the Lagrangian when they are available. If they are not, it can approximate them with a limited-memory quasi-Newton method (BFGS or SR1). In the options reference, the hessian_approximation option defaults to exact, with limited-memory as the alternative.
Sparse storage
The implementation notes state that the Jacobian of the constraints and the Hessian of the Lagrangian are stored as sparse matrices in triplet format: each nonzero is given by a row index, a column index and a value. You can choose C-style (0-based) or Fortran-style (1-based) indexing when you describe the problem size in get_nlp_info. The documentation’s own example is a 7×7 matrix with 14 nonzeros, which needs 14 triplets rather than 49 dense entries. The FAQ states that the derivatives are assumed to be sparse.
What you must supply before it will run
Most confusion about Ipopt comes from mixing up what the solver provides and what the user or the interface provides. The table below separates the two, using the installation and implementation documentation.
| Item | What the documentation says | Who normally supplies it |
|---|---|---|
| Objective and constraint functions | Twice continuously differentiable; linear or nonlinear, convex or non-convex | You, or a modelling layer |
| Gradient and Jacobian | Required, in sparse triplet form for the Jacobian | You, or the interface or tool you call it through |
| Hessian of the Lagrangian | Exact by default; limited-memory quasi-Newton (BFGS, SR1) as the alternative | You, the interface, or Ipopt’s approximation |
| Sparse symmetric indefinite linear solver | At least one required, with inertia information; options named include MA27, MA57, HSL_MA77, HSL_MA86, HSL_MA97, MUMPS, PARDISO, SPRAL and WSMP | Installed at build time or loaded at run time |
| BLAS and LAPACK | Required; an optimised BLAS can change run time by an order of magnitude on large problems | Your system or a library such as OpenBLAS, BLIS, ATLAS, MKL or Accelerate |
| AMPL Solver Library (ASL) | Needed only to build the AMPL executable | Build step |
Two practical points follow from this table. First, a failed build or a slow run is more often a linear-solver or BLAS issue than an Ipopt issue, since the documentation ties robustness and speed to those components. It notes that HSL or Pardiso solvers are often good choices. Second, the option linear_solver is documented with MA27 as its default, so a build without that solver needs the option set to one that is installed.
Ways to call Ipopt
The distribution includes an AMPL executable and interfaces for C++, C, Java and Fortran, plus an R interface (ipoptr). The documentation lists third-party interfaces and tools including ADOL-C, AIMMS, APMonitor, CasADi, CppAD, IpoptNet, cyipopt, GAMS and ifopt. The data table below the article sets out which of these come from the distribution and which are third-party. Two are worth singling out for researchers:
- CasADi. The documentation states that CasADi comes with Ipopt. See the CASRAI guide to CasADi for how it builds derivatives and passes problems to solvers.
- cyipopt. A Python wrapper whose interface is modelled on SciPy’s. If you already use SciPy’s optimisation routines, cyipopt lets you move a constrained problem to Ipopt with a similar calling pattern.
Options and stopping criteria
Options are set through an ipopt.opt file, which takes preference, or through AMPL options. The main convergence setting is tol, the desired relative convergence tolerance, accompanied by tolerances for dual infeasibility (dual_inf_tol), constraint violation (constr_viol_tol) and complementarity (compl_inf_tol). A second, looser criterion, acceptable_tol, lets the algorithm stop at an acceptable point if it cannot reach the primary tolerance. When you report a result, state the tolerances and the linear solver used; they are part of the experimental record.
Where it matters for research and lab work
The documentation does not prescribe domain uses, so the guidance here is limited to what it supports for reproducible work with any nonlinear model that has constraints on its variables:
- Record the environment. Version, linear solver, BLAS library and option settings. The documentation says the solver choice affects both performance and robustness, and that BLAS choice can change run time by an order of magnitude.
- Treat results as local. Because Ipopt aims at a local solution, rerunning from several starting points is a way to see whether a nonconvex problem has more than one answer. This is an interpretation of the documented local-solution behaviour, not a documented procedure.
- Check third-party terms. The FAQ warns that some third-party components needed to build Ipopt may not be free for commercial use, even though Ipopt itself is.
- Cite the implementation paper. The documentation asks users to cite it in publications (see below).
Licence and citation
Ipopt is released under the Eclipse Public License. It is free to use, including commercially, but distributed modified versions must have their changes published. Before version 3.9.2 the licence was the Common Public License. The documentation asks that publications citing results from Ipopt cite: Wächter, A., and Biegler, L. T., “On the implementation of an interior-point filter line-search algorithm for large-scale nonlinear programming,” Mathematical Programming 106, 25–57, DOI 10.1007/s10107-004-0559-y.
Common misunderstandings
Ipopt finds the global optimum
It does not claim to. The documentation says it aims to find a local solution, and it accepts nonconvex problems. A local solution can be fine for many engineering problems, but it is not proof that no better point exists.
Ipopt is a standalone program with a built-in modelling language
Ipopt is a library with an AMPL executable and several language interfaces. Writing models in a convenient syntax is done in a tool such as AMPL, GAMS or CasADi, which then calls the solver.
Free software means every dependency is free
The EPL applies to Ipopt. Linear solvers and numerical libraries have their own terms, and the FAQ explicitly cautions about commercial use of some third-party components.
Ipopt handles integer variables
The documentation defines the problem class as continuous. Integer restrictions belong to a different class of solver; see mixed-integer programming.
Any starting point and any derivatives will do
The functions are expected to be twice continuously differentiable. A model with non-smooth parts, such as absolute values or hard switches, breaks that assumption and should be reformulated or handled with a method designed for it.
Frequently asked questions
What does Ipopt stand for?
Interior Point Optimizer. It is pronounced Eye-Pea-Opt.
Is Ipopt free for commercial use?
Ipopt itself is under the Eclipse Public License, which permits commercial use, provided modified distributed versions publish their changes. Some third-party components needed to build it may not be free for commercial use, so check each one.
What does Ipopt need to run?
BLAS and LAPACK libraries and at least one sparse symmetric indefinite linear solver that provides inertia, such as MA27, MA57, MUMPS or PARDISO. The AMPL Solver Library is needed only to build the AMPL executable.
Can I use Ipopt from Python?
Yes, through third-party wrappers. The documentation lists cyipopt, a Python wrapper with a SciPy-style interface, and CasADi, which comes with Ipopt.
Does Ipopt need the Hessian?
No. By default it uses exact second derivatives, but the hessian_approximation option can switch it to a limited-memory quasi-Newton approximation.
Is the result a global minimum?
No guarantee. Ipopt seeks a local solution of the nonlinear program.
How should I cite Ipopt?
Cite Wächter and Biegler (Mathematical Programming 106, 25–57, DOI 10.1007/s10107-004-0559-y), as the documentation requests.
Sources
- Ipopt documentation overview (version 3.14.20), read 2026-11-15.
- Ipopt FAQ, read 2026-11-15.
- Ipopt options reference, read 2026-11-15.
- Ipopt implementation details, read 2026-11-15.
- Wächter and Biegler, Mathematical Programming 106, 25–57 (DOI record), read 2026-11-15.
Data: Ways to call Ipopt: interfaces named in the official documentation
Interfaces and tools through which Ipopt can be called, as listed in the Ipopt documentation overview, classified by whether the documentation places them in the Ipopt distribution or lists them as third-party, with the documentation's own note where it gives one.
Period covered: 2026.
| Interface or tool | Listed as | Documentation note |
|---|---|---|
| AMPL executable | In the Ipopt distribution | Needs the AMPL Solver Library to build |
| C++ | In the Ipopt distribution | Primary implementation language |
| C | In the Ipopt distribution | Interface included |
| Java | In the Ipopt distribution | Interface included |
| Fortran | In the Ipopt distribution | Interface included |
| R (ipoptr) | In the Ipopt distribution | R interface |
| CasADi | Third party | Documentation states it comes with Ipopt |
| cyipopt | Third party | Python wrapper with a SciPy-style interface |
| ADOL-C | Third party | Named in the documentation list |
| AIMMS | Third party | Named in the documentation list |
| APMonitor | Third party | Named in the documentation list |
| CppAD | Third party | Named in the documentation list |
| IpoptNet | Third party | Named in the documentation list |
| GAMS | Third party | Named in the documentation list |
| ifopt | Third party | Named in the documentation list |
Sources
- Ipopt documentation overview (3.14.20) (accessed 2026-11-15)
Compiled by CASRAI from the sources above. Free to reuse under CC BY 4.0 with attribution.







