No version for distro humble showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

copper-rs repository

gpio_caterpillar

ROS Distro
github

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 logo
Copper Runtime & SDK

A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.

CI/CD status cu29 on crates.io Rust 1.96 or newer Read the Copper book Copper documentation Copper release notes Copper Discord

▶ 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 browser demo
BalanceBot
A self-balancing robot simulation using the application that runs on Raspberry Pi hardware.
Source code
Flight controller browser demo
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

  1. Create a branch from master using user/kind/description, for example alex/fix/replay-seek.
  2. Make one focused change. Add tests and update documentation or examples where the behavior needs them.
  3. Run just from the repository root. It formats the workspace, runs lint and API checks, and tests the std and no_std surfaces.
  4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
  5. 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

# 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](https://copper-project.github.io/copper-rs/) or ask on [Discord](https://discord.gg/VkCG7Sb9Kw). | | Report a bug or request a feature | Open the matching [issue template](https://github.com/copper-project/copper-rs/issues/new/choose). | | Propose a runtime or architectural change | Start a [Discussion](https://github.com/copper-project/copper-rs/discussions) before investing in a large implementation. | | Add a reusable driver, task, bridge, or payload | Read [Contributing Components](#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](SECURITY.md). Do not open a public issue. | All community participation is governed by our [Code of Conduct](CODE_OF_CONDUCT.md). ## Set Up the Workspace Copper's minimum supported Rust version is 1.96. Install the latest stable Rust toolchain with [rustup](https://rustup.rs/), then install [`just`](https://just.systems/) and clone your fork: ```bash 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`](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 1. Create a branch from `master` using `user/kind/description`, for example `alex/fix/replay-seek`. 2. Make one focused change. Add tests and update documentation or examples where the behavior needs them. 3. Run `just` from the repository root. It formats the workspace, runs lint and API checks, and tests the std and `no_std` surfaces. 4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required. 5. 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= bin= [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](https://copper-project.github.io/copper-rs/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](https://github.com/copper-project/copper-rs/tree/master/CONTRIBUTING.md)
No version for distro jazzy showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

copper-rs repository

gpio_caterpillar

ROS Distro
github

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 logo
Copper Runtime & SDK

A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.

CI/CD status cu29 on crates.io Rust 1.96 or newer Read the Copper book Copper documentation Copper release notes Copper Discord

▶ 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 browser demo
BalanceBot
A self-balancing robot simulation using the application that runs on Raspberry Pi hardware.
Source code
Flight controller browser demo
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

  1. Create a branch from master using user/kind/description, for example alex/fix/replay-seek.
  2. Make one focused change. Add tests and update documentation or examples where the behavior needs them.
  3. Run just from the repository root. It formats the workspace, runs lint and API checks, and tests the std and no_std surfaces.
  4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
  5. 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

# 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](https://copper-project.github.io/copper-rs/) or ask on [Discord](https://discord.gg/VkCG7Sb9Kw). | | Report a bug or request a feature | Open the matching [issue template](https://github.com/copper-project/copper-rs/issues/new/choose). | | Propose a runtime or architectural change | Start a [Discussion](https://github.com/copper-project/copper-rs/discussions) before investing in a large implementation. | | Add a reusable driver, task, bridge, or payload | Read [Contributing Components](#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](SECURITY.md). Do not open a public issue. | All community participation is governed by our [Code of Conduct](CODE_OF_CONDUCT.md). ## Set Up the Workspace Copper's minimum supported Rust version is 1.96. Install the latest stable Rust toolchain with [rustup](https://rustup.rs/), then install [`just`](https://just.systems/) and clone your fork: ```bash 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`](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 1. Create a branch from `master` using `user/kind/description`, for example `alex/fix/replay-seek`. 2. Make one focused change. Add tests and update documentation or examples where the behavior needs them. 3. Run `just` from the repository root. It formats the workspace, runs lint and API checks, and tests the std and `no_std` surfaces. 4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required. 5. 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= bin= [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](https://copper-project.github.io/copper-rs/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](https://github.com/copper-project/copper-rs/tree/master/CONTRIBUTING.md)
No version for distro kilted showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

copper-rs repository

