Ferrous Systems Blog

Callgraph analysis

2026-03-31T22:00:00+00:00

Callgraph analysis

Say you have a region of a program where users Want Static Verification that some function is never called. For simplicity, let's say you want to make sure you never call panic! so your program doesn't crash.

In this post we talk...

Accessing Hardware in Rust

2026-03-17T23:00:00+00:00

Overview

At Ferrous Systems, we write a lot of Rust code that runs on bare-metal - the code that is first to run when the processor comes out of reset, and code that has no higher power to call upon for assistance. Some of this we do as example code...

Ferrocene for Air-Gapped Environments

2026-03-09T23:00:00+00:00

Ferrocene and vetted crates going offline

See it in action at embedded world, Hall 4, Booth 4-402

We at Ferrous Systems are excited to share insights into a new feature in development, designed to enable Ferrocene and Rust crates in high-risk environments...

Ferrocene 26.02.0 now available!

2026-02-14T23:00:00+00:00

Today we're announcing the release of Ferrocene 26.02.0, the latest update to our qualified Rust toolchain. This release arrives with an additional certification, ISO 26262 (ASIL B), for the certified subset of the Rust core library (core)!

Now,...

Ferrous Systems Achieves IEC 61508 (SIL 2) Certification for Rust Core Library Subset

2025-12-02T23:00:00+00:00

BERLIN – December 3, 2025 – Ferrous Systems, the leader in Rust-based software solutions for embedded and safety-critical systems, has achieved TÜV SÜD certification for a subset of the Rust core library (core) according to IEC 61508 (SIL 2). The core...

Ferrocene 25.11.0 now available!

2025-12-02T23:00:00+00:00

Today we're announcing the release of Ferrocene 25.11.0, the latest update to our qualified Rust toolchain. This release is particularly special to us as it arrives with our first IEC 61508 (SIL 2) certified subset of the Rust core library (core)...

Ferrocene 25.08.0 now available!

2025-09-30T22:00:00+00:00

Today we're announcing the release of Ferrocene 25.08.0, the latest update to our qualified Rust toolchain. This release includes a compiler version bump, and a preview of our core certification.

What is Ferrocene?

Developed as an open-source, downstream...

Rust: Who, What and Why for ESA SW PA Workshop

2025-09-18T22:00:00+00:00

We are attending the European Space Agency's bi-ennial Software Product Assurance Conference in September, at the European Space Research and Technology Centre in Noordwijk, The Netherlands. At the event, we have been invited to present a 4-hour workshop...

Ferrous Systems Joins SOAFEE Initiative

2025-07-30T22:00:00+00:00

BERLIN – July 31, 2025 – Ferrous Systems, the leading provider of Rust-based software solutions for embedded and safety-critical systems, today announced it has joined the Scalable Open Architecture for Embedded Edge (SOAFEE) initiative. SOAFEE is...

Ferrocene 25.05.0 now available!

2025-06-29T22:00:00+00:00

Today we're announcing the release of Ferrocene 25.05.0, the latest update to our qualified Rust toolchain. This version includes improvements from upstream Rust and two new qualified targets.

Ferrocene is the first Rust compiler toolchain qualified...

Where to Meet Us in 2025: Upcoming Events & Conferences

2025-04-27T22:00:00+00:00

Ever wondered where you can meet our team? We’ve put together a list of events we’ll be attending this year, and we're speaking at most of them! If you’re planning to be at any of these, don’t hesitate to reach out - we’d love to connect!

Upcoming...

defmt is now 1.0

2025-04-08T22:00:00+00:00

A few months ago, we announced our intent to stablize a 1.0 of defmt. Over the last few months we've been collaborating with users and community members to work through the last remaining pieces, and now it's finally time.

As of today, defmt is now...

SEGGER J-Trace and Ferrocene

2025-03-10T23:00:00+00:00

Ferrous Systems Demonstrates SEGGER’s J-Trace System for Analyzing Rust Applications Compiled with Qualified Ferrocene Toolchain

See it in action at embedded world, Hall 4, Booth 4-402

embedded world 2025 – Nuremberg, Germany – March 11, 2025 -

Rust on Cortex-R52

2025-03-10T23:00:00+00:00

Ferrous Systems First to Run Rust on Cortex-R52 Under Open Source License

See it in action at embedded world, Hall 4, Booth 4-402

embedded world 2025 – Nuremberg, Germany – March 11, 2025 – Ferrous Systems, the leader in Rust solutions for safety...

How we built our 2025 Embedded World Demos

2025-03-10T23:00:00+00:00

Background

At Embedded World 2025, we are presenting two demos based around Rust on Arm.

The first is our Rust for Microcontrollers demonstration, showing the power of SEGGER's J-Trace system in analysing the performance of the Knurling Project's...

Ferrocene 25.02.0 now available!

2025-02-25T23:00:00+00:00

