ankuranand
``` writer -> gRPC stream -> replica ```
A writable node owns the WAL. A replica connects over gRPC. The writer streams log records. The replica applies them in order.
We have added a a second replication path inside the Unisondb:
``` writer -> blob store -> replica ```
Project Repo: https://github.com/ankur-anand/unisondb
Looking forward to feedback and suggestions.
Isledb: Database Built on Object Storage
Show HN: KV and wide-column database with CDN-scale replication
It uses WAL-based replication with B+Tree storage to fan out writes to 100+ edge nodes in sub-second latency. Every write is durable, queryable, and instantly available as a replication stream.
Built for Edge AI and distributed systems where data needs to live close to computation. Supports: - Multi-model storage (KV, Wide-Column, LOB) - Atomic multi-key transactions - Real-time change notifications - Namespace isolation for multi-tenancy
We benchmarked it against BadgerDB and BoltDB using redis-benchmark — results in the README show competitive write/read throughput with consistent replication performance even at 100+ concurrent relayers.
Open source (Apache 2.0): https://github.com/ankur-anand/unisondb
Would love feedback on the architecture and use cases!
Show HN: UnisonDB – B+Tree DB with sub-second replication to 100+ nodes
Show HN: Unisondb A open source streaming multimodal database for Edge Computing
https://github.com/ankur-anand/unisondb
Hi everyone — I’m the developer of UnisonDB, an open-source log-native database built in Go for distributed and edge-scale systems.UnisonDB rethinks the boundary between databases and streaming systems. Instead of treating the Write-Ahead Log (WAL) as a recovery mechanism, it treats the log itself as the database. Every write is immediately durable, queryable, and replicable — without Kafka,...
Show HN: UnisonDB – Replicates like a message bus. Acts like a database
https://github.com/ankur-anand/unisondb
Hey Folks, I’ve been experimenting with an idea that combines a database and a message bus into one system, for a system that need colocated state at the edge.Every database already has a log—the Write-Ahead Log. It's durable, ordered, and append-only. It's literally what you'd build if you were designing a message queue. So I asked: what if we just replicate the log itself? UnisonDB is...
I’ve been experimenting with an idea that combines a database and a message bus into one system — built specifically for Edge AI and real-time applications that need to scale across 100+ nodes.
Most databases write to a WAL (Write-Ahead Log) for recovery.
UnisonDB treats the log as the database itself — making replication, streaming, and durability all part of the same mechanism.
Every write is: * Stored durably (WAL-first design) * Streamed instantly (no separate CDC or Kafka) * Synced globally across replicas
It’s built in Go and uses a B+Tree storage engine on top of a streaming WAL, so edge nodes can read locally while syncing in real time with upstream hubs.
No external brokers, no double-pipeline — just a single source of truth that streams.
Writes on one node replicate like a message bus, yet remain queryable like a database — instantly and durably.
GitHub: github.com/ankur-anand/unisondb
Deployment Topologies
UnisonDB supports multiple replication setups out of the box:
* Hub-and-Spoke – for edge rollouts where a central hub fans out data to 100+ edge nodes
* Peer-to-Peer – for regional datacenters that replicate changes between each other
* Follower/Relay – for read-only replicas that tail logs directly for analytics or caching
Each node maintains its own offset in the WAL, so replicas can catch up from any position without re-syncing the entire dataset.
UnisonDB’s goal is to make log-native databases practical for both the core and the edge — combining replication, storage, and event propagation in one Go-based system.
I’m still exploring how far this log-native approach can go. Would love to hear your thoughts, feedback, or any edge cases you think might be interesting to test.
UnisonDB – A Log-Native Database for Edge AI and Edge Computing
Show HN: UnisonDB – Log-native KV database that replicates like a message bus
Hi HN,For the past few months, I’ve been building UnisonDB — a log-native database where the Write-Ahead Log (WAL) is the database, not just a recovery mechanism.I started this because every time I needed data to flow — from core to edge, or between datacenters — I ended up gluing together a KV database + CDC + Kafka.It worked, but it always felt like overkill: too many moving parts for even...
From O(n) to O(1): Expiring 10M TTL Keys in Go
The naive approach — scanning every key every second — works fine at small scale but collapses once you hit millions of entries.
So I implemented a Timing Wheel in Go — the same idea used in Kafka, Netty, and the Linux kernel — replacing the O(n) scan loop with an O(1) tick-based expiration model.
Here’s what I found when comparing both approaches at 10 million keys:
Avg Read Latency: • Naive Scan → 4.68 ms • Timing Wheel → 3.15 µs
Max Read Stall: • Naive Scan → 500 ms • Timing Wheel → ≈ 2 ms
At that scale, the naive loop stalls reads for half a second. The timing wheel glides through them in microseconds.
GitHub repo: https://github.com/ankur-anand/taskwheel
There are situations where you do not want to parse the JSON, but do want to ensure that the JSON is not going to cause a problem. Such as an API Gateway. It would be a PITA for the gateway to have to know all JSON schema of all services it is protecting. There are XML validators that perform similar functions.
A high-performance, zero allocation, dynamic JSON Threat Protection in pure Go
Microservices are hard Build boring stack first
Given the hype for microservices, it's ok to become crazy about it and copy questions of why/what of likes of Netflix/Uber, etc. But at the same time, you need to understand A Netflix/Uber style microservices aren't required by (most?) org. They build it because they understand the domain they’re working in and knows their answers to how. Your approach to building one, without understanding...
Illustrated Tales of Go Runtime Scheduler
Illustrated Tales of Go Runtime Scheduler
How to Mock? Go Way
How to mock in your Go (Golang) tests
How to mock in your Go (Golang) tests
An introduction to 99 percentile for programmers, With example in Go
JSON requests are susceptible to attacks characterized by unusual inflation of elements and nesting levels. Attackers use recursive techniques to consume memory resources by using huge json files to overwhelm the parser and eventually crash the service.
JSON threat protection is terms that describe the way to minimize the risk from such attacks by defining few limits on the json structure like length and depth validation on a json, and helps protect your applications from such intrusions.
JSON threat protection is terms that describe the way to minimize the risk from such attacks by defining few limits on the json structure.
Yes It also validates the json.
JSON threat protection is terms that describe the way to minimize the risk from such attacks by defining few limits on the json structure.