gpio_caterpillar

ROS Distro
github

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 logo
Copper Runtime & SDK

A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.

CI/CD status cu29 on crates.io Rust 1.96 or newer Read the Copper book Copper documentation Copper release notes Copper Discord

▶ 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 browser demo
BalanceBot
A self-balancing robot simulation using the application that runs on Raspberry Pi hardware.
Source code
Flight controller browser demo
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

  1. Create a branch from master using user/kind/description, for example alex/fix/replay-seek.
  2. Make one focused change. Add tests and update documentation or examples where the behavior needs them.
  3. Run just from the repository root. It formats the workspace, runs lint and API checks, and tests the std and no_std surfaces.
  4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
  5. 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

# 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](https://copper-project.github.io/copper-rs/) or ask on [Discord](https://discord.gg/VkCG7Sb9Kw). | | Report a bug or request a feature | Open the matching [issue template](https://github.com/copper-project/copper-rs/issues/new/choose). | | Propose a runtime or architectural change | Start a [Discussion](https://github.com/copper-project/copper-rs/discussions) before investing in a large implementation. | | Add a reusable driver, task, bridge, or payload | Read [Contributing Components](#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](SECURITY.md). Do not open a public issue. | All community participation is governed by our [Code of Conduct](CODE_OF_CONDUCT.md). ## Set Up the Workspace Copper's minimum supported Rust version is 1.96. Install the latest stable Rust toolchain with [rustup](https://rustup.rs/), then install [`just`](https://just.systems/) and clone your fork: ```bash 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`](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 1. Create a branch from `master` using `user/kind/description`, for example `alex/fix/replay-seek`. 2. Make one focused change. Add tests and update documentation or examples where the behavior needs them. 3. Run `just` from the repository root. It formats the workspace, runs lint and API checks, and tests the std and `no_std` surfaces. 4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required. 5. 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= bin= [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](https://copper-project.github.io/copper-rs/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](https://github.com/copper-project/copper-rs/tree/master/CONTRIBUTING.md)
No version for distro lyrical showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

copper-rs repository

gpio_caterpillar

ROS Distro
github

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 logo
Copper Runtime & SDK

A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.

CI/CD status cu29 on crates.io Rust 1.96 or newer Read the Copper book Copper documentation Copper release notes Copper Discord

▶ 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 browser demo
BalanceBot
A self-balancing robot simulation using the application that runs on Raspberry Pi hardware.
Source code
Flight controller browser demo
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

  1. Create a branch from master using user/kind/description, for example alex/fix/replay-seek.
  2. Make one focused change. Add tests and update documentation or examples where the behavior needs them.
  3. Run just from the repository root. It formats the workspace, runs lint and API checks, and tests the std and no_std surfaces.
  4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
  5. 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

# 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](https://copper-project.github.io/copper-rs/) or ask on [Discord](https://discord.gg/VkCG7Sb9Kw). | | Report a bug or request a feature | Open the matching [issue template](https://github.com/copper-project/copper-rs/issues/new/choose). | | Propose a runtime or architectural change | Start a [Discussion](https://github.com/copper-project/copper-rs/discussions) before investing in a large implementation. | | Add a reusable driver, task, bridge, or payload | Read [Contributing Components](#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](SECURITY.md). Do not open a public issue. | All community participation is governed by our [Code of Conduct](CODE_OF_CONDUCT.md). ## Set Up the Workspace Copper's minimum supported Rust version is 1.96. Install the latest stable Rust toolchain with [rustup](https://rustup.rs/), then install [`just`](https://just.systems/) and clone your fork: ```bash 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`](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 1. Create a branch from `master` using `user/kind/description`, for example `alex/fix/replay-seek`. 2. Make one focused change. Add tests and update documentation or examples where the behavior needs them. 3. Run `just` from the repository root. It formats the workspace, runs lint and API checks, and tests the std and `no_std` surfaces. 4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required. 5. 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= bin= [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](https://copper-project.github.io/copper-rs/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](https://github.com/copper-project/copper-rs/tree/master/CONTRIBUTING.md)
No version for distro rolling showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

copper-rs repository

gpio_caterpillar

