Why Did Real‑Time Linux Take 20 Years to Reach the Mainline Kernel?

For more than 20 years, work on real‑time Linux (PREEMPT_RT) benefitted the open‑source operating system, but only this week did Linus Torvalds merge its final part into the mainstream kernel, prompting the question of why it took so long.

What is an RTOS?

RTOS stands for Real‑Time Operating System, a specialized OS designed to handle time‑critical tasks with precise, reliable timing. Unlike general‑purpose OSes such as Windows or macOS, an RTOS guarantees that critical tasks complete within strict deadlines, often measured in milliseconds or microseconds. As Linux real‑time developer Steven Rosedt puts it, “real‑time is the fastest worst‑case scenario.” The core characteristic of an RTOS is deterministic behavior, ensuring reliability over raw speed. Examples include VxWorks (used in NASA’s Mars rovers and Boeing 787 avionics) and QNX Neutrino (widely used in automotive infotainment and advanced driver‑assist systems).

History of Real‑Time Linux

The story began in the late 1990s when demand grew for Linux to support real‑time applications. Early efforts created separate real‑time kernels, such as the University of Kansas’s KURT project, the University of Milan’s RTAI, and New Mexico Tech’s RTLinux. In 2004, kernel veteran Ingo Molnar started consolidating these techniques into a single patch set, laying the groundwork for PREEMPT_RT.

By 2006 the patch set attracted enough interest that Linus Torvalds remarked, “Controlling a laser with Linux is crazy, but everyone in this room is crazy in their own way. If you want to control an industrial welding laser with Linux, I don’t object to you using PREEMPT_RT.”

From 2009 onward, a core team—including Thomas Gleixner, Peter Zijlstra, and Steven Rosedt—merged the prototypes into a standalone out‑of‑tree patch collection. Companies began adopting the patch for millisecond‑precision industrial systems, and many of its features gradually migrated into the main kernel.

Why It Took So Long

Real‑time Linux required multiple rewrites of each component before being accepted into the mainline, reflecting the kernel’s high standards for code quality. Political and perception issues also played a role; early developers were discouraged from even mentioning “real‑time.” Funding was unstable, and the Linux Foundation only created the Real‑Time Linux (RTL) collaborative project in 2015 to coordinate work around PREEMPT_RT.

Technical hurdles included the long‑standing printk debugging function, which introduces hard delays unacceptable for real‑time workloads. Modifying printk without breaking other kernel behavior proved difficult, and latency spikes from its messages (e.g., 30 µs to 5 ms) had to be mitigated.

Key Features Integrated into Mainline

Introduction of mutexes for better synchronization.

Ftrace, a powerful Linux tracing tool.

Priority inheritance for user‑space applications.

NO_HZ, which reduces idle‑system power consumption and enables efficient operation on machines with thousands of CPUs.

These features, once optional, are now part of the standard kernel, allowing Linux to run efficiently in data‑center environments and on a wide range of industrial hardware.

Impact and Future

With the PREEMPT_RT patch merged, the Linux kernel is now fully preemptible, capable of responding to events within microseconds. This deterministic performance is crucial for industrial control systems, robotics, and audio production, where precise timing is essential.

The integration marks a milestone: Linux is now positioned as a serious contender in the RTOS arena, benefiting both real‑time manufacturers and the broader Linux community.