DEC’s Early Computers: PDP-1 Architecture and Interactive Demo

Name: Hacking on the PDP1 Raspberry Pi Emulator - Computerphile
Uploaded: 2026-05-06T14:45:00+00:00
Duration: 24 min 19 s
Channel: Computerphile
Description: Summary and key takeaways on Hacking on the PDP1 Raspberry Pi Emulator - Computerphile — Summary, covering Historical Context DEC avoided the term “computer”

Computerphile

May 06, 2026

•

24 min video

•

2 min read

YouTube video ID: 7WEewUVQabU

Source: YouTube video by Computerphile — Watch original video

PDF

DEC avoided the term “computer” early on because it evoked IBM‑style payroll business machines. The PDP‑1, released in 1960, was an 18‑bit machine with 4 kilowords of memory and marked the first purchasable system in that lineage. The later PDP‑7 became the platform where Ken Thompson developed Unix in 1969. Gordon Bell, the chief architect of most of the line, later called the 18‑bit family a mistake because software could not easily move between models. The PDP‑11, introduced in 1969‑1970, unified the architecture and introduced byte‑addressing, ending the era of word‑addressed machines.

Pre‑DEC Foundations

The TX‑0 served as a simpler, one‑off predecessor to the PDP‑1, while the TX‑2, a 36‑bit machine, enabled Ivan Sutherland to create Sketchpad, the first computer‑aided design system. Project Whirlwind, begun in 1950 for cockpit simulation, pioneered core memory, modems, and graphical displays. The SAGE system (AN/FSQ‑7) expanded Whirlwind into a massive air‑space monitoring installation.

PDP‑1 Technical Overview

The front panel displays the machine’s internal state with rows of lights that represent flip‑flops. Registers include the Program Counter (PC), Memory Address (MA), Memory Buffer (MB), Accumulator (AC), and In‑Out (IO). Programming uses octal (base‑8) notation, where three binary bits correspond to one octal digit. DDT (Digital Debugging Tape) functions as an interactive debugger, allowing manual stepping and inspection of memory. Paper tape serves as the primary storage medium; the reader processes roughly 300–400 lines per second, with each word encoded on three lines.

Demonstrations

Minsky Circle Algorithm

Marvin Minsky’s circle algorithm links the X and Y coordinates directly instead of deriving each new point from the previous one. This prevents the spiraling error that arises from repeated approximations and keeps the plotted circle stable.

Minskyron

Minskyron links three oscillators in a feedback loop. Switches control the division (shifts) of each oscillator, producing intricate, chaotic patterns as the oscillators interact.

Interaction Shift

The PDP‑1 exemplifies the move from batch‑processed mainframes to interactive, personal computing. Manual programming, real‑time debugging with DDT, and direct control of peripherals such as paper tape illustrate how users could engage with the machine in a hands‑on manner, foreshadowing modern microcontroller development. As one speaker put it, “I call it the first microcontroller except it took up a whole building.”

Takeaways

DEC deliberately avoided the word “computer” to distance its products from IBM‑style batch processing machines.
The PDP‑1 introduced an 18‑bit, 4 kiloword architecture that paved the way for later interactive systems like the PDP‑7 and PDP‑11.
Front‑panel lights, octal coding, and the DDT debugger gave users direct, real‑time control over program execution.
Marvin Minsky’s circle algorithm stabilizes graphics by linking coordinates instead of iteratively calculating points.
The PDP‑1’s hands‑on operation with paper tape and interactive debugging marked a clear shift toward personal, interactive computing.

Frequently Asked Questions

Why did DEC avoid calling its early machines “computers”?

DEC avoided the term because it evoked IBM‑style payroll business machines, which the company wanted to differentiate from. By using alternative language, DEC positioned its products as experimental, interactive systems rather than conventional batch‑processing computers.

How does the Minsky Circle algorithm maintain a stable circle on the PDP‑1?

