Why does the One Dollar Computer use Rust instead of C or Arduino-style C++?

Because the first language a student flashes to hardware becomes muscle memory. Rust teaches systems thinking with memory safety by construction, on a ~$1 RISC-V computer, from a browser over WebHID — without asking beginners to fight undefined behavior before they blink an LED.

Is One Dollar Computer firmware the same as no_std embedded Rust?

Beginners write Simple Rust: use odc::*; and fn main(). The editor wraps bare-metal details so the first hour is invention, not linker scripts. The language is real Rust on RISC-V; the ladder to full embedded Rust remains open.

How can the Rust community help?

Teach with it, improve examples and docs, share the project, help classrooms pre-order, and keep the board path as Rust — not a second beginner dialect. Official site: https://onedollarcomputer.com/rust/

Rust · RISC-V · Physical AI

Why Rust — and why the Rust community is the difference

The One Dollar Computer is programmed in Rust on purpose. Not as a trend. As a bet on who gets to invent the physical world next — and in what language.

If you write Rust, you already know the strange thing about this language: it does not spread only because it is clever. It spreads because people who care about correctness show up for each other — crates, docs, Embedded WG, Matrix rooms, conference workshops, late-night PRs. That community is everywhere. For a project that lives or dies on whether the next generation can flash real firmware for a dollar, that is not a nice-to-have. It is infrastructure.

Whoever owns the first computer a student trusts owns the muscle memory of invention.

The first language is the lasting one

Most people who “learned electronics” learned a dialect that ended at the kit. Proprietary pin maps. Toolchains that punish beginners. Undefined behavior treated as a rite of passage. By the time someone is ready for serious systems work, the habits are already set — and switching costs feel like starting over.

We refused that funnel. The One Dollar Computer is a ~$1 open RISC-V educational computer (model 1.004, revision R2, ISA RV32EC). Firmware is Simple Rust: real Rust, compiled for the board, flashed from a Chromium browser over WebHID — no driver install. The first hour is not “install a toolchain.” It is light on, light off, something physical answering your code.

That is the whole strategy: make the honest language also the easy first language.

Why not C “because embedded always was”

C still runs the world. It also taught generations that memory errors are weather — something you endure. Industry and government analyses have repeated the same pattern for years: on the order of ~70% of high-severity security vulnerabilities in major codebases have been memory-safety issues (widely cited from Microsoft and Google/Chromium reporting; echoed in CISA and White House ONCD guidance urging memory-safe languages for new systems). Embedded is not exempt. Studies of real-time and embedded stacks keep finding memory-corruption bugs as a dominant class of serious defects.

Rust’s answer is not a sermon. It is a compiler that refuses whole categories of bugs before the binary exists — without a garbage collector, and with no_std paths that fit bare metal. For education, that matters twice: students learn systems thinking, and they do not learn to romanticize undefined behavior as toughness.

We are not asking classrooms to wait until they are “ready for Rust.” We are putting Rust on a computer cheap enough to leave inside the project.

The missing rung in embedded Rust

The embedded Rust ecosystem is real and growing — Discovery books, Espressif trainings, embedded-hal, Embassy, probe-rs, awesome-embedded-rust, RISC-V targets. The hard part is rarely “is Rust good for MCUs?” The hard part is the first mile: buy a board, pick a HAL, install targets, wire a probe, survive the linker, then blink.

That first mile filters for people who already know they want embedded Rust. It does not recruit the student who only has curiosity and a dollar.

ODC is that missing rung. Same language family. Same architecture ladder (RV32EC today → fuller RISC-V profiles tomorrow). Browser editor. Physical button only to enter the bootloader for Upload. Curriculum under Learn Physical AI so teachers can run the loop at classroom scale. The point is not to replace the Embedded WG’s depth. The point is to feed it a generation that already thinks in Rust when the LED turns on.

use odc::*;

fn main() {
    loop {
        led_on();
        delay(500);
        led_off();
        delay(500);
    }
}

Beginners write that shape. The editor wraps bare-metal entry so the first lesson is invention, not #![no_std] ceremony. Teaching HTML can be any metaphor; the board path is always Rust — never a second beginner dialect pretending to be firmware.

Physical AI needs a body — and a safe language inside it

Physical AI is the shift from software that only writes text to systems that sense, decide, and act in the physical world. Robots, instruments, toys, classroom inventions. That future will be written in something. If it is written in the same memory-unsafe habits we already struggle to secure at planetary scale, we will scale the problem with the ambition.

A dollar computer that speaks Rust is how you put a safe systems language into a million small bodies — without waiting for a research budget. That is why this is not a side project for us. It is the education layer under Physical AI.

If the next inventors never meet Rust, embedded Rust stays a brilliant niche. If they meet it at one dollar, Rust becomes the default language of making.

Why Rust people would help — the honest case

Not charity. Alignment.

You expand the funnel. Every workshop that still starts in C++ for “simplicity” trains the ecosystem you are trying to grow out of. ODC lets “simple” and “Rust” be the same sentence.
You defend the brand of the language where it matters most. Kids and teachers do not read RFCs. They remember what worked when the light blinked. Make that memory Rust.
You connect RISC-V and Rust at the bottom of the ladder. Application profiles and datacenter cores are winning headlines. Educational RV32EC is how a student enters the same open ISA without a lab fee.
You keep firmware honest. The project’s rule is strict: pedagogy can invent HTML experiences; the computer runs Simple Rust. Community pressure that keeps that true is survival — a beginner DSL would be easier marketing and a slower death.
You are already distributed. Rustaceans are in universities, companies, Discord and Matrix channels, local meetups, governments adopting memory-safe roadmaps. ODC needs that graph more than it needs a louder homepage.

What we need from you

Concrete help beats applause.

Teach with it. One club night. One guest lecture. One Physical AI lesson that ends in Upload.
Sharpen the path. Examples, docs, error messages, beginner traps — the difference between “almost” and “I did it.”
Keep the board path Rust. Resist the temptation of a fake-simple language. HTML for teaching; Rust for the silicon.
Put hardware in rooms that lack it. Pre-order for a classroom. Three thousand dollars is three thousand starting points.
Say the quiet part in public. Share why a $1 RISC-V computer speaking Rust is an ecosystem move, not a gadget review.

Pre-Order $1 Open the editor GitHub

Facts, short

Product: One Dollar Computer · model 1.004 · revision R2
Architecture: RISC-V RV32EC · up to 48 MHz · 16 KB flash · 2 KB RAM · pins 0–19
Language: Simple Rust (use odc::*;) · flash via WebHID in Chromium
Education: Learn Physical AI · rules for agents: AGENT_LESSONS.md
Spec: onedollarcomputer.com/specification/