Review: Single Board 65C02 and 65C816 Computers

The 6502 is a classic piece of computing history. Versions of this CPU were found in everything from the Apple ][, to the Nintendo Entertainment System, and the Commodore 64. The history of the 6502 doesn’t end with video games; for the last forty years, this CPU has found its way into industrial equipment, medical devices, and everything else that doesn’t need to be redesigned every two years. Combine the longevity of the 6502 with the fact an entire generation of developers first cut their teeth on 6502 assembly, and you have the makings of a classic microprocessor that will, I’m sure, still be relevant in another forty years.

The cathedral of The 6502 is Western Design Center. For more than 35 years, WDC has been the home of 6502-related designs. Recently, WDC has been interested in the educational aspects of the 6502, with one of the VPs, [David Cramer], lending his time to an after-school club teaching opcodes.

The folks at WDC recently contacted me to see if I would give their hardware a close look, and after providing a few boards, this hardware proved to be both excellent. They’re great for educators adventurous enough to deviate from the Arduino, Processing, and Fritzing zeitgeist, and for anyone who wants to dip their toes into the world of 65xx development.

The Single Board Computers

WDC sent me the W65C02SXB and the W65c816SXB, two single board computers based on the 65C02 and the 65C816, respectively.

SBCThere are hundreds of very well-documented designs floating around the Internet for 65xx-based computers, but most of these designs have a lot in common. If you’re looking to build your own 6502-based computer, you’ll need a CPU, some RAM, and an EEPROM or Flash chip. For peripherals, you’ll be looking at the 6520 PIA, a chip that provides two eight-bit ports of I/O, the 6522 VIA a more advanced I/O chip with timers and a shift register, and maybe an 6551 ACIA communications/serial chip if you’re a purist. This is the standard compliment of chips for a 6502-based computer, and if you believe [Chuck Peddle], the 6502 wasn’t that useful without these support chips.

Both the ’02 and ‘816-based single board computers from WDC feature an ACIA, a PIA, and two VIAs – the second VIA is connected to a microUSB interface designed for WDC’s Terbium IDE (TIDE). More on TIDE in a bit. Each board also has 32kB of SRAM and a 128kB Flash chip mapped into the top 32k of memory. This is a fairly standard layout for just about every homebrew 6502 computer, but there are a few features that make this board special. Every pin you would ever need – data, address, control, and some chip selects – are available on a header running the entire length of the board. This is great if you’d like to interface an SXB with some old hardware, but the potential for creating new hardware is interesting. When I talked to [David Cramer] and [David Gray] at WDC, we speculated on what interesting hardware could be made that supports this gigantic header. The board might be too big and cumbersome for a quadcopter, but a 3D printer controller board is entirely reasonable, and would probably work very well.

The 65C816

The Western Design Center doesn’t just deal with the 6502 and its support chips. It remains the only place where you can get the 65C816, a greatly expanded CPU built on the 6502 ISA.

816The ‘816 is a very interesting chip, most famous for its use in the Apple IIgs and the Super Nintendo. With a 24-bit address bus, it supports 16 Megabytes of RAM, has 16-bit registers, and a few new instructions over the 6502. Most impressively, when you first turn a 65C816 on, it starts up in a 6502 emulation mode that is 100% compatible with the 6502 until you flip a bit in a ‘hidden’ register.

With new stack instructions and compatibility with the 65C02, you have to wonder what would have happened if the 65C816 were introduced a few years earlier. The chip was finished in 1984 in time for Apple to use it in the IIgs, and for [Bil Herd] to realize, ‘the reason to use it is because the competition is using it wasn’t going to be a successful pitch.’ A few years earlier, and this chip would have at least been considered in the initial designs of the Apple Lisa, Macintosh, the Atari ST line, and possibly even the IBM PC. It’s the greatest ‘what-ifs’ of computing history.

For the last 30 years, WDC have been the keepers of the 65C816 flame, and of course their educational offerings include a single board computer based around this chip. It is more or less identical to the W65C02SXB with PIA breakouts, VIA breakouts, and an ACIA breakout. The larger set of connectors contains all the data, address, and control lines of the XBus02 connector of the W65C02SXB, save for additional pins for the extra address lines.

Best of all, with a 65C816 development board, there’s no need to deal with the multiplexed data and address lines. Writing ‘816 code is as simple as plugging the board into your computer and mashing the keyboard; the Western Design Center has the only modern ‘816 C compiler, after all.

Terbium IDE

WDCGIF
The Sample Project for the SXBs blink a seven-segment display in a pleasing pattern

All of the WDC boards work with the Terbium IDE, the IDE packaged with the WDCTool suite. This is the interface for the compiler, linker, the editor of your choice, and a simulator. Truth be told, it’s not exactly a modern IDE – it’s Windows only, and my battle station (Win 8.1) saw the best results running in WinXP Sp2 compatibility mode.

Although TIDE is a little rough around the edges, it’s not really fair to compare this to Visual Studio or Eclipse; these high-end IDEs will always have more features and more polish than an IDE built for a single platform. Also, it’s an IDE, and being rough around the edges is the default, not an exception.

Aside from compiling and linking, TIDE also has another neat feature that’s directly applicable to the SXB boards: a simulator and debugger.

65sim
The TIDE simulator/debugger running the sample project with a seven-segment display

The addition of a simulator and debugger in TIDE is something you’re not going to get if you build your own 6502 single board computer. With the simulator and debugger, you can step into code, set breakpoints, and generally do everything you would expect to be able to do with an embedded IDE.

The sample project for the W65C02SXB was a ‘light up a seven segment display with a VIA’ tutorial, and this demonstrates the potential of the debugger; it even simulates the seven segment display with the help of a little code.

There are a few extra features in TIDE that tie into FPGA-related stuff for WDC’s soft cores for the ’02 and ‘816, but since that’s far beyond the boards I have, those buttons were left alone.

The Microcontroller Development Boards

265
The W65C265SXB – A microcontroller board based on the 65C816

WDC has not been resting on their laurels for 40 years. Their educational tools also include microcontrollers based on the 65c02 and 65c816. These are the 65C134SXB (based on the ’02, and was originally designed for life support), and the W65C265SXB (based on the 65c816).

Each of these boards feature the W65C134S or W65C256S microcontroller with 32kB of SRAM, a socket for a 32PLLC Flash ROM, one large connector that is more or less the same as their ‘full microprocessor’ counterparts, and three 10-pin connectors that are used for basic I/O, the Serial Interface Bus, and UART signals.

Although these microcontroller development boards appear very minimal – there are only four chips, a hand full of passives, and a bunch of pin headers, after all – appearances are deceiving. The microcontrollers are actually incredible pieces of engineering that really aren’t comparable to anything else on the market.

CoolTerm
The W65C265SXB ROM Monitor running in a terminal emulator

Inside both of these microcontrollers is a ROM monitor that functions just like any monitor program you’d find in an ancient computer. With this monitor, you can read and write to memory addresses, jump to addresses, and run code. All that’s needed is a USB cable, a terminal emulator (CoolTerm, Putty, a neat little Python script, or anything else that can connect to something over a serial port, 9600, 8N1) [Rod Biresch] has a great tutorial for entering opcodes into the ‘265SXB to blink an LED. Yes, it’s the most basic thing you can do with a microcontroller, but it does work, and can serve as the first stepping stone to more complex applications of an embedded 65xx ISA microcontroller.

Like their bigger brothers, they are also supported by the WDC’s own development environment, TIDE. With this, you can throw assembly or C at these little boards and they’ll chug right along.

Conclusion

There is one fairly large drawback to the single board computers from WDC – the price. The W65C02SXB and W65C816SXB go for a little under $200 USD. The microcontroller variants – the W65C134 and W65C265 knock $100 off the price of their bigger brothers. When you can get an Arduino Nano clone for $2 with free shipping, this looks insane at first glance. After thinking about it, I’m not convinced the price actually is insane.

While you can pull a 6502 out of any old computer, you’re not going to find new chips from anyone but WDC. Being in the 6502 game is a comparatively low-volume business, and for every classic microprocessor, there are thousands of ARM chips.

That being said, if you were to build a 6502 or 65816 single board computer, you’ll also need those VIAs and PIAs; again, not chips you can pick up for a dollar a piece. I’ve built a 6502-based computer, and in terms of cost, my build wasn’t very far off. If you consider the effort that goes into building your own SBC… well, what do you value your time at?

The microcontroller variants of WDC’s boards are by far their most interesting offerings. There’s a common trope in modern 6502 builds that offload nearly everything to a microcontroller, but keep the 6502 in it’s classic 40-pin DIP format. You’ve seen it done with the Propeller, with an ATMega, and with the Propeller again. The 65C134 and ~265 do this job exceptionally well, and they have a built-in monitor to get you typing in machine code fast. That’s the goal of every homebrew computer, really.

For an educational offering, WDC’s single board computers do exactly what they’re designed to do: get people learning assembly and opcodes and machine codes. There’s still a value in this, especially if you’re going to continue hacking on Arduinos and ARMs. The microcontroller boards are a great introduction to some seriously interesting hardware, and I can’t wait to see the retro/homebrew scene dig into some serious tinkering with these machines.

45 thoughts on “Review: Single Board 65C02 and 65C816 Computers

    1. The z80, 68hc11, 6502, and 8052 were major milestones…
      However, these are still used because the IP has long since expired on the core architecture, and anyone who wishes to argue the fact risks having their portfolio invalidated with prior art.

      Given options, the old style parallel address/data bus has mostly been replaced by modern single chip SoCs, and hybrid ARM ASIC/FPGA. Note Avago purchased Broadcom for $37 Billion for a very good reason.

      1. LOL, the 6502 (actually 65c02, ie, the CMOS version which has a lot of hardware and software advantages) is going into modern products at a rate of over a hundred million units a year today, being the processor at the heart of custom ICs for automotive, industrial, appliance, toy, and even life-support equipment. Western Design Center licenses the intellectual property to the manufacturers making these.

  1. Have you ever wanted a larger dev board in physical size only? How about slow processing speeds? spend more money? If you answered yes to any of the following, have we got a deal for you!

    If I want to do real work I would use literally anything else, lol. If I wanted to putz around with 65xx’s I would want to design and build my own ground up. If it was $50 it would be worth thinking about.

    Oh, and I AM building a z80 SBC from scratch so its not like I’m hating on the age or anything.

    1. The 6809 was a wonderful upgrade to the 6800. The 65c02 was mild but significant upgrade to the 6502, having more instructions and addressing modes, all the bugs fixed, much higher speeds (now topping out at 200+ MHz), and lots of hardware advantages. IMO , the 65816 (also mentioned in the article) was a much better upgrade to the 6502 than the 6809 was to the 6800.

      1. The Z80’s 2nd set of registers for interrupts is nice until you need to nest interrupts. Then it loses its value.

        The 6502 wasn’t just faster than the Z80 on a MHz-to-MHz level field though; it was faster even when the Z80 had a clock rate four times as high, and more and wider registers too.

        There were a couple of paragraphs in an article by Jack Crenshaw in the 9/98 issue of Embedded Systems Programming where he talks about different BASICs he used on computers in the 1970’s and 1980’s, and said the 6800 and 6502 always seemed to run them faster than any other processor. He says that to him, the 6502 was a “near knock-off” of the 6800, and says he liked the 6800 architecture far more than that of the 80 family, even though his work made him much more familiar with the latter. Quoting two paragraphs:

        “To me, the 8080 and Z80 always seemed to be superior chips
        to the 6800 and 6502. The 8080 had seven registers to the
        6800’s two (plus two index registers). The Z80 added
        another seven, plus two more index registers. Nevertheless,
        I can’t deny that, benchmark after benchmark, BASIC
        interpreters based on the 68s consistently outperformed
        those for the 80s.

        “The biggest problem with the 68s was that they had no
        16-bit arithmetic. Though the 8080 and Z80 were basically
        8-bit processors, at least they had 16-bit registers (three
        for the 8080, eight for the Z80), and you could actually
        perform arithmetic in them, shift them, test them, and so
        on. You couldn’t do any of these things with the 6800 or
        6502, which is one reason I still don’t understand, to this
        day, how the 68s could outperform the 80s in benchmarks.”

        After learning the 6502’s instruction set and bus usage, I remember being impressed by the relative inefficiency of the 80 family, including the number of clock cycles it took to execute a single instruction, and how many extra instructions were needed because it did not have things like the 6502’s automatic decimal arithmetic with the D flag, and the automatic compare-to-0 implied in all logical, bit, arithmetic, and load instructions.

        I don’t know why he says, “You couldn’t do any of these things in the 6800 or 6502” though. Sure you could.

        The 80’s even at that time though were generally run at 4MHz or a little higher IIRC, and they were still losing to the 1MHz 6502’s and 6800’s. The 6502 ran figForth 25% faster than the 6800 at a given clock rate, and my 65816 Forth is 2-3 times as fast as my 65c02 Forth at a given clock rate.

        1. The 6502 benefitted a lot from special “page 0” instructions. The first “page” of 256 bytes (because even 16-bit addressing seems glued onto it’s 8-bitness) had special instructions that implicitly used it, so you didn’t need to do quite as much addressing. People often said page 0 was akin to another 256 registers.

          That was when RAM was still faster than CPUs.

          1. hence the rest of my second paragraph, that even at four times the clock rate, the Z80 couldn’t keep up with the 6502. Even at the original, slow 1MHz speed, it was not out of the question for a 6502 to service 40,000 interrupts per second and actually make progress on the background program, if service required nothing more than to increment a RAM variable byte for example. The fastest 6502’s today are running over 200MHz though, ie, about 50 MIPS. That cannot compete with an 800MHz ARM, but it’s still pretty nice performance for the countless situations that don’t need hi-res realtime video.

          2. If 4 times clock rate isn’t enough, use 6 times. Faster crystals are cheap. A more useful metric is to compare performance to memory cycle time.

          3. Back then it was not easy to use a higher clock. And you couldn’t run the Z80 at a higher clock because even the fastest one (Z80B) ran only at 6MHz anyway. So there’s nothing wrong with the metric. The situation is even worse (from the Z80’s point of view) today, because the fastest DIP Z80 I can buy runs at 20MHz, while the 65C02 is clocked at 14MHz (although it is severely conservative spec’ed by WDC – it runs reliably at 20MHz or more).

          4. The cycle time metric by itself is still not a good metric. Looking at practical speed differences using same era hardware is a much better method. Maybe the 6502 was still a bit faster, but the difference was not big, and depended on the task.

            You can get a modern eZ80 that runs at 50 MHz with single cycle execution.

          5. Per-cycle means nothing. The 6502 used less cycles. But it was incapable of running at the 4MHz of the Z80. That’s why one measures this type of thing in MIPS. Or better, with proper benchmarks, since Z80 instructions did a lot more than 6502 ones. Ability to get actual computing work done (I know…) is the only sensible comparison. Since CPUs are mathematical, solving equations is the standard.

    2. Likewise. The 6809 was beautiful and elegant. Motorola assembly in general on the 6809 and 68K series seemed almost high-level compared to other assemblies. Intel in particular – my first attempts at 8086 assembly were terrifying. I also enjoyed how I could take essentially the same BASIC code and run it on my TRS-80 Coco and my dad’s Apple //c and even at a lower clock speed the Coco would often be significantly faster.

  2. For educational purposes? Really?

    In college, I cut my teeth on ASM using a custom course built board using the 68HC11. We were assigned boards in pairs and were allowed to take said boards home. The replacement cost IIRC was around $100 or $150 or something at a time when similar boards were well over $300.

    After the course we were required to return the boards. That fact alone is the reason why I stopped doing anything in ASM as an entire portfolio built around the 68HC11 was useless without the board and the emulators did little to reflect the hardware. I attempted to copy the board (I nicked the necessary files) but the PCB fabrication was a stumbling block for a long time.

    Then OOPic appeared and pretty much blew everything away from a hobbyist standpoint in terms of cost. When you’re a starving student, every dollar counts.

    Those years sucked.

    But I digress. A lot of schools are cash strapped so I can’t see too many buying 35 $100 boards when they can buy 1200 of the $3 Chinese knockoffs and have the kids buy them and take them home.

    I really love the 6502 but that’s a hard sell as an educational tool.

  3. I guess schools that have tons of money and don’t have time to look for cheaper options really love those WDC cards.

    I love that WDC still exists and keeps the 65C02 and friends alive and in production. Awesome! But their evaluation boards are just too expensive. On http://wdc65xx.com/store/SXB-Boards/ I see prices between $89 and $199. That’s a lot of money for just something to demonstrate and learn 65C02/65C816 machine language and not much else.

    If you go to a place like 6502.org you will see a lot of references to some great open-source projects with the 65C02 and 65C816 that do more useful stuff and cost less. I put a 65C02 on a Propeller proto board (https://hackaday.io/project/3620) and I’m sure that at least in some ways, my project is more useful than those WDC boards. And it’s easy for hobbyists to reproduce, probably for less than $50 including shipping.

    So… Yes, I love WDC. But Meh on their dev boards, sorry.

    ===Jac

    1. I estimate that if I were to build my POC V1.1 unit in quantity I could do it for about 75 USD a copy…and that includes the SCSI host adapter. So I do concur with your comment about the cost of the SXB boards and how well they might be received in the educational arena.

    1. I remember reading some documentation for the 65C134 microcontroller. If I remember correctly, the program it has on board doesn’t much useful, can’t be replaced (it’s ROM) and doesn’t offer much towards expansion options. I don’t remember much of it but it got filed in my brain in the “useless” drawer.

  4. I would say the cathedral is Mostek and the ARM was inspired by and designed to replace the 6502 in the BBC computer. Status register is the same in fact – anticipating a need to emulate legacy 6502 code easily.

    1. Pretty interesting, I wonder what you’d have to do to get 6502 code to run on an ARM? Would even a quick search / replace on opcodes come out with something that worked? Of course there’s recompiling emulators, but it’d be interesting to see just how much they have in common without that.

      The ARM has it’s big register file, 6502 has Page 0. The latter has 256 addresses, the former 32 I think. Depending on if a program used more than, say, 25 Page 0 addresses, you might be able to use those. The other 7 you’d use for 6502 registers and assorted track-keeping. Or you could just treat Page 0 like any other page, since RAM is slower than CPUs now.

      Even by hand it’d be interesting. How hard to port BBC Micro stuff to an ARM, maybe running with the same hardware? Get an ARM with built-in RAM (I think you can get them with MMUs to help), solder it in, and use it’s GPIOs to access the BBC’s peripheral chips.

      The 6502’s memory-mapped I/O would need a bit of emulating to patch. Not like the Z80’s manly separate I/O address range (just one extra pin and a bit of logic!). Always seemed much better / simpler to me. The ZX Spectrum didn’t even bother with address decoding. If you have less than 8 peripherals to control, just use one address line to select each. Then make sure you only call I/O addresses with only one (active low) bit set to zero. Means you can have full 64K of memory without cutting out any bytes for I/O, or having to page I/O in. Either way is a horrible idea, and 6502 standard. Separate RAM address range also made it possible for the Z80 to do it’s own refreshing.

      1. They wrote fast emulators beginning with the Archimedes. Emulating 6502 is a snap. The status registers are the same so branching decisions and structure are the same. 6502/C02 is a 1 address machine and so is ARM (called a load-store architecture by the younger crowd that never read the classics on design – like saying “granularity” when they mean to describe how fine something is. What does “increased granularity” mean?). You can interpret 65C02 at 3 to 7 ARM instructions per 6502 instruction. Nearly 1 to 1 if compiled. To choose something fair besides BBB or Pi speeds, take theSTM32F4 at 168 MHz. You get a 6502 speed around 40 MHz or 40 times faster than an Apple II and at least 4 times faster than the best accelerators ever made for the Apple. A smarter interpreter that finds the common instructions combinations used to fetch and store 16 bit numbers can replace them with a single instruction and simple branches vanish because all ARM instructions can be conditional. Depending on the application, this can make a big additional improvement. A FriendlyARM Mini210S is 1 GHz so if the code is in RAM, might do over 200 MHz 65C02 equivalent. Do Multi-core ARMs help? Don’t know when it comes to a linear task like this. Maybe one could do look ahead for code groups and substitute the faster code while another does the interpreter execution.

  5. From the article:

    “That being said, if you were to build a 6502 or 65816 single board computer, you’ll also need those VIAs and PIAs; again, not chips you can pick up for a dollar a piece.”

    No you don’t need those VIAs and PIAs. Interfacing non-65xx I/O chips to the 65xx bus is fairly trivial in most cases. My 65C816-powered POC unit has no 65xx I/O hardware at all, yet it supports dual TIA-232 channels (at 115.2 Kbps) and SCSI. The soon-to-be-built V2 version will have four TIA-232 channels, courtesy of an NXP 28C94 quad UART.

  6. If I’m going to learn 65c816 assembly, it’ll be on an SNES. You could do most of your development using an emulator, then build a cheap EPROM/Flash cart (optionally with exposed I/O lines or built-in hardware), and it would likely still be cheaper than this dev. board (including the cost of the SNES).

    1. Don’t do it! 65C02 yes, 816 nooooooo! Learn ARM instead. That is the real super-6502. (The BC Micro guys rejected 65816 and decided they could do something better themselves – and did).

      1. The 6502/65816 appeal is to old school programmers, chances are if a programmer is attracted to these sorts of micros it’s for nostalgia reasons and ease of learning compared to ARM’s.

    2. I have seen a lot of deer-in-the-headlights responses over the years when the ‘816 is mentioned. Do keep a couple of things in mind. One, you don’t have to latch, decode, or use the bank byte to get a ton of benefits. Two, you can start programming the ‘816 just like a 6502, then slowly help yourself to more and more instructions as you get comfortable with them. I find that when you’re always handling 16-bit quantities, it’s actually easier to program than the ’02 is. It’s an understatement to say it still has the 6502 flavor; but it is much better suited to multitasking, multithreading, relocatable code, etc. that the ’02 is.

      One thing that puts people off seems to be the mode bits; but even there, it can be pretty simple. It comes out of reset in 6502-emulation mode, but I put it in native mode and leave it. There’s no reason to fool with that again unless you have both ’02 and ‘816 programs loaded at once and you’re moving back and forth between them. The other thing is the register-size bits. For my ‘816 Forth, I keep the accumulator in 16-bit mode and the index registers in 8-bit, and seldom change it. The REP and SEP instructions are awfully cryptic, but the easy solution to that is to use macros with intuitive names, so for example REP #00010000B gets replaced with INDEX_16 which lays down the same machine code but is much easier to understand in the source code.

      I started watching ARM seminars to learn ARM (and I would still like to), but it’s nowhere near as friendly as the 65 family is.

      1. Standard 32 bit ARM (e.g. ARM7) is very straightforward. For someone not already familiar with 6502, it’s probably easier to learn ARM than 6502.

        Modern Cortex is more complicated, but you don’t need to learn assembly language for a Cortex chip. Everything, including start-up and interrupts, can be done in C/C++.

    3. You wouldn’t even need to build a flash cart, they sell them. For a reasonable markup. I think some flash and a CPLD would do it though. And the copyright chip pulled out of a genuine cartridge, or the alternative, a slot on top to plug a real cartridge into, just to use it’s copyright chip. Plenty of pirate devices did that, as did region convertors, that allowed you to run other-region (JAP / USA / EUR) carts in your machine. They connected the copyright chip from a local-region game, since they differed. That’s the SNES I’m talking about. Megadrive carts were universal with only the plastic housing for region “protection”.

      Or there’s the “backup” machines of old, a floppy drive and enough RAM to store a cart in. They’d read in carts to store on floppies, then read the floppies back into onboard RAM to emulate a cart. Back in them days, 4MB RAM was very, very expensive! Made the devices very expensive, although so did their rarity and desirability, as well as the money they’d save you on games, assuming you knew of a games rental place. Often you could add extra RAM after purchase, as modules. They also often had a PC link, custom parallel port cable with software on the PC side, that’s how most of the ROM images got on the net.

      They’ve made modern ones since. Often using a USB link to upload stuff into on-cart Flash. Or taking SD cards, or USB memory sticks for storage.

      The N64’s famous Doctor V64 reflected it’s mid-1990s technology, using a CD-ROM drive for storage. Just a while before CD-RW drives became cheap and common. A cheaper version had the PC link only, no CD-ROM, so you’d have to use the PC to get stuff onto it. Another used a Zip drive, aah remember those? Interestingly, the Doctor’s onboard control software used a 6502.

      Piracy tech on consoles is as interesting as the machines themselves. There’s one for the Nintendo DS that has a 233MHz ARM with 32MB RAM onboard. All squeezed into a tiny DS cartridge! Significantly smaller than a book of matches. And that CPU and RAM are way more than those of the machine itself! The CPU is meant to help in combating anti-piracy routines in games. But the manufacturers are kind enough to release the specs and programming methods, so people have written emulators and other stuff that can use the extra power. Including quite powerful, 386-class PC emulators. Would be great to run Civ again on my DS. The emulator will work on a basic DS with an ordinary dumb backup cart, though obviously not as fast or with as much RAM.

      Wouldn’t surprise me if they got Quake running on it, given a bit of time. Emulated PC Quake, not native! Actually I still play the original Civ on the PC now. Don’t need the manual, the piracy protection asks you about the game’s scientific research tree, and that’s burned into my memory. From when I actually bought the game on a compilation CD, about 20 years ago. Civ, Lemmings, and Frontier: Elite II. A bargain!

  7. Those WDC boards look great, but if you wanna save money, get you personal C64 computer on ebay and start learning or write 6502 programs instantly. Benefits are SID sound chip, graphical output, attached keyboard, floppy interface and all signals on edge connector. :-)

  8. What’s with all the 6502 hate? I love how people trash something because they don’t use it…or find it valuable.
    Do you know how many “educational” training sessions I’ve sat in, programming books, etc. that were hundreds or thousands of dollars for useless crap I could download online? Good thing it wasn’t my dime.

    I would love to be “learning” with one of these dev boards.

    But, 6502 isn’t cool anymore. Instead, everyone prefers yet another widget that ends with “uino”. “WhatchamacallitUINO!” Yeah! That’s cool!

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s