PreemptSystems

KideRT is a Real-Time Operating System for Arm Cortex-M.

RTOS designed for robotics, industrial automation and industrial IoT.

Talk to engineeringRead the documentation

High-Resolution Scheduling

KideRT programs the hardware timer for the next scheduled event instead of interrupting on every tick. The timer fires when there is work to wake, and timed wakeups are not rounded up to a tick boundary.

Timer resolution, interrupt handling and the priority-based preemptive scheduler together decide when your code runs. The scheduling page follows each step, from the timer event to your thread running.

Read the scheduling design
Timer interrupts in 20 ms with three timed eventsModel
ABC
Tick-Resolution Scheduling, 1 ms tick20 interrupts
High-Resolution Scheduling, next-event timer3 interrupts
01020 ms

O(1) system calls

Every KideRT system call is O(1). The work the kernel does on a call does not grow with the number of threads, timers or waiters in your application.

The worst-case execution time of a call is set by the target, meaning the core, its clock, the compiler and the options in the build. Measure it on the target, and treat an observed maximum as the maximum of that run, not as a bound.

Read about O(1) system calls
Worst-case execution time (WCET) per system call as the application growsModel
Worst-case execution time per system call as the application growsA line chart without numbers. KideRT’s worst-case execution time per call is a flat line, the same however many threads, timers or waiters the application has. A worst-case execution time that grows with the application rises from the same starting point.KideRT, O(1)O(n) RTOS

A WCET at any sizeA WCET that grows with the application

Memory protection

On processors with an MPU, KideRT can enforce which memory regions application code may access.

A disallowed access raises a fault, and the fault handler determines what happens next. Fault detection and system recovery are separate design decisions.

Explore memory protection
The MPU checks every CPU accessExample policy

Thread A accessWriteThread B stack

Memory regionThread A permission
Application codeRead + execute
Thread A stackRead + write
Thread B stackNo access
Kernel dataNo access
Shared bufferRead + write

Access deniedWrite blocked, fault raised

POSIX interface

KideRT implements a documented subset of POSIX.1-2024 natively in the kernel. Threads, mutexes, semaphores, message queues and timers use the interface your code already knows.

Code written to the subset builds for KideRT and for embedded Linux from the same source.

Read about the POSIX interface
The same code on KideRT and on LinuxPeriodic thread
#include <pthread.h>
#include <time.h>

#define PERIOD_NS 250000L   /* 250 µs */

static void *sampling(void *arg)
{
    struct timespec next;

    clock_gettime(CLOCK_MONOTONIC, &next);
    for (;;)
    {
        next.tv_nsec += PERIOD_NS;
        if (next.tv_nsec >= 1000000000L)
        {
            next.tv_sec += 1;
            next.tv_nsec -= 1000000000L;
        }
        clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &next, NULL);
        read_sensor(arg);
    }
}

Latest release

The latest version is 1.2.1. It ships as full kernel source with the user manual, and builds with the Arm GNU Toolchain.

Footprint figures are measured and published with each release, with the cost of each optional feature, so a target can be sized before an evaluation.

Version
Latest version 1.2.1. See changelog.
Documentation
User manual UM1001.
Source code
Full kernel source, with a default board support package for Cortex-M.
Toolchain
Arm GNU Toolchain.
Footprint
12.4 KiB ROM and 3.6 KiB RAM with minimal configuration on Cortex-M3 at -Os. See footprint tables.

Licensing and support

Licensed per product and royalty-free. Each licence includes the latest source, plus a year of updates and support from KideRT’s developers.

Read about licensing
Licence
Commercial, one product per licence.
Royalties
None per unit shipped.
Updates and support
One year included, renewable.

  • Evaluation

    Start an evaluation path on your own board. KideRT’s developers support you all the way to production.

    Plan an evaluation

  • Supported cores

    KideRT runs on Arm Cortex-M. Porting is available on request.

    See supported processors

  • Documentation

    The user manual for the latest version, 1.2.1, covers how the RTOS is built, configured and called, and its ROM and RAM footprint.

    Open the user manual

Evaluate KideRT for your application

Discuss your target hardware, timing requirements and evaluation needs with our engineers.

Talk to engineeringcontact@preemptsystems.com