Today we're announcing Knurling - Ferrous' effort to sustainably build better tooling for developing and debugging Rust software for embedded systems.

To make this a reality, we are opening a GitHub organization to collect these efforts, as well as making it possible to support our efforts through GitHub Sponsors.

The Mission

We believe that developing software for embedded systems should be no more difficult than developing for hosted platforms. It should be possible to use the same workflows and equally powerful tooling to develop applications and libraries for tiny embedded systems as well as server-class hardware.

To that end, we want to enable:

• Learning embedded Rust with up to date and maintained teaching material
• Space-efficient and real-time capable logging
• Tools that integrate into your standard cargo run and cargo test workflows
• Execution tracing
• Simple data logging and visualization straight into your IDE or Browser

We are already active contributors in the open source ecosystem, but we want to spend more time dedicated to building tools that improve the experience for the entire ecosystem, and we can't do that without your support.

Release Model

We plan to make everything we develop under Knurling to be open source, in order to support the community. This includes all of the tooling, teaching material, and support libraries we develop.

The items we release will all be under MIT+Apache 2.0 licenses for code, and CC-BY-SA 4.0 for written material.

Sponsors will also have early access to work in progress tools and libraries before they are released, as well as early access to our training material and exercises before they are made public.

Early Access is available for all sponsors, regardless of tier.

Let's take a quick tour of the things we plan to make possible with Knurling:

Embedded CLI and IDE Tooling

EDIT: This blog post has been updated to reflect the rename of binfmt to defmt.

We'd like to spend time to make it easier to design, build, debug, and release software components with embedded Rust. This includes developing target-side libraries, as well as host-side applications that interact with these components.

We also want to make it possible to have best-in-class debugging tools, allowing you to monitor, graph, and visualize what your system is doing. We think that it's possible to make developing embedded systems painless through better and extensible tooling!

The first of these tools we plan to release is defmt (in the screenshot above), a tool for efficient logging and tracing in real-time, using a variety of different transport methods like Semihosting, RTT, or even a UART or radio. defmt will allow for logging of data without incurring expensive formatting costs on the device itself.

We'll be talking more about defmt next week on our blog, but you can check it out now if you become a sponsor today!

More Training and Learning Examples

We're already developing open source training material for embedded systems in Rust, including our training material for basic Rust training, the material for our 2019 Embedded Trainings, as well as our most recent 2020 Embedded Trainings.

We plan to develop a new, continuously maintained set of training material that consists of two parts:

The first part is Knurling Books, which are written guides that teach general concepts of embedded systems and Rust, and come with associated sample projects demonstrating the concepts. This is a great place for folks to learn embedded systems or embedded systems with Rust!

The second part is Knurling Sessions, which are quarterly embedded projects that explore specific projects using generally available hardware, building full systems and components using microcontrollers, sensors, and actuators.

These will be guided, hands-on tutorials for building projects like a CO2 Sensor, Data Loggers, and even robots! For folks that want to learn in a more hands-on way, or want to know "what hardware should I buy to get started", Knurling Sessions are a great option!

Before each session, we'll announce the hardware we'll use and how we'll use it. If you want to follow along and build the project at home, we'll include links to purchase the hardware. We'll reuse components session to session, so you can start building your own collection of parts!

In the future, we plan to also offer video based training and Q&A sessions where we explore the concepts in a deeper and more detailed way, great for learning how and why things are built.

As we mentioned, all of the Knurling Books and Knurling Sessions will be made public and open source, but Sponsors will get early access to both!

We'll be announcing our first training books and sessions later in August, so stay tuned!

More Experiments and Ecosystem Improvements

In the past, we've done a number of experiments and improvements towards the Rust and Rust Embedded ecosystems. Most recently, we wrote about making async/await possible for embedded systems, and were even able to contribute optimizations that sped up compilation and run time for all users of async/await!

We released these experiments as an open source project, and it has already been transferred to community ownership.

We'd like to dedicate more time to these kinds of projects, exploring what could be possible with embedded Rust, bringing crates to a maintained 1.0 status, or improving the compiler to benefit embedded systems developers. You can help us make this happen by sponsoring our efforts!

Thank you all!

We think the embedded Rust ecosystem is already the best way to develop embedded software today, but we can make it even better and easier, whether you are a developer who has never touched a microcontroller before, or you are a developer that is already an expert in embedded Rust.

If you'd like to support these works as an individual or through your company, we'd appreciate it a lot! If you're interested in more details, or there is something you'd like to see us do, just drop us an email!