Veris is a Fortran to Python translation of part of the sea ice component of the Massachusetts Institute of Technology general circulation model MITgcm,https://github.com/MITgcm/MITgcm, https://mitgcm.org/documentation/, last access: 1 June 2026, originally based on the formulation by . The core properties of Veris are as follows:

The variables are stored on a two-dimensional, staggered C-grid . Tracer variables, such as ice thickness and concentration, are stored at the centers of grid cells, while the u- and v-components of velocity are stored at the respective u- and v-grid points.

The EVP solver is the most computationally expensive component of Veris and the primary focus of the performance evaluation presented in this study. It is therefore described in more detail in this section. The dynamics of sea ice is governed by the momentum equation: 2m∂tu=∇σ+τa+τw-mg∇H-mfer×u where m is the sea ice mass, u the sea ice velocity, σ the internal stress tensor, τa and τw the wind–ice and ocean–ice stress components, H the sea surface height, f the Coriolis parameter, and er the unit normal vector. Veris employs the viscous-plastic rheology VP,, which relates the strain rate to the resulting internal stress tensor via 3σij=2ηε˙ij+(ζ-η)ε˙kk-P2δij where ζ and η are the bulk and shear viscosities, P the ice strength, δij the Kronecker delta, and ε˙ the strain rate tensor, defined as 4ε˙ij=12(∂iuj+∂jui) The viscosities ζ,η, the deformation rate Δ, and the ice strength P are defined as 5ζ=P2Δ,η=ζe2,Δ=(ε˙11+ε˙22)2+1e2((ε˙11-ε˙22)2+4ε˙122),P=P*he-C(1-A) where e is the aspect ratio of the elliptical yield curve, P* the ice strength parameter, and C the ice concentration parameter. Equation () defines the elliptical yield curve and describes the stress states during plastic deformation. To avoid singularities of ζ for low deformation rates Δ, a regularization Δreg=Δ+Δmin⁡ with a minimum threshold Δmin⁡ is used. This regularization allows for stress states within the yield curve, corresponding to viscous flow.

For small internal ice stresses, ice flow is viscous and the internal stress increases linearly with strain rate. Once a critical stress threshold is reached, the ice deforms plastically, such that the internal stress does not exceed the yield criterion.

The well-known challenge in time stepping the ice momentum equation arises from large values in the stress tensor divergence due to high viscosities, which would require sub-second time steps if treated explicitly. The elastic-viscous-plastic (EVP) solver addresses this by introducing an elastic term into the stress tensor equation, which then relaxes toward the VP solution . The stress tensor is subcycled during the external time step while oceanic and atmospheric forcing terms are held constant. To address convergence issues in the EVP scheme, proposed the modified EVP solver (mEVP) by introducing an additional inertial term, which was later reinterpreted as an iterative scheme . The momentum equation is advanced from timestep n to n+1 using the following subcycling scheme: 6σp+1=σp+1α(σ(up)-σp)7up+1=up+1β(Δtm(∇σp+1+F(up))+un-up) where F includes all forcing terms, p denotes the subcycling index, and α and β are numerical relaxation parameters. σp is the stress tensor as computed in the previous subcycling iteration, while σ(up) is the stress tensor computed from the strain rate and viscosities at iteration p. The initial values of the subcycling are σp=0=σn and up=0=un. After a prescribed number of iterations, convergence is assumed and the stress tensor and velocity are updated as σn+1=σp and un+1=up.

In the aEVP solver, the relaxation parameters for the subcycling procedure are computed based on grid cell size, time step and ice viscosity, resulting in faster convergence in most grid points : 8α=β=(c̃γ)1/29γ=ζcAcΔtm where c̃ and c are numerical empirical scaling factors, γ the local stability parameter, and Ac the grid cell area.

