v0.12.0

ExaModels v0.12.0

Diff since v0.11.2

This release makes a model's structure separable from its data, and compiles
the result ahead of time. A recipe — an ExaCore built against ArgSource
placeholders (ExaCore(nargs = Val(N))) — is instantiated at any sizes and data
later, and ExaModelsCompiler (renamed from ExaModelsC) compiles one into a
shared library implementing cnlp ABI v0.1,
consumed from Julia by CNLPModels.jl
or from Python by cnlpmodels
with no Julia runtime on the caller's side.

One library can carry several models, each under its own symbol prefix, and each
model gets whichever instantiation surface its arguments call for: one integer
(P_new(n)), a published schema and a builder for structured data, a string
entry point (P_new_str, so only a case-file path crosses the boundary), or
nothing at all. Libraries are self-describing: they publish a catalogue of the
models they carry and, per model, a typed signature of what it instantiates
from — so a consumer holding only a library path can discover, instantiate, and
evaluate every model in it.

Models also publish their named blocks — the variables, constraints and
parameters they were written with, each with offset, length and dims — and the
same accessors work on both sides of the boundary:

get_vars(m)                        # named variable blocks; get_cons/get_pars too
solution(result, get_vars(m, :pg)) # reshaped to the block's own dims
multipliers(result, get_cons(m, :balance))
set_value!(m, get_pars(m, :load), new_demand)

A package that ships models can implement compile_all(::Val{TheirModule}) in
an ExaModelsCompiler extension — providing models never costs a dependency on a
compiler toolchain — and ExaModelsPower.jl,
COPSBenchmark.jl and
LuksanVlcekBenchmark.jl
all do, serving as stylistic guidelines for new modeling libraries.

Model construction is now non-concrete by default — lower latency for
ordinary use, with concrete = Val(true) available where the fully-typed core
is wanted.

Breaking — parameters. set_parameter! is gone; set_value! is the only
spelling, paired with get_value, matching the two-stage methods that already
used those names. And a model now copies the core's parameter vector when it
is built, so after that point the core is the blueprint and the model owns the
values: an update goes to the model, set_value!(m, θ, v), not to the core.
Without the copy every model built from one core shared one θ — including
every instance of a compiled recipe, where setting a parameter on one set it on
all. Calls that precede the build are unchanged.

Breaking: @add_expr stores its body as a node rather than as the
generator's closure, so Expression's type parameter changes; the documented
spelling (s[i]) is unaffected, but code that dispatches on Expression{F} or
calls s.f directly needs updating. This is what makes subexpressions usable in
a recipe: a closure captures the variables it mentions, putting a placeholder
inside the closure's type, where instantiation cannot reach it.

Merged pull requests:

