Repository Summary
| Description | |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-10-27 |
| 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
A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.
▶ Try Copper in your browser · Build your first app
Why Copper
| Built for robots | Built to ship |
|---|---|
| Static by design: task graphs are declared in RON and wired at compile time. | Runs anywhere: Linux, macOS, SBCs, and bare-metal microcontrollers. |
| Realtime first: zero-allocation, data-oriented execution on the hot path. | Deterministic replay: record a run, reproduce it, and inspect it offline. |
| Rust-first: ergonomic task APIs with compile-time guarantees. | Interoperable: connect to ROS 2 through Zenoh and migrate progressively. |
Already flying, driving, swimming, spacefaring, and powering humanoids.
See It Run
These are the same Copper applications used on physical robots, recompiled for the browser. The simulator runs beside a live view of the Copper task graph and latency.
BalanceBot A self-balancing robot simulation using the application that runs on Raspberry Pi hardware. Source code |
Flight Controller A quadcopter simulation using the control stack deployed on STM32H7 flight hardware. Source code |
Watch more robots built with Copper in the community showcase, or explore the cross-framework benchmarks.
Build Your First Copper App
Install the latest stable Rust toolchain, then:
cargo install cargo-cunew
cargo cunew hello_copper
cd hello_copper
cargo run
The generated app has a typed source → task → sink graph that prints its
first messages and records logs/hello-copper.copper. Start with
copperconfig.ron, src/main.rs, and src/tasks.rs; the generated justfile
also provides helpers for logs, CopperLists, topology (just graph), the exact
generated process schedule (just sched), post-execution timing from the default
Copper log (just sched-log), and replay. Host projects also include
just pgs-baseline, just pgs-optimize, just pgs-candidate, and
just pgs-measure; the starter schedule.ron is a conservative placeholder to tune
for the real workload. Project creation asks whether the target is bare metal/no_std
and omits PGS scaffolding for that choice.
How Copper Fits Together
| Stage | What happens |
|---|---|
| Declare | Define the static task graph in copperconfig.ron. |
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to Copper
Thank you for helping build a deterministic, production-ready robotics runtime. Contributions of code, components, documentation, examples, and careful bug reports are all welcome.
Choose Where to Start
| You want to… | Best next step |
|---|---|
| Ask a usage question | Search the documentation or ask on Discord. |
| Report a bug or request a feature | Open the matching issue template. |
| Propose a runtime or architectural change | Start a Discussion before investing in a large implementation. |
| Add a reusable driver, task, bridge, or payload | Read Contributing Components; an independent crate is often the best home. |
| Improve docs or examples | Open a focused pull request and update related wiki/book material when behavior and documentation move together. |
| Report a vulnerability | Follow the private process in SECURITY.md. Do not open a public issue. |
All community participation is governed by our Code of Conduct.
Set Up the Workspace
Copper’s minimum supported Rust version is 1.96. Install the latest stable Rust
toolchain with rustup, then install
just and clone your fork:
cargo install just
git clone https://github.com/YOUR_USERNAME/copper-rs.git
cd copper-rs
The Ubuntu development dependencies are documented in
support/docker/Dockerfile.ubuntu. Other
platforms may require equivalent system packages.
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Contribution Workflow
- Create a branch from
masterusinguser/kind/description, for examplealex/fix/replay-seek. - Make one focused change. Add tests and update documentation or examples where the behavior needs them.
- Run
justfrom the repository root. It formats the workspace, runs lint and API checks, and tests the std andno_stdsurfaces. - Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
- Push your branch and open a pull request to
master. Explain the problem, the chosen approach, and how you verified it.
The pull request template contains the final submission checklist.
Checks
Prefer the root justfile over copying long Cargo command lines:
| Change | Run |
|---|---|
| Most pull requests |
just or just pr-check
|
| Formatting, typos, and clippy only | just lint |
| Workflow configuration and change classification |
just ci-config-check (requires actionlint) |
| Host/runtime behavior across the std feature matrix | just std-ci |
Shared, embedded-facing, or no_std code |
just nostd-ci |
| Coverage-sensitive behavior | just coverage |
| Runtime proc-macro expansion | just expand-runtime pkg=<crate> bin=<bin> [features=<features>] |
| SoA derive expansion | just expand-soa |
Linux is the primary full-workspace gate. macOS is also release-blocking, Windows validates a reduced core surface, and embedded coverage is compile-time rather than hardware-in-the-loop. See Supported Platforms for the public platform matrix.
Workspace checks use support/ci/workspace_excludes.py to read
package.metadata.copper. Set ci_exclude_workspace = true to exclude a package
on every runner, or ci_exclude_workspace_os = ["macos"] to exclude it on specific
runner operating systems (linux, macos, or windows). macOS checks include
the portable cu-zed payload and projection code and exclude the native ZED SDK
File truncated at 100 lines see the full file
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Repository Summary
| Description | |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-10-27 |
| 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
A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.
▶ Try Copper in your browser · Build your first app
Why Copper
| Built for robots | Built to ship |
|---|---|
| Static by design: task graphs are declared in RON and wired at compile time. | Runs anywhere: Linux, macOS, SBCs, and bare-metal microcontrollers. |
| Realtime first: zero-allocation, data-oriented execution on the hot path. | Deterministic replay: record a run, reproduce it, and inspect it offline. |
| Rust-first: ergonomic task APIs with compile-time guarantees. | Interoperable: connect to ROS 2 through Zenoh and migrate progressively. |
Already flying, driving, swimming, spacefaring, and powering humanoids.
See It Run
These are the same Copper applications used on physical robots, recompiled for the browser. The simulator runs beside a live view of the Copper task graph and latency.
BalanceBot A self-balancing robot simulation using the application that runs on Raspberry Pi hardware. Source code |
Flight Controller A quadcopter simulation using the control stack deployed on STM32H7 flight hardware. Source code |
Watch more robots built with Copper in the community showcase, or explore the cross-framework benchmarks.
Build Your First Copper App
Install the latest stable Rust toolchain, then:
cargo install cargo-cunew
cargo cunew hello_copper
cd hello_copper
cargo run
The generated app has a typed source → task → sink graph that prints its
first messages and records logs/hello-copper.copper. Start with
copperconfig.ron, src/main.rs, and src/tasks.rs; the generated justfile
also provides helpers for logs, CopperLists, topology (just graph), the exact
generated process schedule (just sched), post-execution timing from the default
Copper log (just sched-log), and replay. Host projects also include
just pgs-baseline, just pgs-optimize, just pgs-candidate, and
just pgs-measure; the starter schedule.ron is a conservative placeholder to tune
for the real workload. Project creation asks whether the target is bare metal/no_std
and omits PGS scaffolding for that choice.
How Copper Fits Together
| Stage | What happens |
|---|---|
| Declare | Define the static task graph in copperconfig.ron. |
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to Copper
Thank you for helping build a deterministic, production-ready robotics runtime. Contributions of code, components, documentation, examples, and careful bug reports are all welcome.
Choose Where to Start
| You want to… | Best next step |
|---|---|
| Ask a usage question | Search the documentation or ask on Discord. |
| Report a bug or request a feature | Open the matching issue template. |
| Propose a runtime or architectural change | Start a Discussion before investing in a large implementation. |
| Add a reusable driver, task, bridge, or payload | Read Contributing Components; an independent crate is often the best home. |
| Improve docs or examples | Open a focused pull request and update related wiki/book material when behavior and documentation move together. |
| Report a vulnerability | Follow the private process in SECURITY.md. Do not open a public issue. |
All community participation is governed by our Code of Conduct.
Set Up the Workspace
Copper’s minimum supported Rust version is 1.96. Install the latest stable Rust
toolchain with rustup, then install
just and clone your fork:
cargo install just
git clone https://github.com/YOUR_USERNAME/copper-rs.git
cd copper-rs
The Ubuntu development dependencies are documented in
support/docker/Dockerfile.ubuntu. Other
platforms may require equivalent system packages.
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Contribution Workflow
- Create a branch from
masterusinguser/kind/description, for examplealex/fix/replay-seek. - Make one focused change. Add tests and update documentation or examples where the behavior needs them.
- Run
justfrom the repository root. It formats the workspace, runs lint and API checks, and tests the std andno_stdsurfaces. - Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
- Push your branch and open a pull request to
master. Explain the problem, the chosen approach, and how you verified it.
The pull request template contains the final submission checklist.
Checks
Prefer the root justfile over copying long Cargo command lines:
| Change | Run |
|---|---|
| Most pull requests |
just or just pr-check
|
| Formatting, typos, and clippy only | just lint |
| Workflow configuration and change classification |
just ci-config-check (requires actionlint) |
| Host/runtime behavior across the std feature matrix | just std-ci |
Shared, embedded-facing, or no_std code |
just nostd-ci |
| Coverage-sensitive behavior | just coverage |
| Runtime proc-macro expansion | just expand-runtime pkg=<crate> bin=<bin> [features=<features>] |
| SoA derive expansion | just expand-soa |
Linux is the primary full-workspace gate. macOS is also release-blocking, Windows validates a reduced core surface, and embedded coverage is compile-time rather than hardware-in-the-loop. See Supported Platforms for the public platform matrix.
Workspace checks use support/ci/workspace_excludes.py to read
package.metadata.copper. Set ci_exclude_workspace = true to exclude a package
on every runner, or ci_exclude_workspace_os = ["macos"] to exclude it on specific
runner operating systems (linux, macos, or windows). macOS checks include
the portable cu-zed payload and projection code and exclude the native ZED SDK
File truncated at 100 lines see the full file
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Repository Summary
| Description | |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-10-27 |
| 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
A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.
▶ Try Copper in your browser · Build your first app
Why Copper
| Built for robots | Built to ship |
|---|---|
| Static by design: task graphs are declared in RON and wired at compile time. | Runs anywhere: Linux, macOS, SBCs, and bare-metal microcontrollers. |
| Realtime first: zero-allocation, data-oriented execution on the hot path. | Deterministic replay: record a run, reproduce it, and inspect it offline. |
| Rust-first: ergonomic task APIs with compile-time guarantees. | Interoperable: connect to ROS 2 through Zenoh and migrate progressively. |
Already flying, driving, swimming, spacefaring, and powering humanoids.
See It Run
These are the same Copper applications used on physical robots, recompiled for the browser. The simulator runs beside a live view of the Copper task graph and latency.
BalanceBot A self-balancing robot simulation using the application that runs on Raspberry Pi hardware. Source code |
Flight Controller A quadcopter simulation using the control stack deployed on STM32H7 flight hardware. Source code |
Watch more robots built with Copper in the community showcase, or explore the cross-framework benchmarks.
Build Your First Copper App
Install the latest stable Rust toolchain, then:
cargo install cargo-cunew
cargo cunew hello_copper
cd hello_copper
cargo run
The generated app has a typed source → task → sink graph that prints its
first messages and records logs/hello-copper.copper. Start with
copperconfig.ron, src/main.rs, and src/tasks.rs; the generated justfile
also provides helpers for logs, CopperLists, topology (just graph), the exact
generated process schedule (just sched), post-execution timing from the default
Copper log (just sched-log), and replay. Host projects also include
just pgs-baseline, just pgs-optimize, just pgs-candidate, and
just pgs-measure; the starter schedule.ron is a conservative placeholder to tune
for the real workload. Project creation asks whether the target is bare metal/no_std
and omits PGS scaffolding for that choice.
How Copper Fits Together
| Stage | What happens |
|---|---|
| Declare | Define the static task graph in copperconfig.ron. |
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to Copper
Thank you for helping build a deterministic, production-ready robotics runtime. Contributions of code, components, documentation, examples, and careful bug reports are all welcome.
Choose Where to Start
| You want to… | Best next step |
|---|---|
| Ask a usage question | Search the documentation or ask on Discord. |
| Report a bug or request a feature | Open the matching issue template. |
| Propose a runtime or architectural change | Start a Discussion before investing in a large implementation. |
| Add a reusable driver, task, bridge, or payload | Read Contributing Components; an independent crate is often the best home. |
| Improve docs or examples | Open a focused pull request and update related wiki/book material when behavior and documentation move together. |
| Report a vulnerability | Follow the private process in SECURITY.md. Do not open a public issue. |
All community participation is governed by our Code of Conduct.
Set Up the Workspace
Copper’s minimum supported Rust version is 1.96. Install the latest stable Rust
toolchain with rustup, then install
just and clone your fork:
cargo install just
git clone https://github.com/YOUR_USERNAME/copper-rs.git
cd copper-rs
The Ubuntu development dependencies are documented in
support/docker/Dockerfile.ubuntu. Other
platforms may require equivalent system packages.
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Contribution Workflow
- Create a branch from
masterusinguser/kind/description, for examplealex/fix/replay-seek. - Make one focused change. Add tests and update documentation or examples where the behavior needs them.
- Run
justfrom the repository root. It formats the workspace, runs lint and API checks, and tests the std andno_stdsurfaces. - Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
- Push your branch and open a pull request to
master. Explain the problem, the chosen approach, and how you verified it.
The pull request template contains the final submission checklist.
Checks
Prefer the root justfile over copying long Cargo command lines:
| Change | Run |
|---|---|
| Most pull requests |
just or just pr-check
|
| Formatting, typos, and clippy only | just lint |
| Workflow configuration and change classification |
just ci-config-check (requires actionlint) |
| Host/runtime behavior across the std feature matrix | just std-ci |
Shared, embedded-facing, or no_std code |
just nostd-ci |
| Coverage-sensitive behavior | just coverage |
| Runtime proc-macro expansion | just expand-runtime pkg=<crate> bin=<bin> [features=<features>] |
| SoA derive expansion | just expand-soa |
Linux is the primary full-workspace gate. macOS is also release-blocking, Windows validates a reduced core surface, and embedded coverage is compile-time rather than hardware-in-the-loop. See Supported Platforms for the public platform matrix.
Workspace checks use support/ci/workspace_excludes.py to read
package.metadata.copper. Set ci_exclude_workspace = true to exclude a package
on every runner, or ci_exclude_workspace_os = ["macos"] to exclude it on specific
runner operating systems (linux, macos, or windows). macOS checks include
the portable cu-zed payload and projection code and exclude the native ZED SDK
File truncated at 100 lines see the full file
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Repository Summary
| Description | |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-10-27 |
| 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
A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.
▶ Try Copper in your browser · Build your first app
Why Copper
| Built for robots | Built to ship |
|---|---|
| Static by design: task graphs are declared in RON and wired at compile time. | Runs anywhere: Linux, macOS, SBCs, and bare-metal microcontrollers. |
| Realtime first: zero-allocation, data-oriented execution on the hot path. | Deterministic replay: record a run, reproduce it, and inspect it offline. |
| Rust-first: ergonomic task APIs with compile-time guarantees. | Interoperable: connect to ROS 2 through Zenoh and migrate progressively. |
Already flying, driving, swimming, spacefaring, and powering humanoids.
See It Run
These are the same Copper applications used on physical robots, recompiled for the browser. The simulator runs beside a live view of the Copper task graph and latency.
BalanceBot A self-balancing robot simulation using the application that runs on Raspberry Pi hardware. Source code |
Flight Controller A quadcopter simulation using the control stack deployed on STM32H7 flight hardware. Source code |
Watch more robots built with Copper in the community showcase, or explore the cross-framework benchmarks.
Build Your First Copper App
Install the latest stable Rust toolchain, then:
cargo install cargo-cunew
cargo cunew hello_copper
cd hello_copper
cargo run
The generated app has a typed source → task → sink graph that prints its
first messages and records logs/hello-copper.copper. Start with
copperconfig.ron, src/main.rs, and src/tasks.rs; the generated justfile
also provides helpers for logs, CopperLists, topology (just graph), the exact
generated process schedule (just sched), post-execution timing from the default
Copper log (just sched-log), and replay. Host projects also include
just pgs-baseline, just pgs-optimize, just pgs-candidate, and
just pgs-measure; the starter schedule.ron is a conservative placeholder to tune
for the real workload. Project creation asks whether the target is bare metal/no_std
and omits PGS scaffolding for that choice.
How Copper Fits Together
| Stage | What happens |
|---|---|
| Declare | Define the static task graph in copperconfig.ron. |
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to Copper
Thank you for helping build a deterministic, production-ready robotics runtime. Contributions of code, components, documentation, examples, and careful bug reports are all welcome.
Choose Where to Start
| You want to… | Best next step |
|---|---|
| Ask a usage question | Search the documentation or ask on Discord. |
| Report a bug or request a feature | Open the matching issue template. |
| Propose a runtime or architectural change | Start a Discussion before investing in a large implementation. |
| Add a reusable driver, task, bridge, or payload | Read Contributing Components; an independent crate is often the best home. |
| Improve docs or examples | Open a focused pull request and update related wiki/book material when behavior and documentation move together. |
| Report a vulnerability | Follow the private process in SECURITY.md. Do not open a public issue. |
All community participation is governed by our Code of Conduct.
Set Up the Workspace
Copper’s minimum supported Rust version is 1.96. Install the latest stable Rust
toolchain with rustup, then install
just and clone your fork:
cargo install just
git clone https://github.com/YOUR_USERNAME/copper-rs.git
cd copper-rs
The Ubuntu development dependencies are documented in
support/docker/Dockerfile.ubuntu. Other
platforms may require equivalent system packages.
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Contribution Workflow
- Create a branch from
masterusinguser/kind/description, for examplealex/fix/replay-seek. - Make one focused change. Add tests and update documentation or examples where the behavior needs them.
- Run
justfrom the repository root. It formats the workspace, runs lint and API checks, and tests the std andno_stdsurfaces. - Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
- Push your branch and open a pull request to
master. Explain the problem, the chosen approach, and how you verified it.
The pull request template contains the final submission checklist.
Checks
Prefer the root justfile over copying long Cargo command lines:
| Change | Run |
|---|---|
| Most pull requests |
just or just pr-check
|
| Formatting, typos, and clippy only | just lint |
| Workflow configuration and change classification |
just ci-config-check (requires actionlint) |
| Host/runtime behavior across the std feature matrix | just std-ci |
Shared, embedded-facing, or no_std code |
just nostd-ci |
| Coverage-sensitive behavior | just coverage |
| Runtime proc-macro expansion | just expand-runtime pkg=<crate> bin=<bin> [features=<features>] |
| SoA derive expansion | just expand-soa |
Linux is the primary full-workspace gate. macOS is also release-blocking, Windows validates a reduced core surface, and embedded coverage is compile-time rather than hardware-in-the-loop. See Supported Platforms for the public platform matrix.
Workspace checks use support/ci/workspace_excludes.py to read
package.metadata.copper. Set ci_exclude_workspace = true to exclude a package
on every runner, or ci_exclude_workspace_os = ["macos"] to exclude it on specific
runner operating systems (linux, macos, or windows). macOS checks include
the portable cu-zed payload and projection code and exclude the native ZED SDK
File truncated at 100 lines see the full file
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Repository Summary
| Description | |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-10-27 |
| 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
A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.
▶ Try Copper in your browser · Build your first app
Why Copper
| Built for robots | Built to ship |
|---|---|
| Static by design: task graphs are declared in RON and wired at compile time. | Runs anywhere: Linux, macOS, SBCs, and bare-metal microcontrollers. |
| Realtime first: zero-allocation, data-oriented execution on the hot path. | Deterministic replay: record a run, reproduce it, and inspect it offline. |
| Rust-first: ergonomic task APIs with compile-time guarantees. | Interoperable: connect to ROS 2 through Zenoh and migrate progressively. |
Already flying, driving, swimming, spacefaring, and powering humanoids.
See It Run
These are the same Copper applications used on physical robots, recompiled for the browser. The simulator runs beside a live view of the Copper task graph and latency.
BalanceBot A self-balancing robot simulation using the application that runs on Raspberry Pi hardware. Source code |
Flight Controller A quadcopter simulation using the control stack deployed on STM32H7 flight hardware. Source code |
Watch more robots built with Copper in the community showcase, or explore the cross-framework benchmarks.
Build Your First Copper App
Install the latest stable Rust toolchain, then:
cargo install cargo-cunew
cargo cunew hello_copper
cd hello_copper
cargo run
The generated app has a typed source → task → sink graph that prints its
first messages and records logs/hello-copper.copper. Start with
copperconfig.ron, src/main.rs, and src/tasks.rs; the generated justfile
also provides helpers for logs, CopperLists, topology (just graph), the exact
generated process schedule (just sched), post-execution timing from the default
Copper log (just sched-log), and replay. Host projects also include
just pgs-baseline, just pgs-optimize, just pgs-candidate, and
just pgs-measure; the starter schedule.ron is a conservative placeholder to tune
for the real workload. Project creation asks whether the target is bare metal/no_std
and omits PGS scaffolding for that choice.
How Copper Fits Together
| Stage | What happens |
|---|---|
| Declare | Define the static task graph in copperconfig.ron. |
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to Copper
Thank you for helping build a deterministic, production-ready robotics runtime. Contributions of code, components, documentation, examples, and careful bug reports are all welcome.
Choose Where to Start
| You want to… | Best next step |
|---|---|
| Ask a usage question | Search the documentation or ask on Discord. |
| Report a bug or request a feature | Open the matching issue template. |
| Propose a runtime or architectural change | Start a Discussion before investing in a large implementation. |
| Add a reusable driver, task, bridge, or payload | Read Contributing Components; an independent crate is often the best home. |
| Improve docs or examples | Open a focused pull request and update related wiki/book material when behavior and documentation move together. |
| Report a vulnerability | Follow the private process in SECURITY.md. Do not open a public issue. |
All community participation is governed by our Code of Conduct.
Set Up the Workspace
Copper’s minimum supported Rust version is 1.96. Install the latest stable Rust
toolchain with rustup, then install
just and clone your fork:
cargo install just
git clone https://github.com/YOUR_USERNAME/copper-rs.git
cd copper-rs
The Ubuntu development dependencies are documented in
support/docker/Dockerfile.ubuntu. Other
platforms may require equivalent system packages.
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Contribution Workflow
- Create a branch from
masterusinguser/kind/description, for examplealex/fix/replay-seek. - Make one focused change. Add tests and update documentation or examples where the behavior needs them.
- Run
justfrom the repository root. It formats the workspace, runs lint and API checks, and tests the std andno_stdsurfaces. - Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
- Push your branch and open a pull request to
master. Explain the problem, the chosen approach, and how you verified it.
The pull request template contains the final submission checklist.
Checks
Prefer the root justfile over copying long Cargo command lines:
| Change | Run |
|---|---|
| Most pull requests |
just or just pr-check
|
| Formatting, typos, and clippy only | just lint |
| Workflow configuration and change classification |
just ci-config-check (requires actionlint) |
| Host/runtime behavior across the std feature matrix | just std-ci |
Shared, embedded-facing, or no_std code |
just nostd-ci |
| Coverage-sensitive behavior | just coverage |
| Runtime proc-macro expansion | just expand-runtime pkg=<crate> bin=<bin> [features=<features>] |
| SoA derive expansion | just expand-soa |
Linux is the primary full-workspace gate. macOS is also release-blocking, Windows validates a reduced core surface, and embedded coverage is compile-time rather than hardware-in-the-loop. See Supported Platforms for the public platform matrix.
Workspace checks use support/ci/workspace_excludes.py to read
package.metadata.copper. Set ci_exclude_workspace = true to exclude a package
on every runner, or ci_exclude_workspace_os = ["macos"] to exclude it on specific
runner operating systems (linux, macos, or windows). macOS checks include
the portable cu-zed payload and projection code and exclude the native ZED SDK
File truncated at 100 lines see the full file
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Repository Summary
| Description | |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-10-27 |
| 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
A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.
▶ Try Copper in your browser · Build your first app
Why Copper
| Built for robots | Built to ship |
|---|---|
| Static by design: task graphs are declared in RON and wired at compile time. | Runs anywhere: Linux, macOS, SBCs, and bare-metal microcontrollers. |
| Realtime first: zero-allocation, data-oriented execution on the hot path. | Deterministic replay: record a run, reproduce it, and inspect it offline. |
| Rust-first: ergonomic task APIs with compile-time guarantees. | Interoperable: connect to ROS 2 through Zenoh and migrate progressively. |
Already flying, driving, swimming, spacefaring, and powering humanoids.
See It Run
These are the same Copper applications used on physical robots, recompiled for the browser. The simulator runs beside a live view of the Copper task graph and latency.
BalanceBot A self-balancing robot simulation using the application that runs on Raspberry Pi hardware. Source code |
Flight Controller A quadcopter simulation using the control stack deployed on STM32H7 flight hardware. Source code |
Watch more robots built with Copper in the community showcase, or explore the cross-framework benchmarks.
Build Your First Copper App
Install the latest stable Rust toolchain, then:
cargo install cargo-cunew
cargo cunew hello_copper
cd hello_copper
cargo run
The generated app has a typed source → task → sink graph that prints its
first messages and records logs/hello-copper.copper. Start with
copperconfig.ron, src/main.rs, and src/tasks.rs; the generated justfile
also provides helpers for logs, CopperLists, topology (just graph), the exact
generated process schedule (just sched), post-execution timing from the default
Copper log (just sched-log), and replay. Host projects also include
just pgs-baseline, just pgs-optimize, just pgs-candidate, and
just pgs-measure; the starter schedule.ron is a conservative placeholder to tune
for the real workload. Project creation asks whether the target is bare metal/no_std
and omits PGS scaffolding for that choice.
How Copper Fits Together
| Stage | What happens |
|---|---|
| Declare | Define the static task graph in copperconfig.ron. |
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to Copper
Thank you for helping build a deterministic, production-ready robotics runtime. Contributions of code, components, documentation, examples, and careful bug reports are all welcome.
Choose Where to Start
| You want to… | Best next step |
|---|---|
| Ask a usage question | Search the documentation or ask on Discord. |
| Report a bug or request a feature | Open the matching issue template. |
| Propose a runtime or architectural change | Start a Discussion before investing in a large implementation. |
| Add a reusable driver, task, bridge, or payload | Read Contributing Components; an independent crate is often the best home. |
| Improve docs or examples | Open a focused pull request and update related wiki/book material when behavior and documentation move together. |
| Report a vulnerability | Follow the private process in SECURITY.md. Do not open a public issue. |
All community participation is governed by our Code of Conduct.
Set Up the Workspace
Copper’s minimum supported Rust version is 1.96. Install the latest stable Rust
toolchain with rustup, then install
just and clone your fork:
cargo install just
git clone https://github.com/YOUR_USERNAME/copper-rs.git
cd copper-rs
The Ubuntu development dependencies are documented in
support/docker/Dockerfile.ubuntu. Other
platforms may require equivalent system packages.
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Contribution Workflow
- Create a branch from
masterusinguser/kind/description, for examplealex/fix/replay-seek. - Make one focused change. Add tests and update documentation or examples where the behavior needs them.
- Run
justfrom the repository root. It formats the workspace, runs lint and API checks, and tests the std andno_stdsurfaces. - Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
- Push your branch and open a pull request to
master. Explain the problem, the chosen approach, and how you verified it.
The pull request template contains the final submission checklist.
Checks
Prefer the root justfile over copying long Cargo command lines:
| Change | Run |
|---|---|
| Most pull requests |
just or just pr-check
|
| Formatting, typos, and clippy only | just lint |
| Workflow configuration and change classification |
just ci-config-check (requires actionlint) |
| Host/runtime behavior across the std feature matrix | just std-ci |
Shared, embedded-facing, or no_std code |
just nostd-ci |
| Coverage-sensitive behavior | just coverage |
| Runtime proc-macro expansion | just expand-runtime pkg=<crate> bin=<bin> [features=<features>] |
| SoA derive expansion | just expand-soa |
Linux is the primary full-workspace gate. macOS is also release-blocking, Windows validates a reduced core surface, and embedded coverage is compile-time rather than hardware-in-the-loop. See Supported Platforms for the public platform matrix.
Workspace checks use support/ci/workspace_excludes.py to read
package.metadata.copper. Set ci_exclude_workspace = true to exclude a package
on every runner, or ci_exclude_workspace_os = ["macos"] to exclude it on specific
runner operating systems (linux, macos, or windows). macOS checks include
the portable cu-zed payload and projection code and exclude the native ZED SDK
File truncated at 100 lines see the full file
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Repository Summary
| Description | |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-10-27 |
| 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
A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.
▶ Try Copper in your browser · Build your first app
Why Copper
| Built for robots | Built to ship |
|---|---|
| Static by design: task graphs are declared in RON and wired at compile time. | Runs anywhere: Linux, macOS, SBCs, and bare-metal microcontrollers. |
| Realtime first: zero-allocation, data-oriented execution on the hot path. | Deterministic replay: record a run, reproduce it, and inspect it offline. |
| Rust-first: ergonomic task APIs with compile-time guarantees. | Interoperable: connect to ROS 2 through Zenoh and migrate progressively. |
Already flying, driving, swimming, spacefaring, and powering humanoids.
See It Run
These are the same Copper applications used on physical robots, recompiled for the browser. The simulator runs beside a live view of the Copper task graph and latency.
BalanceBot A self-balancing robot simulation using the application that runs on Raspberry Pi hardware. Source code |
Flight Controller A quadcopter simulation using the control stack deployed on STM32H7 flight hardware. Source code |
Watch more robots built with Copper in the community showcase, or explore the cross-framework benchmarks.
Build Your First Copper App
Install the latest stable Rust toolchain, then:
cargo install cargo-cunew
cargo cunew hello_copper
cd hello_copper
cargo run
The generated app has a typed source → task → sink graph that prints its
first messages and records logs/hello-copper.copper. Start with
copperconfig.ron, src/main.rs, and src/tasks.rs; the generated justfile
also provides helpers for logs, CopperLists, topology (just graph), the exact
generated process schedule (just sched), post-execution timing from the default
Copper log (just sched-log), and replay. Host projects also include
just pgs-baseline, just pgs-optimize, just pgs-candidate, and
just pgs-measure; the starter schedule.ron is a conservative placeholder to tune
for the real workload. Project creation asks whether the target is bare metal/no_std
and omits PGS scaffolding for that choice.
How Copper Fits Together
| Stage | What happens |
|---|---|
| Declare | Define the static task graph in copperconfig.ron. |
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to Copper
Thank you for helping build a deterministic, production-ready robotics runtime. Contributions of code, components, documentation, examples, and careful bug reports are all welcome.
Choose Where to Start
| You want to… | Best next step |
|---|---|
| Ask a usage question | Search the documentation or ask on Discord. |
| Report a bug or request a feature | Open the matching issue template. |
| Propose a runtime or architectural change | Start a Discussion before investing in a large implementation. |
| Add a reusable driver, task, bridge, or payload | Read Contributing Components; an independent crate is often the best home. |
| Improve docs or examples | Open a focused pull request and update related wiki/book material when behavior and documentation move together. |
| Report a vulnerability | Follow the private process in SECURITY.md. Do not open a public issue. |
All community participation is governed by our Code of Conduct.
Set Up the Workspace
Copper’s minimum supported Rust version is 1.96. Install the latest stable Rust
toolchain with rustup, then install
just and clone your fork:
cargo install just
git clone https://github.com/YOUR_USERNAME/copper-rs.git
cd copper-rs
The Ubuntu development dependencies are documented in
support/docker/Dockerfile.ubuntu. Other
platforms may require equivalent system packages.
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Contribution Workflow
- Create a branch from
masterusinguser/kind/description, for examplealex/fix/replay-seek. - Make one focused change. Add tests and update documentation or examples where the behavior needs them.
- Run
justfrom the repository root. It formats the workspace, runs lint and API checks, and tests the std andno_stdsurfaces. - Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
- Push your branch and open a pull request to
master. Explain the problem, the chosen approach, and how you verified it.
The pull request template contains the final submission checklist.
Checks
Prefer the root justfile over copying long Cargo command lines:
| Change | Run |
|---|---|
| Most pull requests |
just or just pr-check
|
| Formatting, typos, and clippy only | just lint |
| Workflow configuration and change classification |
just ci-config-check (requires actionlint) |
| Host/runtime behavior across the std feature matrix | just std-ci |
Shared, embedded-facing, or no_std code |
just nostd-ci |
| Coverage-sensitive behavior | just coverage |
| Runtime proc-macro expansion | just expand-runtime pkg=<crate> bin=<bin> [features=<features>] |
| SoA derive expansion | just expand-soa |
Linux is the primary full-workspace gate. macOS is also release-blocking, Windows validates a reduced core surface, and embedded coverage is compile-time rather than hardware-in-the-loop. See Supported Platforms for the public platform matrix.
Workspace checks use support/ci/workspace_excludes.py to read
package.metadata.copper. Set ci_exclude_workspace = true to exclude a package
on every runner, or ci_exclude_workspace_os = ["macos"] to exclude it on specific
runner operating systems (linux, macos, or windows). macOS checks include
the portable cu-zed payload and projection code and exclude the native ZED SDK
File truncated at 100 lines see the full file
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Repository Summary
| Description | |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-10-27 |
| 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
A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.
▶ Try Copper in your browser · Build your first app
Why Copper
| Built for robots | Built to ship |
|---|---|
| Static by design: task graphs are declared in RON and wired at compile time. | Runs anywhere: Linux, macOS, SBCs, and bare-metal microcontrollers. |
| Realtime first: zero-allocation, data-oriented execution on the hot path. | Deterministic replay: record a run, reproduce it, and inspect it offline. |
| Rust-first: ergonomic task APIs with compile-time guarantees. | Interoperable: connect to ROS 2 through Zenoh and migrate progressively. |
Already flying, driving, swimming, spacefaring, and powering humanoids.
See It Run
These are the same Copper applications used on physical robots, recompiled for the browser. The simulator runs beside a live view of the Copper task graph and latency.
BalanceBot A self-balancing robot simulation using the application that runs on Raspberry Pi hardware. Source code |
Flight Controller A quadcopter simulation using the control stack deployed on STM32H7 flight hardware. Source code |
Watch more robots built with Copper in the community showcase, or explore the cross-framework benchmarks.
Build Your First Copper App
Install the latest stable Rust toolchain, then:
cargo install cargo-cunew
cargo cunew hello_copper
cd hello_copper
cargo run
The generated app has a typed source → task → sink graph that prints its
first messages and records logs/hello-copper.copper. Start with
copperconfig.ron, src/main.rs, and src/tasks.rs; the generated justfile
also provides helpers for logs, CopperLists, topology (just graph), the exact
generated process schedule (just sched), post-execution timing from the default
Copper log (just sched-log), and replay. Host projects also include
just pgs-baseline, just pgs-optimize, just pgs-candidate, and
just pgs-measure; the starter schedule.ron is a conservative placeholder to tune
for the real workload. Project creation asks whether the target is bare metal/no_std
and omits PGS scaffolding for that choice.
How Copper Fits Together
| Stage | What happens |
|---|---|
| Declare | Define the static task graph in copperconfig.ron. |
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to Copper
Thank you for helping build a deterministic, production-ready robotics runtime. Contributions of code, components, documentation, examples, and careful bug reports are all welcome.
Choose Where to Start
| You want to… | Best next step |
|---|---|
| Ask a usage question | Search the documentation or ask on Discord. |
| Report a bug or request a feature | Open the matching issue template. |
| Propose a runtime or architectural change | Start a Discussion before investing in a large implementation. |
| Add a reusable driver, task, bridge, or payload | Read Contributing Components; an independent crate is often the best home. |
| Improve docs or examples | Open a focused pull request and update related wiki/book material when behavior and documentation move together. |
| Report a vulnerability | Follow the private process in SECURITY.md. Do not open a public issue. |
All community participation is governed by our Code of Conduct.
Set Up the Workspace
Copper’s minimum supported Rust version is 1.96. Install the latest stable Rust
toolchain with rustup, then install
just and clone your fork:
cargo install just
git clone https://github.com/YOUR_USERNAME/copper-rs.git
cd copper-rs
The Ubuntu development dependencies are documented in
support/docker/Dockerfile.ubuntu. Other
platforms may require equivalent system packages.
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Contribution Workflow
- Create a branch from
masterusinguser/kind/description, for examplealex/fix/replay-seek. - Make one focused change. Add tests and update documentation or examples where the behavior needs them.
- Run
justfrom the repository root. It formats the workspace, runs lint and API checks, and tests the std andno_stdsurfaces. - Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
- Push your branch and open a pull request to
master. Explain the problem, the chosen approach, and how you verified it.
The pull request template contains the final submission checklist.
Checks
Prefer the root justfile over copying long Cargo command lines:
| Change | Run |
|---|---|
| Most pull requests |
just or just pr-check
|
| Formatting, typos, and clippy only | just lint |
| Workflow configuration and change classification |
just ci-config-check (requires actionlint) |
| Host/runtime behavior across the std feature matrix | just std-ci |
Shared, embedded-facing, or no_std code |
just nostd-ci |
| Coverage-sensitive behavior | just coverage |
| Runtime proc-macro expansion | just expand-runtime pkg=<crate> bin=<bin> [features=<features>] |
| SoA derive expansion | just expand-soa |
Linux is the primary full-workspace gate. macOS is also release-blocking, Windows validates a reduced core surface, and embedded coverage is compile-time rather than hardware-in-the-loop. See Supported Platforms for the public platform matrix.
Workspace checks use support/ci/workspace_excludes.py to read
package.metadata.copper. Set ci_exclude_workspace = true to exclude a package
on every runner, or ci_exclude_workspace_os = ["macos"] to exclude it on specific
runner operating systems (linux, macos, or windows). macOS checks include
the portable cu-zed payload and projection code and exclude the native ZED SDK
File truncated at 100 lines see the full file
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Repository Summary
| Description | |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-10-27 |
| 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
A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.
▶ Try Copper in your browser · Build your first app
Why Copper
| Built for robots | Built to ship |
|---|---|
| Static by design: task graphs are declared in RON and wired at compile time. | Runs anywhere: Linux, macOS, SBCs, and bare-metal microcontrollers. |
| Realtime first: zero-allocation, data-oriented execution on the hot path. | Deterministic replay: record a run, reproduce it, and inspect it offline. |
| Rust-first: ergonomic task APIs with compile-time guarantees. | Interoperable: connect to ROS 2 through Zenoh and migrate progressively. |
Already flying, driving, swimming, spacefaring, and powering humanoids.
See It Run
These are the same Copper applications used on physical robots, recompiled for the browser. The simulator runs beside a live view of the Copper task graph and latency.
BalanceBot A self-balancing robot simulation using the application that runs on Raspberry Pi hardware. Source code |
Flight Controller A quadcopter simulation using the control stack deployed on STM32H7 flight hardware. Source code |
Watch more robots built with Copper in the community showcase, or explore the cross-framework benchmarks.
Build Your First Copper App
Install the latest stable Rust toolchain, then:
cargo install cargo-cunew
cargo cunew hello_copper
cd hello_copper
cargo run
The generated app has a typed source → task → sink graph that prints its
first messages and records logs/hello-copper.copper. Start with
copperconfig.ron, src/main.rs, and src/tasks.rs; the generated justfile
also provides helpers for logs, CopperLists, topology (just graph), the exact
generated process schedule (just sched), post-execution timing from the default
Copper log (just sched-log), and replay. Host projects also include
just pgs-baseline, just pgs-optimize, just pgs-candidate, and
just pgs-measure; the starter schedule.ron is a conservative placeholder to tune
for the real workload. Project creation asks whether the target is bare metal/no_std
and omits PGS scaffolding for that choice.
How Copper Fits Together
| Stage | What happens |
|---|---|
| Declare | Define the static task graph in copperconfig.ron. |
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to Copper
Thank you for helping build a deterministic, production-ready robotics runtime. Contributions of code, components, documentation, examples, and careful bug reports are all welcome.
Choose Where to Start
| You want to… | Best next step |
|---|---|
| Ask a usage question | Search the documentation or ask on Discord. |
| Report a bug or request a feature | Open the matching issue template. |
| Propose a runtime or architectural change | Start a Discussion before investing in a large implementation. |
| Add a reusable driver, task, bridge, or payload | Read Contributing Components; an independent crate is often the best home. |
| Improve docs or examples | Open a focused pull request and update related wiki/book material when behavior and documentation move together. |
| Report a vulnerability | Follow the private process in SECURITY.md. Do not open a public issue. |
All community participation is governed by our Code of Conduct.
Set Up the Workspace
Copper’s minimum supported Rust version is 1.96. Install the latest stable Rust
toolchain with rustup, then install
just and clone your fork:
cargo install just
git clone https://github.com/YOUR_USERNAME/copper-rs.git
cd copper-rs
The Ubuntu development dependencies are documented in
support/docker/Dockerfile.ubuntu. Other
platforms may require equivalent system packages.
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Contribution Workflow
- Create a branch from
masterusinguser/kind/description, for examplealex/fix/replay-seek. - Make one focused change. Add tests and update documentation or examples where the behavior needs them.
- Run
justfrom the repository root. It formats the workspace, runs lint and API checks, and tests the std andno_stdsurfaces. - Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
- Push your branch and open a pull request to
master. Explain the problem, the chosen approach, and how you verified it.
The pull request template contains the final submission checklist.
Checks
Prefer the root justfile over copying long Cargo command lines:
| Change | Run |
|---|---|
| Most pull requests |
just or just pr-check
|
| Formatting, typos, and clippy only | just lint |
| Workflow configuration and change classification |
just ci-config-check (requires actionlint) |
| Host/runtime behavior across the std feature matrix | just std-ci |
Shared, embedded-facing, or no_std code |
just nostd-ci |
| Coverage-sensitive behavior | just coverage |
| Runtime proc-macro expansion | just expand-runtime pkg=<crate> bin=<bin> [features=<features>] |
| SoA derive expansion | just expand-soa |
Linux is the primary full-workspace gate. macOS is also release-blocking, Windows validates a reduced core surface, and embedded coverage is compile-time rather than hardware-in-the-loop. See Supported Platforms for the public platform matrix.
Workspace checks use support/ci/workspace_excludes.py to read
package.metadata.copper. Set ci_exclude_workspace = true to exclude a package
on every runner, or ci_exclude_workspace_os = ["macos"] to exclude it on specific
runner operating systems (linux, macos, or windows). macOS checks include
the portable cu-zed payload and projection code and exclude the native ZED SDK
File truncated at 100 lines see the full file
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Repository Summary
| Description | |
| Checkout URI | https://github.com/copper-project/copper-rs.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-10-27 |
| 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
A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.
▶ Try Copper in your browser · Build your first app
Why Copper
| Built for robots | Built to ship |
|---|---|
| Static by design: task graphs are declared in RON and wired at compile time. | Runs anywhere: Linux, macOS, SBCs, and bare-metal microcontrollers. |
| Realtime first: zero-allocation, data-oriented execution on the hot path. | Deterministic replay: record a run, reproduce it, and inspect it offline. |
| Rust-first: ergonomic task APIs with compile-time guarantees. | Interoperable: connect to ROS 2 through Zenoh and migrate progressively. |
Already flying, driving, swimming, spacefaring, and powering humanoids.
See It Run
These are the same Copper applications used on physical robots, recompiled for the browser. The simulator runs beside a live view of the Copper task graph and latency.
BalanceBot A self-balancing robot simulation using the application that runs on Raspberry Pi hardware. Source code |
Flight Controller A quadcopter simulation using the control stack deployed on STM32H7 flight hardware. Source code |
Watch more robots built with Copper in the community showcase, or explore the cross-framework benchmarks.
Build Your First Copper App
Install the latest stable Rust toolchain, then:
cargo install cargo-cunew
cargo cunew hello_copper
cd hello_copper
cargo run
The generated app has a typed source → task → sink graph that prints its
first messages and records logs/hello-copper.copper. Start with
copperconfig.ron, src/main.rs, and src/tasks.rs; the generated justfile
also provides helpers for logs, CopperLists, topology (just graph), the exact
generated process schedule (just sched), post-execution timing from the default
Copper log (just sched-log), and replay. Host projects also include
just pgs-baseline, just pgs-optimize, just pgs-candidate, and
just pgs-measure; the starter schedule.ron is a conservative placeholder to tune
for the real workload. Project creation asks whether the target is bare metal/no_std
and omits PGS scaffolding for that choice.
How Copper Fits Together
| Stage | What happens |
|---|---|
| Declare | Define the static task graph in copperconfig.ron. |
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to Copper
Thank you for helping build a deterministic, production-ready robotics runtime. Contributions of code, components, documentation, examples, and careful bug reports are all welcome.
Choose Where to Start
| You want to… | Best next step |
|---|---|
| Ask a usage question | Search the documentation or ask on Discord. |
| Report a bug or request a feature | Open the matching issue template. |
| Propose a runtime or architectural change | Start a Discussion before investing in a large implementation. |
| Add a reusable driver, task, bridge, or payload | Read Contributing Components; an independent crate is often the best home. |
| Improve docs or examples | Open a focused pull request and update related wiki/book material when behavior and documentation move together. |
| Report a vulnerability | Follow the private process in SECURITY.md. Do not open a public issue. |
All community participation is governed by our Code of Conduct.
Set Up the Workspace
Copper’s minimum supported Rust version is 1.96. Install the latest stable Rust
toolchain with rustup, then install
just and clone your fork:
cargo install just
git clone https://github.com/YOUR_USERNAME/copper-rs.git
cd copper-rs
The Ubuntu development dependencies are documented in
support/docker/Dockerfile.ubuntu. Other
platforms may require equivalent system packages.
One-time tools used by the full PR check
The root `justfile` is the source of truth. Its checks use `cargo-nextest`, `typos-cli`, `taplo-cli`, `fmtron`, and `prek`: ```bash cargo install --locked cargo-nextest typos-cli taplo-cli fmtron prek ``` The public API check also pins a nightly toolchain and `cargo-public-api` version. Run `just api-check`; if either is missing, it prints the exact versioned install command required by the current repository. Coverage additionally requires `cargo-llvm-cov` and `llvm-tools-preview`: ```bash cargo install --locked cargo-llvm-cov rustup component add llvm-tools-preview --toolchain stable ```Contribution Workflow
- Create a branch from
masterusinguser/kind/description, for examplealex/fix/replay-seek. - Make one focused change. Add tests and update documentation or examples where the behavior needs them.
- Run
justfrom the repository root. It formats the workspace, runs lint and API checks, and tests the std andno_stdsurfaces. - Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
- Push your branch and open a pull request to
master. Explain the problem, the chosen approach, and how you verified it.
The pull request template contains the final submission checklist.
Checks
Prefer the root justfile over copying long Cargo command lines:
| Change | Run |
|---|---|
| Most pull requests |
just or just pr-check
|
| Formatting, typos, and clippy only | just lint |
| Workflow configuration and change classification |
just ci-config-check (requires actionlint) |
| Host/runtime behavior across the std feature matrix | just std-ci |
Shared, embedded-facing, or no_std code |
just nostd-ci |
| Coverage-sensitive behavior | just coverage |
| Runtime proc-macro expansion | just expand-runtime pkg=<crate> bin=<bin> [features=<features>] |
| SoA derive expansion | just expand-soa |
Linux is the primary full-workspace gate. macOS is also release-blocking, Windows validates a reduced core surface, and embedded coverage is compile-time rather than hardware-in-the-loop. See Supported Platforms for the public platform matrix.
Workspace checks use support/ci/workspace_excludes.py to read
package.metadata.copper. Set ci_exclude_workspace = true to exclude a package
on every runner, or ci_exclude_workspace_os = ["macos"] to exclude it on specific
runner operating systems (linux, macos, or windows). macOS checks include
the portable cu-zed payload and projection code and exclude the native ZED SDK
File truncated at 100 lines see the full file