Comparison with Other Tools

How zsasa compares with FreeSASA, RustSASA, and Lahuta for SASA-focused workflows. This page emphasizes factual feature differences and points to the benchmark pages for current pinned performance numbers.

Overview#

Algorithms and precision#

zsasa and FreeSASA support both Shrake-Rupley (SR) and Lee-Richards (LR). RustSASA and Lahuta support SR only for the SASA paths evaluated here.

zsasa exposes f64 and f32 modes. f64 is the default continuity path for matched FreeSASA-style SR output; f32 is useful when users want lower memory bandwidth and compatibility with f32-oriented tools. RustSASA uses f32 throughout its computation pipeline.

Bitmask LUT mode#

zsasa includes a bitmask lookup-table mode for high-throughput SR calculations. It is an approximation, not a numerically identical replacement for exact SR mode. In the current pinned static validation set, bitmask f64 at 128 points reached R² = 0.999811, mean relative difference = 0.662%, and max relative difference = 2.02% versus FreeSASA.

See SASA Validation and Algorithms for details.

Input and parser behavior#

zsasa uses native parsers that extract the fields needed for SASA calculation. This avoids rejecting structures because of unrelated fields and helps with very large assemblies.

RustSASA relies on pdbtbx; the benchmark input preparation had to normalize large PDB records and other parser-sensitive cases for comparator compatibility. Lahuta's evaluated SASA command is intended for AlphaFold2-model inputs and treats the SASA structure as chain A, which excludes it from the multi-chain single-file stress suite.

Batch processing#

FreeSASA has no native directory mode. The current pinned batch benchmarks therefore use freesasa_batch, a thin wrapper around the pinned FreeSASA C API, so that comparisons are multi-file workloads rather than shell loops.

Results at 10 threads and 128 sphere points, from the zsasa 0.9.0 suite:

See Batch Processing Benchmarks for full tables, thread scaling, and the mmCIF and SwissProt runs.

Single-file stress behavior#

The single-file suite uses eight curated structures up to 4,506,416 atoms, at 100 sphere points and 10 threads.

PDB input, zsasa f64 at 10 threads and 100 sphere points.

Two of the large ratios are parser outliers rather than kernel scaling: FreeSASA on 8rbs and RustSASA on 5vyc. See Single-File Stress Benchmarks for the caveats.

MD trajectory support#

zsasa provides native CLI trajectory processing and Python integrations. The benchmarked CLI path streams frames, keeping peak memory close to the current-frame working set. RustSASA trajectory support is represented by mdsasa-bolt, which uses an MDAnalysis front-end and can materialize much more trajectory data in memory.

Results at 10 threads and 128 sphere points:

See MD Trajectory Benchmarks.

Build complexity#

Known limitations of zsasa#

Zig language maturity#

Zig has not yet reached version 1.0. The language may introduce breaking changes between releases. The Python package communicates with the Zig core through a C ABI, which helps insulate Python users from Zig-internal changes as long as the C ABI is maintained.

Benchmark scope#

The benchmark claims come from one consumer laptop and pinned comparator versions. Absolute runtimes will vary across hardware. Use the relative comparisons and the documented benchmark settings when interpreting the results.

Links#