TL;DR: SCIP Optimization Suite 10.0 brings a numerically exact solving mode for rational MILPs, noticeable performance gains for MILP/MINLP, stronger presolving and symmetry handling, better heuristics and conflict analysis, IIS detection, and major updates to GCG, PaPILO, PySCIPOpt, and MIP-DD.

Written by Dominik Kamp, Gioni Mexi, and Sebastian Pokutta.

Introduction

The SCIP Optimization Suite 10.0 is now available. The new release updates the entire stack:

  • SCIP 10.0 (core solver)
  • SoPlex 8.0 (LP solver)
  • PaPILO 3.0 (presolving library)
  • GCG 4.0 (automatic decomposition solver)
  • Zimpl 3.7 (modeling language)
  • UG 1.0 (parallel framework)
  • plus SCIP-SDP, PySCIPOpt, MIP-DD, and the new PBSolver application.

At a high level:

  • SCIP 10.0 is faster and more robust on both MILPs and MINLPs than 9.x, with the largest gains on harder instances.
  • A new exact solving mode can solve rational MILPs without numerical tolerances and produce verifiable certificates.
  • IIS detection for MIPs is now integrated directly into SCIP, enabling users to extract irreducible infeasible subsystems for debugging and model analysis.
  • Decomposition, presolving, symmetry handling, and conflict analysis all received substantial upgrades.
  • The ecosystem around SCIP (GCG, PaPILO, SCIP-SDP, interfaces, and tooling) has matured further.

Faster and More Reliable Core Solver

Performance: What Changes in Practice?

The team benchmarked SCIP 10.0 against SCIP 9.0 and 9.2.4 on large MILP/MINLP test sets (MIPLIB, COR@L, MINLPLib).

  • On MILPs, SCIP 10.0 is about 4% faster overall than 9.2.4, with up to ~10% speed-ups on harder instances (≥ 100–1000 seconds).
  • On MINLPs, the gains are larger: ≈9% faster on average and 20%+ speed-ups on the hardest problems, while also solving more instances within the time limit.

This may sound incremental, but for real workloads (e.g., nightly planning runs, large-scale research experiments) a 5–20% speed-up with improved robustness delivers tangible, hassle-free gains simply by upgrading.

Numerically Exact Solving Mode for MILPs

The headline feature of SCIP 10.0 is a numerically exact solving mode for rational MILPs:

  • MILP data (MPS/LP/CIP/OPB/ZIMPL) can be read in exact rational arithmetic.
  • SCIP maintains floating-point and rational views and uses a hybrid strategy:
    • Safe dual bounds and cut generation via directed rounding.
    • Exact LP solves via SoPlex or QSopt_ex only when necessary.
  • You can log a VIPR certificate that captures the full branch-and-bound proof. Its correctness can be verified with a C++ proof checker included in the SCIP Optimization Suite VIPR repository, or with a formally verified checker built on CakeML/HOL4 for maximum rigor.

Why this matters:

  • For safety-critical or audited applications, you can now prove optimality of MILPs with rational data instead of trusting floating-point tolerances.
  • For research, this is a playground for exact algorithms, certified MIP technology, and proof logging workflows.

The trade-off is performance: exact mode is currently roughly 3–4× slower than a comparable floating-point configuration and ~7–10× slower than the default configuration, depending on the test set. The fundamental benefit is that the exact objective bounds are actually guaranteed.

Extended Presolving, Symmetry Handling, and Cuts

Smarter Detection of Implied Integrality

SCIP 10.0 adds a new Total Unimodularity-based implied integrality detector that uses network submatrices to infer when some variables can be seen as integers even if they are declared continuous.

  • On MIPLIB 2017, it detects implied integrality for ~19% of variables on average, compared to ~3% before.

This extra structure can feed into branching, cutting, and propagation, and is particularly relevant for models with network-like structure. It’s not yet enabled by default, but it’s an important building block for future performance gains (and fun for people who like to tinker with advanced settings).

Better Symmetry Handling (Including Reflections)

SCIP’s symmetry machinery has taken a major step forward:

  • Reflection symmetries (e.g., flipping binary variables 0↔1 or reflecting coordinates) are better detected and exploited.
  • Schreier-Sims cuts, orbitopes, double-lex matrices, and small but effective symmetry handling inequalities have all been extended to handle these reflections.

