The MOS Technology 6502 is a microprocessor which casts a long shadow over the world of computing. Many of you will know it as the beating heart of so many famous 8-bit machines from the likes of Commodore, Apple, Acorn, and more, and it has retained enough success for a version to remain in production today. It’s still a surprise though, to note that this part is now fifty years old. Though there are several contenders for its birthday, the first adverts for it were in print by July 1975, and the first customers bought their chips in September of that year. It’s thus only fitting that in August 2025, we give this processor a retrospective.
The Moment Motorola Never Really Recovered From
The story of the 6502’s conception is a fascinating tale of how the giants of the early mocroprocessor industry set about grappling with these new machines. In the earlier half of the 1970s, Chuck Peddle worked for Motorola, whose 6800 microprocessor reached the market in 1974. The 6800 was for its time complex, expensive, and difficult to manufacture, and Peddle’s response to this was a far simpler device with a slimmed-down instruction set that his contact with customers had convinced him the market was looking for: the 6502.
There’s a tale of Motorola officially ordering him to stop working on this idea, something he would later assert as such an abandonment of the technology that he could claim the IP for himself. Accompanied by a group of his Motorola 6800 colleagues, in the summer of 1974 he jumped ship for MOS Technology to pursue the design. What first emerged was the 6501, a chip pin-compatible with the 6800, followed soon after by the 6502, with the same core, but with an on-board clock oscillator.
If you were one of the small group of very geeky kids in the early 1980s who really used their home computers instead of merely gaming it’s likely you are part of the only generation ever to have a playground one-upmanship over processor architectures. Those of us with a Z80 in our Sinclair machines would cite the higher clock speed, while the Commodore owners would talk about the 6502’s pipelined architecture and smaller instruction set.
With the benefit of many decades’ hindsight it’s fair to say they had a point, and one that the Z80’s ability to flip between two sets of registers on a dime couldn’t make up for. The 6502 was quick, it had a reliable manufacturing process, and since MOS Technology sold it to anyone for a surprisingly reasonable price rather than restricting it to big-bucks industrial customers, it or one of its many derivatives was a natural choice for much of the first generation of home computers and consoles. If you had an Acorn, an Atari, a Commodore, an Oric, or an Apple 8-bit machine you would have had one, and if you had a Nintendo console you also joined the 6502 club.
Just Who Is Still Buying A 6502?
It’s still not too difficult to find dedicated defenders of the 6502 among those now in their 50s geeks who owned an 8-bit computer when they were new. Just as with their Z80-fan friends, they come from an era when it was possible to fully comprehend the architecture of your computer at nearly gate level. It’s thus understandable that both architectures lingered on in the world of embedded computing long after their heyday on the desktop had passed, but it’s still a surprise to find the WDC version of the chip still in production. Unlike other surviving 8-bit architectures such as the 8051, this is the real thing in a 40-pin DIP rather than a core found embedded in other chips, so we’d be curious to know: aside from a small number of retrocomputing enthusiasts, who is still buying these things? The Z80 finally shuffled off this mortal coil last year, so how long has the WDC W65C02 got left? We’d be curious for your views.
Speaking personally, I had a foot in both camps. Like many British kids of the early 1980s I could save enough pocket money for a Z80-based Sinclair ZX81 of my own, but I had access to a room full of 6502-powered Acorn BBC Micros at school. I thus painstakingly hand-assembled Z80 code for the Sinclair, and was blown away by the built-in assembler in the Beeb. But did I have a favourite? Perhaps not, after all the most important lesson is one I only fully understood years later; that far more important than what architecture a computer uses is what you can do with it. And in that, to my profound sadness as a Sinclair fan, the 6502-powered BBC Micro won hands-down.
Header image: Dirk Oppelt, CC BY-SA 3.0.
I’ve never understood why the 6502 so “went viral” with home computer manufacturers and game console makers. (AI claims the reasons were “cheaper,” “easier to integrate,” and “ease of programming.” I only believe the price argument.) I’m not going to second-guess why Intel priced the 8080 so much higher than the 6502. Eventually the bottom must have fallen out of the market, or Radio Shack’s Z80-based computers never would have been competitive.
The 6502 instruction set makes more sense than the Z80/8080.
Absolutely my experience self-teaching assembly/machine code.
“The 6502 instruction set makes more sense than the Z80/8080.”
That’s because the 6502 is a memory-oriented machine (as are all Moto 68XXXs), while all 80XXX derivatives are register-oriented machines. (Ask a hardware designer to design a computer…you’ll most likely get a register-oriented machine)
This is the reason why the majority of engineers and programmers involved in the IBM-PC project at Boca Raton preferred the Motorola processor over Intel’s offering.
[as an aside—it’s really a shame that the bean-counters at Boca didn’t have to program a machine which had to be programmed via the ‘segment:offset” nonsense in order to get a “20-bit machine”…]
That’s funny, because the Sega Genesis/MD had both an 68000 and an Z80.
The Z80 was the sound co-processor, but it also was the main processor of the older Master System console.
Which interestingly, the Genesis/MD is backwards compatibility to.
Well, mostly. FM chip of the Japanese unit is missing and not all video modes are being supported, but most are.
Anyway: By using a cartridge adapter, Master System cassettes can be installed and the Z80 gets wired to be the main processor.
Why I’m writing this? Because it’s interesting that both a register-oriented and memory-oriented CPU used to work in tandem.
Some sort of symbiosis, if we will.
Also interesting is the rivalry between NES (6502) and SMS (Z80).
Both consoles used to be popular here in Europe of late 80s and early 90s.
But even though the Z80-based version was technological superior, the NES with its pastel color palette won the hearts.
Which is a bit ironic, considering that the overly popular C64 (6510) also had a pastel like color palette..
“Ironic” is probably not the word to use. Maybe “coincidentally”?
So many people moan about programming for segmented architecture, but I still consider this a brilliant design. Not because it made new coding easier but because it allowed you to take your 8080 source code, assemble it as-is, load it into memory with suitable segment registers, and BAM: it runs exactly as it did on the 8080, with the segment registers providing separation (memory “protection”, provided you didn’t mess around with the segment registers).
The NEC V20/V30 used some sort of register-mapping or register-renaming to run unmodified i8080 code in their “8080 emulation mode”.
Hence they didn’t support Z80 instructions, the i8086 instructions set merely built upon the existing i8080 instructions set.
The PC-88 VA series had the obscure NEC μPD9002 CPU,
which is said to have been using an V30/V50 core with full Z80 compatibility.
Another interesting feature of 8080 emulation mode was that it supported access to both 64KB of data and code.
That’s more than the real i8080 was able to address.
“with the segment registers providing separation (memory “protection”, provided you didn’t mess around with the segment registers)”
So what you are saying that if you didn’t mess around, you are protected?
Isn’t protection a thing that prevents problems IF you mess around?
It’s like saying that you don’t need seatbelts as long as you don’t make an accident?!?
Memory mapped IO is a flexible concept allowing you to add functionality during design, the CPU is no limitation at the expense of additional memory decoding and a gap in memory space, although via bank switching that’s a thing relatively easily solved as was done in the C64 for instance.
@Jan I think it was meant like this:
The 8086/8088 uses segments of 64KB size each.
Which equals the whole 64KB address range of earlier 8080.
If you don’t mess with segmentation, then a single 64KB segment remains in use all time.
That means that each ported 8080 program can remain limited to its own 64KB range and can’t interfere with others.
Plain COM files on DOS usually don’t exceed 64KB, either, by the way.
@Robert Good point, whatever. It was simply meant as textual transition here! 😅
Cheaper was one thing but easier to integrate was definitely a thing compared to the 8080 with its requirement of a two-phase external clock and a three-voltage power supply — ±5 V and +12 V — as opposed to the 6502 with an internal clock generator and requiring only a single supply of +5 V.
Personally I also found the 6502 easier to program than the 8080, but I will not go as far to say it was better.
The i8080 was pretty much being superseded once the Z80 was out.
I don’t think the i8080 played any significant role anymore by late 70s.
Not in new developments, at least.
The i8085 and semi-Z80 code compatibles such as NSC800 were much more interesting and useful.
The i8085 was popular among teachers and microcontroller users, I think.
The Z80 had a single 5v operating voltage and an internal DRAM refesher, though SRAM -once being affordable- was a better choice anyway.
The Z80 was the defacto CP/M processor (for MP/M too).
While plain CP/M was using plain i8080 instructions, Turbo Pascal for CP/M-80 relied on the advanced Z80 registers.
Terminals often used Z80s, too, I think. Could be wrong, though.
The Sega Master System had used an Z80, as well – arch rival Famicom/NES used an 6502 derivative.
Nowadays, there’s an 6502 “port” of CP/M, also..
Base 6502 did not have an internal clock generator, that was the C-64 version.
I once looked at upclocking my Apple 2, but the TTL clock generator was tangled up with the video generating shift register.
I came to my senses and got a new computer.
6502 initially took off simply because it was much cheaper.
I liked the 6502 fancy memory addressing modes, e.g. load Accumulator from the Xth address in the table or load Accumulator from the address + Y.
Did pointer math in one instruction.
From what I remember and from a 1975 (the year it was produced) data sheet (https://web.archive.org/web/20211204234443if_/http://archive.6502.org/datasheets/mos_6501-6505_mpu_preliminary_aug_1975.pdf), the 6502 did not require an external clock generator and could work with just an external capacitor and resistor as shown in page 10 of the data sheet.
You can’t just overclock an Apple II, anyway; too much relies upon the CPU running at the stock speed—including disk access. So, Apple II accelerators drop to normal speed when certain memory ranges are accessed.
The 6502 allowed for simpler/cheaper circuit designs, I suppose.
If you’re working with a low clock frequency, all the support chips and circuit traces can be of lower quality (sub standard).
You don’t have to take care of signal reflections (sharp edges of traces on PCB), you can use defective RAM parts
and other stuff that doesn’t meet the official ratings but “still work” to some degree when
being heavily underclocked/running at a slow bus speed and generous duty cycles.
The data rates of the time didn’t really require careful PCB design. Even the 68K at 8MHz could work just fine with wire wrap.
Intel was stuck running their external busses at 25MHz for a year or so because they didn’t have any RF guys or HAMs on staff.
Turns out, 90 degree turns of many parallel traces is a bad idea.
I had problems with reflections on a modified S-100 motherboard in a system with a 6 MHz Z80 CPU. Some clock lines had to be terminated. Different brands of TTL chips had different threshholds; reflections that caused a Signetics counter to double-trigger didn’t bother other brands.
True. It was easy to make single board conputers with Veroboard. Just wire together a cpu, eprom, ram, maybe an uart or bit banging logic for serial port, and some TTL glue logic and you got a working conputer. I used to port in my spare time a minimal Fig-Forth to all 8 bit CPUs I got hold of.1802, 6800, 6502, 8085, Z80, 68008, 8088. With a typical 4 MHz clock frequency, they were easy to get running. Just connect all same named pins together – A0 to every other A0, D0 to every other D0 and so on, then some chip select logic and hey presto! Not so easy with current gigahertz clock rates ..
Did a 25mhz 68030 in wire wrap for my final year project. Of course the beauty of wire wrap is it’s semi chaotic nature which reduced crosstalk and even right bends weren’t really 90 degrees.
Some tech is priced with subsidy, like with Intel. They started to take a loss on each chip in order to achieve market dominance (early pentium). Nowadays the market is going opposite, Nvidia offers hardware far above their break even point, this monopoly has 10+ year old cards without supported drivers still selling for $100+ (when they are worth $25-50)
Luckily, there are alternatives to Nvidia and Intel. 90% of non gamers dont care what card they got, as long as it works.
Intel had the mindset to include every feature any chip user might want, and charge customers for all of that, wanted or not.
MOS had the mindset to NOT include features only a small percentage of customers wanted and focused on the basics everyone needed.
If you understand why the Raspberry Pi fills certain needs almost entirely, and anything outside of that, it is content not being the solution, you’ll understand why the 6502 popped off as well.
Motorola 6800 was a premium-priced CPU. They remained stubborn about this. It was CMOS only a 5V rail whereas the 8080 sucked because it was PMOS and required three power supply rails. Motorola must’ve figured they’d beaten Intel, so their pricing could remain up there – which is the main reason it wasn’t popular at the beginning. Wozniak mentioned this, as well as Mostek being warm and friendly to the little guys, you could get samples and not the snobby treatment.
From memory, I think the Z80 had a multiplexing address and data bus which just added a level of complexity of peripheral chips that wasn’t needed with the 6502 which was really similar to the 6802 and indirect indexing was great. I guess, as said, the 6502 beat Motorola on price but you knew they came out of the same stable. I believe. Chuck Peddle also developed the vario floppy disk drive on the Commodore which had more sectors on the outside than inside. All good days and you really knew how everything worked, I still remember sys 826 which was a bit of memory reserved for the 2nd cassette and available until 1024 where basic programs started.
Nope, Z80 has entirely separate address and data buses.
DC Clock was the thing for me…you could literally slow down the processor for cheap RAM, see my (with Bill Kennedy, RIP) hacks https://www.google.com/url?sa=t&source=web&rct=j&opi=89978449&url=http://forum.6502.org/viewtopic.php%3Fp%3D78835&ved=2ahUKEwi-mqPlsvOOAxUg38kDHaOfOdkQFnoECCIQAQ&usg=AOvVaw0LEK27pjIlj_YFnYSNqARE
The electronics in the 6502 was much simpler, so there were fewer transistors, and more could be crammed onto a silicon wafer, so it was much cheaper. Also, it didn’t require a stupid 12v rail. And it was about as easy to code as a 8080. The choice was obvious. This is a good lesson for anyone who wants to disrupt an existing or emerging market.
This is a fun project using an actual 6502 (and Z80 for that matter)…
https://www.instructables.com/HackerBox-0069-MEGA-Retro/
Being bored to death with the cobol I earned a crust with I jumped at the (leisure) opportunity to learn what machine code and assembly languages could do. A ZX81 was the starting point with a C64 and BBCB following and finally in that era was my Dragon32 bought for the 6809 which ultimately became my choice of 8bit processors. But the 6502 was the one I wrote most code for, using my Lance A. Leventhal 6502 book, pencil and squared paper, and entering the machine code bytes line by line. Games, physics sims, puzzle solving, all the fun of the 8-bit fair. It will always be the golden age of compuers for me and I feel fortunate to have experienced it with (argualbly) enough disposable income to fuel my passion. I still have a dozen or so 65022 (some on on breadboard projects) in various draws around me. Happy half century 6502.
Ah yes, the 6809 was a bit of a beauty, programming wise — and as you, I did most of my home assembler programming for the 6502, but by far the most assembler programming for the 8080/Z80 as I developed BIOSes for CP/M computers, including a dual-processor system where one processor was dedicated to producing video output (essentially a VT100+ terminal on a Eurobus card) with the processor on another card and I/O on a third.
Sigh, those were the days!
Any snow and hills involved?
Luxury!
The only commercially available/affordable assembler that was available for the Commodore Pet back in the day crashed so often at some I switched to hand assembling and entering the hex codes by hand … never did anything large scale with it the way you describe but pretty proud of hand assembly by a 13 year old …
Commodore sold an assembler cartridge for the Commodore 64, called (I think) HexMon, or something. That’s what I used to write assembly usually, although I did sometimes resort to writing hex codes myself, lol. I credit those days with being able to parse CSS colors (e.g., #FA9B40) in my head 😅
Brings back memories…. I too loved that era.
Loved my Dragon32 and 6809. Learned machine code at about 15yo by hand assembling and poking it to memory. Later got the “Dream Macro Assembler” which took a lot of the drudge work out.
I hated doing 6502 on the BBC at school as dropping from 16bit to 8bit felt very limiting but 6502 on the C64 was more interesting with access to sound and sprites hardware.
When I got a Dragon64 I wrote a sound sampler and a low frequency oscilloscope using the cassette port and ADC (terrible quality and very limited capture length but a lot of geeky fun for me).
Also built a speech synth for the dragon cartridge port using SP0256 speech synth chip. This got some attention at my computer club as Tron was pretty popular and the C64 owners were bragging that the Ghostbusters game could say “Ghostbusters!!!”
Later got a job at a computer shop where I made hundreds of working Spectrums, Electrons, BBC’s from batch purchases of faulty returns we got from UK retailers like Dixons, Comet etc. There was no swapping cards… all done with oscilloscope and soldering iron in those days.
All that got me into real IT that got me to travel the world and meet some pretty amazing people who taught me amazing things.
Something that’s easy to forget with today’s compiled languages is how difficult it was then to port software between ISAs. Nearly all high quality software was hand written in assembly. When the 6502 got an early lead due to its cost advantage, it strongly disadvantaged systems like the TRS-80 and TI 99/4a in terms of software availability.
“f you were one of the small group of very geeky kids in the early 1980s who really used their home computers instead of merely gaming [edited] with a Z80 in our Sinclair machines would cite the higher clock speed, while the Commodore owners would talk about the 6502’s pipelined architecture and smaller instruction set.”
This hits the spot. Distinctly remember arguing with a Spectrum 48K (first gen) owner about the differences between it and an Atari 130XE some time around 1984 … or maybe I was taking the C64 side. “Sprites!” It was the Atari now that I think about it; “Display lists! Easier to program in machine code!”
Haha, I programmed both the BBC micro (6502) and the Commodore C16 (7501/8501) in low level machine code. Those were the very start of learning how to program like the pros. Started with basic, but that was never fast enough. I still remember coding scrolling code for graphics to shift graphics left or right which was perfect for simple games. Now I really am showing my age. I grew up with both of those machines, what a time to live.
“Commodore C16”. Now that’s a name I’ve not heard in a long time. A long time.
not certain whether typo or clever pun of an editorial comment declaring early processors to be not real (i.e., mock) processors.
Don’t forget Bender from Futurama is also powered by a 6502.
Also remember that the original Terminator had 6502 code scrolling on his internal vision in the scene where he’s cutting out his damaged eye in a hotel room. No wonder they lost the damn war :-)
I remember noticing that when I watched the movie. But, my thought was that the 6502 basically took over the world. It took an all out war to stop it!
BTW, can someone explain to me why the terminator would need to see his own assembly code running in its heads-up display? (Not to mention the speed it appeared to be running at)
I have a Philips 2650 from 1969-1970 that’s used in a home built computer. I got it when I was 13 years old and have added on to it for meny years. Now I’m 60 years old and still have it and love it because I learned a lot from it. I haven’t started it for a long while, but it is still my top computer.
Philips 2650 from 1969-1970 ?!?!?
Philips bought Signetics which brought the 2650 processor into the fold; it was sold under both brands. It’s a weird 8-bitter inspired by the IBM 1130. It wasn’t introduced until the mid-70s, tho.
The first board I ever used was the NatSemi SC/MP. Next I used a Commodore PET, so that was my first 6502 experience, but only in PET BASIC at that point. Both of those were loaners from one of the employees at the first Maplin Electronics shop in Westcliff-on-Sea, where mate Tim was jammy enough to get a Saturday job. All I could afford myself was a ZX-81 – instant regret! At the start of my second year at Uni in 1981, I spent all my grant money on a BBC Model A, which I gradually upgraded to a B. That’s when my love affair with the 6502 really started, and I spent many hours writing assembly code on the Beeb, well after Uni and my first two jobs at Acorn and Chris Curry’s Red Box outfit. Oh, also the 65SC816 in Acorn’s “Communicator” group.
As a teenager I cycled down to that first Maplin shop in Westcliffe from Upminster not really knowing what to expect. When I got there it was heaven on earth
My high school got a PET when I was in grade 11. After BASIC got boring I learned assembly and poked and peeked the bytes into the memory.
We had a local shop that was selling Ohio Scientific computers. The brochures practically had the whole schematic in them. (Not that it was that complex anyway). Anyway, I just copied that, etched a pcb in a baking dish In the kitchen sink, bought the chips and put it together. I was so cheap, I used dip switches right on the board as the front panel input to load the memory and run programs. You haven’t lived until you’ve entered a 300 byte program using the cap of a Bic pen on 16 dip switches. :)
The Commodore 64 used a MOS variant of the 6502, the 6510. Primary differences between the two were the 6510’s tri-state address bus (still identical instruction sets).
The NEC V20/V30 also supported tri-state.
That’s why they were popular for PC emulator boards (Atari ST, Amiga).
Hey could be wired on top of an 68000 without getting in the way.
Oh, and they supported an updated 8086 instructions set and better performance over i8088/i8086, too! :)
The 2X higher clock speed of the Z80 was bogus; Z80 instructions equivalent to 6502 instructions took twice as many cycles to execute. The zero page addressing was a significant advantage for the 6502; a superior register set was the most important Z80 advantage. Overall, for the same processing technology, the time to execute most tasks was very close to the same.
think of the zero page as a set of 256 registers…
The i8088 took 4 (!) clock cycles, even, making the Z80 looking more advanced here. ;)
https://tinyurl.com/5n9ymnsc
One of the comments there says, “The “world record” clock speed for a 6502 is about 25Mhz.” We have members on the 6502.org forum who’ve run it faster than that; and the highest I’ve heard of is almost ten times that fast (over 200MHz), in ASICs (where memory, I/O, and other support circuitry are all on the same chip).
Embedded a 6502 in a Spartan 6 once, running at 50MHz. Of course, this was with the rest of the computer all inside the same S6, everything external was 16MHz or less.
6502’s generally had an input clock of 1MHz, which was internally (and crudely) delayed to produce a 2-phase clock of twice the effective rate. So 2MHz. But if you tried using a higher input clock the phases would overlap and everything would fall over.
The Z80 had a much simpler single-phase clock scheme, and about the same number of machine cycles per instruction after you took the 6502’s clock tricks into account. But my old Z80 ran at 4MHz (inside and out), and didn’t really quibble if you put 6MHz in it (the other hardware in my old computer didn’t necessarily like it, but that wasn’t the fault of the cpu.) So it was actually faster.
That said, it really wasn’t the CPU that distinguished the various machines – Turing always gets his due – but the hardware in the rest of the computer. My Z80 computer might have had a faster CPU, but every pixel had to be written by the CPU. A C64 couldn’t crunch data anywhere near as effectively, but it could throw sprites around at speed without breaking a sweat.
My loving wife took a 6502 assembly language course in college, which used the KIM-1. She actually wrote and hand-assembled programs, which she then keyed into the KIM-1. She went on to a career as a middle school math teacher.
To this day, she will deny that she knows how to write assembly code pr copy Morse code, but I know she did both (and does neither today)!
Well one of the more interesting programs for the 6502 Apple //e version is a program called Diversi-Dial.
It’s a 7 line chat system for the //e that uses 7 300 baud modems. This was way before AOL or the internet.
I’d love to find a way to flowchart the disassembly, but it has been 40 years. I still look at the code from time
to time and think back to my early computing days. There is a site that runs a chat based on Diversi-Dial.
You can find it on https://www.ddial.com or https://magviz.ca . I’m usually on there.
I still find it fascinating that a little 1 Mhz machine could handle 7 300 baud modems at the same time.
The links between ddials back in the day were huge, think a few hundred people on systems all over the
United States and Canada. One of these days, I’ll learn how to flowchart 6502 and learn how the program
itself works.
6502 Instruction set did have some carry-over into other platforms, like the HSC12. I had two courses at the same college (NOTE: split by 20 years!) and was able to pick up the 6502 code and drop it into HCS12 with just the needed updates for the newer iron. I still have the books and notes and make those olde Apples run.
In 1976, in high school, I had a job as an electronic tech for a college chemistry department. The faculty couldn’t decide which microprocessor type to get, so they bought an Ohio Scientific system that had Z80, 6800, and 6502 processors in the same system. I don’t remember how you selected which processor you were using. No multiprocessing, just switching memory and i/o to the processor you wanted to use.
That ‘long shadow’ comment does carry…
I took 2 computer programming courses at the same college. Albeit 20 years apart!
The early one had us silicon neophytes slogging through 6502 assembly code.
The latter class had me doing the [copy/paste-then minor edit] for the HSC12. The latter class prof called me out for cheating…
Knocking off the latter prof on how code works in front of another prof (and former classmate) is a rarity in the academic circles these days.
He said I did not cheat: just took very good notes, and adapted to the new hardware.
Intel very much thought of the 8080 as a minicomputer CPU and heir to the PDP 8, HP2100, and similar “low end” business and research class machines which cost 5 figures. They thought of CP/M and the S100 bus as the natural habitat of their CPU. Their price point reflected this thinking. $200 for a CPU was a rounding error compared to the cost of medium-scale IC CPU boards and mag core memory. Zilog were more aware of the low-end market but the Z80 still inherited a lot of expensive 8080 cruft from that mindset. You wanted low-end embedded you went with the 1802, a harder chip to program especially for complex programs but very minimalist and efficient for easy hardware design. Motorolla tried to flesh out the minimalist 6502 feature set but could match the 6502 price point; Apple’s Macintosh need for a bit more CPU oomph make its space in the market. Intel remained in its business class ways until IBM came along to validate their world-view. TI went straight to 16-bit and never looked back. Zilog never did quite figure out what to do next, and after Commodore bought out MOS and milked out the 6502 life cycle there was never a next step to its architecture either, although it did become king of the cheap embedded market because it could be easily and cheaply miniaturized to new processes even after everyone forgot how it worked.
The PDP-8 was a 12-bit machine; the HP2100 was a 16-bit machine with (by the mid-70s) memory management and a 1Mb adress space. While I’m sure the 8080 might have picked up some design wins that might have gone to the (by this time very clearly end of life) PDP-8 (or rather Intersil/Harris 6100/6120), the 8080 wasn’t really playing in that ballpark.
Intel thought RMX or ISIS and the Multibus-1 bus was the natural habitat of the 8080. You could get a CP/M for some of the Intel 8080 kit (like the MDS) but it’s not even mentioned in most of the Intel doco. I don’t believe I’ve ever seen an Intel branded S100 card. This myth probably persists because Gary Killdall wrote the first version of CP/M on an MDS-800.
Multibus+RMX was very successful in the embedded market. The market for PCs, obviously, thought differently from Intel.
Are you thinking of the 6809? Not really a 6502 descendent…more a distant cousin with better taste.
Oh, they looked back on 9900/99000…and said “this was a bad idea…let’s not do that anymore” and found DSPs for a while.
I didn’t say the 8080 architecture was anything like the PDP or 2100. Those machines were very slow by micro standards because of core RAM, thus the wider memory busses. Similarly with RMX, ISIS, etc. vs. S-100, they were all seen as embedded or business class desktop backbones. HP 21xx was in particular heavily marketed to embedded designers and ended up built into a lot of medical and testing equipment. Very different architectures, aimed at similar markets. I did mean the 6809, again not a descendant of 6502, but convergently evolved cousin meant for the higher end of the 6502’s market, but that higher end was sucked up by Zilog when it got there first. And yeah, TI did make some other things, a lot of which ended up in calculators. They also ended up picking up where a higher end 1802 might have entered. I used some industrial devices based on the 9900 series, designed in 1980 and hardly changed when TI pulled the plug in the late 90’s.
I didn’t either. I said exactly the opposite.
No they weren’t. Both the PDP-8 and the 2100 had semiconductor memory by the mid-70s. And wider buses. And wider ALUs. And more memory. And a litany of other performance enhancements that people who know it’s about more than clock speed could cite.
The 21MX may have been expensive, but it was not slow.
What does this even mean? Intels primary interest was embedded and businesses. Intel didn’t know that PCs were going to explode, and they weren’t exactly building their product strategies around the guys soldering an IMSAI together in their basement.
So was the 8080.
So was the 8080.
Very different architectures, aimed at very different price/performance points of similar markets…FTFY.
“Convergent” means ‘coming together’. The 6809 and 6502 are the opposite.
I can’t imagine a more reductionist view of TI in the 70s/80s.
The 9900 was a dead end of bad guesses on where semiconductor tech was going, fighting it out with the Z8000 for military embedded wins for most of its life. At least the Z8000 still has life in the Z16C00 ‘smart’ peripheral chips. The 1802 was for very low power operations where things like “speed”, “ease of software development” and “subroutines” are distant considerations behind “power budget” (or “radiation hardness” for a niche within a niche use case). While I like occasionally playing with my 1802 SBC (actually an CDP1806), better chips came along at every level.
But this is now far off the path from the 6502 and going noplace fast, so….
The C64 came with the improved MOS 6510 which included an 8 bit IO port. The C64 was a fabulous gaming machine that took over where the VIC-20 left off. The brilliant SID chip gave it awesome sound and music capabilities that left others for dead- especially the tinny beeps of the BBC micros. Commodore basic was so poor you were very making sys calls to machine code routines to do things more quickly. The Mikro assembler on cartridge was excellent. Some favourite games were Mule, Pole position, choplifter, China Miner, and many others beside. I associate with all the previous comments about that period. I remember 1984 being a very exciting year. Computer and Video Games Magazine and many others- the 80’s equivalent of nerdy tech surfing these days, but so much more exciting as it was all so understandable and manageable.
I work in computer networking now, which has been an excellent career choice. How lucky were we all 🙏❤️.
Hi! I agree on the SID being awesome! And Basic v2 not so, um, being awesome. ;)
What I’ve always liked was the vast library of text-adventures written by bed room programmers, by the way.
So even without the pixel graphics it was fun to use. Imagination was part of the fun, too.
And last, but not least the many peripherals and electronic projects available to C64. There were (are!) many hardware hackers in C64 community.
You ask about who might be using it outside of the hobbyists that buy it; my understanding is that it is perhaps the only CPU certified for use in medical devices. When you think about it, this makes absolute sense. For a medical device you want something that is rock solid, and extremely well understood. With now 50 years under it’s belt, and ISA that has only changed in a few very minor ways, it has to be one of the best understood ISAs out there.
What about the ancient RCA 1802? It was very reliable, too.
It also worked on a large range of voltages (4 to 10v), which made it good for extreme situations.
https://en.wikipedia.org/wiki/RCA_1802
My second computer was a COMX-35, have fond memories of the (frankly bizarre) SCRT method of calling subroutines.
I found a review of the COMX-35 in a copy of Electronics and Computing magazine from the 80s, which my late mother got for me at a jumble sale. In all the decades since, forty years or so, this is the first time I have ever come across somebody who used one!
You certify (e.g. US FDA, UL IEC 60601-1) a medical device, not the processor in the device.
NXP have a 16-bit version of the 6502. They threw in a bunch of peripherals, and made the S12 series.
With so many variations, selection (and documents) is a headache. Still, if you are interested, start at:
https://www.nxp.com/products/processors-and-microcontrollers/additional-mpu-mcus-architectures/16-bit-s12-and-s12x-mcus:S12S12X
What a great trip down memory lane. While I learned BASIC on a TRS-80 in my middle school (which only I and one other boy knew how to use, and we had to teach the teachers), my first home computer was a Commodore VIC-20, which I bought with money earned in my dad’s die-making shop. 18 months later, I graduated to the C=64, not long after it was released, and taught myself assembly on the 6502 variant that powered it; there was an actual cartridge that I bought that had the assembler, and wrote animation routines for games. Learning assembly with so few resources was a lot trial and error (and only two registers and an accumulator, if my memory isn’t totally crap). I also found a computer for BASIC, which compiled into something faster than the interpreted BASIC, but not as fast as assembly. I eventually moved to an Amiga 500, and it’s Motorola 68000 processor, which was more powerful, but a machine I never learned as intimately as my Commodore 64…..
Oops, typo: ” I also found a compiler for BASIC”, not “computer”. Doh!
Couldn’t have said it better myself.
Why was the MC6800 instruction set so well liked by programmers?
The Motorola MC6800, introduced in 1974, had an instruction set that programmers appreciated for several reasons, rooted in its design philosophy and practical usability. Here’s a concise breakdown of why it was well-liked:
Orthogonality and Simplicity: The MC6800’s instruction set was relatively orthogonal, meaning instructions could be applied consistently across a wide range of operands (registers, memory, etc.) without restrictive addressing mode limitations. This made it easier to write predictable, straightforward code compared to more complex or less consistent architectures.
Flexible Addressing Modes: It supported multiple addressing modes (immediate, direct, extended, indexed, and implied), giving programmers versatility in accessing data and memory. The indexed addressing mode, in particular, was powerful for handling arrays and data structures, which was a significant advantage for the time.
Balanced Register Set: The MC6800 had two 8-bit accumulators (A and B) and a 16-bit index register, which provided a good balance for arithmetic, logical operations, and pointer-based addressing. Programmers found this register arrangement intuitive for both computation and memory manipulation.
Clear Instruction Mnemonics: Instructions like
LDA(load accumulator),STA(store accumulator), andADDhad clear, memorable mnemonics that aligned with their functions, reducing the learning curve and making assembly programming more approachable.Efficient for 8-Bit Systems: The instruction set was well-suited for the 8-bit architecture, with operations optimized for common tasks like data movement, arithmetic, and bit manipulation. This efficiency was critical in resource-constrained environments of the 1970s.
Symmetry and Predictability: The instruction set avoided overly quirky or irregular behaviors, unlike some contemporary processors. This predictability made it easier to write reliable code and debug programs.
Support for Structured Programming: The MC6800 included instructions like
JSR(jump to subroutine) andRTS(return from subroutine), which supported structured programming techniques, making it easier to write modular and reusable code—a big deal for early microcomputer software.Competitive Edge Over Contemporaries: Compared to rivals like the Intel 8080, the MC6800 was often seen as more intuitive and less cumbersome. Its single 5V power supply (versus multiple voltages for the 8080) also simplified hardware design, indirectly benefiting programmers by making the platform more accessible.
Programmers of the era, especially those working on early microcomputers and embedded systems, valued these traits because they reduced complexity and enabled efficient coding in assembly language, which was critical given the limited memory and processing power available. While not as advanced as later architectures (e.g., the 68000 series), the MC6800 struck a sweet spot for its time, earning a loyal following among developers.
The 6502, designed by MOS Technology, is not a direct derivative of Motorola’s MC6800, but it was heavily influenced by it. Chuck Peddle, a key designer of the 6502, previously worked at Motorola on the 6800. Disappointed with the 6800’s complexity and cost, Peddle aimed to create a simpler, cheaper microprocessor. The 6502 shares some architectural similarities with the 6800, like a single accumulator and similar instruction set concepts, but it has a distinct design with a different register set, simplified architecture, and unique features like zero-page addressing for efficiency. While inspired by the 6800, the 6502 is a ground-up design optimized for cost and performance, not a derivative in the sense of being a modified version.
ChatGPT correctly pointed out that the 6800 has a real stack pointer. Which LLM did you cut and paste and pretended you wrote from?
I just wished the 68010 was used more often, it was closer to 80286 in terms of features.
The original 68000 had took many clock cycles and didn’t support virtual memory.
If the Amiga would have had haved an 80286, it would have had been much more competitive! 😝
Even though the Z80 is now RIP, making the 6502 the defacto winner, the battle goes on! Like Jenny List, I started out with Sinclair computers (ZX80, ZX81, ZX Spectrum and even QL). The reality is that the Z80 is much easier to program simply because it has far more registers and support for 16-bit operations.
The 6502 can’t even properly manage stack-frames. It’s certainly faster for most hacky-type computing, but when doing a 16-bit add or subtract, it’s slower. Compare Z80:
add hl,bc; 11 cycles, 1 byte.
vs 6502
clc ;2c
lda l ;3c min
adc c ;
sta l
lda h
adc b
sta h ;total 6*3+2=20 cycles.
Now, you could say that I’m ignoring loading and storing on the Z80: I should do a ld bc,(nn); ld hl,(mm) then ld (mm),hl, but in practice most of the time you can use register-based calling conventions on a Z80, so ignoring that is plausible.
This doesn’t make the Z80 better as such: the austerity of the 6502 has a sort-of bracing, mountain-top appeal. I spent years mocking the 6502 before discovering that – these days I’m about as at home with either.
There’s one other nice thing about the Z80 though, NOP is opcode 0. This meant that the Don Lancaster style software TV technique could be easily implemented on the ZX80 and ZX81: the processor jumped into the display file and so a character byte would be read out from RAM; the display logic would latch it and then force the data bus low so that the Z80 would read a 0 (NOP); then on the next 2 cycles of a main instruction fetch (refresh), the I and R register would get used to provide the scan line (MOD 8) of a character bitmap + the character set base address which would get read from ROM at address (I256+(R DIV 32)+(CHR8)).
On a 6502, there’s no refresh phase and NOP isn’t 0 which probably precluded 6502 computers at the crazy-low price of a ZX81.
Silence, foul heretic. :-)
The glorious 40-pin DIP z80 is no more, but the ez80[1] is still in production. You can even get a z8000 in the form of the z16C00 line. Once more into the breach!
[1] yes…I know it’s not drop in compatible…
…surprised that nobody has mentioned (I don’t think) one of the Z80’s very powerful features: the use of two complete machine register sets, and the ability to context-switch the state of the machine with only two very fast one-byte instructions (4 t-states).
The 8080’s register set is duplicated (with improvements, of course: copying to/from memory, for example):
AF, BC, DE, HL —primary register set
AF’, BC’, DE’, HL’ —second, alternate register set.
Switching between the two, giving one a completely new operating environment is accomplished with the two very fast instructions
EXX exchanges BC, DE, and HL with their alternates.
EX AF, AF’ exchanges the two AF registers.
This feature gives the Z80 an extremely powerful interrupt capability.
If the 6502 is fifty years old how many 50 year olds know what it does? I loved the design of refreshing the DRAM while driving the video output in the Apple II. Storing your program using a tape recorder was a pain.
I first learnt graphics and sound programing in assembly language on the 6502 in the late 1980’s. More recently I produced a music track about the 6502, it came out OK, but the number of people who would get all of the references in the lyrics is very limited. https://www.udio.com/songs/fvwPrFqnBrp4Z7B83ZAGpS?utm_source=clipboard&utm_medium=text&utm_campaign=social_sharing
There in the 70s was a pinching bottle neck to get a processor in a bit of plastic with pins that was and is still holdable and pluggable. You can know how it works even to transistor level. It’s simplicity is reassuring for making safe medical machines even today. It’s longevity is a standard that helps in discussing future projects. The 65816 uses so little power and has the 16 bit processing options, yet can be a drop 6502 in a BBC Microcomputer that is being checked over. 14 Mega Hertz is they new speed, or even 1 Hertz. I am surprised people do not know it more, as modern things are so flimsy and overly complex and changing.
Wester Design Center are not distracted with other processors and are still family owned I think. 6502.org is still a thriving hobby place all these years on. I think it was used in farming machines, and farming is a bit isolated Andy hardy where things need to be more reliable as in medical machines. The Medium Wave band is said to be good for emergency conditions and I reckon so to with these 8 bit machines. Solar Storms like the Carrington Event in 1859 and now AI as a concern needs good things like the 65816 with it’s 6502 mode.