HexGL 32X brings the futuristic racer to Sega’s 32X hardware

HexGL started life as a browser game. Now it runs on a Sega 32X. That sounds simple enough, but it really isn’t. HexGL 32X isn’t the old game wrapped inside an emulator or pushed through some compatibility layer. It’s a fresh C implementation written for the 32X hardware, using the add-on’s SH2 processors, its framebuffer and its PWM audio system. The result is a compact anti-gravity racer with three tracks, timed laps, boost management and a full software 3D renderer. It takes the basic idea of HexGL and rebuilds it around hardware from the mid-1990s.

HexGL started in the browser

The original HexGL appeared in 2012 and was created by French developer Thibaut Despoulain, also known as BKcore. At the time, browser games were changing quickly. WebGL had made proper hardware-accelerated 3D graphics possible inside a browser, and HexGL was one of the projects that showed what that could look like.

It used HTML5, JavaScript, WebGL and three.js. The racing itself took clear inspiration from games such as Wipeout and F-Zero, with a hovering craft, twisting circuits and a strong focus on speed. You launched it in a browser and raced. No traditional game installation was needed. The 32X version works very differently. There’s no browser, no WebGL and no JavaScript. It’s a native ROM designed specifically for Sega’s hardware.

The 3D graphics are built in software

This is where the project gets technically interesting. HexGL 32X draws its 3D world using a software polygon renderer. The game transforms track geometry into camera space, clips polygons that get too close to the viewpoint, projects everything onto the screen and then draws the result into the 32X framebuffer. There’s no modern GPU doing the heavy lifting.

Track surfaces use textured polygons with affine texture mapping. That method is simpler than perspective-correct texturing, but it also puts less strain on the hardware. To keep visual distortion under control, the tracks are divided into smaller sections.

Distance shading comes from the colour palette. Textures use blocks of related colours, allowing the renderer to darken surfaces as they move farther from the camera without doing expensive lighting calculations for every pixel. Some distant geometry can also switch to flat shading. That cuts the workload further. It’s a practical renderer built around the limits of the machine.

There are three tracks to race

HexGL 32X currently includes three circuits. Neon City runs through a dusk setting and mixes faster sections with a chicane and a tight harbour-style hairpin. Skybridge opens things up with a wider track, faster sections and a large climb across a bridge. Red Canyon narrows the racing line and adds linked S-bends and two hairpins.

Each race lasts three laps. The game records individual lap times and your overall race time, so the structure is immediately familiar. You accelerate using B or C, steer with the D-pad and hit A for a manual boost. Boosting isn’t free, though.

It drains your shield energy. Hitting the walls takes energy too, which means a messy lap can quickly leave you in trouble. Lose the entire shield and the ship is destroyed, forcing a restart. That gives the boost system a useful trade-off. You can push harder, but you can’t simply hold the button forever.

The visuals keep HexGL’s basic identity

The 32X version follows the general visual language of HexGL without simply copying the old game’s assets. Track surfaces use hexagonal patterns, bright edges and clear lane markings. Boost pads animate on the road surface, while walls carry technical panels and hazard markings. The finish line uses a traditional chequered pattern.

It’s clean and readable. That’s especially useful in a fast racing game, where you need to understand corners and track boundaries almost instantly. The visuals aren’t overloaded with detail, and the track remains the main focus.

The second SH2 handles the sound

Audio also uses the 32X hardware directly. The game produces sound through the system’s PWM audio output, with the second SH2 processor taking care of synthesis. That includes the engine tone, which changes as the ship’s speed changes.

There are also separate sounds for boosting, scraping against walls, countdowns, lap events, explosions and menus. Splitting the work between the two SH2 processors makes sense. One processor can spend more of its time running the game and drawing frames, while the other takes responsibility for audio. It’s a straightforward division of labour.

The project includes automated testing

The development setup doesn’t stop at getting the ROM to boot. HexGL 32X also includes automated emulator tests covering several parts of the game. Those checks look at startup behaviour, video output, track selection, state changes, ship movement, steering, visible textures and audio activity.

There are also tests for the individual circuits. That matters because a game like this has several systems running at once. Rendering, controls, timing, track logic and audio all need to keep working while the race continues. Automated testing gives the developer a way to catch problems without manually replaying every track after each change.

What HexGL 32X offers right now

The current release is version 0.0.1. It’s a downloadable 32X ROM with three tracks, three-lap races, boost and shield mechanics, software-rendered 3D graphics and hardware-driven sound. The codebase is split across the renderer, racing logic, audio system, track tools and support code for the Mega Drive side of the hardware. Most importantly, it isn’t trying to run the original WebGL game unchanged.

HexGL 32X takes the core racing idea and rebuilds it for a completely different platform. The browser version relied on modern web graphics technology. The 32X version has to draw, shade, move and sound like a racing game using hardware designed decades earlier. That’s the whole project in a sentence: HexGL, rebuilt as an actual Sega 32X game.