Documentation

Roadmap

What LARMORX has completed, what is under way and what comes next, in order. This page is updated whenever a step is completed.

Last updated: 2026-11-13. LARMORX advances one step at a time, and each step is finished before the next begins: its code, its tests against the original program, its validation record and its page on this site (how each step is tested). The working plan behind this page, with every follow-up, is in the repository’s next steps.

Under way and next

Step What it delivers Status
The documentation revision The website and the repository’s documents in one set of words, a reference page for every program In progress: the evidence pages and the site’s other pages done (2026-11-13)
1 FreeSurfer 8.2.0 Every program complete, a replica (larmorx-freesurfer) and a clean room built for speed: first the reference runs on the data panel, then FreeSurfer’s shared library, then the programs fMRIPrep runs, slowest first In progress: its preparation done on 2026-11-12 (the inventory of its code, the queue of its ports, the replay tool); its foundations, the shared library, under way. Every step, wave and status: FreeSurfer’s roadmap
2 Surfaces Surface programs compatible with Connectome Workbench and MSM Planned
3 larmorprepx The pipeline: BIDS in, fMRIPrep-compatible derivatives and HTML reports out Planned
4 Clean rooms for the programs that have only a replica A clean room, built for speed, of every program that has only a replica: ANTs and ITK, sdcflows’ field maps, fMRIPrep’s resampler and Python steps, nitransforms, the confounds; after FreeSurfer, in one block, before the final validation phase Planned
5 The completeness parts FSL’s FNIRT, applywarp, convertwarp and fugue, each with a replica and a clean room, then FLIRT’s -warp, epi_reg and flirt_average, which wait for them; ANTs’ missing operations; FreeSurfer’s optional streams: after FreeSurfer Planned

Later (decided on 2026-10-19): two optional AFNI paths of fMRIPrep’s libraries, 3dQwarp (sdcflows’ other PEPOLAR estimator) and 3dSkullStrip with 3dcalc (niworkflows’ older skull strip), and an AFNI analysis track outside fMRIPrep (3dTproject, 3dDespike, 3dReHo, 3dRSFC, 3dDeconvolve/3dREMLfit, 3dFWHMx/3dClustSim, 3dAllineate, 3dcalc, 3dTstat, 3dROIstats/3dmaskave, 3dresample).

New releases of the originals are followed as they come out: a weekly check lists every newer release and the files it changes, and each update is a step of its own.

The final validation phase

Once every program is ported, the extensive testing runs for every program at once, and each program’s evidence page grows with it (levels of testing):

  • the full comparison and the fourteen datasets of the data panel for every program, against the newest releases;
  • long random-testing runs of several hours for every program, and every heavy random case run to its end;
  • wider studies across thread counts, and speed and memory studies;
  • an independent review of every large port;
  • then the comparisons with fMRIPrep, stage by stage and end to end, against its newest release.

The first release

The release candidate 0.1.0rc1 is out (Getting started). The next release follows once the full pipeline, larmorprepx, exists; until then the repository’s main branch collects what comes with it (its changelog’s “Unreleased”), such as the command line’s options --n-threads, --implementation and --upstream-defects and the name clean-room for the clean rooms.

Completed

Newest first. The records of every program are in the repository’s docs/validation; the decisions behind each step in its decision log.

