Blog
Topics for Founders, Operators, and the Terminally Overwhelmed
KEIBIDROP Series
Engineering write-ups on the project. The product pages for KeibiDrop, including install, documentation and the guides for specific workflows, are at keibidrop.com.
Reading a File Changes Its atime on macOS (August 2026)
Linux lets a program open a file with O_NOATIME so the read leaves the access time alone, and Windows has a handle-level equivalent. macOS has neither, so the mount decides. We measured it on APFS while setting up a remote triage rig: a 4 KB read moved the access time on a plain data volume, and held it on a disk image mounted noatime, including across a sha256 of all 24 files in the set. The post has the three commands, the measurements, the way to create and remount the volume, and what the condition means for anyone handling material where access times carry meaning.
4 min read
A Version Is Not Its Bytes (August 2026)
The two-peer editing branch is merged. The last two recorded gaps closed themselves in the field: CI's two-core runners exposed that a machine has two clocks, the fine one code reads and the coarse one the filesystem writes, and an announcement built from the wrong one understates its author until both peers reject each other forever. The identical-timestamp case we expected never to see appeared twice. Then the production relay's own reachability probe killed room creation on the first real-internet run, and a peer overwriting a file whose bytes it never fetched could destroy the only copy: the announced base now declares the newest version the writer actually held, and a third model checker proves no interleaving loses data. Fourteen scenarios green on macOS, Linux, and Windows, and edits converge cross-country in about 0.6 seconds.
5 min read
Editors Don't Edit Files (August 2026)
We traced how programs actually save on a KEIBIDROP mount: vim renames a temp file over the target, GIMP truncates and rewrites in place, Sublime builds its copy on another filesystem and copies it back. Almost nothing edits bytes inside a file; programs replace files. Then we ran every scenario in both directions and made concurrent edits survive: every announcement carries the version the edit was based on, so a stale save is provable without ever comparing clocks across machines, and the losing version is preserved as a conflict file on both peers. A save that changed 1 MiB of a 24 MiB file re-transfers 128 KiB, and the bugs on the way included a writer whose own mount showed an empty file and two conflict copies that overwrote each other.
5 min read
More Test Code Than Product Code (July 2026)
0.4.0 part one is on main: continuous key rotation, a QUIC lane urgent reads own, migration across network changes. With it the repository crossed a line we care about: 27,107 lines of test Go against 26,538 of product Go. The full subsystem map with links into the source, what the bindings really are, why the crypto looks small, and what "verified" means: 102/102 soak cycles byte-perfect between Romania and Singapore, and deterministic reproductions for races the race detector cannot see.
3 min read
You Can't mmap a Database Over a Network Filesystem (July 2026)
We put a pijul repository on a KEIBIDROP mount: cloning through the mount works, pulling an update recorded after the clone does not. Pijul's pristine is a single mmap'd B-tree rewritten in place, and mmap has no cache coherence across two kernels. NFS documents the same wall, SQLite and LMDB warn against it outright, and git dodges the whole class by design with immutable objects. The four known fixes and their prices, and the one we are building: region invalidation by chunk hash.
4 min read
Rekey While the Video Plays: Key Rotation Across TCP and QUIC (July 2026)
KEIBIDROP 0.4.0 replaces the re-handshake rekey with an in-band ratchet: each direction rotates its own key inside the data stream, no round trip, and the QUIC lane now rotates and folds alongside TCP. Measured on loopback with rotation forced every 1 MiB: 63 rotations inside a 64 MiB on-demand stream, with reads that crossed a rotation at p50 2.36 ms against 2.18 ms for reads that did not; Blu-ray-paced playback across 9 rotations with zero underruns; bulk within noise of baseline. Also the test that reported zero rekeys because the data had moved to a lane the observer could not see, four teardown races the merged test suite caught, and why the post-quantum fold does failover across lanes instead of duplication.
9 min read
gRPC over QUIC: Faster Seeks, Slower Bulk (July 2026)
Testing whether to move KEIBIDROP's gRPC transport from TCP to QUIC, ahead of 0.4.0. On macOS the QUIC path is syscall-bound (no UDP GSO, one sendmsg per 1400-byte packet, 57% of the CPU in send and receive); the undocumented Darwin sendmsg_x syscall lifts it from 390 to 700 MB/s by batching. A teardown deadlock traced to calling Stream.Close concurrently with a Write, fixed with CancelWrite. Connection migration survives an IP change, checked with per-socket packet counters. On a real Barcelona to VPS link QUIC bulk runs 3 to 16 times slower than TCP under Wi-Fi loss, but a random seek under saturating prefetch lands in 109 ms on QUIC against about 3 seconds on TCP, because the seek gets its own stream instead of queuing behind the prefetch.
10 min read
Talk: Post-Quantum Encrypted P2P File Transfer (Pass the SALT 2026)
Conference talk at Pass the SALT 2026 in Lille. A walk through the KEIBIDROP architecture: the hybrid post-quantum handshake, the on-demand FUSE filesystem, the two latency boundaries (block size on the same machine, round-trip time across the world) and how we hide them, how an edit propagates, and the open problems that remain.
Watch the recording · Slides (PDF) · Talk page
35 min talk
KEIBIDROP in plain language
Non-technical guides on what KEIBIDROP does and how to use it: sharing large files, streaming video from another device, using your programs on files from another computer, and more.
100,000 Files: What Eager Metadata Costs (June 2026)
KeibiDrop announces every shared file to the peer up front. Measured at 100,000 files: 24.6 s to index and announce (about 4,000 files/s), the peer holds the full index in 60 MiB (~270 bytes per file), byte-perfect, and the metadata arrives concurrently so there is no extra wait. Over a real 17 ms WAN (Intel Mac in Iasi to a VPS in Timisoara, mount to mount on demand) the same 100,000 land in about 72 s — most of it the sharer's own file writes, the metadata riding along — and any file then opens on demand in 30 to 40 ms. Cold-path git over the same mount stays sub-second. Why this beats per-open lazy fetches, and why the obvious byte-saving optimization would not make it faster.
5 min read
Smooth On-Demand Playback Over 200 ms (June 2026)
The Singapore link made a full-speed on-demand read fast (22 to 30 MB/s), but a video player reads at its bitrate, not at full speed, so it still froze for a round trip at every 16 MiB boundary. Predictive read-ahead keeps the next blocks buffered ahead of the playhead. A cold 3 MB/s paced playback went from 5 freezes (2.6 s frozen) to 0 on the Windows mount, and 13 to 1 on Linux. Plus why FUSE reads arrive out of order, and a stale binary that almost hid the result.
7 min read
KEIBIDROP Footprint: Memory and Binary Size (June 2026)
What the daemon and app cost at rest and under load. The engine idles at about 13 MiB; resident memory grows with the number of files tracked (0.68 KiB per file with no FUSE, 0.84 to 2.55 KiB with the mount up), not with data moved, so 300,000 files cost about 214 MiB with no mount and up to 761 MiB with FUSE. A 1 GiB transfer holds a flat working set of 102 to 169 MiB. On disk, one statically linked 20 MB binary, with downloads of 19 to 35 MB per platform.
5 min read
Romania to Singapore: KEIBIDROP Over 330 ms (June 2026)
A Windows test box in Singapore, measured from Romania at about 200 and 330 ms over the bridge. 30 to 38 MB/s into the box, 13 to 25 MB/s out, 6.3 s to connect (almost all a failed IPv6 dial before bridge fallback), FUSE on-demand first byte under 1.5 s. What the numbers say about round-trip time, the send path, and Windows FUSE, plus three bugs the box found.
6 min read
PostgreSQL Across Two Machines, Byte-Perfect (June 2026)
The cross-machine database handoff over a cold P2P FUSE mount now round-trips byte-identical: 1000 rows written on a Linux VPS, read on macOS with a matching md5, all fetched on demand. The three bugs in the way: data races on file metadata found with the race detector, git's atomic renames not propagating (the "bad object HEAD" failure), and silently dropped notifications. Plus git-LFS at 3.6 GB, 0 corrupt.
9 min read
KEIBIDROP v0.3.0
Persistence, resumable downloads, presence, and five platforms. Saved files browser, Bonjour discovery, unshare, disconnect detection, iOS background notifications. CLI at full parity. Critical relay fallback bug fixed.
4 min read
Benchmark Matrix: Loopback, WAN, WiFi, and iOS (May 2026)
662 MB/s loopback (50% faster than March), 55 MB/s laptop-to-VPS (88% wire saturation at 500 Mbps), 47 MB/s iPhone-to-laptop over WiFi, 43 MB/s through Timisoara bridge. FUSE-over-WAN at 22.5 MB/s (macOS) vs 7.9 MB/s (Linux). gRPC HTTP/2 window tuning and push-based StreamFile RPC.
8 min read
Architecture Map: From Raw TCP to Encrypted Virtual Filesystem
The complete architecture reference. Identity tiers, hybrid post-quantum handshake, dual-TCP encrypted channels, relay privacy, FUSE evolution from minimal to production, transport stack diagrams, cross-platform matrix, and every source file linked.
18 min read
KEIBIDROP v0.1.0
Source code public, binaries for macOS (arm64 + x86_64), Linux, and Windows. Post-quantum encryption, FUSE virtual filesystem, LAN discovery, bridge relay. Three interfaces: desktop UI, interactive CLI, and JSON daemon for scripts.
5 min read
Building Post-Quantum Encrypted File Sync
The full technical overview. 7,000 lines of Go, 140 hours, and lessons learned building a cross-platform encrypted file sync tool with ML-KEM and X25519.
6 min read
FUSE Disconnect and Reconnect: Six Bugs in One Session
Why cgofuse can only mount once per process, and how we fixed disconnect hangs, reconnect failures, and context cancellation races in a single debugging session.
10 min read
Debugging FUSE Deadlocks on Intel Macs
How lock ordering and brief-lock patterns saved us from frozen filesystems. pprof, structured logging, and the Intel vs M1 difference.
8 min read
Hybrid Post-Quantum Encryption for gRPC
ML-KEM + X25519 handshake, custom gRPC transport credentials, 3ms overhead. Defense in depth applied to cryptography.
10 min read
Cross-Platform File Sync: The Hidden Complexity
macOS atomic saves, Windows mandatory locking, 47 Linux distros. The sync state machine and why you should budget 3x the time.
9 min read
Building KEIBIDROP While Burned Out
127 commits, 60 hours, 9 months. Sustainable development after burnout. Small progress is still progress.
7 min read
The Write/Release Race Condition
When the kernel closes your file mid-write. Timestamp debugging, RWMutex discipline, and knowing when lock rules apply.
8 min read
10x FUSE Performance via Block Size Tuning
One line changed st_blksize from 4KB to 2MB. 300 MB/s became 3,400 MB/s. Empirical systems engineering.
7 min read
Making Git Work Inside a FUSE Filesystem
mmap, fsync races, fcopyfile quirks, and per-file direct_io. Five bugs, five fixes, git works.
9 min read
Why macOS Preview Can't Read Your FUSE Files
Three-layer debugging: sandboxing + Gatekeeper + mmap. Each fix alone does nothing. All three required.
8 min read
Privacy-Preserving P2P Discovery: How the Relay Works
Dual key derivation, encrypted registration blobs, and why the relay sees nothing. Room passwords, lookup tokens, and the privacy model.
8 min read
Forward Secrecy: Automatic Key Rotation During Sessions
Rekey after 1 GB or 1M messages. Hybrid ML-KEM + X25519 rekey protocol. Counter-based nonces with direction prefixes.
9 min read
Building a CLI for AI Agents
The kd tool: daemon + Unix socket, JSON output, direct function calls. How to build CLI tools that AI agents can actually use.
7 min read
Testing P2P Systems Without External Dependencies
Mock relay, TestPair harness, dynamic ports, cgofuse one-mount workaround. 36 integration tests in 139 seconds, all self-contained.
8 min read
Optimizing Encrypted P2P Transfer: From 225 to 452 MB/s
Layer-by-layer benchmarking and six optimizations. Cipher caching, combined TCP writes, in-place decryption, async cache writes, push-based streaming, and the irreducible 51% FUSE overhead.
8 min read
Cutting 29% CPU from the Encrypted Transport
CPU profiling found 29% of time in memmove, not encryption. Replacing bytes.Buffer with direct slice handoff and adding sync.Pool pushed PullFile throughput to 623 MB/s. ~30 lines changed.
8 min read
Adding AES-256-GCM with Hardware Acceleration
Automatic AES-NI detection and cipher negotiation. Encrypted gRPC throughput from 442 MB/s to 490 MB/s (+11%). Same wire format, domain-separated key derivation, ~80 lines of new code.
8 min read
Benchmarks vs croc, wormhole, LocalSend, and scp
Localhost loopback benchmarks with all tools built from source. KeibiDrop gRPC: 442 MB/s. croc: 153 MB/s. wormhole: 126 MB/s. LocalSend protocol: 612 MB/s. Cipher isolation and overhead breakdown included.
10 min read
Git Clone Between Two FUSE Peers: The Last Puzzle Piece
Eight bugs fixed to make git clone, commit, and checkout work between encrypted P2P FUSE peers. Rename races, pack file truncation, kernel cache poisoning, notification flooding, LFS corruption, and cache coherency.
14 min read
How File Descriptor Recycling Broke PostgreSQL on FUSE
POSIX mandates lowest-available fd. In a concurrent FUSE handler with 224 files created per second, fd numbers collide constantly. 50% data loss during initdb, fixed with opaque handle IDs.
8 min read
Benchmarks, April 2026: Encrypted Throughput and PostgreSQL on FUSE
1,707 MB/s encrypted channel, 585 MB/s file transfer, 1,130 MB/s FUSE writes. PostgreSQL runs with full ACID on the FUSE mount. 75.8% POSIX compliance. Honest numbers from two machines.
10 min read
Cross-Peer PostgreSQL: Iasi to Timisoara Over Encrypted P2P
977 files synced in real time between an Intel Mac and a Linux VPS. PostgreSQL initdb, 15,000 rows, VACUUM ANALYZE. It almost worked. One notification timing bug remains.
10 min read
Security Leadership & Strategy
NIST RMF Roles for Startups: Who Does What
How to assign NIST RMF roles across 5 or 50 people. Which roles must never be combined. How two acquired companies handled separation of duties.
10 min read
Building Trust Between Entities: A Philosophy for Security
What trust means in business relationships. Sun Tzu, Richard Stallman, NIST trust models, and practical lessons from security questionnaires and acquisitions.
8 min read
Why Startups Need a Fractional CISO
Senior security expertise without the full-time cost. When it makes sense and what you actually get.
4 min read
Compliance & Operations
ISO 27001 in 90 Days: A Realistic Guide
How to get certified fast without cutting corners. A practical timeline based on real experience.
5 min read
How to Survive Your First Security Questionnaire
Security reviews don't have to be chaos. What B2B startups need to know before they open that spreadsheet.
3 min read
Your SaaS Demo Broke. Again. Time to Fix It.
If your product keeps crashing during sales calls, it's not "bad luck." It's infra debt. You need to stabilize it so you can stop sweating during Zoom calls.
2 min read
Engineering & Architecture
Lean Terraform, Part 1: Modules Are Logic, tfvars Are Input
Modules should not know that production exists. Why every environment fact belongs in tfvars, with real module code, typed inputs, and the name-to-ID rule that holds it all together.
9 min read
Lean Terraform, Part 2: State and Environments
One state file per environment, chosen at init. Why workspaces are the wrong tool, why the state key is the input you cannot get wrong, and how to clear a stale lock without fear.
8 min read
Lean Terraform, Part 3: The Layer Around the Code
Drift, taint, and silent provisioning failures. Terraform describes the destination, not the journey, and the journey is where the outages live. What a runbook is actually for.
8 min read
Lean Terraform, Part 4: What Sprawl Actually Looks Like
Field notes from two repos. One had 1,400 Terraform files, 59 modules and four separate bastions. The other had no infrastructure code at all. Why both failed the same way, and the freeze-then-change move that fixed one of them.
8 min read
Post-Quantum Cryptography in Practice: ML-KEM + X25519
How KeibiDrop uses ML-KEM-1024 + X25519 hybrid key exchange for post-quantum security. What we use, what we don't use yet, and why hybrid.
4 min read
Detect Security Issues Fast: A Practical DevSecOps Guide
Learn how to integrate security into your CI/CD pipelines using automated scans and best practices based on the OWASP DevSecOps guidelines.
8 min read
Notes on Cryptographic Primitives
Benchmarks and tradeoffs: availability, integrity, and confidentiality of files.
10 min read
go-fp in Production: Metaprogramming + Functional Composition
XSD code generation meets go-fp. 113 generated files, 13 catalogue types, 1 generic function. How we handle healthcare data imports for Romania's national health system.
7 min read
Algorithms & Complexity
The MST Problem: Three Subproblems to Linear Time
Decomposing the famous open problem into three independent targets. Pointer machines, approximate union-find, density partitions, and cycle hierarchies. From my 2018 master's thesis at DIKU.
12 min read