Quite a few successful early microcomputers used the MOS 6502 CPU. This included, but was not limited to, systems like the Apple I, Apple II, Commodore PET, and Ataris. A followup known as the MOS 6510 was used as the main CPU for the Commodore 64 (the floppy disk drive used its own 6502), and variants of these were used in many other systems of the time.

But why? What made the 6502 the CPU of choice for so many different computer designs over several years? (The Apple I was introduced in 1976, and the C-64 was introduced in 1982, which conservatively gives a time period of at least five years. I also suspect that the Apple I wasn't the first system to use the 6502, though it might well have been one of the first that were widely available.)

For comparison, the Intel 8085 was introduced in 1975, and could run at up to 3-6 MHz, while the 6502 was introduced in the same year but could run only at up to 1-3 MHz, both depending on variant. The Intel 8086 came later, in 1978, and even the slow variants could run at up to 5 MHz; faster 8086 CPUs could be clocked at up to 10 MHz.

Was it an issue of cost? Availability? Simplicity of board design? Instruction set? Or what?

What do we know, and what can we deduce from available information? Bonus points for answers that include citations.

  • 14
    retrocomputing.stackexchange.com/questions/2760/… gives a lot of of the answer: the 6502 was a third of the price of the Z80.
    – pndc
    Commented May 14, 2017 at 13:01
  • 10
    You mention clock speed; the 6502 at 1-2MHz often outperformed higher-clocked contemporaries (I remember reading an article talking specifically about efficiency of handling interrupts as one of the reasons, can't find it at the moment)
    – Joe
    Commented May 14, 2017 at 19:38
  • 15
    Clock speed probably isn't terribly relevant as the Z80 family takes 7 cycles for LD A,$34 but the 6502 takes 2 cycles for LDA #34. For clock comparisons I seem to recall that a figure of 3 times was used to compare 6502 with Z80 clock rates. Also the 6502 made it easy to use the other edge of the clock cycle to steal bus access for the video system as the Apple ][ did (and I think Atari did for spriteless video lines). To be honest I suspect cost was the major driver.
    – PeterI
    Commented May 15, 2017 at 9:54
  • 5
    6502 is awesome. 'nuff said.
    – cbmeeks
    Commented May 15, 2017 at 18:47
  • 5
    @cbmeeks Care to post that as an answer, so the community can vote on it? ;-)
    – user
    Commented May 15, 2017 at 18:57

5 Answers 5


First, for Commodore's part, it should be obvious the reason for choosing the 6502 microprocessor for all their 8-bit machines (notwithstanding the dual-processor SuperPet and C128) - Commodore owned MOS. Jack Tramiel was very focused on vertically integrating his manufacturing, which basically assured Commodore's use of MOS CPUs and support chips. Since Commodore sold more 8-bit home computers than any other vendor, this fact alone greatly influenced the 6502's preeminence.

Second, the aggressively low price point of the 6502. Chuck Peddle's team developed the 6502 to be a low-cost, compatible, Motorola 6800 "killer", much the same way as Zilog did in targeting the Intel 8080 with the Z80. Again, Jack Tramiel's willingness to far undercut his competition kept the 6502 as a relative bargain among the early 8-bit options. As noted in this question the 6502 was around 1/3 the cost of the Z80, and both were far cheaper than Motorola and Intel equivalents.

Third, MOS also created system support chips that were designed to easily interface with the 6502, such as the 6522 VIA. This made adding I/O capabilities very simple for system designers, and that freed them to focus more on custom circuitry that would help distinguish their system in the marketplace of many computers built around this basic chipset.

Fourth, the early success of the several 8-bit machines in both North America and Europe created a virtuous ecosystem of hardware designers and software programmers that knew how to work with the 6502. The momentum and professional user base made for a popular "platform" even before that term was widely used, and this reinforced vendors to stick with it as long as it remained technologically competitive with newer CPUs, and perhaps even longer. Indeed, the video game console industry shared in this platform ecosystem, and the 6502 dominated that category too. First in Atari consoles and then in the original NES, which used an ASIC version of the 6502 in the form of the Ricoh 2A03.

Fifth, the 6502 had robust industry support that delivered enhanced versions (65C02 CMOS version, 65C816 16-bit version), higher clock speeds (capping out at 14MHz), alternative chip manufacturing sources (Rockwell, Synertek), and licensing of the 6502 IP to create custom ASIC devices. In this sense, it was a precursor to what happened with the ARM platform in the embedded computer (phones, etc.) industry. These enhancements and licensing extended the lifespan of the platform, leading to its inclusion in many additional computer and console products.

If the KIM-1, released in 1976, and the Super NES (65c816 core), released in 1991, can serve as "bookends" for the 6502 platform dominant years, that represents a 15-year run in the home computer and console market. Of course, by 1991, the computing world was rapidly consolidating around the IBM PC "clone" standard, but the low-cost, high-volume, Super NES was capable of graphics, sound, and gaming abilities that exceeded much more expensive PCs. It was even competitive with newer 16-bit CPU systems more purpose-built for gaming, like the Amiga, Atari ST, and of course the 68000-based Sega Genesis. Even today, the 65C02 CPU continues to be manufactured and licensed (as a core CPU) for use in embedded systems.

  • 2
    See Mitsubishi MELPS 740 series for descendents of the 6502.
    – amI
    Commented Aug 25, 2017 at 20:13
  • Actually the NES is not a good example here; it was practically unknown in Japan. It was used anyway because a) Ricoh lacked a manufacturing license for the far more popular Z80, and b) Yamauchi felt that using such a processor that nobody else used would give them a competitive advantage. (Altace, Nathan, I Am Error, pp. 14-15.)
    – cjs
    Commented May 14, 2023 at 2:26
  • Regarding point 3, the 6502 also had the advantage that it was explicitly designed to be compatible with 6800 peripherals. In fact, the 6520 was a copy of the earlier Motorola 6820/6281 PIA, and the 6522 (and the RIOT, RRIOT, 6526, and many others) all used that same core PIA functionality, working in the same way.
    – cjs
    Commented May 14, 2023 at 2:36
  • As for the Super NES's graphics and sound capabilities, that was nothing to do with the CPU and everything to do with the peripheral chips. You'll note that Nintendo also produced best-in-class graphics and sound capabilities for a handheld in the Game Boy, using very similar graphics and sound hardware, but a completely different CPU (one based on the Z80).
    – cjs
    Commented May 14, 2023 at 2:39

