Open-source project
eclipse-threadx/threadx avatar
eclipse-threadx/threadx

Eclipse ThreadX: a picokernel RTOS whose master branch is not a release, with separate port trees for plain, module and SMP builds

Eclipse ThreadX is an advanced real-time operating system (RTOS) designed specifically for deeply embedded applications.

3,571 stars944 forksCMIT

At a glance

What is it?
eclipse-threadx/threadx is the MIT licensed C source of the ThreadX RTOS for deeply embedded targets. The repository is organised around per-architecture, per-compiler ports and three distinct kernel flavours, and it asks you to build from tagged releases rather than master.
Who is it for?
Choose ThreadX when your target appears in one of the three port lists and you can build from a tagged release, ideally through a vendor SDK or the CMake path. Look elsewhere, or budget for porting work, if your core is missing from the port tree or if you need threadx modules on a core other than the eleven listed.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 6 days ago.
What is it written in?
Mainly C, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • eclipse-threadx/threadx3,571 ★ · +40
Star history
Repository2026-09-242026-11-15
eclipse-threadx/threadx3.5k3.6k

40 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The master branch is explicitly not the latest release

The default branch is master, and the project states that it has the most recent code with all new features and bug fixes but does not represent the latest General Availability release. Official releases, preview or GA, are tagged and pushed to the GitHub releases tab, for example v6.2-rel.

The three most recent tags are v6.5.1.202602a_rel on 2026-06-08, v6.5.2.202603_rel on 2026-10-02 and v6.5.2.202603b_rel on 2026-11-01, and the last push to the repository was on 2026-11-02. So the project is moving, but master runs ahead of any tag.

The repository gives you a way to spot unreleased code: when a function header shows xx-xx-xxxx, 6.x or x.x in the release field, that file is not officially released yet and will be updated in the next release. The consequence is practical. If you build a product from a master checkout, you ship code that has not been through a tagged release, so pin a tag.

Each port is an architecture and compiler pair with its own tx_port.h

Architecture specific work lives under ports, in one directory per core and then one per toolchain. The example in the project is cortex_m7, which contains iar, ac6 and gnu directories. The iar one holds an example IAR workspace and sample project files, an inc folder with tx_port.h for that architecture, and a src folder with the source files for it.

The layout means a port is not just a core name. The same Cortex-M7 chip has different files depending on whether you compile with IAR, Arm Compiler 6 or GNU, so choosing a port means choosing both. If your compiler is not in that directory for your core, you are in porting territory.

The sibling directories ports_modules and ports_smp repeat the pattern for the other two kernel flavours, which the next sections cover. The top level also lists a ports_arch and a ports_module folder.

The standard port list is wide, from Cortex-M0 to Xtensa and RISC-V 32

The standard ThreadX port list includes arc_em, arc_hs, arm11, arm9, c667x, linux, risc-v32, rxv1, rxv2, rxv3, win32 and xtensa, plus Cortex-A cores from a5 up to a76a, Cortex-M cores m0, m3, m4, m7, m23, m33, m55 and m85, and Cortex-R cores r4, r5 and r7.

Two entries are worth noting for development. linux and win32 are listed as ports, so the kernel can run on a host machine, which helps when you want to run kernel code without target hardware.

The gap to watch is anything not in the list. There is no entry for architectures outside it, and the repository gives no instruction for adding one beyond the port directory structure itself. If your core is absent, expect to write the architecture specific files and tx_port.h yourself.

The feature summary also matters when you compare kernels on paper. The project names advanced scheduling facilities, message passing, interrupt management and messaging services, along with picokernel architecture, preemption threshold, event chaining and a rich set of system services. Those are the headline capabilities you would verify against your own timing and memory requirements, since the repository text gives no benchmark figures.

ThreadX Modules cover only eleven ports, so dynamic loading is narrower than the base kernel

ThreadX Modules provide an infrastructure for applications to dynamically load modules that are built separately from the resident portion of the application. The module port list is short: cortex_a35, cortex_a35_smp, cortex_a7, cortex_m0+, cortex_m23, cortex_m3, cortex_m33, cortex_m4, cortex_m7, cortex_r4 and rxv2.

