NanoCore

Inspiration

We wanted to turn a simple accelerometer into an interactive flight controller and challenge ourselves to build a real 3D game using FPGA hardware instead of a traditional GPU. AERO started as a motion-controlled arcade game and evolved into a project combining embedded systems, computer graphics, and hardware acceleration.

What it does

AERO — Escape Run is a motion-controlled flight game where players steer an aircraft by physically tilting an Arduino-connected accelerometer.

We started with a 2D obstacle-dodging game and expanded it into an endless 3D aerial combat game set in a stylized Hanoi-inspired environment. Players can dodge enemy aircraft and projectiles, shoot back, and survive as long as possible.

The game runs on a DE10-Standard FPGA development board, which renders the 3D graphics and streams the resulting frames to a web browser. Players can use the accelerometer, keyboard, or touchscreen to control the aircraft.

How we built it

We divided the project into several components:

Motion controls: An Arduino UNO R4 WiFi with a Grove MMA7660 accelerometer provides motion data. We implemented calibration, filtering, and smoothing to translate physical tilt into responsive flight controls.
Game engine: We developed the 3D game in C#, including a fixed 60 Hz simulation, aircraft movement, enemy AI, projectile collisions, and a custom low-poly environment inspired by Hanoi.
FPGA rendering: We adapted the open-source SpinalVoodoo graphics core to the DE10-Standard's Cyclone V FPGA. The ARM processor handles game logic and geometry preparation, while the FPGA performs triangle rasterization, depth testing, and texture processing.
Web interface: A Python server streams 320×240 RGB565 frames over WebSockets to a JavaScript/HTML5 Canvas interface, allowing players to interact with the actual FPGA-rendered game.

Challenges we ran into

One major challenge was integrating multiple hardware and software components into a working real-time system.

The DE10-Standard's Linux kernel lacked the USB serial driver needed for our Arduino, so we implemented direct USB communication using libusb. Noisy and relatively slow accelerometer readings also required careful calibration and filtering.

On the graphics side, adapting an existing FPGA GPU architecture involved resolving memory compatibility, synchronization, and framebuffer ownership issues. We also had to optimize geometry processing and rendering without changing the game's visual output.

Performance remains our biggest challenge. Our latest sustained test achieved 16.27 displayed FPS, while the simulation maintained approximately 60 Hz. We are still working toward our 30 FPS rendering target.

Accomplishments that we're proud of

We successfully integrated physical motion controls, a complete 3D flight game, and actual FPGA-based rendering into one playable system.

We also implemented a reproducible testing workflow using deterministic game replays, hardware frame captures, and pixel-level comparisons to verify rendering correctness during optimization.

What we learned

We learned that real-time graphics performance depends on the entire system, not just the graphics processor. USB communication, CPU geometry processing, memory synchronization, rendering, and network transmission all contribute to the final experience.

This project gave us hands-on experience integrating hardware and software across multiple programming languages and platforms, debugging low-level interfaces, and optimizing performance using measured evidence.

What's next

Our next goal is to optimize FPGA triangle processing and framebuffer operations to reach 30 FPS while preserving rendering correctness. We also want to improve motion controls and expand the gameplay with new environments and challenges.