RMPReal-time kernel — minimal by design

Designed to be minimal ​

RMP deliberately provides every basic RTOS primitive and nothing more: threads, semaphores, mailboxes, FIFOs, message queues, blocking message queues, alarms, scheduler locking, and an efficient memory pool. That minimality is not an aesthetic choice — it is what makes the kernel small enough to understand, test to full branch coverage, and eventually prove.

Portable by design ​

The same kernel source runs on a 32 KB AVR, a 16-bit MSP430, a 32-bit Cortex-R5 and a RISC-V microcontroller. Ports are deliberately kept thin so the abstraction is exercised by real hardware rather than by a simulator. The full list, including every build project and toolchain, is on the ports page.

Graphics without a middleware layer ​

Run it without a board ​

RMP ships two ready-to-run demonstrations that need no hardware:

• x86 Linux — build the 32-bit binary in Project/GCCMF-X86L and watch the benchmark output. RMP runs on top of ptrace and signals, so it is not fast, but every primitive works.
• Famicom / NES — download RMP.nes and load it into your favourite emulator. The Namco 163 mapper is required: its readable IRQ timer is what RMP uses to measure cycles.

One kernel, two roles ​

RMP is a complete bare-metal RTOS, and it is also the reference guest of RVM: the same source tree builds a virtualized variant that runs as an unprivileged virtual machine, with all privileged operations routed through the monitor. The virtualized ports keep the kernel ABI intact, which is why RMP is used to measure the cost of virtualization itself.

All values are CPU cycles, GCC, highest optimization. The benchmark page has the complete tables, including the virtualization overhead columns.

A first thread ​

void Func_1(void* Param)
{
    RMP_LOG_S("Parameter passed is ");
    RMP_LOG_H((ptr_t)Param);
    RMP_LOG_S("\r\n");
    while(1)
    {
        RMP_Thd_Delay(30000);
        RMP_LOG_S("Delayed 30000 cycles\r\n\r\n");
    };
}

void RMP_Init_Hook(void)
{
    RMP_Thd_Crt(&Thd_1, Func_1, &Stack_1, sizeof(Stack_1),
                (void*)0x12345678, 1, 5);
}

That is the whole "hello world": a thread control block, a stack array, and one call. The getting-started guide walks through compiling a real project and reading its benchmark output.