Try our new documentation site (beta).

Detailed Release Notes for Gurobi 10.0.3

Supported Platforms

Platform (port) Operating System Compiler Notes
64-bit (win64)
Windows 10, 11, Windows Server 2012 R2, 2016, 2019, 2022 Visual Studio 2017-2022 Use gurobi_c++md2017.lib (e.g.) for C++
Linux x86-64
64-bit (linux64)
Red Hat Enterprise Linux 7 (and corresponding CentOS distribution), 8, and 9 GCC >= 4.8 Use libgurobi_g++5.2.a for newer C++ compilers
  SUSE Enterprise Linux 12, 15    
  Ubuntu 20.04, 22.04*    
  Amazon Linux 2    
64-bit universal2 (macos_universal2)
11 (Big Sur), 12 (Monterey), 13 (Ventura) Xcode 12/13  
Linux arm64
64-bit (armlinux64)
Red Hat Enterprise Linux 7 (and corresponding CentOS distribution), 8, and 9 GCC >= 4.8  
  SUSE Enterprise Linux 12, 15    
  Ubuntu 20.04, 22.04    
  Amazon Linux 2    
64-bit (power64)
AIX 7.2, 7.3 XL C/C++ 9 Due to limited Python support on AIX, this port does not include the Interactive Shell or the Python libraries.

*On Ubuntu 22.04 for x86-64, user code that calls dlopen()/dlclose() to load/unload is known to fail. We have investigated the issue, and unfortunately we have not yet found a workaround.

Additional Supported Platform Information

Gurobi 10.0.3 supports the following language/platform versions:

Language Version
Python 3.8, 3.9, 3.10, 3.11
MATLAB R2019a-R2022b
R 4.2
JDK 8, 11, 17
.NET 6.0

Bug Fixes

All bug fixes listed by version can be found on our website.

NuGet package for .NET

We now provide an official NuGet package for .NET users. You can find the package at Additional information is available in the .NET Interface section of the Gurobi Quick Start Guide.

Changed in Gurobi 10.0.1

Changes to the .NET standard library

The .NET standard library is now signed with a strong name. This applies to both the C# library distributed with the full Gurobi installation and the NuGet package.

Changed in Gurobi 10.0.0

Changes to C API

The parameter for method GRBcbproceed has changed. The signature was:

int GRBcbproceed(GRBmodel *model)
and is now:
int GRBcbproceed(void *cbdata)

Changes to attributes

The VBasis variable attribute for a fixed variable will now return either -1 (non-basic at lower bound) or -2 (non-basic at upper bound), depending on the sign of the reduced cost (it previously always returned -1).

Changes to callback

User callbacks could previously be called from a variety of Gurobi methods. They will now only be called from methods that solve an optimization model. The list of such methods of course includes optimize, but also feasRelax, computeIIS, and a few others.

Removed in Gurobi 10.0

End of support for Python 2.7

This version has dropped support for Python 2.7.

Only one set of C++ libraries for Windows

We now only ship a single set of C++ libraries (gurobi_c++md2017.lib, gurobi_c++mdd2017.lib, etc.), built with Visual Studio 2017. These are binary compatible with Visual Studio versions 2017-2022.

Removed attributes

Attributes JobID and ComputeServer are no longer available. The same information can be obtained via the read-only parameters JobID and ComputeServer, which have been available since Gurobi 8.0.

Removed GRBgetlogfile method

The C API method GRBgetlogfile has been removed. Use the LogFile parameter to obtain the name of the log file.

Removed legacy methods for creating Compute Server and Instant Cloud environments

The following legacy methods and constructors for creating Compute Server and Instant Cloud environments have been removed:

  • C: GRBloadclientenv, GRBloadcloudenv
  • C++:
         GRBEnv(const std::string& logfilename, const std::string& computeserver,
                const std::string& router, const std::string& password,
                const std::string& group, int CStlsInsecure, int priority,
                double timeout)
         GRBEnv(const std::string& logfilename, const std::string& accessID,
                const std::string& secretKey, const std::string& pool,
                int priority)
  • Java:
         GRBEnv(String logFileName, String computeServer, String router,
                String password, String group, int CStlsInsecure, int priority,
                double timeout)
         GRBEnv(String logfilename, String accessID, String secretKey, String pool,
                int priority)
  • .NET:
         GRBEnv(string logfilename, string computeserver, string router,
                string password, string group, int CStlsInsecure, int priority,
                double timeout)
         GRBEnv(string logfilename, string accessID, string secretKey, string pool,
                int priority)
  • gurobipy: Env.ClientEnv, Env.CloudEnv,
  • Matlab and R: The env parameter to the Gurobi functions. See Matlab and R changes below for conversion details.

