MARK3 The RTOS Platform for Big Ideas on Small Devices


Mark3 is a sophisticated, modern RTOS and application development platform, targeted towards a growing list of today's most compelling embedded devices.

It currently supports a variety of Atmel AVR, TI MSP430, and ARM Cortex-M series microcontrollers, with other platforms to follow.


Let's face it, there are literally hundreds of RTOS on the market - it's a commodity tool that the majority of embedded systems developers either use on a regular basis, or consider for their products.  So with so many options out there, why would anyone bother "reinventing the wheel" yet again?  Isn't the RTOS a solved problem?

I would argue that there's room for more competition in the market, and that there's even more room for new ideas, new techniques, and products that challenge the status quo.  Mark3 challenges the incumbent free and commercial offerings in a number of key areas, and endeavours to set new standards in others.


Mark3 was designed from the ground-up using disciplined object-oriented design principles - and unlike the vast majority of free or commercial RTOS' is written entirely in C++.  The carefully designed object model drastically reduces the overall size and complexity of the source code, leading to enhanced code reuse, stability, and modularity.  It also makes the source easier to understand - any experienced C++ developer should be able to understand the relationship between objects in the system, as well as use and extend them to fit a given application.


While Mark3 endeavours to break new ground, it also features commercial-grade implementations of common RTOS features, including:

  • Deterministic, multiple-priority preemptive scheduler, with round-robin scheduling within each priority
  • Binary and counting semaphores
  • Mutex objects supporting both recursion and priority inheritence
  • Event flags for efficient synchronization of multiple threads
  • Dynamic message queues for IPC
  • Device driver (open/close/read/write/ioctl) infrastructure baked into the kernel
  • Tickless software-based timers for maximum CPU, interrupt, and power efficienccy 
  • High accuracy code-profiling timers
  • Extendable debug infrastructure for runtime debugging and critical error handling


Mark3 is much more than just a class-leading RTOS kernel - it is an ever-growing platform featuring a wide array of middleware, meaning that you can get your product out the door sooner. 

Besides the kernel, Mark3 currently offers the following middleware components, many of which are large enough to be their own projects:

  • A growing selection of device drivers for supported parts
  • Threadsafe, deterministic fixed-block heap implementation
  • Lightweight string and memory manipulation library
  • The lightweight NLFS (Nice Little File System) library
  • A robust multiplexed serial communications protocol (FunkenSlip)
  • A custom bootloader (AVR Only) with cross-platform flashing utility
  • An end-to-end graphics and GUI solution
  • A customizable VM implementing the DCPU-16 architecture


Mark3 was written with best-practices for software engineering in mind, and is implemented by an industry veteran with over a decade of experience in embedded real-time system design. 

The source code is expertly crafted with a consistent, modular design.  Each feature is broken out into its own module for ease of maintenance, and ease of understanding.  All code is commented with doxygen to provide comprehensive API documentation for all parts of the system.  Code is further annotated to explain all implementational nuance, and guide the user into understanding how the source works.  All documentation is provided free-of-charge, and is available in both browseable HTML and PDF form.  All source code is developed to a strict coding standard which guarantees portability, consistency in style, and is excpetionally "human-readable".

Testing is key to quality, and Mark3 features a dedicated suite of unit and sanity tests to ensure that changes in the code do not introduce regressions or break key functoinality.  This guarantees that Mark3 always works as expected on target platforms, so you can be sure that the high degree of quality behind Mark3 is maintained from one release to another.  All test code is included, so you can run the framework manually to verify the results for yourself.

A recursive-make based build system automates not only simplifies the generation of Mark3 libraries and executables, but also the creation of documentation, and the execution of tests prior to any release. Rigorous use of version control (SVN) is used to manage the development of all core components, and is managed using industry best-practices.


The BSD license used by Mark3 is extremely permissive, allowing you to integrate it into your products on your terms.

Mark3 will never come with hidden costs - there will never be a fee for the code, documentation, or middleware, and no commissions or any royalties are required for its inclusion in any product.
Community contributions to Mark3 are welcome, and a vetting process is leveraged to ensure no IP leakage makes its way into core components.

Mark3 also aligns itself with open hardware projects, such as Arduino.  As a result, extra effort is made to ensure that Mark3 runs on official Arduino hardware platforms (such as the Arduino Uno and Mega).  This powerful combination provides developers with the easiest-to-use, most cost-effective way to get started with a feature-rich, high-quality RTOS.