We’re glad to announce the release of Ferrocene 25.02.0, the latest update to our qualified Rust toolchain. This version includes new Rust improvements and five new experimental targets.

Ferrocene is the first fully open-source Rust compiler toolchain...

Defmt is going to 1.0

2025-01-26T23:00:00+00:00

Update: Defmt 1.0 has been released.

What is defmt?

The defmt library is described in the defmt book as:

A highly efficient logging framework that targets resource-constrained devices, like microcontrollers.

It's important to note that, despite...

Ferrocene Achieves IEC 62304 Qualification

2025-01-13T23:00:00+00:00

Ferrocene Becomes First Rust Toolchain to Achieve IEC 62304 Qualification Enables medical device developers to leverage the unmatched safety and reliability of Rust while streamlining compliance

BERLIN — January 14, 2025 — Ferrous Systems, the...

Ferrocene 24.11.0 now available!

2024-11-25T23:00:00+00:00

We’re proud to announce the release of Ferrocene 24.11.0, the latest update to our qualified Rust toolchain. This version includes new Rust improvements, medical qualification, a new host platform, and qualification of our existing QNX toolchains.

Security in hickory-dns

2024-11-18T23:00:00+00:00

Introduction

About a year ago, the ISRG's Prossimo project approached us to help them to work on a memory safety initiative called hickory-dns, a suite of DNS tools to run authoritative name servers and recursive resolvers. Prossimo is a project of...

Ferrocene 24.08.0 now available!

2024-08-26T22:00:00+00:00

We’re excited to announce the release of Ferrocene 24.08.0, the latest update to our qualified Rust toolchain. This version includes the latest Rust improvements, increased target support, and a preview of the first off-the-shelf QNX toolchain for...

SBOM support in Rust

2024-07-29T22:00:00+00:00

Introduction

Last year Lars Francke, the co-founder and CTO of Stackable, approached us with a project proposal to improve the generation of Software Bill of Materials (SBOM) in the Rust eco-system. One particular task was to find a way to expand...

Improving 64-bit RISC-V Linux support in Rust

2024-07-01T22:00:00+00:00

Ferrous Systems is partnering with Codethink to propose lifting the 64-bit RISC-V Linux (riscv64gc-unknown-linux-gnu) target to Tier 1 though work funded by the RISE Project. While we at Ferrous Systems are fully convinced by Rust’s versatility and...

The New Safety-Critical Rust Consortium: We’re in!

2024-06-11T22:00:00+00:00

We’re excited to be part of the Rust Foundation’s new Safety-Critical Rust Consortium. The primary objective of this group will be to support the responsible use of the Rust programming language in safety-critical software — systems whose failure can...

Ferrocene 24.05.0 now available for purchase

2024-05-26T22:00:00+00:00

We’ve got major updates: We've qualified Ferrocene 24.05.0 based on Rust 1.76.0 and CriticalUp 1.0.0: Ferrocene's installer and toolchain manager. And last, but not least: Ferrocene can now be purchased online as an individual license.

Ferrocene is...

Storing borrowed data in trait objects

2024-02-29T23:00:00+00:00

Recap of the second post

In the second post, we finished working through the pipeline that decodes and decrypts incoming TLS records. To remove the heap allocations in the second decoding pass, we added a generic lifetime parameter to the Codec trait...

Automating Releases for Bindgen

2024-02-15T23:00:00+00:00

Bindgen is an important tool for helping to accelerate the transition from C and C++ to Rust because it generates FFI bindings. We knew that improving the robustness of bindgen would advance our efforts of bringing memory safety to critical infrastructure...

Update: Position Closed - Project Manager

2024-02-13T23:00:00+00:00

Project Manager (all genders) - remote work/German resident

Ferrous Systems is an IT development service and training provider in the Rust programming language. Founded by members of the Rust project, the company engages in all aspects of Rust development...

Allocation-free decoding with traits and high-ranked trait bounds

2024-02-07T23:00:00+00:00

Recap of the first post

In the first post, we started working through the rustls' pipeline that decodes and decrypts TLS records, removing the heap allocations we came across. After the changes in that first post, the pipeline we covered looks like...

rust-analyzer financial report 2023

2024-02-01T23:00:00+00:00

Financial Report 2023

This is the fifth financial status report of the rust-analyzer project Ferrous Systems fund (previous report).

We would like to say a big thank you to all the sponsors of rust-analyzer, past and present. This work is dependent...

Are you ready for Embedded Rust training?

2024-01-22T23:00:00+00:00

Are you ready for Embedded Rust training?

We’re always ready to take on – and provide – more challenges through our Rust trainings. As Rust grows in adoption across various companies, demand is increasing for more advanced trainings.

But that comes...

Using `mem::take` to reduce heap allocations

2024-01-15T23:00:00+00:00

Background