ROS Distro
github

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 logo
Copper Runtime & SDK

A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.

CI/CD status cu29 on crates.io Rust 1.96 or newer Read the Copper book Copper documentation Copper release notes Copper Discord

▶ 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 browser demo
BalanceBot
A self-balancing robot simulation using the application that runs on Raspberry Pi hardware.
Source code
Flight controller browser demo
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

  1. Create a branch from master using user/kind/description, for example alex/fix/replay-seek.
  2. Make one focused change. Add tests and update documentation or examples where the behavior needs them.
  3. Run just from the repository root. It formats the workspace, runs lint and API checks, and tests the std and no_std surfaces.
  4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
  5. 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

# 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](https://copper-project.github.io/copper-rs/) or ask on [Discord](https://discord.gg/VkCG7Sb9Kw). | | Report a bug or request a feature | Open the matching [issue template](https://github.com/copper-project/copper-rs/issues/new/choose). | | Propose a runtime or architectural change | Start a [Discussion](https://github.com/copper-project/copper-rs/discussions) before investing in a large implementation. | | Add a reusable driver, task, bridge, or payload | Read [Contributing Components](#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](SECURITY.md). Do not open a public issue. | All community participation is governed by our [Code of Conduct](CODE_OF_CONDUCT.md). ## Set Up the Workspace Copper's minimum supported Rust version is 1.96. Install the latest stable Rust toolchain with [rustup](https://rustup.rs/), then install [`just`](https://just.systems/) and clone your fork: ```bash 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`](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 1. Create a branch from `master` using `user/kind/description`, for example `alex/fix/replay-seek`. 2. Make one focused change. Add tests and update documentation or examples where the behavior needs them. 3. Run `just` from the repository root. It formats the workspace, runs lint and API checks, and tests the std and `no_std` surfaces. 4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required. 5. 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= bin= [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](https://copper-project.github.io/copper-rs/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](https://github.com/copper-project/copper-rs/tree/master/CONTRIBUTING.md)
Repo symbol

copper-rs repository

gpio_caterpillar

ROS Distro
github

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 logo
Copper Runtime & SDK

A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.

CI/CD status cu29 on crates.io Rust 1.96 or newer Read the Copper book Copper documentation Copper release notes Copper Discord

▶ 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 browser demo
BalanceBot
A self-balancing robot simulation using the application that runs on Raspberry Pi hardware.
Source code
Flight controller browser demo
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

  1. Create a branch from master using user/kind/description, for example alex/fix/replay-seek.
  2. Make one focused change. Add tests and update documentation or examples where the behavior needs them.
  3. Run just from the repository root. It formats the workspace, runs lint and API checks, and tests the std and no_std surfaces.
  4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
  5. 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

# 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](https://copper-project.github.io/copper-rs/) or ask on [Discord](https://discord.gg/VkCG7Sb9Kw). | | Report a bug or request a feature | Open the matching [issue template](https://github.com/copper-project/copper-rs/issues/new/choose). | | Propose a runtime or architectural change | Start a [Discussion](https://github.com/copper-project/copper-rs/discussions) before investing in a large implementation. | | Add a reusable driver, task, bridge, or payload | Read [Contributing Components](#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](SECURITY.md). Do not open a public issue. | All community participation is governed by our [Code of Conduct](CODE_OF_CONDUCT.md). ## Set Up the Workspace Copper's minimum supported Rust version is 1.96. Install the latest stable Rust toolchain with [rustup](https://rustup.rs/), then install [`just`](https://just.systems/) and clone your fork: ```bash 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`](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 1. Create a branch from `master` using `user/kind/description`, for example `alex/fix/replay-seek`. 2. Make one focused change. Add tests and update documentation or examples where the behavior needs them. 3. Run `just` from the repository root. It formats the workspace, runs lint and API checks, and tests the std and `no_std` surfaces. 4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required. 5. 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= bin= [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](https://copper-project.github.io/copper-rs/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](https://github.com/copper-project/copper-rs/tree/master/CONTRIBUTING.md)
No version for distro galactic showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

copper-rs repository

gpio_caterpillar

ROS Distro
github

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 logo
Copper Runtime & SDK

A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.

