Ceris is a serverless infrastructure layer for Gurobi and OR-Tools that eliminates the need for license servers and EC2 clusters. It provides a single API endpoint for deploying optimization models to production in minutes.

How does serverless optimization work?

Serverless optimization with Ceris works by submitting your optimization problems via REST API. Ceris routes your problem to classical solvers like Gurobi, HiGHS, or OR-Tools, and returns results with full audit trails. You pay only for compute time used, with no upfront licensing costs.

Can I use my existing Gurobi license with Ceris?

Yes, Ceris supports BYOL (Bring Your Own License) for Gurobi. You can use your existing license while leveraging Ceris's serverless infrastructure for hosting and scaling.

Is Ceris quantum-ready?

Yes, Ceris is built with a quantum-ready architecture. It uses classical solvers like Gurobi and OR-Tools today, with automatic routing to quantum hardware when it reaches parity. The same API works with both classical and quantum backends.

What are the use cases for Ceris?

Ceris is ideal for portfolio optimization in finance, supply chain optimization in logistics, vehicle routing problems, quantum computing research with classical baselines, and model risk management requiring full audit trails.

Gurobi vs HiGHS: The 2025 Performance Reality Check

The gurobi vs highs debate has intensified as HiGHS emerges as a legitimate open-source challenger to the commercial optimization giants. After a decade of Gurobi and CPLEX dominance, HiGHS is disrupting assumptions about solver performance—but the reality is more nuanced than the hype suggests.

Here's what actually matters in 2025: For most practical problems, Gurobi still wins on raw performance by about an order of magnitude for mixed-integer programming (MIP). But HiGHS has closed the gap dramatically, especially for linear programming, and brings advantages that pure speed can't capture—zero licensing headaches, unlimited scaling, and the freedom to deploy anywhere without procurement nightmares.

The real question isn't "which solver is faster?" It's "which solver lets your team focus on optimization instead of infrastructure?"

The Tale of Two Solvers

Gurobi: The Commercial Heavyweight

Gurobi represents two decades of person-decades in development investment, funded by license fees that can reach tens of thousands per year. That money shows. Gurobi's MIP solver includes parallel tree search, specialized cuts, advanced presolve techniques, and hundreds of algorithmic tricks accumulated over years of attacking real-world problems.

The result? Gurobi consistently solves large-scale industrial problems in minutes that would take open-source solvers hours—when they can solve them at all. For complex energy systems optimization or large-scale supply chain models, this performance gap matters.

But that performance comes with strings attached. Commercial licensing limits where you can deploy, how many cores you can use, and whether you can publish benchmark results. Academic licenses are free but restrict commercial use. Corporate licenses require procurement cycles measured in quarters, not days.

HiGHS: The Open-Source Disruptor

HiGHS launched in 2019 with a different philosophy: build a solver that's fast enough for real work while being completely free to use, modify, and deploy. Originally developed at the University of Edinburgh, HiGHS now benefits from contributions across industry and academia.

The architecture is clean and modern. HiGHS includes primal and dual revised simplex solvers (originally by Qi Huangfu), an interior point solver by Lukas Schork, an active set QP solver by Michael Feldmeier, and a MIP solver by Leona Gottwald. Recent versions add GPU acceleration via NVIDIA CUDA and multi-threaded factorization.

The MIT license means you can deploy HiGHS anywhere—cloud, edge, embedded systems—without worrying about license servers or compliance audits. SciPy adopted HiGHS as its default LP solver in v1.6.0 and MIP solver in v1.9.0. MathWorks made it the default in their Optimization Toolbox. That's not an accident.

Performance Benchmarks: The Reality Behind the Numbers

Mixed-Integer Programming: Gurobi's Domain

Let's be honest about the MIP performance gap. On Hans Mittelmann's benchmarks—the closest thing we have to standardized solver comparison—Gurobi outperforms HiGHS by about one order of magnitude, not the "two orders of magnitude" sometimes claimed in marketing materials.

For large practical MIP problems, this gap is real and consequential. In energy network optimization, Gurobi can solve 720-hour optimization problems that leave other solvers struggling. For supply chain models with millions of integer variables, Gurobi's parallel tree search and advanced cuts make the difference between solutions in minutes versus hours.

But—and this matters—for small to modest-sized MIP instances, HiGHS performs comparably with Gurobi. The performance gap emerges at scale, not for problems with a few thousand variables.

Linear Programming: The Gap Narrows