For highly structured models (graph coloring, packing, disk packing, many combinatorial designs), this can significantly reduce search by eliminating symmetric parts of the tree.

Cut-Based Conflict Analysis and Flower Cuts

Two new pieces in the cut/propagation story:

  • Cut-based conflict analysis: instead of analyzing conflicts purely via implication graphs, SCIP 10.0 can operate directly on linear inequalities, which can theoretically provide exponentially stronger reasoning than classical SAT-style conflict analysis, which is based on the resolution proof system and CNF encodings.
  • Flower inequalities: a new separator for products of nonnegative variables (e.g., logical ANDs) generates so-called k-flower inequalities over a multilinear hypergraph representation. The implementation focuses on k=1 or 2 neighboring edges, for efficiency, and is near-neutral when no multilinear structure is present, but can be a noticeable win on affected instances.

In practice, both features help SCIP learn more from infeasibilities and nonlinear structure, translating into fewer nodes and more solved instances.

Heuristics, Branching, Benders, and Explainability

Several “everyday” parts of the solver got smarter:

  • New decomposition-aware heuristics: two primal heuristics (including a kernel search variant) exploit user-provided decompositions to search promising subspaces first. This is particularly useful when you already know the structure of your problem (e.g., time periods, locations, or scenario blocks).
  • Improved branching strategies: reliability pseudocost branching was made safe for exact mode and further tuned for floating-point runs. This mainly shows up as more stable performance on hard instances.
  • Enhanced Benders’ decomposition framework: more flexible ways to define master and subproblems and better automatic detection of linking variables. This lowers the barrier to using Benders’ decomposition in real models.
  • Infeasibility explanations (IIS): a new tool can compute irreducible infeasible subsystems, giving more interpretable explanations of why a model is infeasible. This is useful for model debugging and communicating with non-optimization stakeholders.
  • CONOPT interface: you can now use CONOPT as the NLP solver. It’s not uniformly faster than Ipopt, but on the hardest MINLPs it yields substantial reductions in runtime and node count, and can solve some instances that stall with Ipopt.

Taken together, these features make SCIP 10.0 not just faster, but also better at telling you what’s going on when things fail.

Ecosystem Updates: GCG, PaPILO, SCIP-SDP, SoPlex, UG, Zimpl

GCG 4.0: Decomposition Solver

GCG’s new release focuses on usability and performance:

  • Harmonized Apache 2.0 licensing with SCIP.
  • New GCG object to simplify the C API and unify access to original/master models.
  • Easier integration of external pricing solvers (HiGHS, Cliquer-based specialized pricing).
  • Parallel pricing enabled by default (with a parameter to control thread count).
  • New IPColGen primal matheuristic for set covering/packing/partitioning master problems.
  • Decomposition scores refactored into plugins for easier experimentation.

In short: if you’re doing branch-cut-and-price/Dantzig-Wolfe, GCG 4.0 is a more pleasant and capable environment.

PaPILO 3.0: Faster Presolving with Less Memory

PaPILO 3.0 brings:

  • Significant improvements in performance and memory usage for the dominated columns presolver.
  • A new parallel clique-merging presolver that extends and cleans up clique structures more efficiently.

These low-level improvements are easy to overlook, but they directly affect large instances where presolving used to dominate runtime or exceed memory.

SCIP-SDP, SoPlex 8.0, UG, and Zimpl

  • SCIP-SDP 4.4.0 updates to SCIP 10.0 and adds the ability to export original and transformed MISDPs in CBF format for use with the Conic Benchmark Library.
  • SoPlex 8.0 is a major version bump reflecting build system and API changes; it remains the default LP solver and is central for exact LP solving in the new exact mode.
  • UG framework now includes an application for parallel Pseudo-Boolean solving with FiberSCIP, featuring 2024 PB competition–tuned settings and optional DIMACS-style log output.
  • Zimpl 3.7.0 adds support for permutations (permutate(A)) and better handling of implied integral variables, which are now recognized by SCIP.

Interfaces, Developer Tooling, and PBSolver

Interfaces: PySCIPOpt, Rust, and More

