/rust-gb

Compile Rust code to GBZ80 (Gameboy Z80)

Primary LanguageRustOtherNOASSERTION

Rust-GB

Compile Rust code to GBZ80 (Work in Progress)
You can find ROM builds of examples in release

image ^ filltest example of GBDK-2020, ported to Rust.

How is this possible?

  1. The Rust compiler can generate LLVM-IR for the ATMega328 processor. (which powers Arduino)
  2. LLVM-IR can be converted to C code using llvm-cbe.
  3. The C code can then be compiled to Z80 Assembly using sdcc.
  4. Z80 Assembly can be assembled into GBZ80 object code with sdasgb.
  5. The GBZ80 object code can be linked with GBDK libraries and built into a Game Boy ROM using lcc.

I referred to z80-babel for steps 1–3, and used gbdk-2020 for steps 4–5.

Why use Rust instead of C or ASM?

  1. Rust provides higher-level and better grammer than C.
  2. Rust's memory stability and strict types help you avoid to write incorrect code (even on a small device).
  3. Putting everything aside, it's fun!

Goal

This project's goal is to develop a Game Boy Development Kit that enables the creation of Game Boy games using Rust, including safe management APIs in Game Boy memory, abstracted functions, and more.

Currently, the dependence on GBDK is large, but we plan to gradually reduce it.

Support

If you like this project, you can always join our Discussion! Please feel free to share your opinions or ideas.

This project is in its very early stages, and we are still designing many things, so it would be nice to have a variety of ideas.

PRs are always welcome too!

Dependencies

  • rust
  • avr-gcc
  • avr-libc
  • llvm
  • llvm-cbe
  • sdcc

This project is still a work in progress, and I haven't tested it outside of my development environment.

Dependencies may change as the project evolves.

Build

I do not recommend that you build this project now. because this is WIP and I'm still testing many things.

But if you want to do it, Here is the description below.

  1. Install all dependencies in your linux (Use WSL for Windows)
  2. Build llvm-cbe in ./ext directory. follow llvm-cbe's instruction to build it.
    the path is ./ext/llvm-project/llvm/build/bin/llvm-cbe
  3. Execute cargo build --release in ./ext/rust-deps
  4. Now, cargo build-rom (where the ./src directory is located) will build your GB ROM to ./out/main.gb
# build GB ROM from Rust code
cargo build-rom

# build GB ROM from LLVM-IR
cargo llvm-rom
# ... from C code
cargo c-rom
# ... from ASM code
cargo asm-romm

Build chain Description

Rust bundling

Rust codes in ./source bundled in one .rs file by rust-bundler-cp

Rust -> LLVM-IR

Bundled Rust code is compiled to target avr-unknown-gnu-atmega328.
This will provide 8-bit compatibility for z80.

LLVM-IR -> C

LLVM-CBE compile LLVM-IR to C code.

I'm considering If it can be replaced with llvm-gbz80

C post-processing

The generated C code is for GCC. Therefore, it goes through post-processing before it is entered into SDCC.

Use the tree-sitter and sed to parse the C code, and replace or add the required codes.

C -> ASM

SDCC compile C code for GBZ80 (sm83)

ASM -> ROM

I used GBDK's build chain for this. GBDK's lcc link ASM with GBDK libraries and build a complete Gameboy ROM file.