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! 😅
I also have to say that the MOS6502 instruction set made more sense than the MC6800.
It took me a while to admit it, but Little-Endian makes more sense than Big-Endian, even though the latter is easier to read the machine code. I realized this when a 16-bit add to an index register took one less clock in the 6502 than the 6800. You want to load the LSB byte first, then load the MSB byte. The 6800, in loading the MSB first had to hold it in an internal register, then load and add the LSB, and finally add (with carry) the MSB. The 6502 loaded and added the LSB first, then loaded and added (with carry) the MSB. That was one instruction clock less.
The other thing was the sense of the carry bit for subtraction. The 6800 had the carry bit set for borrow. But that meant they had to invert it for for storage in the Condition Code Registers (CCR) and invert it back when the Subtract-with-carry (SBC) instruction was executed.
The one thing that the 6502 missed was they needed a straight ADD and SUB instruction. It was always a pain-in-ass to clear the carry before the first ADC and to set the carry bit before the first SBC.
But the logic of the carry bit for borrow in subtraction was correct in the 6502 and inverted in the 6800.
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.
90 degree turns are an RF nightmare. The signals travel both in the wire and in the space around the wire. Think of how antennas work. Always avoid right angle connectors if you can in any situation. You will avoid many problems. Old Ham myself.
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.
Correct. I have been designing z80 architecture systems, I would have noticed if so 🤣
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 CMOS 6502 (ie, 65c02) allows you to stop the clock without losing any state.
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.
The 6502’s regular memory cycles were very amenable to CPU/VDU interleaved access, making video easier to generate. Clock low, VDU access. Clock high, CPU access.
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. :)
“…You haven’t lived until you’ve entered a 300 byte program using the cap of a Bic pen…”
How about 512 words?
1st mini I designed hardware for, and programmed (in assembly, and Fortran), was the Lockheed MAC-16. In an attempt to save money, the boss wouldn’t spring for the 512-word fairly expensive ROM board (containing the most dynamite debug program ever written), so “Technician and Me” had to take turns keying in DBUG after every ‘power-down’ (DBUG was not saved to core, which comprised the MAC’s main memory).
Even though we didn’t power the machine down much, for obvious reasons, the Best Tech Anywhere threatened to quit (and actually walked off the job once), citing (jokingly?) psychological and physical abuse as the reasons, the boss caved in and bought the DBUG ROM board.
At least we had it marginally better than you, even at 1024 bytes—the MAC had rocker switches on its front panel; no Bic pens required.
I got my start @ home w/ OSI (Ohio Scientific) C1P. 10th grade, no drivers license so my mother was my ‘Uber’! Assembly, BASIC, hardware schematics (purchased at the local computer!) store where all a great start into a world that has employed me well over 40 years!
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.
Yeah, it’s only a slight exaggeration to say the 6502 did a complete memory access in half a clock cycle. The Apple II, IIRC, did two memory accesses per microsecond at 1MHz, with the processor accessing memory when Φ2 was high, and video accessing memory when Φ2 was low.
Bill Mensch, president of Western Design Center which owns the intellectual property of the 65c02 (ie, CMOS version, which is improved over the NMOS version in many ways), who was in on the original 6502 design with Chuck Peddle, said they originally used a manual tester, and tested every 6502 for double the speed it would get marked as. So for example, to be marked as a 1MHz part, it had to pass the test at 2MHz. To get marked as 2MHz, it had to pass the test at 4MHz. If it was only good for 3.9MHz, it could not get marked as 2MHz, so it was marked as 1MHz. He said that even in the early days, they had ones that could do 10MHz. The discrete 65c02’s WDC is selling today are all guaranteed for at least 14MHz, and have been for probably the last 20 years.
The 6502 took 1 clock to do a memory cycle, the Z80 took 3 or 4, the 68000 took 8. The memories of the day limited the speed of the CPU.
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…
Jack Crenshaw, an embedded-systems engineer who wrote regularly in Embedded Systems Programming magazine said in the 9/98 issue that he still couldn’t figure out why, in BASIC benchmark after benchmark, the 6502 could outperform the Z80 which had more and bigger registers, a seemingly more powerful instruction set, and ran at higher clock rates. (The 6502’s zero page and improved indexed and indirect addressing modes no doubt helped.)
True. The results were telling people that a small but well-thought-out instruction set beats a large instruction set. You could one execute one instruction at a time (in those days). Acorn looked at many candidates for their next generation, and found they were usually soundly beaten by a 2 MHz 6502. So they invented their own RIC machine.
I have a 6502 stacks treatise at http://wilsonminesco.com/stacks/index.html . Stack frames and local variables are addressed particularly in section 5 at http://wilsonminesco.com/stacks/stackaddressing.html, starting in about the middle of the page, and section 14 at http://wilsonminesco.com/stacks/loc_vars.html .
…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.
I regularly have non-maskable interrupts on the 65c02 interrupt the processing of maskable interrupts, meaning the advantage of the second set of registers is lost. I have on occasion serviced 140,000 interrupts per second on my 5MHz 65c02 workbench computer though.
“I regularly have non-maskable interrupts on the 65c02 interrupt the processing of maskable interrupts, meaning the advantage of the second set of registers is lost…”
You have a second set of registers on your 65C02 ? ! !
Where’d you get one of those. (?)
(…and ‘occasionally’ processing 140K interrupts/second–with a 5MHz clock–is not really something to write home about…)
No; what I’m saying is that trying to take advantage of the Z80’s second set of registers to speed interrupt processing is of no benefit if you have interrupts cutting in on the service of other (lower-priority) interrupts.
If I understand it right, the Z80 takes 11-19 clocks for interrupt acknowledge plus interrupt sequence, depending on mode, or 2.75-4.75μs @ 4MHz. RETI is 14 clocks, or 3.5μs @ 4MHz. That’s 6.25 to 8.25 µs @4MHz, before you’ve done anything useful at all. All current-production 65c02’s can do that much at least ten times that fast. The 6502 really did shine in the interrupts department which is important in my uses. According to page 2 of this article http://marc.retronik.fr/motorola/68K/68000/AN1012_A_discussion_of_Interrupts_for_the_MC68000_%5BMotorola_1988_12p%5D.pdf, the maximum interrupt latency for a no-wait-state 68000 system is 378 clock periods! The 6502 absolutely blew the doors off the 68000 in interrupt performance, which is why the 6551 UART didn’t need a FIFO, because interrupting for every byte was not a problem.
Of course, at this stage of the game, if we were all looking for maximum performance for everything, we wouldn’t be using 8-bit processors that debuted five decades ago; but the 6502 did perform better than its contemporaries which appeared on the surface to have major benefits. Sophie Wilson, chief architect of the ARM processor, said, “an 8MHz 32016 was completely trounced in performance terms by a 4MHz 6502.” (The 32016 was National’s 32-bit processor, having 15 registers, including 8 general-purpose 32-bit registers, and a 16-bit external data bus.)
“…what I’m saying is that trying to take advantage of the Z80’s second set of registers to speed interrupt processing is of no benefit if you have interrupts cutting in on the service of other (lower-priority) interrupts…”
With all due respect, you need to re-thing the strategy of using interrupts.
Here are the rules of writing and using interrupt service routines (ISRs), and a fact:
1) ALL ISRs must be written to run as fast as possible, to ‘be done, and out of the way’.
2) A lower-level interrupt is NEVER allowed to interrupt (what should be) a higher-level interrupt.
3) The Z80’s context-switch approach is MEANT to be used as the highest-priority (level) interrupt.
4) The Z80’s full context switch occurs in 8 t-states, or 1.6 μsec. (This figure is normalized to the 5 MHz clock of the 6502, which is well within the capability of a 6MHz Z80)
It is crucial to understand that what this last point means is that a complete, new machine is ready to go, and service the interrupt, from the reception of the interrupt signal.
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.
My first machine was an Atari 800 with 48k of memory and a cassette drive. Loading programs by cassette was extremely slow and often the loading process would crash, which meant that you had to rewind the tape back to the beginning and try to load all over again.
After a few months of this frustrating routine, I scraped together $200 to buy my first 5 and 1/4 inch floppy disk drive. The floppy drive was a dream compared to that tape drive.
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.
mocroprocessor ?
Must be written by russian AI. “Mocro” in russian means “wet” as in “it is wet outside” :-]
Someone correct me but didn’t MOS also produce all the aupport chips for the 6502 so it also meant that it was straightforward to build a computer based around the 6502 with timers and memory management and I/O etc?
Yes, there’s quite an array of them, although most are out of production now, unlike the 65c02, ’22, ’51, ‘816, ‘134, and ‘265. Older ones I am aware of are:
6520 & 65c21 PIA (peripheral interface adapter)
6523 & 6525 TPI (tri-port interface)
6526 CIA (complex interface adapter)
6529 single-port interface
6530 memory, I/O, and timer array
6532 RIOT (RAM, I/O, and Timer)
6552 dual ACIA (asynchronous communications interface adapter, basically a UART)
6590 EBC
6545, 6560, 6561, 6567, 6569, 6572, and 6573 VIC's (video interface chips)
6582 SID (sound interface device)
and Commodore had lots of 85xx interface ICs that were directly compatible with the 6502's bus.
I’m shocked (shocked!) that the 6522 VIA isn’t in that list! Configurable parallel I/O, timer functions, and decent interrupt control in 40 pins. There was even a serial feature though that never worked quite right, due to some bug on the die or something.
Ah yes—I copied that from a page on my site where I mention the ’22 and ’51, and then say, “Other ones are…” The bug in the VIA is in shifting under control of an external CB1 clock. I describe it at http://forum.6502.org/viewtopic.php?p=2310#p2310, tip #8 in my “Tip of the Day” column, with ways to get around the bug, for those few users who would be affected by it. The other serial modes work fine though, and I have used them tons.
Also worth a mention that the 8 bit Motorola 68xx peripheral chips were pretty straightforward to use with the 6502, having essentially the same RD and WR control signals and compatible clocking schemes.
I started the birthday party early over here, guys!!
https://www.flickr.com/photos/blakespot/5018566004/in/album-72157624897828001
Is there something I could use to flowchart a 6502 disassembly?
It’s been a really really really long time since I did flowcharting and don’t remember
much. Some, but not much. Yep, it’s ddial (again!)
I have done some ASM to flowcharting, but with the Nat Semi 16xxx. I stripped the comments from a copy of the file (you probably won’t need to do this), then wrote pseudo-code as comments, limiting the control commands to IF-THEN, CALL, and RETurn. This will limit the shapes needed to diamonds , parallelograms //, and ovals (). (Underscores added for spacing.)
For producing the charts, I used the now-discontinued ABC Flowcharter or Dia Diagramming software.
HTH,
–Rich
I first met the 6502 in the early 80’s. It was used by Atari in their Ateroids and Lunar Lander arcade video games. This was after Pacman with its Z80. Loved both. Now mived on to microcontrollers. So much easier and simpler.
Asteroids came first in 1979.
https://en.wikipedia.org/wiki/Asteroids_(video_game)
Followed by Pacman in 1980:
https://en.wikipedia.org/wiki/Pac-Man
Nowadays you can run a simulation of the whole 6502 in your browser:
http://www.visual6502.org/JSSim/index.html
and compare vs the 6800 that came before:
http://www.visual6502.org/JSSim/expert-6800.html
We live in amazing times! =)