I shipped a /code page. It is a Go playground that runs entirely in your browser — no server, no round trips, no waiting. You write Go, click a function name, and the output renders inline. It works on your phone.
Here is what it looks like. Edit the code and watch the output update:
What it actually is
The page loads a 43MB WebAssembly binary compiled from yaegi, a Go interpreter written in Go. Yaegi runs inside a Web Worker so it never blocks the UI thread. The editor is Monaco — the same editor that powers VS Code — with a language server worker running alongside it for completions and error markers.
When you click a function in the left panel, the interpreter calls it and whatever it returns gets rendered as HTML in the output panel below. The functions return *Node values from a small HTML builder library, so you are literally writing Go that produces a web page, and you see it instantly.
Here is a slightly more interesting example — a styled card built entirely from Go:
Why this is interesting
Most Go playgrounds send your code to a server, compile it, run it in a sandbox, and stream back the output. That works fine but it means latency, it means infrastructure, and it means someone else's computer is running your code.
This is different. The interpreter is yours, running locally. There is no network call between you editing and seeing the result. The feedback loop is as tight as a spreadsheet formula.
The other thing that makes it interesting is what yaegi actually is. It is a full Go interpreter — not a transpiler to JavaScript, not a subset. It handles generics, closures, interfaces, goroutines. I spent time this week getting it to 100% on a spec compliance harness I wrote: 55 tests covering min/max, clear, range-over-int, defer LIFO ordering, directional channels, type assertions through any, and generic union constraints. All passing.
Here is a real Go loop building a list — the kind of thing that would be awkward to fake in a limited sandbox:
The code page as a format
The thing I want to explore is using this as a publishing format. Instead of a blog post that describes a data structure, you write the data structure in Go and embed it. Instead of explaining an algorithm, you run it. The reader can change the code and see what happens.
This is not a new idea — Bret Victor has been making this argument for fifteen years. But having it work in Go, in the browser, with a real editor, makes it feel more practical than it used to.
The /code page is the beginning of that. The next step is making it embeddable in posts — which, as you can see, already works.