QP-nano  6.9.0
Real-Time Embedded Framework
About QP-nano™

What's new?

To check what's new in QP-nano, please see QP-nano Revision History.

The QP-nano framework is being phased out and is not recommended for new product development.

What is it?

QP-nano™ (Quantum Platform Nano) is an ultra-lightweight Real-Time Embedded Framework (RTEF) for building responsive and modular real-time embedded applications as systems of asynchronous event-driven active objects (concurrent state machines). The QP-nano™ RTEF is a member of a larger family consisting of QP-nano, QP/C, and QP/C++ frameworks, which are all strictly quality controlled, thoroughly documented, and available under dual licensing model.

The QP-nano™ framework is intended for low-end 8- and 16-bit microcontrollers such as AVRmega, MSP430, or 8051 with very limited RAM on board (less then 1KB). If your MCU has more than 1KB of RAM, you should consider the QP/C™ framework instead of QP-nano™.
To use QP-nano™ effectively, you need to understand the key concepts that underline the architecture of the framework and your applications based on the framework.

What does it do?

The main goals of the QP-nano™ framework are:

  • to provide a reusable architecture based on active objects (actors), which is safer and more extensible than the venerable "superloop" commonly used on low-end 8- and 16-bit microcontrollers.
  • to provide a simple-to-use coding techniques for hierarchical state machines, with which to implement the behavior of active objects.
  • to provide efficient and thread-safe event-driven mechanisms for active objects to communicate, such as direct event passing.
  • to provide event-driven timing services (time events).
  • to provide a selection of built-in real-time kernels to run the QP applications, such as the cooperative QV-nano kernel and the preemptive non-blocking QK-nano kernel.
  • to provide portability layer and ready-to-use emulations on the desktop operating systems such as Linux and Windows.
  • to provide a target for modeling and automatic code generation from the QM modeling tool.

What's special about it?

The QP-nano™ Real-Time Embedded Framework (RTEF) is a unique offering on the embedded software market. It provides a modern, reusable architecture of embedded applications, which combines object-orientation with the particular model of concurrency, known as active objects (concurrent state machines). This architecture is generally safer and better structured than the venerable "superloop + spaghetti-code" commonly used on low-end 8- and 16-bit microcontrollers.


The most unique characteristic of the QP-nano™ framework is its tiny footprint, especially in RAM. In this respect, QP-nano™ requires far less resources than even the smallest conventional Real-Time Operating System (RTOS) kernel. In fact, it has been designed to run on microcontrollers, where you cannot fit any traditional kernel. At the same time, QP-nano™ gives you a much higher level of abstraction than a conventional RTOS. With QP-nano™, you work at the level of active objects, state machines and events, as opposed to "superloop" commonly used on low-end 8- and 16-bit microcontrollers.

If you can program your MCU in ANSI-C, you probably can fit in QP-nano™. For example, the article UML Statecharts at $10.99 describes a complete QP-nano™ application (PEdestrian LIght CONtroled (PELICAN) crossing) implemented in a 8051 MCU with 256 bytes of RAM.

Object Orientation

Even though it is written in MISRA-compliant ANSI-C, QP-nano™ is fundamentally an object-oriented framework, which means that the framework itself and your applications derived from the framework are fundamentally composed of classes and only classes can have state machines associated with them.

If you program in C and object-oriented programming is new to you, please refer to the Application Note "Object-Oriented Programming in C", which describes how you can implement the concepts of classes, inheritance, and polymorphism to portable ANSI-C.
Application Note: Object-Oriented Programming in C

Hierarchical State Machines

The behavior of active objects is specified in QP-nano™ by means of hierarchical state machines (UML statecharts). The frameworks support manual coding of UML state machines in C or C++ as well as fully automatic code generation by means of the free graphical QM™ modeling tool.

State machines can be an incredibly powerful technique, but they require an event-driven infrastructure (framework) that provides, at a minimum: a run-to-completion (RTC) execution context for each state machine, queuing of events, and event-based timing services. This is really the pivotal point. Without an event-driven framewok (like QP-nano), state machines are like cars without an infrastructure of roads.

Built-in Kernels

All QP-nano™ framework is designed to run on low-end 8- and 16-bit single-chip microcontrollers, replacing the venerable "superloop". The framework contains two built-in real-time kernels: the cooperative QV-nano kernel and the preemptive non-blocking QK-nano kernel. Native QP ports and ready-to-use examples are provided for selected CPU families.

Windows/Linux Emulation

QP-nano™ can also be emulated on desktop OSes (such as Windows and Linux), which allows you to develop and test large portions of your deeply embedded code on the desktop.

Popularity & Maturity

With over 15 years of continuous development and 60,000 downloads a year, the QP™ RTEF family is the most mature and popular such solution on the embedded software market.

The QP™ frameworks are used in millions of products worldwide in aerospace, medical devices, consumer electronics, wired and wireless telecommunications, industrial automation, transportation, robotics, and many more.


The book, Practical UML Statecharts in C/C++, 2nd Edition provides a detailed design study of the QP frameworks and explains all the related concepts.

Practical UML Statecharts in C/C++, 2nd Edition

How is it licensed?

QP-nano™ is licensed under the increasingly popular dual licensing model, in which both the open source software distribution mechanism and traditional closed source software distribution models are combined.

If your company has a policy forbidding open source in your product, all QP frameworks can be licensed commercially, in which case you don't use any open source license and you do not violate your policy.

Open Source Projects

If you are developing and distributing open source applications under the GNU General Public License (GPL), as published by the Free Software Foundation, then you are free to use the Quantum Leaps software under the GPL version 3 of the License, or (at your option) any later version. Please note that GPL requires that all modifications to the original code as well as your application code (Derivative Works as defined in the Copyright Law) must also be released under the terms of the GPL open source license.

Closed Source Projects

If you are developing and distributing traditional closed source applications, you can purchase one of Quantum Leaps commercial licenses, which are specifically designed for users interested in retaining the proprietary status of their code. All Quantum Leaps commercial licenses expressly supersede the GPL open source license. This means that when you license Quantum Leaps software under a commercial license, you specifically do not use the software under the open source license and therefore you are not subject to any of its terms.

How to get help?

Please post any technical questions to the Free Support Forum hosted on SourceForge.net. Posts to this forum benefit the whole community and are typically answered the same day.

Direct Commercial Support is available to the commercial licensees. Every commercial license includes one year of Technical Support for the licensed software. The support term can be extended annually.

Training and consulting services are also available from Quantum Leaps. Please refer to the Contact web-page for more information.

Contact Information

Getting Started