• Metal extension: convert Float64 model data to Float32 (#280) (@sshin23)
• Fix typo: sovle -> solve (#287) (@blegat)
• Use T for constraint lower bound in opf (#288) (@blegat)
• Model recipes and ExaModelsC (#294) (@sshin23)
• Remove LegacyExaCore (#295) (@sshin23)
• CI: run self-hosted jobs only on this repository's own runners (#296) (@sshin23)
• ExaCore records the arity it was built against (#297) (@sshin23)
• CI: skip juliac AOT tests on the Windows leg (#298) (@sshin23)
• Make non-concrete (low-latency) model construction the default (#299) (@sshin23)
• Take the pglib test cases from ExaPowerIO's artifact (#300) (@sshin23)
• ExaModelsC: compile a fixed core with no example arguments (#301) (@sshin23)
• Rewrite the README overview from the paper; drop the benchmark figure (#302) (@sshin23)
• Update repository URLs after the transfer to madsuite-org (#303) (@sshin23)
• CI: coverage uploads from the self-hosted legs; OIDC everywhere (#304) (@sshin23)
• ExaModelsC: carry a recipe's own package into the generated app (#305) (@sshin23)
• ExaModelsC: make unbundled output the default (#306) (@sshin23)
• ExaModelsC: emit several models into one library (#308) (@sshin23)
• ExaModelsC: emit the schema + builder ABI for structured recipes (#309) (@sshin23)
• Fix register macro scoping (#310) (@pulsipher)
• Rename ExaModelsC to ExaModelsCompiler; publish a model's named blocks (#311) (@sshin23)
• compile_all: a template for compiling everything a package provides (#312) (@sshin23)
• compile_all, a library catalogue, and argument signatures (#313) (@sshin23)
• An axis is measured by its length, whatever iterates it (#314) (@sshin23)
• README: point at the modeling libraries built on ExaModels (#315) (@sshin23)
• Bump ExaModels version to v0.12.0 (#316) (@sshin23)

v0.11.2

ExaModels v0.11.2

Diff since v0.11.1

Merged pull requests:

• Restore Generator Free Constraint Addition (#286) (@pulsipher)

Closed issues:

• Generator-Free Constraint Generation (#285)

v0.11.1

ExaModels v0.11.1

Diff since v0.11.0

Merged pull requests:

• Unpin GPUCompiler (#283) (@michel2323)

v0.11.0

ExaModels v0.11.0

Diff since v0.10.0

ExaModels.jl v0.11.0

Breaking changes

• Drop MadNLP and Ipopt dependencies

Known Issues

• Pin GPUCompiler.jl to 0.11 due to SPIRV and PoCL issue

Closed issues:

• Release v0.10 (#279)

v0.10.0

ExaModels v0.10.0

Diff since v0.9.7

Release Notes

This is a feature-and-API release. The legacy variable / parameter /
objective / constraint / constraint! / subexpr API still works (now
routed through a deprecation wrapper) but is scheduled for removal in v0.11.

Breaking changes

• New functional builder API. Each add_* call returns
  (new_core, handle) and the ExaCore is immutable:
  c, x = add_var(c, 10), c, _ = add_obj(c, x[i]^2 for i in 1:10).
  Macro forms (@add_var, @add_par, @add_obj, @add_con,
  @add_con!, @add_expr) rebind the local core for the same effect.
• ExaCore() now returns a LegacyExaCore mutable wrapper and emits a
  deprecation warning. Use ExaCore(concrete = Val(true)) to obtain the
  immutable core required for the new API and for AOT compilation.
• Naming change: Par → Data (e.g. ParSource → DataSource,
  ParIndexed → DataIndexed).
• Removed extensions: ExaModelsCUDA, ExaModelsAMDGPU,
  ExaModelsLinearAlgebra. CUDA / AMDGPU now run through
  ExaModelsKernelAbstractions + Adapt; load CUDA or AMDGPU in your
  own project as before.

See docs/src/upgrade.md for line-by-line migration recipes.

New features

• Oracle subsystem for callback-defined nonlinear blocks:
  VectorNonlinearOracle, ScalarNonlinearOracle, OracleEvaluator,
  add_eval, and the high-level embed_oracle wrapper. Supports both
  explicit (jac! / hess!) and matrix-free (jvp! / vjp! / hvp!)
  derivatives, with adapt::Val routing for GPU- vs. CPU-only callbacks.
• Two-stage optimization via TwoStageExaCore(ns) and the
  EachScenario() marker on add_var / add_par / add_con. All
  scenarios fuse into a single GPU-friendly model; per-scenario layout is
  exposed via get_nscen, get_var_scen, get_con_scen.
• Apple Metal backend through the new ExaModelsMetal extension.
• AOT compilation via juliac --trim=safe: ExaModel(core) is now
  type-stable and dispatches to ExaModel or ExaModelWithOracle
  depending on whether oracles are registered.
• New constraint augmentation syntax: g[idx] += expr inside add_con!,
  plus multi-dim empty-constraint construction via add_con(core, dims...).
• add_par now supports a dims API matching add_var.
• Pretty-printing for AST node types and the model/core summary.

Tooling and infrastructure

• Adapt.jl is now a direct dependency and powers cross-backend array
  conversion (replaces the per-backend extensions).
• Benchmark workflow runs on PRs across CPU / CUDA / AMDGPU / oneAPI and
  posts a comparison table back to the PR.
• New [compat] entries: Adapt = "4", Metal = "1.9".

Compat

julia ≥ 1.9. Other compat bounds unchanged from v0.9.7 except the
additions above and the removal of AMDGPU / CUDA weakdeps.

Merged pull requests:

• Change naming convention: Par → Data (#234) (@sshin23)
• Use Adapt.jl for backend array conversion (#236) (@michel2323)
• Add Metal support (#242) (@sshin23)
• Add vector nonlinear oracle (#243) (@andrewrosemberg)
• Two-stage model (#244) (@michel2323)
• Fix codecov (#251) (@michel2323)
• AOT compilation (#256) (@sshin23)
• Add benchmark workflow (#257) (@sshin23)
• Revise benchmark CI to run on test pass and post results on PR (#260) (@sshin23)
• Add pretty printing for node types (#261) (@sshin23)
• No 2d/3d specialization (#263) (@sshin23)
• New constraint augmentation syntax (#264) (@sshin23)
• CI improve (#265) (@sshin23)
• Some changes in #261 reverted (#266) (@sshin23)
• CI: restrict benchmark compare job to PRs only (#267) (@sshin23)
• Missing renaming ParSource -> DataSource (#268) (@blegat)
• Add tag infrastructure, add_par dims API, and non-unit indexing fixes (#269) (@sshin23)
• Fix DataIndexed display and add operator precedence (#270) (@sshin23)
• benchmark: reduce timing noise with minimum-based estimator (#271) (@sshin23)
• CI adds backend to test environment (#276) (@michel2323)
• Release v0.10 (#278) (@michel2323)

Closed issues:

• register variable issue (#209)
• ExaModels AOT compilation (#245)
• Extension packages (#246)
• Better document constraint! (#247)
• Linear algebra extension: issue on orbit transfer use case (#250)

v0.9.7

ExaModels v0.9.7

Diff since v0.9.6

Merged pull requests:

• Fixes #238 and #248: Support tuple itr in subexpr and constraint! (#249) (@michel2323)

Closed issues:

• Any efficient way for sparse matrix constraints? (#205)
• Tupled iterators not working for subexpressions (#238)

v0.9.6

ExaModels v0.9.6

Diff since v0.9.5

Merged pull requests:

• Fix min/max (#240) (@michel2323)

Closed issues:

• Generate derivative rules and add LinearAlgebra support (#224)

v0.9.5

ExaModels v0.9.5

Diff since v0.9.4

Merged pull requests:

• Derivative generation using Symbolics.jl (#225) (@michel2323)
• LinearAlgebra extension for ExaModels nodes (#230) (@michel2323)
• Cancel branch workflows after push on branch (#231) (@michel2323)
• Linalg ext (#232) (@jbcaillau)

v0.9.4

ExaModels v0.9.4

Diff since v0.9.3

Merged pull requests:

• Support subexpressions (#202) (@michel2323)
• Constraint start value clarification (#204) (@sshin23)
• WrapperNLPModel bug fix (#206) (@sshin23)
• Getting rid of synchronization (#207) (@sshin23)
• Add TwoStageExaModel for two-stage optimization (#210) (@michel2323)
• Fix indent in docstring (#211) (@blegat)
• Add docstring to Bin (#212) (@blegat)
• Typo fix: creat -> create (#213) (@blegat)
• Reenable oneAPI CI (#214) (@michel2323)
• TwoStageExaModel should be an AbstractNLPModel (#217) (@amontoison)
• Fix build badge and coverage (#218) (@michel2323)
• Fix maximization problems with KernelAbstractions (#219) (@frapac)
• AbstractExaModels (#220) (@sshin23)
• New two-stage API (#226) (@sshin23)
• Add support for MadNLP 0.9 (#227) (@frapac)

Closed issues:

• Expression support (#167)
• [doc] Start in constraint (#203)
• Documentation: parametric models (#208)
• New two-stage API (#221)

v0.9.3

ExaModels v0.9.3

Diff since v0.9.2

Merged pull requests:

• MOI interface fixes (#188) (@klamike)
• Typo fix: funcitons -> functions (#190) (@blegat)
• Support for ObjectiveSense (#191) (@blegat)
• Refactor CI to add backends (#193) (@michel2323)
• Use Runic CUDA.jl style (#195) (@michel2323)
• Track variable bounds for ExaModels.Optimizer (#200) (@klamike)
• Throws an error when legacy JuMP model is used (#201) (@sshin23)

Closed issues:

• Existing options keys (#196)
• ExaModelsMOI is ignoring the old nonlinear API (#198)
• ExaModels.Optimizer fails when variables have bounds (#199)