Aerugo is a safety-critical, cooperative Real-Time Operating System written in Rust for space applications, developed under an ESA activity targeting the Microchip ATSAMV71Q21 (ARM Cortex-M7). The code confirms a genuine, working RTOS: a non-preemptive executor schedules fine-grained type-erased tasklets by priority, alongside primitive event sets, message queues, boolean conditions, cyclic execution, and per-tasklet execution statistics with timeout events. It is designed for no_std, no-alloc, static-allocation environments, using a hand-rolled vtable instead of trait objects to avoid dispatch overhead. An x86 backend exposes the same APIs on the host for development and testing without the SAMV71 hardware. The repo is a Rust workspace: the core aerugo RTOS crate, a generic AerugoHal trait, a comprehensive SAMV71 HAL (SPI, UART, PIO, timer waveform channels, XDMAC DMA, watchdog, PMC clock config, FPU), a large svd2rust-generated Peripheral Access Crate, an x86 HAL stub, utility crates (bounded-int, bitfield-enum, lsm6dso IMU driver, env-parser), and example/demo applications including a CCSDS-based SPI accelerometer telemetry demo. The HAL makes strong use of the typestate pattern (e.g., Spi<NotConfigured> transitioning to Spi<Master>; UART reader/writer token ownership) to enforce correct hardware usage at compile time. The testing infrastructure is unusually strong for an embedded RTOS: the custom 'calldwell' Python harness orchestrates hardware-in-the-loop tests over SSH, GDB, RTT and UART, with SRS requirement IDs traceable to test cases. However, some design-level requirement tests are empty stubs, and the generated PAC contains artifacts including literal '[%s]' placeholder names in register descriptors. Requires nightly Rust (unstable tracked-environment proc macro), and at least one suspected clock-prescaler mapping bug exists in the PMC configuration code. Duplicated utility macros have already started to diverge between crates. Overall this is a professional-grade RTOS with several genuinely reusable components and elegant embedded Rust patterns, held back slightly by generated-code bloat, incomplete traceability stubs, and a narrow single-MCU focus.