1992: Gameboy68000, ToyBoy, and the Game Boy Emulator That Wasn’t

A tiny Amiga archive called Gameboy68000.lha survives with an August 1992 date and a name that seems to promise Game Boy games on a home computer. For years, it looked like an early milestone in emulation. There was one awkward catch: the surviving package could not run software made for the real Nintendo handheld.

Inside the archive is an emulator-like program with a Game Boy-style environment and material related to Tetris. Pair that with the filename—Game Boy software on a Motorola 68000 machine—and the story seemed straightforward. Older histories described it as an extremely early Nintendo Game Boy emulator, sometimes calling it the first known attempt to emulate the handheld on a home computer.

Marat Fayzullin’s surviving Game Boy FAQ tells a different story. It identifies the public package as ToyBoy, a Game Boy look-alike associated with British developer Argonaut Software, and explicitly warns that it is incompatible with the real Game Boy. A much later account from Argonaut programmer Dylan Cuthbert helps explain how a team could build something resembling Nintendo’s machine before it fully understood the hardware.

The accounts fit a development process that began with an approximate Game Boy-like environment and moved on to the real machine. The surviving Gameboy68000/ToyBoy archive could be Cuthbert’s early Amiga emulator, a derivative or another experiment from the same period. Its exact relationship to his program remains unproven.

Argonaut also went well beyond approximation. The team physically probed Nintendo’s Game Boy, built its own development setup and learned enough about the machine to make a working three-dimensional engine. That experiment became X, published by Nintendo in Japan on May 29, 1992. Its prototype, Eclipse, would help establish the Argonaut–Nintendo relationship that led toward the Super FX chip and Star Fox.

The Game Boy Looked Simple — Until You Tried to Recreate It

The Game Boy hardly looked like a difficult machine to recreate. Its monochrome display measured just 160×144 pixels, its processor ran at roughly 4.19 MHz, and its games came on small cartridges. There was no dedicated polygon hardware, optical drive or multitasking operating system. Beside later consoles, it looked almost comically modest.

But matching those specifications would not make a Game Boy game run. Software depended on the machine’s particular behavior. Its processor belonged to the broad Intel 8080/Z80 family without being an ordinary desktop Z80: modern technical references document removed instructions, changed opcodes and different flag behavior. Around that processor sat timers, interrupts, serial communication, joypad input, LCD control and sound. A game expected all of them to behave as Nintendo’s hardware did.

Even drawing the picture involved more than putting the right pixels on screen. The Game Boy built its image from tiles, tile maps and sprites, with tightly controlled LCD behavior. Games could depend on scanline timing, interrupts and changes to hardware registers. Cartridges could complicate things further: memory bank controllers switched which sections of ROM or RAM the processor could see. Those cartridge differences became increasingly important as the library grew.

An approximate Z80 environment could still help a developer test programming ideas, estimate performance or build tools. Loading arbitrary retail Game Boy cartridges was a much tougher demand.

Argonaut Starts by Imagining the Game Boy

In a 2025 interview, Dylan Cuthbert recalled joining Argonaut while he was still young enough to leave school for the job. One of his first assignments was to build a Z80 emulator on the Amiga. The team had not yet fully reverse-engineered Nintendo’s hardware, so he tried to reproduce what they imagined the Game Boy’s architecture would be like.

Cuthbert said their estimate was “not too far wrong.” That gave Argonaut a head start when the team moved from theory to hacking the actual hardware. The Amiga program was an early research and development tool, built around an educated guess about a new handheld rather than a fully understood machine ready to run commercial ROMs.

The Amiga was a natural place to try it. Commodore’s 68000-based computer family already hosted cross-platform experiments, including the commercial Commodore 64 and Macintosh emulation software covered in earlier chapters. By the early 1990s, Amiga programmers were accustomed to making their computer imitate very different hardware.

Gameboy68000 Appears in the Amiga Archive World

The modern Aminet mirror at FAU lists Gameboy68000.lha under misc/emu, with a timestamp of August 15, 1992 and a compressed size of just 27K. The archive gives this story a surviving program and a dated catalog entry.

Aminet itself was still taking shape. It began as an Amiga FTP archive hosted in Switzerland in 1991. Urban Dominik Müller took over administration in January 1992 and introduced the .readme collector that became one of its defining features. When the popular ab20 Amiga archive went offline in April, users flooded toward alternatives, and the first mirror appeared. The name Aminet arrived in June, followed by the first Aminet Download Tool in August. By December, its Usenet announcements listed eight international mirrors.

Those mirrors gave small programs a better chance of surviving. Many emulators circulated as tiny archives on FTP servers, bulletin boards and university networks rather than as commercial releases. Lose the server without a copy elsewhere, and the software could vanish too. Aminet and similar archives became accidental software museums long before preservation was an organized movement. Gameboy68000 survived that way, but its file could not explain who had written, copied, renamed or uploaded it—or how later users had interpreted it.

Tetris Made the Story Look More Convincing Than It Was

The Tetris material around the Gameboy68000/ToyBoy package made it easy to believe that an Amiga was already running Game Boy software. Nintendo’s handheld and its falling blocks were inseparable in the public imagination. An emulator-like program running a Tetris demonstration looked convincing. The catch was which Tetris it could run.

