# Is there any MIP solver you would recommend?

**URL:** <https://discourse.julialang.org/t/is-there-any-mip-solver-you-would-recommend/142786>\
**Category:** Optimization (Mathematical)\
**Tags:** highs\
**Created:** [November 5, 2026, 1:58pm UTC](https://discourse.julialang.org/t/is-there-any-mip-solver-you-would-recommend/142786 "2026-11-05T13:58:45Z")\
**Posts on this page:** 3\
**Page:** 1

<div class="post-metadata">

**Author:** ![zchenytt](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/zchenytt/32/223795_2.png) [@zchenytt](https://discourse.julialang.org/u/zchenytt)\
**Post date:** [November 5, 2026, 1:58pm UTC](https://discourse.julialang.org/t/is-there-any-mip-solver-you-would-recommend/142786/1 "2026-11-05T13:58:46Z")

</div>

(Feel free to move this topic to offtopic, if desired)

I feel a bit sorry for my situation: I’d been using JuMP+Gurobi for more than 3 years. I thought it should be Gurobi10, at which time users need to set the `nonconvex` to `2` to support nonconvex optimization (which they don’t have to now).

As suggested by this link [As a student at a university in China, how do I request a Free Academic License? – Gurobi Help Center](https://support.gurobi.com/hc/en-us/articles/33982552193937-As-a-student-at-a-university-in-China-how-do-I-request-a-Free-Academic-License), I’ll no longer have access to the Gurobi optimizer. It’s a bit sad but I think I shouldn’t grieve for something that wasn’t my fault—just like I’m also ineligible to use Claucle (though I’ve heard of it a lot of times), etc…

I would be glad to switch to HiGHS.jl, but I’m not sure if it will be as full-featured as Gurobi’s optimizer. (I’m actually prepared somewhat for the performance variation, if any).

For example, for a Gurobi’s MILP model, when I call `optimize!(model)` to let it solve for some time and then interrupt, and I call `optimize!(model)` for the 2nd time, I would just pick up all the information from the last solve. But when I use HiGHS, it seems that the 2nd-time `optimize!` would be identical to the 1st-time solve—it starts solving the MILP from scratch _again_. I don’t understand this behavior.

For another example, for a Gurobi’s MILP model, if I modify some objective coefficient and re-optimize, it would show “MIP starts from previous solution”, I’m not sure if HiGHS can also reuse information efficiently (in LPs, in MIPs, respectively).

Another small thing (I’m not sure if it is seen as an issue) is that `ctrl+c` works only with some small probability when HiGHS is solving a tough MILP.

(Finally, okay, I know there’s a well-known related solver that I could use—I just want to hear some more options. I wonder if there’s more experience that I can learn from. Thanks.)

---

<div class="post-metadata">

**Author:** ![jaharoni](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/jaharoni/32/225050_2.png) [@jaharoni](https://discourse.julialang.org/u/jaharoni)\
**Post date:** [November 5, 2026, 11:22pm UTC](https://discourse.julialang.org/t/is-there-any-mip-solver-you-would-recommend/142786/2 "2026-11-05T23:22:00Z")

</div>

With `JuMP.jl`, the best Mixed-Integer Programming (MIP) solver depends on whether you need a permissive open-source license (`MIT`), warm-starting across interrupted solves, or single-threaded throughput inside `Threads.@threads`:

1. **Best Open-Source Default (`HiGHS.jl`, MIT License)**: `HiGHS` is the clear open-source leader in `JuMP`, substantially faster and more numerically stable than `Cbc` or `GLPK` on medium-to-large MILPs. Since you parallelize across outer Julia threads (`Threads.@threads`), pin each `HiGHS` instance to `threads = 1` and pass the incumbent primal solution back via `set_start_value` before calling `optimize!(model)` a second time (since `HiGHS` does not yet persist its internal branch-and-bound tree across interrupted `optimize!` calls the way Gurobi does, but _does_ accept a MIP warm-start vector to prune the second search):

```julia
using JuMP, HiGHS

model = Model(HiGHS.Optimizer)
set_attribute(model, "presolve", "on")
set_attribute(model, "threads", 1) # 1 thread per solver when outer-looping with Threads.@threads
set_attribute(model, "time_limit", 60.0)

# After a time-limited or interrupted solve, feed the incumbent primal solution as a warm start:
if has_values(model)
    for v in all_variables(model)
        set_start_value(v, value(v))
    end
end

```

1. **Open-Source MINLP & Tree Resume (`SCIP.jl`, Apache-2.0)**: Unlike `HiGHS`, `SCIP` is now fully open-source under the **Apache-2.0 license** and _does_ preserve its internal branch-and-bound tree, cutting planes, and conflict clauses in memory if you raise the time limit and call `optimize!(model)` a second time without rebuilding the problem.
2. **Academic & Commercial Alternatives (`COPT.jl` / `CPLEX.jl`)**: If you are at a university in China and lost Gurobi academic access, **Cardinal Optimizer (`COPT.jl`)** provides free academic licenses globally (including Chinese universities), supports full JuMP `MOI` warm-starts/callbacks, and sits side-by-side with Gurobi on Mittelmann MILP benchmarks.

---

<div class="post-metadata">

**Author:** ![zchenytt](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/zchenytt/32/223795_2.png) [@zchenytt](https://discourse.julialang.org/u/zchenytt)\
**Post date:** [November 5, 2026, 11:58pm UTC](https://discourse.julialang.org/t/is-there-any-mip-solver-you-would-recommend/142786/3 "2026-11-05T23:58:38Z")

</div>

Welcome.

Although I typically won’t use in-solver parallelism (I’d use Julia’s multithreading, with each MIP optimization procedure occupying only one logical processor).