4colors Optimizer for QUBO

Fast classical optimization for QUBO models

A high-performance classical solver for QUBO and Ising models with millions of variables. It sets a strong classical reference for quantum research.

One million variables: in 10 seconds, the quality other solvers need over 30 seconds to reach.

Start QUBO free trialCompare plans15-day free trial · 120 minutes · No credit card required

One million variables: ahead from the first second

On a one-million-variable 3D spin glass, a standard hard test for QUBO solvers, the Optimizer answers first and stays closest to the ground state at every budget.

Stop as soon as the answer is good enough, or give hard problems more time: every extra second brings the answer closer.

One million variables, against the other solvers tested

  • 1.7 s to the first answer, with a 1 s budget
  • 6.6 s before the fastest other solver answers
  • 3.8× faster to a first answer
  • 1.9× closer to the ground state with a 10 s budget
Distance from the estimated ground-state energy One million variables · lower is better · gap to the estimated ground-state energy
10%1%1 s3 s10 s30 s60 s10%1%1 s3 s10 s60 s
  • 4colors
  • Best other solver at each budget
  • Only 4colors answers within the budget
How we measuredClose ×

Five sparse 3D ±J spin glasses with one million variables, three seeds each; the median over seeds, then over instances. Search budgets of 1, 3, 10, 30 and 60 s. The reference is the estimated ground-state energy of the 3D ±J spin glass, −1.7863 per spin (Pál 1996), times the number of spins.

Times include reading the model, for every solver, as a user would run it; at this size every solver can run past a short budget. At the 1 s budget the best other answer arrived after 6.6 s of real time, the 4colors answer after 1.7 s.

The gray line shows, at each budget, the best answer from the other solvers: D-Wave neal, OpenJij and MQLib with its hyper-heuristic and the Burer 2002 heuristic.

Other solvers are shown at their better setting per budget (restarts or budget-filling): D-Wave neal and OpenJij also ran with sweeps sized to fill the budget. The tuned settings of D-Wave neal and OpenJij are sized from a calibration run on the same problem before the timed run; that calibration time is not counted in their budget or their wall time. A user would have to calibrate once per problem size.

Measured on 31 October 2026 with 4colors Optimizer for QUBO 1.0.0, all solvers on the same hardware, on one dedicated server; on a quiet machine 4colors did slightly better. Every time is measured on our server, from the start of the run; none is a round trip through the API.

From your model to a better answer

Submit a model and a time budget, and watch better solutions arrive.

  1. Input

    • Model QUBO or Ising, from Python or dimod
    • Linear constraints Optional, alongside the quadratic objective
    • Time budget From one second to minutes

  2. 4colors Optimizer for QUBO

    • Search Searches binary or spin assignments
    • Improvement Keeps improving the objective until the budget is spent
    • Early answers A first answer in seconds
    • Stopping Stop early and keep the best solution

  3. Output

    • Best assignment With its objective value
    • Live progress Follow each improvement as it arrives
    • Timing Computation time for the run
    • Solver status Reported with the result

Fits into the tools you already use

Keep your models as they are. Add one call.

Scripts and notebooks

Python module

Submit a model and follow each better solution as it arrives.

Python module documentation
python
import fourcolorsQ = {(0, 1): 2, (1, 2): 2, (2, 3): 2, (0, 3): -3}job = fourcolors.qubo.submit(Q, time_limit_s=30, linear=[-1, -1, -1, -1])for res in job.incumbents():    print(res.objective)print(res.solution)

Existing code

dimod

Use it as a dimod sampler, on the binary quadratic models you already have.

dimod documentation
dimod
import dimodfrom fourcolors import FourColorsSamplerbqm = dimod.generators.ran_r(1, 50, seed=1)   # or your own BinaryQuadraticModelsampleset = FourColorsSampler().sample(bqm, time_limit_s=30)print(sampleset.first.energy)print(sampleset.first.sample)

Any language or pipeline

Direct API

Submit from any language, follow better solutions live, and stop early when the answer is good enough.

API documentation
POST /v1/jobs
Submit a model and a time budget
GET /v1/jobs/{id}/events
Follow each better solution live
GET /v1/jobs/{id}
Read the best solution and its objective
POST /v1/jobs/{id}/stop
Stop early and keep the best solution