You should use the configuration parameters instead, which were introduced in Gurobi 8.0 to simplify this process.

New features affecting all APIs


The Gurobi Web License Service (WLS) previously only worked within containerized environments. With Gurobi 10.0, WLS licenses are also available that work outside of containers (on Windows, macOS and Linux), as well as in both types of environments.

New parameters The following parameters are new in Gurobi 10.0:

  • NetworkAlg to control the network simplex algorithm.

  • OBBT to control the aggressiveness of Optimality-Based Bound Tightening.

  • SoftMemLimit to limit the total amount of memory available to an optimization (leading to a graceful exit when the limit is hit).

  • SolutionTarget to specify the solution target for LP.

  • WLSTokenRefresh to specify the refresh interval of a Web License Service token.

Logistic General Constraint

Added support for piecewise-linear approximation of the logistic function as a general constraint. With this feature, you can model the logistic function <span>$</span>y = \frac{1}{1 + e^{-x}}<span>$</span> on problem variables <span>$</span>x<span>$</span> and <span>$</span>y<span>$</span>. As with all general constraints, you can control how fine-grained the piecewise-linear approximation should be. See the General Constraint section for more information.

Specific performance improvements

In addition to general performance improvements across all supported problem classes, we have added the following enhancements for specific problem types:

  • Added a network simplex algorithm to speed up the solution of LPs with pure network structure.
  • Added a new QUBO heuristic to improve our ability to quickly find good feasible solutions for Quadratic Unconstrained Boolean Optimization problems.
  • Reorganized the concurrent LP solver to improve performance and reduce memory consumption.
  • Significantly improved performance on MIP models that contain constraints that model neural networks with ReLU activation functions.

Behavior changes affecting the Python matrix-friendly API

With version 10.0 we have extended the capabilities of the existing MVar, MLinExpr, and MQuadExpr modeling classes and improved their behaviour in many respects. Some of the changes may cause incompatibilities with existing code that uses these objects, so we suggest that you read the following summary carefully and adapt your code accordingly.

More arithmetic operations supported

You can now perform point-wise multiplication involving combinations of matrix-friendly modeling objects and NumPy ndarrays. For example:

a = numpy.random.rand(3)
x = model.addMVar(3)
y = model.addMVar(3)

# Add three linear constraints a[i]*x[i] = y[i]
model.addConstr(a * x == y)
# Add three quadratic constraints x[i]*y[i] = a[i]
model.addConstr(x * y == a)

Arbitrary dimensions now supported

The classes MVar, MLinExpr, and MQuadExpr now support arbitrary numbers of dimensions. For example, you can now create 2-D matrix linear expressions:

A = numpy.random.rand(4,3)
B = numpy.random.rand(4,2)
X = model.addMVar((3,2))

# Add 8 linear constraints A[i, :] @ X[:, j] == B[i, j]
model.addConstr(A @ X == B)

Dimensionality and consistency

The classes MVar, MLinExpr, and MQuadExpr now behave similarly to NumPy's ndarray when it comes to dimension handling. For example:

X = model.addMVar((3,3))

sub1 = X[:, 1]    # Gives 1-D (3,) Mvar
sub2 = X[:, 1:2]  # Gives 2-D (3, 1) Mvar
sub3 = X[0, 1]    # Gives 0-D () Mvar

In addition, a 0-D MVar object now acts like a “scalar” Var object, but it keeps its dimensionality properties.

Furthermore, in previous versions all MQuadExpr objects containing just one element had shape (1,). Such objects now follow the shape rules of Python's matrix multiplication operator:

Q = np.random.rand((3,3)); Q = Q + Q.T
x = model.addMVar((3,1))

