Tried the GenosDB demos and was genuinely impressed.
The real-time sync was instant across multiple desktop browsers, multiple tabs, and even mobile at the same time. I stress-tested the sample apps—chat, kanban, share-location, tic-tac-toe, todolist, and video streaming—and messages/updates landed fast and consistently. In several rounds of testing with multiple devices I didn’t hit downtime.
Who it’s for: devs building decentralized apps that need low-latency collaboration or live state (chat, boards, multiplayer toys, shared docs, location).
Why it stands out (from my tests):
No central server to babysit for real-time
Graph model feels natural for relationships/feeds
Demos felt production-snappy without tuning
Room to grow:
More security/permission recipes out-of-the-box
A bigger examples repo (auth flows, offline strategies)
Not affiliated—just a dev who loves fast real-time, If you’re into decentralized, give it a spin.
Examples: https://github.com/estebanrfp/gdb/blob/main/docs/genosdb-examples.md
Pros
Real-time updates felt instant across browsers/tabs/mobile
Graph model = intuitive relationships for modern apps
Worked reliably through repeated multi-device testing
Best for: real-time collab UIs, social graphs, multiplayer, shared state
Cons
Would love more docs on access control patterns
Needs more “batteries-included” examples for auth/offline
Curious to see formal benchmarks as the community grows
Not ideal for: teams needing a fully managed-centralized backend today
Because the demos synced instantly across multiple browsers, tabs, and mobile with zero hiccups in my tests. Easy to use and a lot of functions by default.
GenosDB doesn’t use an external SDK; it’s distributed as a minified JavaScript build ready for production. This build exposes a native, self-contained API that can be integrated directly into JavaScript projects without additional bindings or dependencies.
Migration isn’t directly comparable, since centralized graph databases and distributed systems operate on different principles. In GenosDB, data is transmitted granularly through edge ID lists, allowing each node to resolve connections independently. Instead of a centralized graph structure, it relies on decentralized data flow and autonomous entities.
GenosDB stores data using the OPFS (Origin Private File System) for fast, persistent, and sandboxed local storage, with a configurable debounced I/O (saveDelay) that batches writes to minimize disk access and boost performance.
I’ve been testing GenosDB for a while, and honestly, it’s a big step forward for local-first and P2P applications.
The API feels clean — using top-level await makes setup simple, and real-time synchronization between peers works flawlessly.
Modules can be activated just by passing a parameter, and since it’s imported only once, everything else loads asynchronously, giving a smooth and clean user experience.
For example:
const db = await gdb("mydb", { rtc: true })
I was impressed by how well it handles data persistence with OPFS and ephemeral events through db.room.
The data transfer speed between two tabs running in different browsers is very fast — I still want to run more tests, but it’s already impressive.
I haven’t tried all the examples in the repo yet, but synchronization, replication, and conflict resolution work efficiently in practice.
My conclusion: it’s stable and well-documented. Definitely worth checking out.
Great work, Esteban.
More examples of use
Because it uses the Nostr network for peer discovery and stores data in OPFS (Origin Private File System) for fast, persistent local storage.
Conflict Resolution System - Hybrid Logical Clock (HLC)
Utilizes OPFS (Origin Private File System) for high-performance, sandboxed, and persistent local storage directly in the browser.
Zero-Trust Security Model
I tested GenosDB with a focus on its query system, especially the .map() function. It’s well designed — you can perform both static and reactive queries using the same interface.
The reactive behavior works reliably, and updates propagate smoothly. The support for operators, filters, and recursive graph traversal through $edge is comprehensive and consistent.
Overall, the query engine feels stable and thoughtfully implemented. It performs as expected for a browser-based graph database, and it’s clear a lot of attention went into making it practical for real-world use.
I've never seen anything like it. The simplicity, ease of use, and the learning curve for querying that database is truly painless!!
Reliability and performance is very nice!
For internal use in my company, the performance is as expected.
Thanks so much, Lorenzo — really appreciate your thoughtful review and the time you spent exploring the query system.
For anyone curious about how querying works in GenosDB: the .map() method was designed to unify static and real-time querying through a single, consistent interface. You can perform snapshot queries or live subscriptions with minimal code changes:
GUNimport { gdb } from "genosdb"
const db = await gdb("my-db", { rtc: true })
// Real-time query: listen for active users and updates automatically
const { results, unsubscribe } = await db.map(
{
query: { status: "active", age: { $gte: 18 } },
field: "name",
order: "asc",
realtime: true
},
({ id, value, action }) => {
if (action === "added") console.log(`Node added: ${id}`, value)
if (action === "updated") console.log(`Node updated: ${id}`, value)
if (action === "removed") console.log(`Node removed: ${id}`)
}
)
// Stop listening when needed
// unsubscribe()Static mode (await db.map({ ... })) gives you an instant filtered dataset.
Real-time mode (with a callback) keeps your results synchronized automatically.
The query language supports advanced operators like $and, $in, $regex, and $edge for recursive graph traversal, which lets you fetch descendants dynamically across linked nodes.
Under the hood, GenosDB uses Hybrid Logical Clocks (HLCs) to keep events consistent and resolve conflicts deterministically — even when peers temporarily lose connection. Queries are evaluated locally on each peer, and real-time synchronization only exchanges deltas, which keeps performance smooth as data grows.
We’re expanding examples showing hybrid use cases of .map() with security modules (sm and ACLs) and multi-hop $edge traversal patterns — all designed for local-first, P2P-ready applications.
Thanks again, Lorenzo — your detailed feedback helps others understand what makes GenosDB’s graph engine different.
Esteban Fuster Pozzi (estebanrfp)
Thanks so much, Carlos — really appreciate your detailed review.
For anyone exploring GenosDB: one of its core ideas is modularity through asynchronous loading. Each capability — whether it’s real-time sync (rtc), security (sm), AI, or ACLs — can be enabled simply by passing a parameter. Once activated, the module loads independently and doesn’t block the rest of the app, keeping everything responsive even in the browser.
This pattern makes it easy to scale from a small local graph to a fully distributed, zero-trust network without changing your base code.
We’re also expanding examples regularly — showing modular combinations like rtc + Security Manager (sm), secure collaboration with ACLs, and real-time queries with db.map(). New implementations are rolling out constantly, so it’s worth keeping an eye on updates.
Thanks again for testing it so deeply — your feedback helps highlight what makes the system different.
Esteban Fuster Pozzi (estebanrfp)