The gaming industry has changed. Corporations have become greedy and want to mlik you for every dime. Gaming used to be something special, if you grew up with the Genesis, SNES, Game Boy, or GBA, even up to the early Nintendo DS you know the feeling tight pixel art, responsive controls, and games that ran on hardware with less RAM than a modern thermostat oh and you actually owned the games. That era of gaming shaped how I think about systems design. So when I set out to build a handheld console, I didn't want a nostalgia clone or another emulator machine. I wanted modern retro, the soul of those classic machines, built on today's silicon. I also wanted it to be open not just "here's a console figure it out" but an entire ecosystem that makes development, deploment, simulation and making your own games simple, and when I say open I mean down to the chips, so RISC-V was the natural choice. 

That's RV-Boy

 

The Hardware

RV-Boy runs on the WCH CH32V307, a 32-bit RISC-V microcontroller with 64KB of RAM and 256KB of ROM, you can increase ROM and decrease flash and vice versa for the chip, but I left it as that becuase it's the default and I needed the extra flash anyway. For the display, I went with a 4-inch capacitive touchscreen LCD. I know, buttons are king in retro gaming. But here's the thing: on-screen controls give you options. I can add a thumbstick later without ever worrying about drift. Softbuttons means developers can put thier game landscape or portrait, though landscape is preferred. It also diferentiates itself from every other console out there, the distraction free ad free gaming, but the tocuh you're familiar with on your smartphone. For more powerful MCU configurations down the road, I'll add external controllers and physical buttons too, so you get both worlds.

The form factor is deliberate. Classic feel, modern flexibility.

To see it in action, check this video: https://www.youtube.com/watch?v=KCqui4CP1yg

 

RV-Tile: The Engine

RV-Tile is the custom game engine that powers RV-Boy. It's not a library I pulled off GitHub. It's built from scratch, in C and assembly, targeting bare metal RISC-V, no OS, no abstractions, no runtime hiding what the hardware is doing.

The name comes from what it does at its core: tile-based rendering on RISC-V. Think of it as a modern take on how the SNES PPU worked, but implemented entirely in software on a microcontroller. Where those classic consoles had dedicated graphics hardware to handle tiles, sprites, and scrolling, RV-Tile does it all through carefully optimized code running directly on the CH32V307's RISC-V core.v The engine also has stuff like camera support and other things that make the user feel really good. 

 

Physics and Player Feel

The engine also integrates physics inspired to how AndEngine and Box2D did stuff, of course I didn't integrate those but the idea of "rigid body physics" is what I have going. Getting a platformer to feel right is harder than getting it to work correctly. RV-Tile implements several techniques borrowed from modern indie platformer design that would have been luxuries on original era-specific retro hardware:

Jump buffering: if the player presses jump a few frames before landing, the jump still registers. This makes the controls feel responsive rather than punishing.

Coyote time: the player can still jump for a few frames after walking off a ledge. Named after Wile E. Coyote's ability to hang in the air before looking down. This single feature makes platforming feel dramatically more forgiving without making it easier.

Gravity and acceleration curves: the player's jump arc isn't a simple parabola. The rise is faster than the fall, and holding the jump button extends the arc. This gives the player fine-grained air control. I also integrated a lot of easing functions to help with stuff like that. 

I also have a particle system thats good for explosions and hits and what not. 

 

Rendering Pipeline

RV-Tile uses a strip-based buffer renderer that pushes pixels to the LCD via DMA. Instead of rendering an entire frame into a buffer (which would blow past the 64KB RAM limit), it renders in horizontal strips and streams them via buffer directly to the display controller. This is similar to how the SNES PPU rendered scanline-by-scanline, except RV-Tile does it without any dedicated graphics hardware, just raw CPU cycles and DMA transfers.

The color space is RGB-565, giving us 65,536 colors to work with. That's a massive step up from the SNES's 256-color palettes or the GBA's 32,768 colors, while keeping the per-pixel memory footprint at just 2 bytes. I think the console graphics looks really good. 

 

Tilemap System

The level design pipeline is built around Tiled, the open-source map editor, that I jump to anytime I have to make games. If you never used Tiled give it a shot its really amazing. Levels are designed on PC as .tmj files, then run through custom converters that output binary data optimized for the CH32V307's flash storage. The tilemap system supports entity marker layers from Tiled, so enemy spawn points, collectible locations, and trigger zones are all authored visually in the editor and flow directly into the engine.

This is one of the most important design decisions in RV-Tile. A game engine without good tooling is just a tech demo. The Tiled integration means I can design, iterate, and test levels rapidly using a mature, well-documented editor, then convert them into the engine's native format with a single command.

 

