I love using Rust for game development.

Ryan Kopf, Owner of the Moon — Sat, 28 Mar 2026 05:06:48 +0000

Why Rust is the Ultimate Tool for Game Architecture: From AoS to SoA

In the world of game development, performance is king, but technical debt is the executioner. When building rpgfx.com, I realized that the choice of language isn't just about how fast the code runs; it’s about how safely you can change your mind. Rust is the only language that allows for radical architectural shifts without the "fear of the unknown" that usually accompanies large-scale refactors.

My name is Ryan Kopf and I have been developing for a long time.

1. The Great Refactor: Moving from AoS to SoA

One of the most significant changes a game developer can make for performance is moving from Array of Structures (AoS) to a Structure of Arrays (SoA).

AoS (Traditional): You have a struct Player { position: Vec3, health: i32, velocity: Vec3 } and an array of those players. This is intuitive but bad for CPU cache locality when you only need to update positions.
SoA (Data-Oriented): You have one struct that holds several arrays: struct Players { positions: Vec<Vec3>, healths: Vec<i32>, velocities: Vec<Vec3> }. This is much faster for the CPU but usually a nightmare to refactor in C++ or C#.

The "One Field at a Time" Strategy

In other languages, a refactor like this usually involves breaking the entire project, resulting in thousands of errors that you have to fix blindly before you can even try to compile.

With Rust Analyzer and VS Code, I was able to move one single field at a time. I could pull position out of the player struct and move it into a global component system. Immediately, Rust Analyzer would light up every single invalid reference in the entire project with surgical precision.

I didn't have to guess where the player's position was being accessed.
I didn't have to worry about a "null" reference or a dangling pointer.
I simply followed the red squiggles until the code was "normalized" again.

2. Code Normalization: The Developer's Safety Net

We often talk about database normalization—organizing data to reduce redundancy and improve integrity. Rust allows for code normalization. By using the type system to make errors unrepresentable, you ensure that your game state can never be in an "impossible" configuration.

For a game engine, this is revolutionary. Think about a character state:

The Old Way: A bunch of booleans like is_jumping, is_swimming, and is_dead. You could accidentally have a character that is both jumping and swimming at the same time.
The Rust Way: An Enum called CharacterState. A character is either Jumping or Swimming. The compiler ensures you never have to write a "sanity check" for these states ever again.

3. Fearless Iteration with Rust Analyzer

When you're deep in the logic of rpgfx.com, you're constantly asking: "What will this break?"

In most environments, you find out what it breaks when the game crashes during a playtest. In Rust, you know what will break before you even save the file. Rust Analyzer provides:

Semantic Awareness: It understands the ownership and lifetime of every variable. If you try to move a resource that is still being used by a rendering system, it warns you instantly.
Exhaustive Matching: If I add a new damage type (e.g., "Chaos Damage") to the engine, the compiler forces me to update every single system that handles damage. I can't "forget" a spot.
Inlay Hints: Seeing the types and parameter names directly in the editor means I’m never guessing what a function expects.

4. Stability for the Long Haul (webraven.com)

While rpgfx.com focuses on the "engine" side of things, the same logic applies to webraven.com. A website builder service needs to be a "fortress." The strong typing in Rust means that once the code compiles, the logic is sound.

The "normalization" of the code translates to a service that doesn't experience random memory leaks or segfaults under load. It’s the difference between building on sand and building on bedrock.

5. Technical Facts and References for Copy-Paste

Zero-Cost Abstractions: Rust’s iterators and closures compile down to the same assembly as a manual for loop.
Memory Safety: No NULL, no use-after-free, and no data races—guaranteed at compile time.
Cargo: A build system that actually works. Dependency management for complex game crates is handled effortlessly.
Deterministic Rollback: Because Rust encourages immutable data and clear ownership, implementing rollback networking for RPGs is significantly more manageable than in languages with ambient mutability.

Summary

I love Rust because it respects my time. It forces me to solve the hard problems upfront so that I’m not chasing ghosts in the debugger at 2:00 AM. It turns refactoring from a chore into a superpower.

Suggested Reading for Game Devs:

Data-Oriented Design by Richard Fabian
Game Programming Patterns by Robert Nystrom (Applied to Rust)
The Bevy Engine Book (For ECS concepts in Rust)

How to use Rust on Arduino (Windows Rust)

Ryan Kopf, Owner of the Moon — Mon, 27 Mar 2023 05:13:07 +0000

1 - Install Rust nightly compiler:

rustup toolchain install nightly

2 - Install Scoop via PowerShell:

Set-ExecutionPolicy RemoteSigned -Scope CurrentUser irm get.scoop.sh | iex

3 - Install avr-gcc and avrdude using Scoop:

scoop install avr-gcc scoop install avrdude

4 - Install ravedude for flashing the microcontroller:

cargo +stable install ravedude

5 - Create a new project using cargo-generate:

cargo install cargo-generate cargo generate --git https://github.com/Rahix/avr-hal-template.git

6 - Navigate into the project directory and open the folder in your preferred code editor.

7 - Edit the main.rs file to include your desired program.

main.rs

#![no_std]
#![no_main]

use panic_halt as _;
use arduino_uno::prelude::*;

#[arduino_uno::entry]
fn main() -> ! {
    let dp = arduino_uno::Peripherals::take().unwrap();
    let mut pins = arduino_uno::Pins::new(dp.PORTB, dp.PORTC, dp.PORTD);
    let mut led = pins.d13.into_output(&mut pins.ddr);
    loop {
        led.toggle().void_unwrap();
        arduino_uno::delay_ms(1000);
        //Or Your Other Code Here
    }
}

Cargo.toml
[dependencies] arduino_uno = "0.2"

8 - Build the project:

cargo build

9 - Connect your Arduino board to your computer via USB.

10 - Set the serial com port for ravedude (replace COMx with the actual port number):

$env:RAVEDUDE_PORT="COMx"

11 - Build and flash the program into the Arduino:

cargo run

12 - After these steps, the Arduino should execute the program as intended.

DEV Community: Ryan Kopf, Owner of the Moon