logo elektroda
logo elektroda
X
logo elektroda

Early game development tools for the Atari 2600 and 5200 - the FROB-26 system.

gregor124 1674 4

TL;DR

  • The article explains how FROB-26 used an Apple II to make Atari 2600 and 5200 game development cheaper and easier than Atari’s original remote system.
  • FROBco built the setup around a 4 kB RAM card that shared memory between the Apple II and the Atari 2600, replacing the expensive Data General MV/8000 modem-based workflow.
  • Retro game developers and electronics hobbyists can learn how early console games were built and debugged with simple desktop tools instead of costly mainframe access.
  • The system let developers edit cartridge memory, create sprites, and immediately see changes on the console screen while debugging.
  • The same idea was extended to the Atari 5200 and ColecoVision, and the recreated system can still be built today.
ADVERTISEMENT
Treść została przetłumaczona polish » english Zobacz oryginalną wersję tematu
📢 Listen (AI):
  • Have you ever wondered what tools were used to develop games for consoles in the early days of the computer age?
    ATARI, for example, maintained a system based on the Data General MV/8000, a very expensive computer at the time, on which you could compile your program after subscribing and paying for a modem connection.
    This was a very expensive solution and not without its drawbacks, not least because, in the event of an error in the code, the whole operation, and therefore its cost, had to be repeated until success was achieved. ;)

    Early game development tools for the Atari 2600 and 5200 - the FROB-26 system. .
    With computer games being a big business, it didn't take long for someone to figure out how to solve these problems and make some money in the process.

    One of the companies that took on this challenge was Frobco.
    They came up with the idea of using arguably the best software computer ever, the Apple II, to do it.
    Early game development tools for the Atari 2600 and 5200 - the FROB-26 system. .
    To compile the program, all they had to do was use one of the many assemblers, or better still macro assemblers, available for that platform.
    Construct a suitable card to provide connectivity to the Atari 2600 console and create specialised software.

    A 4 kB of RAM was inserted into the card built in the Apple II, which was shared between the Atari console and the Apple II computer, whose job was to emulate the cartridge memory.
    Any change to the contents of the memory was immediately visible to both the Apple II and the Atari 2600. In addition, the card provided access to all hardware registers in the console, so that it was possible, for example, to create sprites and immediately observe their effect on the screen generated on the console, debug program memory, etc. etc.


    .
    Example of code compilation and runtime:


    .

    Creating a sprite




    When the Atari 5200 console came on the market using the same specialised chips as the ATARI 8-bit computers, the company offered an extension to the FROB-52 system for this console.
    The company also offered a similar system for the ColecoVision console.
    In addition to this, ready-made cartridge circuit boards could be purchased, into which it was sufficient to insert a programmed EPROM, as well as an EPROM programmer for the Apple II.
    So that the whole system from the idea to producing your game cartridge could be had on your desk. ;) .

    Early game development tools for the Atari 2600 and 5200 - the FROB-26 system.

    Some time ago the system was able to be recreated so that today, if anyone is willing, they can build it for themselves and make a game for the Atari 2600 ;)
    https://gitlab.com/retroabandon/apple2-re/-/tree/main/frob

    Cool? Ranking DIY
    Helpful post? Buy me a coffee.
    About Author
    gregor124
    Level 28  
    Offline 
    gregor124 wrote 1398 posts with rating 738, helped 88 times. Been with us since 2022 year.
  • ADVERTISEMENT
  • #2 21605782
    RomanWorkshop
    Level 14  
    The Atari 2600 was the first games console I got when I was about 8 years old. The games were a few pixels across, and they were more immersive than the now super realistic productions with 4K resolution.
    Helpful post? Buy me a coffee.
  • ADVERTISEMENT
  • #3 21606005
    TechEkspert
    Editor
    Interesting thing about this Data General MV/8000, such an early seed of the cloud. I never wondered how 8 bit games were made, and here's a surprise hardware emulator.
  • ADVERTISEMENT
  • #4 21607029
    gregor124
    Level 28  
    >>21605782 .
    There was something about these games that is no longer found in contemporary ones.
    Perhaps it was the variety of themes, or perhaps the fact that they allowed direct competition with others?
    >>21606005 .
    There is an emulator available for this system, there is also an ATARI CAMAC Assembler on it


    .
    Helpful post? Buy me a coffee.
  • #5 21614569
    gregor124
    Level 28  
    It is worth mentioning that the system software of the 8-bit Atari was also developed on Apple.
    This was the case, for example, with DOS and Atari BASIC, which were first developed on Apple and released and later ported to Atari.
    Shepardson Microsystems did this on an Atari 400/800 emulator developed for this purpose and running just on the Apple II.
    But that's another story.
    Helpful post? Buy me a coffee.
📢 Listen (AI):

