DonHopkins

https://cars-int.org/

https://cars-int.org/editorial-board/

I found the reference to his 1969 PIXIE paper, which describes his radial menus, in December 1986. His pioneering work inspired me over many decades to publish papers, free open source code, and develop pie menus for X10, NeWS, X11, TCL/Tk, ActiveX, JavaScript, SimCity, and The Sims.

I have been actively tracking down his PIXIE papers, the films, and the listing since May 2008, to tell his story and give him credit while he is still alive and active, and to see and feel first hand how his radial menus worked with a light pen.

I asked Cambridge University Library to help me find the films. David Chapman tracked them down, had them digitized, and the library published them in July 2019, and I made a music video from them in March 2020. I asked Heinz if he had any code listings or other resources. He had kept the listing, and sent me the scan in July 2026.

Please explain and justify which specific objections you have to using AI to OCR and correct the scans of handwritten notes and 128 pages of line printer listings, and implementing an emulator that runs that code in a web browser? Can you suggest a better approach, please?

It simply would not have been possible to do in this time frame at such a low cost without AI, which only just recently enabled a quest I've been on for 40 years since 1986.

I am doing it all on my own time, paying for it all out of my own pocket, while Heinz is still around to help by sending scans of his listings, papers and handwritten notes, generously answering my questions, and patiently explaining the history and details of his work.

PIXIE System Analysis -- Heinz Lemke's handwritten scanned notes and AI assisted transcript:

https://github.com/SimHacker/WillWrightShowForFood/tree/main...

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

How do you suggest I should have done anything differently? Are you volunteering your own time to help out with this project without using AI?

If you want to do cool things without AI, I could certainly use your help manually proofreading the transcript of his handwritten notes, carefully looking at these 128 scanned pages of line printer listings from 1972, meticulously cross checking the octal machine code against the PDP-7 assembly language source, and thoroughly testing and debugging the code in the emulator, or on a real PDP-7 if you are lucky enough to have access to one. The scans, the assembly, and the octal are all here:

https://github.com/SimHacker/WillWrightShowForFood/tree/main...

The version the browser emulator runs is here:

https://github.com/SimHacker/WillWrightShowForFood/tree/main...

Please submit PRs for any errors you find, and I will appreciate and credit your constructive criticism and contributions more than your banal unhelpful low-effort drive-by knee-jerk anti-ai trolling.

Or do you believe I just should not have done any of this research and work at all, nor published it as free open source code for other people and museums to use, nor shared it on Hacker News?

https://en.wikipedia.org/wiki/Digex

The Digex Video! - Part 1:

https://www.youtube.com/watch?v=IsgROO4MIvc

DEF CON 12 - Doug Mohney, DIGEX At the Dawn of the Commercial Internet:

https://www.youtube.com/watch?v=uxMq-x9rlJM

The article also didn't mention the PDP-15, which was the fifth and last 18 bit DEC machine of the PDP-1 => 4 => 7 => 9 => 15 lineage.

https://hyperties.org/cabinet/unix/

Same cabinet runs DECUS DUEL (the spacewar), DEC's light pen test, a lunar lander, and guess-the-number, besides PIXIE and the Forth below.

Here's a music video I cut from the 1969 films of that system running on the PDP-7 and Titan at Cambridge. PIXIE has the first known radial menus:

https://www.youtube.com/watch?v=jDrqR9XssJI

Cambridge librarian David Chapman digitized the uncut films from the Cambridge University Library:

https://www.youtube.com/watch?v=j9R63T2xGCA

https://www.youtube.com/watch?v=lCrl5QmQ9aA

The listing the emulator runs was assembled 12 February 1972. I wanted to look and feel first hand how the radial menus work, so here's that code running in the browser:

https://hyperties.org/cabinet/symelec/

Here's the PDP-7 assembly source code I recovered. The page runs the image it assembles to:

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

I asked Mitch Bradley, who is the Forth guru who wrote OpenFirmware, if there was a Forth system for the PDP-7, so in one day he and Claude created one, including a Turtle Graphics library for the Type 340 vector graphics display! It turns out that the PDP-7 instruction set is perfect for Forth, and its inner interpreter loop is only three instructions.

Mitch Bradley's PDP-7 Forth:

https://github.com/MitchBradley/pdp7forth

How Mitch's Forth works, and my enhancements (full names, CREATE DOES>, PIXIE rings):

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

Video demo of PIXIE and FORTH on the PDP-7 Cabinet Emulator with the Type 340 Vector Graphics Display:

https://www.youtube.com/watch?v=lo8kdY-5i6c

