Actors Are Alive

Last time we walked through every piece of the Blimp grammar. Actors, typed state, pipes, message sends, guards, Holes, situations, bubbles. The parser was real, it could chew through stuff like this.

But that was it. You could parse it into an AST and stare at a tree. Nothing ran, nothing evaluated, nothing compiled.

So we kept going. Naturally, working on this language the way I am, and moving so quickly, viewing diffs became the key piece of the work more than being in an editor. Viewing these diffs and commenting on them to influence code was done much more than hand crafting, and that needs to feel better than what we've got right now. So before we could make the language do anything, we needed a way to watch the work happen.

The goal is Magit in a browser. We're not there yet, but we're getting closer.

It's a Phoenix LiveView app that watches .git/index and refs, picks up changes in real time, and renders diffs. Two panes: file list on the left, diff on the right. Everything keyboard-driven. j/k to move, Tab to switch panes, Enter to expand a file, s to stage, u to unstage, l to open the git log. The active pane gets a green glow, the selected item gets a blue highlight.

The thing it does have that's cool is line selection. You can highlight a line or a range of lines in a diff, write some commentary about what you want changed, and send an agent off to do the work. The agent spawns in the multiplexer (more on that next) and you watch it go while you keep reviewing other diffs. That feedback loop, of looking at code and being able to just point at something and say "fix this", is the whole point.

The diff viewer shows you what changed. The multiplexer shows you who's changing it.

It runs up to five Claude sessions simultaneously, each in its own pane, streaming output in real time. You click some lines in the diff viewer, write a comment like "this error handling is wrong, use bubbles instead", and an agent spawns. It shows up in the multiplexer and starts working while you go back to reviewing other files.

When you write actor Counter do ... end, the evaluator registers a template. It's a blueprint, not an instance. You call spawn Counter and the runtime creates an instance with its own state, assigns it a ref, and puts it in the global registry. That ref is how you talk to it.

Two instances, completely independent state. c1 has been incremented twice, c2 once. They're lightweight refs like Erlang PIDs. become updates the state for the next message, not the current scope. That's real actor semantics, not a simulation.

You can override state at spawn time too. spawn Counter(count: 100) creates a counter starting at 100. No constructor patterns, no factory methods. The defaults in the template are just defaults.

State machines fall out of this for free. No state machine library, no framework. An actor with one state field and a situation that cycles through values. That's a state machine.

Guards give you multi-clause dispatch. Two handlers for :withdraw, different guards. The runtime tries them in order and picks the first match. No nested if inside case inside the handler body. Just separate handlers with clear conditions.

And the _ Hole operator works in situation branches. You write the branches you know and the agent fills the rest. The comment after a Hole is a directive to the agent, not a note to yourself.

The agent sees that Hole in the AST, reads the comment, and gets to work figuring out what should go there. You don't leave your code to write a prompt. The Hole is the prompt.

Six error types, all with this format. UNDEFINED VARIABLE lists what's in scope so you can spot the typo. TYPE MISMATCH shows both types so you know what you have vs what was expected. DIVISION BY ZERO because yeah. UNKNOWN FUNCTION lists the available builtins. NOT AVAILABLE IN REPL nudges you toward expressions the REPL can evaluate. NO MATCHING HANDLER names the actor and the message that didn't match, which is huge for debugging actor communication because you immediately know "oh, I sent :incremnt instead of :increment."

The implementation is stupid simple. A struct with a title, an optional source line, an optional column for the caret, a message, and an optional hint. One format method that writes colored output on TTYs and plain text when piped. Zig makes this really clean because anytype writers mean you don't care where the output goes.

I am going to basically be studying the Elm and Elixir compilers to rip off how to keep making this better.

Every expression type compiles: literals become LLVM constants, binary ops become add/sub/mul/div instructions, variables are allocas, pipes compile by substituting _, situation and case become conditional branches.

But the fun part is actors. An actor definition compiles to three things: a state struct type (each state field becomes a struct member), handler functions (each on block becomes an LLVM function that takes a pointer to the state struct), and a handler table mapping atom IDs to function pointers. spawn allocates the struct, initializes defaults, registers with the runtime, builds the table. <- compiles to a runtime call that looks up the handler by atom ID, tries each clause's guard, and calls the first match. become writes to the struct via GEP. reply builds a {i1, i64} return pair, the i1 being "has reply" and the i64 being the value.

The compiler links against a tiny C runtime, about 260 lines, that provides what LLVM IR can't do alone: a global actor registry, handler table management, a mailbox per actor (ring buffer, capacity 256), message dispatch with multi-clause guard support, synchronous send, and a round-robin scheduler that drains pending messages.

It's deliberately dumb right now. Fixed-size array of actor pointers, a round-robin loop, no preemption. The whole point is that this grows into the real actor runtime later, with per-actor memory arenas, Perceus reference counting, and preemptive scheduling. But you start with the dumbest thing that works and iterate.

The REPL auto-detects whether you're on a TTY. If you are, you get TUI mode: your session on the left, live state sidebar on the right. Every variable you define, every actor you spawn, shows up on the right immediately. If you're piped or not on a terminal, you get clean plain-text output.

There's also an --introspect flag that switches the output to JSON. Instead of pretty-printing results, the evaluator dumps its whole state: variables, actor refs, the last expression result, errors. This is how the web tools consume the language. The Phoenix app has a REPL explorer at /repl that runs blimp file.blimp --introspect and renders the JSON in the browser. The language has an API from day one, not because we planned it that way, but because the web tooling needed to talk to the evaluator and JSON was the obvious move.

We also started on a TUI REPL with libvaxis, a proper terminal UI framework for Zig. TEA architecture for state management, vim modes (normal/insert/command), syntax highlighting, tab completion. The current raw ANSI version works but the libvaxis version is going to feel like an actual editor. That's still in progress.