Ferrous Systems was contracted by the Internet Security Research Group (ISRG) to work on rustls, a modern TLS library in Rust, in 2023. We worked on adding no-std support to rustls, as well as designing and implementing an alternative API...

Update: Position Closed - Contract Manager, remote

2023-12-18T23:00:00+00:00

Contract Manager (all genders)

Ferrous Systems is an IT development service and training provider in the Rust programming language. Founded by members of the Rust project, the company engages in all aspects of Rust development and Open-Source sustainability...

Rust and ThreadX

2023-12-06T23:00:00+00:00

Rust and ThreadX

ThreadX is a real-time operating system (or RTOS) written in C which dates back to 1997. The developer, Express Logic, was acquired by Microsoft in 2019 and the product was renamed Azure RTOS. In November 2023, it was announced that

Officially Qualified - Ferrocene

2023-11-07T23:00:00+00:00

It’s official: Ferrocene is ISO 26262 and IEC 61508 qualified!

You can even find the certificate in TÜV SÜDs certificate database.

This means we achieved qualification for the open source Ferrocene toolchain. Ferrocene 23.06.0, based on Rust 1...

sudo-rs' first security audit

2023-11-02T23:00:00+00:00

Thanks to funding from NLNet and ISRG, the sudo-rs team was able to request an audit from Radically Open Security (ROS). In this post, we'll share the findings of the audit and our response to those findings.

ROS performed crystal-box penetration...

Deprecation of probe-run and migration to probe-rs

2023-10-10T22:00:00+00:00

TL;DR

probe-run is getting deprecated in favor of probe-rs (github, website)
Migration steps are simple. [Skip to migration steps]
probe-rs offers most features of probe-run and many more

Letter

Dear community,

We'd like to share an important...

Open Sourcing Ferrocene

2023-10-03T22:00:00+00:00

Today we’re publishing Ferrocene, the Rust compiler for safety-critical and cyber-security use, as an open source project. After 2 years of work, we feel ready to make it available - but also fully open source under the classic Rust license: Apache...

Qualifying Rust without forking

2023-09-25T22:00:00+00:00

Ferrocene is a qualified downstream of the main Rust compiler, rustc, which is built and maintained for safety-critical and security use.

Many vendors fork such compilers - they take a current version of the compiler, change it, qualify it, and then...

Rust for Mission Critical Applications

2023-09-24T22:00:00+00:00

As you may be aware, Ferrous Systems has done a lot of work around Rust and Embedded Systems; be they "big" embedded systems that run on real-time OS like QNX, or "small" embedded systems that run on bare-metal. We were delighted to have this recognised...

How Ferrocene improves Rust

2023-09-10T22:00:00+00:00

Over the past few years, Ferrous Systems has been developing Ferrocene, a distribution of the Rust compiler for safety-critical (qualified for ISO 26262 and IEC 61508) and security.

Being a downstream of the Rust project, Ferrocene doesn't exist in...

Our latest adventures with bindgen

2023-08-09T22:00:00+00:00

As you may know, Open Source projects are a fundamental part of the software development ecosystem. While the creation of new projects is exciting and gathers a lot of attention, it is as important to maintain the already existing software that a lot...

Ferrocene update

2023-07-18T22:00:00+00:00

We have an update to share on Ferrocene, the premier safety compiler for Rust. We'd also like to invite you to the Ferrocene release announcement, happening on October 4th.

AdaCore and Ferrous Systems have jointly developed a Rust toolchain that is...

A Decade of Rust, and Announcing Ferrocene

2023-07-18T22:00:00+00:00

Hello Rustaceans!

Sometimes, good things come in many. For example: birthdays! 🎉

As it just so happens, we have 3 big things to celebrate:

It's the 10th anniversary of Florian publicly posting his first Rust code on September 28th, 2013!
Ferrous...

Testing sudo-rs and improving sudo along the way

2023-06-27T22:00:00+00:00

sudo-rs is a project by Prossimo jointly implemented by Tweede golf and Ferrous Systems.

As our friends at Tweede golf announced in a previous blog post, Ferrous Systems and Tweede golf have been working together on a re-implementation of sudo...

Why it is hard to learn another programming language Part III

2023-06-20T11:00:55+00:00

Why it is hard for developers to learn another language and how a professional training can help - Part III

Note: other posts in this series - Part I and Part II.

In the first two posts in this series, we focused on how the dialogues in a group setting...

Why it is hard to learn another programming language Part II

2023-04-03T11:00:55+00:00

Why it is hard for developers to learn another language and how a professional training can help - Part II

Note: other posts in this series - Part I and Part III.

In our last post in the series, we focused on how the dialogues in a group setting...

A Rustaceans tour of embedded world

2023-03-27T08:00:00+00:00

