The Benevolent Grue; DOCTYPE; Insert Cartridge/Cassette
We’re kickin’ it old-school in the Friday Drop, with three retro resources that will both entertain and educate.
TL;DR
(This is an LLM/GPT-generated summary of today’s Drop. This week, I continue to play with Ollama’s “cloud” models for fun and for $WORK (free tier, so far), and gave gpt-oss:120b-cloud a go with the Zed task. Even with shunting context to the cloud and back, the response was almost instantaneous. They claim not to keep logs, context, or answers, but I need to dig into that a bit more.)
- Microsoft has open‑sourced the original Zork I‑III source code under an MIT license, preserving a foundational piece of interactive‑fiction history (https://opensource.microsoft.com/blog/2025/11/20/preserving-code-that-shaped-generations-zork-i-ii-and-iii-go-open-source)
- The DOCTYPE magazine provides printed web‑project tutorials that require readers to type HTML, CSS, and JavaScript by hand, reviving tactile coding practice (https://vole.wtf/doctype/)
- Retro Game Coders delivers step‑by‑step tutorials and browser‑based tools for creating 8‑bit style games, helping preserve and teach retro programming techniques (https://retrogamecoders.com/)
The Benevolent Grue
West of House You are standing in an open field west of a white house, with a boarded front door. There is a small mailbox here.
Even some sociopaths can do something OK once in a while!
Microsoft just officially open-sourced the original source code for Zork I, II, and III under the MIT License. This is genuinely significant for gaming history and software preservation. These games, created by Infocom in 1980-1982, essentially defined interactive fiction as a genre and pioneered technical approaches that were ahead of their time.
The real engineering brilliance wasn’t just the storytelling – it was the Z-Machine virtual machine. When the original mainframe Zork was too large for home computers (Apple II, Commodore 64, IBM PC), Infocom split it into three games but ran them all on the same VM. This made Zork one of the first truly cross-platform games. Instead of porting code to each system, they just needed a Z-Machine interpreter for each platform. Sound familiar? This is the same concept Java would popularize a decade later with “write once, run anywhere.”
The games were written in ZIL (Zork Implementation Language), which is a refactoring of MDL (Muddle), itself a LISP dialect created at MIT. The source code shows how they handled natural language parsing, world state management, and interactive narrative branching in an era of severe memory constraints.
Each of the three repos (I; II; III) contains:
- Original ZIL source code files
- Build notes and documentation where available
- Historical artifacts from Infocom’s development process
- Commentary and unused code that shows their development thinking
The code represents a snapshot from Infocom’s final shutdown. So while it may be canonical, it might not be exactly what shipped commercially since the original ZILCH compiler and build tools are lost to time.
This wasn’t Microsoft creating new repos. They worked with Jason Scott (the legendary digital archivist from Internet Archive) to submit pull requests to existing historical repositories, adding proper MIT licensing and documentation. This approach preserves the archival integrity rather than fragmenting the historical record.
The license covers only the source code itself. No commercial packaging, trademarks, or brand rights are included. The games themselves remain commercially available via GOG’s Zork Anthology.
You can actually compile and run this code today using ZILF (created by Tara McGrew), a modern compiler that can turn ZIL files into Z3 format files. Then you can run those in any Z-Machine interpreter like Frotz. The fact that 40+ year old code can still compile and run is testament to the Z-Machine’s design longevity.
This triple-release is pure gold for anyone studying early game design patterns, virtual machine architecture, and natural language processing. You can also don your best Indiana Jones gear and play the part of a software archaeologist to see how code evolved, what got discarded, and what patterns they reused.
I don’t know how long this division at Microsoft will be around, but their Open Source Program Office seems to be sociopath-free? After acquiring Activision (which owned the Infocom IP), they’re also using their position to ensure this foundational game code isn’t lost to bit rot or legal limbo. The MIT License ensures maximum accessibility for education and research.
DOCTYPE
I still remember the crackle of the CRT as I painstakingly copied line after line of BASIC from one of many computer hobbyist magazines back in the day, then hunted for that elusive missing bit that kept my little program from running. There was a quiet thrill in watching a block of code come to life after you’d typed every character yourself and a small, stubborn pride in knowing you’d built something from scratch rather than just pressing “run”. DOCTYPE magazine taps that same feeling, but it swaps 8‑bit sprites for HTML, CSS and vanilla JavaScript and hands you a fresh, printed page of web projects that you type into any text editor, open in a browser, and watch work without a single copy‑paste.
The idea is deliberately inefficient, which is precisely why it works. By forcing you to read every tag, every brace and every event listener, the magazine turns what today feels like a click‑and‑drag task into a slow, tactile exercise that sticks in memory. Ten complete projects – from a space‑themed “Meteors” demo to an emoji‑hunting game and a handful of other quirky toys – are laid out in full, with no hidden build steps or npm packages. All you need is a browser and the willingness to type, debug the occasional typo, and feel that small rush when the page finally renders the way you expected.
Behind the print is the offbeat collective VOLE.wtf, a group that loves making the web feel a little strange again. Their aesthetic plays with retro‑futuristic covers and meta‑code backgrounds, reminding us that the internet doesn’t have to be a mass‑produced assembly line of dependencies. In this terrible time of ours where AI can vomit up a whole app in seconds, there’s something oddly satisfying about opening a magazine, turning a page, and letting your fingers do the work.
I cannot wait for my copy to arrive in the post, and will likely do a follow-up article with some home-taken meatspace captures.
Insert Cartridge/Cassette
Retro Game Coders harkens back to a time when every clock cycle was a precious commodity, and available RAM’s worth was measured in kilograms of gold-pressed latinum. If you ever even once fell in love with the 8‑bit machines of yore, you can tap this resource to pick up a new hobby or deepen an old passion.
The site is all about learning by doing. Instead of just reading about how games were made, you actually sit down with hands‑on tutorials that walk you through the process step by step. Whether you’re curious about how to squeeze a three‑dimensional maze out of a language called XC=BASIC 3, or you’re just trying to figure out why the BASIC you grew up with never seemed to understand a modulo operation, the lessons break things down in the same way an avuncular mentor might. There are also very deep rabbit holes into the code of classic titles, showing you how the legends of the era pushed hardware to its limits. And, then there’s a look at how you can apply those same ideas with modern tools while still keeping the spirit of those old systems alive.
One of the spiffier components of the site is the set of tools the creators have built for the browser. A tiny pixel‑art editor lets you paint sprites that look like they belong on a vintage screen, and there’s even a map‑making program called Dungeon Loom that helps you sketch out the twisting corridors of a text adventure without ever leaving your modern computer. These utilities let you experiment and create without having to hunt down a physical floppy or a dusty old monitor, but they keep the constraints and quirks that made programming on the C64 such a unique challenge.
Why does all of this matter now? Well, I don’t know about y’all, but I continue to need a deep mental break from waves hands outward wildly. However, there are even better reasons. The lessons you’ll learn on a machine that could only remember a few kilobytes of data or perform a handful of operations per second translate surprisingly well to today’s world of tiny embedded devices and performance‑critical code (not every system has 64 GB of speedy RAM).
The clever tricks for speeding up a BASIC program or the clever ways developers worked around missing features are still useful ways of thinking about efficiency. And perhaps more importantly, the site helps preserve a slice of computing history that might otherwise fade. By keeping the knowledge of those early days alive, Retro Game Coders gives us a chance to remember the thrill of making something magical out of limited resources, and to pass that sense of wonder on to a new generation of coders.
FIN
Remember, you can follow and interact with the full text of The Daily Drop’s free posts on:
- 🐘 Mastodon via
@dailydrop.hrbrmstr.dev@dailydrop.hrbrmstr.dev - 🦋 Bluesky via
https://bsky.app/profile/dailydrop.hrbrmstr.dev.web.brid.gy
☮️
hrbrmstr's Daily Drop 
Leave a comment