For pure LP problems, the story changes. HiGHS's simplex implementation exploits hyper-sparsity and includes multi-threading for the dual simplex solver. The interior point method uses preconditioned conjugate gradient rather than direct LDL* decomposition, which can be advantageous for certain problem structures.

Recent benchmarks show HiGHS within one order of magnitude of commercial solvers for LP, and for certain problem types, the gap disappears entirely. When PyPSA (a major energy modeling framework) switched to HiGHS as their default solver, they reported "incredible performance boost" compared to alternatives.

The 2025 HiGHS releases include GPU acceleration that's starting to level the playing field. Version 1.10.0+ includes native GPU execution for cuPDLP-C solver and ~2.5% LP performance improvements through optimized arithmetic operations.

The Benchmark Problem

Here's something the vendor marketing won't tell you: Gurobi withdrew from public benchmarks in August 2024, followed by MindOpt in December. This limits current comparative data and makes independent verification harder.

Why? Benchmark gaming. When solvers are tuned specifically for benchmark problems rather than real-world performance, the results become misleading. Academic test problems don't always reflect the structures you see in production supply chain or portfolio optimization models.

Licensing and Costs: The Hidden Infrastructure Tax

Gurobi's Licensing Reality

Gurobi offers multiple licensing tiers:

Academic: Free for students, faculty, and staff at accredited institutions for non-commercial use
Commercial: Named user licenses starting at ~$2,400/year, floating licenses for ~$12,000/year
Cloud: Token-based pricing on major cloud platforms
Enterprise: Site licenses and token servers for large deployments

The academic license is genuinely generous—full solver capabilities with no problem size limits. But it's strictly non-commercial. Publishing benchmark results comparing Gurobi to other commercial solvers violates the academic license terms.

Commercial licenses create procurement friction. Legal reviews, budget approvals, compliance audits. Your optimization team becomes experts in license server administration instead of optimization modeling. When you want to scale from 10 to 100 optimization jobs, you need procurement approval, not just more EC2 instances.

HiGHS: Zero Licensing Friction

HiGHS is MIT licensed. This means:

No per-seat costs
No license servers to maintain
No compliance audits
No restrictions on where you deploy
No limits on problem size or solve time
Full commercial use permitted
Publish any benchmarks you want

For early-stage companies, NGOs, or government agencies in developing countries, this difference is decisive. You can't optimize what you can't afford to license.

Code Example: Switching Solvers

Here's how easy it is to compare solvers in practice using Python's mip library:

from mip import Model, BINARY, maximize, CBC, GUROBI

# Define the same model with different solvers
def solve_knapsack(solver_name):
    # Create model with specified solver
    if solver_name == 'gurobi':
        m = Model(solver_name=GUROBI)
    elif solver_name == 'highs':
        # HiGHS is CBC backend in mip library
        m = Model(solver_name=CBC)
    
    # Standard knapsack problem
    weights = [10, 20, 30]
    values = [60, 100, 120]
    capacity = 50
    
    x = [m.add_var(var_type=BINARY) for i in range(len(weights))]
    
    # Objective
    m.objective = maximize(sum(values[i] * x[i] for i in range(len(weights))))
    
    # Constraint
    m += sum(weights[i] * x[i] for i in range(len(weights))) <= capacity
    
    # Solve and return results
    m.solve()
    
    return {
        'solver': solver_name,
        'objective_value': m.objective_value,
        'solve_time': m.solve_time,
        'solution': [x[i].x for i in range(len(x))]
    }

# Compare solvers
gurobi_result = solve_knapsack('gurobi')
highs_result = solve_knapsack('highs')

print(f"Gurobi: {gurobi_result['objective_value']} in {gurobi_result['solve_time']:.3f}s")
print(f"HiGHS: {highs_result['objective_value']} in {highs_result['solve_time']:.3f}s")

For this toy problem, both solvers find the optimal solution instantly. The performance gap appears when you scale to thousands of variables and complex constraints.

When to Choose Each Solver

Choose Gurobi When:

Performance is critical. If you're solving large-scale MIP problems where the difference between 5 minutes and 50 minutes matters for business decisions, Gurobi's performance advantage justifies the cost.

You have budget and simple deployment. Enterprise customers with procurement processes and dedicated optimization teams can absorb the licensing complexity for the performance benefit.

You need commercial support. Gurobi's support team includes optimization experts who can help tune models and troubleshoot performance issues. That's valuable when optimization is mission-critical.

Academic research with performance needs. The free academic license provides full Gurobi capabilities for research and education.

Choose HiGHS When:

Deployment simplicity matters. You want to deploy optimization services without license server complexity, procurement cycles, or usage restrictions.