CI/CD status cu29 on crates.io Rust 1.96 or newer Read the Copper book Copper documentation Copper release notes Copper Discord

▶ 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 browser demo
BalanceBot
A self-balancing robot simulation using the application that runs on Raspberry Pi hardware.
Source code
Flight controller browser demo
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

  1. Create a branch from master using user/kind/description, for example alex/fix/replay-seek.
  2. Make one focused change. Add tests and update documentation or examples where the behavior needs them.
  3. Run just from the repository root. It formats the workspace, runs lint and API checks, and tests the std and no_std surfaces.
  4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
  5. 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

# 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](https://copper-project.github.io/copper-rs/) or ask on [Discord](https://discord.gg/VkCG7Sb9Kw). | | Report a bug or request a feature | Open the matching [issue template](https://github.com/copper-project/copper-rs/issues/new/choose). | | Propose a runtime or architectural change | Start a [Discussion](https://github.com/copper-project/copper-rs/discussions) before investing in a large implementation. | | Add a reusable driver, task, bridge, or payload | Read [Contributing Components](#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](SECURITY.md). Do not open a public issue. | All community participation is governed by our [Code of Conduct](CODE_OF_CONDUCT.md). ## Set Up the Workspace Copper's minimum supported Rust version is 1.96. Install the latest stable Rust toolchain with [rustup](https://rustup.rs/), then install [`just`](https://just.systems/) and clone your fork: ```bash 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`](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 1. Create a branch from `master` using `user/kind/description`, for example `alex/fix/replay-seek`. 2. Make one focused change. Add tests and update documentation or examples where the behavior needs them. 3. Run `just` from the repository root. It formats the workspace, runs lint and API checks, and tests the std and `no_std` surfaces. 4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required. 5. 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= bin= [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](https://copper-project.github.io/copper-rs/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](https://github.com/copper-project/copper-rs/tree/master/CONTRIBUTING.md)
No version for distro iron showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

copper-rs repository

gpio_caterpillar

ROS Distro
github

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 logo
Copper Runtime & SDK

A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.

CI/CD status cu29 on crates.io Rust 1.96 or newer Read the Copper book Copper documentation Copper release notes Copper Discord

▶ 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 browser demo
BalanceBot
A self-balancing robot simulation using the application that runs on Raspberry Pi hardware.
Source code
Flight controller browser demo
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

  1. Create a branch from master using user/kind/description, for example alex/fix/replay-seek.
  2. Make one focused change. Add tests and update documentation or examples where the behavior needs them.
  3. Run just from the repository root. It formats the workspace, runs lint and API checks, and tests the std and no_std surfaces.
  4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
  5. 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

# 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](https://copper-project.github.io/copper-rs/) or ask on [Discord](https://discord.gg/VkCG7Sb9Kw). | | Report a bug or request a feature | Open the matching [issue template](https://github.com/copper-project/copper-rs/issues/new/choose). | | Propose a runtime or architectural change | Start a [Discussion](https://github.com/copper-project/copper-rs/discussions) before investing in a large implementation. | | Add a reusable driver, task, bridge, or payload | Read [Contributing Components](#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](SECURITY.md). Do not open a public issue. | All community participation is governed by our [Code of Conduct](CODE_OF_CONDUCT.md). ## Set Up the Workspace Copper's minimum supported Rust version is 1.96. Install the latest stable Rust toolchain with [rustup](https://rustup.rs/), then install [`just`](https://just.systems/) and clone your fork: ```bash 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`](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 1. Create a branch from `master` using `user/kind/description`, for example `alex/fix/replay-seek`. 2. Make one focused change. Add tests and update documentation or examples where the behavior needs them. 3. Run `just` from the repository root. It formats the workspace, runs lint and API checks, and tests the std and `no_std` surfaces. 4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required. 5. 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= bin= [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](https://copper-project.github.io/copper-rs/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](https://github.com/copper-project/copper-rs/tree/master/CONTRIBUTING.md)
No version for distro melodic showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

copper-rs repository

gpio_caterpillar

ROS Distro
github

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 logo
Copper Runtime & SDK

A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.

