I learned to code with Apple LOGO. THEN I learned BASIC and Pascal. But no modern IDE with 47 panels and a settings menu that has more options than the machine it’s configuring. LOGO. A green phosphor screen, a little turtle, and the absolute magic of typing FD 100 and watching it happen.
No line numbers. No GOTO. No “syntax error on line 42.” Just you and the machine, in a conversation that felt almost… alive. You told the turtle to go forward, and it there it went. You said turn right 90 degrees, and you saw it turn, like a robot on the screen you control. Every command had an immediate, visual consequence. The feedback loop was instant. It’s what made programming feel like play instead of learning.
I’ve been thinking about that relationship — programmer and machine, no abstraction layers in between, no framework telling you how to structure your life — for a long time. So when the IndyInit hackathon came around, I knew exactly what I was building.
So what’s Maturin Logo?
Maturin Logo is a browser-based turtle-graphics programming environment in the spirit of Terrapin Logo and Apple Logo II on the Apple II. It runs entirely as Blazor WebAssembly (WASM) and .NET 10 — no server, no account, no install. Once it loads, it works offline forever. A kid opens it, types FD 50, presses Enter, and a turtle draws on a 40×24 grid that looks and feels like an Apple IIe screen: one phosphor color (green or amber, your pick), CRT scanlines, the whole vibe.
It supports 170+ commands — FD, RT, REPEAT, SETPC, TOOT, procedures, variables, lists, the works. There’s an EASY mode that hides the advanced stuff and gives the turtle most of the screen, and an ADVANCED mode that opens up the full language. It plays 8-bit square-wave sounds through the Web Audio API. Sessions save locally and export as plain-text .logo files.
And if you just sit on the loading screen for a few seconds, it runs a little demo so kids (and their parents) can see what’s possible before they start typing.
You can try it here: https://logo.auri.net
A brief history of LOGO (the short version)
LOGO was created in 1967 by Seymour Papert and colleagues at MIT. The whole point was to give children a language where the output was visible — not just text on a screen, but a turtle moving around drawing shapes. Papert’s insight was that kids learn better when they can see their thinking. Type REPEAT 4 [FD 100 RT 90] and you don’t get “OK” printed at the bottom of a terminal. You get a square. A real, drawn, visible square.
It ran on everything from PDP-10s to Apple IIs. The Apple II version (Apple Logo II, 1982) is the one most of us remember — bundled with the computer, green screen, that little turtle cursor. It was the first programming language a generation of kids ever touched, and it shaped how they thought about computers for the rest of their lives.
That’s the thing nobody talks about anymore: LOGO didn’t just teach you to code. It taught you that you could talk to a machine in plain English-ish words and it would do what you said. The relationship was direct. There was no framework, no build step, no dependency tree. You were the programmer, it was the machine, and between you there was just… a command line and a turtle.
How I built it (and yes, I used AI)
I’ll be upfront: this is a vibe-coded project. Not in the dismissive sense people use that word — in the “I had a clear vision, a plan, and an AI partner that helped me execute at speed” sense. But yeah, it did most of the coding work. I saved the original prompt, in case you’re interested.
The model doing most of the heavy lifting was Qwen3.8, running on my home AI server. Most of the development happened locally — no code left the house for the bulk of it. For the initial instance – I needed speed since it was a hackathon – and some architectural planning , I routed through OpenRouter to hit cloud models for raw reasoning power. But the day-to-day “add this feature,” “fix this edge case,” “add tests for this” work? That was all local Qwen on my server, running 24/7 while I slept. I’ve talked about this in my Developer Rants.
The project is structured as a .NET 10 Blazor WASM app with a clean split: MaturinLogo.Core is a pure C# class library (interpreter, turtle, screen, sessions — no browser dependency), and the Blazor host handles canvas rendering, audio, and storage. That split means the core logic has around 500 unit tests running without a browser in sight. The browser just paints what Core tells it to.
The hackathon deadline was real. The scope was ambitious. And honestly? Without the AI pair programming workflow I’ve been refining over the last year, this wouldn’t have shipped in that timeframe. Not because I can’t write C# — I can. But because the volume of work (170+ primitives – a.k.a. commands, screen emulation, audio, session management, CRT effects, the full UI) is exactly the kind of thing where a fast, reliable pair accelerates you without compromising the architecture.
Now, I haven’t read every line yet – it was a hackathon. I will still ultimately read most of the code. I still make every architectural decision. The AI executes; I direct. That’s the model that works for me, and it’s the same one I’ve written about before — plan first, agree on definition of done, then let the tokens fly.
Why retro? Simplicity is a feature.
We don’t build things like this anymore. Not because we can’t — we absolutely, obviously can — but because the modern development paradigm has moved so far from “type a command, see it happen” that most kids today have never experienced that directness. They get Scratch blocks (great for absolute beginners) or Python in an IDE with autocomplete and linting and 14 panels open. If it takes significant effort just to load the development environment, especially when attention spans are ever shorter, what good are the complex solutions of today?
LOGO was none of that. It was you. And the machine. And the thing you were making.
I miss that. I think kids would too, if they got a chance to feel it. Not as a museum piece — as a living, working tool that runs in their browser and lets them draw a square in four commands. No setup. No “install Node.js first” or list of system requirements. Just open the page and go.
Try it / Fork it / Break it
- Play with it: https://logo.auri.net — no login, no install, works offline after first load.
- Read the code: https://github.com/aurir/logo — MIT licensed. Fork it, modify it, use it in your classroom.
- Found a bug? Open an issue on GitHub. I read them all.
- Want to contribute? Please log an issue first. If you are invited to contribute, remember: The test suite is thorough; make sure yours passes before you submit.
The full architecture doc, command reference (auto-generated from the code so it can’t drift), and design rationale are in the repo under Docs/Architecture.md.
What’s next
There’s more I want to do with this — a tutorial mode, more examples, a programmer guide for beginners, maybe a “share your program” feature that just generates a URL. The offline-first architecture means it could run at schools with limited Internet connectivity.
But for now: it’s live, it works, it’s open source, and it runs on a green screen that looks like it’s 1984.
Go draw a square. 🐢