Last week, I had the pleasure of representing Ferrous Systems at Embedded World together with our partners at AdaCore. We shared a space so that we can collectively represent our joint project: Ferrocene. AdaCore additionally presented SPARK Pro, a...

How we built our Embedded World Demo on Rust for QNX

2023-03-24T09:54:57+00:00

Background

At Embedded World 2023, Ferrous Systems had a joint booth with AdaCore, to talk about our new joint-venture: Ferrocene. Ferrocene is a qualified toolchain for building safety-critical systems in Rust.

Florian noted that our booth was next...

A cheatsheet for some potentially confusing terms in Rust

2023-03-09T07:00:55+00:00

Learning Rust can be a bit tedious. There are various reasons for that. My colleague - Tanks - has started a blog series on this topic: Why is it hard to learn another programming language Part 1. One aspect is a combination of the opportunistic learning...

Binding with bindgen

2023-03-06T07:00:55+00:00

I bet you know that at Ferrous Systems we are big proponents of open source. You are also probably aware that Ferrous Systems is a leading name in Rust training. But – did you know that we also consult on a range of client projects? Some of these projects...

rust-analyzer Financial Report #4

2023-02-27T10:00:00+00:00

Financial Report #4

This is the fourth financial status report of the rust-analyzer project Ferrous Systems fund.

This one is loooong overdue, apologies for that! We will be posting these reports yearly from now on.

Since the last report, rust...

Update: Position Closed - Student Assistant, remote

2023-02-14T23:00:00+00:00

Student Assistant (all genders) in Rust Software Development

Ferrous Systems is a development service and training supplier in the space of the Rust programming language. Founded by members of the Rust project, the company engages in all aspects of...

Why it is hard to learn another programming language Part I

2023-02-14T11:00:55+00:00

Why it is hard for developers to learn another programming language and how a professional training can help - Part I

Note: other posts in this series - Part II and Part III.

Being a major training provider in the Rust programming language, we are...

Using Rust to build a next-generation network

2023-01-19T13:47:55+00:00

Using Rust to build a next-generation network

Ferrous Systems specialises in the Rust Programming Language. We’re perhaps best known for our Training Courses, and the sponsored work we do on open-source projects like rust-analyzer, but we also offer...

Update: Position Closed - Senior Software Developer, remote

2023-01-12T10:09:07+00:00

Software development

Ferrous Systems provides development service and training in the space of the Rust programming language. Founded by members of the Rust project, the company engages in all aspects of Rust development and Open-Source sustainability...

defmt-rtt linker error

2022-12-05T23:00:00+00:00

TL;DR

Compiling a Rust project with defmt-rtt v0.3 fails with a linker error if an application author (this is you!) does not select a critical section implementation.

To fix this do the following (taken from the critical-section docs):

Add...

The Ferrocene Language Specification is here!

2022-07-25T22:00:00+00:00

It’s here! A couple of months ago, we announced that as part of our efforts with Ferrocene, we were creating the Ferrocene Language Specification – and now our first draft is online.

The Ferrocene Language Specification (FLS) is an effort of Ferrocene

Espressif #embeddedrust training information

2022-07-10T22:00:00+00:00

Here comes all important information for our Rust Embedded Espressif trainings.

Training

Dates

We have two 'levels' of training workshop - Beginner and Advanced. The Beginner training will be on September 15 (beginner) and the Advanced training...

Call for applications: Knurling-rs Summer of Code 2022 🦀

2022-06-22T22:00:00+00:00

Call for applications: Knurling-rs Summer of Code 2022 🦀

The knurling-rs project will run the "Knurling-rs Summer of Code" for the first time. We aim to advance our mission to improve the embedded Rust experience and support newcomers to improve their...

Introducing the Ferrocene Language Specification

2022-05-31T22:00:00+00:00

Announcement

At Ferrous Systems, our work to qualify rustc to produce Ferrocene is primarily an exercise in documentation. And today, we're excited to give you a glimpse into the core of that package: the Ferrocene Language Specification (FLS).

Embedded Rust on Espressif

2022-04-04T22:00:00+00:00

Are you ready to explore the world of the Internet of Things (IoT) with embedded Rust? We've got news for you! We have been collaborating with Espressif on training material for new embedded workshops. You can join our workshops in September!

Board...

Knurling-rs changelog #34

2022-03-09T23:00:00+00:00

This is the 34th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Knurling-rs changelog #33

2022-02-06T23:00:00+00:00

This is the 33rd changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Ferrous Systems and AdaCore to join forces on Ferrocene

2022-02-01T23:00:00+00:00

Ferrous Systems started in 2018 with the mission to help companies adopt Rust. This has led to many different activities: Ferrous Systems is augmenting teams around the world by providing training and other forms of advice, it develops software and...

Knurling toolset v0.3 has been released!

2021-10-31T23:00:00+00:00

Knurling-rs is Ferrous Systems' push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your embedded Rust...