Backgrounds

The background system supports 4 independent layers plus a parallax scrolling layer. Each layer can scroll at a different rate relative to the camera, creating the classic depth illusion that made games like Sonic and Donkey Kong Country feel so alive. On the SNES, this was handled by Mode 1 hardware registers. On RV-Tile, it's done in software, which actually gives more flexibility, since I'm not limited to fixed hardware modes.

 

Game Systems

Beyond the rendering engine, RV-Tile includes a full suite of game systems:

Enemy AI: enemies support patrol patterns, player-chase behavior, and projectile attacks. Each enemy type can be configured with different parameters loaded from the Tiled entity layer.

Collectibles and scoring: a system for pickups with animated sprites, collection effects (particles), and a running score counter.

Health system: heart-based health with invincibility frames after taking damage, exactly like the classic Zelda, Castlevania approach from that era. 

HUD: bitmap font rendering, icons, and counters drawn directly to the display. No operating system font APIs, every glyph is a hand-crafted bitmap stored in flash give a nice retro touch, 

Scene manager: handles transitions between Title Screen, Gameplay, Pause, and Game Over states. Clean state machine, no spaghetti which if I'm being honest is very easy to do in a C based game like this. 

What's Running Right Now

This is a work in progress, but here's the current state of the engine:

Rendering & Graphics

  • Strip-based renderer with DMA-to-LCD pipeline
  • RGB-565 color space (65,536 colors)
  • Parallax background with 4-layer background system
  • Tilemap system using Tiled on PC for level design, with custom converters feeding into the engine

Physics & Collision

  • Solid tile collision using 8-point AABB with axis-separated resolution
  • Player physics with gravity, jump buffering, and coyote time

Game Systems

  • Sprite system with animation, flipping, and bounding boxes
  • Sprite modifiers and a particle system
  • Enemy AI supporting patrol, chase, and projectile behaviors
  • Collectibles and scoring system
  • Health system with hearts and invincibility frames
  • HUD rendering with bitmap font, icons, and counters

Architecture

  • Scene manager handling Title → Gameplay → Pause → Game Over transitions
  • Entity marker layer loaded from Tiled
  • Full level loading from PC
  • Zero dynamic allocation on hardware
  • Flash-based asset loading

Every byte of this is written in C and assembly. It's bare metal RISC-V, no OS, no abstractions hiding what the hardware is doing. Yuo of course write your games in C and once the compiler is setup C++ shouldn't be an issue either. 

 

The PC Simulator

One of the tools I'm most proud of is the PC simulator. I can design, test, and iterate on games entirely on my development machine before porting anything to the console hardware. This dramatically speeds up the development cycle. When you're working with 64KB of RAM and flash-based assets, you don't want to be flashing firmware every time you tweak a sprite animation, it also saves flash endurance of the console, adding a cartridge for ROMs is also an option I may look at. 

 

The Level Design Pipeline

The level design workflow uses Tiled on PC for map creation. Custom converters translate .tmj files into formats the engine can consume directly. Entity markers, tile layers, collision data it all flows from the editor to the console through a pipeline I built specifically for RV-Boy's constraints.

 

What's Next

Right now, RV-Boy and RV-Tile target the CH32V307 with its 64KB of RAM. Once I get the CH32H417 in hand, WCH's newer dual-core RISC-V running at 400MHz + 144MHz with 896KB of SRAM and an LTDC display controller, the possibilities open up dramatically. More complex levels, richer audio, expanded enemy behaviors, and potentially even software 3D rendering.

The bigger vision is a console that's not just a tech demo but a real platform, original games built specifically for open RISC-V hardware. No emulation, no ROMs, no legal grey areas. Just new games on new hardware, inspired by the classics.

I'm also working on a GUI tool that bridges Tiled's .tmj output directly to the RV-Tile engine format, streamlining the level design pipeline for anyone who wants to build games on this platform.

I'll be putting RV-Tile up on GitHub once the tooling is ready for public consumption, aka I have some cleaning up to do, I also want to do some proper docs so people can follow along as well. The engine is still evolving, but the foundation is solid, a real game engine running on bare metal RISC-V, built from the ground up in C and assembly, with a complete development pipeline from PC to console.

RV-Boy Modern retro, the way it should be. #tagline lol

 

RV-Boy is built by Armstrong Subero for RISC-V Microcontrollers specifically the CH32V series of ships. Follow the project at rvembedded.com for updates on RISC-V embedded systems.