Repository Summary
| Description | Copper is an operating system for robots - build, run, and replay your entire robot deterministically. |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-02-23 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| gpio_caterpillar | 0.0.0 |
README
Copper Runtime & SDK
🤖     Copper is to robots what a game engine is to games - build, run, and replay your entire robot deterministically.
Why Copper
🦀 Rust-first – ergonomic & safe
⚡ Sub-microsecond latency – zero-alloc, data-oriented runtime
⏱️ Deterministic replay – every run, bit-for-bit identical
🧠 Interoperable with ROS2 – bridges via Zenoh opening the path for a progressive migration.
🪶 Runs anywhere – from Linux servers, workstations, SBC to bare-metal MPUs
📦 Built to ship – one stack from simulation to production
### Example Applications
| Flying | Driving | Swimming | Spacefaring |
|:--:|:--:|:--:|:--:|
| |
|
|
|
### You don't have a real robot yet? Try it in our toy example right now in a sim environment!
[](https://youtu.be/kC6sGRZUxLE)
Here is a Copper-based robot in action in a Bevy simulation environment!
The realistic sim is created using [Bevy](https://crates.io/crates/bevy) (A Rust Game Engine)
and [Avian3d](https://crates.io/crates/avian3d) (Physics Engine in Rust).
On your mac or linux machine (x86-64 or Arm) just run ...
```bash
$ cargo install cu-rp-balancebot
$ balancebot-sim
```
... to try it locally.
The source code for this demo is available in the [examples/cu_rp_balancebot](examples/cu_rp_balancebot) directory.
## Get Started
- Start a new project from templates: [Project Templates](https://copper-project.github.io/copper-rs/Project-Templates)
- See a full task graph + runtime walkthrough: [Copper Application Overview](https://copper-project.github.io/copper-rs/Copper-Application-Overview)
- Build and deploy an application: [Build and Deploy a Copper Application](https://copper-project.github.io/copper-rs/Build-and-Deploy-a-Copper-Application)
- RON configuration reference: [Copper RON Configuration Reference](https://copper-project.github.io/copper-rs/Copper-RON-Configuration-Reference)
## Log Visualization (Rerun)
Copper logs can be visualized with Rerun using an app-specific logviz binary generated by `gen_cumsgs!`.
Enable the `logviz` feature and run:
```bash
# Spawn a viewer and stream the log
cargo run --bin
CONTRIBUTING
Contributing to Copper-rs
First off, thank you for considering contributing to Copper-rs! We welcome contributions from everyone. This document provides guidelines for contributing to the project.
Getting Started
Prerequisites
- Rust: Ensure you have a recent stable Rust toolchain installed. You can install it using rustup.
curl --proto '=https' --tlsv1.2 -sSf [https://sh.rustup.rs](https://sh.rustup.rs) | sh
- just: We use just as a command runner for common development tasks. Install it via cargo or your package manager:
cargo install just
- cargo-nextest: For running tests efficiently.
cargo install cargo-nextest
- typos: For spell checking.
cargo install typos-cli
- Platform-Specific Dependencies: Depending on your operating system and the features you intend to work with, you might need additional dependencies. For Ubuntu 22.04, please checkout our Dockerfile.
Using justfile (Recommended)
The project includes a justfile that mirrors the CI workflow. This is the recommended way to run checks locally before submitting a PR:
# Run the default PR pipeline (format + lint + tests for std/no_std)
just pr-check
# Same as above (default target)
just
# Run lint checks (fmt-check + typos + clippy for std and no_std)
just lint
# Run unit tests (std + no_std)
just test
# Run CI-aligned std checks (build/tests/templates)
just std-ci
# Run CI-aligned embedded/no_std checks
just nostd-ci
# Run in release mode
just std-ci release
# Run with CUDA features
just std-ci cuda-release
The just pr-check command runs:
- Formatting (
just fmt) - Lint checks (
just lint: format check + typos + std/no_std clippy) - Unit tests (
just test: std + no_std)
The just std-ci command remains CI-aligned for std paths, including:
- Format check (
just fmt-check) - Typos check (
typos -c .config/_typos.toml) - Clippy with
--deny warnings - Build with all features
- Unit tests with cargo-nextest
- Project generation tests (debug mode only)
Prek hooks (Recommended)
To mirror the CI lint steps locally, you can install prek hooks that run formatting and typos checks on each commit.
- Install
prek
cargo binstall install prek
# or
cargo install install prek
- Reinstall the git hooks if you previously executed
pre-commit install
prek install -f
- Run once to verify:
prek run --all-files
If you want to customize prek, please modify .pre-commit-config.yaml.
Proc-macro expansion (cargo expand)
Prefer cargo expand when inspecting generated code from Copper proc-macros.
Install it once with:
cargo install cargo-expand
File truncated at 100 lines see the full file
Repository Summary
| Description | Copper is an operating system for robots - build, run, and replay your entire robot deterministically. |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-02-23 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| gpio_caterpillar | 0.0.0 |
README
Copper Runtime & SDK
🤖     Copper is to robots what a game engine is to games - build, run, and replay your entire robot deterministically.
Why Copper
🦀 Rust-first – ergonomic & safe
⚡ Sub-microsecond latency – zero-alloc, data-oriented runtime
⏱️ Deterministic replay – every run, bit-for-bit identical
🧠 Interoperable with ROS2 – bridges via Zenoh opening the path for a progressive migration.
🪶 Runs anywhere – from Linux servers, workstations, SBC to bare-metal MPUs
📦 Built to ship – one stack from simulation to production
### Example Applications
| Flying | Driving | Swimming | Spacefaring |
|:--:|:--:|:--:|:--:|
| |
|
|
|
### You don't have a real robot yet? Try it in our toy example right now in a sim environment!
[](https://youtu.be/kC6sGRZUxLE)
Here is a Copper-based robot in action in a Bevy simulation environment!
The realistic sim is created using [Bevy](https://crates.io/crates/bevy) (A Rust Game Engine)
and [Avian3d](https://crates.io/crates/avian3d) (Physics Engine in Rust).
On your mac or linux machine (x86-64 or Arm) just run ...
```bash
$ cargo install cu-rp-balancebot
$ balancebot-sim
```
... to try it locally.
The source code for this demo is available in the [examples/cu_rp_balancebot](examples/cu_rp_balancebot) directory.
## Get Started
- Start a new project from templates: [Project Templates](https://copper-project.github.io/copper-rs/Project-Templates)
- See a full task graph + runtime walkthrough: [Copper Application Overview](https://copper-project.github.io/copper-rs/Copper-Application-Overview)
- Build and deploy an application: [Build and Deploy a Copper Application](https://copper-project.github.io/copper-rs/Build-and-Deploy-a-Copper-Application)
- RON configuration reference: [Copper RON Configuration Reference](https://copper-project.github.io/copper-rs/Copper-RON-Configuration-Reference)
## Log Visualization (Rerun)
Copper logs can be visualized with Rerun using an app-specific logviz binary generated by `gen_cumsgs!`.
Enable the `logviz` feature and run:
```bash
# Spawn a viewer and stream the log
cargo run --bin
CONTRIBUTING
Contributing to Copper-rs
First off, thank you for considering contributing to Copper-rs! We welcome contributions from everyone. This document provides guidelines for contributing to the project.
Getting Started
Prerequisites
- Rust: Ensure you have a recent stable Rust toolchain installed. You can install it using rustup.
curl --proto '=https' --tlsv1.2 -sSf [https://sh.rustup.rs](https://sh.rustup.rs) | sh
- just: We use just as a command runner for common development tasks. Install it via cargo or your package manager:
cargo install just
- cargo-nextest: For running tests efficiently.
cargo install cargo-nextest
- typos: For spell checking.
cargo install typos-cli
- Platform-Specific Dependencies: Depending on your operating system and the features you intend to work with, you might need additional dependencies. For Ubuntu 22.04, please checkout our Dockerfile.
Using justfile (Recommended)
The project includes a justfile that mirrors the CI workflow. This is the recommended way to run checks locally before submitting a PR:
# Run the default PR pipeline (format + lint + tests for std/no_std)
just pr-check
# Same as above (default target)
just
# Run lint checks (fmt-check + typos + clippy for std and no_std)
just lint
# Run unit tests (std + no_std)
just test
# Run CI-aligned std checks (build/tests/templates)
just std-ci
# Run CI-aligned embedded/no_std checks
just nostd-ci
# Run in release mode
just std-ci release
# Run with CUDA features
just std-ci cuda-release
The just pr-check command runs:
- Formatting (
just fmt) - Lint checks (
just lint: format check + typos + std/no_std clippy) - Unit tests (
just test: std + no_std)
The just std-ci command remains CI-aligned for std paths, including:
- Format check (
just fmt-check) - Typos check (
typos -c .config/_typos.toml) - Clippy with
--deny warnings - Build with all features
- Unit tests with cargo-nextest
- Project generation tests (debug mode only)
Prek hooks (Recommended)
To mirror the CI lint steps locally, you can install prek hooks that run formatting and typos checks on each commit.
- Install
prek
cargo binstall install prek
# or
cargo install install prek
- Reinstall the git hooks if you previously executed
pre-commit install
prek install -f
- Run once to verify:
prek run --all-files
If you want to customize prek, please modify .pre-commit-config.yaml.
Proc-macro expansion (cargo expand)
Prefer cargo expand when inspecting generated code from Copper proc-macros.
Install it once with:
cargo install cargo-expand
File truncated at 100 lines see the full file
Repository Summary
| Description | Copper is an operating system for robots - build, run, and replay your entire robot deterministically. |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-02-23 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| gpio_caterpillar | 0.0.0 |
README
Copper Runtime & SDK
🤖     Copper is to robots what a game engine is to games - build, run, and replay your entire robot deterministically.
Why Copper
🦀 Rust-first – ergonomic & safe
⚡ Sub-microsecond latency – zero-alloc, data-oriented runtime
⏱️ Deterministic replay – every run, bit-for-bit identical
🧠 Interoperable with ROS2 – bridges via Zenoh opening the path for a progressive migration.
🪶 Runs anywhere – from Linux servers, workstations, SBC to bare-metal MPUs
📦 Built to ship – one stack from simulation to production
### Example Applications
| Flying | Driving | Swimming | Spacefaring |
|:--:|:--:|:--:|:--:|
| |
|
|
|
### You don't have a real robot yet? Try it in our toy example right now in a sim environment!
[](https://youtu.be/kC6sGRZUxLE)
Here is a Copper-based robot in action in a Bevy simulation environment!
The realistic sim is created using [Bevy](https://crates.io/crates/bevy) (A Rust Game Engine)
and [Avian3d](https://crates.io/crates/avian3d) (Physics Engine in Rust).
On your mac or linux machine (x86-64 or Arm) just run ...
```bash
$ cargo install cu-rp-balancebot
$ balancebot-sim
```
... to try it locally.
The source code for this demo is available in the [examples/cu_rp_balancebot](examples/cu_rp_balancebot) directory.
## Get Started
- Start a new project from templates: [Project Templates](https://copper-project.github.io/copper-rs/Project-Templates)
- See a full task graph + runtime walkthrough: [Copper Application Overview](https://copper-project.github.io/copper-rs/Copper-Application-Overview)
- Build and deploy an application: [Build and Deploy a Copper Application](https://copper-project.github.io/copper-rs/Build-and-Deploy-a-Copper-Application)
- RON configuration reference: [Copper RON Configuration Reference](https://copper-project.github.io/copper-rs/Copper-RON-Configuration-Reference)
## Log Visualization (Rerun)
Copper logs can be visualized with Rerun using an app-specific logviz binary generated by `gen_cumsgs!`.
Enable the `logviz` feature and run:
```bash
# Spawn a viewer and stream the log
cargo run --bin
CONTRIBUTING
Contributing to Copper-rs
First off, thank you for considering contributing to Copper-rs! We welcome contributions from everyone. This document provides guidelines for contributing to the project.
Getting Started
Prerequisites
- Rust: Ensure you have a recent stable Rust toolchain installed. You can install it using rustup.
curl --proto '=https' --tlsv1.2 -sSf [https://sh.rustup.rs](https://sh.rustup.rs) | sh
- just: We use just as a command runner for common development tasks. Install it via cargo or your package manager:
cargo install just
- cargo-nextest: For running tests efficiently.
cargo install cargo-nextest
- typos: For spell checking.
cargo install typos-cli
- Platform-Specific Dependencies: Depending on your operating system and the features you intend to work with, you might need additional dependencies. For Ubuntu 22.04, please checkout our Dockerfile.
Using justfile (Recommended)
The project includes a justfile that mirrors the CI workflow. This is the recommended way to run checks locally before submitting a PR:
# Run the default PR pipeline (format + lint + tests for std/no_std)
just pr-check
# Same as above (default target)
just
# Run lint checks (fmt-check + typos + clippy for std and no_std)
just lint
# Run unit tests (std + no_std)
just test
# Run CI-aligned std checks (build/tests/templates)
just std-ci
# Run CI-aligned embedded/no_std checks
just nostd-ci
# Run in release mode
just std-ci release
# Run with CUDA features
just std-ci cuda-release
The just pr-check command runs:
- Formatting (
just fmt) - Lint checks (
just lint: format check + typos + std/no_std clippy) - Unit tests (
just test: std + no_std)
The just std-ci command remains CI-aligned for std paths, including:
- Format check (
just fmt-check) - Typos check (
typos -c .config/_typos.toml) - Clippy with
--deny warnings - Build with all features
- Unit tests with cargo-nextest
- Project generation tests (debug mode only)
Prek hooks (Recommended)
To mirror the CI lint steps locally, you can install prek hooks that run formatting and typos checks on each commit.
- Install
prek
cargo binstall install prek
# or
cargo install install prek
- Reinstall the git hooks if you previously executed
pre-commit install
prek install -f
- Run once to verify:
prek run --all-files
If you want to customize prek, please modify .pre-commit-config.yaml.
Proc-macro expansion (cargo expand)
Prefer cargo expand when inspecting generated code from Copper proc-macros.
Install it once with:
cargo install cargo-expand
File truncated at 100 lines see the full file
Repository Summary
| Description | Copper is an operating system for robots - build, run, and replay your entire robot deterministically. |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-02-23 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| gpio_caterpillar | 0.0.0 |
README
Copper Runtime & SDK
🤖     Copper is to robots what a game engine is to games - build, run, and replay your entire robot deterministically.
Why Copper
🦀 Rust-first – ergonomic & safe
⚡ Sub-microsecond latency – zero-alloc, data-oriented runtime
⏱️ Deterministic replay – every run, bit-for-bit identical
🧠 Interoperable with ROS2 – bridges via Zenoh opening the path for a progressive migration.
🪶 Runs anywhere – from Linux servers, workstations, SBC to bare-metal MPUs
📦 Built to ship – one stack from simulation to production
### Example Applications
| Flying | Driving | Swimming | Spacefaring |
|:--:|:--:|:--:|:--:|
| |
|
|
|
### You don't have a real robot yet? Try it in our toy example right now in a sim environment!
[](https://youtu.be/kC6sGRZUxLE)
Here is a Copper-based robot in action in a Bevy simulation environment!
The realistic sim is created using [Bevy](https://crates.io/crates/bevy) (A Rust Game Engine)
and [Avian3d](https://crates.io/crates/avian3d) (Physics Engine in Rust).
On your mac or linux machine (x86-64 or Arm) just run ...
```bash
$ cargo install cu-rp-balancebot
$ balancebot-sim
```
... to try it locally.
The source code for this demo is available in the [examples/cu_rp_balancebot](examples/cu_rp_balancebot) directory.
## Get Started
- Start a new project from templates: [Project Templates](https://copper-project.github.io/copper-rs/Project-Templates)
- See a full task graph + runtime walkthrough: [Copper Application Overview](https://copper-project.github.io/copper-rs/Copper-Application-Overview)
- Build and deploy an application: [Build and Deploy a Copper Application](https://copper-project.github.io/copper-rs/Build-and-Deploy-a-Copper-Application)
- RON configuration reference: [Copper RON Configuration Reference](https://copper-project.github.io/copper-rs/Copper-RON-Configuration-Reference)
## Log Visualization (Rerun)
Copper logs can be visualized with Rerun using an app-specific logviz binary generated by `gen_cumsgs!`.
Enable the `logviz` feature and run:
```bash
# Spawn a viewer and stream the log
cargo run --bin
CONTRIBUTING
Contributing to Copper-rs
First off, thank you for considering contributing to Copper-rs! We welcome contributions from everyone. This document provides guidelines for contributing to the project.
Getting Started
Prerequisites
- Rust: Ensure you have a recent stable Rust toolchain installed. You can install it using rustup.
curl --proto '=https' --tlsv1.2 -sSf [https://sh.rustup.rs](https://sh.rustup.rs) | sh
- just: We use just as a command runner for common development tasks. Install it via cargo or your package manager:
cargo install just
- cargo-nextest: For running tests efficiently.
cargo install cargo-nextest
- typos: For spell checking.
cargo install typos-cli
- Platform-Specific Dependencies: Depending on your operating system and the features you intend to work with, you might need additional dependencies. For Ubuntu 22.04, please checkout our Dockerfile.
Using justfile (Recommended)
The project includes a justfile that mirrors the CI workflow. This is the recommended way to run checks locally before submitting a PR:
# Run the default PR pipeline (format + lint + tests for std/no_std)
just pr-check
# Same as above (default target)
just
# Run lint checks (fmt-check + typos + clippy for std and no_std)
just lint
# Run unit tests (std + no_std)
just test
# Run CI-aligned std checks (build/tests/templates)
just std-ci
# Run CI-aligned embedded/no_std checks
just nostd-ci
# Run in release mode
just std-ci release
# Run with CUDA features
just std-ci cuda-release
The just pr-check command runs:
- Formatting (
just fmt) - Lint checks (
just lint: format check + typos + std/no_std clippy) - Unit tests (
just test: std + no_std)
The just std-ci command remains CI-aligned for std paths, including:
- Format check (
just fmt-check) - Typos check (
typos -c .config/_typos.toml) - Clippy with
--deny warnings - Build with all features
- Unit tests with cargo-nextest
- Project generation tests (debug mode only)
Prek hooks (Recommended)
To mirror the CI lint steps locally, you can install prek hooks that run formatting and typos checks on each commit.
- Install
prek
cargo binstall install prek
# or
cargo install install prek
- Reinstall the git hooks if you previously executed
pre-commit install
prek install -f
- Run once to verify:
prek run --all-files
If you want to customize prek, please modify .pre-commit-config.yaml.
Proc-macro expansion (cargo expand)
Prefer cargo expand when inspecting generated code from Copper proc-macros.
Install it once with:
cargo install cargo-expand
File truncated at 100 lines see the full file
Repository Summary
| Description | Copper is an operating system for robots - build, run, and replay your entire robot deterministically. |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-02-23 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| gpio_caterpillar | 0.0.0 |
README
Copper Runtime & SDK
🤖     Copper is to robots what a game engine is to games - build, run, and replay your entire robot deterministically.
Why Copper
🦀 Rust-first – ergonomic & safe
⚡ Sub-microsecond latency – zero-alloc, data-oriented runtime
⏱️ Deterministic replay – every run, bit-for-bit identical
🧠 Interoperable with ROS2 – bridges via Zenoh opening the path for a progressive migration.
🪶 Runs anywhere – from Linux servers, workstations, SBC to bare-metal MPUs
📦 Built to ship – one stack from simulation to production
### Example Applications
| Flying | Driving | Swimming | Spacefaring |
|:--:|:--:|:--:|:--:|
| |
|
|
|
### You don't have a real robot yet? Try it in our toy example right now in a sim environment!
[](https://youtu.be/kC6sGRZUxLE)
Here is a Copper-based robot in action in a Bevy simulation environment!
The realistic sim is created using [Bevy](https://crates.io/crates/bevy) (A Rust Game Engine)
and [Avian3d](https://crates.io/crates/avian3d) (Physics Engine in Rust).
On your mac or linux machine (x86-64 or Arm) just run ...
```bash
$ cargo install cu-rp-balancebot
$ balancebot-sim
```
... to try it locally.
The source code for this demo is available in the [examples/cu_rp_balancebot](examples/cu_rp_balancebot) directory.
## Get Started
- Start a new project from templates: [Project Templates](https://copper-project.github.io/copper-rs/Project-Templates)
- See a full task graph + runtime walkthrough: [Copper Application Overview](https://copper-project.github.io/copper-rs/Copper-Application-Overview)
- Build and deploy an application: [Build and Deploy a Copper Application](https://copper-project.github.io/copper-rs/Build-and-Deploy-a-Copper-Application)
- RON configuration reference: [Copper RON Configuration Reference](https://copper-project.github.io/copper-rs/Copper-RON-Configuration-Reference)
## Log Visualization (Rerun)
Copper logs can be visualized with Rerun using an app-specific logviz binary generated by `gen_cumsgs!`.
Enable the `logviz` feature and run:
```bash
# Spawn a viewer and stream the log
cargo run --bin
CONTRIBUTING
Contributing to Copper-rs
First off, thank you for considering contributing to Copper-rs! We welcome contributions from everyone. This document provides guidelines for contributing to the project.
Getting Started
Prerequisites
- Rust: Ensure you have a recent stable Rust toolchain installed. You can install it using rustup.
curl --proto '=https' --tlsv1.2 -sSf [https://sh.rustup.rs](https://sh.rustup.rs) | sh
- just: We use just as a command runner for common development tasks. Install it via cargo or your package manager:
cargo install just
- cargo-nextest: For running tests efficiently.
cargo install cargo-nextest
- typos: For spell checking.
cargo install typos-cli
- Platform-Specific Dependencies: Depending on your operating system and the features you intend to work with, you might need additional dependencies. For Ubuntu 22.04, please checkout our Dockerfile.
Using justfile (Recommended)
The project includes a justfile that mirrors the CI workflow. This is the recommended way to run checks locally before submitting a PR:
# Run the default PR pipeline (format + lint + tests for std/no_std)
just pr-check
# Same as above (default target)
just
# Run lint checks (fmt-check + typos + clippy for std and no_std)
just lint
# Run unit tests (std + no_std)
just test
# Run CI-aligned std checks (build/tests/templates)
just std-ci
# Run CI-aligned embedded/no_std checks
just nostd-ci
# Run in release mode
just std-ci release
# Run with CUDA features
just std-ci cuda-release
The just pr-check command runs:
- Formatting (
just fmt) - Lint checks (
just lint: format check + typos + std/no_std clippy) - Unit tests (
just test: std + no_std)
The just std-ci command remains CI-aligned for std paths, including:
- Format check (
just fmt-check) - Typos check (
typos -c .config/_typos.toml) - Clippy with
--deny warnings - Build with all features
- Unit tests with cargo-nextest
- Project generation tests (debug mode only)
Prek hooks (Recommended)
To mirror the CI lint steps locally, you can install prek hooks that run formatting and typos checks on each commit.
- Install
prek
cargo binstall install prek
# or
cargo install install prek
- Reinstall the git hooks if you previously executed
pre-commit install
prek install -f
- Run once to verify:
prek run --all-files
If you want to customize prek, please modify .pre-commit-config.yaml.
Proc-macro expansion (cargo expand)
Prefer cargo expand when inspecting generated code from Copper proc-macros.
Install it once with:
cargo install cargo-expand
File truncated at 100 lines see the full file
Repository Summary
| Description | Copper is an operating system for robots - build, run, and replay your entire robot deterministically. |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-02-23 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| gpio_caterpillar | 0.0.0 |
README
Copper Runtime & SDK
🤖     Copper is to robots what a game engine is to games - build, run, and replay your entire robot deterministically.
Why Copper
🦀 Rust-first – ergonomic & safe
⚡ Sub-microsecond latency – zero-alloc, data-oriented runtime
⏱️ Deterministic replay – every run, bit-for-bit identical
🧠 Interoperable with ROS2 – bridges via Zenoh opening the path for a progressive migration.
🪶 Runs anywhere – from Linux servers, workstations, SBC to bare-metal MPUs
📦 Built to ship – one stack from simulation to production
### Example Applications
| Flying | Driving | Swimming | Spacefaring |
|:--:|:--:|:--:|:--:|
| |
|
|
|
### You don't have a real robot yet? Try it in our toy example right now in a sim environment!
[](https://youtu.be/kC6sGRZUxLE)
Here is a Copper-based robot in action in a Bevy simulation environment!
The realistic sim is created using [Bevy](https://crates.io/crates/bevy) (A Rust Game Engine)
and [Avian3d](https://crates.io/crates/avian3d) (Physics Engine in Rust).
On your mac or linux machine (x86-64 or Arm) just run ...
```bash
$ cargo install cu-rp-balancebot
$ balancebot-sim
```
... to try it locally.
The source code for this demo is available in the [examples/cu_rp_balancebot](examples/cu_rp_balancebot) directory.
## Get Started
- Start a new project from templates: [Project Templates](https://copper-project.github.io/copper-rs/Project-Templates)
- See a full task graph + runtime walkthrough: [Copper Application Overview](https://copper-project.github.io/copper-rs/Copper-Application-Overview)
- Build and deploy an application: [Build and Deploy a Copper Application](https://copper-project.github.io/copper-rs/Build-and-Deploy-a-Copper-Application)
- RON configuration reference: [Copper RON Configuration Reference](https://copper-project.github.io/copper-rs/Copper-RON-Configuration-Reference)
## Log Visualization (Rerun)
Copper logs can be visualized with Rerun using an app-specific logviz binary generated by `gen_cumsgs!`.
Enable the `logviz` feature and run:
```bash
# Spawn a viewer and stream the log
cargo run --bin
CONTRIBUTING
Contributing to Copper-rs
First off, thank you for considering contributing to Copper-rs! We welcome contributions from everyone. This document provides guidelines for contributing to the project.
Getting Started
Prerequisites
- Rust: Ensure you have a recent stable Rust toolchain installed. You can install it using rustup.
curl --proto '=https' --tlsv1.2 -sSf [https://sh.rustup.rs](https://sh.rustup.rs) | sh
- just: We use just as a command runner for common development tasks. Install it via cargo or your package manager:
cargo install just
- cargo-nextest: For running tests efficiently.
cargo install cargo-nextest
- typos: For spell checking.
cargo install typos-cli
- Platform-Specific Dependencies: Depending on your operating system and the features you intend to work with, you might need additional dependencies. For Ubuntu 22.04, please checkout our Dockerfile.
Using justfile (Recommended)
The project includes a justfile that mirrors the CI workflow. This is the recommended way to run checks locally before submitting a PR:
# Run the default PR pipeline (format + lint + tests for std/no_std)
just pr-check
# Same as above (default target)
just
# Run lint checks (fmt-check + typos + clippy for std and no_std)
just lint
# Run unit tests (std + no_std)
just test
# Run CI-aligned std checks (build/tests/templates)
just std-ci
# Run CI-aligned embedded/no_std checks
just nostd-ci
# Run in release mode
just std-ci release
# Run with CUDA features
just std-ci cuda-release
The just pr-check command runs:
- Formatting (
just fmt) - Lint checks (
just lint: format check + typos + std/no_std clippy) - Unit tests (
just test: std + no_std)
The just std-ci command remains CI-aligned for std paths, including:
- Format check (
just fmt-check) - Typos check (
typos -c .config/_typos.toml) - Clippy with
--deny warnings - Build with all features
- Unit tests with cargo-nextest
- Project generation tests (debug mode only)
Prek hooks (Recommended)
To mirror the CI lint steps locally, you can install prek hooks that run formatting and typos checks on each commit.
- Install
prek
cargo binstall install prek
# or
cargo install install prek
- Reinstall the git hooks if you previously executed
pre-commit install
prek install -f
- Run once to verify:
prek run --all-files
If you want to customize prek, please modify .pre-commit-config.yaml.
Proc-macro expansion (cargo expand)
Prefer cargo expand when inspecting generated code from Copper proc-macros.
Install it once with:
cargo install cargo-expand
File truncated at 100 lines see the full file
Repository Summary
| Description | Copper is an operating system for robots - build, run, and replay your entire robot deterministically. |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-02-23 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| gpio_caterpillar | 0.0.0 |
README
Copper Runtime & SDK
🤖     Copper is to robots what a game engine is to games - build, run, and replay your entire robot deterministically.
Why Copper
🦀 Rust-first – ergonomic & safe
⚡ Sub-microsecond latency – zero-alloc, data-oriented runtime
⏱️ Deterministic replay – every run, bit-for-bit identical
🧠 Interoperable with ROS2 – bridges via Zenoh opening the path for a progressive migration.
🪶 Runs anywhere – from Linux servers, workstations, SBC to bare-metal MPUs
📦 Built to ship – one stack from simulation to production
### Example Applications
| Flying | Driving | Swimming | Spacefaring |
|:--:|:--:|:--:|:--:|
| |
|
|
|
### You don't have a real robot yet? Try it in our toy example right now in a sim environment!
[](https://youtu.be/kC6sGRZUxLE)
Here is a Copper-based robot in action in a Bevy simulation environment!
The realistic sim is created using [Bevy](https://crates.io/crates/bevy) (A Rust Game Engine)
and [Avian3d](https://crates.io/crates/avian3d) (Physics Engine in Rust).
On your mac or linux machine (x86-64 or Arm) just run ...
```bash
$ cargo install cu-rp-balancebot
$ balancebot-sim
```
... to try it locally.
The source code for this demo is available in the [examples/cu_rp_balancebot](examples/cu_rp_balancebot) directory.
## Get Started
- Start a new project from templates: [Project Templates](https://copper-project.github.io/copper-rs/Project-Templates)
- See a full task graph + runtime walkthrough: [Copper Application Overview](https://copper-project.github.io/copper-rs/Copper-Application-Overview)
- Build and deploy an application: [Build and Deploy a Copper Application](https://copper-project.github.io/copper-rs/Build-and-Deploy-a-Copper-Application)
- RON configuration reference: [Copper RON Configuration Reference](https://copper-project.github.io/copper-rs/Copper-RON-Configuration-Reference)
## Log Visualization (Rerun)
Copper logs can be visualized with Rerun using an app-specific logviz binary generated by `gen_cumsgs!`.
Enable the `logviz` feature and run:
```bash
# Spawn a viewer and stream the log
cargo run --bin
CONTRIBUTING
Contributing to Copper-rs
First off, thank you for considering contributing to Copper-rs! We welcome contributions from everyone. This document provides guidelines for contributing to the project.
Getting Started
Prerequisites
- Rust: Ensure you have a recent stable Rust toolchain installed. You can install it using rustup.
curl --proto '=https' --tlsv1.2 -sSf [https://sh.rustup.rs](https://sh.rustup.rs) | sh
- just: We use just as a command runner for common development tasks. Install it via cargo or your package manager:
cargo install just
- cargo-nextest: For running tests efficiently.
cargo install cargo-nextest
- typos: For spell checking.
cargo install typos-cli
- Platform-Specific Dependencies: Depending on your operating system and the features you intend to work with, you might need additional dependencies. For Ubuntu 22.04, please checkout our Dockerfile.
Using justfile (Recommended)
The project includes a justfile that mirrors the CI workflow. This is the recommended way to run checks locally before submitting a PR:
# Run the default PR pipeline (format + lint + tests for std/no_std)
just pr-check
# Same as above (default target)
just
# Run lint checks (fmt-check + typos + clippy for std and no_std)
just lint
# Run unit tests (std + no_std)
just test
# Run CI-aligned std checks (build/tests/templates)
just std-ci
# Run CI-aligned embedded/no_std checks
just nostd-ci
# Run in release mode
just std-ci release
# Run with CUDA features
just std-ci cuda-release
The just pr-check command runs:
- Formatting (
just fmt) - Lint checks (
just lint: format check + typos + std/no_std clippy) - Unit tests (
just test: std + no_std)
The just std-ci command remains CI-aligned for std paths, including:
- Format check (
just fmt-check) - Typos check (
typos -c .config/_typos.toml) - Clippy with
--deny warnings - Build with all features
- Unit tests with cargo-nextest
- Project generation tests (debug mode only)
Prek hooks (Recommended)
To mirror the CI lint steps locally, you can install prek hooks that run formatting and typos checks on each commit.
- Install
prek
cargo binstall install prek
# or
cargo install install prek
- Reinstall the git hooks if you previously executed
pre-commit install
prek install -f
- Run once to verify:
prek run --all-files
If you want to customize prek, please modify .pre-commit-config.yaml.
Proc-macro expansion (cargo expand)
Prefer cargo expand when inspecting generated code from Copper proc-macros.
Install it once with:
cargo install cargo-expand
File truncated at 100 lines see the full file
Repository Summary
| Description | Copper is an operating system for robots - build, run, and replay your entire robot deterministically. |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-02-23 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| gpio_caterpillar | 0.0.0 |
README
Copper Runtime & SDK
🤖     Copper is to robots what a game engine is to games - build, run, and replay your entire robot deterministically.
Why Copper
🦀 Rust-first – ergonomic & safe
⚡ Sub-microsecond latency – zero-alloc, data-oriented runtime
⏱️ Deterministic replay – every run, bit-for-bit identical
🧠 Interoperable with ROS2 – bridges via Zenoh opening the path for a progressive migration.
🪶 Runs anywhere – from Linux servers, workstations, SBC to bare-metal MPUs
📦 Built to ship – one stack from simulation to production
### Example Applications
| Flying | Driving | Swimming | Spacefaring |
|:--:|:--:|:--:|:--:|
| |
|
|
|
### You don't have a real robot yet? Try it in our toy example right now in a sim environment!
[](https://youtu.be/kC6sGRZUxLE)
Here is a Copper-based robot in action in a Bevy simulation environment!
The realistic sim is created using [Bevy](https://crates.io/crates/bevy) (A Rust Game Engine)
and [Avian3d](https://crates.io/crates/avian3d) (Physics Engine in Rust).
On your mac or linux machine (x86-64 or Arm) just run ...
```bash
$ cargo install cu-rp-balancebot
$ balancebot-sim
```
... to try it locally.
The source code for this demo is available in the [examples/cu_rp_balancebot](examples/cu_rp_balancebot) directory.
## Get Started
- Start a new project from templates: [Project Templates](https://copper-project.github.io/copper-rs/Project-Templates)
- See a full task graph + runtime walkthrough: [Copper Application Overview](https://copper-project.github.io/copper-rs/Copper-Application-Overview)
- Build and deploy an application: [Build and Deploy a Copper Application](https://copper-project.github.io/copper-rs/Build-and-Deploy-a-Copper-Application)
- RON configuration reference: [Copper RON Configuration Reference](https://copper-project.github.io/copper-rs/Copper-RON-Configuration-Reference)
## Log Visualization (Rerun)
Copper logs can be visualized with Rerun using an app-specific logviz binary generated by `gen_cumsgs!`.
Enable the `logviz` feature and run:
```bash
# Spawn a viewer and stream the log
cargo run --bin
CONTRIBUTING
Contributing to Copper-rs
First off, thank you for considering contributing to Copper-rs! We welcome contributions from everyone. This document provides guidelines for contributing to the project.
Getting Started
Prerequisites
- Rust: Ensure you have a recent stable Rust toolchain installed. You can install it using rustup.
curl --proto '=https' --tlsv1.2 -sSf [https://sh.rustup.rs](https://sh.rustup.rs) | sh
- just: We use just as a command runner for common development tasks. Install it via cargo or your package manager:
cargo install just
- cargo-nextest: For running tests efficiently.
cargo install cargo-nextest
- typos: For spell checking.
cargo install typos-cli
- Platform-Specific Dependencies: Depending on your operating system and the features you intend to work with, you might need additional dependencies. For Ubuntu 22.04, please checkout our Dockerfile.
Using justfile (Recommended)
The project includes a justfile that mirrors the CI workflow. This is the recommended way to run checks locally before submitting a PR:
# Run the default PR pipeline (format + lint + tests for std/no_std)
just pr-check
# Same as above (default target)
just
# Run lint checks (fmt-check + typos + clippy for std and no_std)
just lint
# Run unit tests (std + no_std)
just test
# Run CI-aligned std checks (build/tests/templates)
just std-ci
# Run CI-aligned embedded/no_std checks
just nostd-ci
# Run in release mode
just std-ci release
# Run with CUDA features
just std-ci cuda-release
The just pr-check command runs:
- Formatting (
just fmt) - Lint checks (
just lint: format check + typos + std/no_std clippy) - Unit tests (
just test: std + no_std)
The just std-ci command remains CI-aligned for std paths, including:
- Format check (
just fmt-check) - Typos check (
typos -c .config/_typos.toml) - Clippy with
--deny warnings - Build with all features
- Unit tests with cargo-nextest
- Project generation tests (debug mode only)
Prek hooks (Recommended)
To mirror the CI lint steps locally, you can install prek hooks that run formatting and typos checks on each commit.
- Install
prek
cargo binstall install prek
# or
cargo install install prek
- Reinstall the git hooks if you previously executed
pre-commit install
prek install -f
- Run once to verify:
prek run --all-files
If you want to customize prek, please modify .pre-commit-config.yaml.
Proc-macro expansion (cargo expand)
Prefer cargo expand when inspecting generated code from Copper proc-macros.
Install it once with:
cargo install cargo-expand
File truncated at 100 lines see the full file
Repository Summary
| Description | Copper is an operating system for robots - build, run, and replay your entire robot deterministically. |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-02-23 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| gpio_caterpillar | 0.0.0 |
README
Copper Runtime & SDK
🤖     Copper is to robots what a game engine is to games - build, run, and replay your entire robot deterministically.
Why Copper
🦀 Rust-first – ergonomic & safe
⚡ Sub-microsecond latency – zero-alloc, data-oriented runtime
⏱️ Deterministic replay – every run, bit-for-bit identical
🧠 Interoperable with ROS2 – bridges via Zenoh opening the path for a progressive migration.
🪶 Runs anywhere – from Linux servers, workstations, SBC to bare-metal MPUs
📦 Built to ship – one stack from simulation to production
### Example Applications
| Flying | Driving | Swimming | Spacefaring |
|:--:|:--:|:--:|:--:|
| |
|
|
|
### You don't have a real robot yet? Try it in our toy example right now in a sim environment!
[](https://youtu.be/kC6sGRZUxLE)
Here is a Copper-based robot in action in a Bevy simulation environment!
The realistic sim is created using [Bevy](https://crates.io/crates/bevy) (A Rust Game Engine)
and [Avian3d](https://crates.io/crates/avian3d) (Physics Engine in Rust).
On your mac or linux machine (x86-64 or Arm) just run ...
```bash
$ cargo install cu-rp-balancebot
$ balancebot-sim
```
... to try it locally.
The source code for this demo is available in the [examples/cu_rp_balancebot](examples/cu_rp_balancebot) directory.
## Get Started
- Start a new project from templates: [Project Templates](https://copper-project.github.io/copper-rs/Project-Templates)
- See a full task graph + runtime walkthrough: [Copper Application Overview](https://copper-project.github.io/copper-rs/Copper-Application-Overview)
- Build and deploy an application: [Build and Deploy a Copper Application](https://copper-project.github.io/copper-rs/Build-and-Deploy-a-Copper-Application)
- RON configuration reference: [Copper RON Configuration Reference](https://copper-project.github.io/copper-rs/Copper-RON-Configuration-Reference)
## Log Visualization (Rerun)
Copper logs can be visualized with Rerun using an app-specific logviz binary generated by `gen_cumsgs!`.
Enable the `logviz` feature and run:
```bash
# Spawn a viewer and stream the log
cargo run --bin
CONTRIBUTING
Contributing to Copper-rs
First off, thank you for considering contributing to Copper-rs! We welcome contributions from everyone. This document provides guidelines for contributing to the project.
Getting Started
Prerequisites
- Rust: Ensure you have a recent stable Rust toolchain installed. You can install it using rustup.
curl --proto '=https' --tlsv1.2 -sSf [https://sh.rustup.rs](https://sh.rustup.rs) | sh
- just: We use just as a command runner for common development tasks. Install it via cargo or your package manager:
cargo install just
- cargo-nextest: For running tests efficiently.
cargo install cargo-nextest
- typos: For spell checking.
cargo install typos-cli
- Platform-Specific Dependencies: Depending on your operating system and the features you intend to work with, you might need additional dependencies. For Ubuntu 22.04, please checkout our Dockerfile.
Using justfile (Recommended)
The project includes a justfile that mirrors the CI workflow. This is the recommended way to run checks locally before submitting a PR:
# Run the default PR pipeline (format + lint + tests for std/no_std)
just pr-check
# Same as above (default target)
just
# Run lint checks (fmt-check + typos + clippy for std and no_std)
just lint
# Run unit tests (std + no_std)
just test
# Run CI-aligned std checks (build/tests/templates)
just std-ci
# Run CI-aligned embedded/no_std checks
just nostd-ci
# Run in release mode
just std-ci release
# Run with CUDA features
just std-ci cuda-release
The just pr-check command runs:
- Formatting (
just fmt) - Lint checks (
just lint: format check + typos + std/no_std clippy) - Unit tests (
just test: std + no_std)
The just std-ci command remains CI-aligned for std paths, including:
- Format check (
just fmt-check) - Typos check (
typos -c .config/_typos.toml) - Clippy with
--deny warnings - Build with all features
- Unit tests with cargo-nextest
- Project generation tests (debug mode only)
Prek hooks (Recommended)
To mirror the CI lint steps locally, you can install prek hooks that run formatting and typos checks on each commit.
- Install
prek
cargo binstall install prek
# or
cargo install install prek
- Reinstall the git hooks if you previously executed
pre-commit install
prek install -f
- Run once to verify:
prek run --all-files
If you want to customize prek, please modify .pre-commit-config.yaml.
Proc-macro expansion (cargo expand)
Prefer cargo expand when inspecting generated code from Copper proc-macros.
Install it once with:
cargo install cargo-expand
File truncated at 100 lines see the full file