Completed Step
2026-11-13 Confounds: fMRIPrep’s confound estimation. The confounds fMRIPrep computes for every BOLD run (its desc-confounds_timeseries.tsv and the JSON beside it: CompCor, DVARS, framewise displacement, the motion parameters and their expansion, the tissue signals, the spike and cosine regressors), ported bit for bit from fMRIPrep 25.2.7, nipype 1.12.0 and niworkflows 1.15.4 (fMRIPrep 25.2.6’s own releases on request) with the arithmetic of the libraries under them: numpy’s and SciPy’s linear algebra (OpenBLAS’s kernels and LAPACK’s SVD and least-squares paths, in Rust), SciPy’s FFTs, pandas’ tables, nitime and nipy. fMRIPrep’s own confounds files of 36 runs (21 reference runs) reproduced column by column, their JSON byte for byte; every case of the five records bit-identical (88), in numpy 2.5.4, 2.3.5 and fMRIPrep’s 2.2.6; 49 defects of the originals found, 41 corrected or refused by default with the originals’ behaviour on request (among them every confounds JSON’s missing tissue-signal entries and nipype’s file names with a blank); nipype’s own command line as larmorx nipype run; the Python nodes 1.1 to 1.4 times fMRIPrep’s speed at one thread, at most 0.96 of its memory. Its page comes with the documentation’s new layout.
2026-11-12 Multi-echo: tedana’s t2smap clean room. t2smap in larmorx (pip install larmorx alone; its page): written from a behavioural specification, tedana’s documentation and runs of tedana’s program, never its source, built for speed; every option, message, exit status and failure case, its fits within the specification’s thresholds of tedana’s and of the replica’s (125 cases: 124 pass, 1 expected divergence; fMRIPrep’s six calls in three of fMRIPrep’s runs included), 10 to 15 times tedana’s speed at one thread on fMRIPrep’s curve-fit calls and 19 to 30 at eight, with a quarter of its memory; --implementation clean-room, and the default when larmorx-gpl is not installed. Two new defects of tedana, corrected in both ports (TED-31 and TED-46); the replica now reads ANALYZE and MGH images and prints tedana’s messages in every compared case (102: 62 identical, 40 refused by both alike); with it, larmorx’s own settings for FSL’s topup (b02b0 and five others), so topup runs them without FSL
2026-11-11 The easy command line. After the release candidate was tried by hand on macOS and Windows: the three settings as options of the larmorx command, before the program’s family, with the Python arguments’ names (--n-threads, --implementation, --upstream-defects; the environment variables keep working), the same in the larmorx-nc and larmorx-gpl programs; clean-room as the name of the clean rooms (original still accepted); a program’s messages shown while it runs; every FSL program writing .nii.gz when FSLOUTPUTTYPE is not set, and saying so; the installation page’s First steps, tried as typed in bash, zsh and Windows PowerShell. With the next release
2026-11-11 The first release: 0.1.0rc1, a release candidate. The three packages on PyPI at one version: larmorx (Apache-2.0), larmorx-nc (the FSL replicas; the FSL Licence, non-commercial use only) and larmorx-gpl (tedana’s t2smap; the GNU GPL version 3), pip install "larmorx[all]" for all three; wheels for Linux, macOS and Windows on x86-64 and ARM, built and tested on every platform by a release workflow on the version’s tag, with Windows’ C runtime built into the programs and smaller binaries; the standalone programs for each platform and two container images for Apptainer, Docker and Podman; every file with its SHA-256 and GitHub’s record of its build; the files rehearsed on clean Linux systems and on Windows before the upload. With it, the pages Installation and Why Rust and Python
2026-11-10 Field maps, part B: sdcflows’ PEPOLAR, direct and fieldmap-less estimation. The rest of what fMRIPrep runs, through sdcflows, to estimate the field that corrects susceptibility distortion, ported bit for bit from sdcflows 2.17.1 and niworkflows 1.15.4 (the newest releases; fMRIPrep 25.2.6 runs 2.15.1 and 1.15.2, both wirings kept) with nipype’s command lines, pybids’ dataset index and the arithmetic of SciPy, scikit-image and numpy (SciPy’s ndimage filters, morphology, labels and watershed, scikit-image’s random walker and Otsu threshold, numpy’s percentiles and dot products, in Rust): PEPOLAR pairs through FSL’s topup, direct field maps, the fieldmap-less (SyN) estimation through ANTs’ registration, the brain masks, the estimators of a BIDS dataset, the derivatives, fMRIPrep’s own field-map steps and sdcflows’ BIDS app, every option, message and failure case; every output bit-identical to the originals’ in every case of its records (57 of 57), sdcflows’ BIDS app whole on its eight reference datasets and fMRIPrep’s own field-map derivatives included, the SyN registration ANTs’ one-thread warp byte for byte at any thread count; 89 defects of the originals registered, 42 corrected by default and 15 refused with a clear error, each with the original’s result on request; the BIDS app 1.2 to 5.3 times faster at one thread, with 16 to 72 % of the originals’ peak memory. The page
2026-11-08 Multi-echo: tedana’s t2smap replica. The T2* and S0 fits and the optimal combination fMRIPrep runs for every multi-echo run, translated from tedana 26.0.3 with numpy’s, SciPy’s, nibabel’s and nilearn’s arithmetic, in the larmorx-gpl package (GPL-3.0 under LGPL-2.1’s section 3): every file, message and exit status bit-identical to tedana in both library environments in every compared case of its record (69: 44 identical, 25 refused by both alike), fMRIPrep’s five calls in three of fMRIPrep’s runs included; eighteen defects of tedana found (TED-01 to TED-18) and three entries of numpy’s and the C library’s maths (NP-03, NP-04, GLIBC-07), each corrected by default, refused with a clear error or kept by rule, and reproduced on request; 44 % of tedana’s peak memory, 3.0 to 4.2 times its speed at 14 threads on fMRIPrep’s curve-fit calls; the specification for the clean room. The page
2026-11-08 Field maps, part A: sdcflows’ field-map estimation. The steps fMRIPrep runs, through sdcflows, to turn a gradient-echo field map into the smooth field that corrects susceptibility distortion, ported bit for bit from sdcflows 2.17.1 (the newest release; fMRIPrep 25.2.6 runs 2.15.1, the same code on these paths) with the arithmetic of the libraries under it (scikit-learn’s ridge regression, SciPy’s conjugate gradients, B-splines and sparse matrices, numpy’s reductions over OpenBLAS’s kernels, nibabel’s scaled writer and header arithmetic): the phase difference to radians and, after PRELUDE, to Hz, the field map’s cubic B-spline fit, the field evaluated on other grids and a series unwarped with it, every option, message and failure case; every output, file, header, warning and message bit-identical to sdcflows’ in every case of its record (37 of 37), fMRIPrep’s seven phase-difference estimators in four of fMRIPrep’s runs included, whose own files it matches, at any thread count; eleven defects of sdcflows found (SDC-01 to SDC-11), each corrected by default or refused with a clear error and reproduced on request; the fit 6.5 to 7.8 times faster than scikit-learn’s at 14 threads, with 22 to 32 % of sdcflows’ peak memory. The page
2026-11-08 3dvolreg’s clean room. AFNI’s rigid-body registration written again from its behavioural specification and black-box runs of AFNI alone, never its source, and built for speed: each rotation’s four shears swept plane by plane in the cache, the Fourier rows transformed four pairs at a time, the coarse search’s rotations on its support box only, every step parallel inside each volume with the same bits at any thread count, so fMRIPrep’s calls run 2.8 to 5.2 times faster than AFNI on one thread (1.5 to 1.9 times the replica’s speed) and 9 to 15 times on 14 threads, with AFNI’s memory plus at most 10 % and 8 MiB on one thread; every option, message and failure case: exit statuses, messages, files and headers exactly AFNI’s, the numbers within the specification’s limits, measured from AFNI’s own spread where exact ties in its shear decomposition decide AFNI’s last bits, in every compared case of its record (251 cases: 185 pass, 63 refused by both alike, 3 expected divergences: AFNI’s own .HEAD/.BRIK format, which LARMORX does not write, and a malformed attribute AFNI reads past), fMRIPrep’s ten RobustAverage and PEPOLAR calls included (their medians at most 0.115 of their limits from fMRIPrep’s own outputs; a child’s high-motion run at 0.68 of one volume’s limit); AFNI-86 to AFNI-99 handled as the replica handles them; with it, output names of 228 to 255 bytes written by all four AFNI clean rooms. The page
2026-11-07 PRELUDE’s clean room. FSL’s phase unwrapping written again from its behavioural specification and black-box runs of FSL alone, never its source, and built for speed: the regions merged in FSL’s order through an indexed heap and a weighted union-find in place of FSL’s scans, so fMRIPrep’s two large calls run 97 and 211 times faster than FSL on one thread (2.5 to 2.8 times the replica’s speed) and a 128³ map in 0.3 s against FSL’s three minutes, the same bits at any thread count; every option, message and failure case: in reproduce every file bit for bit FSL’s, by default bit for bit the replica’s corrected result (but the last bits of a few complex images’ phases: the correctly rounded arctangent), in all 166 cases of its record (28 of them refused by both alike), fMRIPrep’s seven calls included; FSL-261 to FSL-272 handled as the replica handles them. With it the other clean rooms follow the specification answers of 2026-11-06: FLIRT’s weighted correlation counts each point’s weight as it goes (that registration now FSL’s matrix exactly), topup’s Jacobian with a coefficient field of other voxel sizes corrected by default (FSL-273), the head-motion correction’s least squares as FLIRT’s; and every FSL clean room writes a NIfTI pair’s header and reads a series’ time step as FSL does. The page · FLIRT · topup · head-motion correction
2026-11-07 3dvolreg’s replica. AFNI 26.3.05’s rigid-body registration, which fMRIPrep runs for every BOLD reference and sdcflows for its PEPOLAR reference averages, translated from AFNI’s source with every option (the six interpolation methods and -final, -twopass with its blurred first pass and coarse searches, the weights and edging, -tshift, -rotparent and -gridparent, -twodup, every output: the motion parameters, the matrices, the maximum displacements, the displacement datasets), message and failure case: every file bit for bit AFNI’s in every compared case of its record, fMRIPrep’s calls in six of fMRIPrep’s runs’ BOLD references and two PEPOLAR averages included (their medians fMRIPrep’s own outputs byte for byte), AFNI 25.2.09 the same, 2.2 to 3.1 times faster than AFNI; thirteen defects of AFNI found (AFNI-86 to AFNI-99), nine corrected by default or refused with AFNI’s behaviour on request (the maximum displacements of mirrored positions on inputs stored RAS or LAS, as every fMRIPrep input of the record is; a crash of Fourier rotations far beyond a head’s motion; -nocoarserot read as -noclip, among them) and four crashes or endless loops refused; the behavioural specification its clean room will be written from, checked by a model of its own text against AFNI. The page
2026-11-06 PRELUDE’s replica. FSL 6.0.7.23’s phase unwrapping, which sdcflows runs for every phase-difference field map, translated from FSL’s source with every option (phase and magnitude or a complex image, the mask and its threshold, 3D and slice-by-slice unwrapping, series, the ramps, the saved mask, labels and raw phase), message and failure case: every file bit for bit FSL’s in every compared case of its record, fMRIPrep’s seven calls in four of fMRIPrep’s runs included (fMRIPrep’s own outputs the same), with a faster bookkeeping of the regions; twelve defects of FSL found (FSL-261 to FSL-272), eleven of them corrected by default or refused, FSL’s behaviour on request (a NaN first phase value that skips the rewrap, the ramps’ last slice, NaN phases that move a region by about 2^31 cycles, among them); the behavioural specification its clean room will be written from, and the answers to the waiting questions of the other specifications (FSL-273 found in applytopup). The page
2026-11-05 The clean-room catch-up: topup, FAST, FLIRT, BET and the head-motion correction. The clean rooms brought up to their specifications’ answers of 2026-11-03 and 2026-11-04, from the specifications and black-box runs of FSL’s programs alone: topup’s reproduce with FSL’s forward differences for the movements (FSL-201), FSL-133’s and FSL-134’s applytopup layouts and FSL-145’s coefficient counts, 104 of 104 compared cases within its record’s thresholds; FAST’s default correcting FSL-202 and FSL-203 as the replica’s default does (the same bits with the C library’s functions in place of the correctly rounded ones), 64 of 65; FLIRT’s -debug, leastsq’s sums, applyxfm4D’s spline in double precision, the C library’s single-precision sine, cosine and arctangent in reproduce and its search’s starting points of equal cost in FSL’s order (found through BET’s trial), 238 of 240; BET’s -S, -B, -A and -A2 with standard_space_roi and fslroi as clean-room programs, FSL’s three standard images found or fetched with their checksums, 198 of 200; the head-motion correction’s centres of mass as mcflirt’s blocked sums, 145 of 146. Five random-testing trials of half an hour, every difference in a category with its verdict; two defects of FSL found: midtrans’ results beyond double precision (FSL-241, refused) and topup’s rejected last step of its scaled conjugate gradients (FSL-242, corrected by default); topup · FAST · FLIRT · BET · head-motion correction
2026-11-04 BET’s -S, -B, -A and -A2 in the replica, with standard_space_roi and fslroi. Every variation of FSL 6.0.7.23’s bet script translated: the eyes and optic nerves removed through MNI152’s eye mask (-S), the bias field and the neck removed before a robust run (-B), the skull and scalp surfaces from the T1-weighted image alone or with a T2-weighted one (-A, -A2), each running its programs (FLIRT, FAST, fslmaths, fslstats, betsurf) inside LARMORX’s own process; standard_space_roi and fslroi as programs of their own; FSL’s three standard images (1.4 MB) shipped in larmorx-nc with FSL’s licence, so no FSL installation is needed; every file bit for bit FSL’s in all 201 compared cases that run (600 files; the real heads of a 3.5-year-old, an 82-year-old, a tumour and a 1.5 T scan among them), FSL’s crashes refused or filled deterministically, one step not replicated yet (fslpy’s conversion of an image’s file type, refused clearly); seven defects of FSL found and corrected by default, FSL’s behaviour on request (FSL-211 to FSL-217); first, the replicas’ reproduce mode computes the C library’s double sine and cosine wherever FSL’s and AFNI’s code calls them (fslmaths’ functions and FFT, the interpolation windows, avscale, AFNI’s FFT). The page
2026-11-04 The C library’s own digits for reproduce, second half. LARMORX’s own implementation of the GNU C Library 2.35’s double sine, cosine and joint sine-cosine, written from a behavioural specification without reading the library’s code and checked against the system’s library on 11.8 billion arguments each (none differ), and the clean rooms’ reproduce computing the C library’s functions as the library does in fslmaths, fslstats, FLIRT and its programs, the head-motion correction, FAST, topup, BET and 3dTshift: FAST’s calls in fMRIPrep and 41 FLIRT cases, its default registration among them, now give FSL’s bytes; the default stays correctly rounded, and a notice names the C library’s digits only where a value differs exactly. The replicas take up the new functions in the next step.
2026-11-04 The C library’s own digits for reproduce, first half. The functions of the GNU C Library 2.35 that come from permissive code (Arm’s routines for the single-precision sine, cosine, logarithm, exponential and power and for the double exponential, logarithm and power; fdlibm’s single-precision arctangents) are now one exact copy in LARMORX’s maths module, shared by the replicas and open to the clean rooms’ reproduce, proved equal to the C library itself on every single-precision input and on more than a billion arguments of each other function; for the C library’s double sine and cosine, whose code is LGPL and never copied, a behavioural specification of its method, proved by a model written from that text alone on 3.2 billion arguments (the tangent and the inverse functions stay correctly rounded: their tables in the C library cannot be rebuilt from a definition); the clean room and its use in the programs come next
2026-11-04 fslmaths’ and fslstats’ clean rooms: fslmaths and fslstats complete. FSL’s image calculator and image statistics written in larmorx (Apache-2.0) from their behavioural specifications, FSL’s usage texts and black-box runs of FSL’s programs, without FSL’s code: every operation, option, data type, message and failure case of both programs; 374 of 374 compared fslmaths cases within the record’s thresholds, 358 of them FSL’s values in every file, and 126 of 126 fslstats cases, 125 of them FSL’s numbers, fMRIPrep’s mask combination in three of fMRIPrep’s runs and its goodvoxels calls included; three defects of FSL found by black-box runs, corrected by default (FSL-191 to FSL-193); built for speed: fMRIPrep’s goodvoxels chain 4.5 times FSL’s speed with half its memory, the heavy operations 1.8 to 28 times on one thread and up to 268 times on 14, the same result at any thread count; where FSL convolves a large kernel by its FFT the clean room adds in double precision, closer to the exact result than FSL’s FFT; fslmaths’ page, fslstats’ page
2026-11-03 The specifications’ answers for topup, FAST and FLIRT. The questions the three clean rooms left for their specifications (topup’s 9, FAST’s 21, FLIRT’s part 2’s 38) answered from FSL’s source, each precision answer checked by a model written from the specification’s text alone that gives FSL’s numbers; four defects of FSL found or explained, corrected by default in the replicas with FSL’s behaviour on request: topup’s rotation derivatives of the movements (FSL-201), FAST’s single-channel variance, whose cancellation is most of FAST’s own last-bit band (FSL-202: the default outputs of fMRIPrep’s FAST call move toward the exactly computed statistics), FAST’s NaN first voxel (FSL-203) and pointflirt without points (FSL-204); the replicas gained the clean rooms’ FSL-111 and FSL-144 to FSL-146 too; FAST · topup
2026-11-03 fslmaths’ and fslstats’ replicas. FSL’s image calculator and image statistics translated from FSL 6.0.7.23’s source, with the FSL libraries they need (newimage’s kernels, filters, connected components and statistics, the probability functions, Armadillo’s FFT): every operation of fslmaths and every option of fslstats, every data type, message and failure case; every file and printed number bit for bit FSL’s in every compared case but two (-dt double -tan and an FFT’s twiddle factors, one unit in the last place, where FSL’s glibc is not correctly rounded and LARMORX is), fMRIPrep’s mask combination in three of fMRIPrep’s runs and its goodvoxels mask’s eighteen calls included; FSL’s deterministic defects corrected by default and named, FSL’s behaviour on request. fslmaths · fslstats
2026-11-03 topup’s clean room: FAST and topup complete. FSL’s susceptibility-field estimation and its correction written in larmorx (Apache-2.0) from their behavioural specification, the papers and black-box runs of FSL’s programs, without FSL’s code: every option, message and failure case of topup and applytopup, applytopup’s variational methods included; 92 of 92 compared cases within its thresholds, fMRIPrep’s call in two of fMRIPrep’s runs as close to FSL as FSL at another thread count is (but for the field’s correlation on ds005040, 0.999958 against FSL’s own 0.999966); three defects of FSL found by black-box runs and random testing, corrected by default (FSL-144 to FSL-146); built for speed: fMRIPrep’s call in 2.8 and 7.7 s on one thread against FSL’s 33 and 77 s, 0.8 and 2.0 s on 14, the same result at any thread count; the page
2026-11-03 topup’s replica. FSL’s susceptibility-field estimation and its correction translated from FSL 6.0.7.23’s source, with the FSL libraries they need (B-spline fields and their regularisers, sparse matrices, non-linear optimisers, warps): every option, message and failure case of topup and applytopup, applytopup’s undocumented variational methods included; every file both programs write bit for bit in every compared case, fMRIPrep’s call in two of fMRIPrep’s runs included (fMRIPrep’s own outputs the same); FSL-116 to FSL-143 corrected by default (the thread count, the membrane energy’s units, the first volume’s interpolation, a divergent prior, options without meaning); the page
2026-11-03 FAST’s clean room. FSL’s tissue segmentation written in larmorx (Apache-2.0) from its behavioural specification, the paper and black-box runs of FSL’s program, without FSL’s code: every option, message and failure case, one channel or any number, FSL’s tissue priors registered by FLIRT’s clean room; 60 of 61 compared cases within its thresholds, fMRIPrep’s call in three of fMRIPrep’s runs bit for bit what FSL computes with correctly rounded maths; built for speed (parallel sweeps with the serial result, a vectorised exp with the same bits): 2.4 to 5.2 s on one thread against FSL’s 22 to 60 s, under a second on 14; the page
2026-11-02 FAST’s replica. FSL’s tissue segmentation translated from FSL 6.0.7.23’s source: the hidden Markov random field, the bias field and the partial volumes, every option, message and failure case, one to eight channels (FSL’s matrix arithmetic followed to 8 × 8 covariances) and FSL’s tissue priors registered by FLIRT’s replica; every file FAST writes bit for bit in every compared case, fMRIPrep’s call in three of fMRIPrep’s runs included; FSL-96 to FSL-104 corrected by default (memory FAST never writes, the multi-channel class sort, the mask’s brightest voxels, meaningless options, FAST’s aborts and crashes); the page
2026-11-02 FLIRT’s clean room, part 2: FLIRT complete. FLIRT’s other programs (avscale, the coordinate programs, rmsdiff, makerot, midtrans, pointflirt, applyxfm4D) and scripts (pairreg, extracttxt, aff2rigid), -debug and every verbose level, written from the specification and black-box runs; the specification’s answers to the clean room’s 20 questions (each checked by a model written from the specification’s text alone; the replica gained FSL-90 to FSL-93, 302 cases) closed 22 of its 30 open cases; fMRIPrep’s three boundary-based calls within 0.011 mm of FSL’s matrices, 12 to 14 times FSL’s speed on 14 threads; FSL-111 found (applyxfm4D’s 8-bit images read as signed bytes); the page shows it beside FSL and the replica, with FSL’s own variability; the record: 206 of 214 compared cases within thresholds
2026-11-02 FLIRT’s clean room, part 1. flirt and convert_xfm written from the specification alone, on the registration engine of LARMORX’s head-motion correction (shared, never copied; its results unchanged): fMRIPrep’s three boundary-based calls within 0.1 mm of FSL’s, -applyxfm’s images FSL’s bit for bit, convert_xfm and the messages FSL’s; 89 of 111 compared cases within thresholds, the others waiting for the specification’s answers; fMRIPrep’s boundary-based call in 38 s on one thread and 5.9 s on eight (FSL: 46 s)
2026-11-02 FLIRT’s replica, part 3. The rest of FSL’s FLIRT package: midtrans, pointflirt, applyxfm4D in every data type (double precision included), the scripts pairreg, extracttxt, aff2rigid, the schedule’s principal-axes alignment and any parameter subset (FSL’s own LAPACK translated word for word), -debug; FSL-78 to FSL-81 corrected by default; the page
2026-11-01 FLIRT’s replica, parts 1 and 2. flirt and convert_xfm with every cost function, BBR and the schedules, bit-identical to FSL 6.0.7.23 in every compared case, fMRIPrep’s boundary-based calls included; FLIRT’s other programs (avscale, img2imgcoord, std2imgcoord, img2stdcoord, rmsdiff, makerot), quaternion parameters, FSL’s heap overflow in the background value traced and corrected (FSL-75); the page with fMRIPrep’s boundary-based registrations
2026-11-01 BET’s clean room (bet, bet2, betsurf), written from its behavioural specification and built for speed, beside the replica: every bet2 and bet brain, mask and outline of the standard tests bit-identical to FSL 6.0.7.23’s (fMRIPrep’s calls included), betsurf’s profiles decided as FSL’s and its masks within their thresholds on 4 of 5 real heads; 2.5 to 3.6 times FSL’s speed on one thread, 6.5 to 13.5 times on 24. Open questions for its specification: a centre on neurologically stored images, betsurf where few profiles vote and on small images
2026-10-30 A cube root with the C library’s digits, for reproduce. 3dUnifize -EPI, in the clean room and the replica, keeps LARMORX’s correctly rounded cube root by default (naming GLIBC-05 where the C library’s last bit would change the result) and gives AFNI’s exact result in reproduce, through a clean-room cube root with the C library’s bits, proved on all 2^32 inputs; with it, mcflirt’s replica handles FSL-65 and FSL-66 as the clean room does, and the comparisons with the originals run in parallel (the same outcome for every test)
2026-10-30 Two additions to the clean rooms. The clean-room head-motion correction now handles mcflirt’s FSL-20, FSL-21, FSL-65 and FSL-66 as the specification says (outputs that cannot be written, impossible bin counts), and the clean-room 3dUnifize stops before an impossible -EPI neighbourhood (AFNI-75), with the same words as the replica
2026-10-30 3dUnifize’s replica: memory as AFNI’s. Peak memory within the rule with -T2 and -EPI (it held 1.5 and 2.8 times AFNI’s); the specifications of FSL-20, FSL-21, FSL-65, FSL-66, AFNI-75 and a cube root with the C library’s exact results written for the clean rooms’ implementers
2026-10-30 The AFNI replicas in larmorx. AFNI 26.3.05 releases the Medical College of Wisconsin’s code under CC BY 4.0, so the replicas of 3dTshift, 3dAutomask and 3dUnifize left the separate GPL package, larmorx-gpl, for larmorx (pip install larmorx, Apache-2.0 with CC BY 4.0’s attribution) and run in its process; the C library’s sine and cosine they need come from Arm’s MIT routines, proved equal to glibc’s on every input; their records, re-made in-process, agree case for case
2026-10-29 SciPy, NumPy and OpenBLAS at their newest releases. The one-shot BOLD resampler follows SciPy 1.18.1 (its fix of the reflect boundary, SCI-03) and is checked against numpy 2.5.4 with OpenBLAS 0.3.34 (nothing LARMORX follows changed); the FSL replicas follow FSL 6.0.7.23’s matrix library (Armadillo 14.2.1 on OpenBLAS 0.3.33) bit for bit, so mcflirt’s 5 expected divergences pass; FSL’s own last digits depend on the computer’s processor (FSL-64), and every record runs FSL on one set of kernels
2026-10-29 The clean rooms at the newest releases. 3dTshift, 3dAutomask and 3dUnifize follow AFNI 26.3.05 and the head-motion correction mcflirt 6.0.7.23 (its zstd and bzip2 formats, FSL-59, FSL-60), as their replicas do; the head-motion correction’s -cost mutualinfo and normmi computed exactly, as well aligned as mcflirt’s on 169 random phantoms
2026-10-29 FSL 6.0.7.23. The mcflirt and BET replicas follow FSL’s newest release (FSL-59 to FSL-63 registered; FSL-41 fixed upstream); every example on their pages shows both releases
2026-10-29 AFNI 26.3.05. The 3dTshift, 3dAutomask and 3dUnifize replicas follow AFNI’s newest release; a weekly check for new releases of every original
2026-10-29 The clean-room fixes. 12 of the 13 differences that random testing and the data panel found in the clean rooms of 3dTshift, 3dAutomask, 3dUnifize and the head-motion correction fixed or explained
2026-10-28 antsAI and antsAffineInitializer: memory and speed. Peak memory at or below ANTs’; antsAI about twice as fast
2026-10-28 fMRIPrep’s template registrations at full size. antsRegistration on the fourteen panel runs: 14 of 14 identical to ANTs with correctly rounded maths
2026-10-27 ANTs’ programs on the data panel. Every ANTs call of fMRIPrep’s fourteen panel runs, and the panel’s own images
2026-10-26 BET’s replica (bet, bet2, betsurf)
2026-10-25 mcflirt’s replica; the first long random-testing run over every program; the cache of the original programs’ runs
2026-10-24 The data panel: fourteen OpenNeuro subjects chosen to be hard, each with an fMRIPrep run
2026-10-23 and 24 3dAutomask and 3dUnifize, replica and clean room each; antsAI’s blob alignment
2026-10-23 antsRegistration, every stage: SyN, B-spline, displacement-field, exponential and velocity-field stages
2026-10-22 Atropos, every option
2026-10-21 Interactive evidence on every program’s page
2026-10-20 This documentation site
2026-10-17 and 18 antsRegistration’s linear stages and point-set metrics; antsAI and antsAffineInitializer
2026-10-16 ITK transform files, HDF5 included, read and written in pure Rust
2026-10-11 N4BiasFieldCorrection and DenoiseImage; ImageMath’s morphology, distance maps and the remaining operations; antsApplyTransforms in single precision; the cross-platform checks on six platforms; the first stage-by-stage comparison with fMRIPrep 25.2.6; the originals’ defects corrected by default, with a switch that reproduces them
2026-10-10 3dTshift, clean room and replica; the one-shot BOLD resampler; the head-motion correction (a clean room, experimental); ImageMath’s arithmetic, ThresholdImage, MultiplyImages and the smoothing and resampling filters
By 2026-10-10 The skeleton with continuous integration on six platforms; NIfTI-1/2 I/O, validated against nibabel; antsApplyTransforms