Performance

Better answers, measured

Ahead on standard benchmarks

Gset Max-Cut graphs and 3D spin glasses are the problems solver papers report on. The Optimizer comes closer to the best known answer on them, from the shortest budget up.

The lead is widest at the shortest budgets, when a fast start matters most. On G32 the Optimizer reaches the best known cut within seconds, and on the larger spin glass it stays ahead at every budget shown.

Distance from the best known answer Lower is better · the five problems where 4colors leads most at each budget

G32 3.9× closer

4colors0.142%

best other solver0.567%

G61 1.9× closer

4colors0.379%

best other solver0.724%

G63 2.7× closer

4colors0.203%

best other solver0.566%

ea3d-L20 1.7× closer

4colors0.535%

best other solver0.954%

ea3d-L50 2.3× closer

4colors1.166%

best other solver2.785%

G32 at best known

4colorsbest known

best other solver0.284%

G61 2× closer

4colors0.207%

best other solver0.431%

G63 1.7× closer

4colors0.177%

best other solver0.311%

G81 1.7× closer

4colors0.597%

best other solver1.024%

ea3d-L50 2.5× closer

4colors0.913%

best other solver2.302%

G61 2.2× closer

4colors0.155%

best other solver0.345%

G63 1.5× closer

4colors0.14%

best other solver0.218%

G67 1.3× closer

4colors0.432%

best other solver0.604%

G81 1.6× closer

4colors0.469%

best other solver0.782%

ea3d-L50 2× closer

4colors0.691%

best other solver1.402%

G36 1.1× closer

4colors0.091%

best other solver0.104%

G56 1.1× closer

4colors0.174%

best other solver0.199%

G67 1.1× closer

4colors0.403%

best other solver0.46%

G81 1.2× closer

4colors0.526%

best other solver0.654%

ea3d-L50 1.7× closer

4colors0.607%

best other solver1.033%

G32 at best known

4colorsbest known

best other solver0.142%

G63 1.1× closer

4colors0.092%

best other solver0.107%

G67 1.2× closer

4colors0.317%

best other solver0.403%

G81 1.7× closer

4colors0.299%

best other solver0.512%

ea3d-L50 1.6× closer

4colors0.537%

best other solver0.874%

  • 4colors
  • Best other solver
How we measuredClose ×

Standard problems: Gset Max-Cut graphs and 3D spin glasses with 8,000 and 125,000 variables; median over 3 seeds; on one dedicated server, 4colors Optimizer for QUBO 1.0.0.

The best other solver is the best of MQLib (hyper-heuristic and Burer 2002), D-Wave neal and OpenJij for each problem and budget. The reference is the best known cut for the Gset graphs and, for the spin glasses, the estimated ground-state energy, −1.7863 per spin (Pál 1996), times the number of spins. Shown at each budget: the problems where 4colors is ahead.

Measured on 31 October 2026, search budgets of 1, 3, 10, 30 and 60 s.

An answer in under 2 seconds

A usable answer early lets your pipeline act while the search goes on. At a million variables, the Optimizer delivers one before any other solver tested.

First usable answer with one million variables Fewer seconds is better

4colors fastest

4colors1.7 s

Fastest other solver 3.8× slower

Fastest other solver6.6 s

How we measuredClose ×

With a 1 s search budget at one million variables: the real time, measured on our server, from the start of the run to an answer, including reading the model; none is a round trip through the API; the median of five instances and three seeds. Other solvers tested: MQLib (hyper-heuristic and Burer 2002), D-Wave neal and OpenJij; the fastest of them answered after 6.6 s.

Other solvers are shown at their better setting per budget (restarts or budget-filling): D-Wave neal and OpenJij also ran with sweeps sized to fill the budget. The tuned settings of D-Wave neal and OpenJij are sized from a calibration run on the same problem before the timed run; that calibration time is not counted in their budget or their wall time. A user would have to calibrate once per problem size.

Measured on 31 October 2026, all solvers on the same hardware, on one dedicated server.

The same quality in a fraction of the time