The algorithm links X and Y coordinates directly instead of deriving each new point from the previous one, which prevents cumulative approximation errors that cause spiraling. This direct linkage keeps the plotted shape stable and accurate.

Who is Computerphile on YouTube?

Computerphile is a YouTube channel that publishes videos on a range of topics. Browse more summaries from this channel below.

Does this page include the full transcript of the video?

Yes, the full transcript for this video is available on this page. Click 'Show transcript' in the sidebar to read it.

Helpful resources related to this video

If you want to practice or explore the concepts discussed in the video, these commonly used tools may help.

The Soul Of A New Machine Book Recommended

This Pulitzer Prize-winning book chronicles the intense engineering culture at Data General, providing deep historical context for the era of minicomputers like those produced by DEC.

Amazon →

Vintage Computer Front Panel Replica Kit

These kits allow enthusiasts to interact with physical switches and LED displays, mimicking the hands-on experience of operating a PDP-1 or similar early minicomputer.

Amazon →

The Idea Factory Bell Labs History Book

This book covers the foundational research and technological breakthroughs that enabled the development of systems like Whirlwind and the early DEC architectures.

Amazon →

Breadboard Electronics Kit With Leds

Provides a hands-on way to understand the flip-flop circuits and logic gates that form the basis of the PDP-1's architecture described in the video.

Amazon →

Links may be affiliate links. We only include resources that are genuinely relevant to the topic.

Summarize another video

Full Transcript YouTube

