Repository files navigation

Coordination repository of the embedded devices Working Group (WG)

This repositoryissue tracker is used by the embedded WG to coordinate efforts towards making Rusta great choice for embedded development.

Want to get started with embedded development with Rust? Check out ourembedded Rust book and the rest of ourbookshelf.

Want to stay up-to-date with community progress? Check out ournewsletter.

Join the discussion on Matrix!#rust-embedded:matrix.org

What is it that we really want? At a broad level:

• To improve the absolute quality (functionality, safety, performance) of embedded software in thewild.
• To improve the productivity of embedded software development teams, by reducing the tangible andintangible costs of achieving a level of quality.
• To improve the experience for programmers developing for embedded systems.
• To make embedded systems programming more accessible for people that are not already embeddedsystems developers.

At a high level we have two main tasks:

We work with the community to improve the embedded ecosystem.

• We maintain and develop core crates in the embedded ecosystem ensuring that the developmentroadmap aligns with the needs of its users. You can find all the crates we maintain in theOrganization section.

• We develop and curate resources about embedded Rust development. Check ourbookshelf!

• We maintain and moderate the venues the embedded community uses to discuss. That includes thiscoordination repository and ourMatrix room.

And, we serve as a bridge between theRust teams and the embedded community.

Everyone can contribute to the embedded WG efforts! There are several ways to help out:

• Let us know where the gaps are. If you think the language, the compiler, the tooling, thedocumentation or the crate ecosystem is lacking some feature, information or library to buildembedded software let us know and we'll bring it up to the Rust teams or organize the community tobuild the crates or tools to fill the gaps.

• Participate inRFC (Request For Comments) threads. We are always looking into ways toimprove. This may involve things from changing how we run the WG to landing major breaking changesin core crates. To ensure we areactually making things better we need your input! That's whyall these changes are preceded by an "RFC", a discussion thread (which may or may not be backed bya proper RFC document) where we evaluate the pros and cons of a proposal and explore alternatives.Only after there's consensus on accepting the proposal is the proposal made effective.

• Help wanted!. There's always lots to do but the WG members only have so much free time. You canhelp us fixing bugs, implementing features, writing tests, trying out examples and tutorials,writing documentation, fixing typos, etc. We'll mentor you through these tasks and review yourwork. In some cases you may not even need previous embedded experience or access embedded hardwareto help us out so don't let that discourage you from checking out our help wanted issues.

• Join our weekly meetings onMatrix. We use these meetings as a faster, synchronous alternative to theRFC threads on GitHub. The agenda is posted in the matrix channel in advanceto the meeting. Everyone is free to join the meeting and share their thoughts. You can alsonominate an existing GH thread for discussion if you think it would benefit from a moresynchronous discussion.The usual meeting time is Tuesdays, 8pm CET/CEST.

• We have several teams focused on different areas: tooling, Cortex-M crates, etc. and each teammaintains several projects (crates, docs and / or tools) that live under therust-embeddedorganization. You can collaborate with the maintenance and development of these projects bybecoming a project collaborator (consult with the team that owns the project) or byjoining theteam.

The WG is composed of several teams whose functions are defined inRFC#136. The embedded WG develops and maintains a large setof projects under therust-embedded organization. This section lists all theteams and all the projects owned by the WG.

The functions of the core team are:

• Representing the WG in meetings with otherRust teams.
• Communicating the needs of the embedded Rust community (e.g. language features,core APIstabilization) to the Rust teams.
• Giving the casting vote on intra-WG decisions where novoting majority can be achieved.
• Driving and moderating the weekly meetings.

• @adamgreig
• @therealprof

The Arm team develops and maintains the crates related to Arm microprocessorsand microcontrollers, including Cortex-A, Cortex-R, and Cortex-M.

• @adamgreig
• @bartmassey
• @berkus
• @jonathanpallant
• @nchong-at-aws
• @newAM
• @raw-bin
• @robamu
• @thalesfragoso
• @therealprof
• @ithinuel
• @davidtwco (representing@rust-lang/arm-maintainers)

Projects maintained by this team.

• aarch64-cpu
• arm-dcc
• cortex-ar
• cortex-m-rt
• cortex-m-semihosting
• cortex-m
• itm
• panic-dcc
• panic-itm
• panic-semihosting
• rust-raspberrypi-OS-tutorials

The embedded Linux team develops and maintains the core of the embedded Linux crate ecosystem.

• @eldruin
• @nastevens
• @ryankurte
• @sirhcel
• @jannic

Projects maintained by the embedded Linux team

• gpio-cdev
• gpio-utils
• i2cdev
• linux-embedded-hal
• meta-rust-bin
• spidev
• sysfs-gpio
• sysfs-pwm

The HAL team develops and maintains crates containing shared traits and relatedcode that enables the development of hardware abstraction layers and driverswhich can interoperate across all embedded Rust devices on all architectures.

• @therealprof
• @ryankurte
• @eldruin
• @dirbaio
• @MabezDev
• @ithinuel

