einheit (Python)

Python bindings for Einheit, a linear programming solver written in Rust. The solver runs as native code inside the package; Python builds the model and reads the result. The package also works as a solver backend for PuLP and Pyomo.

Einheit solves linear programs today. Mixed-integer programming is in development: a branch-and-bound search that races its work across cores. It is not part of a release yet.

Install

pip install einheit

To use Einheit as a PuLP or Pyomo solver, install the matching extra:

pip install "einheit[pulp]"
pip install "einheit[pyomo]"

Requires Python 3.11 or newer. Wheels are published for Linux x86_64, macOS arm64, and Windows x86_64. They include the compiled solver, so no Rust toolchain is needed. There is no source distribution, so pip cannot install Einheit on other platforms yet.

Quick start

import einheit

lp = einheit.parse_mps(open("afiro.mps").read())
sol = einheit.solve(lp)
if sol.is_optimal:
    print(sol.objective)   # -464.7531428571
    print(sol.x)           # primal solution, length lp.num_cols

API

Building a model

Three ways to get an Lp:

import einheit, math

# 1. MPS text
lp = einheit.parse_mps(open("model.mps").read())

# 2. CPLEX / Gurobi LP-format text
lp = einheit.parse_lp(open("model.lp").read())

# 3. Programmatic builder — no file needed
b = einheit.LpBuilder("demo")
b.sense("maximize")                              # default is "minimize"
x = b.add_var("x", 3.0, 0.0, math.inf)          # returns VarRef
y = b.add_var("y", 2.0, 0.0, math.inf)
b.add_constraint("c1", [(x, 1.0), (y, 1.0)], -math.inf, 4.0)
b.add_constraint("c2", [(x, 1.0), (y, 3.0)], -math.inf, 6.0)
lp = b.build()                                   # raises ValueError on bad bounds / refs

Reference

• parse_mps(text: str) -> Lp — parse an MPS model (raises ValueError on a bad model).
• parse_lp(text: str) -> Lp — parse a CPLEX / Gurobi LP-format model (raises ValueError on a bad model). Produces the same Lp as parse_mps — the two readers are interchangeable.
• LpBuilder(name: str = "") -> LpBuilder — programmatic model builder.
  • .sense(sense: str) — "minimize" (default) or "maximize".
  • .objective_offset(offset: float) — constant term added to the objective.
  • .add_var(name, obj, lower, upper) -> VarRef — add a variable; returns an opaque handle.
  • .add_constraint(name, coeffs, lower, upper) — add a ranged row; coeffs is a list of (VarRef, float) pairs.
  • .build() -> Lp — validate and pack; raises ValueError on bad bounds or foreign refs.
• VarRef — opaque column handle; .index gives the column number.
• Lp — num_rows, num_cols, nnz, name, col_names, row_names (all read-only).
• solve(lp, *, max_iters=None, driver=None, presolve=None, edge_weight=None) -> Solution — solve to optimum / infeasible / unbounded. Releases the GIL while the simplex runs. All keyword args default to None (Rust Options::default()); pass explicit values to override: driver ("primal" / "dual"), presolve (True / False), edge_weight ("dantzig" / "steepest"). Raises ValueError on unknown strings.
• Solution — status ("optimal" | "infeasible" | "unbounded" | "iteration_limit"), is_optimal, objective, x, iterations.

Links

• Documentation: https://docs.einheit.tech — installation, the PuLP and Pyomo guides, and the API reference
• Website: https://einheit.tech

License

MIT License. Copyright (c) 2026 Dennis Cost.