First we will look a little bit into the
history of these machines and uh we uh
we use the PDP1 here as sort of our
central uh starting point. The PDP1 um
designed in like the 8 the late 50s 59
uh sold starting in 1960 and about 50
were built and sold by deck. Um, and I
think it's a very good uh starting point
to explore this whole history if you're
interested because um, we then have a
couple of PDP models branching out from
this, but there's also a history to the
PDP-1. So,
>> so the deck is a digital electronics
corporation.
>> Digital equipment corporation.
>> Equipment corporation. Okay. And they
were obviously a computer manufacturer
in America.
>> Yeah. They didn't call it computers back
then because that evoked uh notions of
IBM style like payroll business machines
very hard to access like you give your
punch punch cards to someone and so on
and these are uh a different tradition
very interactive and more personal and
the PDP1 uh was sort of the first one
that you could buy in that lineage.
The PDP1 was an 18- bit machine. You can
see it here. 18 bits and 4 kilows of
memory originally. So a word is again 18
bits. Didn't have any bytes yet. That
came in the mid60s. So after the PDP1
which was a little bit more
experimental. Deck was a startup
essentially at that point. When they had
more customers, they had different needs
and the company was expanding. So the
first model after the PDP1 was
surprisingly not the two or three. That
was like an old business strategy that
didn't pan out. Um, but it was actually
a PDP4,
uh, which was also an 18- bit machine,
but not really not compatible with the
PDP1. Like they had the same peripherals
to some degree, but not quite. And they
reused these uh, architectures again.
They built new machines that were more
or less compatible. So the seven was the
next. And that one is perhaps a bit
famous for being the machine that Unix
was developed on by Ken Thompson. 1969.
Uh they again built in a machine in that
uh family the 9 and the 15. Uh we're not
going to talk about that.
>> Those just kind of different capacities
or
>> Yeah. So essentially they they
rededicated like they flipped one bit
from being an address bit uh from being
an instruction bit to being an address
bit. So you get 8 kilows of memory on
the PDP4 and in this family, but you get
only half of the instruction space. Um,
and so in Unix, uh, you see that, um,
because the kernel has 4 kilobytes of
memory and the user has 4 kilobytes of
memory and with a PDP1, you would only
have like 4 kil time sharing on a PDP1
was done a bit differently. Um,
>> so yeah, kilows is a new one to me, but
I
>> Yeah, people are not used to kilow, 24
words then.
>> Yeah. Okay.
>> Right. Um so that was uh sort of the
first thing that uh uh that they built
and afterwards uh came the PDP5.
>> What sort of things were these used for?
Were they were they what who were their
customers?
>> Um so the idea initial idea was to make
a more a cheaper uh PDP-1 essentially
and also use it for things like process
control lab equipment that sort of
stuff. um things where the computer is
part of a system and not just the system
itself crunching numbers like uh like a
mainframe would do uh like doing
scientific I don't know weather
simulations or whatever and eventually
you you'd have uh the result but it was
something that you know talk to talk to
the real world
>> and so there was a smaller uh uh family
um which is kind of a stripped down 18-
bit family condensed into 12 bits.
That's the PDP 5, 8, and 12. Uh so these
are very minimal and really just to like
more more of the lab equipment type and
uh process control even though people
did time sharing and such on the PDP8 as
well. Um and it's a very popular
machine. There's a big PDP8 fan
community. Um and the PDP8 was the first
uh that Oscar made. And on the other end
we have the PDP 6 and the PDP 10. So the
PDP 6 and 10 uh were 36bit machines uh
meant for time sharing such that
multiple users could use the machine at
the same time. Also sort of designed to
run lisp well which was a popular
programming language uh in AI circles
and around MIT where these machines came
to be. Um, and yeah, so so that is like
the the on the wide end of the word size
36 bits.
>> I'm just going to ask a question if
that's all right because obviously
you've mentioned the word AI, right? And
we're now talking about the 1960s. I
mean, this is, you know, become massive
nowadays, but it isn't this, you know,
what we're going through now wasn't the
start of AI, was
>> right. uh AI at the time at that time
meant something like um symbolic
differentiation or chess programming um
stuff like this um so symbolic AI good
oldfashioned AI not the neural networks
uh I mean the neural networks uh go back
quite some time but this was not really
what people uh did because the computers
weren't there yet so this is sort of the
uh the PDP family and there's one
important piece missing which is the
PDP11 introduced in 1969 like around uh
70 and this kind of uh pulled everything
or almost everything together a bit. So
uh it's a single architecture that is uh
that has small machines PDP 1105 for
things like what a PDP8 would do maybe
um but also bigger machines um maybe a
PDP1140 which ran Unix or on the bigger
on the higher end a PDP170 which was
quite um yeah quite a capable machine.
Um it did not quite replace the the PDP
6 and 10 uh style machines. Um but they
later uh built the vax the like a 32-bit
reinterpretation of the PDP11 but this
was 16 bits and so they had this these
two uh as their flagships uh essentially
and this became like ancient history
which is why people don't know so much
about them anymore. And these are very
familiar. These have bytes like bite
addressing which people take for granted
these days but these don't have bytes
yet. These are all word addressed. Um
>> so that those B I mean they they were
pioneering machines those ones but
basically we're going to have a look at
what came before.
>> Yeah. I mean everyone was pioneering at
the time had no choice but uh yeah
people had to figure out uh what
computers should be like. Um, for
instance, Gordon Bell, who was the
architect on essentially all of them
except for the PDP1, uh, said this this
18- bit line was a mistake because it
was not compatible with the with the 18-
bit PDP-1 and they didn't, uh,
appreciate the like portable software
yet, being able to run,
>> being able to write,
>> right? they they thought oh well you
just write the program for the new
computer and then but yeah uh software
quality like the the value of software
was not uh was not on people's minds
apparently back then
>> and and I suppose um when I say
pioneering I think I guess I mean they
laid some of the foundations that we
still use today but yeah
>> yeah like the PDP11 uh and vax are like
very normal computers from today's stand
points of view you can you can read
PDP10 assembly or vax assembly and it's
it's not too foreign. Whereas when you
go back to these older machines, it
becomes a bit less familiar. Um but on
the other hand, they are also very
simple. Uh like the PDP1 is not a
complicated machine for instance. Um so
you can still understand it. It just
takes a little shift in the perspective
perhaps.
>> Mhm.
>> And so there's also prehistory which
we're not going to cover, but the PDP1
had uh was preceded by the TX0 and these
were one of machines. Now that we're
talking about, these were like
production machines that were sold, even
if maybe not too many. Um, but the
earlier stuff only existed uh once. So
the TX0 was also an 18- bit machine, but
much simpler than the PDP1. Um, there is
also a TX2,
which was a bigger uh 36-bit machine uh
famous for being the machine that
Sketchpad uh was written on by Ivan
Sutherland. uh the uh first CAD system,
you might say. Um and this it goes uh
back a little further to the memory test
computer which was really part of
project whirlwind.
So whirlwind one was there was that
machine um originally to do um cockpit
simulation but it didn't really pan out
and they built a digital computer
instead. uh I call it the first uh
microcontroller except it took up a
whole building but essentially that was
the idea to have a computer that
interacts with the real world. So this
is where it starts.
>> What what era is that then? uh well when
one was operational more or less or
became operational during 1950
and
>> so it's kind of post-war kind of things
>> right they had difficulty with uh
finances because the war stopped and uh
well luckily for them the cold war
started so they got money again
>> and uh that is how the whirlwind 2 you
might call it but it's perhaps better
known as the computer of the sage system
uh the an
FA Q7
um that was like a a bigger version of
the whirlwind one essentially built all
over the US for airspace monitoring. Um
it was never it never really had a
purpose because shortly after they had
intercon uh intercontinental
uh missiles and like
they never got to use it essentially. So
yeah, this is uh the the history that
we're talking about and the whirlwind
one was what what core memory was
invented for here. We got modems and
like displays were already were on the
whirlwind and this kind of uh goes down
into the tree. So we have this whole uh
history of interactive controller type
um personal perhaps uh computers. And so
again the PDP1 is uh sort of our central
piece here and uh we will now look a
little bit into what the computer how it
works and what to do with it how to use
it using the PDP1. Um we're first going
to look a bit at the front panel, what
it shows and how to use it. And then
we'll use it to uh draw the circle uh
that uh uses the algorithm that Marvin
Minsky discovered. Um and also the
Minskyron which is based on that uh
algorithm which is a very uh nice
looking demo and it's also you can play
with the switches and uh it's very
satisfying to play with. So what you see
on the panel, all these lights are
almost all of the state that the the
PDP1 has. All the internal flip-flops
are visible as lights on the panel,
which you need because if the machine
isn't working, and back in the day, the
machine was not working quite a bit. Um,
you have to make it work again and you
have to see uh the machine state. Um,
this panel doesn't have all the lights.
there was an IO panel and peripherals
would have more lights and so on. But
this shows everything important really.
So we have two registers up here, the
program counter and the memory address.
Program counter is the same as you would
expect today. It's the address at which
to fetch the next instru instruction.
Memory address is the register that
holds the address for the memory word
that is being addressed by the computer.
So it's just an address and the memory
buffer is the data that either came out
of memory or was written back into
memory. So at the end of a memory cycle
uh the MB register would show what is in
memory at that location shown at memory
address. And the accumulator and inout
register are what the programmer uses.
And as you can as you can tell from the
name in out is also connected to the uh
peripheral equipment IO stuff. So the
accumulator is the arithmetic register
that control with with your program uh
more or less and IO was also used for uh
like as an auxiliary register also when
we display a point it will be x and y
coordinates one register is x one is y
and uh the address in the uh in the
basic machine is 12 bits here but we
have a memory extension we can use up to
64 uh kilohz 12 only gives you 4 kohz
and uh 64 kil other words for the
maximum what a PDP1 could do. So here we
have uh like a run light and a cycle
light and so on. These uh run is
obviously when the machine is running
it's not running yet. And this is
internal flip-flops that we're not going
to uh go into in much detail. Uh the
power switch obviously turns off the
power and on again the sense switches
could be used by a program just to read
like general uh inter user interaction.
you can read them and the program flags
are kind of similar. They can be set and
read by the program to its will and they
can also be connected to some uh
peripheral uh equipment like when you uh
use the light pen and it sees a spot uh
it might uh light uh set the program
flag for the pen here. Uh and we have
the instruction register so five bits
that encodes the instruction. So now
let's uh put something into memory. We
have the Minsky circle algorithm here.
Um, it's not a lot of words. And we have
the symbolic assembly on the right here.
And I just wrote down the binary code,
an octal, uh, that encodes these
instructions. So,
um, you have to know octal, of course.
Oh. Oh, and on the left we have the the
address where this where we put this
into memory.
>> So, because yeah, just to remind me,
that's base eight, isn't it? Octal. Is
that right?
>> So, three bits are one octal digit. It's
very easy to u like it it's very quick
uh to get into really. So if you have
the upper bit that's a four. If you have
the middle bit that's a two and if you
have the lower bit that's a one. And so
if you have multiple you just add them.
So that's five. And at some point you
just don't think about it anymore. You
just read octal and toggle in binary or
you read binary. Um so let's do a couple
of instructions manually with the front
panel. We start at address 1 0 0 and the
word that's supposed to go here is 7 all
up six which is four and two one and the
rest zeros.
Now uh pressing deposit up
uh puts this into memory. We see memory
address 1 0 0 and memory buffer 7 6 1 0
0. Oh, actually I made a mistake. That's
the second instruction. That's no
problem. We could just change the
address and put it in location 101
instead. Easy. But now we have to do the
first instruction of course. So that is
two 0 0
1 1 3.
So 2 0 0 1 1 3. Uh so you can already
tell it's easy to make mistakes and that
is why I don't really want to do this on
the front panel so much. It's very
tedious. Um but just to make sure uh
that we also check the examine uh
switch. Let's look at our previous
previous word and uh press examine. And
then we see our six uh 761 again. So now
let's do the rest not on the front panel
but actually using the debugger DDT. DDT
is the debugger and it's uh it's an
insecticide. So a debugger. So I have
DDT mounted as a paper tape in the
reader. It will be above the front panel
here. We have it on screen. Um and when
you press read in the machine knows the
format of the tape and goes through it
and you can see the address being
counted up here where things is things
are being put into memory and eventually
it's going to jump into DDT.
Okay. So now we're interacting with a
typewriter here.
>> Would that have been the sort of speed a
paper tape to to run or is it?
>> Yes, it's the original speed like uh
there are different numbers given but uh
400 lines per second is is about right
something like 300 400. Um okay so now
let's confirm that what we have put into
memory is indeed correct. So uh at
address 10 0 0 we have exactly the
instruction uh that I wanted to put
there. And by pressing backspace we can
check the next one
and equals gives us the octal.
And so now I just do the rest. Um I can
do sum
in octal directly. This will be the next
instruction.
and
and the next one and the rest one uh the
other ones I will just do symbolically
because that's something DDT can also
do. So we are now at 104 and that is
supposed to be DAC 114
deposit accumulator. Okay, so now we
finished uh putting this into memory
using DDT and we see um by examining uh
successive locations that uh we have
this code in memory now which is the one
that I want to execute. DDT was quite
popular on other machines as well. There
is a whole tradition of these
interactive debuggers. It doesn't start
with DDT but uh DDT is fairly wellnown.
Okay, so we now finished putting the
program into memory. Uh we can examine
the memory locations with DDT and we see
the code which is the one I uh wanted to
put in there. And now we want to start
this program. Uh one way to do it is
with the front panel. So we stop DDT
because we're still running. So run is
now off. And we put in our start address
which is 1 0 0. Hit start.
And there we see the circle.
>> So what's happening there? It's kind of
the equivalent of find a point, print a
dot there, move a bit, print a dot
there. Um right it starts with a single
point and essentially with a little bit
of uh approximate trigonometry you you
would move the point uh with a small
angle but if you approximate it it
spirals out because it's just an
approximation. So Marvin Minsk's
discovery was that uh you don't
calculate the new point from the pre
previous point but that the x and y
coordinates are sort of linked and if
you do the math you find out that it
actually remains stable. So that was a
very cool discovery and there is a
program called the Minskyron obviously
named after Raminsky which is three of
these circles kind of linked together.
So one oscillator is is connected to the
second one, the second to the third, and
the third one again to the one to the
first. And you have settings on the
switches which control them. And you
have a very cool demo. And this is
exactly what we're going to do now. So
um we we'll put the
>> So this is where we use the magic of the
emulator to load it back in. Right.
>> Right. Uh oh, actually no. Uh let's do
one one thing first. We want to perhaps
punch this onto paper tape because we
like this program and want to run it
again without toggling it in again. So,
we go back into DDT, which is at 600 0.
So, stop the machine, start there. We're
back in DDT. And now we uh punch a tape.
Uh we start with a title, capital L, and
we might call it circle.
And we see it punched on the paper tape
as
>> as just so you can read it. Uh,
>> so you know what that tape is,
>> right? With tap, we go into punching
words now. And our words start at 1 0 0
and it goes up to 114.
And now we see the words being punched.
And we just have to give it our starting
location now, which is 100 or 10 0.
There it is. And now we can like rip off
the tape. Uh, which we do with the
emulator here. Uh,
>> so you're basically saving that, right?
program.
>> Exactly. So, we now storing that the
file already existed. It's fine. So, uh
we now have our paper tape which came
out of the machine and now we want to
put it back into the reader. So, here we
go. There it is. And obviously, we still
have it in memory, but it doesn't really
matter. So, just read in the tape goes
in and it jumps into the circle program.
>> Ah, so that last instruction on the tape
is basically run,
>> right? It it just executes the
instruction from uh from paper tape
really
>> and on the tape I think we've done a
video on paper tape and computer file
before but each line is basically some
code is it
>> yeah one word is three lines and there's
different formats like readin has a
special hardware format but it's not the
most space efficient and so there's more
efficient loaders but yeah uh but that's
how it works and that's how you would
perhaps program the machine and punch a
program onto tape and Yeah, very
interactive and nice to use. Um, you
could of course use an assembler, but
that's a bit more uh involved. Okay, so
now let's uh go into the Minskyron. So
we uh load this demo tape here and read
it in. Takes a while.
Uh that's the snowflake, but we don't
want that. Uh we want Minskyron. It
starts at 5 0 and it needs some initial
switches. If we if we start like this,
it's just very noisy because all these
shifts that are done in the Minsky
algorithm which is a very easy division
by a by a number power of two number um
we can set these shifts now. So let's
just try something.
>> So you just randomly well
>> more or less random. I have some
intuition but not too much. Um but you
can see how we have this feedback
between these three oscillators now.
>> And if you observe it for a while it
will go crazy. Or if you change the
switches you can just change them and
hit start and you get a different
pattern. And you can you can really have
fun uh exploring all these possible
patterns here. And sometime like this is
the the typical display after after some
time it was would just go crazy.
>> Say PDP1 you're drunk go home.
>> Yeah exactly.
Uh but it's very very fun to explore for
sure and I can really recommend doing
that. There's a very good website where
you can do it as well. Um Masvak
Minskron. If you Google Minskron you
will find it easily. Um so kind of in a
chaotic mode right now. Let's see.
But yeah, this is this is what you can
do with a with this very simple circle
like just goes character by character.
So we get that uh compare against the uh
end of the string marker and uh until
that is the case we just uh print the
character on screen. So to see that in
action, uh let's call the B command and
give

MIT OpenCourseWare

May 18, 2026

Watch Read Summary

PDF

Pre‑DEC Foundations

PDP‑1 Technical Overview

Demonstrations

Minsky Circle Algorithm

Minskyron

Interaction Shift

Takeaways

Frequently Asked Questions

Why did DEC avoid calling its early machines “computers”?

How does the Minsky Circle algorithm maintain a stable circle on the PDP‑1?

Who is Computerphile on YouTube?

Does this page include the full transcript of the video?

Helpful resources related to this video

Share This Summary

Embed This Summary