Projects maintained by the HAL team.

• embedded-dma
• embedded-hal
• nb
• critical-section

The infrastructure team manages our domains, DNS records, e-mail aliases, etc.

• @nastevens
• @ryankurte

Projects maintained by this team

• rust-embedded-provisioning

The libs team manages library code that is not architecture-specific.

• @dirbaio
• @newAM
• @reitermarkus
• @zeenix
• @sgued

Projects maintained by this team

• embedded-alloc
• heapless
• qemu-exit
• volatile-register

The MS430 team develops and maintains the core of the MSP430 crate ecosystem.

• @cr1901

Projects maintained by this team

• msp430-quickstart
• msp430-rt
• msp430

The RISC-V team develops and maintains the core of the RISC-V crate ecosystem.

• @almindor
• @dkhayes117
• @romancardenas
• @MabezDev
• @jessebraham
• @rmsyn

Projects maintained by this team

• riscv-rust-quickstart
• riscv-pac
• riscv-rt
• riscv-semihosting
• riscv

The resources team develops, maintains and curates documentation, books, oursocial media accounts and websites, and similar resources on embedded Rust.

• @adamgreig
• @bartmassey
• @eldruin
• @hdoordt
• @jamesmunns
• @therealprof

Projects maintained by the resources team

• Awesome embedded Rust
• The Discovery book
• The embedded Rust book
• The embedonomicon
• @rustembedded twitter

The tools team maintains and develops software for embedded developmentwhich typically runs on your development machine rather than theembedded targets themselves.

• @adamgreig
• @burrbull
• @Emilgardis
• @ryankurte
• @therealprof
• @ithinuel

Projects maintained by the tools team

• cargo-binutils
• itm
• svd-parser
• svd2rust

The triage team is charge of keeping PR queues moving; they ensure no PR is left unattended.

• @mathk
• @jessebraham
• @jannic

The following alumni have put themselves into the hibernation state, due to being absent or busy for an extended amount of time. Seeops/hibernating.md.

• @andre-richter
• @awygle
• @bradjc
• @danc86
• @Disasm
• @dvc94ch
• @dylanmckay
• @hannobraun
• @hargoniX
• @japaric
• @jcsoo
• @korken89
• @laanwj
• @paoloteti
• @parched
• @pftbest
• @sekineh
• @v-thakkar
• @wizofe
• @posborne
• @thejpster
• @YuhanLiin

Each team can be privately contacted via the following e-mail addresses:

• cortex-m@teams.rust-embedded.org
• embedded-linux@teams.rust-embedded.org
• hal@teams.rust-embedded.org
• infrastructure@teams.rust-embedded.org
• resources@teams.rust-embedded.org
• risc-v@teams.rust-embedded.org
• tools@teams.rust-embedded.org

You can usually find the members of the embedded WG on the Rust Embedded Matrix room(#rust-embedded:matrix.org).

Our Matrix room is logged by on the bridged IRC channel, and you can find the logs at:https://libera.irclog.whitequark.org/rust-embedded/

These are other projects you may be interested in but that (currently) are not owned by the WG.

• AVR fork of Rust
• Xtensa fork of Rust (for Espressif chips)

Several device specific communities exist that are not part of the working group.These communities maintain crates for peripheral access, hardware abstraction,examples, and more that are specific to a particular family of devices.The list below is not exhaustive and will be updated as device support increases.

• nrf-rs: Nordic nRF series of microcontrollers
• stm32-rs: STM32 microcontrollers
• lpc-rs: NXP LPC microcontrollers
• imxrt-rs: NXP i.MX RT microcontrollers
• esp-rs: Espressif Systems microcontrollers
• rp-rs: Raspberry Pi microcontrollers including the RP2040

embedded-hal is a project that aims to build a standard set of traits (interfaces) for I/Ofunctionality common in embedded devices: Serial, I2C, etc. with the goal of serving as a base forbuilding reusable driver crates, crates to interface with external components like sensors.

There are plenty of traits that still need to be designed, in particular ones that involve asyncI/O. Join the discussion and help us design the missing traits so that they'll fulfill your needs.

The community is building a curated list of crates useful for embedded development. In this listyou'll find driver crates, board support crates and general purpose no-std crates. Help us improvethis list by adding your crate via PR or by tackling any of ourhelp wanted issues.

As an experiment theRust lang user forum has gained a newembedded category.

This is meant as a friendly exchange for anyone interested in embedded topics with Rust.

So if you want to discuss ideas, problems or solutions please feel free to chime in on existing topics or create a new one!

When the team deems it necessary the RFC process may be used to make decisions or to designprocesses, user interfaces, APIs, etc.

Learn more about the Rust's RFC process (which is the same as our own)here.

To create an RFC, simply:

• clone this repo to your own personal one
• copy0000-template.md totext/0000-my-feature.md (where "my-feature" isdescriptive. Don't assign an RFC number yet)
• fill in the details of your RFC in that file
• Open an pull request with this repository