Time is what large models cost. The Optimizer reaches in seconds a quality other solvers need far longer to match, and the gap widens with the budget.

Pick the quality you need, and the Optimizer gets there first. The answer it gives after two minutes was not matched by any other solver tested, even in much longer runs.

Real time to the same quality, one-million-variable 3D spin glasses Fewer seconds is better · real time · one million variables

3 s budget

4colors 3.7 s, Best other solver 9.4–34 s

5 s budget

4colors 5.8 s, Best other solver 9.4–34 s

10 s budget

4colors 11 s, Best other solver 34–60 s

20 s budget

4colors 21 s, Best other solver 60–111 s

30 s budget

4colors 31 s, Best other solver 111–283 s

60 s budget

4colors 61 s, Best other solver 111–292 s

120 s budget

4colors 121 s, Best other solver over 283 s

  • 4colors
  • Best other solver
How we measuredClose ×

Real (wall) time, measured on our server, from the start of the run to the answer, for every solver on the same hardware, on one dedicated server; none is a round trip through the API. Million-spin 3D ±J spin glasses (1,000,000 variables), 5 instances × 3 seeds; median over seeds, then over instances.

Quality: the gap to the literature ground-state energy of this model (Pál 1996, −1.7863 per spin; the same ranges hold with the later estimate −1.7876). Other solvers: MQLib (hyper-heuristic and Burer 2002) at its time limit; D-Wave neal and OpenJij simulated annealing, two settings each: restarts with doubling sweeps until the budget, and one anneal sized to fill the budget. The tuned settings of D-Wave neal and OpenJij are sized from a calibration run on the same problem before the timed run; that calibration time is not counted in their budget or their wall time.

Their budgets were 1, 3, 10, 30, 60, 120 and 300 s; each range runs from the longest run that had not yet reached the quality to the shortest that had. Their times are rounded down and ours up, so every figure is in their favor.

Measured on 31 October 2026.

Measure it on your own problems

Performance

Across problem types and sizes

From sparse to dense

On 100,000-variable random graphs, from sparse (degree 4) to a dense graph of degree 256, and on the classic Palubeckis benchmarks, the Optimizer's median result comes closest to the best answer found at every budget shown.

On the sparse graphs, a 10-second run already matches what the best other solver tested reaches in a minute. The dense graph, with hundreds of terms per variable, makes every move costlier to evaluate, and there the other solvers fall furthest behind.

Distance from the best answer found Lower is better · 100,000-variable random graphs and Palubeckis

Sparse graph, degree 4 100,000 variables

4colors0.24%

best other solver0.63%

Sparse graph, degree 16 100,000 variables

4colors0.18%

best other solver0.59%

Sparse graph, degree 64 100,000 variables

4colors0.27%

best other solver3.67%

Dense graph, degree 256 100,000 variables

4colors0.70%

best other solver4.81%

Palubeckis 3,000 variables at best found

4colorsbest found

best other solver0.07%

Palubeckis 5,000 variables

4colors0.01%

best other solver0.42%

Sparse graph, degree 4 100,000 variables

4colors0.11%

best other solver0.36%

Sparse graph, degree 16 100,000 variables

4colors0.12%

best other solver0.24%

Sparse graph, degree 64 100,000 variables

4colors0.13%

best other solver0.37%

Dense graph, degree 256 100,000 variables

4colors0.33%

best other solver3.80%

Palubeckis 3,000 variables at best found

4colorsbest found

best other solver0.02%

Palubeckis 5,000 variables at best found

4colorsbest found

best other solver0.06%

Sparse graph, degree 4 100,000 variables

4colors0.07%

best other solver0.22%

Sparse graph, degree 16 100,000 variables

4colors0.07%

best other solver0.12%

Sparse graph, degree 64 100,000 variables

4colors0.08%

best other solver0.13%

Dense graph, degree 256 100,000 variables

4colors0.16%

best other solver1.08%

Palubeckis 3,000 variables at best found

4colorsbest found

best other solver0.02%

Palubeckis 5,000 variables at best found

4colorsbest found

best other solver0.04%

Sparse graph, degree 4 100,000 variables

4colors0.02%

best other solver0.17%

Sparse graph, degree 16 100,000 variables

4colors0.01%