To verify the correctness of the translation from Fortran to Python, we conducted a comparative analysis of model outputs from Veris and the MITgcm. The thermodynamic and dynamic components were evaluated separately. For the thermodynamic component, a one-dimensional benchmark was employed, simulating the temporal evolution of sea ice thickness, snow thickness, and ice concentration within a single grid cell. This setup is sufficient for thermodynamic verification because thermodynamic growth and melt processes depend exclusively on local state variables and atmospheric and oceanic forcing, without lateral coupling to neighboring grid cells.

The thermodynamic benchmarks covered a range of initial conditions for ice thickness, snow thickness, and ice concentration, as well as variations in atmospheric and oceanic forcing, including air temperature, ocean surface temperature, precipitation, and shortwave and longwave radiation. Simulations were performed for 365 time steps with a daily time step. Differences between Veris and the MITgcm remained on the order of O(10-7) for all prognostic variables and exhibited random, non-accumulative behavior (Fig. ). Small differences are expected in code porting due to a variety of reasons, including differences in compiler-dependent ordering of operations, intrinsic library implementations, and floating-point arithmetic. The bounded and non-growing nature of the differences indicates that the translated thermodynamic formulation represents a stable, non-divergent system. The deviations are therefore attributed to numerical precision limitations .

For the dynamic component, a two-dimensional benchmark following was conducted on rectangular grids with resolutions of 128×128, 256×256, 512×512, and 1024×1024 grid cells. As in the thermodynamic tests, varying initial conditions for ice thickness, snow thickness, and ice concentration were employed, along with variations in atmospheric and oceanic forcing. In contrast to the thermodynamic component, the sea ice dynamics solver is subject to stricter stability and accuracy constraints, requiring shorter time steps. Accordingly, a time step of 10 min was used for 1000 time steps.

The dynamical evolution of the sea ice field is substantially more sensitive to small perturbations than the thermodynamic evolution. To establish a reference for acceptable divergence, the MITgcm benchmark was repeated with perturbations on the order of O(10-15) added to the initial conditions and forcing fields. This procedure follows , who propose that successful code porting is achieved when the divergence between the original and translated solutions is not exceeding the growth of an initial perturbation introduced into the lowest-order bits of the original code solution. Both Veris and the MITgcm use double precision (float64) arithmetic. Even perturbations of this magnitude led to differences on the order of O(10-2) in ice speed and O(10-1) in ice concentration. These deviations with patterns nearly on the grid scale did not accumulate further over time and were constrained primarily to regions with pronounced grid-scale variability. This accumulation is attributed to small horizontal displacements in sea ice concentration between the model simulations that have a larger impact in these regions than in regions with smoother sea ice.

The differences between Veris and the MITgcm are of the same or smaller magnitude than those obtained in the perturbed MITgcm reference simulations (Fig. ), indicating successful code porting and variations within acceptable numerical limits. In addition to the 1000-time step benchmarks, a longer integration of 3 months (12 960 time steps) was performed to assess Veris's long-term behavior , which remained consistent with the MITgcm.

In the initial implementation of Veris, developed as a sea ice plug-in for Veros, the EVP solver cannot be executed in parallel when using JAX as the backend. This limitation arises because the EVP solver requires halo exchanges between neighboring partitioning regions within the solver iteration. These exchanges are performed inside the EVP loop body via a routine: calculate_stress and calculate_velocity correspond to Eqs. () and (). When NumPy is used as the backend, the EVP solver is implemented with a standard Python for-loop, allowing Veris to rely on the existing MPI-based communication infrastructure provided by Veros. When JAX is used, however, iterative loops are implemented using the , which compiles the loop body without unrolling every iteration during compilation. This compilation model is not compatible with the communication mechanism employed in Veros. The communication mechanism of Veros enables MPI-based halo exchanges through a decorator that contains both the JIT compilation and the MPI communication. This decorator can only wrap functions that are not automatically compiled by JAX, and since the EVP loop is automatically compiled, this decorator-based approach cannot be applied, and the routine cannot be invoked inside the compiled loop body. Enabling MPI-based parallelism in this context would therefore require a custom Veros-compatible mechanism that supports communication inside a compiled loop while ensuring the loop body is traced and compiled only once. The development of such an interface is beyond the scope of this work.

