Analogue has always sold a specific fantasy: not just “playing old games again”, but doing so with a kind of over-engineered respect that original manufacturers rarely had the budget for. The Analogue Pocket is that philosophy shrunk into the silhouette of a Game Boy, then sharpened with modern industrial design and a frankly excessive screen. Underneath it all sits an FPGA heart that refuses to emulate in the usual software sense, and a dock that turns this little slab into a living-room console.
My own unit is the white model, which only reinforces the “design object” feeling: it looks less like a toy and more like something that accidentally wandered out of a museum shop. It is a handheld that looks affordable, but behaves, and is priced, like a boutique instrument.
Two FPGAs Instead of One Emulator
Analogue’s core claim is simple: the Pocket is built around FPGAs, not a general-purpose CPU running software emulators.
A software emulator does something conceptually straightforward but technically messy: you take the original console’s behavior and model it in code. The emulator runs on a fast modern CPU, interpreting or recompiling instructions from the original system, faking video and audio timing, and approximating all the little quirks that games rely on. The host CPU is doing everything in sequence, one instruction after another, and the emulator is constantly juggling between accuracy and speed.
An FPGA works differently. It is a large grid of logic blocks and interconnects that can be configured to behave like custom hardware. Instead of “running an emulator”, you use a hardware description language (Verilog, VHDL, and so on) to describe the original console’s circuits: CPU, video hardware, audio unit, memory buses, timing generators. When the FPGA is configured with that design, it stops behaving like a generic chip and starts behaving like a hardware clone of the target console.
On the Pocket, that means:
- When a Game Boy core is loaded, the FPGA becomes a Game Boy-like machine at the electrical and timing level.
- When a Game Boy Advance core is loaded, the fabric is reconfigured into a different machine.
- When an openFPGA core targets a completely different system, the same physical silicon is rewired again into a new configuration.
The advantages over classic software emulation are subtle but important:
Timing and edge cases
Original games often rely on undocumented hardware behavior, exact clock relationships, or tiny race conditions between CPU, video and audio. A traditional emulator has to model all of this in software, stepping through time in small increments and constantly approximating how several components would have behaved in parallel. An FPGA core, by contrast, is a network of parallel circuits. Clocks, phases, and signal propagations are part of the design itself, which makes strange timing tricks and borderline cases more likely to behave as they did on original hardware.Latency and determinism
A software emulator is stacked on top of an operating system, drivers, and a renderer. Frames may be delayed by buffering, scheduling, or synchronization with the host’s GPU. An FPGA system can be much more direct: input, game logic, and pixel output are chained together in hardware, with fewer layers in between. That tends to reduce input lag and produce more predictable frame pacing, especially when the output display supports the right refresh rates.Hardware-level compatibility with cartridges and peripherals
Because the FPGA recreates the original memory maps and bus protocols, plugging an original cartridge into the Pocket looks almost exactly like plugging it into the original console—from the game’s point of view. Save chips, mappers, and oddball enhancements are all accessed through the same kinds of signals they expect. This is much harder to reproduce cleanly when the only thing the emulator sees is a raw ROM file.Separation between cores and platform
In the FPGA model, each “core” is a hardware design. Improve the core and you ship a new bitstream; the Pocket simply loads it and becomes a slightly better version of the same console. Bugs and inaccuracies exist, but they take the form of fixable hardware descriptions rather than layers of clever hacks in C++ abstractions.
None of this is free. FPGA capacity is finite, development is slow, and the chips themselves are expensive. That cost is built into the Pocket’s price, and into the fact that it targets a relatively small audience who care about this level of fidelity.
The Screen: Ten Game Boys Worth of Resolution
The first time you see a Pocket in person, the screen dominates everything else. It is a 3.5-inch LCD running at 1600×1440, for an almost absurd 615 ppi in roughly the same footprint as the original Game Boy’s panel.
That resolution is not just a spec-sheet trophy. Classic handheld resolutions land neatly into integer scales: 160×144 from the DMG Game Boy becomes a 10×10 pixel grid per original pixel. Sprites and text suddenly look like clean high-resolution artwork instead of shimmering blocks. Analogue leans into that with a library of display modes: DMG-style greens, Game Boy Color palettes, GBA-style warmer tones, different sub-pixel patterns, simulated grids and subtle “LCD” behaviors for those who miss the original flaws.
Combined with precise timing on the FPGA side, motion feels crisp and immediate. There is no sense of the smeared ghosting that haunts many cheaper LCD mods; instead, you get a kind of hyper-real version of handheld history—more detailed than the original screens ever were, but still visually anchored to their character.
Industrial Design: A Minimalist Tribute, Not a Clone
From a distance, the Pocket reads as “Game Boy, but drawn with a ruler”. The body is a clean rectangle with a high-gloss glass front covering the entire upper half and gently rounded edges on the shell. Face buttons follow Nintendo’s basic layout but are tighter and more symmetrical, with Start and Select tucked into the lower bezel instead of floating somewhere in the middle.
On the sides and back, the practicalities appear: a link port, microSD slot, USB-C for charging and the dock, and a rear cartridge slot that accepts all Game Boy-family Game Pak types.
This device feels even more like a minimalist reinterpretation than a straightforward homage. It sits comfortably on a desk next to cameras, keyboards, and laptops without looking out of place. It is a handheld, but it is also a piece of industrial design that happens to play cartridges.
Official Cartridge Adapters: Beyond the Game Boy Family
Out of the box, the Pocket is a Game Boy, Game Boy Color, and Game Boy Advance machine. Officially, though, Analogue never meant it to stop there. The company sells a separate adapter ecosystem that lets the same FPGA brain impersonate a wider set of handhelds while still using original cartridges.
There are two main branches:
- A Game Gear adapter, sold as a dedicated accessory.
- The Analogue Pocket Adapter Set, a three-pack that covers Neo Geo Pocket Color, Atari Lynx, and TurboGrafx-16 / PC Engine / SuperGrafx HuCards.
Inserted into the Pocket’s rear slot, these adapters become little plastic bridges between very different ecosystems. In practical use, they feel surprisingly seamless. Slide in a Lynx card or Neo Geo Pocket Color cart and the system reconfigures to match the original hardware model, just as it does switching from GB to GBA.
Owning the Analogue Pocket with these official adapters turns it into a strangely dense archive: Atari’s early color experiments, SNK’s compact fighting machine, Hudson’s HuCard world—all squeezed into the footprint of a modern Game Boy. It is still “original media, original timing”, but now spread across several companies that never designed their hardware to coexist like this.
openFPGA: From Cartridges to ROM-Driven Multi-System
The physical cartridges are only half the story. The other half lives on the microSD card and inside the firmware.
Analogue’s openFPGA initiative exposes the Pocket’s FPGA fabric to third-party developers. Instead of only relying on Analogue’s own cores, openFPGA allows independent projects to define their own hardware implementations and ship them as downloadable cores.
Once configured, the Pocket is no longer just a Game Boy derivative with adapters. It becomes a menu of soft consoles and arcade boards:
- Additional handhelds beyond the official adapter set.
- Eight- and sixteen-bit home consoles like NES, SNES, Mega Drive / Genesis, and PC Engine in core form.
- Selected arcade systems, where FPGA resources permit.
ROMs live on the microSD card; the Pocket’s role becomes that of a hardware-accurate host. For preservation, this is an appealing model. Cores can evolve, bug-fix, and be archived independently of any given hardware revision, while ROM sets safeguard aging carts whose save batteries will eventually die.
The ethical line is familiar: nothing in the hardware stops you from loading whatever ROMs you can find. Analogue keeps its own OS and official cores closed, and frames openFPGA as a platform for development and preservation. What people actually load into it is, as always, their own responsibility.
The Dock: From Handheld to Living-Room FPGA Console
The Pocket experience changes character when you drop the handheld into the Analogue Dock. Physically, the dock is understated: a compact base with a USB-C post at the top, HDMI and USB-A ports at the back, and not much else to look at.
Once docked, the Pocket’s FPGA cores drive 1080p HDMI output to a TV or capture device. Wired USB controllers and a range of Bluetooth pads can be paired, turning handheld games into couch multiplayer. Firmware updates have gradually broadened controller support, including Nintendo’s own retro-style wireless pads intended for Switch Online, which fit naturally when you are running SNES or Mega Drive cores via ROMs.
For Game Boy-era software, the dock effectively recreates the old “handheld-on-TV” tricks—think Super Game Boy on the Super Famicom or Game Boy Player on the GameCube—but with cleaner video, more flexible scaling, and modern controller options. For openFPGA home console cores, the Pocket-in-a-dock simply behaves like a small FPGA console that happens to undock and become a handheld when you leave the house.
The economics are still harsh. A 219.99 USD handheld, a 99.99 USD dock, a 99.99 USD adapter set, a separate Game Gear adapter, and whatever controllers you bring: this is not a budget way to revisit the past. It is, very clearly, an enthusiast stack.
A Machine Honestly Aimed at Enthusiasts
There are cheaper, simpler ways to play ROMs. Android handhelds, Raspberry Pi builds, and a whole ecosystem of emulation-focused devices exist precisely to treat retro gaming as a solved software problem: pick a SoC, run Linux, ship an emulator front-end.
The Analogue Pocket finish with its official adapters and dock, is almost aggressively different. It uses FPGAs where a cheap ARM chip would suffice, a screen whose pixel density has no business being attached to thirty-year-old games, and a set of accessories that clearly assume you are prepared to spend serious money on a hobby that already peaked decades ago.
For some people, this will forever be the wrong answer. If all you want is a handful of childhood favorites on the commute, an inexpensive emulator handheld makes more practical sense. But if you treat cartridges as a collection, care about timing quirks, want Atari Lynx cards and HuCards and Neo Geo Pocket Color carts to all converge on one piece of hardware, and appreciate the sensation of over-specified design in your hands, the Pocket becomes a very particular kind of ideal object.
In that sense, it fits neatly into what Retro Obsession is about: not just keeping old games technically playable, but exploring what happens when modern engineering and old ideas collide. The Analogue Pocket is one of the clearest examples of that collision—an FPGA monument to handheld history, now extending far beyond the Game Boy family, unapologetically priced and designed for the kind of person who sees a FPGA handheld and immediately imagines the shelf it should live on.