A demonstration written for an imagined or custom Game Boy-like environment could show that the environment worked on its own terms. Running the binary data from Nintendo’s retail Tetris cartridge demanded something more: an accurate enough recreation of the machine that the cartridge expected to find. Familiar blocks on the screen could not settle that question.

Jez San and the Argonaut Connection

Marat Fayzullin’s surviving General Questions About GameBoy page supplies the correction. It calls ToyBoy a Game Boy look-alike emulator, says the package circulating on Aminet is incomplete and “has nothing to do” with the real Game Boy, and connects it directly to Argonaut. The FAQ attributes the explanation to Argonaut managing director Jez San: ToyBoy was an internal emulator built to investigate how difficult Game Boy programming might be. Its authors did not yet know the real hardware internals, so the program was incompatible with Nintendo’s system.

The FAQ also alleges that the package was taken from Argonaut without authorization. Who copied or uploaded the files, and how they left the company, remains unclear. The package’s public availability is much better documented than its route out of Argonaut.

From Approximation to the Real Hardware

Then Argonaut moved from its approximation to an actual Game Boy. Cuthbert recalled that the early Amiga emulator gave the team a head start when it began hacking the hardware to load its own programs. Other interviews describe the company constructing its own development arrangement because normal official Game Boy tools were difficult for it to obtain.

Getting a program onto the handheld brought many of the same problems an emulator developer would face. The team needed to understand the CPU, the layout of memory and the route graphics took to the screen. It also had to work out how a cartridge communicated with the machine and what happened during startup before a game was allowed to run. Building software for a console and recreating that console were different jobs, but both required getting past guesses about what happened inside it.

Commercial Game Boy development systems did exist, including specialized Intelligent Systems hardware. The small British company had not begun with that comfortable official setup. Argonaut improvised—and the Game Boy’s startup checks gave it another problem to work around.

The Boot Logo Was Part of the Security System

Before a Game Boy could run a game, its cartridge had to pass a check involving the Nintendo logo. The handheld’s boot ROM—the code that runs at startup—read logo data from the cartridge, displayed it, then checked it before handing control to the game. Wrong data could stop startup altogether. The familiar logo was doing a second job as part of Nintendo’s technical check on cartridge identity.

San later recalled that Argonaut found a way to show different data on the screen while still passing the check. Modern reverse engineering explains how that could work: the Game Boy reads the logo for display and then checks it in a separate step. Carefully changing the data presented between those stages can change what the player sees without necessarily stopping the game from starting. Argonaut was learning to observe the handheld’s behavior, test it and bend it—work that had much in common with building an emulator.

The two stages of that startup process are explained in Catskull’s reverse-engineering article on the Game Boy boot screen. San describes Argonaut demonstrating its technical tricks to Nintendo in later Time Extension interviews.

Dylan Cuthbert

Cuthbert’s 2025 interview traces the progression: first the Amiga-hosted Z80 emulator, then experiments with the real hardware, then a small 3D demo called Eclipse. Argonaut began by modeling the machine it expected to find, tested those ideas against the actual Game Boy, and used what it learned to make the handheld do something visually unexpected.

Eclipse: A 3D Demo on Hardware That Was Never Designed for It

That last step survives in the recovered Eclipse prototype. After the demo was rediscovered in preserved development material, the Video Game History Foundation reconstructed its story in 2023. By this point, Cuthbert had moved well beyond the hypothetical Game Boy-like environment: he had a 3D world running on the real machine.

Eclipse presents that world from a first-person viewpoint, using lines, simple objects and wireframe geometry. On a monochrome handheld with a tiny screen, an inexpensive processor and no polygon accelerator, even those spare shapes were demanding. There was no dedicated hardware to take over the 3D work. Every line had to be calculated and drawn in software, within tight performance limits.

The prototype also gave those lines something to do. Surviving screens show vehicles, status information, missiles and a navigable 3D space. Eclipse was already taking shape as a game, rather than remaining a test of how much geometry Cuthbert could put on the screen.

Nintendo Sees the Demo

Cuthbert says Eclipse was shown to Nintendo around the Consumer Electronics Show period, after which he and San were flown to Nintendo’s headquarters in Kyoto. Nintendo liked the demo and signed a deal to turn it into a complete game. Recollections differ slightly on the order of meetings and demonstrations, but agree on where they led: Argonaut’s 3D experiments opened a direct relationship with Nintendo. A team that had started without a comfortable official development setup, imagining and then hacking the handheld, was now working with its maker.

Inside the Small Argonaut Culture

Argonaut was still a small company, far from the sprawling studios that would later dominate game development. It developed a reputation for programmers who wrote their own technology, built tools from scratch and tackled hardware problems larger teams might have avoided. Alongside Cuthbert and San, the later Nintendo collaboration included Peter Warnes, Giles Goddard, Carl Graham, Ben Cheese and others.

May 29, 1992: X Reaches the Game Boy