To enable parallel execution, we adopted JAX's native sharded-array framework. Sharded arrays explicitly contain information on how their data are distributed across the available devices. Communication and synchronization between devices are managed automatically by the XLA (Accelerated Linear Algebra) compiler, which inserts collective operations and resharding operations tailored to the underlying hardware. While communication remains necessary, it is managed by the compiler and at runtime rather than being expressed manually in the sea ice model code. This separation of scientific implementation from distributed execution reduces programming complexity and improves portability across diverse hardware architectures. Compared with our earlier mpi4jax-based approach, JAX's sharded arrays also reduce maintenance effort by relying on stable, backward-compatible public APIs, whereas mpi4jax depends on internal JAX APIs that may change between versions and require adaptation. On GPU systems, JAX's sharding backend can leverage optimized communication libraries such as NCCL (NVIDIA Collective Communications Library) for distributed transfers and collective operations. The Veris infrastructure was therefore restructured around sharded arrays while preserving the existing sea ice physics formulation, resulting in a standalone, fully JAX-based version of Veris that supports portable and scalable parallel execution on both CPU- and GPU-based architectures. All performance benchmarks presented in Sect.  were conducted with this updated version of Veris, except for the NumPy-based simulations.

To demonstrate that Veris accurately simulates sea ice dynamics and its rheology, a simulation was conducted using a forcing that is designed to induce fracturing of the sea ice cover (Fig. ). The forcing fields include a circular anti-cyclonic ocean surface current, which grows stronger towards the boundaries, and a circular cyclonic wind field with some horizontal convergence, which is displaced from the grid center and is strongest in its center. These fields are taken from the sea ice benchmark experiment described by , with the difference that the wind field is stationary in this work. The quadratic model domain is enclosed by land, resulting in boundary conditions of zero velocity. The simulation was run with a simulation time of 10 d with a time step of 10 min. The initial conditions included a constant ice thickness of h=0.3 m and an ice concentration of A=1. Narrow features in the sea ice concentration arise from inhomogeneities in the deformation field driven by the internal ice stress responding to the forcing fields. These linear kinematic features are discussed in and show that Veris's dynamics are on par with state-of-the-art sea ice dynamics codes.

To evaluate the performance of Veris, a series of idealized and scalable benchmark experiments were conducted. These experiments were performed on a rectangular grid with varying process count and problem size, utilizing the scaled forcing fields described in Sect. . The benchmarks serve two primary purposes. First, they compare the performance of Veris to the Fortran reference, assessing the impact of transitioning from Fortran to Python. Second, the benchmarks analyze the scaling behavior of Veris with increasing process count and domain size. Additionally, Veris running on a GPU is compared to the Fortran reference across various parallel CPU configurations, focusing on both time to solution and total power consumption.

The benchmarks are performed over 20 time steps. During the first time step, the compilation process with JAX's JIT compiler introduces significant overhead. To properly evaluate the model performance, the first time step is therefore discarded. The absolute compilation time for CPU-based processes ranges from 2.0 to 32.2 s and the relative compilation time ranges from 1.0 to 10.4 model iterations. For GPU-based processes, absolute and relative compilation times range from 2.1 to 32.4 s and from 2.1 to 6.2 model iterations, respectively.

For both Veris and the MITgcm, the full model is run with thermodynamics disabled at runtime (i.e., it is compiled but not run), and the reported timings exclude thermodynamics, initialization, and finalization. This approach is justified because thermodynamic calculations are computationally less expensive and negligible compared to the dynamics. The models are compared using the aEVP solver with 120 subcycling iterations.

The benchmarks are run on two different nodes of the HPC Levante, a supercomputer of the German Climate Computing Center (DKRZ). The specifications of the different node types are listed in Table .