If you are passionate about Retrocomputing, classic hardware, and the Raspberry Pi, the universe of the PiDP replicas It's literally a treat. Not only do they allow you to relive legendary systems like the DEC PDP, but they do so with a visual and functional fidelity that appeals to both veteran collectors and makers who want to tinker with something very different from a modern PC.
Within this ecosystem, the PiDP-1 replica to recreate the PDP-1 computer with Raspberry Pi It occupies a very special place: we're talking about a machine that's at the origin of hacker culture, video games, and the first experiments in graphics and AI. And the best part is that, thanks to projects like Obsolescence Guaranteed and the community behind them, today you can have a fully functional version on your desktop, with lights, switches, and a workflow virtually identical to that of the real machine from the late 50s and early 60s.
What was the PDP-1 and why is its replica, the PDP-1, so special?
The PDP-1 (Programmed Data Processor-1) was one of the Digital Equipment Corporation's (DEC) first commercial minicomputersIntroduced around 1959, it broke with the idea of gigantic, inaccessible mainframes: it was more compact, relatively affordable for the time, and, above all, interactive. Only 53 units were manufactured, and its price, adjusted for current inflation, is estimated at around $1,3 million, so forget about finding one on eBay for your living room.
Beyond the numbers, the PDP-1 is famous because It gave rise to the MIT hacker culture and is now part of modern interactive computing.It was the birthplace of the legendary game Spacewar!, one of the first video games in history, and revolutionary tools such as one of the first digital text editors. It was also used for experiments in graphics, music, and primitive multi-user systems with typewriter-style terminals.
The PiDP-1 replica seeks to capture precisely that spirit: a computer with a console full of lights and switchesConnected to a vector display system (the famous Type 30 monitor), it encourages experimentation with assembly language, graphics, games, and historical tools. It's not just a pretty case with a Raspberry Pi inside; the project aims to recreate, as closely as possible, the complete experience of using a real PDP-1, but in a home-friendly and relatively affordable format.
Behind the PiDP-1 is the work of Oscar Vermeulen and collaborators such as Angelo Papenhoff, within the umbrella of Obsolescence GuaranteedThe same group that has brought to life other very popular replicas such as the PiDP-8/I, the PiDP-11 and the PiDP-10. The PiDP-1 is their most ambitious foray into the territory of DEC's origins and the systems of the early 60s.
PiDP-1 physical design: front panel, variants and aesthetics DEC
One of the most striking things about the PiDP-1 project is the care that has been taken in clone the aesthetics of the original PDP-1DEC, back in the day, couldn't quite decide on the console's design: they manufactured some desktop versions, others with the panel mounted on the side of the rack, and alternated between white and blue front panels. That historical "indecision" has been very consciously carried over to the modern replica.
PiDP-1 kits are supplied with interchangeable panels in white and bluerecreating the two variants that DEC used. In addition, there is both a "rack" version for those who want to emulate the rack installation of the original systems, and a more compact "console" version, designed for desktop use and for those who prioritize practicality or the demoscene approach.
If you opt for the rack variant, the project even considers that You can also have a console-style caseSo you can swap out the boards whenever you want a different look, just like DEC changed its design over time. It's a nice way to keep that legacy of endless aesthetic evolution alive.
Contrary to what one might think, the PiDP-1 does not resort to a 3D printed casing as the primary solution. The chassis and front panel are made using custom PCB boards soldered togetherThis gives it a look much closer to the industrial finish of the equipment of that era. The front panel integrates the classic blinking lights (status indicators) and toggle switches that allow direct interaction with the registers and memory of the emulated machine.
This PCB approach, similar to that seen in the PiDP-8/I and PiDP-11, gives the assembly a very solid and professional appearance, far removed from a simple homemade project assembled with random parts. Visually, the result It's very close to what a real PDP-1 console was like.but in a smaller, more manageable format.
Internal architecture: Raspberry Pi, minimal electronics, and circuit-level emulation
Inside the PiDP-1 there is no discrete CPU or dozens of cards like in the original PDP-1: the heart of the system is a Raspberry Pi (typically a Raspberry Pi Zero 2 W (in the publicly displayed developments) which handles the emulation part. Along with it, on the panel board, only a few 7400 logic chips, diodes, switches, and LEDs are needed to build the physical interface.
What's truly unique about the PiDP-1 isn't so much that it uses a Raspberry Pi, something quite common in retro projects, but rather the type of emulator it runs. Angelo Papenhoff studied the PDP-1 schematics in detail and developed a circuit-level simulation in VHDLnot only at the logical level. That simulation was later ported to C so that it could be run directly on the Raspberry Pi.
This means that the emulation performed by the PiDP-1 does not only replicate the instruction-by-instruction behavior, but also It attempts to simulate the machine at the level of internal signals and cyclesThe goal is to achieve very high temporal fidelity (cycle by cycle), something that on a computer so slow compared to current hardware doesn't pose a performance problem. On the contrary: there's plenty of headroom to emulate each transition in detail.
Some define it as an “absolutely cycle-exact” emulation, an ambitious claim but consistent with the type of approach taken. For those who want study in depth the architecture of the PDP-1This level of simulation is pure gold: you have at your disposal a model virtually identical to the original hardware, but accessible from a simple C code file and from a common Raspberry Pi.
All of this relies on a GNU/Linux-based software environment for the Pi, similar to other PiDP projects. The Pi handles input and output from the panel, interaction with the radar-like "monitor" (simulated or real, depending on the configuration), and loading the various recovered historical programs. Essentially, it's a embedded Linux system hosting an extremely faithful simulation of the PDP-1.
Available historical software: games, graphics, music, and development tools
Although the PiDP-1's hardware is spectacular, it truly comes to life in the historical software ecosystem that can runIn the case of the PDP-1, it must be taken into account that we are going so far back in time that many things have been lost along the way: there is not the same abundance of operating systems, applications and games that there is for other more modern machines such as the PDP-8, PDP-10 or PDP-11.
Even so, a surprising amount of material has been preserved, which is usually grouped into three main blocks: graphical demos, early video games, and user programsWithin the world of demos, the PDP-1 is practically the starting point: when combined with the Type 30 vector graphics display, programmers of the time began experimenting with shapes, animations, and visualizations simply because they could, without a clear commercial objective. It's the proto-demoscene, so to speak.
In games, the undisputed star is Spacewar!, rightly considered as one of the first video games in historyThe PiDP-1 allows you to play it in a way very similar to how it was played in the 60s, with the same style of vector-based graphics on slow phosphor. You can also run other interactive demos and small experimental games that were developed as proofs of concept for the Type 30.
As for user programs, a small but interesting toolset is retained: a text editor (ET)It also included a macro assembler (MACRO) and the famous DDT debugger, considered one of the first debuggers in computing history. With only 27 instructions in the PDP-1's CPU instruction set, the development ecosystem was surprisingly accessible: it was possible to understand real code from that era with a simple opcode cheat sheet.
In addition to native assembler, high-level languages such as Lisp and FORTRANLisp, for example, was ported by Peter Deutsch, a prodigy who, at a very young age, also implemented the REPL (Read-Eval-Print Loop) concept that we now immediately associate with environments like Python. In the context of the PiDP-1, some of that historical software can be run, opening the door to studying "in situ" how programming was done in those languages more than half a century ago.
Complementing this, the modern community has developed convenient cross-assemblers and even C compilers These tools generate code for the PDP-1, making it easier to write new programs and demos without having to do everything directly from the emulated console. This combination of contemporary tools with a historical machine model is perfect for those who want to create new content (demos, games, visualizations) while respecting the limitations of the original architecture.
The Type 30 display and vector graphics: the visual heart of the PDP-1
One of the key elements to understanding the appeal of the PiDP-1 is the Monitor Type 30The graphic display device most associated with the PDP-1 was not a raster monitor like those used today, but a cathode ray tube derived from radar technology, with slow phosphor and no image memory: the screen lit up when the electron beam passed over a point and darkened in a short time, so the elements had to be redrawed continuously.
This monitor's interface was extremely simple: the system took bits directly from the input/output log to interpret them as X/Y coordinatesAnd with that, points or lines were drawn on the screen. Thanks to this simplicity, the PDP-1 was capable of rendering around 20.000 points per second, more than enough to display primitive interactive graphics and striking visual effects.
In the PiDP-1, great care has been taken to ensure that this graphical aspect is also an integral part of the experience. The simulation of the Type 30 is essential for both games and other applications. graphics demos and musical experiments original. It's still a complete mindset change for anyone used to working with conventional pixels and framebuffers: here you're controlling a beam that travels through space, not a grid of static pixels.
This conceptual difference is precisely one of the great attractions for those coming from the current demoscene or from the development of 8-bit retro video games. Instead of struggling with color and scrolling limitations, in the PDP-1 environment the challenge is to make the most of a vector graphics system with a very small instruction setwhile maintaining a sufficient refresh rate to ensure the image is stable for the human eye.
It's no coincidence that the PDP-1 team insists the Type 30 is an "integral part" of the replica. While the original machine had other important peripherals (such as the magnetic storage drum for swapping 4K-word pages or the interfaces for multiple typewriters as terminals), what truly defines the popular image of the PDP-1 is that monitor where Spacewar! and the first graphical demos came to life.
PDP-1 Architecture: 27 Instructions and “Poetry” in Assembler
The PDP-1 had to encode each instruction in 5 bits, which implies a maximum of 32 different codes. DEC settled on 27 actual instructions, reserving some codes and applying a clever approach: "Swiss Army knife" instructions Those that did not need a memory address used the remaining 12 bits to activate different internal functions of the machine using flip-flops.
This allowed, for example, a single instruction that, depending on which bits were active, could clear the accumulator, erase the I/O register, or activate other special operations, all packaged in a single word. It was a way to maximize the use of a very small instruction set while still offering great control flexibility.
The practical consequence is that the The PDP-1 instruction set literally fits on a small reference sheet.It's compact enough that someone with a basic understanding of computer architecture can learn it quickly and start reading real programs without getting lost. The community often refers to this machine's code as a kind of "logical poetry" because of how direct and transparent it is.
Of course, this simplicity comes at a price: to build complex programs in an environment with so few instructions and resources, programmers of the time had to be very resourceful. Even so, this limitation has become part of the charm for those who approach the PiDP-1 from a modern programming perspective: working with 27 instructions and limited memory forces them to to think about code in a radically different waywhich is an excellent school for algorithm design.
Analyzing the behavior of these instructions within the circuit-level emulator of the PDP-1 adds another layer of interest. You not only see what each opcode does, but also how internal signals propagate, how cycles are synchronized, and how the different registers interact. For architecture students or hardware enthusiasts, it's a nearly unique opportunity to "get inside" a historic computer without needing physical access to one of the few remaining original PDP-1s.
Relationship with other PiDP projects: PiDP-8/I, PiDP-11 and PiDP-10
Although the PiDP-1 is perhaps the most exotic because it goes so far back in time, it is part of a Raspberry Pi-based PDP replica family which has gained a lot of popularity among enthusiasts worldwide. Each one targets a different DEC machine and they share a common philosophy: faithful front panel, functional lights and switches, and simulation running on a Raspberry Pi with emulators like SimH or specific variants.
The PiDP-8/I was one of Oscar Vermeulen's first major successes: a clone of the PDP-8/I that combined a very attractive front panel design with a relatively affordable kit. From there came the PiDP-11, 6:10 scale replica of the PDP-11/70Perhaps the most popular minicomputer in history and one of the first to run Unix widely. This machine also uses a Raspberry Pi with the SimH emulator, capable of reproducing the memory state in real time through the console and reading the position of switches.
The PiDP-11 reached such demand that Vermeulen found himself waiting lists and limited productionSince it can only assemble a limited number of kits each month, it doesn't include the Raspberry Pi, power supply, or SD card. Even with those components, the cost is light years away from the roughly $20.000 that an original PDP-11/70 could cost back in the day, not counting inflation.
Another twist is the PiDP-10 project, a replica of the DEC PDP-10 KA10 mainframe computer from 1968This machine was an icon at MIT's AI lab during the 1960s and 1970s: it played a key role in early artificial intelligence research, hacker culture, and the birth of network computing. The PiDP-10 uses a Raspberry Pi 5 with Raspberry Pi OS (based on Debian) and SimH to provide a complete system simulation, including even reproducing known failures of the original hardware.
The PiDP-10 features a plastic control panel with 124 lights and 74 switcheswhich faithfully reproduces the front panel of the PDP-10 KA10. At the software level, it can run the multitasking and multi-user TOPS-10 operating system, as well as ITS, the alternative system developed at MIT. TOPS-10 allows users to explore advanced features for the time, such as full support for multiple users and concurrent processes, direct influence on later systems like MS-DOS, and a wide range of applications and programming tools.
At ITS, meanwhile, more than 400 historical applications have been recovered from MIT tape archives, many of them related to research, system utilities, and classic games like Adventure. In the context of the PiDP-10, the replica serves not only as a retrocomputing toy, but also as Practical Linux server (network storage, media server, up to 10 users, etc.), always keeping the PDP-10 simulation with its control panel accessible.
User experience, community, and educational opportunities
The philosophy behind all these projects, and the PiDP-1 in particular, is to promote hands-on experience with historical machinesIt's not just about looking at them as museum pieces, but about turning them on, programming them, tinkering with the registers, experimenting with their assembler, and understanding firsthand where many ideas that we take for granted today come from.
In the specific case of PiDP-1, the team is aware that the catalog of historical software is more limited than that of other PDPs. Therefore, one of their objectives is to attract... new generations of democoders and creative developers Those who want to push the PDP-1 architecture to its limits with new games, intros, and demos for the Type 30 vector monitor. The message is clear: if you're making demos for the 6502 or Z80 with pixel graphics today, here's a completely different challenge with vector graphics.
To enhance all of this, the project includes a development page on Hackaday where progress updates, photos, and technical explanations are displayed, as well as a dedicated page on the Obsolescence Guaranteed website. From there, you can link to the GitHub repository, where anyone can download the emulator's code, examine it, and contribute if they wish.
Other PiDP projects have also shown a clearly educational aspect. For example, the PiDP-11 includes a prototyping area on the board, which allows connecting sensors and I2C devices to expand the system's capabilities, turning it into a kind of "Retro" home automation platformSimilarly, the PiDP-1 encourages the use of its control panel and direct access to the machine's internal state to experiment with external hardware and learn old-fashioned digital electronics.
On the other hand, the community surrounding these kits has generated a wealth of resources: assembly videos (such as Beige-O-Vision's series for the PiDP-11), scanned manuals of the original equipment (for example, Bitsavers' PDFs for the PDP-11/70), and tutorials on how to configure historical operating systems in emulators (TOPS-10, ITS, various older Unix systems, etc.). Taken together, all of this makes PiDP replicas... ideal tools for training in architecture, operating systems, and the history of computing.
How to test a PDP-1 today: emulation on a laptop or Raspberry Pi
Although the PiDP-1 is the most visually striking and “tangible” way to approach the PDP-1, the project creators also encourage those who are curious to Try the simulation on a laptop or a bare Raspberry PiWithout any extra hardware. From the GitHub repository, you can download the emulator and run it on Linux, giving you a fully functional virtual PDP-1 without needing any physical kit.
This option is perfect if you want first experiment with the development environmentThe assembler, debugging tools, and historical programs are useful before you decide to build a panel with lights and switches. It's also ideal for teachers who want to prepare lab exercises or classroom demonstrations without requiring additional hardware; a computer and a Linux system are all that's needed.
Later, if you fall in love with the system (which is quite likely if you're into the inner workings of computers), you always have the option of upgrading to the PiDP-1, PiDP-11, or PiDP-10 kit, depending on which historical period or architecture appeals to you most. In all cases, the software that runs on the hardware replica is the same as what you can use on your PC, which makes things easier. Easily migrate projects, programs, and configurations between both environments.
For many retrocomputing enthusiasts, this combination of accessible emulation and detailed physical replicas It represents the best of both worlds: on the one hand, you have the historical accuracy and romanticism of consoles with blinkenlights; on the other, the convenience and robustness of modern hardware and the ability to work comfortably from your usual development environment.
This entire ecosystem of PiDP-1, PiDP-8/I, PiDP-10, and PiDP-11 demonstrates the extent to which it's possible to keep alive systems that marked the beginning of interactive computing, video games, hacker culture, and AI research. Being able to power up a replica of the PDP-1 today, play Spacewar!, examine assembly code with DDT, or program new vector graphics with just a Raspberry Pi and some solder is a very powerful way to connect the the more distant past of computing with current technological concerns.
