Why PugDB?
Beating a KV on a public chart does not say whether a memoirs or RAG corpus survives restarts, failover, and months of ingest. PugDB exists for that second question — an embeddable Rust LSM with gates you can re-run.
What we actually prove
Evidence from the embed train and the server harness (snapshot 2026-08-22):
| Gate | Result | When |
|---|---|---|
| Crash-loop | 50× SIGKILL, 0 loss | 2026-08-17 |
| Soak 1h+1h | 1.66M cache ops, 10/10 anchors | 2026-08-18 |
| Meso 100k chunks | 100,050 / 100,050 after restart | 2026-07-24 |
| YCSB 10k (server) | 4.1× vs PostgreSQL · 2.63× vs ScyllaDB | 2026-08-22 |
* Full methodology on /bench. We do not pitch “faster than RocksDB”. Cluster remains lab.
Key Differentiators
Memory Safety
The Problem: Traditional key-value stores written in C/C++ are prone to memory safety issues: buffer overflows, use-after-free bugs, memory leaks, and security vulnerabilities.
PugDB's Solution: Built entirely in Rust, PugDB eliminates entire classes of bugs with compile-time safety, zero-cost abstractions, no garbage collection, and proven reliability.
Privacy-First Architecture
The Problem: Many storage solutions prioritize convenience over privacy: data sovereignty concerns, limited encryption options, no offline-first capabilities, compliance challenges.
PugDB's Solution: Privacy is built into the foundation with encryption support, audit logging, offline-first design, and local-first storage.
Modern Async/Await Design
The Problem: Legacy storage systems use outdated concurrency models: blocking I/O operations, thread-per-request models, limited scalability, complex error handling.
PugDB's Solution: Modern Rust async/await with Tokio: non-blocking I/O, excellent concurrency, clean error handling, and future-proof patterns.
Rust-Native Integration & Multi-Language Support
The Problem: Using storage solutions from other languages in Rust applications: FFI overhead and complexity, type system mismatches, limited integration options, performance penalties. For non-Rust developers, finding high-performance storage with good language bindings can be challenging.
PugDB's Solution: Native Rust implementation with zero FFI overhead for Rust developers, providing type safety, seamless integration, and optimal performance. For developers using other languages (Python, Go, C++, Node.js, etc.), PugDB provides C-compatible FFI bindings that enable integration from virtually any programming language, making high-performance storage accessible to everyone.
Target Use Cases
Embedded RAG / memoirs corpora
The GO path: C/Go FFI over the canonical LSM for chunked, prefix-scanned corpora that must survive process death.
Why PugDB: tagged embed train, 100k-chunk integrity after restart, crash-loop 0 loss. Not a generic cloud KV.
Single-server cache / session store
Session storage and application-level caching on one node — the soak harness we actually run.
Why PugDB: 1.66M cache ops at 462/s with 10/10 restart anchors. YCSB 10k numbers on /bench; we do not pitch RocksDB.
Edge Computing and IoT
Ideal for edge device local storage, IoT data collection and caching, offline-first applications, and resource-constrained environments.
Why PugDB: Small memory footprint, efficient resource usage, privacy-focused design, offline-first architecture, and cost-effective operation due to lower resource requirements.
Privacy-Sensitive Applications
Ideal for healthcare data storage, financial transaction caching, legal document management, and compliance-critical systems.
Why PugDB: Encryption support built-in, audit logging capabilities, local-first data storage, data sovereignty control.
Rust-Native Applications & Multi-Language Projects
Ideal for applications built in Rust (native integration) or other languages (via FFI), high-performance services, systems requiring memory safety, and modern async applications.
Why PugDB: Native Rust implementation with zero FFI overhead for Rust developers, plus C-compatible FFI bindings for Python, Go, C++, Node.js, and other languages. Type-safe integration, idiomatic APIs, and cross-language compatibility.
When to Choose PugDB
✅ Choose PugDB When:
- You need high-performance single-node key-value storage
- Memory safety is a priority
- Privacy and data sovereignty matter
- You're building in Rust
- You need offline-first capabilities
- Low latency is critical
- You want stable core features (beta)
❌ Consider Alternatives When:
- You need Redis protocol compatibility
- You require advanced data structures (Lists, Sets, etc.)
- You need Pub/Sub messaging
- You require enterprise RBAC and compliance features
- You need production-ready multi-node clustering (still in beta)
- You need production-ready persistent storage beyond memory (still in beta)