There were two major reasons:

1: On introduction, the 6502 (at $25) was considerably cheaper than its nearest competitors; at the time, those were the 6800 ($175) and the 8080 ($179); the Z80 would not be released until the following year, and even then its initial price was $200.

2: Despite its low cost and simplicity, the 6502 was relatively fast for a given clock speed and memory type. At the time, CPU speed was limited more by memory access constraints than anything else. The program code it needed was also acceptably compact for the time.

  • 8
    Nobody else seems to have mentioned it, but the price consideration counts doubly for Atari: the 28-pin 6507 significantly reduced board costs over a full 40 pins, encouraging their entry into MOS world.
    – Tommy
    Commented Jun 29, 2019 at 15:10
  • "Despite its low cost and simplicity". I think its simplicity actually contributed to its relative speed.
    – JeremyP
    Commented Feb 23, 2022 at 9:22
  • A low speed CPU also meant you could use low-speed memory, which added to the cost effectiveness. Commented Apr 28, 2022 at 7:59
  • 1
    IIRC the 6502 actually requires relatively fast memory compared to it's nominal clockspeed, because it does a memory access on every cycle. Commented Sep 21, 2022 at 16:27
  • 1
    @PeterGreen It does (same as the 68xx series, actually), but conversely you could say that Intel-type CPUs (eg. Z80) used more clock cycles than they needed per single memory access. For the same speed of memory, the 6502 tended to yield more practical performance than its competitors. Even more so, the 68xx/65xx bus was more conducive to multiplexing video output onto the same memory, another potential cost saving. Early Z80 machines either halted the CPU during video scanout or had a separate memory system to drive it.
    – Chromatix
    Commented Sep 24, 2022 at 12:07