Structuring, testing and debugging procedural macro crates

2021-10-18T22:00:00+00:00

In this blog post we'll explore how to structure a procedural macro, AKA proc-macro, crate to make it easier to test. We'll show different testing approaches:

unit tests, for code coverage;
compile-fail tests, to ensure good error messages; and

Knurling-rs changelog #32

2021-10-07T22:00:00+00:00

This is the 32nd changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Knurling-rs changelog #31

2021-09-16T22:00:00+00:00

This is the 31st changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Knurling-rs changelog #30

2021-08-26T22:00:00+00:00

This is the 30th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Knurling-rs changelog #29

2021-08-02T22:00:00+00:00

This is the 29th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Knurling-rs changelog #28

2021-07-05T22:00:00+00:00

This is the 28th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Knurling-rs changelog #27

2021-06-19T22:00:00+00:00

This is the 27th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Knurling-rs changelog #26

2021-06-06T22:00:00+00:00

This is the 26th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Taking Rust for a Test Drive

2021-05-27T22:00:00+00:00

Taking Rust for a Test Drive

At Ferrous, we often help folks who are in the "getting started" phase of using Rust. Sometimes their engineering teams have started using the language unofficially and they'd like some help making it official, and other...

Knurling-rs changelog #25

2021-05-22T22:00:00+00:00

This is the 25th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Knurling-rs changelog #24

2021-05-06T22:00:00+00:00

This is the 24th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Using GDB and defmt to debug embedded programs

2021-05-03T22:00:00+00:00

With logging frameworks like defmt, "printf debugging" is a powerful and easily accessible tool to figure out why your code is behaving differently than expected. However, sometimes you might still want to use a debugger like gdb, for example if you...

Compilers as Teachers

2021-05-02T22:00:00+00:00

In the introduction of our trainings, we like to stress that Rust takes its commitment to developer friendliness very seriously, and that the Rust compiler considers confusing error messages a bug. This has been an explicit sentiment of the Rust project...

Knurling-rs changelog #23

2021-04-16T22:00:00+00:00

This is the 23th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Knurling-rs changelog #22

2021-04-01T22:00:00+00:00

This is the 22th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Testing an embedded application

2021-03-30T22:00:00+00:00

Welcome to the final post in our "testing embedded Rust" series. In the previous posts we covered how to test a Hardware Abstraction Layer, how to test a driver crate and how to set up a GitHub Actions (GHA) workflow to include Hardware-In-the-Loop...

Knurling Financial Update

2021-03-28T22:00:00+00:00

When we first started the knurling-rs project, our aim was to share our tools for accelerating development of embedded Rust. We had been building and using them internally– for trainings, open source and commercial customer projects.

Since then, our...

Breathe-rs - An air quality monitor based on Knurling sessions

2021-03-22T23:00:00+00:00

Breathe-rs - An air quality monitor based on Knurling sessions

NOTE: This is a guest post by Matous Hybl (@hyblmatous on Twitter). Matous participated in the first Knurling Session, and shared his experience with us.

When Knurling-rs was announced...

Knurling-rs changelog #21

2021-03-18T23:00:00+00:00

This is the 21th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Running hardware-in-the-loop tests on GitHub Actions

2021-03-16T23:00:00+00:00

This is the third post in our "embedded Rust testing" series. This post covers how to run a hardware testsuite based on defmt-test on real hardware with GitHub Actions. We'll be using the testsuite introduced in the first article in the series, so...

We published the first knurling-session!

2021-03-15T23:00:00+00:00

After a couple of months behind closed curtains, accessible to sponsors only, we published last winter's knurling-session today! It's now available to all, for free.

This is the project repo.
Direct link to the rendered book.
And on the knurling...

Knurling-rs changelog #20

2021-03-11T23:00:00+00:00

This is the 20th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Knurling-rs changelog #19

2021-03-04T23:00:00+00:00

This is the 19th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Testing a driver crate

2021-03-02T23:00:00+00:00

Welcome to the second post in our "testing Embedded Rust" series. In this blog post we'll cover how to test a platform agnostic driver crate.

Driver crate?

In the embedded Rust ecosystem, the term driver crate refers to a generic library that interfaces...

Knurling-rs changelog #18

2021-02-25T23:00:00+00:00

This is the 18th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Ferrocene Part 3: The Road to Rust in mission- and safety-critical

2021-02-23T23:00:00+00:00

Announcing Ferrocene

Ferrocene is an effort led by Ferrous Systems and its newly formed subsidiary Critical Section GmbH to qualify the Rust Language and Compiler for use in the safety-critical domain. This is the third post in a series detailing...

Knurling-rs changelog #17

2021-02-21T23:00:00+00:00

This is the 17th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Testing a Hardware Abstraction Layer (HAL)

2021-02-17T23:00:00+00:00

