Pokémon Gen 1 gets a 3D voxel release on PSP Vita

Pokémon Red and Blue have been emulated on almost everything with a screen. Pocket Voxel takes a different route. Instead of simply running the original Game Boy game inside an emulator, the project rebuilds the first-generation Pokémon experience around a 3D voxel renderer. The familiar towns, routes, buildings and landscapes are turned into blocky 3D environments, while the game itself still follows the rules and structure of the original adventure. The project first targeted Sony’s PSP. It has now expanded to PS Vita, where the same game package can run with a renderer designed for the Vita’s more capable hardware and higher-resolution display.

Pokémon Gen 1, but viewed differently

The original Pokémon games arrived in Japan in 1996 before Pokémon Red and Blue reached Europe in 1999. They established the basic formula that still defines the series: explore a region, catch Pokémon, train a team, battle other trainers and work through a series of Gyms on the way to the Pokémon League. There were 151 Pokémon, one main region and a relatively simple top-down presentation designed around the Game Boy’s tiny monochrome screen.

Pocket Voxel keeps that basic game underneath. What changes is the way you see it. Maps become 3D voxel scenes. Trees, buildings, paths and terrain gain actual depth instead of being made from flat tiles. Characters and Pokémon are still presented as sprite-like elements, so the project doesn’t try to turn the game into a fully modern 3D remake.

That choice matters. It lets Pocket Voxel change the visual presentation without redesigning the whole game. Menus, dialogue boxes and battle information also stick closely to the Game Boy-style interface. So while the world has been rebuilt around voxels, the game still behaves much like the original.

TypeScript runs the game logic

Underneath the graphics, Pocket Voxel has an unusual setup. The game systems are written in TypeScript. That includes movement, collisions, maps, scripted events, NPC behaviour, random encounters, menus, items, saving and Pokémon battles.

The TypeScript code runs inside QuickJS, a lightweight JavaScript engine embedded into the project. Game logic updates at a fixed 60 Hz, meaning the simulation keeps ticking at the same rate even when the final graphics are displayed differently on each handheld. Rust handles the other side of the system.

It manages the voxel world, camera, characters, battle scenes, interface rendering and sound. Rather than sending the complete state of the game between TypeScript and Rust every frame, the game logic sends smaller instructions when something in the scene needs to change. That keeps the two parts fairly separate. TypeScript decides what’s happening. Rust works out how to put it on the screen.

The same game data works on PSP and PS Vita

One of the more interesting parts of Pocket Voxel is how it handles the two Sony handhelds. The PSP and Vita don’t need completely separate copies of the converted game data. Instead, Pocket Voxel produces a prepared data package of roughly 31 MB that both systems can use. Each handheld then gets its own renderer.

On PSP, the game displays at 30 frames per second while the underlying game logic continues running at 60 Hz. That lets the gameplay simulation stay consistent without asking the PSP to redraw the full voxel scene 60 times every second. The Vita has more room to work with.

Pocket Voxel uses the same logical 480 x 272 layout as the PSP version but renders it at the Vita’s native 960 x 544 resolution. In simple terms, everything stays in the same place, but the Vita gets more pixels to draw it with.

The graphics code also changes between machines. The PSP version talks to Sony’s Graphics Engine hardware, while the Vita build uses a renderer based around the Vita’s GXM graphics system. There are a few differences in how transparent sprites are handled, but the main voxel environment and interface follow the same overall design.

You still need the original Pokémon game

Pocket Voxel doesn’t include the commercial Pokémon game data needed to run it. Users have to provide a compatible US first-generation Pokémon ROM themselves. The build tools check the ROM before extracting the material Pocket Voxel needs, including maps, graphics, text, encounters, Pokémon information, moves and audio data.

From there, the original map information gets converted into the voxel format used by the new renderer. The installation process depends on the handheld. The PSP build places the executable and converted data together, while the Vita version can be packaged into a VPK for installation on compatible homebrew-enabled hardware. It’s a technical project, and setup isn’t aimed at someone expecting to install a normal commercial game from a storefront.

A different way to run an old Game Boy game

Pocket Voxel sits somewhere between a port, a reimplementation and a new rendering engine. The important part is that it isn’t simply putting a 3D effect on top of an emulator. The game logic has been rebuilt in TypeScript, the visual side runs through a Rust voxel renderer, and the hardware-specific graphics code changes depending on whether it’s running on PSP or Vita.

Adding Vita support shows how portable that structure can be. The same Pokémon Gen 1 game package can now sit underneath two different Sony handheld renderers, with each version using the hardware it has available. The result is still recognisably Pokémon Gen 1. It just reaches the screen in a very different way.

Spread the love