The world remembers
Every page proposes facts, and those land in a knowledge graph with provenance. What a site publishes is stored apart from what is true, so a tabloid can lie without corrupting who somebody is.
Elsewhere
A browser for an internet that doesn’t exist yet.
Type any domain. If it’s already in this world, you get the page that’s there, byte for byte, the same one you saw last week. If nothing is there yet, a model writes the site, and it’s kept. That address now is that site.
It isn’t a chat window that renders HTML. It’s a browser, with tabs, history, back and forward and an address bar, over a web that writes itself as you walk through it, and then stays put.
Nothing here is broken
Every link that page invented leads somewhere, because following one is what writes the page at the other end. There are no 404s and no dead ends, only places nobody has visited yet.
The comments on it are worth reading twice. One of them:
this page is a portfolio?? i watched the grid for 20 minutes before realising there are no videos. anyway. 5 stars. the tram one is loading.
That is the model noticing, in character, that its own world contains no video files.
Pages persist, and that’s the whole point
A generated site is committed to SQLite as a versioned record: HTML, images, outbound links, and everything the page asserted about the world. Revisit it in a month and you get the same page. Follow a link it invented and that page gets written too, in the same voice, knowing what the first one said.
Disagreements survive
When two pages contradict each other, both statements are kept and the conflict is recorded rather than quietly resolved in favour of whoever wrote last.
Faces stay put
Images are permanent world objects, not page decoration. Once somebody has been photographed, every later site showing them shows the same face.
You can change a page, once a week
In a shared world anybody may edit any page, one page per person per week. The ration is what makes it safe to let strangers rewrite things: nobody can own a page. Every edit is a new version beside the old one, so nothing is destroyed, and you can take your own change back while you’re still looking at it.
A world, drawn as districts
Past a few dozen entities a node-per-thing graph is an unreadable hairball. So the graph is clustered (Louvain, both phases) and drawn as districts, sized by what’s in them and joined by the traffic between them. Open one to see the things inside it.
Three problems worth reading the code for
A model asked to change one thing will rewrite the page instead
Small fast models carry out the instruction and then write a fresh page around it. Since the reply replaces the stored version, an unchecked edit destroys the only copy. So replies are measured before they commit, by counting the landmarks (image references, link targets, headings) that an edit to something else has no business removing.
The interesting part is what happens next. “Drop the sidebar” is a real instruction whose whole point is removal, and you can’t tell it from a rewrite by reading the words: add an article about the harbour and remove the article about the harbour differ only in the verb. So it doesn’t guess. It shows you what would be removed and lets you decide.
A ration enforced by the client is not a ration
A shared world can’t take a client’s word for who it is or when it last edited. The server verifies a Google ID token, keys its ledger on the account’s stable subject claim, and checks the limit before spending a single token. There’s deliberately no field in the request by which a client can name itself.
The WebView sits on top of everything
The page is a real native view, so nothing the interface draws can appear above it. Menus live in their own always-on-top window; the undo bar takes its own strip rather than being an overlay that would simply be invisible. Every obvious approach fails in a different visible way, and the comments record which.
Run it yourself
Rust 1.97+ and an API key for any OpenAI-compatible endpoint: DeepSeek, NVIDIA NIM, OpenRouter, or a model on your own machine.
git clone https://github.com/DenizYunus/Elsewhere.git
cd Elsewhere
cargo run -p elsewhere-desktop --release
There is no shared key. Elsewhere calls whatever endpoint you
point it at, on your account: about a minute and a few cents a page. Set
provider = "mock" to browse a bundled offline internet with no key
and no cost, which is enough to see what the thing is.
A built macOS app is committed too, but it isn’t signed or notarised, so macOS will call it damaged. That means unsigned, not malware. Signing needs a paid Apple Developer account this project doesn’t have. Building from source takes about two minutes.
How it’s built
Native Rust. No Electron, no Node, no bundler. The chrome is drawn on the GPU with egui; the system’s WebKit renders generated pages exactly as it would render real ones. A generated page gets a browser, not a computer: no native bridge, its own origin, and a policy that denies it the network.
574 tests, all offline and free, run against a deterministic mock provider. They test the shape of the thing rather than its pixels. What a screen decides to show, whether a ration holds, whether an edit is faithful: a test that asserts on colours breaks when you change a colour and passes when you break the browser.
Design work is verified by rendering real application frames to PNG offscreen, which is how every screenshot on this page was made.