Native arm64 scientific
containers, verified to work.

Looking for a specific tool?
Two questions decide which project has it — the first usually settles it.

1. Do you want one tool, or a working stack?

2. The same software can be in both — in different shapes. The split is by artifact, not by subject and not by channel. So "it's biology, go to aarch.bio" and "it's on conda-forge, come here" are both wrong. scanpy is a single-tool image in aarch.bio (sourced from conda-forge, because bioconda's 1.7.2 cannot import) and a component of single-cell here. Both are correct.

Neither project is "the bioinformatics one." aarch.bio ships biology and general tools as single images, from whichever channel actually provides a working package; aarch.science ships biology and everything else as environments. Still unsure? Open an issue and we'll point you at the right project, or build it if neither does.

geospatial
110 packages — native arm64, verified, signed, public

The fieldwork CPU-prep stack. Headline packages:

earth-observation
246 packages — native arm64, verified, signed, public

The geospatial base plus the labeled-array / lazy / STAC layer:

geo-ml
368 packages — CPU machine learning on geospatial / tabular data

climate
267 packages — atmospheric / climate analysis (GRIB + regridding) + ocean thermodynamics

pointcloud
234 packages — LiDAR / DEM / terrain processing

comp-chem
212 packages — cheminformatics, molecular dynamics, quantum chemistry & docking

dft
236 packages — plane-wave & LCAO density-functional theory, MPI-parallel

The first MPI-parallel env — its verification runs the same bulk-silicon DFT calculation serially and under mpiexec -n 2, and fails unless the two energies agree. nwchem gets the same treatment on an H2O SCF (−74.963023 Hartree, identical across 1, 2 and 4 ranks). siesta is the one documented exception to the functional standard: conda-forge ships no pseudopotentials, so it is verified as an aarch64 MPI binary parsing a real input across 2 ranks, not as an SCF. On HPC, run this image with apptainer run — not exec, which skips conda activation and leaves nwchem hunting for basis sets under its feedstock build path.

md
246 packages — classical molecular dynamics, MPI-parallel

Every engine is run for real, on data the packages themselves ship: gromacs integrates 216 SPC waters, LAMMPS melts a Lennard-Jones lattice on 1 and 2 ranks with the energies agreeing, and sander conserves energy to 0.0109 kcal/mol — which says the Fortran kernels are numerically correct on aarch64, not merely that they load. Note the gromacs binary is gmx_mpi, and conda-forge builds it ARM_NEON_ASIMD, so it uses NEON and leaves SVE/SVE2 idle on Graviton 3+.

viz
246 packages — headless scientific visualisation, rendered on CPU

The clearest case in the catalog for why “verified” means a functional test: a bare conda install paraview cannot even start, because paraview links libhdf5 without declaring it. Here the smoke test renders a filtered volume to a PNG with no GPU, then reads that PNG back with pillow — which had no part in drawing it — and proves the frame contains real geometry rather than a blank background. No GPU needed; a display is (Xvfb ships in the image).

r
328 packages — R for scientific work, the catalog's first non-Python env

Being non-Python changes the verification, not the standard: this env's smoke test is Rscript /opt/aarchsci/smoke.R, and it still has to do real work — reproject through PROJ, write and re-read a GeoTIFF and a GeoPackage through GDAL, round-trip Parquet, recover a known sparse signal with glmnet, render a 400×300 PNG and decode its header back, and compile C++ through Rcpp::sourceCpp(). Pinned to the R 4.5 line deliberately: r-base reaches 4.6.1 on arm64, but zero of conda-forge's 3162 r-* packages have an r46 build, and r-base=4.6.1 r-tidyverse does not solve at all. Newest is not always usable.

astro
361 packages — the Astropy ecosystem, for astronomy and astrophysics, plus N-body dynamics

Astronomy is unusually kind to a functional test, because so many of its numbers are definitions rather than measurements — so this env's checks are exact, not approximate. 1 au is exactly 149597870700 m by IAU resolution; TAI−UTC in 2020 is exactly 37 leap seconds; a HEALPix map at nside=64 has exactly 49152 pixels; an exact-overlap circular aperture on an image of ones sums to exactly πr². A wrong answer can't hide inside a tolerance that tight. The test also runs entirely offline on purpose: astropy would happily download IERS tables, and a smoke test that needs the internet fails on someone else's outage and passes for reasons it can't see.

fem-cfd
131 packages — FEniCSx + CalculiX: finite-element PDE solving and structural FEA, MPI-parallel

The finite-element method hands you a way to test it exactly: if the PDE's true solution happens to lie in the element space, the computed solution is that solution, to round-off. So the smoke test solves −∇²u = −6 for u = 1 + x² + 2y² with quadratic elements and demands an L2 error of ~10⁻¹⁴ — then repeats it with linear elements, which can't represent that solution, and demands the error fall by a factor of 4 when the mesh is halved. Measured: 4.000. Both legs run again on 2 ranks and must agree. One thing to know before you use it: it compiles C at runtime — FFCx builds a C extension per variational form, which is why gcc is a runtime dependency, not a build-time one.

cfd-fv
56 packages — SU2: finite-volume CFD (compressible / aerodynamic), MPI-parallel

A second CFD culture next to fem-cfd — finite volume, not finite element. SU2 ships no meshes, so the smoke test builds its own: a deliberately distorted quad mesh, then a real Euler solve on it. The check is free-stream preservation — uniform flow is the exact solution, and a correct finite-volume scheme holds it to machine zero even on skewed cells, so the density residual must fall to ~10⁻¹⁴. A scheme with wrong metric terms fails that. Runs serially and again on 2 ranks (real ParMETIS domain decomposition), and the two must agree. Its own env because SU2's arm64 builds cap Python at 3.11.

optimization
64 packages — LP & mixed-integer programming (operations research)

Optimization is a method, not a domain, so it gets its own small image rather than lodging inside a domain env. It also has exact identities available, so none of its verification is a tolerance: the test LP's optimum is a derivable 36, the primal–dual gap must be 0 by strong duality — a theorem, not a measurement — and HiGHS and SCIP, unrelated codebases, must agree to 0 on identical input. An LP optimum is unique in value even when the vertex is not, which is what makes that cross-check meaningful.

neuroimaging
296 packages — volume-based fMRI, diffusion & structural MRI

Verified with nothing staged and nothing downloaded. A NIfTI affine is the image's spatial contract, so it must survive a write/read bit-exactly — asserted with exact equality, because a transform that is "nearly" right is the classic silent data-loss bug. Then DIPY fits a diffusion tensor to a planted eigensystem, where fractional anisotropy has a closed form: measured agreement 5.6×10⁻¹⁶, machine precision against analysis rather than against a number someone once recorded. Finally AFNI's 3dinfo — an unrelated C codebase — reads the file nibabel wrote and must report the same dimensions and voxel sizes; neither library can fake the other's agreement. Honest limits: ants has no arm64 build at all and FSL/FreeSurfer/MRtrix3 are not on conda-forge, so registration-heavy and surface-based pipelines are out of reach.

single-cell
532 packages — single-cell transcriptomics, both ecosystems in one image

Scanpy and Seurat are shipped together for one reason: the strongest check available here is two unrelated codebases, in two different languages, clustering identical bytes — and separate images could never verify that, because a smoke test cannot reach across containers. On a synthetic matrix with three planted groups, Scanpy recovers them at adjusted Rand index 1.0000, Seurat at 1.0000, and the two partitions agree at 1.0000. Both are scored against the planted truth as well as against each other, since two codebases agreeing on a wrong answer would sail through a cross-check alone. ARI rather than label equality, because cluster names are arbitrary — only the partition means anything.

bayes
125 packages — Bayesian inference & MCMC with Stan

Checked against a conjugate identity, which is about as strong as a test gets: Bernoulli data with two successes in ten, under a Beta(1,1) prior, has posterior exactly Beta(3, 9) — mean 0.25, sd 0.120096. No reference file, no band; the answer is derivable, and the tolerance is computed from the draw count rather than chosen. Measured 0.249395, which is 0.64 MCMC standard errors out, R-hat 1.0007. One thing to know: Stan ships no precompiled models — it compiles each model at run time, which is why a C++ compiler is a runtime dependency here and the first sample() in a session pays a few seconds.

geoscience
113 packages — seismology & groundwater flow (solid earth / subsurface)

The subsurface complement to the surface-and-atmosphere envs. Both halves get an exact check. One-dimensional steady flow between two fixed heads has a closed-form linear solution, and for a homogeneous 1-D domain the finite-difference answer is exact at the nodes — so the right expectation is machine precision, not a tolerance: measured 1.8×10⁻¹⁵, with the constant-head inflow matching Darcy's law to 1.5×10⁻¹⁵. ObsPy reads its bundled three-component example with no network, and detrend("demean") must leave a mean of exactly zero.

cp2k
111 packages — CP2K: Gaussian + plane-wave DFT and ab-initio MD, MPI-parallel

This one was the catalog's longest-standing gap — recorded from the first coverage probe as the single package most worth upstream effort, because CP2K had no arm64 build at all while every comparable DFT engine did. conda-forge now ships one. It also gets the strongest check here, and we didn't invent it: CP2K ships 344 regression tests whose manifests carry a committed reference energy and a committed tolerance, so the test reproduces upstream's own number at upstream's own bound — both read out of that manifest at run time rather than copied into our test. Reference −21.04944231395054, tolerance 3×10⁻¹³, measured 4.6×10⁻¹⁴ serially and 6.0×10⁻¹⁴ on two ranks.

pathology
209 packages — digital pathology / whole-slide imaging

Whole-slide images are gigapixel pyramidal TIFFs, and the obvious way to test a reader is to download a real slide — which would mean a 546 MB fetch every build. So this test generates its own slide with a planted region instead, and that turns out to be the stronger choice: the truth is planted rather than looked up. The pyramid must have dimensions exactly W/2^k with downsamples exactly 2^k; through lossless tiles read_region must return the planted pixels bit-exactly (measured: one unique colour in the region); and the same region measured at different pyramid levels must agree after scaling — relative error 0.00 at levels 0–2. A JPEG-tiled pyramid is checked too, because that is what real slides actually ship as.

quantum
165 packages — quantum circuit simulation

Quantum state vectors are exact linear algebra, so almost nothing here is a tolerance: a Bell state's amplitudes are exactly 1/√2 — measured |a| − 1/√2 == 0.0, with the forbidden amplitudes exactly zero — a circuit unitary satisfies U^†U = I to 5.6×10⁻¹⁶, and QuTiP, an entirely separate implementation, returns σ_z eigenvalues of exactly ±1. The packaging trap worth knowing: Qiskit ships only a py310 build for aarch64, which reads as a gap and isn't — it is abi3, so it installs and runs on Python 3.14. A py3NN build string caps nothing; a python_abi dependency does.

hep
355 packages — high-energy physics

The strongest check in this env is cross-implementation: ROOT writes a histogram and uproot — an independent pure-Python reader of the ROOT format, sharing none of ROOT's I/O code — reads back the exact per-bin counts that were planted. ROOT reading its own file would only prove self-consistency. ROOT's own arithmetic is checked as an identity too (a histogram of 1000 entries at a bin centre has integral exactly 1000), and a Gaussian fit is judged against the fit's own reported uncertainty rather than a band we picked. One thing this image does not do: run a Geant4 simulation. conda-forge ships no working Python bindings for Geant4 in any variant — the py* builds install zero files into site-packages while still pinning an interpreter — so the headless noqt build is what's here, with all twelve physics datasets present and wired. Library and data, verified; no simulation driven from Python. We'd rather say that than imply otherwise.

pic
167 packages — particle-in-cell plasma physics

The package ships 62 of upstream's own input decks, so this env is verified against WarpX's own Langmuir test rather than a fixture we invented — and that deck carries its own answer: the analytic plasma frequency is written into its parameters, so the reference is a closed form, not a number someone committed. Measured: Gauss's law ε₀·divE = ρ holds as a discrete identity to 7×10⁻¹⁰, and the oscillation sits within 3.6×10⁻⁴ of the closed-form frequency — stable to four digits whether you watch it for 1 or 12 plasma periods. The best check is an exact one: WarpX writes the same step twice through two unrelated writers, and yt and openpmd-api read the two files back bit-for-bit identical. No MPI, deliberately — conda-forge's WarpX is nompi on every architecture, so adding an MPI stack would dress a single-node code as a cluster code. It is still parallel: OpenMP across a Graviton's cores, with the thread count asserted.

structbio
121 packages — crystallography & structural biology

cctbx and gemmi are both here because they are two independent implementations of crystallographic symmetry — which makes a cross-implementation check possible instead of a self-check. Measured: a triclinic unit-cell volume comes out bit-identical across gemmi, cctbx and the closed-form expression; both agree with the International Tables on space-group order for ten groups; and symmetry operations close under composition exactly — F m -3 m gives 192 operators, 36 864 products, 0 outside the group. One lesson is baked into that table: our first draft asserted order 3 for R 3 and both libraries independently said 9 — because R 3 defaults to hexagonal axes, where 9 is right. When two independent implementations disagree with your constant, re-check the constant.

popgen
247 packages — coalescent simulation / population genetics

A tree sequence is a conservation structure, so most of this verification is exact rather than statistical: writing one to disk and reading it back gives byte-identical tables and bit-identical diversity, tszip compression round-trips the same way, and the segregating-site count equals the site count exactly. The one statistical check is judged against its own standard error, not a band we chose: coalescent theory says E[diversity] = 4N_eμ exactly, and 200 replicates give 3.815×10⁻⁵ against a theoretical 4.000×10⁻⁵ — 0.57σ.

tomography
88 packages — CT reconstruction

A parallel-beam projection is a set of line integrals, so the integral of every projection equals the object's mass — an identity that needs no reference value. Measured to 9.5×10⁻⁷, which is float32 round-off. The projector decides whether that is an identity at all: strip gives 9.5×10⁻⁷ where line gives 2.1×10⁻³. Reconstruction error then falls monotonically with the number of angles — 0.773 → 0.425 → 0.250 → 0.217 over 16/32/64/128 — plateauing near 0.21, which is FBP's floor for this phantom rather than a defect. The phantom is generated, so the ground truth is exact and nothing is downloaded. ASTRA is the verified engine; TomoPy is verified at import plus its phantom generator, because its reconstruction needs calibration and its multiprocessing path proved flaky under load. We'd rather say which half is proven.

psi4
82 packages — molecular quantum chemistry

Almost every env here is verified against an identity, because no published number exists at the precision we need. Quantum chemistry is the exception: RHF/STO-3G on H₂ is one of the most-tabulated numbers in the field, so this env checks a textbook value directly — and then adds two things a single number can't catch. MP2 must sit below Hartree–Fock, which the variational principle guarantees and no bug satisfies by accident; and the SCF energy must be invariant under translating the molecule 5 Å, which it is to 10⁻⁸ Hartree. Psi4 earned its own image the hard way — it was displaced from two other envs by version constraints that had nothing to do with arm64.

nlp
91 packages — natural-language processing

spaCy's documented way to get a pipeline is python -m spacy download — a runtime fetch. conda-forge packages the model instead, so this image needs no network, which is the only reason the env exists at all. Verified against identities rather than predictions, because a tagger's output can change with a model version without anything being broken: tokenization is lossless (the document reconstructs its input byte for byte, with Dr. and Jan. surviving as single tokens), the string store round-trips string → hash → string exactly, and Doc.to_bytes preserves tokens and tags. One documented limitation, asserted so it can't surprise you: the small model ships no word vectors.

gw
216 packages — gravitational-wave astronomy

A textbook case for why this project runs the code instead of trusting the solve. Two pin combinations both resolve cleanly; only one works. PyCBC 2.8.2 cannot import its own waveform module — it reaches for astropy.cosmology.core, removed in current astropy — so a bare import pycbc succeeds while everything useful underneath it is dead. We had recommended that set before measuring; the image ships 2.10 instead, at the cost of one LALSuite minor. Verified by identities: LAL's own constants are mutually consistent (M_⊙ in seconds equals M_⊙G/c³ exactly), chirp mass is bit-identical to the closed form, and the matched filter is both normalised and discriminating.

Browse the registry →  ·  Want another env (earth-observation, geo-ml, climate)? Request it.

🔄 Kept current automatically. A daily reconciler re-solves each env spec and rebuilds when the resolved package set changes — so latest stays current with conda-forge.