2.14.0 release notes

These notes are built from the fragments in changelog.d/. Each file is one user-visible change on the 2.14 lanes, in the towncrier form +slug.<type>.md. docs/check_changelog.py renders them and fails if a fragment is left out or repeated. The notes are the changes since tag v2.13.0 (7f310225). The upgrade from 2.13 is the upgrade guide.

Added

  • The binding-overhead session times each language wrapper of read, k-nearest neighbours, q6 with q6bar, CHILL, and primitive rings on ice Ih, and records the median and interquartile range.

  • A CI job compiles the library sources PydSEAMSlib and dseams-r build under Clang 22 with -Wsign-conversion -Wunneeded-internal-declaration -Werror, once without OpenMP or any optional backend and once with them, and builds those libraries with -Dwerror=true. The compiler-warnings workflow also runs on release/** branches.

  • The installed C library reads frames from arrays and files. Callers can build neighbour lists and primitive rings, evaluate q3, q4, q6, and q6-bar, and run CHILL, CHILL+, cages, the shell classifier, and the brine front. seams.pc and seams-config.cmake ship with the library, and examples/c builds against that install.

  • Frame.cages_by_signature takes edge, and Lua dseams.cages_by_signature reads edge from its options table. Both call the same window as --cage-edge: empty keeps 2.65,3.15, and none leaves the cage bound to the face census. The C entry for the libseams path is seams_signature_cages_edge. seams_frame_signature_vertices_edge returns the vertices of that window.

  • capi_abi_2_13 holds libseams_lang, the C interface of the 2.13.0 release (seams_lang.h), to that release’s ABI: it compares a debug build of the library with the libabigail corpus in scripts/abi_2.13.0_seams_lang.abi, passes functions added since, and fails on a removed function or a changed signature. capi_abi_2_13_selftest edits copies of the corpus to prove both failures are caught. The capi-abi CI job runs both. Without abidiff they are skipped.

  • capi_abi compares libseams type by type with the 2.14.0 ABI 1 corpus through libabigail’s abidiff when it is installed, and passes only added functions. The abi pixi environment provides abidiff, and the capi-abi CI job uses it. Without abidiff, or with one too old to read the corpus, that step is skipped.

  • Julia, R, and C++ call the analyses seams.h now exports. Julia uses ccall on libseams. R keeps the libseams_lang frame API and adds a C shim. seams.hpp is a header-only RAII wrapper whose exceptions carry seams_handle_error.

  • The Rust, Fortran, and Python ctypes bindings call the analyses seams.h now exports, including frame reading, CHILL, Steinhardt parameters, cages, neighbour lists, the RDF, hydrogen bonds, density, the fingerprint, prisms, and the monolayer.

  • capi_docs_complete fails when a function in tests/capi_symbols.txt lacks a seams.h doc comment with a brief, every parameter, the return codes, thread safety, and ownership for pointer arguments, or when its C API page section is missing or differs from that comment. capi_docs_selftest removes each of those pieces from a copy of the header or page and requires the check to report it.

  • docs/examples/c/ holds one short C program per C API family: neighbours, rings, CHILL+, q4 and q6, cages, and errors. Each checks its own results on the in-tree ice Ih fixture, and capi_example_<family> compiles it as C11 with -Wall -Wextra -Wpedantic -Werror and runs it. The C API page includes all six.

  • C API: seams_system_set_positions overwrites the coordinates, and optionally the cell, of a stored frame, and seams_system_box, seams_system_positions, seams_system_types, and seams_system_ids copy the stored frame back out through a const handle. seams_system_set_atoms reuses the storage of the frame it replaces, and keeps the id index when the ids are 1 to n, so loading 110592 atoms costs about the same as building the frame in C++.

  • -Dcapi_fuzz_coverage=true instruments this project’s code for libFuzzer under clang, so the fuzzers see coverage inside libseams and not only in the harness. Subprojects stay uninstrumented, so their examples link without a sanitizer runtime; with sanitizers or coverage on, clang links the shared libraries with -z undefs and leaves the runtime’s symbols to the executable.

  • capi_installed_examples installs libseams into a staging directory and builds the six family examples in docs/examples/c out of tree against it, once with the flags from pkg-config seams and once through find_package(seams) with the new docs/examples/c/CMakeLists.txt, both as C11 with -Wall -Wextra -Wpedantic -Werror. Every binary must load the installed libseams.so and pass its own checks.

  • seams_c_last_stages returns the wall seconds of the last seams_cutoff_csr or seams_ql_cutoff call on the calling thread, split into point-cloud conversion, cutoff-list build, q_l and copy-out.

  • capi_reload_fuzzer drives seams_system_set_atoms, seams_system_set_positions and seams_system_stage_positions with random atom counts, NULL pointers, wrong lengths, NaN and infinite values in both reload modes, and reads the frame back after every call. Under clang the libFuzzer harnesses are built with -fsanitize=fuzzer and the capi_sanitize sanitizer.

  • -Dcapi_sanitize=address,undefined builds the C API suite under ASan and UBSan at once, and every UBSan build also checks float-to-int overflow, which GCC leaves out of -fsanitize=undefined.

  • C API: seams_last_error_message, seams_system_natoms, seams_neighbours_nrows, seams_rings_nrings, and the length-checked seams_chill_plus_n, seams_q4q6_n, seams_rings_labels_n, and seams_rings_histogram_n. Every public declaration in seams.h now has a Doxygen block with parameters, ownership, thread safety, and an example.

  • bench/capi_thread_scale.txt records capi_thread_scale on a release build. At 8 threads the cutoff-list build is about 60% of seams_ql_cutoff and 74% of seams_cutoff_csr, and the serial point-cloud conversion about 15% and 18%.

  • capi_thread_scale runs seams_cutoff_csr and seams_ql_cutoff at 1, 2, 4 and 8 OpenMP threads on 110592-molecule ice Ic, requires every width to return the one-thread bytes, and logs the per-stage times.

  • Saved trajectories other than CON are read with chemfiles, including xyz, a LAMMPS dump, gro, pdb, dcd, xtc and Amber NetCDF. A selection expression names water oxygen and hydrogen. The dependency is optional and on by default.

  • Every target, tests, benchmarks, bindings, engines and subproject examples included, builds under Clang 21 with -Dwerror=true, and a CI job builds that configuration and runs the suite on it.

  • Add pinned head-to-heads of 5^12 cages against ClavisCage TRACE and of q4, q6 and coordination against PLUMED.

  • A top-level Comparisons page links the OVITO FindRings, freud, SQQ, and PLUMED head-to-head results already recorded in this book.

  • A linux-64 pixi environment, cycles, holds Python 3.13 and bpy 5.3 for the Cycles molecule stills. pixi install -e cycles is enough: render_molecules.py finds that interpreter without MOLECULES_BPY. docs_render_molecules exits 77 only when no interpreter imports bpy. The environment adds lock entries and leaves the default environment’s solve alone.

  • meson test --suite engines-e2e runs each engine for 200 steps on ice and liquid (mW in LAMMPS and in LAMMPS with fix plumed, TIP4P/Ice in GROMACS, in gmx mdrun -plumed and in OpenMM), dumps the coordinates d-SEAMS classified in the run with their labels, and requires seams chill-plus to give the same label to every site of every frame. An engine that is not found is a skip. The Snakemake rule engines_e2e writes data/engines-e2e.csv.

  • CI builds each engine plugin against the conda-forge engine and runs its engines-e2e tests, with LAMMPS on one and two ranks; a skip fails the job. The PLUMED checks take the libplumedKernel.so beside plumed when PLUMED_KERNEL is unset, and gromacs_plumed_e2e reads the action log from PLUMED.OUT under GROMACS 2025 and later. C and Fortran snippets link against the patched chemfiles meson builds when the system one is rejected.

  • The mW front speed was measured again under the other readings of L and tau, under Lechner-Dellago q6, on the three faces, and at a 5 fs step. The one-front speed is a quarter of Espinosa et al. Table I at both 240 K and 260 K, and it matches the primary-prism markers in Shi et al., J. Chem. Phys. 162, 054714 (2025), Figure 3. Equation 2 is unchanged.

  • The secondary-prism speed is reported under equation 2 and under the solid-count slope, on the 4000-molecule cell. The 2015 CHILL+ thresholds are unchanged.

  • Local q4 and q6 on the cutoff shell use the solid-harmonic kernel from seams steinhardt, seams_q4_q6, and the Python, R, and Julia q4_q6 fronts.

  • seams_frame_chordless lists the chordless cycles of one size on a libseams_lang frame, with the same rows as seams_rings_chordless on that frame. seams.hpp returns them from Neighbours::chordless and rings_chordless.

  • Each language front reports rings, cages, signature cages and symmetry, and the binding CI runs those calls.

  • Every target also builds under GCC 15 in release mode with -Dwerror=true, and a gcc15-all CI job next to clang21-all builds that configuration and runs the suite on it.

  • The mW one-front speed was measured on the basal, primary-prism and secondary-prism faces from 220 K to 265 K. A Wilson-Frenkel curve is fit to the count-slope estimator on each face.

  • TIP4P/2005 ring updates at 0.01, 0.1 and 1 ps stay inside the hop ball and match a full search. The strict seeded graph is 8.3, 3.3 and 2.6 times a rebuild.

  • Fortran callers use a seams module of derived types with final procedures, allocatable results, and an optional stat/errmsg pair (d-SEAMS/dseams-fortran), and Lua callers get a Fennel module, a rockspec, and LDoc comments (d-SEAMS/yodaStruct). The numbers match the existing tests.

  • pydseams in pydseamslib 2.14.0 has the documented Frame handle. pydseams.read, from_ase, to_ase, to_solvis, chill_plus, cages, cages_by_signature, steinhardt, rdf_2d, monolayer_rings, find_prisms, and pydseams.band.ring_census call libseams_lang. The tutorials keep those calls.

  • A running molecular dynamics calculation can call the in-situ engine on each frame it chooses. The engine reports the primitive ring census. It also reports the published common neighbour ice labeling (CHILL) labels. The cage flags cover hexagonal and double-diamond cages. LAMMPS, GROMACS, OpenMM, i-PI, and the Atomic Simulation Environment attach through optional adapters. -Dplumed=enabled now errors. Live analysis does not use PLUMED.

  • Live analysis for LAMMPS, GROMACS, and OpenMM calls the library. The LAMMPS plugin and the in-tree package share one fix. GROMACS uses a module inside mdrun. OpenMM uses a reporter. Chemfiles reads the saved trajectory.

  • interface_order wc reports a Willard-Chandler width on the crystal center of mass. input/interface/campaign.py grows the shipped mW slab at several temperatures and seeds. The 2015 CHILL+ thresholds are unchanged.

  • interface_order compares the Nguyen and Molinero 2015 CHILL+ rule with the OVITO 3.17.2 rule on one frame or a short trajectory. The thresholds are unchanged. A square, pentagonal or hexagonal nanotube is labeled by its prism blocks, and a honeycomb sheet by its polygon or bilayer rings.

  • Meson builds compute dseams as dseamsplugin.so for LAMMPS plugin load when the LAMMPS class headers are installed. The compute takes cutoff, graph cutoff|mutual and rule published|ovito, and logs its call count and seconds per call when LAMMPS deletes it.

  • -Dlammps_src_include=DIR builds compute dseams against conda-forge LAMMPS, which installs library.h without the class headers. scripts/fetch_lammps_headers.sh DEST checks out src of the release that lmp reports and prints the directory.

  • Python, Julia, Rust and Fortran call the C API. Python reads NumPy arrays in place and accepts ASE and MDAnalysis frames. Julia uses ccall. Rust splits the raw FFI from the safe crate. Fortran binds the same symbols with iso_c_binding.

  • Orthorhombic frames are cut by linkcell’s weighted recursive coordinate bisection of the cell grid. The halo is the stencil painted while walking the cells a rank owns, and the same cut is reused on the next frame of that size. Neighbour rows, CHILL+, q6 and primitive rings keep their scratch across that repeat, and the ring search answers a length-2 shortcut that passes below the source.

  • Add a pinned head-to-head of cutoff neighbours, q4, q6, diamond, rings and local symmetry against mdapy, pyscal3, vesin, IRA and SQQ.

  • Add optional IRA, SOFI and spglib symmetry reports for ice shells, hydrate cages and rings.

  • require("dseams") is a Lua 5.4 and LuaJIT module over seams.h, with userdata handles and a Fennel wrapper on the same module. Reading, CHILL, Steinhardt parameters, cages, neighbour lists, the RDF, hydrogen bonds, density, the fingerprint, prisms, and the monolayer call that header.

  • The Lua binding (d-SEAMS/yodaStruct) finds the Lua 5.4 module through the lua pkg-config name that conda-forge and Homebrew use, builds dseams_ffi.lua by default, and fetches the Fennel 1.5.3 compiler with a checked sha256 when none is installed.

  • The Rust bindings are the crates dseams-sys and dseams (library names seams_sys and seams), built and published from d-SEAMS/dseams-rs. dseams-sys compiles a bundled C API by default and links an installed libseams with the system feature. The Fortran module is the fpm package dseams from d-SEAMS/dseams-fortran, and the LuaRocks rock dseams for Lua 5.1 to 5.4 and LuaJIT comes from d-SEAMS/yodaStruct. Each links an installed libseams; ci_packages.yml here builds and installs that libseams prefix.

  • Direct-coexistence mW growth is scored on basal and secondary-prism slabs of 8064 molecules at 1 bar. The 2015 CHILL+ thresholds are unchanged.

  • A nucleation-pathway census reports primitive rings by size, both CHILL+ rules, Lechner-Dellago q6-bar, and diamond symmetry labels on every frame. The CHILL+ staggered and eclipsed edges are unchanged. Largest-cluster size and the Ic/Ih fraction are recorded for each definition. nucleation-pathway writes the table. input/nucleation/regenerate.py rebuilds the short mW quenches outside the work tree.

  • Library calls narrow their OpenMP team when other processes hold the cores. Beside an idle resident 8-thread OpenMP team in its default wait, 8-thread CHILL+ on 110592-molecule ice Ic took 74 ms and now takes 7 ms, and the shell match went from 76 to 9 ms, with idle-machine times unchanged. SEAMS_FAIR_WIDTH=0 keeps the requested width.

  • DseamsReporter writes its dump argument: each report appends a LAMMPS dump frame of the classified sites with their CHILL+ labels. seconds and calls time the reports. Callers that passed a placeholder name now pass nothing.

  • Primitive rings are the Franzblau shortest-path census. OVITO FindRings is a subset: K2,3 has three chordless 4-rings and FindRings reports two, and every ring on the 864-atom interface frame at 3.5 Å is primitive.

  • Meson options -Dwith_blas, -Dwith_readcon, and -Dsystem_libseams. The last builds only the dseams module against an installed libseams.

  • A Reproduce the paper catalog lists each seams-core figure and table with the command, the input frame, the printed numbers, and the Snakemake rule or asv class. Small rows run in the suite. Full rows run when -Dpaper_full=true. Each head-to-head names its committed CSV.

  • seams chill and seams chill-plus take --per-atom FILE and append a LAMMPS dump frame with a label column, the CHILL or CHILL+ class of each site. Workers under --jobs append whole frames.

  • The PLUMED SEAMS collective variable reports q6, the CHILL+ ice fraction and the six-ring fraction, and a restraint can bias q6.

  • The PLUMED SEAMS action takes MODE=all|q6|q6bar and DUMP=file. MODE=q6 and MODE=q6bar compute only the mean local q6 or the mean q6-bar, without CHILL+ or the ring search. DUMP appends the coordinates handed to d-SEAMS and the per-atom value, plus the CHILL+ label under MODE=all.

  • The Snakemake rule h2h_plumed_q6 runs PLUMED’s Q6, LOCAL_AVERAGE and LOCAL_Q6 and d-SEAMS q6 and q6bar through SEAMS in plumed driver on the same mW ice/liquid frames at 4096 and 110592 molecules, serial and with 8 threads, and writes the per-atom agreement and the seconds per frame to benchmarks/h2h-plumed-q6.csv. The asv benchmark h2h_plumed_q6 times the same decks.

  • The Python Frame reference runs read, steinhardt, ring_census, rdf_2d, monolayer_rings, find_prisms, to_ase, and to_solvis on ice Ih and shows each result.

  • seams_frame_q4_q6_chill and the Python wrapper write q4, q6, q4-bar and q6-bar together with the published CHILL+ labels.

  • The R package dseams (d-SEAMS/dseams-r) builds as a self-contained source package that carries its own copy of the engine, or links an installed libseams_lang through SEAMS_LIBDIR and SEAMS_INCLUDE. The Julia package Dseams (d-SEAMS/Dseams.jl) takes its engine from libseams_jll, or from the libseams_lang that SEAMS_LANG_LIB or Dseams.set_library! names. packaging/yggdrasil/L/libseams in this repository is the Yggdrasil recipe for libseams_jll.

  • One sitting retimes neighbours, q4, q6, CHILL+, rings, symmetry and hydrate cages at 110592 and 884736 molecules on one thread and on eight. The raw lines are benchmarks/rc3-sitting.csv.

  • Add seams_rings_chordless, which lists every chordless cycle of one size (3 to 12) in a neighbour graph as sorted canonical rows, the same for any thread count, with per-atom counts. It meets two induced half-paths in the middle, and the six-ring census in bench/ring_ice.c now calls it: 3.1 ms instead of 20.6 ms on 4096 mW molecules, one thread.

  • bench_rings_h2h times primitive rings against OVITO FindRings with the cutoff graph outside the timer. A small-graph test checks that census against a brute-force cycle list.

  • seams rings prints the primitive-ring census by size. seams prisms counts perfect and imperfect prisms of size 3 to 6. seams cluster prints the largest domain, the subset, and whether it percolates.

  • The ice label is the residual of the seventeen-atom shell after the optimal rotation and scale. The shell is the four bonded neighbours and each of their bonded neighbours.

  • science::layersOf bins published CHILL+, the shell label and q6 along the interface normal. science::criticalSize is the mean size of the band around the smallest largest cluster. That number is an upper bound when the minimum falls in the first two frames. It is not a committor.

  • seams.h is ABI 1. A frame carries an orthorhombic or triclinic cell, and the library returns neighbours, both CHILL+ rules, q4 and q6, primitive rings, and ring symmetry labels.

  • The 884736-molecule sitting adds pyscal3 neighbours and q6, PLUMED q6 with PLUMED_NUM_THREADS set to the row width, and OVITO coordination. Those rows agree with d-SEAMS on the same ice Ic frame. scripts/plot_sitting_large_time.py draws time against threads and does not store the PDF.

  • One sitting pairs ice Ic at 884736 molecules with freud, mdapy, vesin, OVITO PTM and CHILL+, and rings-statistics-matter, at 1, 2, 4 and 8 threads. The detail column records the agreement check on that frame. The rings row is the cutoff list and the ring search together. The pool-audit rings kernel is ringNetwork alone.

  • The ice label takes an eclipsed-cosine cutoff, and cage, ring and shell naming runs in parallel.

  • Each OpenMP thread owns a block of the linkcell weighted cell cut and writes the neighbour rows of those cells. The halo is painted in that owned walk. On 884736 molecules, eight threads build the neighbour rows in 5.72 times the one-thread time.

  • OpenMM, rings, and cages each have a video slug next to the existing rings-cages slug. Topic pages embed the recording from the same embed.txt as the gallery, using an Odysee /$/embed/ URL when a claim is present and the words video coming soon when it is not.

  • An unsigned-char CI job builds every target on x86_64 Linux with -funsigned-char and runs the suite on it, so code that reads a plain char as signed fails without an aarch64 runner.

  • The videos gallery and the README link the d-SEAMS Odysee channel. Every docs/videos/<slug>/script.md end card cites Goswami, Goswami, and Singh 2020 and names the 2.0 paper as to be submitted soon.

  • All nineteen recordings embed their Odysee claims. The cages transcript adds the ice Ih hexagonal-cage census and the cubic double-diamond census, and keeps the clathrate lines. The brine transcript again includes the three-frame front beside the nacl census. The GROMACS overhead_s timer is machine-dependent.

  • The rings recording uses the 250-oxygen exampleTraj census and the ice Ih six-ring count. The Rust recording prints the ice Ih census. The GROMACS recording runs gmx-seams after gmx mdrun. A slug with no Odysee claim renders no player. End cards invite questions, issues, discussions, and pull requests. The Python pages show dseams.Frame next to pydseams.

  • recipe/recipe.yaml builds libseams (libyodaLib, libseams, libseams_lang, the seams CLI, headers, pkg-config and CMake files) for conda-forge with rattler-build from the release tag archive. The pydseamslib wheels and their conda package are built in d-SEAMS/PydSEAMSlib.

Changed

  • Every public symbol of the C headers and the C++ language header is listed in the reference pages with its parameters, return value, ownership, and error behavior. docs_api_coverage fails when a public symbol is missing from that list or a listed symbol is not in the header. Each binding repository checks its own language the same way.

  • A repeated neighbourhood builds its bond list once, the first time that ball is seen.

  • The language bindings move to their own repositories, each released with the seams-core version it binds: Python to d-SEAMS/PydSEAMSlib (pydseamslib, import dseams and import pydseams), Lua and Fennel to d-SEAMS/yodaStruct (LuaRocks dseams), R to d-SEAMS/dseams-r, Julia to d-SEAMS/Dseams.jl, Rust to d-SEAMS/dseams-rs (crates dseams-sys and dseams), and Fortran to d-SEAMS/dseams-fortran (fpm dseams). seams-core builds the engine, the C API libseams, the C ABI libseams_lang, the seams CLI and the engine drivers, and releases conda libseams and the Yggdrasil recipe for libseams_jll. The Meson options with_python, with_lua, fennel_lua, with_fortran, julia_wrap, r_libs_user and system_libseams are removed with the bindings they built. The docs run their Python snippets against the installed pydseamslib of the same version. docs/orgmode/contributing/repositories.org maps the repositories, the pins and the release order.

  • The Python and Lua bindings read neighbour lists through seams_neighbours_copy instead of the deprecated seams_neighbours_csr borrow, which stays only for ABI 1 callers.

  • Neighbours, CHILL, CHILL+, rings and cages can keep water oxygens by atom type or by molecule, and leave ions out of that graph. seams --mol water uses the atom that appears once in a multi-atom molecule. seams --mol 1,5-12 keeps those molecule ids. A type or molecule that is not in the frame is an error. On a LAMMPS dump with multi-atom molecules and no --type, the same choice replaces the old preference for type 2, which labeled hydrogens or sodium. compute dseams, as the LAMMPS plugin and as the copy-in style in extras/lammps, takes type I and mol water and scores only those oxygens; the other atoms it is given read 6. A group of several types that sets neither is an error. CHILL+ then reports ion-ice, ion-liquid and ion-front when ions remain in the frame.

  • The C API version macros come from the project version at build time. This release is 2.14.0.

  • The hexagonal-cage sweep in seams cages runs across the threads. One thread and several threads mark the same rings.

  • The seeded cage binding searches one graph when the mutual and union edge sets match. A dirty cage frame starts the backoff before it returns, so the following frames are warm sweeps instead of another diff.

  • The ice cage search counts distinct atoms in a small buffer and builds only the least ring reading.

  • The seeded cage call searches once when the mutual and union edge sets match. fellBack() runs before a dirty frame returns, so the following frames are warm sweeps.

  • A cold cage frame searches six-rings only, and the six triplet walks of the equatorial check share one read of each atom’s ring row.

  • Each function section of the C API page now carries its full seams.h documentation: purpose, every parameter, return codes, ownership, thread safety, and the header example. docs/capi_docs.py --write rewrites those sections from the header, and docs/render_c_api.py uses the same renderer. Every function that takes or returns a pointer now says in seams.h who owns each argument and how long the library holds it.

  • C API: seams_system_set_atoms and seams_system_set_positions check the coordinates with a vector scan that runs from the end of the input, so the write pass that follows finds the start of it still in cache. A default reload in a trajectory loop costs 2 to 5% more than writing the coordinates into the C++ frame directly at 4096 and 110592 molecules, against 13 to 15% before, and about 12% at 884736.

  • C API: seams_system_stage_positions makes seams_system_set_positions check and write the coordinates in one pass, into a second set of per-atom records that it swaps in only when every value is finite, at about 72 bytes per atom. By default a reload checks every coordinate first and writes in place, with no extra memory; either way a failed reload keeps the old frame.

  • A ring census counts each size into a per-thread bin and adds the bins after the search, so a dense frame no longer updates one shared counter for every ring.

  • A sparse ring census keeps one scratch list per thread instead of one empty list per atom. A dense frame still keeps a list per source.

  • A dense ring census counts size-5 rings on the first shell’s own bit rows, and size-7 arms that share a far vertex are kept or dropped together. That census uses the team below the sparse cutoff.

  • Users who run chill-plus on a cutoff list now see different counts. This is a bug fix in the shell count. The old code counted bonds after the list had been cut to four. A crystal row needs four neighbours inside the cutoff. On the mixed TIP4P fixture, interClathrate moves from 12 to 9. Water on that fixture moves from 238 to 241. Default q3 uses up to four nearest neighbours in the cutoff. Interfacial rows keep the neighbour test from the published table. Users who want the OVITO labels use the ovito-chill+ command. That command averages q3 on the full shell and skips the test. Plain CHILL keeps four closest neighbours and Moore’s test. A reader error now returns exit code 2 instead of aborting the process. We print reCubic and reHex as plain text. A path that ends in xyz and cannot be opened returns an error. An exception outside std::exception returns exit code 2.

  • A dense ring search builds each thread’s adjacency bits once, instead of once per atom.

  • seams chill-plus on a published cutoff classifies from the fused CSR kernel. seams steinhardt computes the degrees named by --l (default 4,6). seams symmetry builds the reported shell from the cells inside 5 Å. Primitive rings and the orthorhombic cutoff list stay on one thread below 2048 atoms. The vendored vesin meson project reports 0.5.7.

  • Documented seams lines that named FILE, dump.lammpstrj, or water.lammpstrj keep that template and gain a twin on input/traj/il_tiny.lammpstrj or ice1h.lammpstrj. The suite runs every twin, including the ionic-liquid commands and the chill line that exits 2.

  • A dense frame mixes each repeated neighbour-color signature once, instead of once per vertex.

  • The fingerprint options use the American spelling. seams fingerprint --color-types is the name help shows, and --colour-types remains a hidden deprecated alias of that same option. The Fortran frame_fingerprint keyword is colors, and colours remains an optional deprecated keyword with the same meaning; giving both different values is an error. seams_fingerprint takes color_types. Python fingerprint(color_types=...), Rust FingerprintOptions::color_types, and the Lua colors field follow the same rename and do not accept the old names. A key library writes colors in its header and still reads colours as a deprecated alias, so a 2.13 library file with colours 1 keeps its type colors.

  • The Comparisons tables name HaoZeke/seams-core and the benchmark branch, with a GitHub link, instead of a local remote. The long census and timing tables sit in collapsible blocks under a short per-cell summary. The C, C++, Python, Fortran, Julia, R, Rust, and Lua examples are programs or asserted snippets the docs suite runs.

  • The Comparisons pages are rendered from the vendored head-to-head CSVs. ClavisCage TRACE records the cage-by-cage census, including the seven periodic-wrap cages it drops on the 46-molecule sI cell, and the serial TRACE times against d-SEAMS at one and eight threads. SQQ records the exact edge and ring match on the 4096-molecule TIP4P/2005 frame, and the chordless-census and whole-tool ratios. A timed row names the version, the thread count, the repeat count and the core count.

  • The orthorhombic cutoff neighbour list is built by a parallel cell sort. Each thread counts its atoms, a prefix sum places them, and the pairs are written straight into one CSR. The same buffers are reused on the next frame. The pair set does not depend on the thread count. q_l reads that CSR. The neighbour average is skipped when only q_l is requested.

  • A threaded cutoff neighbour list on an orthorhombic cell uses the scaling cell list instead of linkcell’s buffered walk. The rows stay the same sorted cutoff set, so the ring search matches the one-thread list.

  • The triclinic cutoff list uses the same stencil as the orthorhombic list. CHILL+ evaluates the real spherical harmonics on that CSR. The diamond common-neighbour test reads the same rows. The ring census uses the short-hop search on that CSR.

  • The cutoff list now covers restricted triclinic boxes. A half list keeps each pair on the lower index. A skin reuses the wide list while every atom stays inside the Verlet shell. CHILL+, the ring census, and the template overlay read that CSR.

  • Per-atom keys of a frame whose neighbourhood is the whole graph are refined on that one graph, counting repeated neighbour colors instead of sorting them.

  • A dense size-7 ring drops an arm that already fails on its own, and the frame takes that walk as soon as a vertex has two shortest paths.

  • When a vertex has more shortest paths than the pairing walk stores, the same primitive rings are taken from the breadth-first levels, and a dense census counts them instead of storing each ring. Each search keeps its own count and path cap.

  • Each bonded neighbourhood is color-refined once, and the hop walk reuses one stamp instead of a fresh map.

  • A five-ring census walks only the arms that belong to one of the two vertices, skipping the arms they share.

  • A repeated small neighbourhood is recognised from one flat neighbour list, without rebuilding a graph for every atom. A team of threads keeps the direct row walk.

  • A four-ring census counts non-adjacent arms from the shell bit rows.

  • Hydrogen atoms are indexed by molecule once, so a hydrogen bond no longer scans the hydrogen cloud for every oxygen.

  • Per-atom keys on a sparse frame reuse one repeated neighbourhood instead of refining it again, and the atoms of a large frame are refined together.

  • The landing page hides the root toctree and replaces that dump with cards for Tutorials, How-to, the language reference, the engines, Comparisons, and the paper reproductions. The suite-stack diagram fills the article column.

  • Cutoff neighbour lists (neighListPair, halfNeighList, SkinNeighborList, and neighListO / getNewNeighbourListByIndex below 2048 atoms) come from linkcell’s lc_pairs_within with cells of about 20 atoms, and vesin is the fallback. halfNeighList on 8192 atoms at water density with a 3.5 Å cutoff goes from 8.9 to 4.7 ms on one thread and 4.0 ms on eight. The first linkcell cutoff list keeps freed pages on the heap for the rest of the process (M_TRIM_THRESHOLD, M_MMAP_THRESHOLD).

  • The linkcell wrap names the v0.4.1 tag and carries no patches.

  • A neighbourhood row longer than 16 stays in visit order, because that ball does not repeat.

  • The minimage wrap names the v0.1.4 tag. Distances use mi_displacement_euclidean, and a failed call keeps the in-tree formula.

  • MPI ring analyses can reduce ring counts and per-atom ring types with seams::domain::reduceRings, which keeps each rank on its own domain and sends only owned atoms to the root instead of gathering every ring on every rank.

  • CHILL, CHILL+, the shell match, rings, prisms and the 2D RDF use the OpenMP team for more of their work. The kNN graph rows, the shell-match cell sorts, the ring-pool merge and the prism ring index run on the team, and the 2D RDF bins its cells inside the pair-loop region. test_thread_invariance checks that every result is identical at 1, 2, 4 and 8 threads.

  • The orthorhombic cutoff list, cutoff q_l and the primitive ring census scale with OpenMP threads. Each thread fills its own CSR rows from a slot-balanced cell range, the C API reuses per-thread frame buffers, and the ring census counts sizes per thread without gathering the rings. On 110592-molecule ice Ic in bench/omp-scaling, 8 threads run the cutoff list 4.8 times, q4 5.8 times, q6 5.9 times and rings 6.1 times faster than 1 thread, and the 1-thread times are no slower than before. The CSR, q_l and ring counts are identical at 1, 2, 4 and 8 threads.

  • A type-1 crystal is read once; the default oxygen choice no longer parses that frame twice.

  • The in-plane RDF builds an explicit grid whose cells are the cutoff and bins packed coordinates from the neighbouring cells. Each thread keeps its own histogram until the frame finishes.

  • The full paper Snakemake tutorials stay out of a default test run. meson setup -Dpaper_full=true turns them on; otherwise they exit 77 and say they are opt-in.

  • The carried ring update sorts ring indices and merges the kept rings in parallel, and it keeps dropped ring buffers instead of freeing them on the update. The orthorhombic cutoff list counts each pair once, a z layer at a time, so several threads beat the single-thread walk. One-thread and several-thread results still match.

  • The one-thread carried ring update copies and sorts its rings directly again. Several threads still sort indices and merge in parallel. A team narrower than the process is bound once to that many cores of the allowed set. Interior cells of the orthorhombic cutoff skip the periodic-shift arithmetic. One-thread and several-thread results still match.

  • Neighbour, order-parameter, ring and shell calls keep one worker pool and leave the OpenMP team running between a Rayon search and the next region. A per-atom walk runs on the team the caller asked for, whatever the frame size. Ring sources still take one thread per eighty sources. The one-thread and several-thread results match.

  • The prism search without shape matching, which seams_rings_find and seams_prisms run, pairs each ring only with the rings that hold a neighbour of its first atom, the pairs the basal test can accept. On the 21 in-situ frames of 4096 mW molecules from engines/lammps/in.mw.lmp, seams_rings_find on one thread went from 0.672 to 0.0333 s per frame (median of 8), with the same rings, cages and prism counts. bench/seams_ring_frames times it on a LAMMPS dump.

  • The Python binding is released on PyPI as pydseamslib 2.14.0 from d-SEAMS/PydSEAMSlib, the distribution name of the 2.11 wheels, so pip install -U pydseamslib upgrades them in place. It provides import dseams and import pydseams.

  • Every Python block in the docs runs in the suite, and a printed value is asserted. seams commands that name a frame in the tree run as well, and a quoted count in the following paragraph has to appear in the output.

  • Neighbour-list q3 uses the one-bond kernel. The eight-bond batch stays on degrees 4 and 6.

  • An empty Steinhardt shell is 0. The harmonic row stays zero and is not divided by the neighbour count, so freud and pyscal3 store NaN for that same atom. A NaN switch is not added: it would enter every mean and every CHILL+ label, and a neighbour count of zero already names the shell.

  • q4_q6_equal compares per-atom and Lechner-Dellago q4 and q6 with freud and pyscal3 on ideal ice Ih, ideal ice Ic, and one liquid. OVITO 3.15 has no Steinhardt modifier, so that test no longer skips on it. pyscal3 matches to 1e-10. freud stores q_l as float32, and an empty shell is 0 here and NaN there.

  • q4 and q6 share one cutoff list. A multi-thread cutoff walk records each pair once. Seeded cages with identical neighbour rows search rings and cages once, and the k-nearest nomination uses the same thread count as the rest of the command.

  • The averaged q4 and q6 rows keep m = -l..0. The positive orders are the conjugate partners, and the power adds them in the full order.

  • q12 is the Cartesian solid harmonic, eight bonds at a time. The value matches the associated-Legendre form.

  • Release builds define NDEBUG, so the libstdc++ assertions that meson adds when b_ndebug is false no longer run in them. The closed-cage search on the sI 2x2x2 crystal takes 13.2 ms instead of 16.0 ms, with the same output.

  • A fingerprint and a per-atom ring count tally rings while searching and do not keep the list. seams fingerprint --by-atom reads those per-atom counts.

  • Interior cells of the one-thread orthorhombic cutoff skip the periodic-shift branches. A parallel ring search writes each neighbour row, already sorted, into one array, so the walk after the cell list matches the walk after linkcell.

  • A ring census adds up its seven-rings and publishes one total per atom, instead of one atomic increment per ring.

  • Seven-rings share the tests of one near vertex across the arms that leave it.

  • A five-ring census walks the shorter of the two exclusive arm sets.

  • The documentation sidebar is eight groups: Getting started, Tutorials, How-to, Reference (every language and the C API), Engines, Comparisons, Explanation (the paper and the architecture), and Project. The suite-stack diagram is a top-down figure with body-sized labels in light and dark theme.

  • A six-ring census drops arm pairs that share a second-shell vertex, or whose second-shell vertices are adjacent, before walking them.

  • A neighbourhood of fewer than 400 vertices counts a wide color palette instead of sorting each neighbour list.

  • A large sparse census counts rings from the parent at the previous level instead of copying every shortest path.

  • The one-thread ring search packs sorted neighbour rows in one pass, and interior cells of a triclinic cutoff skip the image-wrap branches. Both stencils keep the same directed pairs as the branchy walk.

  • A frame whose shell is three words wide counts five-rings from that fixed width.

  • The hydrate signature search scales with threads. The cutoff list is the threaded linkcell list, built on one reused worker pool, and crystals under a few thousand molecules stay at four threads so a wider team does not slow them down. Neighbour rows are placed on the calling thread until the pair list is large enough that a parallel sort is the smaller cost. The cage index is merged from per-thread buckets in ring order. Census and cage membership match the one-thread result.

  • A two-word shell counts seven-rings by testing each neighbour of the far vertex in place.

  • A regular frame’s first color round is the root, its neighbours, and the rest.

  • A dense neighbourhood counts repeated colors instead of sorting every neighbour list. The frame key is unchanged.

  • A small ball mixes a wide palette from the colors that occur, in palette order.

Deprecated

  • --types is a deprecated exact alias of --pair-types. The exact names both bind, and using --types prints a one-line warning on stderr.

Removed

  • The d-SEAMS 2.0 manuscript, its benchmark campaign, the record tables and logs under benchmarks/, and the paper reproduction pages leave this repository for the private paper repository; the records and figure data are the d-SEAMS/dseams2-benchmark-records and d-SEAMS/dseams2-paper-figure-data datasets. The performance pages show tables rendered once from those records (docs/records), and the asv harness and the timing scripts stay.

Fixed

  • The thread pool stays inside the CPU mask it inherited. A restricted taskset or cpuset is no longer widened to every CPU the kernel would allow.

  • The AMX INT8 product behind ozaki-ii-amx is checked against exact row, weighted-row and column checksums of its inputs, and recomputed with VNNI or scalar code when one disagrees. On a KVM guest that corrupted AMX tiles while separate processes used AMX at once, ozaki failed in 62 of 1200 concurrent runs and now passes all of them.

  • The AVX2 per-atom ice classifier behind symmetry and the shell labels, and the AVX2 scan that builds a one-thread full neighbour list in a triclinic cell, run only on a CPU that reports AVX2 and FMA. The classifier’s file was compiled with -mavx2 -mfma and called without a check, so symmetry stopped on an illegal instruction on a CPU without AVX2 or without FMA, and the inline header code that file emitted could replace the library’s own copies at link time. The triclinic scan checked the CPU inside a function that was itself compiled for AVX2. The classifier is now built twice, once for any CPU and once with a target pragma below its includes, the scan is split the same way, and each call takes the AVX2 copy only after the check. The double-precision product in ozaki now also requires FMA, and the AMX INT8 path requires the AMX-TILE and AMX-INT8 bits and the operating system’s tile state before it asks Linux for the tiles. One test switch holds the AVX-512 kernels, the classifier and the scan on their generic path, and a test compares the labels, the diamond signatures and the neighbour lists of the two paths. On a CPU with AVX2 and FMA the output is unchanged.

  • The AVX-512 spherical-harmonic kernels behind Steinhardt q4, q6, q12 and the batched Ylm run only on a CPU that reports AVX-512F, AVX-512DQ and FMA, the three their file is compiled with. The q12 path checked AVX-512F alone and the batched paths AVX-512DQ alone, so a CPU with one of the three but not the others could stop on an illegal instruction. Every call now goes through one check, other CPUs take the scalar path with the same values, and a test forces that path and compares the two.

  • The backtrace signal handler now outlives static destruction. A sanitizer abort at exit hit the freed handler stack and hung lammps_hook until its timeout.

  • Keep BondClassifier at the 2.13 layout, three doubles and one int. Open edges are an argument of classifyBond, so a caller that passes the struct by value is unchanged.

  • docs_brine_cli fetches the 230 K brine frame itself, through the same checked download as the science tutorials, and no longer skips on a clone where no other test has fetched it yet. The download takes a lock and lands through a .part file, so tests that start together do not read a partial frame.

  • A ring with no edge throws. An empty species pattern throws. A vertex at the minimum integer throws. The sphere test checks tiling before the closed test.

  • A cage ring is filled only when the cycle closes on a bond. A six-cycle that winds the periodic box is left unfilled, so the still is not a sheet the size of the cell.

  • A call that narrows the OpenMP team below the caller’s width, such as seams_prisms on a few thousand molecules at eight threads, pinned the calling thread to one cpu for the rest of the process. Every OpenMP worker and Rayon thread created afterwards inherited that cpu, so on 21 frames of 4096 mW molecules seams_rings_find after seams_prisms took 0.590 s per frame at eight threads instead of 0.0182 s. The caller now keeps its mask; one thread is unchanged at 0.035 s.

  • Keep the cutoff shell list and the per-share ring scratch on the calling thread. Overlapping calls no longer share those buffers.

  • C API: libseams exports only the seams_* functions in seams.h (hidden visibility plus a linker export list). No call aborts or exits: the MIS self-test throws instead of calling exit, every allocation in the wrappers is caught, a missing trajectory returns SEAMS_ERR_ARG, and infinite cutoffs are rejected by seams_hbonds and seams_monolayer.

  • C API: calls on a const handle no longer write the handle on success, and take a lock to record a failure, so several threads may query one handle at once. The ring label cache that seams_rings_labels fills on the first symmetry request is now built once under a lock and marked done only when complete; before, a second thread arriving during that request, or any request after a failed one, could read unfinished labels.

  • C API: seams_ql, seams_q4q6, seams_q4q6_n, seams_q6bar, and seams_steinhardt kept their q_lm scratch in function-local statics, so two of them on different handles in different threads corrupted each other’s results or the heap. The scratch now belongs to the calling thread, and the one-time affinity setup they reach is guarded, so q calls on different handles may run at the same time.

  • capi_symbols, which holds the exported functions of libseams to tests/capi_symbols.txt, reads the exports with readelf when nm is missing and reports a skip when neither exists; it used to pass without checking. capi_symbols_selftest proves that the check rejects an unlisted export and a listed function the library no longer exports, and that nm and readelf agree.

  • The vendored fmt 6 in chemfiles 0.10.4 counts format strings without std::char_traits, so the macOS build compiles under libc++ 19.

  • A MOL2 molecule whose counts line is empty no longer crashes seams_path_nframes. The vendored chemfiles 0.10.4 indexed the first count of an empty line; the build now applies cmake/patches/chemfiles-0.10.4-mol2.patch and refetches chemfiles when the patch set changes. Found by capi_read_fuzzer.

  • CHILL+ defaults to the cutoff list on the CLI, the C API, the LAMMPS compute dseams, and every language binding. The mutual four-nearest list is graph = mutual. On input/traj/exampleTraj.lammpstrj (oxygen, type 2) the cutoff list is 9 interClathrate and 241 water; the mutual list is 1 clathrate, 7 interClathrate, and 242 water. The docs tutorials run against the pydseamslib 2.14.0 package built from d-SEAMS/PydSEAMSlib.

  • Keep the 2.13 signatures of getCorrelPlus, getIceTypePlus, and getIceTypePlusNoPrint as overloads. The longer forms take the open-edge flag and the OVITO neighbour test.

  • Clang builds record the directory of clang’s libomp.so as a runpath, so the libraries, tests and libFuzzer harnesses start without LD_LIBRARY_PATH with an EESSI LLVM and with the apt.llvm.org packages, whose libomp lives in /usr/lib/llvm-<version>/lib.

  • The library builds with clang again: the prism code in topo_one_dim.cpp casts its signed ring and atom indices explicitly, as the rest of the tree does, so the -Werror=sign-conversion and -Werror=shorten-64-to-32 that clang builds use no longer stop it.

  • The engine builds with clang, libc++ and musl and on macOS. CPU features are read with cpuid instead of __builtin_cpu_supports, which needs compiler-rt’s __cpu_model on macOS. The AVX-512 row work in ozaki.cpp moved into target functions, since clang does not give an OpenMP region the target attribute of the enclosing function. The dump reader replaces __gnu_cxx::stdio_filebuf, which libc++ lacks, with its own seekable buffer. backward.cpp compiles to nothing where <execinfo.h> is missing, the ring profiler ticks use steady_clock off x86, and the AMX request in ozaki.cpp is Linux only.

  • The cutoff neighbour search clamps its cell count and stencil reach before converting them to integers. A cell edge many orders of magnitude shorter or longer than the cutoff overflowed both, which is undefined behavior and in practice left the reach at one cell. Found by capi_reload_fuzzer under UBSan.

  • The multi-thread cutoff list records neighbour ids during the count walk, and the linkcell pool is sized to the OpenMP width.

  • Keep a diamond shell while eight good (4,2,1) signatures, or the ambiguous band, are still reachable. The old count stopped once four bad rows made nine good signatures unreachable.

  • On a crowded shell the diamond label uses the four nearest neighbours, the list mdapy uses, and the labels stay those of the cutoff list.

  • A LAMMPS dump whose NUMBER OF ATOMS line comes after ITEM: ATOMS no longer indexes past the id table, which was sized for the previous count. Found by capi_read_fuzzer.

  • A chemfiles LAMMPS dump keeps the reduced cell edge. The bound span was being padded by the tilt a second time, so genice sH reported 31.05 Å instead of 24.84 Å. OVITO FindRings is compared as a subset of the primitive-ring census: K2,3 has three chordless 4-rings and FindRings reports two.

  • dump_index_eintr, dump_index_eio and dump_fstat_keeps_atoms each write their dump under a directory of their own. The three run one driver in parallel and shared a fixed temporary directory, so one test’s cleanup could remove the other’s file and abort it with filesystem error: cannot remove.

  • Engine checks load the plugin from the build tree. A copy staged under an install destdir is left alone.

  • docs/howto/test_engines.py runs each engine how-to in a temporary directory under build/docs-examples and removes it afterwards. docs_engine_<engine> and the docs_video_tapes scenes ran the same engine at once in one fixed directory, and PLUMED, which renames every colvar it finds to a numbered backup, refused to run once 101 backups had built up over repeated meson test runs.

  • libSeamsPlumed.so, run_hook and seams_openmm carry an rpath to libplumedKernel.so, liblammps.so and libOpenMM.so. Without LD_LIBRARY_PATH, PLUMED’s LOAD failed with “libplumedKernel.so: cannot open shared object file” and the two drivers did not start.

  • The Fortran methods that size a buffer and then fill it (rdf, running_cn, density, brine_profile, the fingerprint keys and the neighbour columns) pass the capacity in its own variable. They passed one variable as both the by-value capacity and the intent(out) length, which leaves the capacity undefined on entry.

  • The Fortran bindings free the result buffers after the copy, and a dump that cannot be opened names its path. The cubic example drops the arrays it owns after the frame is closed, which LeakSanitizer otherwise reports before a Fortran main finalizes its allocatables.

  • capi_fuzzer writes its per-format scratch files under names that include the process id. -fork jobs and parallel test runs shared fixed names in one working directory, so one process could truncate a file another had mapped and die with SIGBUS. The fuzz targets also rebuild when their source changes.

  • gmx-seams classified every site of the trajectory, which for TIP4P/Ice put hydrogens and virtual sites into the CHILL+ graph. -select now picks the sites (-s topol.tpr -select 'name OW'), -dump writes the classified frames with their labels, and molecules are no longer made whole before classification. The gromacs_legacy_include option builds it against GROMACS 2023 and later, which install neither the trajectory-analysis headers nor libgromacs_export.h.

  • A LAMMPS dump that grows while it is read is kept. The language fronts follow the build Python and skip a library mismatch.

  • Read a halo source from the frame index in share.local. The old index walked the local list as if it were the frame.

  • Keep spherical-harmonic scratch local to each call so concurrent frames and changing thread counts do not share buffers.

  • The XYZ and LAMMPS dump readers no longer size their buffers from the header atom count alone. A few-byte file that declared 99999999 atoms made seams_system_read allocate several gigabytes before reporting the truncated frame, and under MALLOC_PERTURB_ it pushed capi_fuzzer past its 4 GB limit. Reservations are now capped by what the unread bytes can hold, and the dump id index sizes its bitmap only after the rows confirm the count. capi_contract checks the peak RSS on Linux.

  • bench_rings_h2h --repl answered every sample with the ring search on a graph built before the clock, so the inside row repeated the prebuilt one. An in line now times the neighbour list, its index and the ring search as one call, and scripts/rings_one_thread.py records the prebuilt and inside rows side by side and writes them to a CSV next to the JSON. The one-thread table on the Rings on one thread page is the prebuilt row and does not change.

  • c_api_installed and capi_installed_examples install into a fresh directory under install-stages in the build tree and remove it on exit, so meson test --repeat can run two copies at once.

  • compute dseams on several MPI ranks classified each rank’s own atoms as a separate cell, so atoms near a subdomain boundary lost neighbours. On two ranks, 8312 of 86016 labels over 21 frames of 4096-molecule mW ice and liquid differed from seams chill-plus on the same dump. The compute now gathers every atom to rank 0, classifies the whole cell once, and returns each rank its labels; all 86016 match. meson test lammps_e2e_np2 is the regression.

  • The landing-page and architecture diagrams quote labels that contain a slash or a quote, so Mermaid 11 draws the suite stack.

  • meson-uninstalled/seams-lang-uninstalled.pc and seams-core-uninstalled.pc name the build tree. They passed -L a lib directory under the build root that nothing is built into, and no include path, so a binding with PKG_CONFIG_PATH at meson-uninstalled did not find seams_lang.h and did not link -lseams_lang or -lyodaLib. The installed seams-lang.pc and seams-core.pc resolve to the same flags as before.

  • language_fronts gives cargo test the SEAMS_SOURCE_ROOT and SEAMS_CPP_ORACLE that the Rust cpp_match tests read, and builds binding_oracle first.

  • libyodaLib no longer installs backward-cpp’s crash handler. Its static SignalHandling replaced the SIGSEGV handler of any process that loaded the library, so Julia, which faults on purpose at its GC safepoints, died with signal 11 at random points of Pkg.test() once libseams_lang was open. backward.cpp is now compiled into the seams, brine_front, science-front and nucleation-pathway executables, which keep their stack traces on a crash.

  • -Dwith_linkcell=disabled builds and links again: the k-nearest neighbour list merges its rows on the OpenMP team instead of calling linkcell’s slab walk, and the GPU batch helpers build under -Werror without linkcell.

  • A Clang build loads one OpenMP runtime. linkcell compiled its OpenMP k-nearest region with the environment’s GCC and linked libgomp next to Clang’s libomp, and the two runtimes disagreed on thread numbers, so neighbour, ring, CHILL+ and C API calls indexed past their per-thread buffers and aborted. linkcell 0.4.1 compiles that region with the C compiler Meson chose and links that compiler’s runtime.

  • The Lua LuaJIT FFI module dseams_ffi.lua is written by a plain build of the Lua binding, not only by its example test, so the LuaJIT FFI tutorial runs on a fresh build. The Lua binding lives in d-SEAMS/yodaStruct.

  • require("dseams") loads the module built for that interpreter. The Lua binding used to put the LuaJIT module first on the search path, and PUC Lua 5.4 then mapped that shared object.

  • The 1.x migration guide lists only the Lua globals v1.0.1 registered (readFrame, chillPlus_iceType, getPrimitiveRings and the rest). The dseams table and the later Lua names sit under the yodaStruct release that first shipped each one, and coordination, density, fingerprint, contact pairs, domains, k-NN and signature search are marked new in 2.x. The migrate video narration says the same.

  • A short LAMMPS frame no longer returns from the reading rank before MPI_Gatherv. Both ranks gather, and the frames that did read still print. On the 11-frame dump cut short, frames 1-10 stay whole and frame 11 keeps its header and two atoms.

  • The four nearest bonds are ordered by an insertion sort of that bounded count. GCC 15 no longer inlines std::sort past the end of the stack array once OpenMP outlines the loop, and the order is unchanged. AVX dispatch uses the CPUID helper, which exists on aarch64.

  • Use the one-cell neighbour stencil from two cells per edge, so a short box is not left on the general walk.

  • topo_bulk calls omp_get_thread_num only when OpenMP is on.

  • The paper tutorials, the science figures and the gallery render with Tachyon under Qt’s offscreen platform, so no display, OpenGL context or libxcb-cursor0 is needed. The science tutorials no longer start Xvfb with QT_QPA_PLATFORM=xcb, which aborted the process where libxcb-cursor0 is absent. The pixi-suite CI job keeps the locked OVITO 3.15.5 wheel, which matches the locked PySide6 6.9.3; the OVITO 3.17.2 wheel it installed over it needs PySide6 6.12 and import ovito failed. docs_science_tutorials holds a lock while it writes docs/source/science/figures, as the science snippet pages already do.

  • The Ozaki residue division uses shifts, so clang-cl no longer emits __udivti3 and __umodti3 for a 128-bit operator that lld-link does not pull into the DLL.

  • Name the site-site pair flag --pair-types. Give the gpulite and vesin wraps their own option files so meson configure does not copy the engine options onto them.

  • The opt-in paper runs print the molecule count, the frame count, and the file they read, next to the size the paper states. Rings reads frame 1 of the 11-frame 4096-molecule mW dump. The interface and brine runs read the shipped 864-water frames. Nucleation reads the figshare trajectory, 148 frames of 4096 molecules.

  • The linux-64 pixi lock keeps PLUMED 2.9, because a LAMMPS build that links PLUMED 2.10 needs glibc 2.38 and this lock is glibc 2.28. It also keeps libcurl before 8.10, because Julia 1.10.4 aborts in Downloads when that libcurl runs the socket callback during curl_multi_cleanup.

  • plumed_driver runs PLUMED in a scratch directory under the build tree, not beside the deck in the source tree, so two build trees no longer share its colvar.

  • The PLUMED q6 derivative is expressed per nanometer. A 0.001 angstrom step matched an independent difference to 3.99e-11 on a shifted eight-molecule cell.

  • The PLUMED SEAMS action scaled positions and the box by 10 whatever PLUMED’s length unit, so under UNITS LENGTH=A it saw a cell a hundred times too large: on the ideal 64-molecule cell seams.ice was 0 and seams.q6 0 instead of 1 and 0.6285. It now reads the unit from PLUMED. meson test plumed_units is the regression.

  • The engine compiles on aarch64, Apple silicon, and musl. The AVX kernels are built for x86_64 only and other targets take the scalar paths, backward.cpp is skipped without execinfo.h, and LinearFit::stderr is now slopeStdErr because musl defines stderr as a macro.

  • q4 and q6 build the multi-thread cutoff list in one pass again, instead of copying each linkcell block.

  • The C API builds q4 and q6 from one cutoff shell and does not fill an atom-index map on that path.

  • When SEAMS_LIBDIR is set, the R configure script exports DSEAMS_ROOT so it can find seams.h. A missing header names that variable.

  • Require readcon-db 0.1.8 so static consumers receive only the archive and shared consumers receive the runtime search path.

  • The release checks run on every platform again. test_serial_affinity counted a sampler thread from its previous call as a library thread, because pthread_join returns before the joined thread leaves /proc/self/task; each call now waits until it is gone. padding_probe reads the process cpu mask only on Linux, so the macOS build compiles it and counts every online cpu there. The ThreadSanitizer C API suite runs with address randomisation off, since GCC’s libtsan stops with “unexpected memory mapping” under the 32-bit mmap randomisation of newer kernels. The Julia and R binding pages link the README sections by the ids GitHub gives them.

  • An install is relocatable. The vendored chemfiles is installed beside libyodaLib as libseams-chemfiles.so.0.10, and the installed libyodaLib, libseams, libseams_lang and libSeamsPlumed find each other through an $ORIGIN rpath instead of a build-tree path.

  • The primitive ring search no longer crashes on a vertex with more than 48 neighbours when it searches by hops alone, as it does up to six-membered rings. Such a row fell through to the distance table that only the longer search builds; seams_rings_find over every atom of input/traj/dump-bcc was one case.

  • seams_rings_find classifies prisms from the neighbour index instead of an all-pairs scan, and the ice Ih stacking-plane pass runs across threads. Ring lists and labels on the 4096- and 32768-molecule cells are unchanged.

  • A sanitized build does not preload AddressSanitizer into Julia, R, or nm. Those hosts abort in their own startup. The runtime is mapped when they load libseams.

  • Sanitized builds of the seams, brine_front, science-front and nucleation-pathway executables leave fatal signals to the sanitizer. The backward-cpp crash handler had replaced the ASan and libFuzzer handlers, so a fuzzer stopped with no report and no saved input. capi_signal_owner checks that libseams installs no SIGABRT handler in plain or sanitized builds.

  • A one-thread run keeps a single thread, and a bound run keeps the cpus of its OpenMP places. At OMP_NUM_THREADS=1 or after seams_set_num_threads(1), the neighbour, CHILL+, q6 and ring calls started a Rayon worker beside the caller: libseams and every executable carried their own copy of linkcell, so the one-thread width never reached the searches libyodaLib runs, and linkcell’s walks asked rayon for its global pool even at width one. libyodaLib now holds the only copy, and linkcell runs a one-thread search, its walks and its fused k-nearest region on the calling thread. Under OMP_PROC_BIND the calling thread stayed on the first OpenMP place and the linkcell pool built from it inherited that one cpu, so two threads under taskset -c 0,1 ended on cpu 0; the caller now gets back the cpus of the OpenMP places, and no cpu outside the launch mask. test_serial_affinity checks the mask and the thread count under taskset.

  • The library sources PydSEAMSlib and dseams-r compile build without a warning under -Wsign-conversion and -Wshorten-64-to-32 with GCC and the newest Clang, with or without OpenMP, chemfiles, MPI and sphericart. Indices are std::size_t or pass a range check on the way, so PydSEAMSlib’s -Werror build on macOS no longer stops on them. Every count is unchanged.

  • ringNetwork, RingUpdater and seams_rings_find keep their odd rings on targets where plain char is unsigned, such as aarch64. The two-coloring that decides whether odd rings can be skipped stored its unvisited mark of -1 in a plain char; read back as 255, every graph looked bipartite and every three-, five- and seven-membered ring was dropped. The GenIce sII host now gives its 144 five-membered rings there too. The color is a std::int8_t.

  • with_sphericart=auto takes sphericart only from pkg-config or CMake. The library inside a pip wheel is used only with -Dwith_sphericart=enabled, and then yds_dep carries the -rpath-link a consumer of libyodaLib needs. The probe calls the constructor and compute the engine uses and links without --allow-shlib-undefined, and sphericart_consumer links a program against libyodaLib alone the same way.

  • Build the Sphinx book with warnings as errors from the committed sources. Doxygen XML and the C++ pages are optional, and each page is listed in one toctree.

  • seams_status_string reads its argument as an int, so a code outside seams_status returns “unknown status” without undefined behaviour in the C++ library; clang’s UBSan enum check aborted on it.

  • The cutoff cell window is timed with steady_clock when OpenMP is off, so the macOS R package and the wheels build that loop without omp_get_wtime.

  • A build with -Dwith_tests=false, including seams-core as a Meson subproject, registers no tests: the CLI, docs, C API, C ABI and engine plugin checks and their test programs follow with_tests, and the wrapped linkcell and minimage get the same with_tests and with_examples.

  • dseams-sys declares the C functions that return nothing without -> (), so cargo clippy --all-targets with warnings denied passes on the 1.85 MSRV toolchain as well as on current stable. gen_sys.py writes the declarations that way.

  • A tilted cell’s cage edge window uses the lattice minimum image, so a GenIce sH dump keeps every 5^12, 4^3 5^6 6^3 and 5^12 6^8 cage. The head-to-head against ClavisCage and cycless is benchmarks/cage-h2h-v8.txt.

  • Tilted LAMMPS dumps are read by the native reader again. Chemfiles 0.10.4 took the cell edge as xhi_bound - xlo_bound and kept the tilt padding, so the GenIce sH dump came back with an edge of 31.053 instead of 24.8424228 angstrom.

  • Builds without OpenMP or chemfiles, such as dseams-r on macOS, no longer carry functions nothing calls, so Clang’s -Wunneeded-internal-declaration and -Wunused-function stay quiet. The unused tallyRing in shell2_count.cpp and the per-atom counting path it served are gone, and helpers that only OpenMP or chemfiles builds call are compiled only there.

  • libyodaLib, and every program and binding that loads it, finds chemfiles::seams_with_frame in a pixi or conda environment. The patched chemfiles is built as libseams-chemfiles, with the soname libseams-chemfiles.so.0.10. Meson renamed it only when patchelf was on PATH, and pixi does not install patchelf. Without it the library kept the soname libchemfiles.so.0.10, and the loader opened the unpatched conda copy that the conda compiler puts first on the RPATH.

  • The recorded.txt check of docs_video_tapes ignores the note LAMMPS prints when OMP_NUM_THREADS is unset, as it is under meson test, so the lammps transcript matches with or without that variable. The using 1 OpenMP thread(s) line after it is still compared.

  • The brine, interface, nucleation, and rings picture tracks now show the paper-frame transcripts: 873 atoms with hexagonal 352 and water 434, the 864-molecule interface, 148 nucleation frames, and the 11-frame mW cell. docs_video_tapes fails when recorded.txt disagrees with the tape output or a spoken number is absent from that transcript.

  • docs_video_tapes treats a step that exits 77 as an absent engine or frame. That scene is skipped, each scene of the folder that ran still has to match its own section of recorded.txt, the narration check of that folder is left out, and the remaining tapes still run; the test then exits 77 with the reasons. Any other exit is still a failure.

  • -Dwith_cli=false configures again; seams_lang_fixtures referenced the CLI target unconditionally, so pip install . failed.