KideRT kernel architecture

KideRT has a microkernel architecture that keeps the kernel small. Device drivers, protocol stacks, file systems and your application run above it as threads in user space.

From user space to the hardware

Hover over the Application and kernel blocks for what they do.Tap the Application and kernel blocks for what they do.

User space

ApplicationPOSIX at the kernel interface. KideRT implements a documented subset of POSIX.1-2024 natively in the kernel. Threading, synchronisation, message queues and timers use that interface. Compatibility is defined by the implemented API subset. Read about the POSIX interface

Application IPC
Device drivers
Protocol stacks
File systems
Services

Kernel space

KideRT

Basic IPCThreads need more than CPU time. Mutexes control access to shared resources. Semaphores coordinate availability. Message queues pass data between threads. KideRT provides these primitives at kernel level, giving application components defined ways to coordinate work.
SchedulingThe next event sets the timer. KideRT programs the hardware timer for the next scheduled event. Its preemptive scheduler manages runnable threads. Timer expiry, interrupt handling and thread execution are distinct parts of the response path. Read the scheduling design
Memory managementAccess has boundaries. On processors with an MPU, configured permissions govern which memory an application context can read, write or execute. A disallowed access raises a fault. The fault handler determines what happens next. Explore memory protection

Arm Cortex-M hardware

Kernel and user space

KideRT is a microkernel, meaning it keeps only basic IPC, scheduling and memory management in the kernel. Everything else, KideRT’s own services included, runs as threads in user space, like your application, and talks to the kernel through IPC.

That is Jochen Liedtke’s minimality principle. The kernel keeps only what cannot work outside it.

Privilege and memory protection

With memory protection enabled on a processor with an MPU, the kernel and interrupt handlers run privileged and threads run unprivileged. A thread reaches the kernel through POSIX.1-2024 calls, cannot touch kernel memory or other threads’ stacks, and accesses peripherals only through a region granted to it.

Basic IPC: Mutexes, semaphores and message queues, through calls such as pthread_mutex_lock(), sem_wait() and mq_send(). A thread that cannot proceed waits without using CPU time.
Scheduling: Threads, priorities, sleeps and timers, through calls such as pthread_create(), pthread_setschedparam(), clock_nanosleep() and timer_settime(). The highest-priority ready thread runs. The kernel masks interrupts only briefly, so a handler starts soon after its hardware event.
Memory management: Optional, on processors with an MPU. The kernel applies the memory permissions configured for each thread, and the MPU checks every access against them.

Target-specific configuration

Explore supported processors

Processors: Arm Cortex-M
Timer and interrupts: Support is determined by the processor and port.
Memory protection: Optional. Requires a processor with an MPU.

Included with KideRT

Included: The kernel and its own services, as full source code with the commercial licence.
Not included: Device drivers, protocol stacks and file systems. Use your own or third-party components.

Evaluate KideRT

Talk to engineering contact@preemptsystems.com