expr1 = x.T @ Q @ x            # expr1.shape is (1,1)
expr2 = x[:, 0] @ Q @ x[:, 0]  # expr2.shape is ()

Arithmetic operations embrace NumPy's broadcasting rules

The behaviour of arithmetic operations among the matrix friendly modeling objects of different shapes now follows NumPy's broadcasting rules. For example:

a = numpy.random.rand(3)
x = model.addMVar((3,3))

# a is broadcast along the first dimension of x; result is (3,3)
expr = a * x

Broadcasting is also applied implicitly when adding broadcastable expressions as constraints:

a = numpy.random.rand(3)
x = model.addMVar((3,3))

# a is broadcast along the first dimension of x.
# The effect is the same as doing addConstr(x - a == 0)
model.addConstr(x == a)

For detailed information on broadcasting we refer you to NumPy's documentation.

Other changes

  • Creating MVar objects through Model.addMVar is now roughly 40% faster.

  • The optional attribute initializers for Model.addMVar now need to be passed in a broadcastable shape. In older versions, any list with an appropriate number of elements could be used, which is ambiguous in the case of a multi-dimensional MVar. Please refer to the documentation of Model.addMVar for details.

  • Using the MVar constructor to convert a list of Var objects to an MVar object is deprecated. A dedicated, faster method (MVar.fromlist) has been introduced for this purpose.

  • The method MVar.sum now takes an optional axis argument to select an axis along which the summation should happen. Also, the shape of the resulting MLinExpr after summing all elements is now (), (0-D), as opposed to (1,) in older versions.

  • The method MLinExpr.copy now returns a deep copy, as opposed to a shallow copy in earlier versions.

  • Invalid or incompatible matrix multiplication invocations now raise a ValueError instead of a GurobiError.

To check whether your program calls any deprecated methods you can set an appropriate filter in Python's warnings module. For example, you can turn all warnings to runtime errors by starting the Python interpreter with the option -W error.

Changes in the Matlab and R APIs

The env argument to Matlab and R API functions has been removed. This argument was previously used to provide the data required to connect to a Compute Server or to Gurobi Instant Cloud. This information should now be passed through parameters in the params struct.

For example, the new signature of the "gurobi" function is gurobi(model, params). To update a program that uses the env argument, just set the appropriate parameters in params to match the fields you previously used in env. The following table shows the correspondence between the field names of the deprecated env argument and Gurobi parameters:

env params
router CSRouter
password ServerPassword
group CSGroup
priority CSPriority
timeout CSQueueTimeout
accessid CloudAccessID
secretkey CloudSecretKey
pool CloudPool

A client MATLAB program that solves a model on a Compute Server should now look something like the following:

m.A = sparse(0,0);  % Just a minimal model struct for demonstration
params.Method = 2;  % Use barrier method (for demonstration)
params.ComputeServer = '';  % Set server name
params.ServerPassword = 'pass';  % Set password
gurobi(m, params);  % Solve model on server with barrier

Similarly for R, client code to solve a model on a Compute Server should look like:

m <- list(A = matrix(0))  # Just a minimal model struct for demonstration
params <- list()
params$Method <- 2  # Use barrier method (for demonstration)
params$ComputeServer <- "";  # Set server name
params$ServerPassword <- "pass";  # Set password
gurobi(m, params);  # Solve model on server with barrier

In summary, this is now the full list of signatures for Matlab and R API functions:

gurobi(model, params)
gurobi_feasrelax(model, relaxobjtype, minrelax, penalties, params)
gurobi_iis(model, params)
gurobi_read(filename, params)
gurobi_relax(model, params)
gurobi_write(model, filename, params)

Compute Server, Cluster Manager, and Instant Cloud

Detailed release notes for Compute Server, Cluster Manager, and Instant Cloud can be found here

Try Gurobi for Free

Choose the evaluation license that fits you best, and start working with our Expert Team for technical guidance and support.

Evaluation License
Get a free, full-featured license of the Gurobi Optimizer to experience the performance, support, benchmarking and tuning services we provide as part of our product offering.
Academic License
Gurobi supports the teaching and use of optimization within academic institutions. We offer free, full-featured copies of Gurobi for use in class, and for research.
Cloud Trial

Request free trial hours, so you can see how quickly and easily a model can be solved on the cloud.