When operations complete in 200ns instead of blocking for microseconds/milliseconds on fsync, you avoid thread pool exhaustion and connection queueing. Each sync operation blocks that thread until disk confirms - tying up memory, connection slots, and causing tail latency spikes.
With FeOxDB's write-behind approach:
- Operations return immediately, threads stay available
- Background workers batch writes, amortizing sync costs across many operations
- Same hardware can handle 100x more concurrent requests
- Lower cloud bills from needing fewer instances
For desktop apps, this means your KV store doesn't tie up threads that the UI needs. For servers, it means handling more users without scaling up.
The durability tradeoff makes sense when you realize most KV workloads are derived data that can be rebuilt. Why block threads and exhaust IOPS for fsync-level durability on data that doesn't need it?
1- Session stores (can be reconstructed from auth service)
2- leaderboards/counters (recent scores/counters can be recalculated)
3- Real-time analytics/metrics (losing ~100ms of metrics is acceptable)
4- Caching layers with upstream persistence
5- High-frequency systems where latency > everything
I generally think that for KV stores, there are more use cases that can accept this _slightly_ relaxed durability model than not. of course this isn't the case for a main DB. KV stores often handle derived data, caches, or state that can be rebuilt.
That said, for cases needing stronger durability, you can call flush_all() after critical operations - gives you fsync-level guarantees. Also considering adding a "sync" or "Full ACID" mode that auto-flushes on every write for users who want strong durability.
The philosophy is: make the fast path really fast for those who need it, but provide escape hatches for stronger guarantees when needed.
Thanks! yeah, SQLite's write lock is painful for concurrent apps.
I'm comfortable with kernel development, so I brought some of those patterns here - RCU-style lock-free reads, per-CPU inspired sharded buffers, and io_uring for kernel-bypass I/O.
would love to hear your thoughts if you had the chance to give it a spin :)
One thing we'd like to know your opinion on, is our key monitoring via WebSocket (pub-sub) feature. You can read more about it in our documentation under WebSocket.
Is it something that you think it's useful and you might have use case for or you can't see any value in it? In other words, is it something that you might consider using HPKV because of it?
thank you :) it would be interesting to have a chat for sure. would you mind dropping an email on the email I mentioned in OP and I'll reach out to you.
We provide some elements of ACID guarantees, but not full ACID compliance as traditionally defined in database systems:
Atomicity: Yes, for individual operations. Each key-value operation is atomic (it either completes fully or not at all).
Consistency: Partial. We ensure data validity through our conflict resolution strategies, but we don't support multi-key constraints or referential integrity.
Isolation: Limited. Operations on individual keys are isolated, but we don't provide transaction isolation levels across multiple keys.
Durability: Yes. Our persistence model allows for tunable durability guarantees with corresponding performance trade-offs.
So while we provide strong guarantees for individual operations, HPKV is not a full ACID-compliant database system. We've optimized for high-performance key-value operations with practical durability assurances rather than complete ACID semantics.
> Consistency: Partial. We ensure data validity through our conflict resolution strategies, but we don't support multi-key constraints or referential integrity.
That's not what consistency means in ACID.
> Durability: Yes. Our persistence model allows for tunable durability guarantees with corresponding performance trade-offs.
> ~600ns p50 for writes with disk persistence
I'm pretty sure there's no durability there. That statement is pretty disingenuous in itself, but it'd be nice to see a number for durability (which, granted, is not something you advertise the product for).
My main concern is that all these speed benefits are going to be eclipsed by the 0.5ms of network latency.
of course. the speeds down to 15us can be achieved over network over our custom protocol on the same region. for sub-microsecond latency, you need to have HPKV running on the same machine as yours :)
thanks for taking time and commenting :) we'd still be happy if you decided to use it and give us your thoughts. as I mentioned in one of the comments below, we're hoping to go open source in future :)
Let me know when it's open source and I'd be happy to give it a try! It doesn't even have to be free - I'm fine with Unreal's model where you get access to the source even though commercial use requires a paid license.
I want something running locally on my machine that doesn't rely on calling home.
Give me one reason to use a closed-source Redis alternative rather than one of many open ones, starting with KeyDB. If I wanted a closed clone, I'd probably go with DragonflyDB (whose license is "feel free to run it in production unless you offer it as a managed redis service").
Test was done using Redis benchmark for 1M random keys, 50 clients, Pipeline depth, 64.
I did this locally on my MBP M3-Max. This gives a little over 2M for Redis and 5.4M for Feox.
redis-benchmark -n 1000000 -r 1000000 -c 50 -P 64 -t SET,GET -q
https://x.com/mltoosi/status/1963599382592590069?s=46
Feox DB itself (the embedded KV behind the server) is quite fast as well. You can also test for yourself or see the criterion benchmark report.
https://feoxdb.com/benchmarks.html
<700ns INSERT and <200ns GET on Feox DB itself.