fsync

Crash-consistency explorer: enumerates every disk state a power loss can leave behind, runs your checker on each, and names the missing fsync. Rust library + CLI (strace).

From-scratch Raft consensus in Go: leader election, log replication, and crash-safe persistent term, vote, and log

fsync() implementation for the Linux Kernel CIFS filesystem.

An embedded key-value store whose durability is observed by a simulated disk, not asserted

WALRUS A thread-safe, crash-resilient, append-only binary log engine in C with durable writes, checksum-based recovery, and O(1) indexed reads.

Test that your files survive a power cut — a pytest plugin that rebuilds the disk states a power cut could leave behind.

Benchmark Synchronous Group Commit

Crash-safe atomic file replacement for C on Linux and OpenBSD. Handles all seven write-temp-then-rename failure modes. Zero heap, zero dependencies.

A durable, high-throughput write buffer for Rust - microsecond fsync'd acks over a Unix socket, N→1 batched commits to your database, and crash-safe WAB replay.

Durable disk-backed FIFO byte queue for Go: fsync-on-append with group commit, at-least-once delivery via explicit commit, byte-bounded backlog, and checksummed frames whose corruption is always reported, never silent

Can this server lose data? Checks the data, the backup and the restore: backup on the same disk, snapshot missing a database, backup never restore-tested. Consistent SQLite copies, restore test. One static Go binary and two small libraries.

Atomic file writes with the parent-directory fsync that popular libraries leave out.

Write files atomically and durably from Go, so a crash never leaves a partial file

Zero-dependency WAL for durable Node.js process restarts.

ProFTPD module for configuring fsync(2) usage

Atomic durable file replacement for Node: fsync discipline so a crash never leaves a 0-byte file

rust crate for durability evading crash and powercut dataloss

Plain-file persistence for Python with explicit guarantees: atomic visibility, crash durability, cooperative locks, checksums, runtime diagnostics, and small TLA+ protocol models.

Syncing files accross directories and devices.

A Go worker pool killed with SIGKILL mid-run, measured. It lost nothing with fsync off - which cost between 202x and 1,222x throughput and prevented none of the loss it is credited with.