Atom 0.3.6: less guesswork
Atom 0.3.6 reports clearer errors at the source lines that need fixing. Examples show missing names, values that do not fit and short jumps that cannot reach their destinations.
Atom 0.3.5 for CP/M
With Atom 0.3.5 you can write, assemble and run Z80 programs on a CP/M machine without leaving it. Try it in Triptych with an editor and a commented example or put it on your own system.
Making space for closures
Skate implements lexical closures using heap binding records and pointers. Following a small adder example shows how those bindings survive a procedure call on a Z80.
Building a heap out of slabs
Skate divides its small heap into 256-byte pages. Pairs, bindings, closures, strings and vectors can then share the available memory without fixed reservations for each type.
Taking out the garbage
Skate reclaims list pairs that a running program can no longer reach. Its collector traces from live roots, keeps reachable pairs and returns the rest to the free list.
Room to run
Skate brings compiled Scheme to Z80/CP/M. Providing automatic memory management on a small machine means balancing runtime size, data capacity and processing time.
Scheme within limits
Skate’s design balances useful Scheme features against the memory and processing limits of Z80/CP/M. Some features remain central; others sit outside the scope of the first version.
A minimum viable Scheme
I’m building Skate, a Scheme compiler for the Z80 running CP/M. Examples from Structure and Interpretation of Computer Programs provide a test of how much we can retain while leaving enough memory to run useful programs.
Starting Skate
I’m building Skate, a Scheme compiler for Z80/CP/M. I’ll release the implementation in stages and explore how to make its expressive style of programming practical on a small machine.
Recovering Hyperdrive, part two: Pulse-width modulation
Decoding Ken Stone’s cassette recording turned pulse timings into readable BASIC. As the words emerged, apparent damage gave way to unfamiliar Commodore conventions, and I began recovering details I could no longer recall.
Recovering Hyperdrive, part one: a very old cassette
Ken Stone’s old cassette preserved a game I could no longer reconstruct from memory. Recovering Hyperdrive gave me evidence to piece together the history of our early work on Caverns and the games he sold through Micro Parts.
Triptych, a retro computer in three parts
Triptych is a retro computer project using three ESP32 boards for CPU and storage, VGA video, and sound. The goal is a machine you can program directly, with a Z80 and CP/M at the centre of the current design.
Machines, Intelligence and Subjectivity
A language model can solve a problem and describe an inner life. What would establish that it actually experiences anything?
Atom, a new Z80 assembler
Atom runs on macOS, Windows, Linux … and CP/M. The assembler itself is written in Z80 assembly, fits within 16 KiB and can assemble its own source.
AI is a map not a mind
This article argues that current AI systems can model thought with extraordinary power without becoming conscious subjects. It explains the difference between simulation and experience, syntax and meaning, and output and inner life for a technical audience.
An elephant in the room too large to see
This article argues that code generated without sufficient human authorship may fall into the public domain by default. It frames that legal risk as a neglected issue inside the current rush toward AI-assisted software development.
Can you own vibe-coded software?
This article examines the legal parallel between the monkey selfie case and software generated by large language models. It considers what happens to ownership, licensing, and open source when code lacks traditional human authorship.
Programming in clay
On the January 2025 Copyright Office advice that vibe-coded software is public domain, why chat-window prompting fails to transfer authorial intent, and what a clay-like programming interface would need to do differently.
Why I came back to the Z80
My work with the Z80 began on paper in the late 1970s and became real hardware in the early 1980s. This series documents a return to that architecture through the construction of a modern debugging environment.
Your address is your domain
Argues that owning the domain is the first unit of independence. It calls the reader to secure the address before building the site.
Owning your output
Frames self-publishing as a technical choice that keeps writing durable and under my control. It ties that choice to why I am building this system and publishing here.
A blog that is also the build system
Sets out why the repository holds both the writing and the build so decisions stay traceable. It anchors that structure in classic web values and a minimal toolchain.
Why I'm building this in public
Explains why I build this in public and how writing reshapes the technical decisions. It also sets out how I use deliberate review to keep pace without losing my voice.
Start here: building the tool while using it
An entry map for the project that frames the live build log. It starts with the genesis series, then moves forward through the next posts in order.
Years
- 2026 (24)