danbitengo
Joined 11 months ago
Karma
46
Submissions
29
Member since
Nov 27
Recent submissions
Comment · 8 months ago
Comment · 8 months ago
Try it now: https://localwrite-demo.fly.dev
Open in two tabs, join a room, start typing. That's the pitch.
SyncKit is an offline-first sync engine. Rust core compiled to WASM, TypeScript SDK, works in any framework.
What's new since v0.1.0 (which some of you saw here 75 days ago):
- Live demo (LocalWrite) - collaborative editor you can try right now
- Rich text CRDTs (Fugue + Peritext) not just LWW anymore
- Live cursors and presence
- React/Vue/Svelte adapters
- Multi-language servers (TypeScript, Python, Go, C#)
- 2,100+ tests, formally verified with TLA+
The demo shows character-level sync, slash commands, a community Word Wall, and offline editing. Disconnect your network, keep typing, reconnect - it merges automatically.
Known limitations:
- SDK undo/redo not yet wired into the demo editor (browser native works)
- No E2E encryption yet
Security note on the demo: LocalWrite is a public collaborative space with no authentication. Rooms are accessible to anyone with the URL and so don't share sensitive or personal data. The server sees all content in plaintext. Rate limiting and input validation are in place, but there's no content moderation or identity verification. Treat it like a public whiteboard.
GitHub: https://github.com/Dancode-188/synckit
npm: @synckit-js/sdk
Happy to answer questions about the CRDT implementation, architecture, or anything else.
Comment · 10 months ago
Hey HN, I'm Daniel, creator of SyncKit.
I've been obsessed with the Ink & Switch "Local-First Software" vision for some time now—apps that work offline, feel instant, and give users control of their data. But every time I tried to build a local-first app, I hit the same wall: integration complexity.
The existing CRDT libraries (Yjs, Automerge) are incredible—they pioneered the algorithms that make local-first work. Kevin's optimization work on Yjs is masterful, and Automerge changed how I think about distributed systems.
But they're designed as modular primitives. You compose networking, storage, and conflict resolution yourself. That flexibility is powerful for complex systems, but it creates what I call the "Day 1 problem" for local-first: you spend 3 days wiring infrastructure before writing features.
I built SyncKit to solve this.
Different philosophy: Where Yjs gives you powerful primitives (build your own local-first stack), SyncKit gives you a pre-wired local-first database. Persistence, sync, presence—built-in, not plugins.
The technical approach: - Rust core with zero unsafe blocks (you can grep the codebase)
- TLA+ verified (explored 6.5M states to prove correctness)
- 154KB bundle (everything compiled together)
- 1,081 tests, 80 chaos tests
Performance: Competitive within 1-2ms of Yjs for standard ops. The win is local-first DX - one package that handles offline, sync, and conflict resolution.
What's included: - Rich text editing (Fugue algorithm for non-interleaving edits)
- Live cursors & presence
- Undo/redo (CRDT-native)
- IndexedDB persistence
- React/Vue/Svelte adapters
Built this in Nairobi, 9pm-3am. v0.1.0 got 601 stars in 3 weeks which honestly shocked me.
Try it live: https://synckit-demo.netlify.app GitHub: https://github.com/Dancode-188/synckit
Happy to answer questions about the TLA+ verification or the local-first architecture choices.
Comment · 11 months ago
That's a fair point. The description does assume some familiarity with local-first patterns. I'll think about how to make the "why you'd want this" clearer for people outside that space. I appreciate the honest feedback
Comment · 11 months ago
That's actually a really cool idea! Notes are just documents, so the sync model would work well. Hadn't thought about Obsidian specifically but I like it.
Oath is an open protocol for cryptographically signed human intent. Before an agent acts, it checks for an attestation:
oath attest --action "database:delete_records:project_alpha" \
oath verify --action "database:delete_records:project_alpha"# → ATTESTED proof: a1b2c3d4
If there's no attestation, the action is blocked. The interesting part: the absence of a signature is itself evidence. An agent can't claim it was authorized if there's no cryptographic proof that it was.
Security model: the private key never leaves your machine. The agent only calls verify, never attest. Attest is a human command. As secure as SSH key storage - same threat model, no central authority to compromise.
The repo has a working demo - an agent running 5 actions, 2 attested, 3 blocked — and a protocol spec at v1.0.0 (CC0, public domain). Anyone can implement the protocol in any language.
What's not there yet: multi-device sync and a Python package. Would appreciate feedback on the protocol design, especially the action class format (namespace:action:scope) and whether the signing model covers edge cases I haven't thought of.