best other solver0.13%

Sparse graph, degree 64 100,000 variables

4colors0.01%

best other solver0.14%

Dense graph, degree 256 100,000 variables

4colors0.02%

best other solver0.25%

  • 4colors
  • Best other solver
How we measuredClose ×

Random graphs of 100,000 variables with average degree 4, 16, 64 and 256, and the Palubeckis benchmarks of 3,000 and 5,000 variables; 3 instances each, 3 seeds, median over instances and seeds; on one dedicated server, 4colors Optimizer for QUBO 1.0.0. The Palubeckis problems were run up to 1 min, so the 5 min view shows the random graphs only. Gap: distance to the best answer any tested solver found, 5-minute runs included. Other solvers: MQLib (Burer 2002), D-Wave neal and OpenJij, at default settings and with sweeps sized to fill the budget; the best of them at every point. 4colors' gaps rounded up, the others' down.

Measured on 1 November 2026.

Random 3-regular spin glasses

The speed advantage holds on irregular graphs, not only on lattices.

Random 3-regular graphs have no lattice for a solver to exploit, so they test the search itself. From a few seconds up, the other solvers tested need far longer to reach the same quality.

Real time to the same quality, random 3-regular spin glasses Fewer seconds is better · real time · one million variables

3 s budget

4colors 3.9 s, Best other solver 11–28 s

10 s budget

4colors 11 s, Best other solver 28–57 s

30 s budget

4colors 31 s, Best other solver over 57 s

  • 4colors
  • Best other solver
How we measuredClose ×

Real (wall) time, measured on our server, from the start of the run to the answer, for every solver on the same hardware, on one dedicated server; none is a round trip through the API. Three instances with one million variables per family, 3 seeds each; median over seeds, then over instances.

Quality: the gap to the best answer any tested solver found in this campaign, runs of up to 300 s included. Other solvers: MQLib (hyper-heuristic and Burer 2002) at its time limit; D-Wave neal and OpenJij, two settings each: restarts, and one anneal sized to fill the budget. The tuned settings of D-Wave neal and OpenJij are sized from a calibration run on the same problem before the timed run; that calibration time is not counted in their budget or their wall time.

Each range runs from the longest run that had not yet reached the quality to the shortest that had; other solvers' times are rounded down and ours up, and a budget is shown only where 4colors is still ahead after rounding.

Measured on 1 November 2026.

2D torus spin glasses

On planar lattices too, the other solvers tested fall behind and stay behind.

2D lattices are a standard test for annealing-based solvers. At a 30-second budget, no other solver tested matched the Optimizer's answer, even in longer runs.

Real time to the same quality, 2D torus spin glasses Fewer seconds is better · real time · one million variables

30 s budget

4colors 31 s, Best other solver over 57 s

  • 4colors
  • Best other solver
How we measuredClose ×

Real (wall) time, measured on our server, from the start of the run to the answer, for every solver on the same hardware, on one dedicated server; none is a round trip through the API. Three instances with one million variables per family, 3 seeds each; median over seeds, then over instances.

Quality: the gap to the best answer any tested solver found in this campaign, runs of up to 300 s included. Other solvers: MQLib (hyper-heuristic and Burer 2002) at its time limit; D-Wave neal and OpenJij, two settings each: restarts, and one anneal sized to fill the budget. The tuned settings of D-Wave neal and OpenJij are sized from a calibration run on the same problem before the timed run; that calibration time is not counted in their budget or their wall time.

Each range runs from the longest run that had not yet reached the quality to the shortest that had; other solvers' times are rounded down and ours up, and a budget is shown only where 4colors is still ahead after rounding.

Measured on 1 November 2026.

Standard problems at 2 minutes

Ahead of the best other solver on 7 standard problems, tied on G32.

Two minutes is long enough for every solver to come close, so what remains is the hardest part of the search: the last fraction of a percent. That is where the Optimizer keeps finding better answers.

The lead grows with size. It is widest on the largest problems shown, the 125,000-variable spin glass and G81, the largest Gset graph. On G32 both reach the best known cut.

Standard problems at 2 minutes: distance from the best known answer Lower is better · each problem with its result

G32 tied

4colorsbest known