Interface highlights:

  • PySCIPOpt now supports matrix variables based on numpy.ndarray, making it much more natural to write matrix-centric models (think: SDP-like structures, network flows, control). The documentation and tutorials have also been significantly improved, including exercises and “recipes” for common modeling tasks.
  • The Rust interface (russcip) has a more ergonomic and type-safe API with builder-style variable/constraint creation and safe access to separators and constraint handlers.
  • Other interfaces (Matlab, AMPL, SCIPpp C++, PySoPlex, PyGCGOpt, PaPILO’s Julia interface) were updated and documented.

From a user perspective, this makes it easy to access the full solver functionality in your favorite language.

MIP-DD 2.0: Delta Debugging for MIP Solvers

MIP-DD is the first open-source, solver-independent delta debugger for MIP solvers.

  • It automatically shrinks a failing instance while preserving the bug, often down to models with just a handful of variables and constraints.
  • Version 2.0 adapts modification batch sizes automatically, limits solving effort intelligently, and supports both real and exact solving modes of SCIP and SoPlex.

If you develop solvers or serious extension plugins, MIP-DD is a powerful way to turn pathological “customer instances” into minimal test cases, while also removing sensitive information.

PBSolver: Dedicated Pseudo-Boolean Application

SCIP 10.0 introduces PBSolver, a SCIP-based application tailored to Pseudo-Boolean optimization and the Pseudo-Boolean Competition format.

  • Emits competition-compliant DIMACS-style logs and solution lines.
  • Handles OPB/WBO instances out of the box, with parameters to control input limits.
  • SCIP/FiberSCIP-based solvers using these features won several categories of the 2024 PB competition.

If you work with Pseudo-Boolean benchmarks or SAT+PB hybrids, PBSolver gives you a supported, competition-ready entry point.

Availability and Getting Started

Core Distribution

The SCIP Optimization Suite 10.0 (SCIP, SoPlex, PaPILO, GCG, Zimpl, UG, SCIP-SDP, interfaces, and applications) is available as usual via the project website and GitHub repositories. Licensing is now more unified:

  • SCIP 10.0, SoPlex 8.0, PaPILO 3.0, GCG 4.0 under Apache 2.0.
  • Zimpl 3.7.0 and UG 1.0 under LGPL.

You can download the latest release from the SCIP Optimization Suite website or from our GitHub repositories.

New Docker Images: Web Service and Jupyter Lab

To make the suite easier to adopt in teaching, prototyping, and production, we provide two official Docker images (described in detail on the dedicated Docker page):

  • scip-webservice: a FastAPI-based web service for solving problem instances in common formats (e.g., .lp, .mps, .cip, .cnf, .fzn, .nl, .opb, .osil, .pip, .wbo, .zpl) via HTTP.

    • Single-command startup, with endpoints for status, uploads, and auto-generated API docs.
    • Environment variables to control concurrency, retention, and upload limits; Docker flags for CPU/memory caps.
    • Designed so you can go from “no SCIP installed” to a working REST API in a minute.

  • scip-jupyterlab: a pre-configured Jupyter Lab environment with

    • SCIP 10.0, PySCIPOpt 6.0, and Python 3.11,
    • plus a standard data-science stack (NumPy, Pandas, Matplotlib, scikit-learn, etc.).
    • Mount a local directory into /app and you have a ready-to-use notebook environment for teaching, demoing, or exploratory modeling.

Think of these as the modern replacement for the older “Dockerized SCIP for Teaching” setup: less friction, more batteries included.

(For details, examples, and recommended resource settings, see the SCIP Optimization Suite 10 Docker page)

Who Should Upgrade?

  • Practitioners get a faster, more reliable solver with better decomposition and PB capabilities, plus easier deployment via Docker.
  • Researchers get exact solving, proof logging, extended symmetry and presolving, and richer interfaces.
  • Teachers can run everything from a browser via the Jupyter Lab image, avoiding per-student installation pain.

If you experiment with the new exact mode, MIP-DD, or the Docker images and find interesting use cases (or rough edges), feedback is very welcome on GitHub or via email; this release is meant as both a robust workhorse and a platform for the next wave of MIP/MINLP research.