About

I work on storage engines, execution runtimes, and distributed systems where correctness and performance are determined by IO paths, scheduling, and recovery behavior.

Some things that I’ve built(or am building)

Frigatebird: Embedded columnar SQL database with vectorized query execution rust

  • Columnar SQL database optimized for scan-heavy analytical workloads
  • Push-based Volcano execution model with morsel-driven parallelism and vectorized pipelines
  • Late materialization: filters operate on column IDs first, materializing projection columns only for surviving rows (up to ~70% less data loaded)
  • Vectorized filtering with bitmap operations and dictionary encoding for low-cardinality columns
  • Three-tier caching: hot (uncompressed) → warm (compressed) → cold (disk)
  • WAL-backed durability with multi-phase commit and io_uring + O_DIRECT for predictable IO

SatoriDB: Embedded vector database for billion scale ANN search rust

  • Two-tier architecture: HNSW routing in RAM → cold storage on disk
  • 95%+ recall with predictable latencies via cluster rebalancing
  • Shared-nothing, CPU-pinned executors with io_uring and SIMD
  • Zero allocations on the hot path

Walrus: Distributed Log streaming engine rust

  • Raft consensus for metadata, segment-based sharding, automatic leadership rotation
  • sustained ~1.2M writes/sec on consumer SSDs, outperforms single-broker Kafka and RocksDB WAL
  • Lease-based write fencing, sealed segment reads from any replica
  • Formal TLA+ spec verifying single-writer-per-segment and cursor bounds

Octopii: Distributed systems kernel for building replicated, fault-tolerant services rust

  • Raft consensus (OpenRaft for production, raft-rs for simulation)
  • Custom WAL with two-phase commit and dual-topic durability model
  • QUIC transport (Quinn) with multiplexing and connection pooling
  • Deterministic simulation testing: controlled time, seeded randomness, VFS with fault injection
  • Multi-cycle crash recovery validation with invariant checking (DST-style)
  • Powers Walrus for distributed coordination

Nubmq: In-memory key-value engine go

  • 100k+ ops/sec with ~900µs writes, ~500µs reads
  • Dual-engine architecture: auto-scales shards, migrates keys in background, non blocking architecture
  • TTL, pub-sub, zero dependencies

What I do now

Currently I help build Stream, mainly focused at distributed systems work on high-fanout messaging, internal storage paths, and operational behavior under load.

What I used to do

I spent 4 years working at various startups including the likes of Browserstack working on backend systems on large-scale distributed testing infrastructure.

Philosophy

I work on storage and runtime systems where behavior is determined by IO paths, memory layout, scheduling, and failure semantics. The focus is on explicit mechanisms, minimal abstraction in hot paths, and designing for recovery and backpressure from the start.

Get in Touch