I was laid off so I rebuilt their product but better (in 2 weeks from scratch)
Open Canvas - a multiplayer site builder with an agent at the cursor.
Most website builders ask you to fill in a template.I built one that lets you design - on a free-form canvas, with an AI agent at your cursor, where your whole team co-edits live and visitors see your publish update without refreshing.
What makes it different:
• Drag 14 design primitives anywhere — not into fixed slots
• AI agent edits in plain English, you preview before it lands
• Real-time co-editing (Yjs CRDT, Figma-style cursors)
• Publish → every open visitor tab updates in <100ms
Under the hood: one Cloudflare Worker, serverless Postgres, a first-class CMS, version history, a blocking accessibility audit, AI image gen, custom domains — all shipping as pure HTML, zero client-framework weight.
It's MIT-licensed and built in the open
i was thinking most ppl keep saying i wanna start gym, read books, do this, do that, but are never able to bc they just keep thinking that and don’t come up with an action plan. for me its logical if i wanna start smth new, i need to change my routine and commit to it. thoughts?
and now, stage 2 is wrapped up
a lil recap: stage 1 was "how do we store memory durably?". and the goal of stage 2 was to answer "how does memory become knowledge?"
the answer ended up being a knowledge graph. messages still go in the same way, but now the leader also extracts entities and relationships from each one, and replicates those through raft as a proper command. so every node ends up with the same graph
so instead of only doing semantic search, you can now directly ask "who works at X?" or "find the path from A to B"
the distributed part was a bit tricky to get down. extraction had to go through Raft because LLM extraction isnt deterministic, and per node extraction would have given you divergent graphs. so the leader extracts once and replicates everywhere
messages stay the source of truth. the graph is the derived state built on top of them
up next: collective memory. multiple autonomous systems sharing one knowledge substrate
we're getting closer to answering the bigger question :)
repo below ^^
so, stage 1 of engram was about making memory survive failure. basically turning it into a distributed system from the previous single node system
and so now, we have 3 nodes, raft, grpc, leader election, log replication, failover, and all that fun distributed systems stuff
lore 1: high-level architecture and crate structure
to separate control from performance in my hybrid load balancer project, i divided things into two worlds across a cargo workspace:
data plane:
- 'janus-proxy' (network i/o)
- 'janus-balancer' (selection algorithms)
control plane:
- 'janus-config' (configuration management)
- 'janus-admin' (metrics api)
- 'janus-health' (health checking)
- 'janus-bin' (orchestration)
what is a data plane?
- it has one very simple role: handling incoming client connections.
- speed is critical here, which is why it must avoid slow system operations.
- its job is to accept connections, read and write bytes, decide where traffic should go, and forward the data.
what is a control plane?
- it is responsible for system management tasks such as configuration, health monitoring, metrics collection, startup, and graceful shutdown.
- the data plane should only focus on routing and handling traffic.
- you do not want the data plane worrying about configuration changes while processing incoming requests.
- a request should never have to wait because someone opened the dashboard, reloaded a config file, or checked metrics. the control plane takes care of those responsibilities and makes the data plane's job easier.
why this division?
- let's say your load balancer is handling 100k requests per second.
- if every request had to check whether configurations changed, whether a backend became unhealthy, or whether some metric was updated, you would waste a lot of time and eventually money.
- why should your connection handler care about changes that might not even happen?
- this is where the control plane comes in.
- it maintains the system's configuration and state, then provides the necessary information to the data plane so it can focus entirely on moving traffic.
communication between the data plane and control plane?
- i said the control plane gives instructions to the data plane, but how?
- everything that is modified by the control plane and read by the data plane is stored in a shared state module that both can access.
- this shared state contains things like runtime server state, backend health metrics, routing information, and other important operational data.
- the control plane updates it whenever changes happen, while the data plane reads from it during request processing without having to perform expensive checks itself.
next upcoming topic: cli argument parsing & main entrypoint (janus-bin)
My toxic trait is comparing myself to someone who has multiple times more experience than me, getting depressed for 10 minutes, then deciding I need to work even harder.
193 Followers 130 FollowingBuilding https://t.co/fxKzW82B44 | Intelligent creative strategies for D2C Owners and Marketers | Helping you win attention & build in public | DM for collabs
3K Followers 1K FollowingSoftware Engineer @EPAMSystems | 24 | I code, animate, write, study physics & mathematics | Oh, and I love Spider-Man & music
Writing - @wtf_times
193 Followers 130 FollowingBuilding https://t.co/fxKzW82B44 | Intelligent creative strategies for D2C Owners and Marketers | Helping you win attention & build in public | DM for collabs
132 Followers 269 FollowingBuilding backend systems that survive production |
Retries, failures & distributed systems |
Built Initex & https://t.co/zHA8TMCLK7 |
Open for freelance