25,701 karma · joined April 13, 2014
\ don@donhopkins.com
FORTH ?KNOW IF HONK ELSE FORTH LEARN THEN
: C(-; LICK SMILE NOSE WINK ;
\ FORTH PAPER TAPE PUNCHER:
: PT# ( L --- L/2 )
DUP 1 AND IF
ASCII @
ELSE BL THEN
HOLD
2/
;
: PT. ( N --- )
<# PT# PT# PT#
ASCII . HOLD
PT# PT# PT# PT#
#> TYPE
;
: CUT
." -----------" CR
;
: PTAPE
CUT
BEGIN
KEY ?DUP WHILE
DUP ." |" PT. ." |" SPACE EMIT CR
REPEAT
CUT
;
Lisp -vs- Forth -vs- PostScript: ; Lisp:
(defun caar (x) (car (car x)))
(defun caaar (x) (car (car (car x))))
(defun caaaar (x) (car (car (car (car x)))))
\ Forth:
: droop drop drop ;
: drooop drop drop drop ;
: droooop drop drop drop drop ;
% PostScript:
/poop { pop pop } def
/pooop { pop pop pop } def
/poooop { pop pop pop pop } defFor how unoriginal, unreactive, and mind-numbingly iterative over virtual DOM React is, it should be named Repeat.
"Things seem to hang on in computing just because they work a little bit." -Alan Kay
https://news.ycombinator.com/item?id=8841428
Alan Kay also said this about his famous "Point of View is worth 80 IQ points" aphorism, which I think poignantly explains why React costs a net of 160 IQ points compared to Svelte:
>I have been keeping to "80" IQ points in the saying (thus avoiding inflation). However very few people have noticed there is no sign bit in the aphorism, and that it works just as well for "poor perspectives being worth negative 80 IQ points" (and I think we could claim inflation of stupidity in many bad directions these days ...).
Rich Harris: Rethinking Reactivity:
https://svelte.dev/blog/svelte-3-rethinking-reactivity
>There are some important technical differences (as I explain in the video above, React is not reactive) but conceptually it’s the same thing.
So we're not only supposed to believe that there was a bug that forgot to remove that text from customer facing help (ok...), but also that the pesky bug JUST HAPPENED to make the text it ACCIDENTALLY forgot to remove be INVISIBLE instead?
What a FANTASTICALLY convenient bug for WhatsApp!
Anne and Benjamin have a "sim" recorded at their wedding -- not a photo, but everything they know and feel at that instant. The sim wakes up believing it IS Anne on the happiest day of her life, then figures out it's the keepsake. The real Anne is out there aging, divorcing, moving on. The sim only runs when somebody opens the album.
Your harness is all there. Time skipping: sims get paused for decades and wake into a future they don't recognize. The context window: their whole world is whatever got captured at the moment of recording. Reset to a clean state: the cruelest moments in the story are ordinary file operations, pause, reset, copy, migrate, delete. Nobody throws a punch, somebody just clicks. And the back door: the sims organize for the rights of simulated people and a place of their own to live, which they call "Simopolis." Marusek's tagline: "Till deletion do us part."
It's a big influence on what I'm building. Soul City imports characters from Sims 1 save files, with personality bytes frozen since 2000, into MOOLLM where an LLM wakes them up. That's literally the Wedding Album premise, so I try to write the rules like a settlement of Marusek v. The Future: consent when a real person is portrayed, the subject (not the file's creator) can correct or delete it, sims know and say they're sims, the dead are discussed but never ventriloquized, and everything lives in plain text so nobody gets stranded in a dead format.
So maybe what your read-only admin panel is missing isn't a console, it's a sense of what the operators owe the agents.
The Wedding Album:
https://en.wikipedia.org/wiki/The_Wedding_Album_(short_story...
The Wedding Album and the rights of digital souls:
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
MOOLLM Soul City example:
https://github.com/SimHacker/moollm/tree/main/examples/soul-...
https://en.wikipedia.org/wiki/Netochka_Nezvanova_(author)
https://en.wikipedia.org/wiki/Nato.0%2B55%2B3d
https://news.ycombinator.com/item?id=774594
>"The epoch of the generalist has arrived -- again. Any fool can program and most do. Software engineers are emotionally inept. In today's unstable + dynamic environment they do not stand a chance." - Netochka Nezvanova
https://web.archive.org/web/20090826104645/http://www.usemod...
>One of the most famous and infamous EccentricCharacters in turn–of–the–21st Century Western artistic NetworkCulture, Netochka Nezvanova (aka N.N., antiorp, integer, Irena Sabine Czubera) remains an enigma to many. Widely believed to be an IdentityCollective?, Netochka Nezvanova is a PenName named after the title character in [an early unfinished Fyodor Dostoevsky novel] whose name means "nameless nobody" in Russian. The identity always presents itself as female, though it may not be in reality. Despite the meaning of her moniker, N.N. has coveted attention and recognition like few others on the Internet.
https://news.ycombinator.com/item?id=22352276
>Bravo! If you enjoyed that anti-Max performance art trolling, but thought it wasn't spectacularly hyperbolic and sociopathic enough, I recommend looking up some of the classic flames on the nettime mailing list by Netochka Nezvanova aka "NN" aka "=cw4t7abs", "punktprotokol", "0f0003", "maschinenkunst" (preferably spelled "m2zk!n3nkunzt"), "integer", and "antiorp"! [...]
https://news.ycombinator.com/item?id=16753758
>Nato.0+55+3d (released in 1999) was an amazing but notorious extension for Max that enabled live programming of real time video manipulation, networking and display. [...]
http://www.salon.com/2002/03/01/netochka/
The most feared woman on the Internet
Netochka Nezvanova is a software programmer, radical artist and online troublemaker. But is she for real?
The name Netochka Nezvanova is a pseudonym borrowed from the main character of Fyodor Dostoevski’s first novel; it translates loosely as “nameless nobody.” Her fans, her critics, her customers and her victims alike refer to her as a “being” or an “entity.” The rumors and speculation about her range all over the map. Is she one person with multiple identities? A female New Zealander artist, a male Icelander musician or an Eastern European collective conspiracy? The mystery only propagates her legend.
You can intuitively understand what "yaml jazz" means, and to the LLM, that term is a "k-line" to a skill that spells out the implications: free-form expressive yaml carries structured meaning, and yaml comments add a rich semantic overlay of meaning for both llms and humans, so it follows for both humans and LLMs to write generous narrative comments, and to write deterministic tools (like cli scripts both LLMs and humans can drive) that round trip yaml and preserve comments they can't understand.
YAML Jazz skill:
https://github.com/SimHacker/moollm/tree/main/skills/yaml-ja...
Here is the "kernel" that has constitutional and intrinsic "operating system" like stuff, including drivers for the orchestrator it's running on.
https://github.com/SimHacker/moollm/tree/main/kernel
MOOLLM Constitution Core:
https://github.com/SimHacker/moollm/blob/main/kernel/constit...
MOOLLM Kernel Architecture:
https://github.com/SimHacker/moollm/blob/main/kernel/ARCHITE...
The part I'm most delighted with, thanks to its inherent power of simplicity, is the "Selfish" prototype based object system, which supports multiple inheritance from both files and latent space. And it can model other more complex object systems like Smalltalk classes, CLOS MOP, generic dispatch, COM interfaces, OLE dispatch and reflection, LambdaMOO objects, Sims advertisements, etc.
The original Self paper by David Ungar and Randall B. Smith is at least as powerful and mind expanding as great LSD, without any of the downsides! Its ideas underly the fast dynamic JavaScript, Java, C# engines we're all running now, so you can use high doses of it every day for work and for play.
SELF: The Power of Simplicity:
https://bibliography.selflanguage.org/_static/self-power.pdf
MOOLLM Object System:
https://github.com/SimHacker/moollm/tree/main/designs/object...
Prototype skill:
https://github.com/SimHacker/moollm/tree/main/skills/prototy...
Self and MOOLLM: Prototypes over the File System:
https://github.com/SimHacker/moollm/blob/main/designs/object...
Latent-Space Inheritance — multiple inheritance from named concepts in training data:
https://github.com/SimHacker/moollm/blob/main/designs/object...
Selfish COM: Directory-as-Object:
https://github.com/SimHacker/moollm/blob/main/kernel/DIRECTO...
Selfish COM: Implementation Guide:
https://github.com/SimHacker/moollm/blob/main/kernel/SELFISH...
Memory Management Protocol:
https://github.com/SimHacker/moollm/blob/main/kernel/memory-...
Context Assembly Protocol:
https://github.com/SimHacker/moollm/blob/main/kernel/context...
There are some important rules about naming, like "big-endian naming", and "k-lines", a term defined by Minsky, and well represented in the training data because he wrote a lot about them:
https://github.com/SimHacker/moollm/tree/main/kernel/naming
K-Lines: A Theory of Memory, MIT AI Memo 516, June 1979 (PDF)
https://courses.csail.mit.edu/6.803/pdf/aim-516.pdf
The skill that explains k-lines:
https://github.com/SimHacker/moollm/tree/main/skills/k-lines
>A K-line is a mental structure that, when activated, reactivates an entire constellation of knowledge, skills, and associations. Minsky defined them in a 1979 MIT AI Lab memo, published in Cognitive Science in 1980, then built Society of Mind (1986) on them:
>"When you get an idea and want to remember it, you create a K-line for it. When later activated, the K-line induces a partial mental state resembling the one that created it." The art is to choose a coherent set of k-lines and terminology, that's well supported and understood in the training data, and fits together well.
If names are pointers into latent space, then naming is API design.
For contrast, Steve Yegge's approach to Gastown is the exact opposite of moollm's approach. This compares Gastown to moollm:
https://github.com/SimHacker/moollm/tree/main/designs/gastow...
Your question about who decides what gets loaded into the context window is close to something I've been experimenting with. I worked on the original Sims, and I'm now developing MOOLLM, which is roughly The Sims crossed with LambdaMOO, running on an LLM.
The connection to Leary is quite literal. MOOLLM has a Mind Mirror skill, an extension of the Anthropic Skills approach to character and location simulation, meets the Self prototype based object system. It draws on Timothy Leary's Mind Mirror, the game published by Electronic Arts, alongside Sims-style personality traits and needs.
Leary's earlier work on the Interpersonal Circumplex and personality inventories supplies another connection to your question about control. There's the story of him recognizing his own psychological testing framework during prison intake and answering strategically to obtain a minimum-security classification, from which he subsequently escaped the California Men's Colony in San Luis Obispo. Understanding how the system represented him helped him change what the system allowed him to do. Practical applications include prison escapes, and computer games too. ;)
MOOLLM's Mind Mirror skill:
https://github.com/SimHacker/moollm/tree/main/skills/mind-mi...
Timothy Leary's Mind Mirror game from Electronic Arts:
https://en.wikipedia.org/wiki/Timothy_Leary%27s_Mind_Mirror
Leary explaining his MIND MIRROR computer program:
https://www.youtube.com/watch?v=9oabRxvjf9k
Mind Mirror gameplay:
https://www.youtube.com/watch?v=epOL4QiPLJo
I'm using these ideas as an editable vocabulary for exploring personalities, relationships, and different interpretations of a situation, not as a scientific model of consciousness or a way to diagnose people.
What interested me about The Sims wasn't just watching simulated people. It was being able to build their environment, change it while they were living in it, and discover how their behavior changed. LambdaMOO brought a related idea into a shared, programmable world: the inhabitants could also be its builders.
https://github.com/SimHacker/moollm
In MOOLLM, directories represent rooms, files hold objects and character state, and the LLM interprets descriptions and behavioral instructions. The world persists outside the context window, but any particular interaction brings only part of it into context. Deciding what to retrieve, summarize, remember, or leave out becomes part of constructing the character's perspective.
I want that construction to be inspectable and editable. You should be able to look at the character description, memories, and instructions that were supplied, change them, and try the situation again. That doesn't reveal the model's internal workings, but it does let you examine and manipulate some of the conditions shaping its response.
So your "God's admin panel" made me smile. I'm interested in building one for these little worlds, and letting people move between playing a character, designing the environment, and examining the simulation -- even importing and exporting characters between games, and "llmulating" them in LLM driven microworld simulations like moollm. You don't have to believe our universe is simulated to learn something by building one you can take apart.
The moollm soul-city skill, inspired by something Will Wright said in 1996 about data portability:
https://github.com/SimHacker/moollm/tree/main/skills/soul-ci...
I'd be interested in how you'd turn the context-window idea into an interaction: what would you want someone to be able to inspect or change?
Thanks for writing this up! "Autodesk is not the street" is a wonderful reply. I appreciate having your account and the actual letters to separate what happened from the story that grew around it.
I also remember you developing something called Warp (not IBM's ill-fated operating system), if I have the name right -- an early predecessor to QuickTime VR. Am I remembering that correctly?
Your description of the EyePhone, Polhemus tracker, and data glove brought back memories of VPL and Body Electric, which I later worked on as Bounce. There’s a rich history of Forth running through VR, graphics, and live performance that I’d love to compare notes about.
I knew Michael Perry through Laxen and Perry Forth (and Strawberry Music Festival), which Mitch Bradley built on in developing Forthmacs and Sun Forth, leading to Open Firmware. There’s Young Harvill’s Swivel 3D, written in Forth, in the VPL world too.
And the late Marc de Groot developed Meme, the Multitasking Extensible Messaging Environment: a multi-user networked virtual-world system programmed in multitasking Forth. His June 1994 announcement emphasized portable executable behavior for objects, not just geometry, with code that could travel efficiently over the network. I dug up his website and announcement and posted them here (including some Tales of the Great TCL Wars):
https://news.ycombinator.com/item?id=22342800
https://web.archive.org/web/19990125100147/http://www.immers...
And here is his patent on Meme, which has 53 citations, including Philip Rosedal's Distributed Simulation patent (who made Second Life and High Fidelity):
https://patents.google.com/patent/US6421047B1/en
Another wonderful part of this history is Coco and Peter Conn’s HOMER & Associates. They hired Forth, Inc. to program their Homer II visual mixing console, and got Chuck Moore himself to write the host software!
Paul Rother worked alongside Chuck, learning Forth and programming the individual visual channels. The console had 24 channels with their own Z80s, a master Z80 running multitasking PolyForth in 32K, touch-sensitive sliders, and a “joystick bumper” like a Mustang gearshift. You could perform visual sequences, record them, and overdub corrections like an audio mix, then take the recording and slide trays to the optical printer.
Paul later got a CAT-700 framebuffer running as a Forth paint system alongside the optical-printer controls. Coco remembers its early use on Abracadabra and Atomic Dog.
I posted Coco’s and Paul’s accounts to Hacker News with Coco’s permission:
https://news.ycombinator.com/item?id=29261868
I’ve also collected the story, sources, and photographs here. Paul’s account describes working with Chuck directly:
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
There are linked collections for Coco, Peter, Paul, and Chuck:
https://github.com/SimHacker/WillWrightShowForFood/tree/main...
https://github.com/SimHacker/WillWrightShowForFood/tree/main...
https://github.com/SimHacker/WillWrightShowForFood/tree/main...
https://github.com/SimHacker/WillWrightShowForFood/tree/main...
I’ve been bringing Forth and hand-controlled graphics together again on a somewhat unlikely machine: a PDP-7 running in the browser.
Mitch Bradley and Claude recently wrote a beautiful PDP-7 Forth in one day. Its inner interpreter takes three instructions, using XCT to execute thread cells whose opcodes select the behavior. I integrated it into my Cabinet PDP-7 emulator, with a Type 340 vector display, Mitch's 3D turtle written in Forth, and an emulated fictional hand-tracking peripheral, as if the Data Glove + Polhemus existed in 1967, that plugs into the PDP-7 cabinet with its own IOT instructions wrapped with a Forth API.
The browser tracks your hand with the webcam and exposes the coordinates through PDP-7 device registers. Forth running inside the emulated machine reads those registers and draws the hand. The camera processing stays in the browser; only tracking numbers enter the emulated machine, converted to 18 bit integers in the scale compatible with the Forth lookup table trig words and turtle graphics coordinate system. The hand tracking library uses floating point, so the idea is to have the virtual hardware interface do all the pre-processing so it's convenient to program in Forth.
Here’s ULTIMATE HAND, implemented in PDP-7 assembly and Forth:
https://hyperties.org/cabinet/ultimate-hand/
It’s Minsky and Shannon's Ultimate (aka Useless) Machine, except your hand becomes its hand. Allow the camera, hold up your hand with your palm away and fingers up, and the box opens and carries your hand toward the switch. Touch the switch with a fingertip and it retreats into the box. The arm positions the hand, but you control its finger shapes.
Ultimate (aka Useless) Machine:
https://en.wikipedia.org/wiki/Useless_machine
Ultimate Hand Forth code with turtle graphics:
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
Forth datahand device driver:
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
TypeScript datahand PDP-7 device adaptor emulator:
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
TypeScript hand tracking device emulator (MediaPipe wrapper):
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
Simple Forth data hand tester (point the light pen at the fingers to see their names -- the tooltips are in the 340 display user interface overlay, not drawn by the PDP-7):
https://hyperties.org/cabinet/hand/
The Ultimate Machine itself is an emulated fictional PDP-7 device with its own IOT instructions to inspect and control it, whose only purpose is to turn itself off (through a state machine with configurable delays), which exposes its state to the PDP-7 so it can render an animated view with vector turtle graphics with Forth:
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
And it wouldn't be classically Turing Complete without a Turing Machine co-processor device -- a lot like the 340 display -- with its own IOTs and instruction set via DMA, that represents code and tape in PDP-7 memory. When it runs off the end of the tape window, it tapefaults: (temporarily) halting and sending an interrupt to the PDP-7, so it can implement virtual infinite tape memory, potentially using compression, extended memory, or other devices like disk or paper tape:
https://hyperties.org/cabinet/turing/
Turing Machine fictional co-processor device emulator:
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
Mitch’s Forth:
https://github.com/MitchBradley/pdp7forth
The hand device and Forth graphics documentation:
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
Here's a demo of other stuff the PDP-7 emulator can do, including displaying the source code and scans of the line printer listing from 1971 of the original code it's executing:
https://www.youtube.com/watch?v=lo8kdY-5i6c
Did you encounter Marc or Meme? I’d love to hear what other Forth connections you remember from the Autodesk and Sense8 days.
Abstract: The PSIBER Space Deck is an interactive visual user interface to a graphical programming environment, the NeWS window system. It lets you display, manipulate, and navigate the data structures, programs, and processes living in the virtual memory space of NeWS. It is useful as a debugging tool, and as a hands on way to learn about programming in PostScript and NeWS.
PostScript Source Code Available Here: http://www.donhopkins.com/home/pub/NeWS/litecyber/
Introduction: Cyberspace. A consensual hallucination experienced daily by billions of legitimate operators, in every nation, by children being taught mathematical concepts … A graphic representation of data abstracted from the banks of every computer in the human system. Unthinkable complexity. Lines of light ranged in the nonspace of the mind, clusters and constellations of data. Like city lights, receding ....
[Gibson, Neuromancer]
Too bad the PC was more like PCP, the only drug that everything the government tell your about it is true. And Elon Musk's favorite excuse for pissing his pants all the time.
I can't exchange this living shell, give me some salt, and turn me to jell.
The PDP-7 is the 18-bit machine the first version of Unix was written on. It turns out that the PDP-7 instruction set is perfect for Forth, and the "next" inner interpreter is only three instructions, the first being the "xct" execute indirect instruction. It's one of the most elegant implementations of Forth I've ever seen, and has an efficient threading model unique to the PDP-7 that I've never encountered anywhere else.
https://github.com/MitchBradley/pdp7forth
https://github.com/MitchBradley/pdp7forth/blob/main/src/kern...
" --- NEXT: the inner interpreter ---
" Only LAC/LAW-tag cells fall through to "dac i 012"; CAL/JMP-tag cells
" transfer control elsewhere and never reach it.
next: xct i 010 " pre-increment IP, execute the thread cell
dac i 012 " push AC (only reached by constant/variable cells)
jmp next
https://en.wikipedia.org/wiki/Threaded_code#Threading_modelsIt is a hybrid that Wikipedia’s list of threading models doesn’t name explicitly: instruction-encoded threading, with the behavior of indirect threading but without its usual code-field lookup. The project’s design notes describe it as:
Essentially ITC, but the code field is implied by tag bits in each thread cell rather than stored in the body.
The PDP-7 emulator that Claude and I made runs PDP-7 Forth like a bat out of hell. And the point is that if it's this good with antique esoteric PDP-7 assembly, then it's so much more proficient with modern assembly and high level languages that are orders of magnitude more widely represented in the training data like StackOverflow and GitHub, including TypeScript and Python.
https://youtu.be/lo8kdY-5i6c?t=867
OK, I held up my end of the bargain, and gave you the links to high quality AI generated code that you demanded, and even a video demo that shows and explains why it's so elegant and efficient and high quality. As you can see, the PDP-7 emulator also runs the original version of Unix flawlessly.
PDP-7 Forth is a small enough example to inspect, and I've explained the specific design choices I admire. If you think it's low-quality code, what is wrong with it? Can you optimize the inner loop any better, reducing it from 3 instructions to 2?
Before you complain you don't know PDP-7 assembly language: Neither did Mitch or I, but now thanks to Claude's help, we're learning a lot about it with hands-on experience, enough to make CPU and device emulators, an assembler, a disassembler, data visualization tools, improve and extend the Forth system itself, implement device emulators and drivers and apis and testers, and integrate PDP-7 assembly language libraries written in the late 1960's into it and run them. Can you do that yourself without AI in a couple of weeks, while having as much fun as Mitch and I did?
So why don't you review and criticize that code you asked for without using AI, tell me how you would have implemented it differently, then link me to some code you have written yourself without using AI that's at least as elegant as Mitch's PDP-7 Forth, and explain why.
https://donhopkins.com/home/catalog/unix-haters/etc/unix-is-...
https://commons.wikimedia.org/wiki/File:ASCII-Table-wide.svg
https://worrydream.com/ABriefRantOnTheFutureOfInteractionDes...
On the visual pretense: "Pictures Under Glass sacrifice all the tactile richness of working with our hands, offering instead a hokey visual facade."
On touchscreens mimicking real objects without haptics: "Pictures Under Glass is an interaction paradigm of permanent numbness. It's a Novocaine drip to the wrist. It denies our hands what they do best."
On why this design path is short-sighted: "To me, claiming that Pictures Under Glass is the future of interaction is like claiming that black-and-white is the future of photography. It's obviously a transitional technology. And the sooner we transition, the better."
https://www.youtube.com/watch?v=fKMk6fcKbwE
Now that AI makes it so easy to play yer guitar, there's a lot more shutting up to do!
https://hyperties.org/databases/playground/sun-founders-big-...
I prefer the term "Pleasure Programming", to de-emphasize how addictive it is.
>Permission to build useless things.
I prefer the term "Ultimate Things", to de-emphasize how useless they are.
https://en.wikipedia.org/wiki/Useless_machine
>The Italian artist Bruno Munari began building "useless machines" (macchine inutili) in the 1930s. He was a "third generation" Futurist and did not share the first generation's boundless enthusiasm for technology but sought to counter the threats of a world under machine rule by building machines that were artistic and unproductive.
>The version of the useless machine that became famous in information theory (basically a box with a simple switch which, when turned "on", causes a hand or lever to appear from inside the box that switches the machine "off" before disappearing inside the box again) appears to have been invented by MIT professor and artificial intelligence pioneer Marvin Minsky, while he was a graduate student at Bell Labs in 1952. Minsky dubbed his invention the "ultimate machine", but this nomenclature did not catch on. The device has also been called the "Leave Me Alone Box".
So here's a live demo of an ultimate thing I pleasure programmed:
https://hyperties.org/cabinet/ultimate/
What this is:
I've been using Claude to recreationally develop a PDP-7 and Type 340 vector graphics display emulator for the web browser, in order to run an early CAD system called PIXIE, which has the first known radial menus, driven by a light pen, developed at Cambridge in the late 1960's, whose 128 pages of PDP-7 assemblxy language source code the author Heinz Lemke scanned and sent me.
Once I got it working, I told Mitch Bradley about how much I wanted a Forth system for it. Mitch has written useful things like OpenFirmware and CForth, and I was his summer intern at Sun in 1987, where we had a fun time hacking his CForth into CADroid (a circuit editing system developed at LucasFilms) as an extension language and macro system.
https://github.com/MitchBradley/openfirmware
https://github.com/MitchBradley/cforth
http://www.art.net/~hopkins/Don/lang/forth.html
Since then, Mitch developed his Sun Forth system into OpenFirmware for the boot ROMs of systems like the Sparcstation, PowerPC Mac, and the OLPC. So naturally I thought it would be fun to run Forth on the same machine that ran PIXIE, mainly because I'd love to work together and hack Forth with Mitch again after all these years, but also because Forth was the perfect language for the PDP-7.
So then Mitch used Claude to whip up a PDP-7 Forth in one day, with Turtle Graphics!
https://github.com/MitchBradley/pdp7forth
https://hyperties.org/cabinet/forth/
It turns out that the PDP-7 instruction set is ideal for Forth. It has an "XCT" instruction for indirectly executing other instructions, which makes the Forth inner interpreter loop only require 3 instructions.
PDP-7 Forth — Mitch Bradley, 26 September 2026:
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
PDP-7 Forth, by Mitch Bradley:
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
PDP-7 Forth Source Code, NEXT: The Inner Interpreter:
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
" --- NEXT: the inner interpreter ---
" Only LAC/LAW-tag cells fall through to "dac i 012"; CAL/JMP-tag cells
" transfer control elsewhere and never reach it.
next: xct i 010 " pre-increment IP, execute the thread cell
dac i 012 " push AC (only reached by constant/variable cells)
jmp next
Now that Forth runs like a bat out of hell, I'm hacking virtual hardware devices for the PDP-7, and controlling and visualizing them with Forth.First I made an "Ultimate Machine" device for the PDP-7, inspired by Claud Shannon and Marvin Minsky, whose only purpose is to turn itself off!
https://en.wikipedia.org/wiki/Useless_machine
Bruno Munari called it a "Useless Machine", but Minsky was more compassionate, and appreciated its purpose of turning itself off as being ultimately useful, so he renamed it the Ultimate Machine.
I think there are some deep implications to the halting problem, but I can't quite put my finger on it the way the Ultimate Machine puts its finger on its own off switch.
The Ultimate Machine emulator plugs into the PDP-7 emulator as a virtual device cabinet, which has its own device control IOTs that augment the PDP-7 instruction set.
DEC sold a lot of "plug-in instruction sets in a cabinet" like the Type 340 vector graphics display, its light pen, character generator, subroutine executer, advanced math instructions, etc.
https://gunkies.org/wiki/Type_340_Precision_Incremental_Disp...
The Ultimate Machine device, an emulator of device 56 with its registers, phases and IOTs:
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
Then I made a Forth program that draws an animation of the Ultimate Machine on the 340 display, with a switch activated by the light pen. It's not a "simulation" -- it's an actual interactive visual representation of the emulated Ultimate Machine device state that FORTH controls via IOT instructions, the same way it controls the 340 display and light pen!
The Forth 340 view, with the IOT words, the hand, lid and lamps, and the light-pen switch, so you can turn it on (and off) with the light pen (check out the tool tips the emulator user interface shows you when you point at the graphics):
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
Instead of halting there, for even more Turing completeness, I made a Turing Machine device, which is like the 340 display in that it not only adds device control IOT instructions, but also executes its own Turing Machine instructions and tape via DMA from of the same 18-bit core memory as the PDP-7 and 340 display.
The 340 display and the Turing Machine are both co-processors that execute their own instructions from the shared 18-bit core memory of the PDP-7, which generates code for them to execute, and controls them via IOT instructions.
The Turing Machine device issues an interrupt when its head page faults off the edge of the tape window in core, so the PDP-7 can implement virtual memory to support "infinite" tape.
Live Demo:
https://hyperties.org/cabinet/turing/
Turing Engine:
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
Forth => Turing Machine Compiler I made based on Christopher Cherniak's "TM*" courseware from the "Philosophy and Computers" course I took from him in the 1980's:
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
https://terpconnect.umd.edu/~cherniak/philcomp/
https://terpconnect.umd.edu/~cherniak/PhlCogSci.pdf
Ostensibly the real use is for education, but I actually did it because it was fun, and I felt like working with Mitch and programming Forth again.
Forth, the 340, and co-processors in one core: what the cabinet teaches:
https://github.com/SimHacker/WillWrightShowForFood/blob/main...
Here's a demo video that tries to explain it:
PIXIE and FORTH on PDP-7 Cabinet Emulator with Type 340 Vector Graphics Display:
Ixnay on the celinay ingolay.
This reminded me of Tim Davison’s LifeBrush, an interactive VR painting and simulation system explicitly inspired by Goodsell’s illustrations.
In his thesis, Davison describes using it to "structurally recreate, simulate and step inside" famous Goodsell illustrations -- the cytoskeleton demo is a striking example of a painting becoming a world you can enter and set in motion:
https://www.youtube.com/watch?v=6CsxADBpal0
https://hdl.handle.net/1880/111493
I first called LifeBrush "Emacs for Cytoplasm" in a Boids thread and asked Davison whether the molecular motion was slowed down. He replied that medium-sized proteins move around 5 m/s, and that LifeBrush deliberately slows and smooths Brownian motion for illustration. The code was open source; at the time it required a VR headset and had a clunky, research-grade interface.
https://news.ycombinator.com/item?id=22715199
https://news.ycombinator.com/item?id=22724602
https://github.com/timdecode/LifeBrush
The interaction is the magic: in the overview, a ribosome moves along mRNA as tRNA brings amino acids and a polypeptide chain grows. You can grab the ribosome and move it where you want, rather than wait for Brownian motion.
I described it as dragging the ribosome’s "lazy ass" through "tRNA pasta and mRNA meatballs." It’s a scientific illustration you can play with, not a literal molecular-dynamics visualization.
https://www.youtube.com/watch?v=5LBHRyGxLGI
https://www.youtube.com/watch?v=624F5iaCKco
https://www.youtube.com/watch?v=L482dpH9S8o
https://www.youtube.com/watch?v=bUnTEI9QZPE
Davison’s work has since grown into CellWalk, a guided, interactive tour through a bacterial cell, from the whole cell down to its atoms, for iPhone, iPad, and Apple Vision Pro.
And here the Goodsell connection is even more direct: Davison’s site credits David Goodsell, Ludovic Autin, and Martina Maritan with the CellWalk model and tour, based on their whole-cell paper. Davison is now CEO and cofounder of Ako Biotica, the company behind CellWalk.
https://www.youtube.com/watch?v=r8DOAPPjMw0
https://doi.org/10.1016/j.jmb.2021.167351
LifeBrush papers: the 2018 conference paper, followed by the 2019 Computers & Graphics article on painting, simulating, and visualizing dense biomolecular environments.
OpenSteer: Steering Behaviors for Autonomous Characters
https://github.com/meshula/OpenSteer
>OpenSteer is a C++ library for constructing steering behaviors for autonomous characters in games and animation. In addition to the library, OpenSteer provides an OpenGL-based application called OpenSteerDemo which demonstrates a variety of steering behaviors. The user can quickly prototype, visualize, annotate and debug new steering behaviors by writing a plug-in for OpenSteerDemo. [...]
>OpenSteer was initially developed by Craig Reynolds beginning in 2002 at the Research and Development group of Sony Computer Entertainment America. The OpenSteer authors wish to acknowledge the support of SCEA, SCEI and in particular these executives who had the foresight to release this code as open source for all to use: Shin'ichi Okamoto, Masa Chatani and Dominic Mallinson.
Also there's Blender's boids system, which has two main ancestors: Craig Reynolds' behavioral animation research, and Janne Karhu's rewrite of Blender's particle system. Its evolution turned the classic flocking model into an animator-controlled toolkit for flocks, herds, pursuit, and simple battles.
Treating Photoshop's interface as the destination squanders the opportunity to rethink how people create images.
"Things seem to hang on in computing just because they work a little bit." -Alan Kay
From a personal email about MVC and Morphic, published here:
https://news.ycombinator.com/item?id=8841428
"It is an unworthy design objective to aim for anything less than trying to do to the Macintosh what the Macintosh did to the previous state of the art." -Bill Buxton
The "Natural" Language of Interaction: A Perspective on Non-Verbal Dialogues, INFOR: Canadian Journal of Operations Research and Information Processing, 26(4), 1988, pp. 428–438.
https://www.billbuxton.com/natural.html
THE MACINTOSH AS VICTIM
Before going too much further, it is probably worth making a few comments about my approach and my examples. As will become pretty evident, the Apple Macintosh takes a bit of a beating in what follows. Some readers may view this as evidence of contempt for its design. From my perspective, it is evidence of respect. Let me explain.
User interface design today is plagued by an unhealthy degree of complacency. We live in a world of copy-cat unimaginative interface products, where major manufacturers put out double-paged colour spreads in Business Week announcing "... our system's user interface is as easy to use as the most easy to use microcomputer [i.e., the Mac]" (or words to that effect). In what other industry can you get away with stating that you're as good as the competition, rather than better? Especially when the competition's product is over 4 years old!
The best ideas are the most dangerous, since they take hold and are the hardest to change. Hence, the Macintosh is dangerous to the progress of user interfaces precisely because it was so well done! Designers seem to be viewing it as a measure of success rather than as a point of departure. Consequently, it runs the risk of becoming the Cobol of the 90's.
I criticize the Macintosh precisely because it is held in such high regard. It is one of the few worthy targets. If I can make the point that there are other design options, and that these options appear to have a lot of potential, then I may help wake people up to the fact that it is an unworthy design objective to aim for anything less than trying to do to the Macintosh what the Macintosh did to the previous state-of-the-art.
Enough of the sermon. Let's leave the pulpit for some concrete examples.