# Significant difference in SCIP solving time between JuMP and Rust (\`russcip\`)

**URL:** <https://discourse.julialang.org/t/significant-difference-in-scip-solving-time-between-jump-and-rust-russcip/130455>\
**Category:** Optimization (Mathematical)\
**Tags:** jump\
**Created:** [July 3, 2025, 3:35pm UTC](https://discourse.julialang.org/t/significant-difference-in-scip-solving-time-between-jump-and-rust-russcip/130455 "2025-07-03T15:35:19Z")\
**Posts on this page:** 3\
**Page:** 1

<div class="post-metadata">

**Author:** ![ShugarSkull](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/shugarskull/32/217568_2.png) [@ShugarSkull](https://discourse.julialang.org/u/ShugarSkull)\
**Post date:** [July 3, 2025, 3:35pm UTC](https://discourse.julialang.org/t/significant-difference-in-scip-solving-time-between-jump-and-rust-russcip/130455/1 "2025-07-03T15:35:19Z")

</div>

Hi all,

I’ve noticed a large difference in solving time when using SCIP through JuMP in Julia versus using the `russcip` crate in Rust, and I’m hoping someone can help explain why.

### 🧩 Context

I’m solving a MIQP problem from an `.mps` file using SCIP. Here’s the Julia function I wrote using JuMP:

```julia
using JuMP
using SCIP

function run_model(modelpath)
    model = read_from_file(modelpath)
    set_optimizer(model, SCIP.Optimizer)
    optimize!(model)
end

```

Using this, the problem solves in around **120 seconds** , according to the “Solving Time (sec)” reported by SCIP.

To compare, I reimplemented the same workflow in Rust using `russcip`:

```rust
fn read_and_solve_model(filepath: &str) -> Model<Solved> {
    let model = Model::new()
        .include_default_plugins()
        .read_prob(filepath)
        .expect("Failed to read model file");

    model.solve()
}

```

> `Model` and `Model<Solved>` come from the `russcip` crate.

With this Rust version, the same problem solves in **less than 10 seconds** , again using SCIP’s own “Solving Time” metric.

### ❓ Question

That’s a dramatic difference—over 10× faster in Rust—so I’m wondering what could explain it.

My first guess was `include_default_plugins()` might add some useful features, but I assumed JuMP would also initialize SCIP with a reasonable default set of plugins (though perhaps not exactly the same ones?).

Are there known differences between how SCIP is initialized/configured in JuMP vs `russcip`? Is it possible that JuMP disables certain presolvers, heuristics, or plugin features by default?

### 🧪 Notes

- The `.mps` file is identical in both runs.
- The hardware and OS are the same.
- Both runs use the “Solving Time (sec)” from SCIP output, so the measurement should be consistent.
- I’m using the latest stable versions of `JuMP`, `SCIP.jl`, and `russcip`.

Thanks in advance for any insights!

---

<div class="post-metadata">

**Author:** ![giordano](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/giordano/32/2166_2.png) [@giordano](https://discourse.julialang.org/u/giordano)\
**Post date:** [July 3, 2025, 3:39pm UTC](https://discourse.julialang.org/t/significant-difference-in-scip-solving-time-between-jump-and-rust-russcip/130455/2 "2025-07-03T15:39:42Z")

</div>

What’s your machine? I wonder if the difference is entirely in the builds of SCIP used by the julia package vs the rust package. Profiling the two executions would shed some light.

---

<div class="post-metadata">

**Author:** ![ShugarSkull](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/shugarskull/32/217568_2.png) [@ShugarSkull](https://discourse.julialang.org/u/ShugarSkull)\
**Post date:** [July 3, 2025, 3:52pm UTC](https://discourse.julialang.org/t/significant-difference-in-scip-solving-time-between-jump-and-rust-russcip/130455/3 "2025-07-03T15:52:32Z")

</div>

I have a laptop with Arch Linux (always up to date) on it and a Ryzen 7 7840U inside. The version of SCIP I’m using is the same one in both cases, the one packaged in the official’s repo of Arch.

What information should I search for when profiling ?