Building a Ferris-inspired Jumper for the Crab Robot Open-source Challenge, from an uncooperative shell design to a custom learned celebration.
A successful Rust build usually rewards me with a line of terminal output. I wanted something more expressive: a crab that celebrates when my code compiles, grabs at a moved value, and jumps at the sight of unsafe.
That became my entry for the Crab Robot Open-source Challenge, which invites people to explore Jumper through appearance, motion, and intelligence. My project brings those three directions together around a familiar character: Ferris, the Rust crab.
The idea was straightforward. Getting a recognizable shell and a readable dance took several rounds of work. Let’s take a look at the finished version, then I will dive into the details.
First, make it look like Ferris
I started with Copilot and asked it to design a Ferris-inspired skin. In my attempts, it struggled to change the shell itself. Even after I supplied examples of other people’s shell modifications, the results followed those examples too closely and still did not look like Ferris to me.
Those examples were supposed to explain how shell modification worked. I wanted the resulting character to have its own recognizable silhouette.
I switched to Codex and continued working on the skin. The selected result has a broad, serrated orange-red carapace, large black oval eyes with white highlights, and Jumper’s moving grippers. The shell shape mattered as much as the color: painting the original body orange would not have delivered the character I was trying to build.
There was an integration wrinkle. Jumper’s Train repository does not have a general .skin . Appearance creation lives in the separate jumper-design repository. For this demo, an explicit integration applies the skin’s visual meshes and colors to the simulation robot while preserving the mechanics, joint limits, inertia, collisions, and controller observations.
That separation mattered later: the new shell could hide a claw even when the controller was moving the original mechanical model correctly.
Giving compiler output a personality
I built the interaction around real Cargo commands. A Python bridge launches Cargo, reads its structured JSON diagnostics, and publishes a small event to a JSONL inbox. A separate simulation process consumes those events and queues the reactions.
Rust source → Cargo → diagnostics and exit status ↓classified event ↓queued Ferris robot reaction
Running compilation in a separate process keeps the simulation moving while the compiler works. The terminal still shows the actual diagnostic; the robot adds an expressive response alongside it.
The classifier has a few deliberate rules. Borrowing and ownership errors get their own category, based on selected rustc diagnostic codes. Other compiler errors take priority over warnings and celebration. A failed cargo run produces an error response. The unsafe example is an explicitly declared source cue: using valid unsafe syntax is not a compilation failure.
The current reactions are:
The assisted presets use authored joint targets and simulation base support. The learned happy dance uses no external base-support wrench. Keeping those distinctions visible helped me describe what I had actually built.
All the Rust examples that trigger the demo
A clean build: celebrate
fn main() { println!("Ferris says: compiled successfully!");}
A build without errors or warnings starts the learned happy dance.
A type error: look shocked
fn main() { let claws: u32 = "two"; println!("{claws}");}
Assigning a string to a u32 produces a type mismatch, E0308. Ferris responds with the startled preset.
An unused variable: wave for attention
fn main() { let unused_claw = 2; println!("One claw would like your attention.");}
The unused unused_claw produces a warning under the example’s default settings. Compilation succeeds, and Ferris waves one claw.
A moved value: hold on to it
fn main() { let treasure = String::from("my precious shell"); let borrowed_by_ferris = treasure; println!("Ferris kept {borrowed_by_ferris}"); println!("Can I have {treasure} back?");}
Assigning treasure to borrowed_by_ferris moves the String. The later attempt to print treasure triggers E0382. Despite the variable name, this is a move rather than a borrow; it belongs to the demo’s ownership/borrowing reaction category.
Ferris closes its left claw while a learned policy supplies balance.
Valid unsafe code: jump
fn main() { let shell = 42; let pointer = &shell as *const i32; // This dereference is valid: shell is still alive and pointer is aligned. unsafe { println!("Spooky syntax, valid pointer: {}", *pointer); }}
This example compiles successfully. The pointer refers to a live, aligned value; the jump is a joke about the syntax.
Run the program: start walking
.venv/bin/python demo/rust-compiler-crab/compiler.py --example success --command run
The bridge publishes the run event after the program exits successfully. Ferris then walks with the tripod policy.
Clean the project: acknowledge cleanup
.venv/bin/python demo/rust-compiler-crab/compiler.py --example success --command clean
Cleaning is a command event and does not compile a new Rust program. Ferris acknowledges it with the outward wave.
What this project taught me
The hardest part was getting appearance and motion to work together. The larger Ferris shell changed which gestures were visible. A successful training run could reproduce choreography that still looked wrong for the character.
My useful loop became: inspect the character, author a motion that suits its shape, preview the reference, train it under physics, and evaluate the learned result through the actual compiler interaction.
Switching assistants helped me get past the shell-design problem. The next breakthrough came from making the motion requirement concrete: the claws needed to alternate visibly outside the shell, with a supported body and a smooth finish.
Now a successful build gives me the response I wanted: Ferris waves its claws beyond its orange shell and celebrates with me.
What If the Rust Compiler Were a Robot Crab? Meet Jumper 🦀 was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.