Benchmarks

All numbers below were measured on Apple M4 (aarch64-apple-darwin), Rust 1.95 stable, criterion --warm-up-time 2 --measurement-time 4. All libraries compiled with --release (LTO=fat, codegen-units=1, panic=abort). Run locally via cargo bench --bench comparison.

PGO — scripts/pgo.sh runs the full LLVM profile-guided optimisation pipeline (instrument → train against the YAML test suite + benches/fixtures/ → merge profdata → optimised rebuild). Adds 5-15% on top of the numbers below; recommended for production deployments.

For algorithmic-complexity guarantees (O(n) parser, O(d) stack depth, O(1) anchor lookup, etc.), see POLICIES.md §4 — Performance & algorithmic complexity.

Headline (5-way Rust YAML head-to-head, every fixture)

Compares noyalib against the five most-used pure-Rust YAML libraries: serde_yaml_ng (the de-facto ecosystem successor to the unmaintained serde_yaml), yaml-rust2 (the heaviest-tuned non-serde parser), serde_yml (the maintainer’s prior crate), yaml-spanned (the closest other span-tracking parser), and serde-saphyr (a high-performance newcomer).

The serde_yml and serde_yaml_ng figures below are recorded measurements, not rerunnable today: both crates were retired from benches/comparison.rs, serde_yml in v0.0.6 (RUSTSEC-2025-0068) and serde_yaml_ng in v0.0.58 (its unsafe-libyaml dependency is unmaintained, RUSTSEC-2024-0449), so that cargo deny and cargo audit stay clean without exemptions.

Deserialize (parse a YAML document into a Value AST)

(serde_yml, yaml-spanned, serde-saphyr ship single-document APIs only — no apples-to-apples cell on the multi-document fixture.)

Serialize (emit a typed value to YAML)

Round-trip (deserialize + serialize)

Headline numbers

noyalib is faster than every Rust YAML library on every fixture measured. Speedup ranges:

Serialize: 3.00×–4.34× over serde_yaml_ng. Round-trip: 1.83× over serde_yaml_ng. The gap to yaml-rust2 is the narrowest because that library doesn’t carry the Spanned<T> plumbing, the per-tag Cow<'a, str> propagation, or the Value::Tagged preservation that noyalib does — paying for those costs is part of the engineering cost. Closing the remaining gap to ≥ 2× over yaml-rust2 runs through SemVer-breaking refactors (CompactString keys in Mapping, bump-arena event lifetimes, eliminating the Value AST on the typed path).

Typed deserialization (streaming, no Value AST)

from_str::<T> walks parser events directly into the typed target, bypassing the Value AST when the caller asked for a typed T. The streaming path bakes in YAML 1.2 semantics (<<: *alias merges natively, !!binary is propagated as a typed tag).

Why serialize is so far ahead

The serializer was built around itoa / ryu direct-write buffers (the fast-int / fast-float features) plus SIMD-driven quote-need detection that lets plain ASCII output emit borrowed bytes without escaping. serde_yaml_ng routes through fmt::Write and revalidates UTF-8 on output — that’s the source of the 3-4× gap.

Why deserialize against yaml-rust2 is closer

yaml-rust2 is a heavily-tuned parser that doesn’t carry the Spanned<T> plumbing, the per-tag Cow<'a, str> propagation, or the Value::Tagged preservation that noyalib does. The 1.12-1.35× gap reflects the engineering cost of those guarantees; yaml-rust2 is a good baseline because it’s the closest pure-Rust parser in feature shape. The path to ≥ 2× over yaml-rust2 on deserialize runs through SemVer-breaking refactors (CompactString keys in Mapping, bump-arena event lifetimes, eliminating the Value AST on the typed path).

Roundtrip (deserialize + serialize)

SIMD structural-discovery throughput

How fast each library can find every YAML delimiter in a 1 MiB real-shaped document. The structural-bitmask path replaces the classical “find one delimiter at a time” pattern with a 32-byte chunk that drains every delimiter via mask.trailing_zeros() before reloading. (benches/structural_bitmask.rs)

serde_yaml_ng and serde-saphyr use byte-by-byte structural discovery — they sit alongside the scalar baseline row and lose to the 32-byte-bitmask path by an order of magnitude on the 1 MiB workload.

SWAR decimal-integer parsing

Plain-scalar integer resolution via the SIMD-Within-A-Register pipeline that folds 8 ASCII digits per u64 cycle. (benches/numeric_parse.rs)

How the SWAR pipeline works

The standard library’s i64::from_str walks one digit at a time, branching on each character to validate it’s 0..=9 and folding into the accumulator with acc * 10 + digit. SWAR fuses this loop:

1. Load 8 bytes into a u64 register (one aligned mov).
2. Subtract b'0' lane-wise (sub_packed).
3. Validate every byte is < 10 via a single masked compare.
4. Combine the eight digits into a single integer with two multiply-and-add rounds (the 0x010A0064... constant pipeline).

The result is an 8-digit chunk consumed in 6 instructions instead of ~24, and i64::MAX (19 digits) parses in 9.75 ns versus 24.6 ns — a 2.5x speedup. The full pipeline is documented inline in crates/noyalib/src/simd.rs.

Every SWAR pipeline has a portable byte-by-byte fallback that Miri verifies under big-endian (mips64) so the byte-order assumption stays explicit.

Parallel multi-document throughput

Linear scaling across CPU cores for ----separated streams (telemetry logs, audit exports, Kubernetes-resource snapshots). Pre-scan runs in O(input_len) on the main thread; the per- document parse work distributes across the Rayon thread pool. (benches/streaming_vs_value.rs, benches/large_doc_soak.rs)

#![allow(unused)]
fn main() {
#[derive(serde::Deserialize, PartialEq, Debug)]
struct MyType { kind: String }
let yaml = "kind: a\n---\nkind: b\n";
// Single-threaded baseline:
let docs: Vec<MyType> = noyalib::load_all_as(yaml)?;

// Parallel (off by default — pulls Rayon under `parallel`
// feature). Drop-in replacement, scales near-linearly with cores
// on multi-document inputs:
let docs: Vec<MyType> = noyalib::parallel::parse(yaml)?;
assert_eq!(docs.len(), 2);
}

Other Rust YAML libraries the comparison table covers run single-threaded.

Architecture validation

Reproduce: make bench-compare (the comparison bench with the compare-saphyr feature, so serde-saphyr is in the same run) and cargo bench --bench architecture.

Head-to-head with serde-saphyr (2026-09-06)

serde-saphyr is the other pure-Rust crate that passes the full official test suite, so it is the comparison that matters. Same run, same host, same command, every crate in the same criterion session:

make bench-compare   # cargo bench --bench comparison --features compare-saphyr

Host: Apple A18 Pro. Toolchain: rustc 1.98.0 (88d9e12ae 2026-08-18). Times are criterion medians in the default bench profile (no LTO tuning), so they sit above the headline table’s tuned numbers; the ratios are what to read.

serde-saphyr does not appear on the multi-document fixture because its from_str reads one document. Rerun the command to refresh this table; the numbers above are reproducible to within criterion’s reported confidence intervals.

v0.0.6 feature benchmarks

Three additional bench arms cover the optional surfaces added in v0.0.6 (recovery, sval, tokio). Run together with:

cargo bench --bench v006_features --features recovery,sval,tokio

Project metrics