Ipopt needs a linear solver you have to license and build yourself

The problem class is fixed: twice continuously differentiable, bounded

Ipopt solves nonlinear programs in the form minimise f(x) subject to lower and upper bounds on a constraint vector g(x), plus bounds on the variables themselves. Both f and g may be nonlinear and nonconvex. The condition the documentation attaches is that they should be twice continuously differentiable, which is not a technicality: the interior point method relies on second-order information to build its barrier approximation.

Bounds are how this formulation absorbs everything else. An equality constraint is a lower and an upper bound set to the same value. Variable bounds cover box constraints and infinity conditions in one mechanism. So the question to ask before reaching for Ipopt is not whether your problem is convex, but whether it is smooth enough to differentiate twice.

That excludes a real class of problems. Integer variables, combinatorial choices, and min and max expressions with a kink are outside this formulation directly. Such problems belong with a derivative-free or mixed integer solver instead.

It finds local solutions, and the README says so in the first line

The introduction describes Ipopt as designed to find local solutions. For an unconstrained or nonconvex objective the README claims only local solutions, and any research result built on Ipopt that needs a global answer has to obtain it another way.

This is ordinary for the class of solver, not a defect, but it changes how results should be reported. The usual practice is multiple restarts from different initial points, which multiplies the solve cost that the large-scale machinery was built to reduce. If your problem is badly scaled, the dual variables and the convergence status carry more information than the objective value, and the documentation's options reference is where you find the relevant tolerances.

The package ships an examples directory with runnable problems that illustrate the range: hs071_c, hs071_cpp, hs071_f and hs071_java in four languages, Cpp_example, recursive_nlp, and a ScalableProblems set with a Java variant. The four-language hs071 is the one to run first if you want to confirm your build produces correct answers.

You must supply the linear solver, and each option has its own terms

This is the part of Ipopt installation that surprises newcomers. Ipopt requires at least one solver for systems of linear equations, and the documented choices are MA27, MA57, HSL_MA77, HSL_MA86 or HSL_MA97 from the Harwell Subroutines Library, PARDISO from the Pardiso Project, SPRAL, MUMPS, or the Watson Sparse Matrix Package. A fast BLAS and LAPACK implementation is also required.

The README recommends building HSL and MUMPS through the COIN-OR ThirdParty projects, ThirdParty-HSL and ThirdParty-Mumps, and points to prebuilt macOS, Windows and Linux HSL libraries from STFC. It also notes that Intel MKL includes a PARDISO version, but that the one from the Pardiso Project often performs better. For the AMPL interface you additionally need the AMPL Solver Library, recommended through ThirdParty-ASL.

The licence consequence is direct: those third party components are available under different conditions and licences. That is a procurement decision, not a build detail, and it is the single most common reason an Ipopt installation stalls.

Four commands, one prefix, and make test is not optional advice

Once dependencies are in place the build is short:

./configure
make
make test
make install

configure has its own options, visible with./configure --help. make builds the libraries, and if ASL was made available the AMPL solver executable is built too. make test runs the test suite against the build, which is the step that tells you your linear solver is actually working before you link it into anything. make install puts libraries, executables and headers in place.

The documentation asks you to use the same --prefix when configuring ThirdParty-ASL, ThirdParty-HSL, ThirdParty-Mumps and Ipopt. Using the same prefix is therefore the documented way to configure these related components consistently.

If you would rather not do this by hand, coinbrew automates fetching, building and installing ASL, MUMPS and Ipopt in sequence:

/path/to/coinbrew fetch Ipopt --no-prompt
/path/to/coinbrew build Ipopt --prefix=/dir/to/install --test --no-prompt --verbosity=3
/path/to/coinbrew install Ipopt --no-prompt

Note the --test flag on the build step, which is the scripted equivalent of running the suite.

Language bindings and where you can get binaries instead

The distribution produces a library you link into your own C++, C, Fortran or Java code, a solver executable for the AMPL modelling environment, and an interface for R. Ipopt runs on Linux/UNIX, macOS and Windows.

The modelling layer matters for how you will actually use it. Ipopt provides an AMPL solver executable and an interface for R. If you are in C++, you implement the objective, the constraints and their derivatives yourself and call the library.

Precompiled options exist if you would rather not build. The Ipopt releases page provides libraries and executables for Windows. JuliaBinaryWrappers publishes an Ipopt_jll.jl release with libraries and executables. The IDEAS project publishes executables that bundle HSL solvers. On Linux the usual route is a source build or a distribution package.

The current default branch is stable/3.14, so patch releases arrive against a maintenance branch rather than a moving trunk.

Twenty years of releases and the EPL's modification clause

The C++ version was first released on 2005-08-26 as version 3.0.0, and the project has been in continuous use since. The most recent tagged releases are 3.14.20 on 2026-08-27, 3.14.19 on 2025-07-30 and 3.14.18 on 2025-07-28. The last push to the repository was on 2026-10-10. The pre-3.0 Fortran version is no longer maintained and lives on a stable/2.3 branch.

The license is the Eclipse Public License, and the README's summary is unusually precise about what you may do. Use is free, including commercially. Modification is free as well, with the restriction that if you distribute your modified version in any way, for example as an executable, your changes must be made public. That is the EPL's weak copyleft applied at the file level, and it is compatible with commercial distribution provided you publish the modified files.

Reading the LICENSE yourself for your case is the sensible step, because the third party linear solvers you link in carry their own terms and the EPL does not extend to them.

Editorial conclusion

Ipopt fits large smooth nonlinear programs with bound and inequality constraints, including ones embedded in modelling layers through the AMPL or R interfaces. It is the wrong choice if your problem has non-smooth or discontinuous structure, since the objective and constraints must be twice continuously differentiable. Before building, settle the linear solver question, because that choice determines both your license obligations and your performance ceiling, then follow the documented configure, make, make test, make install sequence with a shared --prefix across ASL, HSL, MUMPS and Ipopt.

Frequently asked questions

Official sources

1. coin-or/Ipopt on GitHub
2. License: EPL-2.0
3. Project website
4. README
5. Releases