Eclipse eventually reached players as X. Nintendo’s historical Game Boy software listing dates its release to May 29, 1992, and MobyGames records the same date. MobyGames also credits Nintendo as publisher, Argonaut Software as a developer, and Dylan Cuthbert with programming and design. The small 3D demo had become a commercial Nintendo Game Boy game.

The finished game puts the player into first-person space combat and tank action across ten missions, with surface navigation, fighting and tunnel travel. Its world is drawn in sparse wireframes because the Game Boy had almost no resources to spare for real-time 3D. Those economical lines made a navigable three-dimensional world possible on the handheld.

Even the box sold the Game Boy’s unlikely new trick. The artwork for X emphasized geometry, space and abstract 3D forms, rather than dressing it up as a familiar platformer or puzzle game. Nintendo made that unexpected look the game’s identity.

But X never got a normal worldwide release. A planned English-language version is commonly associated with the name Lunar Chase; Nintendo’s Japanese release remained the version most players knew. With distribution so limited, the game’s place in history stayed obscure outside specialist circles for years.

From the development experiment to a finished game

X does not emulate another commercial console. Its connection to this story runs through Cuthbert’s move from modeling an imagined Game Boy on the Amiga to investigating the real hardware. Making the game drew on the same close attention to CPU behavior, memory, timing, graphics and cartridges that emulator development required.

Marat Fayzullin Preserves the Correction

Another story attached itself to ToyBoy: that its code became the basis for Marat Fayzullin’s Virtual GameBoy. Treat the 1992 archive as a working Game Boy emulator, and the sequence sounds plausible—ToyBoy supplies early knowledge of the handheld, Marat acquires it, and VGB follows a few years later.

Marat gives a different account on the official Virtual GameBoy website. He says he began writing VGB in 1995, after finding Game Boy programming information on the Internet, and relied on his earlier experience with fMSX. His documentation does not identify ToyBoy as VGB’s technical foundation.

Aminet Preserved the File Better Than the Story

Software archives often preserve files after their context has gone missing. An emulator can outlive its website, lose its readme or acquire a new name on a mirror. Upload dates can be mistaken for release dates, authors may be known only by handles, and unrelated projects can share a name. A rumor copied from a BBS post into FAQs, websites and modern articles can then look like dozens of independent confirmations.

Cuthbert fills in the background

Cuthbert’s 2025 recollection gives the early Amiga experiment a practical role: it let Argonaut start exploring how to program the handheld before the team had finished reverse-engineering Nintendo’s hardware. The emulator was a working hypothesis, not simply a failed attempt to run retail games.

From Game Boy Experiments to the Super FX

Argonaut’s Game Boy work also led to a bigger hardware problem: giving the Super Nintendo more power to draw polygons. Nintendo’s interest in the company’s 3D work grew into a larger collaboration, and Argonaut proposed custom hardware to push beyond what the base 16-bit console could do.

That proposal became the programmable processor family best known as Super FX. Star Fox made the chip famous in 1993, with more Super FX games following. Cuthbert and other Argonaut programmers spent extended periods working directly with Nintendo in Japan, while Argonaut’s engineering staff developed the technology in Britain. Work that had begun with software experiments now led to a new processor.

Two programs, one stubborn mix-up

The distinction is simple: Fayzullin describes the surviving ToyBoy package as incompatible with Nintendo’s Game Boy; Cuthbert recalls a genuine emulator used to explore an imagined version of the hardware. Together, those accounts explain Argonaut’s experimental approach without proving that the two programs were identical.

Aminet kept the file available; later FAQs, interviews and research helped recover its context. The Video Game History Foundation’s work on Eclipse also gave substance to a story that might otherwise have remained little more than an anecdote. Code alone could not tell this whole story. Manuals, disks, screenshots and the memories of the people who did the work helped explain what had survived—and what it had actually been built to do.

The Road to 1993

By 1993, the obscure experiments of 1990–1992 were beginning to share the stage with projects built for wider use. Their authors would create reusable emulator architectures, distribute source code and reach users across the rapidly expanding Internet. Isolated experiments would continue, but an emulator-development community was starting to form.

Fayzullin’s role in that story goes well beyond correcting the ToyBoy record. His fMSX would become an early example of a portable, source-available emulator, giving him experience he later carried into Virtual GameBoy, iNES and several other systems.

Sources and Further Reading

• Aminet mirror — Gameboy68000.lha listing dated August 15, 1992
• AminetWiki — The history of Aminet
• Marat Fayzullin — General Questions About GameBoy, including the ToyBoy clarification
• Marat Fayzullin — Official Virtual GameBoy history
• Low Poly Pigeons — Dylan Cuthbert interview transcript discussing the Amiga Z80 emulator
• Video Game History Foundation — Eclipse: The Demo that Sold 3D to Nintendo
• Time Extension — Jez San on Argonaut, Nintendo and Star Fox
• Time Extension — The making of Star Fox and the Argonaut/Nintendo relationship
• Nintendo Japan — historical Game Boy software listing confirming X on May 29, 1992
• MobyGames — X release information and credits
• Game Boy hardware database — DMG-CPU-01 hardware photographs and component data
• Catskull — Reverse Engineering the Game Boy Boot Screen