Hello and welcome back to the 8-Bit Guy. So, I’ve been wanting to do a documentary
about the Apple 1 for a really long time. The trouble is, if you want to make a good
episode about the Apple-1, you kind of need to have an Apple-1 on hand. There were only a few hundred produced. I think there’s somewhere around 200 of
them still in existence. And if you’ve got about half a million dollars
in the bank, you could probably afford to buy an Apple 1. But, obviously I don’t have that kind of
money. So, there’s a couple of other choices. One, you can build your own Apple-1, which
is exactly what I’m about to do. This is actually a pretty long process just
finding all of the parts to put one of these together. I’ll talk about that more in a little bit. Another option is, you can buy several different
kinds of kits, this is an example of one, it’s called a Smarty Kit. And this is an Apple 1 compatible computer. So, it’s not a real Apple-1, but it will
run Apple-1 software. But, let’s go ahead and get started putting
this thing together. I’ll start by soldering in all of the IC
sockets. As far as soldering goes, this is the most
time consuming thing. There’s around 63 chips on this board. I know it doesn’t look like that many, but
it’s a lot. That’s somewhere around 1,000 solder joints
just for the sockets alone. It took me about 6 hours to complete this
part. I will say this gives me great respect for
Jobs and Wozniak assembling these in a garage. This would have been a monumental task. In fact, it’s quite interesting to think
about that, as this is quite literally the exact same thing they were assembling. Unfortunately, it turns out I installed these
axial lead capacitors in backwards. For some reason I was thinking the arrows
pointed to the positive side, when they actually point to the negative. I honestly don’t think I’ve ever had to
solder in axial lead capacitors before. Anyway, it was easily corrected. I’m just glad I found out about it before
powering the board up. Most of the soldering is done now, so it’s
time to use some alcohol to clean the flux off of the board. For authenticity, I am also building a power
brick based on the original design. And now it’s time to test the power brick. OK, since nothing blew up, I’ll test the
voltages. And it looks like everything is working correctly. So, now I’ll take it one step further and
test the voltages on the board. Here’s the 12 volt rail. And here’s the 5 volt rail. Everything is looking good! At this point I need to explain a few things
about how this computer works. I want to draw your attention to these numbers
along the bottom edge of the board going from 1 to 18. Likewise along the left edge there are letters
A, B, C and D. These actually form a nearly perfect grid across every major chip on this
board. This is used a lot in the documentation and
between hobbyists to identify specific chips or regions of the board. OK, the next thing I want to mention is that
you can also roughly divide this board into 3 seconds. Over in the top corner you have the regulated
power supply. Down here at the bottom two rows, this is
the actual computer. This is where the CPU, RAM, and ROM live. Up here, the top two rows is the video section. But what’s interesting is that this section
works almost independently of the computer section. In fact, it’s essentially a copy of a glass-teletype
style terminal like this. These terminals essentially just take in ASCII
characters and print them to the screen, taking the place of older type-writer style teletypes
that printer characters to paper. So, the Apple 1 actually sends ASCII characters
one at a time from the bottom of the board to the top to be displayed. This was considered one of the selling points
of this computer. For example, a year earlier you could my a
KIM-1, a single board computer also based on the 6502. But it did require a terminal in order to
use it. And while the KIM-1 was decently affordable
on its own, a terminal could easily cost a thousand dollars or more. So the Apple 1, which sold for $666 was a
pretty good deal. The heart of the video display boils down
to this character ROM, which contains the bit patterns for 64 characters. And guys, this is it. These are literally the only characters that
can be displayed on the Apple 1. There aren’t any graphics modes. There aren’t any graphics characters like
the PET had. There aren’t any reverse characters, and
In fact, there aren’t even any lower-case characters. What’s more interesting is the way in which
this thing works. The screen is 40 characters wide, by 24 characters
tall. So you need to store 960 characters. But, where is all of that data stored? You see, there isn’t any video RAM either.. Well, at least not in the traditional sense. It uses shift registers. Now, a typical shift register is a chip that
handles 8 bits of data. And all 8 bits are exposed as their own pin
on the chip so that each bit can be input or output. Then the data can be shifted around. These are used for all sorts of things. But the Apple 1 uses a really unusual type
of shift register. This one has 1,024 bits. I can’t even draw them all on the screen. And, only one bit is actually exposed at a
time. As such, the chips are surprisingly small. Here are some of them right here on the board,
as you can see they are little 8-pin chips. Of course, one of these chips wouldn’t be
enough to store all of the characters on the screen, but if you have 6 of them together,
now you have enough to store 1,024 characters. Unfortunately, this creates one of the biggest
limitations of the Apple 1’s video system. There is no way to modify characters at random
on the screen. You are pretty much limited to sending out
new characters and having the screen scroll. Of course, this was quite common on older
text terminals, because they exactly mimicked the behavior of a teletype, which is obviously
limited to printing characters in this manner. As you can imagine, you aren’t going to
be playing any arcade games on this thing. So, back to our assembly. I’m going to populate all of the chips needed
to run the video display only. Because for the moment, that’s all I want
to test. And so here we go. In theory this should give us some sort of
video display. OK, so I’ve reached the point where it’s
time to test. Now granted, I’m only, I’ve only populated
the video section, so the computer is not going to boot up, but I should get some sort
of display since the video is essentially independent from the rest of the computer. But, I’m really nervous about it because
I have literally spent the last two weeks working on this project. It is by far the hardest build that I’ve
ever done. It’s not just the soldering. Yeah, there’s a lot of soldering. I probably spent like 8 hours soldering stuff,
but it’s just been so many other things that have made this much more difficult than
you’re typically computer kit that you would put together. I would not recommend this project to anyone
who is looking for a beginner project. This is way harder than I thought. And, I’m also probably about 800 dollars
in the hole for this already. In other words, these parts are not cheap. They are really hard to find and they are
really expensive when you do find them, so if I fry something here, this is, it’s not
a trivial thing. So. I’ve also spent the last few months looking
for the perfect monitor for this computer. Now, you have to think about this for a moment. You’ve got to go back to 1976, what kind
of monitor would you use on a computer? I mean, televisions did not have composite
inputs back then. Right? So you’d have to get an RF modulator if
you wanted to use a television. There was no such thing as a computer monitor,
or at least not that the consumer could go get. But, there were these. And what I have here is a CCTV security camera
monitor. It’s just a black and white monitor and
it does have a composite input. And this is exactly the sort of thing that
an Apple 1 user would have probably been using in 1976. Now, actually, even many Apple 2 users ended
up using monitors like this. Anyway, this is about from the right era and
I think this will be a perfect match for my Apple 1, so let’s hook it up and see if
we get a display. Well, at first I thought it was dead. But then I remembered there was a little adjustment
on the board for video level, so I tried turning that, and what do you know, I have a video
signal! The fact that it looks like random garbage
characters is not a problem. It just means the video RAM hasn’t been
cleared yet. So, this is a really good sign. Actually, the next thing I’m going to do
is manually apply 5 volts to the clear-screen circuit. And sure enough, that works and I get a blinking
cursor at the top left. Yes, the Apple 1 uses an AT symbol for a blinking
cursor. So, time to move on, I’m going to populate
all of the chips for the computer section. Here’s the most important chip of all, the
6502 microprocessor. And so I think I’m ready for the next power
on. Well, I don’t think there is any CPU activity
as the screen is still junk characters. But then I remembered that I had neglected
to solder a few connections on the board, such as this one. There’s a little pad you need to put a blob
of solder on if you are using a 6502 microprocessor. Believe it or not, this board is also designed
to take a Motorola 6800 CPU instead, but you need some extra things to make it work. For example, you need to put a chip in this
socket, notice it says 6800 only. And this whole area up here would need to
be populated. But since I am using the 6502, I’ll just
solder across this little pad. Oh, and I also need to setup the RAM banks. These are very configurable. This is a testament to the fact this computer
was designed for hobbyists to tinker with. Anyway, I’ll need to put some little jumpers
here and there to configure the RAM setup. And even if I did get this working, I need
a keyboard to test with. I bought this one online. I think it may have been a pull from an Apple-2,
but it’s close enough to the right era, I think it will work. The trouble is, it won’t sit flat on the
desk because of the daughterboard on the bottom, so I cut out these little pieces of wood. They look like doorstops, actually. But I think they will work fine to prop the
keyboard up. The next thing I needed to do was build an
adapter cable based on this design here, since the the pinout of the Apple 2 keyboard is
different from the Apple 1. OK, so here goes nothing. I’m going to power it on. Now I’ll clear the screen, as there is no
key on the keyboard to do this. Then I’ll press reset on the keyboard. And ladies and gentlemen, I think it is working. So, the operating system on the Apple 1 is
insanely primitive. The ROM code is only 256 bytes. Compare that with something like a Commodore
VIC-20, which has 16 Kilobytes, that is literally 64 times the amount of code. There is no BASIC or anything like that. It boots up to something called WozMon, which
is just a really simple system for typing in code. The idea is you can type in machine code from
the keyboard, which let’s face it, was quite common in that era. But the operating system on this thing is
just one step above a computer with toggle switches to enter in the byte code. So, that being said, what can we do with this
thing? Well, now I have an excuse to show you these
manuals. This is a perfect re-creation of the Apple-1
manual. These are made by a guy named Armin who lives
in Munich, Germany. The manual isn’t huge. But it does contain the entire source code
to the operating system. Of course, it fits on just two pages, because
again, it’s just 256 bytes in size. It also contains a full schematic of the computer,
which was not uncommon at the time. And of course, Apple Computer’s first ever
warranty page. I also have here a recreation of the magazine
advertisement for this product. It was advertised as a microcomputer system
with a video terminal and 8K of RAM. But anyway, what I really want to draw your
attention to is this example program in the manual. This is just a test program and it’s only
11 bytes long. So, this shouldn’t take too long to type
in. And so, as I’m typing this into WozMon,
I’m thinking about the fact that this is most likely the very first thing most Apple-1
owners would have typed in on their computer. And they were probably anxiously awaiting
to see the result. And so here we are. I’m going to have it list back the machine
code. Everything looks correct. So now I’ll tell it to run the code. And there we go. This is probably the first thing every Apple
1 user saw when they setup their computers back in 1976. And they probably saw it on a monitor just
like this. It’s basically just a repeating pattern
showing all of the characters that the computer can display and it will keep scrolling forever. So what about using BASIC? Well, most of the modern Apple-1 clones include
BASIC in ROM, which is very convenient. But the original Apple-1 sold in 1976 didn’t
have BASIC in ROM, so you had to load it from cassette. But in order to do that, you’d need the
ACI, or Apple Cassette Interface. This plugs into the expansion slot and it
also contains two more PROM chips, which add another 256 bytes of ROM to the system. Let me demonstrate. If you boot up the Apple 1 and ask Wozmon
to show you the memory contents at C100, you’ll see that area is totally blank. So now what we’re going to do is insert
the card, obviously with the system powered off. While we’re at it, let’s go ahead and
connect up a cassette recorder. This is about the closest thing I have for
the time period. We just need to connect the earphone and microphone
jacks, and they will connect right here on the cassette interface. Now I’ll repeat the same test, having a
look at memory in the C100 range. And as you can see, there is ROM data there,
this is reading straight off the ACI card. So here’s how you use it. We’ll tell Wozmon to start the ROM code
at C100. The asterisk indicates we’ve entered the
cassette interface software. So now I’m going to tell it to load a program
into the memory range of E000 to EFFF, and the R at the end stands for read. If I wanted to write, I’d put a W there
instead. At this point it’s waiting on some data
from the cassette. I have a copy of BASIC on this cassette, so
I’ll load that into there. And press play. And there we go. It’s loading. You don’t really get a lot of feedback that
anything is happening. But at the end of the load you’ll get the
little backslash which indicates you are back in Wozmon again. So, we can start basic by executing the code
at E000. And it works. The way we know we’re in BASIC is that the
prompt has changed from a backslash to a greater than sign. And of course, you get more friendly error
messages like syntax error. But anyway, we’ll write a small test program
just to see. I apologize, I still don’t have a backspace
key wired up correctly, so I can’t fix my typos. But anyway, there you go. BASIC code running on an original Apple 1. Of course BASIC programs can be considerably
more complex, which is easier to show with an emulator here. And there are even some very primitive games
like this one where you try to govern an ancient city. Which apparently I did terrible as all of
my people starved. You can even run the classic game Star Trek
from that same era. So, obviously most people aren’t going to
have the time, money, or patients to assemble an Apple-1 replica. But I wanted to show some alternatives. And I’ll start by showing the SmartyKit,
which I mentioned at the beginning. This kit is a solder-less design. It uses micro-controllers for the video and
keyboard input. Putting this together is more like putting
a puzzle together than electronics. Unfortunately, I didn’t have time to finish
this before the video. I think I’ve got about 25% of it complete. I also wanted to mention the PE6502 computer,
which is also Apple-1 compatible. I did a whole video on this a few years ago. So there are a variety of Apple 1 emulators
out there to play around with. But the one that might surprise you the most
is this one that runs on a Commodore 64. It’s called Green Delicious, but I hesitate
to call this an emulator, though. It’s more like a virtual machine. The main difference being is that the code
actually runs natively on the C64’s CPU since they are both 6502 derivatives. The only thing the C64 has to emulate is the
keyboard and terminal display, which isn’t really that hard for a C64 to do. It completely emulates the font, and even
gives us a colorful Apple logo for the flashing cursor. And everything works pretty much as expected. F1 works as the hardware clear-screen button. F7 works as the CPU reset button. F3 changes the screen colors for common monochrome
styles like green, white, or amber. F5 will toggle between the apple-logo cursor
or the standard @ symbol cursor that the real Apple-1 uses, for authenticity. Now, while I don’t think it can read Apple-1
cassettes, it has included BASIC in ROM, which is handy. And they’ve given us a makeshift disk loading
system so we can load additional software from disk instead, along with a few example
programs. Clearly the Apple-1 never supported a disk
drive, but this is pretty handy. And here I am playing Apple-1 version of Star
Trek on my Commodore 64. Who would have thought. So, I’m not planing to cover any of the
history of this computer as I feel that’s really well documented in some high budget
movies as well as some other YouTube channels. But, I wanted to give you an overview of how
this computer actually works and let you see a real one in action. I say real, I mean this is about as close
as you can get to the real thing. And while this episode is coming to an end,
the story of this computer is not yet done. I’m going to hand this over to my brother,
who’s going to build some sort of case for this and do an episode on his channel, the
GeekPub. So, keep a lookout for that. I also wanted to give a shout out to Uncle
Bernie who runs an ebay store carrying some of the more obscure parts that’s really
hard to do find for this, and he was also able to answer some questions I had which
was very helpful in getting this thing put together, so I’ll put a link down in the
description for that too. But that’s about it for this episode, so
as always, thanks for watching!