The fast "zero page" addressing mode of the 6502, allowing to think of the lowest 256 bytes as "registers", could have contributed to its popularity among programmers, prolonging the demand for 6502-based systems.

Quoting from Wikipedia:

Many instructions are coded differently for zero page and non-zero page addresses:

LDA $00            ; zero page
LDA $0000          ; non-zero page

The above two instructions both accomplish the same thing: they load the value of memory location $00 into the .A register (accumulator).

However, the first instruction is only two bytes long and requires three clock cycles to complete. The second instruction is three bytes in length and requires four clock cycles to execute. Obviously, the difference in execution time could significantly improve performance in repetitive code.

Using single-byte addresses for size-critical code could also somehow mitigate the difference in code density compared to Z80.

  • This was a great feature. CBM BASIC gobbled up most of zero page for its own functions, but if you knew it well (Mapping the Vic and Mapping the C64 were a terrific help), you could make use of certain bytes when BASIC wasn't looking. They left you a couple or three user defined bytes. But of course if you were writing assembly, you could use nearly all of it.
    – Cliff Hall
    Commented Jun 30, 2019 at 23:22
  • 2
    More importantly, pairs of consecutive zero-page addresses could be used to hold memory addresses for use with (zp),y addressing mode, accomplishing an insane amount of work in a five-cycle instruction. A music player I did for the Atari 2600 required 46 cycles of every 76-cycle scan line to generate four-voice music, and within each group of four scan lines it used twenty different pointers all held in zero page (so 25 cycles out of each 46 were five-cycle instructions using (zp),y addressing).
    – supercat
    Commented Feb 18, 2022 at 22:50
  • 1
    The Motorola 6800 also had a zero page (which they called the "direct page"), and many instructions that saved a byte and a cycle by using it. As supercat mentions, the innovation the 6502 brought to this was indirection through the zero page, modified by the Y register, which consumed slightly fewer cycles and significantly less code than modifying the 6800's (16-bit) X register when you needed to alternate between using two or more pointers in a routine. (Unless you needed to work with more than 256 byte areas.)
    – cjs
    Commented May 14, 2023 at 2:30

An advantage of the 6502 which favors its usage in the Apple II series and Commodore VIC-20 and 64 (though not the Atari 400/800) is that it accesses memory on a very regular cycle--once every full clock cycle. This makes it very easy to split each clock cycle into two parts--one of which is given to the CPU and the other of which is given to video (and--for the Apple--DRAM refresh) circuitry. This makes it very easy for the CPU and video to use the same memory system, and also makes it possible for code to access memory that holds display data as quickly as it can access any other memory.