Cost is a constraint. Early-stage companies, NGOs, academic institutions outside traditional partnerships, or government agencies in developing countries where commercial licenses aren't viable.

You need flexible scaling. Running optimization jobs across thousands of cloud instances without per-core licensing costs or compliance concerns.

Integration is key. HiGHS integrates cleanly into existing Python, R, Julia, or C++ workflows without external dependencies or license verification steps.

LP-heavy workloads. For problems that are primarily linear programming, HiGHS performance is competitive while offering significant operational advantages.

Real-World Performance: Beyond Benchmarks

The PyPSA energy modeling community provides insight into real-world solver performance. PyPSA switched their default recommendation from CBC to HiGHS and reported substantial performance improvements for energy network optimization problems.

For energy systems with hundreds of nodes and thousands of time periods, HiGHS can optimize networks "below one day with memory requirements available for laptops." Gurobi remains faster for the largest models, but HiGHS crosses the threshold from "unusably slow" to "fast enough for practical work."

Similarly, GenX (another major energy modeling framework) endorsed HiGHS funding to reduce reliance on proprietary solvers. This represents a broader trend: communities building on open-source optimization stacks to avoid vendor lock-in.

The GPU Acceleration Game Changer

HiGHS's 2025 GPU acceleration deserves special attention. Version 1.10.0+ includes NVIDIA CUDA support for first-order LP solvers and multi-threaded factorization-based interior point methods.

This isn't just about raw performance—it's about matching the computational model to the problem structure. GPU acceleration works particularly well for certain LP formulations common in machine learning and large-scale network optimization.

NVIDIA's cuOpt becoming open source creates interesting possibilities for HiGHS-cuOpt integration, potentially closing the performance gap for specific problem classes where GPU parallelization provides natural advantages.

Looking Forward: The 2025 Landscape

The solver landscape is evolving beyond simple "commercial vs open-source" categories. We're seeing:

Hybrid approaches: Teams using HiGHS for development and testing, switching to Gurobi for production problems where performance matters.

Cloud-native deployment: Serverless optimization services where licensing friction matters more than peak performance for individual problems.

Domain-specific optimization: Solvers optimized for specific problem classes (energy, logistics, finance) rather than general-purpose MIP performance.

GPU acceleration: Hardware-specific optimization that can shift performance advantages independent of algorithmic improvements.

The question isn't which solver will "win"—it's how teams will choose the right tool for each problem context.

FAQ

Is HiGHS fast enough for production use?

For LP problems and small-to-medium MIP problems, absolutely. HiGHS performance is within an order of magnitude of Gurobi, which means problems that solve in seconds with Gurobi solve in tens of seconds with HiGHS. For many applications, this difference doesn't matter.

For large-scale MIP problems with millions of integer variables, Gurobi's performance advantage can be decisive—the difference between solutions in minutes versus hours.

Can I use HiGHS commercially without restrictions?

Yes. HiGHS uses the MIT license, which permits unrestricted commercial use, modification, and redistribution. You can deploy HiGHS in commercial products, cloud services, or internal business applications without licensing fees or usage restrictions.

How do I benchmark Gurobi vs HiGHS for my specific problems?

Test on your actual problem instances, not academic benchmarks. Use the same modeling approach and measure both solve time and solution quality. For MIP problems, pay attention to optimality gaps—sometimes "fast enough" solutions are more valuable than optimal solutions that take much longer.

Set up A/B testing in your development environment where you can easily switch between solvers for the same model.

Is Gurobi's academic license really free?

Yes, with restrictions. Gurobi's academic license provides full solver capabilities at no cost for students, faculty, and staff at accredited institutions. The license restricts use to non-commercial purposes including teaching, coursework, and academic research.

The license prohibits publishing benchmark results comparing Gurobi to other commercial solvers, which limits transparent performance comparisons in academic literature.

Should I choose a solver based on peak performance or operational simplicity?

This depends on your problem scale and organizational context. If you're solving problems where the difference between 5 minutes and 50 minutes affects business decisions, choose for performance. If you're solving problems where the difference between 1 second and 10 seconds doesn't matter, choose for operational simplicity.

Consider the total cost of ownership: licensing fees, procurement cycles, infrastructure complexity, and team productivity. Sometimes the "slower" solver enables faster iteration.

Teams using Ceris get the best of both worlds—access to multiple solvers including Gurobi (bring your own license) and HiGHS (open source) through a single API, with automatic solver selection based on problem characteristics. No license server management, no infrastructure complexity, just optimization that works.