# SEEDS, a game where you can run Linux thanks to RISC-V

> Linux runs inside the game SEEDS with PasRISCV, an open RISC-V emulator. How it works, what hardware it virtualizes and why it matters to players.
> By José Maldonado · Technology · 2026-10-10

There is a computer inside a video game that runs real Linux. It happened in early October 2026, when the team behind the space game SEEDS presented PasRISCV, a RISC-V emulator written in Object Pascal that boots a complete system inside the game, as detailed in [LavX's analysis of October 4](https://news.lavx.hu/article/inside-pasriscv-the-risc-v-emulator-powering-seeds-in-game-linux). The Hacker News announcement on October 3 gathered about 84 points and a lively discussion about emulation and games.

RISC-V is an open, royalty-free processor architecture that anyone can implement, something like a free blueprint for building computer brains. Linux is the operating system that manages that brain, and an emulator is a program that pretends to be a chip so the system believes it is running on real hardware. Putting the three pieces together inside a game means your spaceship's computer is not decoration, it runs real programs.

What stands out is not just the technical trick, but what they use it for. The emulated computer communicates with the game through virtual sockets, lets you program the planet with Python or Rust and allows installing Alpine packages from inside. A week after the announcement, it is worth explaining how it is built, what hardware it virtualizes and why this experiment interests players and programmers alike.

## The SEEDS team's presentation

The SEEDS team, a space game in development, needed believable computers inside its ships and bases. Instead of simulating a fake terminal with limited scripts, they decided to emulate a complete machine with PasRISCV and boot Linux on top, as they explained on the [project blog](https://againstallodds.games). The Hacker News presentation on October 3, under the title of a space game with an integrated RISC-V emulator that runs Linux, summed up the idea well.

![SEEDS official website](https://content.observatorioblockchain.com/wp-content/uploads/2026/10/seeds-game-scaled.webp)
*SEEDS official website*

PasRISCV is open software written in Object Pascal, a language with a reputation for clarity and for being unfashionable that here proves it is still useful. It includes an interpreter and a tracing JIT compiler, a technique that translates guest code into native code on the fly to go faster. The authors say the JIT executes about 99 percent of instructions on 64-bit x86 hosts, leaving the rare and delicate cases to the interpreter.

The choice of RISC-V has practical logic beyond its open appeal. Being a free standard documented by [RISC-V International](https://riscv.org), there are no licenses to negotiate or secrets to work around in order to emulate it. For a small studio, that freedom reduces legal risks and allows publishing the emulator without commercial ties.

## How does Linux boot inside the game?

The boot follows the usual chain of these virtual boards. First OpenSBI comes in, acting as an intermediary between the hardware and the system, then U-Boot, which locates the kernel, and finally the Linux kernel from a disk image. The disk appears as a VirtIO Block device or as emulated NVMe over PCI, two standard ways of presenting storage to a virtualized system.

The guest system is 64-bit RISC-V Alpine Linux, a lightweight distribution famous for its small size and its apk package manager. Players can open btop to monitor CPU and memory or fastfetch to show the configuration, just like on a real laptop. That familiarity is part of the charm, because everything you know about the terminal works inside the game.

The disk setup separates a read-only root partition, which the game updates without breaking saves, from a user partition where each player stores their data and programs. In addition, host folders are shared with VirtIO-9P or VirtIO-FS, so you can compile tools outside and use them inside. It is a convenient bridge between developing on your machine and playing on the emulated one.

## Hardware pretends to have the virtual machine

A believable system needs quite a bit more than CPU and disk to convince. PasRISCV emulates screen and sound as well as network and debugging, so the guest machine behaves like a complete computer.

For video it offers a simple framebuffer with its own buffer, plus VirtIO GPU with 2D functions and experiments with 3D via VirGL. The authors tried an X server with Motif, although they admit it is slow for daily use and prefer the framebuffer with retro scanline effects.

Subsystem

What PasRISCV emulates

What it is used for in the game

CPU

RV64GC and RVA23 with SMP and hypervisor

Runs Linux and user programs

Video

SimpleFB and VirtIO GPU

80 by 50 terminal and retro effects

Sound

CMI8738, FM801, Intel HDA

OPL3 music and PCM effects

Network and communication

Own NAT and vsock with the game

Install packages and request planet data

**[Steam Deck and PC, a guide to playing on Linux with Heroic and Proton](https://observatorioblockchain.com/en/technology/steam-deck-pc-heroic-lutris-protondb/)**

On sound, the list looks like a well-chosen museum, with retro CMI8738 and FM801 cards offering OPL2 and OPL3 synthesis alongside PCM for samples. There is even support for Intel HDA and VirtIO sound on modern guests. The game Space Prowler, which runs on the base's computer, mixes an OPL3 theme with PCM drums composed in their own editor called chOPLin.

The network works with their own user-space NAT implementation, with IPv4 and IPv6, which allows updating Alpine from inside during development. In the playable version, however, the external network is disabled for security and reproducibility. That decision prevents a game from depending on the internet or leaking data without control.

## Why does programming the planet change the rules?

The piece that turns the trick into a game is the communication between the emulated Linux and the SEEDS engine. They use Linux virtual sockets alongside their own binary format, quick to serialize, with a priority queue for urgent messages and responses. Thus, the ship's computer can ask the game for the relief of a planet or the position of animals and receive fresh data.

Since it is a normal Linux, you can program with common languages such as Python or Rust and also with C or Go. That compatibility turns every in-game task into practice that is useful outside the game.

The authors talk about programming, reshaping and populating entire planets with scripts, with the same satisfaction that building by hand gives. For a curious player, learning to automate a harvest inside the game can be the first programming lesson without leaving the game.

The approach recalls old games that included scripting languages, but with a fundamental difference. Here you do not learn an invented dialect for a single title, you practice with real tools that are useful outside the game. That transfer of knowledge is what excites many commenters since October 3.

**[Kdenlive, Audacity and GIMP, a free audiovisual studio on Linux](https://observatorioblockchain.com/en/technology/kdenlive-audacity-gimp-estudio-audiovisual-libre/)**

## What can you try if you are interested in emulation?

If you like tinkering, this project leaves several doors open even though they do not yet publish final binaries. You can read the PasRISCV code to see how a tracing JIT is implemented in an unusual language. You can compare its approach with QEMU to understand what a game-oriented emulator cuts compared with a general-purpose one.

*   Download Alpine RISC-V and try its packages in QEMU to familiarize yourself with the guest
*   Read the RISC-V documentation on RV64GC to understand which instructions the JIT emulates
*   Mount a VirtIO disk in a virtual machine and practice with read-only partitions
*   Write a small Python script that reads sensors and draws a graph on the framebuffer

Each exercise brings you closer to the SEEDS approach without having to wait for launch. The beauty of the project is that it uses standard pieces, so what you learn with QEMU or with Alpine will serve you when the game opens its terminal. The authors insist on documenting the emulated hardware precisely, precisely so that others can replicate experiments.

For players without a technical bent, the recommendation is to follow the development diary at againstallodds.games and try Space Prowler when they publish demos. Watching how the OPL3 music sounds inside the game helps understand why emulating old sound matters as much as emulating a modern CPU.

## What limits the team itself acknowledges

The authors do not sell smoke and describe frankly what is slow. The X server with Motif works but at a speed that is impractical for everyday use, so the game uses a simple framebuffer with its own shaders for scanlines and phosphor glow. It is an aesthetic and performance choice, because emulating a modern GPU at good speed remains very costly.

The JIT helps a lot on CPU, but floating-point operations can run on the host's FPU or in strict software mode with the interpreter. That strict option gives more fidelity in exchange for speed, useful for debugging without going crazy. They also include their own disassembler, debugger and GDB server mode to analyze guest programs with standard tools.

Two thirds of the creative team use Linux as their main system and consider Linux a first-class platform for playing SEEDS. That fact explains the care with which they treat the 640 by 400 terminal and the console music tracker. When you develop where you play, details show and mistakes stand out less.

## A ship that teaches computing without giving lessons

SEEDS proposes something unusual in 2026. Instead of hiding computing behind shiny menus, it puts a functional Linux at the center of the ship and invites you to tinker. If you just want to explore, you ignore the terminal and play the space story. If curiosity bites, you open the terminal and discover a real world inside the fictional world.

It remains to be seen how the final performance and the stability of the JIT hold up in long games, as well as how they will moderate players' programs. But the direction looks good, because it combines open emulation with a real system and with game design meant for tinkering.