This is the first post in our "embedded Rust testing" series. This post covers how to test a Hardware Abstraction Layer (HAL) with defmt-test and little to no additional hardware.

Intro

A Hardware Abstraction Layer is a crate (library) that exposes...

Knurling-rs changelog #16

2021-02-11T23:00:00+00:00

This is the 16th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Knurling-rs changelog #15

2021-02-04T23:00:00+00:00

This is the 15th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Another Knurling-Session

2021-02-02T23:00:00+00:00

While the last Knurling Session was focused on Hardware and and how to make it work together using software, this quarter will be focused more on the software side of things. We'll explore basic Rust principles in a way that is suitable to get started...

Knurling-rs changelog #14

2021-01-21T23:00:00+00:00

This is the 14th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Knurling-rs changelog #13

2021-01-14T23:00:00+00:00

This is the 13th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Knurling-rs changelog #12

2021-01-07T23:00:00+00:00

This is the 12th changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test your...

Knurling-rs changelog #11

2020-12-17T23:00:00+00:00

This is the eleventh changelog (and the last in 2020) for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop

Knurling-rs changelog #10

2020-12-10T23:00:00+00:00

This is the tenth changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test

Knurling-rs changelog #9

2020-12-03T23:00:00+00:00

This is the ninth changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test

Knurling-rs changelog #8

2020-11-26T23:00:00+00:00

This is the eighth changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test

Knurling-rs changelog #7

2020-11-19T23:00:00+00:00

This is the seventh changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test

Knurling-rs changelog #6

2020-11-12T23:00:00+00:00

This is the sixth changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test

Knurling-rs changelog #5

2020-11-05T23:00:00+00:00

This is the fifth changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test

Knurling-rs changelog #4

2020-10-28T23:00:00+00:00

This is the fourth changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test

For Complex Applications, Rust is as Productive as Kotlin

2020-10-27T23:00:00+00:00

In this article, we will compare one apple (IntelliJ Rust) to one orange (rust-analyzer) to reach general and sweeping conclusions. Specifically, I want to present a case study supporting the following claim:

For complex applications, Rust is...

Knurling-rs changelog #3

2020-10-22T22:00:00+00:00

This is the third changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and test

Dancing Links In Rust

2020-10-05T22:00:00+00:00

Hi!

This will be a rather technical article — we will implement Dancing Links algorithm in Rust. I became aware of this beautiful problem when working with Calendly — they are using Dancing Links (and Rust!) to find the best time slot for an event...

Knurling-rs changelog #2

2020-09-24T22:00:00+00:00

This is the second weekly changelog for Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems. Knurling-rs includes a suite of tools that make it easier to develop, log, debug, and...

Learning Rust: OMG WTF RS – resources to help you get started with Rust

2020-09-22T22:00:00+00:00

I'm an embedded C/C++ developer who joined Ferrous and made the switch to Rust this spring. One thing that continues to amaze me on this journey is the quality and friendliness of Rust tools and learning resources.

Still, when you're just starting...

Knurling-rs changelog #1

2020-09-17T22:00:00+00:00

Since the releases of defmt and probe-run there have been many improvements in the defmt ecosystem and work on new tools. We have been posting those updates on Twitter but in case you missed them this blog post is a summary of those updates.

Location...

One Month of Knurling-rs

2020-09-13T22:00:00+00:00

Just over a month ago, we announced Knurling-rs, our push to sustainably build better tooling for developing and debugging Rust software for embedded systems.

In the past month, we've made some amazing achievements. We've released a number of tools...

Learning Embedded Rust with Knurling-rs

2020-09-08T22:00:00+00:00

Having a good set of tooling is only half of the story in making it easier to develop and debug Rust software for embedded systems. The other half is knowledge and documentation. This is where Knurling Books and Knurling Sessions are brought into...

Using `cargo test` for embedded testing with `panic-probe`

2020-08-31T22:00:00+00:00

We're happy to announce the newest crate published as part of our knurling project: panic-probe.

panic-probe is a simple panic and fault handler that integrates into probe-run, our host-side tooling for embedded programs. When using panic-probe in...

defmt, a highly efficient Rust logging framework for embedded devices

2020-08-20T22:00:00+00:00

Today we are thrilled to announce the public release of defmt ("de format"). defmt stands for "deferred formatting" and it's a highly efficient logging framework. As we covered in our blog post about embedded tooling for the 21st century we hope defmt

Run Rust on your embedded device from VSCode in one click

2020-08-18T22:00:00+00:00

The rust-analyzer plugin for VSCode provides you with a helpful little ▶ Run button above every test or main() function that lets you execute your code right out of the editor. Unfortunately though, this won't work out of the box in embedded projects...

Learning Rust: The Compiler is your Friend

2020-08-16T22:00:00+00:00

