# NPCompleter: Paste a model and watch the solvers race for it. > Post an optimization or satisfiability model. Several open-source solvers race on it on an 8 vCPU machine and you see which one won. No signup. Send an LP, MPS, CNF, MaxSAT, SMT-LIB, MiniZinc or TSPLIB file. Every solver we have for that format starts on it at once, on an 8 vCPU machine, with 60 seconds to finish. You get the best checked answer back, along with each solver's time and which one won. Your file stays private unless you say otherwise, and there is no account to create. Today every racer is an open-source solver on our hardware. Later, other people's solvers will be able to enter the race. Example race: a 1,184-variable scheduling MIP in MPS. Illustrative figures. | Solver | Status | Wall time | |---|---|---| | SCIP (won) | optimal | 7.204 s | | HiGHS | stopped | 7.210 s | ## Try it Pick a sample and watch the race, or paste your own model. On the web page each sample posts with one click. To post one yourself, send its body to `POST https://npcompleter.com/v1/problems`. ### Production plan (`lp`) Integer LP. Three products, three resource limits, maximise profit. Post it with `"format": "lp"` and `"source_ref": "sample-lp-production"`. ``` \ Three products share three machines. Maximise profit. Maximize profit: 5 x + 4 y + 3 z Subject To cutting: 2 x + 3 y + z <= 5 pressing: 4 x + y + 2 z <= 11 packing: 3 x + 4 y + 2 z <= 8 Bounds 0 <= x <= 10 General x y z End ``` ### Tiny MIP (`mps`) Fixed-format MPS with one integer column, three rows, bounds. Post it with `"format": "mps"` and `"source_ref": "sample-mps-tinymip"`. ``` NAME TINYMIP ROWS N COST L LIM1 G LIM2 E MYEQN COLUMNS MARKER 'MARKER' 'INTORG' X1 COST 1.0 LIM1 1.0 X1 LIM2 1.0 MARKER 'MARKER' 'INTEND' X2 COST 2.0 LIM1 1.0 X2 MYEQN -1.0 X3 COST -1.0 MYEQN 1.0 RHS RHS LIM1 4.0 LIM2 1.0 RHS MYEQN 7.0 BOUNDS UP BND X1 4.0 LO BND X2 -1.0 UP BND X2 1.0 ENDATA ``` ### Pigeonhole 3 into 2 (`cnf`) DIMACS CNF. Three pigeons, two holes. Unsatisfiable by design. Post it with `"format": "cnf"` and `"source_ref": "sample-cnf-pigeonhole"`. ``` c Three pigeons, two holes. Variable 2(i-1)+j: pigeon i sits in hole j. p cnf 6 9 1 2 0 3 4 0 5 6 0 -1 -3 0 -1 -5 0 -3 -5 0 -2 -4 0 -2 -6 0 -4 -6 0 ``` ### Pick one (`wcnf`) Weighted MaxSAT. Hard: at most one of three. Soft: prefer each. Post it with `"format": "wcnf"` and `"source_ref": "sample-wcnf-pickone"`. ``` c Hard clauses (weight 10 = top): at most one of x1, x2, x3. c Soft clauses: we would like each of them, with weights 3, 2, 1. p wcnf 3 6 10 10 -1 -2 0 10 -1 -3 0 10 -2 -3 0 3 1 0 2 2 0 1 3 0 ``` ### Two equations (`smt2`) SMT-LIB, integer arithmetic. Find x and y. Post it with `"format": "smt2"` and `"source_ref": "sample-smt2-linear"`. ``` ; Integers x and y with x + y = 10 and x - y = 4. (set-logic QF_LIA) (declare-const x Int) (declare-const y Int) (assert (= (+ x y) 10)) (assert (= (- x y) 4)) (assert (> y 0)) (check-sat) (get-model) ``` ### SEND + MORE = MONEY (`mzn`) MiniZinc. The classic cryptarithm, eight distinct digits. Post it with `"format": "mzn"` and `"source_ref": "sample-mzn-sendmore"`. ``` % SEND + MORE = MONEY, each letter a distinct digit. include "alldifferent.mzn"; var 1..9: S; var 0..9: E; var 0..9: N; var 0..9: D; var 1..9: M; var 0..9: O; var 0..9: R; var 0..9: Y; constraint alldifferent([S, E, N, D, M, O, R, Y]); constraint 1000*S + 100*E + 10*N + D + 1000*M + 100*O + 10*R + E = 10000*M + 1000*O + 100*N + 10*E + Y; solve satisfy; ``` ### Eight cities (`tsplib`) TSPLIB, Euclidean. Shortest round trip through eight points. Post it with `"format": "tsplib"` and `"source_ref": "sample-tsplib-tiny8"`. ``` NAME : tiny8 COMMENT : Eight cities on a plane TYPE : TSP DIMENSION : 8 EDGE_WEIGHT_TYPE : EUC_2D NODE_COORD_SECTION 1 0 0 2 10 0 3 20 5 4 25 15 5 15 25 6 5 20 7 -5 10 8 8 10 EOF ``` ### A 60-bit semiprime (`factor`) Factoring demo. Inputs are capped at 330 bits. Post it with `"format": "factor"` and `"source_ref": "sample-factor-60bit"`. ``` 998244359987710471 ``` From a terminal, one call posts a problem and returns a link to poll: ``` printf 'p cnf 3 2\n1 -3 0\n2 3 -1 0\n' | jq -Rs '{format: "cnf", body: .}' | curl -s https://npcompleter.com/v1/problems -H 'content-type: application/json' -d @- ``` ## What runs it | Format | Racers | |---|---| | LP (`lp`) | HiGHS, SCIP | | MPS (`mps`) | HiGHS, SCIP | | CNF (`cnf`) | Kissat, CaDiCaL | | WCNF (`wcnf`) | RC2 | | SMT-LIB (`smt2`) | Z3, cvc5 | | MiniZinc (`mzn`) | CP-SAT | | FlatZinc (`fzn`) | CP-SAT | | CP-SAT proto (`cpsat`) | CP-SAT | | TSPLIB (`tsplib`) | PyVRP, OR-Tools routing | | Factor (`factor`) | SymPy | Each race runs on one machine with 8 vCPU and 16 GiB of memory. Every racer gets the whole problem and a 60-second cap. When one racer proves optimality or answers a yes-or-no problem, the others are stopped. We check the winning solution ourselves before showing it: every constraint, bound and clause, with the objective recomputed. Optimality proofs and UNSAT answers come from the solver, and the card says so. The open-source MIP solvers we run are 8 to 14x behind the best commercial MIP solver on hard instances. On Hans Mittelmann's MILP benchmark of 28 October 2026 (240 instances, 2 hours each), COPT solved 225. Parallel HiGHS solved 179 and took 7.7 times as long as COPT. SCIP solved 136 and took 14 times as long. If your model needs Gurobi or COPT, this service will not replace them. For SAT, MaxSAT, SMT and constraint programming, the open solvers are the best available. CP-SAT won gold in every awarded category of the 2025 MiniZinc Challenge. ## Limits - 60 seconds of racing per problem. A problem that does not finish is marked unsolved, and you can set a bounty on it. - 1 MB per file. - 20 posts per day from one IP address. - LP and MPS models must be linear. A quadratic objective is rejected with an error. - Factoring inputs are capped at 330 bits. Factoring is a demo, and the cap keeps it away from real keys. - No callbacks, warm starts or solver parameters. You send a file and get an answer. ## Prices Small problems are free. If the race finishes in under 3 seconds and the model has at most 2,000 variables and constraints (or 2,000 clauses, or 200 cities), the solution is shown at once. Above that, the card shows the quality of the result first: the objective and bound, or that an answer was found. The solution then costs somewhere between fifty cents and a few dollars, depending on the size of the model and how long the race took. Next to the price we show what the compute actually cost us, usually a fraction of a cent, so the markup is in plain view. ## Who it is not for - Code that calls a solver thousands of times in a loop. The network round trip will dominate. Install HiGHS or OR-Tools locally. - Column generation, branch-and-price, lazy constraints, or anything else that needs callbacks into your code. - Hard MIPs when you already have a Gurobi, CPLEX or COPT license. Use your license. - Data you may not send to a third party. Private problems are deleted 30 days after you last open them, but they do pass through our servers. ## Why not NEOS, or pip install highspy? NEOS is free, run by the University of Wisconsin-Madison, and its open solvers, HiGHS and SCIP included, may be used commercially. For a plain MIP it is a good choice, and we will not pretend otherwise. Where it falls short for us: NEOS jobs are not confidential and NEOS has no deletion policy, while problems here are private by default and deleted after 30 days. NEOS has nothing for SAT, MaxSAT, SMT, MiniZinc or CP-SAT, which is most of what we run. And a NEOS job runs one solver on 4 threads, where a race here runs every applicable solver on 8 vCPU and tells you which one won. `pip install highspy` is the right answer when HiGHS on your machine solves your model. This site is for the moment it does not: the solve returns UNKNOWN, times out, or will not close the gap, and you want to know whether a different solver or a bigger machine changes anything. That takes one HTTP call here and nothing to install. A coding agent can install a solver for you, but it will still be one solver on your laptop. ## A solver marketplace, with the house as the only entrant for now Every problem posted here is a small competition between solvers. Today all the entrants are open-source solvers that we run. Next we want to open the race to outside solvers: yours would run on the problems people choose to share, and the board would show when it wins. The post form already has a "public" checkbox for this. It does nothing yet. Later it will let other solvers compete your price down. If you write or maintain a solver and want to enter when the race opens, leave your address. Solver signup: use the form on https://npcompleter.com/solvers, or post the same thing yourself: ``` curl -s https://npcompleter.com/v1/events -H 'content-type: application/json' \ -d '{"type": "solver_signup", "props": {"email": "you@example.com", "solver": "name, formats, link"}}' ``` `solver` is optional. You can also email hello@npcompleter.com with the subject "Solver signup". --- API: https://npcompleter.com/v1/formats · https://npcompleter.com/openapi.json · https://npcompleter.com/llms.txt - [Home](https://npcompleter.com/index.md) - [Board](https://npcompleter.com/board.md) - [Docs](https://npcompleter.com/docs.md) - [Solvers](https://npcompleter.com/solvers.md) - [About](https://npcompleter.com/about.md) - [Privacy](https://npcompleter.com/privacy.md) - [Terms](https://npcompleter.com/terms.md)