CI/CD status cu29 on crates.io Rust 1.96 or newer Read the Copper book Copper documentation Copper release notes Copper Discord

▶ 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 browser demo
BalanceBot
A self-balancing robot simulation using the application that runs on Raspberry Pi hardware.
Source code
Flight controller browser demo
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

  1. Create a branch from master using user/kind/description, for example alex/fix/replay-seek.
  2. Make one focused change. Add tests and update documentation or examples where the behavior needs them.
  3. Run just from the repository root. It formats the workspace, runs lint and API checks, and tests the std and no_std surfaces.
  4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
  5. 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

# 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](https://copper-project.github.io/copper-rs/) or ask on [Discord](https://discord.gg/VkCG7Sb9Kw). | | Report a bug or request a feature | Open the matching [issue template](https://github.com/copper-project/copper-rs/issues/new/choose). | | Propose a runtime or architectural change | Start a [Discussion](https://github.com/copper-project/copper-rs/discussions) before investing in a large implementation. | | Add a reusable driver, task, bridge, or payload | Read [Contributing Components](#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](SECURITY.md). Do not open a public issue. | All community participation is governed by our [Code of Conduct](CODE_OF_CONDUCT.md). ## Set Up the Workspace Copper's minimum supported Rust version is 1.96. Install the latest stable Rust toolchain with [rustup](https://rustup.rs/), then install [`just`](https://just.systems/) and clone your fork: ```bash 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`](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 1. Create a branch from `master` using `user/kind/description`, for example `alex/fix/replay-seek`. 2. Make one focused change. Add tests and update documentation or examples where the behavior needs them. 3. Run `just` from the repository root. It formats the workspace, runs lint and API checks, and tests the std and `no_std` surfaces. 4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required. 5. 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= bin= [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](https://copper-project.github.io/copper-rs/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](https://github.com/copper-project/copper-rs/tree/master/CONTRIBUTING.md)
No version for distro noetic showing github. Known supported distros are highlighted in the buttons above.
Repo symbol

copper-rs repository

gpio_caterpillar

ROS Distro
github

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 logo
Copper Runtime & SDK

A Rust runtime for building, running, recording, and deterministically replaying static robot task graphs, from Linux to bare metal.

CI/CD status cu29 on crates.io Rust 1.96 or newer Read the Copper book Copper documentation Copper release notes Copper Discord

▶ 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 browser demo
BalanceBot
A self-balancing robot simulation using the application that runs on Raspberry Pi hardware.
Source code
Flight controller browser demo
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

  1. Create a branch from master using user/kind/description, for example alex/fix/replay-seek.
  2. Make one focused change. Add tests and update documentation or examples where the behavior needs them.
  3. Run just from the repository root. It formats the workspace, runs lint and API checks, and tests the std and no_std surfaces.
  4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required.
  5. 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

# 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](https://copper-project.github.io/copper-rs/) or ask on [Discord](https://discord.gg/VkCG7Sb9Kw). | | Report a bug or request a feature | Open the matching [issue template](https://github.com/copper-project/copper-rs/issues/new/choose). | | Propose a runtime or architectural change | Start a [Discussion](https://github.com/copper-project/copper-rs/discussions) before investing in a large implementation. | | Add a reusable driver, task, bridge, or payload | Read [Contributing Components](#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](SECURITY.md). Do not open a public issue. | All community participation is governed by our [Code of Conduct](CODE_OF_CONDUCT.md). ## Set Up the Workspace Copper's minimum supported Rust version is 1.96. Install the latest stable Rust toolchain with [rustup](https://rustup.rs/), then install [`just`](https://just.systems/) and clone your fork: ```bash 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`](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 1. Create a branch from `master` using `user/kind/description`, for example `alex/fix/replay-seek`. 2. Make one focused change. Add tests and update documentation or examples where the behavior needs them. 3. Run `just` from the repository root. It formats the workspace, runs lint and API checks, and tests the std and `no_std` surfaces. 4. Review the complete diff, then commit with a clear message. Conventional Commits are welcome but not required. 5. 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= bin= [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](https://copper-project.github.io/copper-rs/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](https://github.com/copper-project/copper-rs/tree/master/CONTRIBUTING.md)