Compare that to the base list. Cortex-M55 and Cortex-M85 are in the standard ports but not in the module list, as are Cortex-R5, Cortex-R7, risc-v32, xtensa and the ARC cores. A product built on one of those cannot use the module feature through a listed port.

The cost of ignoring this is discovered late. A design that depends on loadable modules has to be checked against this list on day one, because choosing a Cortex-M85 part would leave you without a ready port for the module infrastructure.

ThreadX SMP is a separate kernel with its own twenty port directories

Eclipse ThreadX SMP is described as a high-performance real-time SMP kernel designed specifically for embedded applications, and it has its own port directory, ports_smp, along with common_smp for the core files. The list covers arc_hs_smp and Cortex-A cores from a5 to a78, such as cortex_a53_smp, cortex_a57_smp, cortex_a72_smp, cortex_a77_smp and cortex_a78_smp, and also linux.

This tells you how to read the repository. SMP is not a build switch on the standard kernel. It is a parallel set of sources and ports. No Cortex-M or Cortex-R appears in the SMP list, so those families are uniprocessor choices in this repository.

The practical decision is made at the start: pick standard or SMP from the target core, then pick the port, instead of expecting to turn on multicore later.

Adaptation layers help migration, but they are layers, not compliance claims

To ease application migration, the project provides adaptation layers for various legacy RTOS APIs, naming FreeRTOS, POSIX and OSEK, and they sit in utility/rtos_compatibility_layers. The text says to ease migration, nothing more.

So an application written against the POSIX API can be pointed at ThreadX through the layer, but the repository makes no statement that ThreadX itself is POSIX compliant. Likewise the FreeRTOS layer is a bridge for existing code, not a promise of identical behaviour. Check the layer source for the specific calls your code uses before you rely on it.

The components of ThreadX each live in their own repository, with dependencies between them, and the project warns that you must take the dependency graph into account when building anything other than ThreadX itself. A build that pulls in more than the kernel therefore needs the sibling repositories checked out as well.

Build from source with CMake and Ninja, or take it through a vendor SDK

There are two routes. The first is a vendor one: ThreadX is integrated into the SDKs and development environments of STMicroelectronics, NXP, Renesas and Microchip, and if you use a semiconductor's toolchain and IDE you follow its instructions. The project also keeps separate getting started and samples repositories for development boards.

The second is a library build with the Arm GNU Toolchain and CMake. You install CMake version 3.0 or later, the Arm GNU Toolchain for arm-none-eabi and Ninja, then clone:

bash
$ git clone https://github.com/eclipse-threadx/threadx.git

Next you define the features and add-ons you need in tx_user.h and build together with the component source code, using common/inc/tx_user_sample.h as a reference. Each component is then built as a static library.

The consequence of the tx_user.h step is that the kernel is configured at compile time. There is no runtime configuration file, so a wrong setting means rebuilding. The top level also contains build-all.log and ctest-all.log, and the repository has test and utility directories with test cases.

Editorial conclusion

Choose ThreadX when your target appears in one of the three port lists and you can build from a tagged release, ideally through a vendor SDK or the CMake path. Look elsewhere, or budget for porting work, if your core is missing from the port tree or if you need threadx modules on a core other than the eleven listed. Before committing, check the port directory for your exact core and compiler and pin a release tag.

Frequently asked questions

What is ThreadX?

Eclipse ThreadX is an advanced real-time operating system designed for deeply embedded applications, with a picokernel architecture, preemption threshold and event chaining.

Is ThreadX open source?

The eclipse-threadx/threadx repository on GitHub is licensed under MIT, and its source is public on the master branch with tagged releases.

Is ThreadX POSIX compliant?

The repository does not claim compliance. It provides adaptation layers for legacy RTOS APIs including POSIX, FreeRTOS and OSEK under utility/rtos_compatibility_layers.

Official sources

  1. eclipse-threadx/threadx on GitHub
  2. License: MIT
  3. Project website
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/eclipse-threadx-threadx.svg)](https://hysenlabs.com/projects/eclipse-threadx-threadx)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/eclipse-threadx-threadx.svg)](https://hysenlabs.com/projects/eclipse-threadx-threadx)

Was this useful?