best other solverbest known

G36 4colors closer

4colors0.091%

best other solver0.104%

G61 4colors closer

4colors0.155%

best other solver0.172%

G63 4colors closer

4colors0.07%

best other solver0.104%

G67 4colors closer

4colors0.259%

best other solver0.374%

G81 4colors closer

4colors0.256%

best other solver0.498%

ea3d-L20 4colors closer

4colors0.311%

best other solver0.367%

ea3d-L50 4colors closer

4colors0.485%

best other solver0.745%

  • 4colors
  • Best other solver
How we measuredClose ×

Gset Max-Cut G32, G36, G61, G63, G67 and G81 against their published best-known cuts, and 3D ±J spin glasses with 8,000 and 125,000 variables against the literature ground-state energy (Pál 1996); 3 seeds each, the median; a 120 s search budget on one dedicated server, 4colors Optimizer for QUBO 1.0.0.

The best other solver is the best of MQLib (hyper-heuristic and Burer 2002), D-Wave neal and OpenJij at their default settings, for each problem.

Measured on 1 November 2026.

Try it on your problem type

Ten million variables

The Optimizer handles models of ten million variables on a single server and improves its answer as the budget grows.

Ten million variables, against the best other solver

  • 1.9% from the ground state after 1 min; the best other solver had no answer yet
  • 1.3% from the ground state after 5 min; the best other solver: 8.4% at best
  • 6× closer to the ground state than the best other solver after 5 min
  • 1 of 3 other solvers tested could run at this size; the other two exceeded the test's memory limit
How we measuredClose ×

3D ±J spin glass of 10 million variables, 3 seeds, budgets of 1 min and 5 min, on one dedicated server, 4colors Optimizer for QUBO 1.0.0. Gap: distance to the published ground-state energy, −1.7863 per spin (Pál 1996); 2.0% and 1.4% against the later estimate. Three other solvers were tested. The best, and the only one that could run at this size, is MQLib (Burer 2002): it gave no answer within 1 min in any of its 3 runs and answered in 1 of 3 runs within 5 min. D-Wave neal and OpenJij could not be run within the test's memory limit. Figures rounded against 4colors. Measured on 1 November 2026.

What a faster solver buys your team

Solver speed is not a benchmark trophy. It sets how often you can re-plan, how much compute you buy and how fairly you can judge new methods.

  • Faster decisions

    A good answer in seconds puts optimization inside the loop: rerun on every change, not overnight.

  • Better objectives

    Every fraction of a percent closer to the optimum is cost, energy or capacity you keep.

  • Lower compute

    The same quality in a fraction of the time means fewer cores and shorter jobs for the same result.

  • A fair quantum bar

    Quantum and hybrid methods prove themselves only against the strongest classical solver. This is that bar.

Start QUBO free trialPlans and limits

Features built for large models

  • QUBO and Ising models

    Binary or spin form, from Python or as a dimod model.

  • Linear constraints

    Add linear constraints alongside the quadratic objective.

  • Large-scale search

    Up to a million variables in the hosted service; the engine runs to ten million.

  • Early answers

    A first answer in seconds, then steady improvement.

  • Live progress

    Follow every better solution as it arrives.

  • Your time budget

    Set the budget; stop early and keep the best.

  • Clear output

    Assignment, checked objective, timing and status.

  • Quantum baselines

    The classical reference for quantum and hybrid methods, on the same model and budget.

  • Missing something?

    Tell us which feature would help your work.

    Request a feature

Proven on scheduling first

The same search engine that sets scheduling records

The Optimizer for QUBO runs on 4colors optimization algorithms, the family that set new best-known schedules in a public project-scheduling benchmark.

Anytime search carries over: a useful answer early, then steady improvement for the budget you choose.

Powered by

4colors Optimizer

Original search algorithms, tested on demanding benchmarks and run to your search budget. Also powers the Optimizer for Scheduling, the Quantum Compiler and the planning apps.

Explore the 4colors Optimizer

Understand the QUBO result

Browse guides and tutorials

Bring your hardest model

Run it with your budget and compare the objective with your current solver. The numbers speak for themselves.

Start QUBO free trialSee pricing

Academic and research access