The starting point for the project was the development of high-level concurrency in an object-oriented programming language. This approach is in contrast to programming with threads and locks, e.g., POSIX threads, which deemed unreasonable because it is complicated and error-prone (like assembler programming). An attempt was made to add concurrency without extending C++, but it turns out to be impossible to build either an efficient or sound concurrency library due to fundamental language issues (not problems with C++); therefore, a concurrent dialect of C++ was created, called μC++.
The μC++ project extends C++ with new constructs providing advanced control-flow including light-weight concurrency on shared-memory uni- and multi-processor computers running UNIX and Linux operating systems. μC++ accomplishes this by providing new kinds of classes: coroutines, which have independent execution states; tasks, which have their own threads; and monitors, which allow for safe communication among tasks. These new classes can take part in inheritance, overloading, and templates, just like other classes. As well, C++ exception handling is extended, allowing exceptions to propagate among coroutines and tasks. Additional capabilities include: clustering of tasks and processors, object-oriented non-blocking I/O for files and sockets, and support for real-time programming. True parallelism is achieved utilizing operating-system kernel-threads. μC++ clarifies and extends object-oriented concurrency providing generality and functionality that surpasses languages like Ada, Java, and C#.
μC++ is implemented as a translator, u++, that reads a program containing the extensions and transforms each extension into one or more C++ statements, which are then compiled by an appropriate C++ compiler (currently only GNU C++) and linked with the μC++ concurrent runtime library. Currently, u++ runs on x86, x86_64, ia64 (Itanium), and SPARC, on Linux, FreeBSD, and Solaris systems.