If you’ve checked out any of my past writing, you know I change my mind a lot—especially in crypto. That world moves fast and throws you curveballs, and I’ve felt them all. My first step in was a Facebook post about XRP in 2017. I put in a little money, rode the wave, and like everyone else, briefly daydreamed about quitting my job. Didn’t happen, but something stuck. Since then, I’ve been through hype cycles, halvings, midnight whitepaper rabbit holes, Telegram drama, protocol deep-dives—literally every exchange and experiment. Watched SushiSwap launch, felt the rush, built dApps, chased high-risk leverage trades, fried some hardware, lost wages in quick liquidations. My mood swung wildly—sometimes I believed, other days I was sure it was all smoke and mirrors. My views shifted as fast as the crypto charts on my screen. I kept learning, kept building. In 2019, I started a construction company. Then the pandemic hit, and suddenly I had extra time to code. By 2021, things seemed off. Everyone called it “decentralized,” but the reality pointed back to massive companies and total choke points. The degens got quiet, innovation slowed, and I just got bitter—even as I tested every new dApp, read every whitepaper, and saw the space drift right back toward centralization dressed up as progress. Honestly, personal chaos gave me space to think. Watching my kids grow up, it hit me—no one’s coming to shield them from a future full of surveillance and control. That lands like a punch. Couldn’t rely on someone else’s opinion anymore. Had to figure it out and build what I needed. So almost four years ago, I went all in. I stopped trading time for a paycheck, gave up a lot, and just started building. At first, I wanted to ship a dApp for some quick upside—but it turned into tackling deeper problems nobody else cared about. The stack was broken. Dependencies, languages, crazy complexity—each roadblock forced me to start over. I stopped building on the broken stuff and started rebuilding everything. Created a universal, interoperable language for better compute models. Filled gaps where nothing existed. It started as fixing one piece and grew into trying to build a new kind of internet—one that could run locally, deterministically, and didn’t need cloud intermediaries every second. Honestly, it felt lonely. I’m just a carpenter, not some PhD. Pushed through doubts and moments when the outsiders weren’t taken seriously. Ran into walls, restarted, swore at bugs—but something deeper kept me stubborn. The wins? Small validations: random GitHub stars, good LLM conversations, early prototypes that actually worked. Things picked up speed. This wild ride has taught me way more about resilience and chasing truth than about code. Sold tools, survived rough times, made exactly zero dollars from the actual code. When things got brutal, I went submarine mode—learned to operate quietly, listen to my gut, ignore distractions. There’s no backup plan. I just won’t accept a future full of extraction, surveillance, and control—for my family or anyone else. Maybe this system looks like a ticking bomb to me and a dud to others. Either way, I know this: better systems are possible. We don’t have to hand over control, money, and power. Nobody’s coming to save us—but some people see the stakes, and they’ll help push this uphill. If you’ve read this far, thank you. Sometimes, a single comment or view kept me moving forward. This isn’t about money anymore. The dual license reflects that—free for personal use, research, and non-commercial work (just give credit), and protects against things I honestly don’t want. It’s about drawing a line in the sand about what should never be normalized. The Meat and Potatoes: DLDSS v2.0 and the Rise of Sovereign AI So here’s the big piece: I built and released a working proof-of-concept. It flips a core idea on its head—**you don’t need servers, backends, or constant cloud to maintain shared, real-time, deterministic application state**. It’s called the **Deterministic Local DAG State System (DLDSS)**. There’s a live demo right now—no login, no account, no infrastructure. Try it: Just open https://xhecarpenxer.github.io/message-demo/ in a few browser tabs (or on different devices). Start sending messages. Everything stays perfectly in sync. What Is DLDSS? DLDSS is a client-native architecture. It tracks all app state as an append-only Directed Acyclic Graph (DAG) of immutable events. These events get stored locally and sync across tabs (or devices) using browser stuff like BroadcastChannel and, optionally, WebRTC DataChannels. - Determinism: With the same events, every instance ends up with the exact same state through strict ordering and replay. - No mutable objects—state comes from replaying the event log. - Auditability: Full history is the source of truth. - Offline-first and serverless: Works totally fine without network or third-party services. Inside a device (multiple tabs): Uses localStorage and BroadcastChannel for instant sync. No server at all. Across devices (P2P in v1.1+): Manual WebRTC signaling (copy/paste offer/answer, no signaling server). Events flow direct, the DAG syncs. Origin badges tell you if messages came locally, through BroadcastChannel, or over P2P. Conflict Handling Without CRDTs or OT DLDSS doesn’t merge or overwrite. It preserves all events and imposes a strict deterministic order (timestamp + authorId). Conflicts live side by side in the log—identical outcomes for everyone, no data loss, full audit. Why This Matters Nearly every real-time collaborative app assumes you need a backend, special sync protocols, and vendor lock-in. DLDSS proves you don’t. For tons of use cases—messaging, collaborative tools, offline productivity, audit-heavy apps, even local AI workflows—you can ditch all that. It sets prior art for: - Local-first deterministic state replication - DAG-based application state modeling - BroadcastChannel intra-client sync - Serverless multi-context consensus with shared local storage The demo is a single HTML file you can inspect. The repo’s got more detail if you want to dig deeper or build on it. But that’s just one part. It ties into a bigger vision called **"I Am Node"**—a browser-native, fully deterministic, decentralized state machine with real sovereign AI capabilities. To show what sovereignty means, there are three core demos coming: 1. Personal Sovereign AI Assistant: Uses Semantic Clustered Memory Protocol (SCMP), DLDSS, and local embeddings. Your AI remembers context across devices via P2P gossip and deterministic replay. Your memories stay yours—zero cloud control. 2. Time-Limited & Revocable Document Sharing: Fine-grained capability tokens, encryption, audit ledger, optional IPFS. Revoke access cryptographically; the DAG enforces consistent permissions. 3. Distributed IoT & Resource Scheduling: Deterministic event ordering for shared resources (energy, bookings, etc.). Conflicts are preserved, ordered fairly, constraints enforced—no central authority. These paint a picture of real digital sovereignty: power over your memory (AI), your data (sharing/revocation), and your group coordination—no platforms needed. The browser? It stops being a window to other people’s servers—now it becomes **sovereign territory**, private, resilient, and under your control. DLDSS is public prior art, protected with a dual license for commercial use. My goal isn't to extract value—it's to prove we can already shift away from centralization. This isn’t pie-in-the-sky; it’s a working, live demo. If any of this hits home, try the demo, check the repo, and send feedback. I’m looking for fellow builders who want to make things that actually empower people—not extract from them. The future isn’t locked in yet. Let’s go build the one that’s worth living in.