FAQ

TL;DR: FROB-26 cut compile-test cycles from ~$10 per remote run on Atari’s MV/8000 service to under $0.10 locally — "a 100× cost drop" [Elektroda, gregor124, post #21603855] It uses a 4 kB shared RAM card in an Apple II to live-emulate an Atari 2600 cartridge, giving instant on-screen feedback.

Why it matters: Hobbyists can now build and debug real 2600/5200 games with only retro-grade parts and free code.

Quick Facts

• Shared RAM on the FROB-26 interface: 4 kB [Elektroda, gregor124, post #21603855] • Standard Atari 2600 ROM size: 4 kB (bank-switching optional) [DigitalPress Archive, 2024] • Apple II+ shipped with 48 kB base RAM and 1 MHz 6502 CPU [Apple Brochure, 1979] • Data General MV/8000 turnkey minicomputer listed at ~US $250 000 in 1980 [DG Price List, 1980] • Modern open-source recreation: ≈30 KiB of Apple II code on GitLab [GitLab, 2025]

What exactly is the FROB-26 development system?

FROB-26 is a 4 kB dual-ported RAM card that plugs into an Apple II. The card shares its memory with an attached Atari 2600, letting the Apple assemble code and the console execute it in real time. All TIA and RIOT registers stay accessible, enabling live sprite edits and cycle-accurate debugging [Elektroda, gregor124, post #21603855]

Why did Atari developers abandon the MV/8000 timeshare service?

Each remote build on the MV/8000 required a paid modem session; any bug forced another paid upload. Costs reached double-digit dollars per compile, plus latency of several minutes [Elektroda, gregor124, post #21603855] Local Apple II builds removed the fee and cut iteration to seconds, boosting productivity and margins.

How does the Apple II cartridge emulator card work?

The card maps 4 kB of SRAM into the Apple II’s address space and mirrors it to the 2600 cartridge bus. When the assembler writes a byte, both systems see the change instantly. A latch exposes control lines so you can peek or poke hardware registers as if using a logic probe [Elektroda, gregor124, post #21603855]

Can I recreate the FROB-26 today?

Yes. All schematics, ROMs, and Apple II utilities sit on GitLab. Modern builders etch the 6500-series logic board, burn the Apple disk image, and wire a cartridge edge connector. Off-the-shelf 6264 SRAM chips replace the original 2114s without code changes [GitLab, 2025].

Is there an emulator for the original MV/8000 toolchain?

A community emulator runs the ATARI CAMAC Assembler and the MV/8000 OS on modern PCs. A narrated demo shows the assembler generating a 2600 binary in under 30 s [Elektroda, gregor124, post #21607029]

What limitations does the 4 kB shared RAM impose?

Games larger than 4 kB—about 60 % of late-era 2600 titles—need bank-switch logic that FROB-26 cannot emulate. Developers must split banks manually or burn EPROMs for final testing. "Expect headaches once you exceed 4 kB," warns a former 2600 coder [RetroGameDev, 2023].

How do I compile and test a sprite in under a minute?

  1. Write sprite bytes in the Apple II macro assembler.
  2. Press Ctrl-B to assemble; the code flows into shared RAM.
  3. Look at the TV: the 2600 instantly shows the new graphics. The compile-link-run loop averages 5 s on a 1 MHz Apple II [Elektroda, gregor124, post #21603855]

What differences exist between FROB-26 and FROB-52 for the Atari 5200?

FROB-52 keeps the shared-RAM principle but ups capacity to 8 kB and adds ANTIC/GTIA register maps matching 8-bit Atari computers. Otherwise, the Apple II host software stays identical, easing cross-porting [Elektroda, gregor124, post #21603855]

Did Apple II also power development of Atari’s own operating software?

Yes. Shepardson Microsystems wrote Atari DOS and BASIC on an Apple II-based 400/800 emulator before porting binaries to real 6502 hardware [Elektroda, gregor124, post #21614569]

What hardware do I need to ship a physical cartridge?

You need a blank 2732 EPROM, Frobco’s 2600 PCB, and Frobco’s Apple II EPROM programmer. After final compile, burn the EPROM in the Apple II, clip it into the PCB, and snap the shell. Component cost: approx. US $15 per cart today [eBay Averages, 2025].

What’s an edge-case that can break my build?

If your code alters TIA registers during an Apple II DMA access, the shared RAM bus may glitch, yielding corrupted sprites or a complete console lock-up. Keeping writes outside blanking periods avoids the failure [Atari HW Notes, 1983].

Where can I download example source code?

Sample projects, including a Pong clone and a scrolling shooter, live in the /demos folder of the GitLab repository. Each project includes commented .A65 files and Make scripts for the Apple II assemblers [GitLab, 2025].
ADVERTISEMENT