PROJECT STEVE | The 1986 Experiment

Project STEVE — short for the Semantic Task and Environment Vision Engine — is an experiment in what the desktop could have looked like if AI had existed from the start. It runs natively on real 1986 Macintosh hardware as a System 6 Desk Accessory, combining natural language, semantic indexing, contextual understanding, and visual composition to reason about what's on screen instead of just responding to clicks. It isn't a modernized Mac, a chatbot, or a screenshot-and-guess script — every part of it runs for real, on the hardware.

Here's proof it's not just theoretical: what STEVE actually drew, below — designed by beta visual detection functions inside 1984 MacPaint, not by me.

Rendered using FatBits in 1984 MacPaint

That's a remarkable result for software working inside a forty-year-old interface — and it's evidence the experiment has already begun.

[01] Why we did this

Skeuomorphism taught a generation to think in objects — files, folders, windows — because that was computing's only bridge in 1984. Forty years and several computing eras later, that bridge hasn't changed. If we were inventing personal computing today, with everything we know about AI and natural language, would we still build it the same way?

[01] The Macintosh Plus

The Macintosh Plus is one of the purest expressions of the GUI ever built: before cloud computing, notifications, and decades of accumulated complexity, it distilled computing into one simple interaction model, built on metaphors borrowed from the physical world. In effect, it taught computers how to appear human, not the other way around.

[02] The Anti-Mac Interface

That tension isn't new. Don Gentner and Jakob Nielsen's 1996 paper "The Anti-Mac Interface" argued the opposite: that a computer told what you want, rather than manually operated, might serve people better. Project STEVE explores a concrete version of that inversion, thirty years later — using AI to teach the computer how people work, instead of teaching people how computers work.

Project STEVE isn't about rebuilding the Macintosh — it's about testing whether one of computing's oldest interaction models can evolve alongside one of its newest. It's currently focused on the capabilities shown above, and two of them are furthest along.

[01] Visual composition

Reading a tightly packed icon grid inside an open window — not just isolated desktop icons — is solid. The fix was separating window chrome (long, thin shapes) from icon artwork (compact, blocky shapes) at the pixel level, so STEVE can now open a window, read what's inside it, and act on a specific item.

[02] Native presence on the Mac

Most of the current work: giving STEVE a real presence on the Mac itself as a native Desk Accessory, written in actual 68K Toolbox code — ported from an old open-source Ethernet driver's resource pattern, since no DA scaffolding exists. It compiles into a real Mac resource today; the next step is merging it into the System file so it shows up under the Apple menu and opens on a real boot.

From there, the DA becomes the front end for a real LocalTalk connection — the Mac Plus's own serial port — to the Python backend doing the actual reasoning. No screenshotting a text field and guessing at what it says. A real data channel, running in period-correct hardware, doing 2026 reasoning on the other end.

In-app concept for the STEVE Desk Accessory

The first milestone is conversation — not a chatbot floating above the desktop, but a native interaction model that feels like it belongs inside System 6. The goal isn't to make a Mac Plus behave like a modern computer, but to see whether modern interaction models can learn something from one of the simplest interfaces ever built.

The opening portrait wasn't the destination — it was evidence STEVE could already reason about composition and layout well enough to create original artwork inside a forty-year-old app. Every experiment since teaches it a little more about how people create, think, and work within graphical environments.

[01] Boot the DA for real

Boot the Mac with the DA merged into the System file, confirm .STEVE shows up under the Apple menu, and watch it actually open and draw. That's the real proof, not a clean compile on a build machine.

[02] Give the DA its voice

A real LocalTalk connection over the Mac's serial port, bridged to a modern machine through a small USB adapter that speaks the same 1986 protocol — turning the static window into an actual conversation with the reasoning backend.

[03] Indexed search and the demo

Real indexed search, so STEVE can find things by walking its own disk directly instead of guessing from a filename — and eventually a video demo of the whole loop, prompt to response, running on real 1986 hardware.

There's a lot of work ahead, and not all of it will succeed. I'll be sharing the prototypes, breakthroughs, and setbacks as they happen. Stay tuned — I'm working toward a demo over the next couple of weeks to a couple months.

Where the experiment actually happens