The Rust programming language doesn't just aim to be practical, it also aims to be useful for the people working with it. Not only does this improve productivity, it also helps learning the language! One of the features I want to pick out: the borrow...

probe-run, run embedded Rust apps like native apps

2020-08-13T22:00:00+00:00

Today we are pleased to announce the public release of probe-run, a custom Cargo runner for embedded development. This host application integrates into your Cargo workflow and lets you cargo run embedded applications. Let's see how to use it for ARM...

Embedded Rust tooling for the 21st century

2020-08-10T22:00:00+00:00

These days GDB is the go-to development/debugging tool of many embedded Rust developers. We think there's room for complementary tools that could provide a better development workflow and improve productivity. In this blog post we'll share our vision...

Knurling-rs Announcement

2020-08-05T22:00:00+00:00

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...

Learning Rust: Mindsets and Expectations

2020-08-02T22:00:00+00:00

We often hear that Rust is a language that is too complex and too difficult to learn. While, yes, the language is complex, we have identified some existing mindsets and expectations that serve as obstacles to the learning process. Let's discuss these...

Concurrency Patterns in Embedded Rust

2020-07-06T22:00:00+00:00

How should you do concurrency in an embedded no_std application? There's no built-in support for time-sliced threads in core; that abstraction is only available in std (see std::thread). The latest stable release brought the async/await feature to...

Learning and Teaching Rust

2020-06-11T22:00:00+00:00

A new series of posts