The Atari 400/800 use shared memory for CPU and video, but don't subdivide cycles. The CPU runs at 1.79Mhz [chroma/2] (vs. 1.022MHz [2*chroma/7] for the Apple II, VIC-20, and C64) but it has to stall the CPU every time it fetches data for the video subsystem. On the other hand, the earlier Atari 2600 used a 28-pin version of the 6502 (called the 6507) running at 1.19MHz [chroma/3] which benefited enormously from the zero-page addressing mode, and inertia would have encouraged use of the 6502 on the later 400/800. Since a memory bus speed of 1.19MHz would have been insufficient, it was boosted to 1.79Mhz.

  • 2
    The Motorola 6800 also could be run in the same "split cycle" mode, using the first half of the cycle for video and the second for the CPU. The MC6800 also included a VMA (Valid Memory Address) pin that could allow cycles to be suppressed if not needed. At the time, the 6502 was much cheaper (at least to me) than the 6800. Was it also true that Bill's Tiny Basic ran on the 6502 but not the 6800? I remember modifying my 6800 home-brew to use a 6502 for a night to try it out.
    – cmm
    Commented Apr 1, 2019 at 22:35
  • Not only could the Motorola be run in the same alternating ϕ2/ϕ1 mode, but IIRC Motorola themselves suggested designs that did this in their application notes. In general, one must be careful to check that features of the 6502 aren't taken from the 6800, since, being designed to work with 6800 peripherals (and even replace a 6800!) it shares a lot of the 6800's bus and timing characteristics.
    – cjs
    Commented May 14, 2023 at 2:33
  • From what I understand, the 6800 would have been cost-prohibitive for personal computers at the time the 6502 came out, but if designs using the 6800 for interleaved-phase video were physically produced those would be interesting to see. One thing I've sometimes thought would have been a nice design feature for a CPU would be a couple of inputs that would force the CPU to process instructions normally, or "jam" an opcode to NOP, branch not taken, or branch taken. If one wanted e.g. a 60-column display, one could have a couple ranges of addresses which shadowed RAM, one of which would...
    – supercat
    Commented May 15, 2023 at 15:40
  • ...jam the opcode when bit 6 of the address was clear, and the other of which would jam it when it was set. Jumps to $8004, $9044, $8084, $90C4, etc. would clock out 60 characters and then start executing code again.
    – supercat
    Commented May 15, 2023 at 15:45
  • 1
    Oh and to make things more interesting on the Atari, besides video memory access, the ANTIC chip was also running a display list, running a simple program to control the graphics hardware. Usually just a simple one to keep the same graphics mode for the whole screen, but it (like the Amiga and Atari ST) could change graphics modes and get a new color pallete every couple of scan lines.
    – hwertz
    Commented Nov 27, 2023 at 7:41

So as others have said, cost of the 6502 was a major factor. Why was it so inexpensive?

(Per Wikipedia) the CPU has 3,510 transistors. It's quite a RISC design, the actual instruction set is quite small. For instance, for math, you have (8-bit) add and subtract, 8-bit data (with an overflow flag so you know when you needed to "carry the one" as it were). The instruction set was spartan but instructions per clock was quite good for the time -- many instructions took 1 cycle whereas (for example) on the Z80 they typically took 4.

One noteable feature on the 6502, it has an 8-bit addressing mode so "page 0" (the first 256 bytes) can be accessed much faster than the rest of the system memory (64K, requiring a 16 bit address.)

Also, since humans use base-10, on the 6502 you set a decimal mode flag before you add or subtract, and it's using BCD (Binary Coded Decimal -- each byte holds 2 digits from 0-9 for a range of 0-99 rather than 2 hex digits for a range of 0-255.) (...Intel x86 also has BCD instructions, although x86-64 doesn't.)

  • 2
    No instruction in the 6502 takes 1 cycle. 2 cycles is the minimum. It's always at least fetch+execute. 65816 was the first in the family to have 1 cycle instructions. Commented Nov 27, 2023 at 10:51
  • … and for those single-byte instructions it fetches two, then throws one away. Even though it’ll always then be immediately reread as the next instruction. It’s not efficient so much as simple. Not that the single-byte instructions tend to crop up that much proportionally.
    – Tommy
    Commented Nov 27, 2023 at 12:53
  • Oh man that's funny. (Fetching two bytes and throwing one away.) I guess sacrifices must be made to keep the transistor count that low! It's amazing that a functional CPU, let alone one with (for the time) reasonable performance could be made with just 3510 transistors. I suppose it'd be hard to keep enough threads going to keep going, but it'd be kind of amusing to make a 6502 variant with 64-bit addressing, and throw like 10000 of them onto a CPU die.
    – hwertz
    Commented Nov 28, 2023 at 17:28

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .