Jorge Aparicio

Everything you need to know about cross compiling Rust programs!

Travis CI and AppVeyor template to test your Rust crate on 5 architectures and publish binary releases of it for Linux, macOS and Windows

The sysroot manager that lets you build and customize `std`

Whole program static stack analysis

[INACTIVE] Rust's standard library, free of C dependencies, for Linux systems

How-to: Sanitize your Rust code!

a smaller, faster and panic-free alternative to core::fmt

This crate guarantees that your application is free of panicking branches

Unit `#[test]`ing for microcontrollers and other `no_std` systems

HAL for the STM32F103xx family of microcontrollers

Raw system calls for Rust

Board Support Crate for the STM32F3DISCOVERY

Machine scalar casting that meets your expectations

Tool to print stack usage information emitted by LLVM in human readable format

A blog about Rust and embedded stuff

Tools for analyzing ITM traces

Lightweight logging framework for resource constrained devices

Rust on the Zynq UltraScale+ MPSoC

Type aliases to C types like c_int for use with bindgen

Madgwick's orientation filter

Cooperative multitasking (AKA async/await) on ARM Cortex-M

Implementation of the `embedded-hal` traits for STM32F30x microcontrollers

A fresh look at embedded Rust development

A platform agnostic driver to interface the MFRC522 (RFID reader/writer)

Fixed Point Arithmetic

DEPRECATED

WS2812B LED ring controlled via a serial interface

[Experiment] JNeT: japaric's network thingies

A platform agnostic driver to interface with the ENC28J60 (Ethernet controller)

[Experiment] Real Time for The Masses on Linux

Experiments in `no_std` cooperative multitasking

Peripheral access API for STM32F30X microcontrollers (generated using svd2rust)

Just like `Cell` but with volatile read / write operations

A self-balancing robot coded in Rust

An implementation of the Two-Level Segregated Fit (TLSF) allocator with optimized memory footprint

USB 2.0 data types

A platform agnostic driver to interface with the LSM303DLHC (accelerometer + compass)

Crate to interface full H-bridge motor drivers

Real Time For the Masses (RTFM), a framework for building concurrent applications, for MSP430 MCUs

A heap-less, interrupt-safe, lock-free memory pool for Cortex-M devices

Zero cost stack overflow protection for ARM Cortex-M devices

WIP

[Experiment] A lock-free, wait-free, block-free logger for the ARM Cortex-M architecture

A remotely controlled wheeled robot

No description.

No description.

Yet Another (CMSIS-)DAP Alternative

Flips the memory layout of a program to add zero cost stack overflow protection

A minimal device crate for the LM3S6965

Runs `rustc --print cfg` and parses the output

[Prototype] Real Time for The Masses on the homogeneous dual core LPC55S69 (2x M33)

[Prototype] Real Time For the Masses on the HiFive1

[Proof of Concept] Allocator singletons and parameterized collections on stable

DEPRECATED

Set panic behavior to abort

[Prototype] Real Time for The Masses on the heterogeneous dual core LPC54114J256BD64 (M4F + M0+)

Build scripts for Docker images I maintain at

Library to retrieve information about a Cargo project

No description.

Memory allocators backed by singletons that own statically allocated memory

Statically sized matrices for `no_std` applications

Tool to decode strings logged via the `stlog` framework

How to bootstrap support for a no_std target

A guinea pig

Slides for FOSDEM presentation

Minimal example of using C++ from Rust

RFCs for changes to Rust

No description.

Minimal blog theme for hugo based on Hemingway2

Rust library for build scripts to compile C/C++ code into a Rust library

A no-frills, MIDI-based, command line ear trainer

experiment. do not use

No description.

Slides about the embedded WG for the Rust All Hands 2018 event

A Rust HAL for the nRF family of devices

No description.

You actually want to head to

The Dark Arts of Advanced and Unsafe Rust Programming

Documentation for the upcoming version v0.5.0 of RTFM

[Experiment] slicing by value

Rust on the Hercules RM42 LaunchPad

Fearless concurrency in your microcontroller

Pre-compiled MUSL for use in Travis CI (Ubuntu 14.04)

Some static QEMU binaries

Peripheral access API for STM32F100XX microcontrollers (generated using svd2rust)

References that point into `static` data

Pure Rust implementation of HPKE (https://www.rfc-editor.org/rfc/rfc9180.html)

No description.

No description.

Documentation for Hickory-DNS

No description.

Safe, fast, small crypto using Rust

A modern TLS library in Rust

Basic parser for PEM formatted keys and certificates

CA certificates for use with webpki

a safe, concurrent, practical language

WebPKI X.509 Certificate Validation in Rust

No description.

Real-Time Interrupt-driven Concurrency (RTIC) framework for ARM Cortex-M microcontrollers

Emacs client/library for the Language Server Protocol

Subcommand to show result of macro expansion

No description.

Test: shipping an mdbook with API docs

A test stand for firmware applications. Currently only supports NXP LPC845 microcontrollers.

A collection of example applications build using Riker

A high-performance, end-to-end observability data platform.

A simple cross leveldb build. It's broken, so you probably can't use it.

No description.

No description.

No description.

A debugging toolset and library for debugging embedded ARM and RISC-V targets on a separate host

Strongly typed JSON library for Rust

Semihosting for ARM Cortex-M processors

The Rust Reference

[WIP] Porting `compiler-rt` intrinsics to Rust

Experiments with adding SIMD support to Rust's standard library.

Debug Communication Channel (DCC) API

Home for the Unsafe Code Guidelines working group.

Github hooks to provide an encouraging atmosphere for new contributors

Rust teams structure

Low level access to RISCV processors

No description.

Owned singletons

No description.

The Rust package manager