Our Ferrous Systems team has spent the past five years helping people to learn Rust, either as members of the community, or in the context of paid training services. (Yes, we have been doing this before the company even began...

Coverage Marks

2020-05-27T22:00:00+00:00

In this post, we will discuss an interesting technique for testing test coverage, and the associated Rust crate — cov-mark. The two goals of the post are:

Share the knowledge about a specific testing approach.
Show a couple of Rust tricks...

rust-analyzer: Next Few Years

2020-05-24T22:00:00+00:00

This is a repost from rust-analyzer blog.

rust-analyzer is a new "IDE backend" for the Rust programming language. Support rust-analyzer on Open Collective.

During the past several months, I’ve been swamped with in-the-trenches rust-analyzer...

Oxidize Global Workshop and CfP announcement

2020-05-10T22:00:00+00:00

Last week, we announced Oxidize Global, a 4 day online Rust conference with workshops, talks and Impl. days happening all around the world. Oxidize Global takes place on July 17-20, 2020. Read our full announcement over here.

Today, we are announcing...

Oxidize Global

2020-05-05T22:00:00+00:00

Today we're announcing Oxidize Global, a four day and remote-only conference covering development in Embedded Rust! We want Oxidize Global to be accessible from wherever you live in the world, so we're adjusting the format a bit to make sure everyone...

no_std async/await - soon on stable

2020-05-04T22:00:00+00:00

In about 4 weeks time from the publish date of this blog post, you'll be able to use the async/await feature in no_std code on stable! In this blog post we go over the work we did to make it happen and what we learned from building a proof of concept...

First Release of rust-analyzer

2020-04-28T22:00:00+00:00

This is a repost from rust-analyzer blog.

I am pleased to announce the first alpha release of rust-analyzer — a new "IDE backend" for the Rust programming language. Support rust-analyzer on Open Collective.

Wait a second… Haven’t people been...

Embedded Rust pattern - Zero Sized References

2020-04-23T22:00:00+00:00

"Zero Sized Reference" (ZSR) sounds like an impossible thing given that mem::size_of returns a non-zero value for references to Zero Sized Types (ZST) like &() but ZSRs can in fact be constructed and they can improve both the performance and correctness...

Ferrous Systems online Rust courses

2020-04-23T22:00:00+00:00

Ferrous Systems is a major Rust training provider and has been offering Rust trainings for all fields since 2015.

Having invested some time and effort over the last month to provide an online offering, we are happy to announce our online training...

async/await on embedded Rust

2020-03-04T23:00:00+00:00

In a previous post we explored what needs to be done on the rustc side to bring async/await to no_std Rust.

In this post we'll explore what could be done once async/await is available in no_std land and why we think async/await is a big deal for embedded...

Oxidize 2020 Update

2020-03-03T23:00:00+00:00

After an amazing response to our initial announcement, we're ready to share more details about Oxidize 2020! Here's a quick summary of the information:

Oxidize 2020 will be July 17th-20th
- July 17th: Workshops
- July 18th: Conference...

Ferrocene Update

2020-02-12T23:00:00+00:00

Update: Ferrocene is now officially qualified and open sourced 🎉🎉🎉
Please note that Ferrocene was previously named "Sealed Rust".

Ferrocene is the effort led by Ferrous Systems GmbH to qualify the Rust language and compiler for use in mission and...

rust-analyzer 2019 Financial Report

2020-02-11T23:00:00+00:00

This is a repost from rust-analyzer blog.

This is a short financial report for Open Collective money for 2019.

We’ve got 9933 EUR on open collective after fees. We’ve rounded that number up to 10000 (using some funds from this year) and split...

Training in London March 2020

2020-02-09T23:00:00+00:00

We are happy to announce that we are now offering a Rust training for beginners in London, hosted by our partner TrueLayer! TrueLayer builds universal APIs that allow companies to access the financial data of their end user to initiate direct bank...

Bringing async/await to embedded Rust

2020-02-06T23:00:00+00:00

At Ferrous Systems, we've worked on a wide range of software in Rust, from embedded systems, to highly concurrent asynchronous applications. While the environments that these systems operate in are wildly different, they both can be boiled down to...

Oxidize 2020 - The Embedded Rust Conference

2020-01-19T23:00:00+00:00

Oxidize 2019 was our way to put professional embedded development in Rust on the table as a serious topic. It was a great success, selling out the full conference!

Over the last months, people have asked us if there’s going to be an Oxidize 2020...

rust-analyzer: Find Usages

2019-11-13T09:00:00+00:00

This is a repost from rust-analyzer blog.

Last month, rust-analyzer gained an exciting new feature: find usages. It was implemented by @viorina in #1892.

This post describes how the feature works under the hood. It's an excellent case study to compare...

Cost of rust-analyzer

2019-10-16T09:00:00+00:00

This is a repost from rust-analyzer blog.

In this post, we'll talk about financial side of the rust-analyzer project. The goal is to find out how much rust-analyzer costs now, formulate financial goals for speeding up the development and document...

Happy First Birthday, Ferrous!

2019-09-30T22:00:00+00:00

Ferrous Systems GmbH was fully incorporated in Berlin, on October 1st, 2018; which makes today Ferrous' first birthday!

It's been a busy year (or really more than a year) for us, full of ups, downs, growth, challenges, stress, and opportunities, and...

rust-analyzer changelog #0

2019-08-30T22:00:00+00:00

Hello!

This is the first instance of a monthly changelog for rust-analyzer. This changelog also serves as a transparency measure for our OpenCollective. We want to thank all sponsors, especially Embark Studios, as well as all individual contributors...

Rust Summer Classes

2019-07-08T10:00:00+00:00

Ferrous Systems has moved! Besides travelling all over the world to train people in Rust, we are now able to offer courses in our new space in Berlin. We are kicking off this new service with our Rust Summer Classes!

Whether you’re just starting to...

Status of rust-analyzer: Achievements and Open Collective

2019-07-01T22:00:00+00:00

rust-analyzer is an experimental compiler frontend for the Rust programming language. The ultimate goal for this project is to provide the perfect IDE experience for Rust, with all IDE features working flawlessly while editing code.

I began working...

Ferrocene

2019-06-04T22:00:00+00:00

Note: Ferrocene used to be called "Sealed Rust".

This is the first post in a series detailing Ferrous System's plan to qualify the Rust language and compiler for use in the mission and safety-critical domains. We call this effort Ferrocene.

The design and implementation of a lock-free ring-buffer with contiguous reservations

2019-06-03T10:00:00+00:00

This is the story of how Andrea Lattuada (PhD student at ETH Zurich) and James Munns (from Ferrous Systems) designed and implemented (two versions!) of an high-perf lock-free ring-buffer for cross-thread communication. If any of those words look scary...

Oxidize Berlin 2019 In Retrospect

2019-05-20T10:00:00+00:00

On April 25th to 29th, Ferrous Systems organized and hosted Oxidize - the first global Rust conference focused on embedded and IoT subjects. It included a day with three workshops and a conference day with 13 talks.

Talks were practical and presented...

Graphical Debugging with Embedded Rust

2019-01-25T16:00:00+00:00

So, I recently re-discovered gdbgui - a python tool that attaches to a GDB server and provides a graphical frontend in your browser. It turns out, this works really well for Embedded Rust Development! This also works across Windows, Mac, and Linux...

Rust Analyzer in 2018 and 2019

2018-12-15T16:00:00+00:00

Hi! I am Aleksey Kladov (aka @matklad). In the past, I've worked at Jet Brains where I've helped to create the IntelliJ Rust plug-in, and now I am a part of the Ferrous Systems team.

I've spent a significant amount of the last year experimenting with...

Oxidize - The Embedded Rust Conference

2018-11-25T00:00:00+00:00

Now that we have announced OxidizeConf, we wanted to share a bit more detail about what is going on behind the scenes, what we have planned already, and what to expect. Some details may change as we get closer to the final date.

TL;DR

We're currently...

The last few weeks at Ferrous Systems

2018-10-25T10:00:00+00:00

Hello everyone and welcome to our first blog post! We became a little silent after announcing this company at RustConf. This was mostly due to finalising all the paperwork. We wanted to take the chance to introduce ourselves a little and talk about...