Kairos — FreeRTOS Remade In Rust, Kernel And All

FreeRTOS runs on more chips than most people will ever name. Doorbells, meters, radios, the board in the hallway — a fixed-priority preemptive kernel written in C, with a CVE class that follows every C kernel. The Arduino promise was setup() and loop(). The substrate under that promise was still a C scheduler.

Kairos is FreeRTOS remade in Rust: an umbrella over the rusty_rtos family — kernel, core, ports, heap, demo, and a C ABI so existing C demos relink. rusty_rtos is the implementation name. Kairos is the program. The catalog is Remade with Rust. The thesis is rebuilding the foundation of the internet. This article is the kernel.

Why Kairos Is FreeRTOS Remade In Rust

A real-time kernel is a state machine that touches every interrupt. When that state machine is C, a bad pointer is a silent reset or a hijacked task. The NIST Secure Software Development Framework pushes memory-safe languages for this class of code. Kairos is that push as an RTOS. FreeRTOS remade in Rust means the scheduler is a pure state machine over a Port seam, forbid(unsafe) in the kernel, traced against the C kernel so behavior stays honest.

rusty_rtos is not a binding. A crate that calls FreeRTOS over FFI has not remade FreeRTOS. Kairos remakes it.

Trust, Security, and Incentive fail when the home device is the weakest node on the network. Trust fails when the doorbell's kernel is a vendor blob. Security fails when the scheduler is C. Incentive fails when the safer kernel cannot relink the demos people already have. Kairos is how those three primitives apply below loop().

What Kairos Ships As The rusty_rtos Family

Kairos is the umbrella. The crates are named rusty_rtos_* so a search finds the kernel, not a mythology. FreeRTOS remade in Rust is a family because a kernel that hard-codes a port is a toy.

rusty_rtos_kernel — The Kairos Scheduler

rusty_rtos_kernel is the fixed-priority preemptive scheduler: notifications, queues, semaphores, mutexes with priority inheritance, timers, event groups. It is a pure state machine over the Port seam. It forbid(unsafe). It is traced against the C kernel so a task that unblocked in FreeRTOS still unblocks in Kairos. That is FreeRTOS remade in Rust at the place that matters.

The kernel does not hide behind "we are inspired by FreeRTOS." It is measured against it.

rusty_rtos_core And rusty_rtos_port

rusty_rtos_core is ticks, priorities, the Config trait, and the Port / Heap / Trace / Hooks seams — no pointers. That is how Kairos stays a state machine instead of a bag of *mut. rusty_rtos_port is the ports: a sim oracle, Posix, Cortex-M, RISC-V, Xtensa. The only fenced unsafe lives at the context switch. That is the Remade with Rust rule applied to an RTOS.

The sim oracle is how Rust on Arduino already runs a sketch before the board arrives. Kairos is that idea as a kernel. rusty_rtos is how FreeRTOS remade in Rust gets CI without a probe.

rusty_rtos_heap, Demo, And C ABI

rusty_rtos_heap ships heap_1 / heap_4 / heap_5 plus rusty_alloc. The heap story matches the rest of the house stack. rusty_rtos_demo is the proof you can flash. rusty_rtos-capi is a C ABI so C demos relink. That last crate is Incentive. FreeRTOS remade in Rust that cannot take a C demo is a rewrite nobody ports.

The Electronic Frontier Foundation has documented how "smart home" claims collapse when the firmware still phones a vendor cloud. Kairos is the kernel that lets the firmware stay yours. rusty_rtos is the code.

How Kairos Feeds The Distributed Cloud

A distributed cloud that stops at the phone and ignores the chip in the wall is a cloud with a C basement. Kairos is FreeRTOS remade in Rust so the basement is Rust.

Trust The Task, Secure The Kernel

Trust is a task you scheduled on hardware you hold. Security is Kairos — rusty_rtos with forbid(unsafe) in the kernel and fenced unsafe only at the switch. Incentive is the C ABI and the ports people already ship. The NIST Zero Trust Architecture tells operators to stop trusting the perimeter. Kairos is how you stop trusting the C scheduler as well.

Era 4 is a home companion. That companion has a kernel. FreeRTOS remade in Rust is how the companion is not a vendor RTOS with a pretty app.

Disco Party At The Chip Edge

Disco Party is the mesh. Some nodes are phones. Some are boards. rusty_rtos is how those boards join without a C kernel. The Freedom Guide is personal data; Kairos is the firmware under the sensor that collected it. dldeploy is the home-sensor flash path those boards take when they stay in the house. AI on the edge still needs a scheduler when the model shares a chip with a radio.

The FTC cares what a home device sends. A memory-safe kernel is how you make "it only sends what we said" a compile-time story, not a firmware-update story.

The Catalog Entry For Kairos

The rusty_rtos family lives under github.com/Remade-With-Rust. Cards and shipping status live on the Remade with Rust catalog. The mesh this kernel feeds is what a distributed cloud is and the Disco Party. Digital Freedom is Trust, Security, and Incentive.

If you came from the Learn index looking for FreeRTOS remade in Rust, this is Kairos. If you came from FreeRTOS, rusty_rtos is the remake — kernel and all. The internet you want to own still has chips. Kairos is how that sentence stays true without the C kernel.

The amateur sketch above that kernel is secure and easy Arduino. Timekeeping for the same class of node is rusty_time. The heap those tasks sit on is rusty_alloc. Those nodes as the mesh, not a rack, are Rust edge nodes.