It's easy to make virtual real and fictional PDP-7 devices that, like the actual Type 340 vector graphics display, plug in custom IOT instructions and even perform DMA, like a Turing Machine co-processor, the Ultimate Machine (Minsky's design, which Claude Shannon built, that just turns itself off), and a Data Hand (like VPL's Data Glove) that tracks your hand with the webcam:

Turing Machine (adds IOT instructions and uses DMA to run TM programs out of 18 bit core memory, which it animates with Forth turtle graphics and Type 340 display character generator):

https://hyperties.org/cabinet/turing/

Forth Turing Machine driver and renderer:

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

Ultimate Machine (adds IOT instructions to control and monitor device that turns itself off, and animate it with Forth turtle graphics):

https://hyperties.org/cabinet/ultimate/

Forth Ultimate Machine driver and renderer:

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

Minsky and Shannon's Ultimate Machine (sometimes called Useless, but Marvin considered it Ultimately useful):

https://en.wikipedia.org/wiki/Useless_machine

Data Hand (adds IOT instructions to read hand position, orientation, and pose, and draws hand with Forth turtle graphics):

https://hyperties.org/cabinet/hand/

Forth Data Hand driver and renderer:

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

Ultimate Machine + Data Hand = Ultimate Hand (combines the above devices into an interactive Ultimate Machine that lets you turn it off with your own hand, animated with Forth turtle graphics):

https://hyperties.org/cabinet/ultimate-hand/

Forth Ultimate Hand demo putting it all together:

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

The Type 340 was a real PDP-7 device. Shannon's box was a real box, and the DataGlove was a real glove, but neither was a PDP-7 peripheral. These are virtual devices that plug in the way a real one did: their own IOT instructions, and DMA.

Here's the manifesto about the emulator design:

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

>We control the horizontal. We control the vertical. The machine in the page is ours, all of it at once: every register, every word of core, every device, and the host around them. Nothing here is a black box we have to squint at through a keyhole. So when something would be better, we make it better, from whichever side is closest. The 1960s machine stays honest. Everything around it is ours to invent.

Cabinet Design:

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

>The rule throughout: instance first. Hardwire what SYMELEC needs, comment where the abstraction would go, generate it lazily when a second instance demands it. Work backwards from the software you want to run.

Cabinet README:

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

>An emulator: a stand-in for a cabinet, so the original program can run. PDP-7 is the first plug-in instruction set, for PIXIE. Type 340 on a canvas, light pen as a hit-test.

https://www.reddit.com/r/programming/comments/eaqgk/java_is_...

"XML is like violence: if it doesn't solve your problem, you aren't using enough of it." -Chris Maden

https://www.reddit.com/r/ProgrammerHumor/comments/1mbgih/xml...

"XML is a giant step in no direction at all" -Erik Naggum

https://quotefancy.com/quote/1643080/Erik-Naggum-XML-is-a-gi...

https://www.youtube.com/watch?v=hBA0AH-LSbo

https://www.youtube.com/watch?v=GiQUMypDNoE

Except in this case, the romanticized "nothing" between you and your autonomous agents is a massive, multi-layered stack of legacy Unix abstractions, sockets, remote procedure calls, historic terminal emulators, escape codes, pseudo-tty device drivers, and modern infrastructure slop.

The reality of what is actually sitting between you and your agents:

- A herdr-core background daemon handling JSON-RPC IPC messages.

- A crates/ghostty-sys Rust FFI layer binding against libghostty-vt.

- A hardware-accelerated GPU rendering pipeline drawing terminal cell glyphs.

- A legacy Unix PTY subsystem providing master/slave pairs and terminal line discipline.

- An ancient mountain of VT100/ANSI escape codes and termios settings, with resize requests traveling through IPC and SIGWINCH signals notifying Unix terminal applications.

- A structured agent-status protocol carried by yet another terminal escape sequence, OSC 7501, then exposed through JSON-RPC.

"Nothing" says unfiltered, raw human intimacy quite like reading output from a pseudo-terminal file descriptor and watching \x1b[31m error logs cascade through an SSH pipeline and "pseudo" TTY device drivers.

Wrapping this tech in branding that sounds like a sultry, pseudo-erotic pitch is peak HBO Silicon Valley. TTY literally stands for teletype. We are supposedly building the frontier of autonomous artificial intelligence, yet our cutting-edge orchestration layer still routes interaction through abstractions inherited from noisy, electromechanical printing telegraphs of the 1960s. It's not a "native home for your displaced AI souls" -- it's an over-engineered wrapper shackled to the physical heritage of paper rolls and mechanical carriage-return timing: 110-baud Teletypes, separate carriage-return and line-feed operations, and terminal null padding conventions devised to give machinery time to move before the next character printed.

https://en.wikipedia.org/wiki/Teletype_Model_33