CPP / C++ - Libraries Bookmarks

• Math Toolkit 2.8.0 - 1.69.0
  • Brief: The math toolkit provides the following facilities:
    • Floating Point Utilities
    • Specific Width Floating Point Types
    • Statistical Distributions (Gaussian, Poisson, Bernouli…)
    • Mathematical Special Function
    • Root Finding and Function
    • Minimisations, Polynomials and Rational Functions
    • Interpolation
    • Numerical Integration and Differentiation
    • Quaternions and Octonions.
  • Chapter 6. Special Functions - 1.69.0
  • Chapter 5. Statistical Distributions and Functions - 1.69.0
• uBLAS (Linear algebra facilities, linear systems, vector matrices and so on.)
  • Brief: "uBLAS provides matrix and vector classes as well as basic linear algebra routines. Several dense, packed and sparse storage schemes are supported."
• Boost Odeint
  • Library for ordinary differential equations - initial value problems.
• Date Time
  • Brief: "A set of date-time libraries based on generic programming concepts."
  • Descr: "The motivation for this library comes from working with and helping build several date-time libraries on several projects. Date-time libraries provide fundamental infrastructure for most development projects. However, most of them have limitations in their ability to calculate, format, convert, or perform some other functionality. For example, most libraries do not correctly handle leap seconds, provide concepts such as infinity, or provide the ability to use high resolution or network time sources. These libraries also tend to be rigid in their representation of dates and times. Thus customized policies for a project or subproject are not possible."
• Chapter 7. Boost.Chrono 2.0.8 - 1.69.0 (Time interval computation, already in C++11, but it is a good documentation for the STL library.)
• Accumulators
  • Summary: Incremental statistics.
  • Descr: "Boost.Accumulators is both a library for incremental statistical computation as well as an extensible framework for incremental calculation in general. The library deals primarily with the concept of an accumulator, which is a primitive computational entity that accepts data one sample at a time and maintains some internal state. These accumulators may offload some of their computations on other accumulators, on which they depend. Accumulators are grouped within an accumulator set. Boost.Accumulators resolves the inter-dependencies between accumulators in a set and ensures that accumulators are processed in the proper order."
• Boost Multiprecisions
  • Brief: "The Multiprecision Library provides integer, rational, floating-point, and complex types in C++ that have more range and precision than C++'s ordinary built-in types. The big number types in Multiprecision can be used with a wide selection of basic mathematical operations, elementary transcendental functions as well as the functions in Boost.Math. The Multiprecision types can also interoperate with the built-in types in C++ using clearly defined conversion rules. This allows Boost.Multiprecision to be used for all kinds of mathematical calculations involving integer, rational and floating-point types requiring extended range and precision."
• Units
  • Brief: "Zero-overhead dimensional analysis and unit/quantity manipulation and conversion."
• The Boost Multidimensional Array Library (Boost.MultiArray) - 1.69.0
  • Brief: Multidimensional arrays, aka tensors.

• Chapter 26. Boost.MPI - 1.69.0
  • Brief: "Boost.MPI is a library for message passing in high-performance parallel applications. A Boost.MPI program is one or more processes that can communicate either via sending and receiving individual messages (point-to-point communication) or by coordinating as a group (collective communication). Unlike communication in threaded environments or using a shared-memory library, Boost.MPI processes can be spread across many different machines, possibly with different operating systems and underlying architectures."
• Chapter 1. Boost.Compute - 1.69.0
  • Brief: "The Boost Compute library provides a C++ interface to multi-core CPU and GPGPU computing platforms based on OpenCL."

• Chapter 21. Boost.Lexical_Cast 1.0 - 1.69.0
• The Boost Format library - 1.69.0
  • The format library provides a class for formatting arguments according to a format-string, as does printf, but with two major differences : format sends the arguments to an internal stream, and so is entirely type-safe and naturally supports all user-defined types. The ellipsis (…) can not be used correctly in the strongly typed context of format, and thus the function call with arbitrary arguments is replaced by successive calls to an argument feeding operator%
• String algo
  • Brief: "The String Algorithm Library provides a generic implementation of string-related algorithms which are missing in STL. It is an extension to the algorithms library of STL and it includes trimming, case conversion, predicates and find/replace functions. All of them come in different variants so it is easier to choose the best fit for a particular need."
• Boost Spirit
  • Brief: Framework for building parsers.
• Tokenizer
  • Brief: "Break of a string or other character sequence into a series of tokens."

• Boost Operators
• Range [BEST]
  • Descr: "A new infrastructure for generic algorithms that builds on top of the new iterator concepts."
  • Note: Maybe the future replacement for C++ classical iterators.
• Boost.HigherOrderFunctions (aka Boost.Hof)
  • Brief: Provides many higher order functions.
  • Descr: HigherOrderFunctions is a header-only C++11/C++14 library that provides utilities for functions and function objects, which can solve many problems with much simpler constructs than whats traditionally been done with metaprogramming.
• Boost.Mp11: A C++11 metaprogramming library - 1.69.0
• Boost Fusion
• Boost.Hana
  • Brief: "Hana is a header-only library for C++ metaprogramming suited for computations on both types and values."
  • Descr: "The functionality it provides is a superset of what is provided by the well established Boost.MPL and Boost.Fusion libraries. By leveraging C++11/14 implementation techniques and idioms, Hana boasts faster compilation times and runtime performance on par or better than previous metaprogramming libraries, while noticeably increasing the level of expressiveness in the process. Hana is easy to extend in a ad-hoc manner and it provides out-of-the-box inter-operation with Boost.Fusion, Boost.MPL and the standard library."
• Concept check
  • Descr: "Tools for generic programming."
• Proto
  • Brief: "Expression template library and compiler construction toolkit for domain-specific embedded languages."

• Chapter 40. Boost.TypeErasure - 1.69.0
  • Brief: "The Boost.TypeErasure library provides runtime polymorphism in C++ that is more flexible than that provided by the core language. The Boost.TypeErasure library combines the superior abstraction capabilities of templates, with the runtime flexibility of virtual functions."
• Boost Pointer Container Library - 1.69.0
  • Brief: "Boost.Pointer Container provides containers for holding heap-allocated objects in an exception-safe manner and with minimal overhead. The aim of the library is in particular to make OO programming easier in C++ by establishing a standard set of classes, methods and designs for dealing with OO specific problems."
• Boost Flyweight
  • Brief: Descr: "Design pattern to manage large quantities of highly redundant objects."
  • Descr: "Flyweights are small-sized handle classes granting constant access to shared common data, thus allowing for the management of large amounts of entities within reasonable memory limits. Boost.Flyweight makes it easy to use this common programming idiom by providing the class template flyweight<T>, which acts as a drop-in replacement for const T."
  • Additional notes:
    • "Learning to use Boost.Flyweight can be accomplished in a matter of minutes. When special needs arise, however, an extensive customization interface is provided which allows the user to control and extend the following aspects:"
    • Type tagging for separation of domains using the same basic flyweight types.
    • Specification and parameterization of the so-called flyweight factory.
    • Control of the factory instantiation procedure.
    • Specification of the internal synchronization mechanisms.
    • Flyweight tracking, allowing for the disposal of stored values when no longer referenced by any flyweight object.
• Chapter 32. Boost.PropertyTree - 1.69.0
  • "The Property Tree library provides a data structure that stores an arbitrarily deeply nested tree of values, indexed at each level by some key. Each node of the tree stores its own value, plus an ordered list of its subnodes and their keys. The tree allows easy access to any of its nodes by means of a path, which is a concatenation of multiple keys."
• Boost.Functional/Factory
  • Brief: "The template boost::factory lets you encapsulate a new expression as a function object, boost::value_factory encapsulates a constructor invocation without new."
• Property Map Library - 1.69.0

• Chapter 31. Boost.Program_options - 1.69.0

• Chapter 1. Boost.Log v2 - 1.69.0
  • Descr: "The application stores all essential information about its execution to a log, and when something goes wrong this information can be used to analyze the program behavior and make the necessary corrections. There are other very useful applications of logging, such as gathering statistical information and highlighting events (i.e. indicating that some situation has occurred or that the application is experiencing some problems). These tasks have proved to be vital for many real-world industrial applications. This library aims to make logging significantly easier for the application developer. It provides a wide range of out-of-the-box tools along with public interfaces for extending the library. The main goals of the library are:"
    • Simplicity. A small example code snippet should be enough to get the feel of the library and be ready to use its basic features.
    • Extensibility. A user should be able to extend functionality of the library for collecting and storing information into logs.
    • Performance. The library should have as little performance impact on the user's application as possible.

• Boost Asio
  • Descr: "Portable networking and other low-level I/O, including sockets, timers, hostname resolution, socket iostreams, serial ports, file descriptors and Windows HANDLEs."
• Boost CRC - CRC (Cyclick Redundancy Checking)
  • Descr: " CRCs (cyclic redundancy codes) is one common technique to confirming data integrity after transmission. The Boost.CRC library provides access to two styles of CRC computation, one as a function template, the other as a function template and two computation object class templates, where the two class templates differ in speed."
• Statechart
  • Brief: "Boost.Statechart - Arbitrarily complex finite state machines can be implemented in easily readable and maintainable C++ code."
  • Note: Many network protocols, embedded systems applications and business processes are well described by state machines such as Mealy state machine or Moore State machine.
• UUID - A universally unique identifier.

• Boost DLL
  • Brief: "This library was designed to simplify plugin development using C++ in a portable cross-platform manner."
  • Descr: "Adding a specific features to an existing software applications at runtime could be useful in many cases. Such extensions, or plugins, are usually implemented using Dynamic Library Modules (DLL,SO/DSO) loaded at runtime."
  • Library provides a portable across platforms way to:
    • load libraries
    • import any native functions and variables
    • make alias names for C++ mangled functions and symbols
    • query libraries for sections and exported symbols
    • self loading and self querying
    • getting program and module location by exported symbol

• Boost.Interprocess
  • Brief: "Boost.Interprocess simplifies the use of common interprocess communication and synchronization mechanisms and offers a wide range of them:"
    • Shared memory.
    • Memory-mapped files.
    • Semaphores, mutexes, condition variables and upgradable mutex types to place them in shared memory and memory mapped files.
    • Named versions of those synchronization objects, similar to UNIX/Windows sem_open/CreateSemaphore API.
    • File locking.
    • Relative pointers.
    • Message queues.
  • Additional:
    • Boost.Interprocess also offers higher-level interprocess mechanisms to allocate dynamically portions of a shared memory or a memory mapped file (in general, to allocate portions of a fixed size memory segment). Using these mechanisms, Boost.Interprocess offers useful tools to construct C++ objects, including STL-like containers, in shared memory and memory mapped files:
• Boost.Process
  • Brief: "Boost.Process is a library to manage system processes. It can be used to:"
    • create child processes
    • setup streams for child processes
    • communicate with child processes through streams (synchronously or asynchronously)
    • wait for processes to exit (synchronously or asynchronously)
    • terminate processes

• Endian Library - 1.69.0

• POSIX Threads - Threading C-API defined by POSIX IEEE standard which is implemented by many Unix-like operating systems such as Linux, MacOSX, iOS, Android, BSD, QNX and so on. Note: This API is already encapsulated and wrapped by C++11 standard library.
  • POSIX thread (pthread) libraries
  • POSIX Threads Programming
  • POSIX Threads API
• jthread - (C++20 Inclusion) - C++ class for a joining and cooperative interruptible thread (should become std::jthread)
  • "C++ class for a joining and cooperative interruptible thread (should become std::jthread) with stop_token helper. Draft implementation of the C++ paper P0660 https://wg21.link/p0660; Authors: Nicolai Josuttis and Lewis Baker".
  • Repository: https://github.com/josuttis/jthread
• ICNC - Intel Concurrency Collection - " CnC makes it easy to write C++ programs which take full advantage of the available parallelism. Whether run on multicore systems, Xeon Phi™ or clusters CnC will seamlessly exploit the performance potential of your hardware. Through its portabilty and composability (with itself and other tools) it provides future-proof scalability. Intel® Concurrent Collections for C++ is a C++ template library for letting C++ programmers implement CnC applications which run in parallel on shared and distributed memory."
  • Site: https://icnc.github.io/
  • Repo: https://github.com/icnc/icnc
• CAF - C++ Actor Framework - "CAF is an open source C++11 actor model implementation featuring lightweight & fast actor implementations, pattern matching for messages, network transparent messaging, and more."
  • Site: https://actor-framework.org/
  • Repo: https://github.com/actor-framework/actor-framework
  • Doxygen: http://www.actor-framework.org/doc/
• SObjectizer - "SObjectizer is one of a few cross-platform and OpenSource 'actor frameworks' or C++. But SObjectizer supports not only Actor Model, but also Publish-Subscribe Model and CSP-like channels. The goal of SObjectizer is significant simplification of development of concurrent and multithreaded applications in C++."
  • Repo: https://bitbucket.org/sobjectizerteam/sobjectizer/
• QP/C++ - "QP/C++™ (Quantum Platform in C++) is a lightweight Real-Time Embedded Framework (RTEF) for building modern, responsive and modular real-time embedded applications as systems of asynchronous event-driven active objects (actors). QP/C++" is a member of a larger family of real-time embedded frameworks (RTEFs) consisting of QP/C++, QP/C, and QP-nano frameworks, which are all strictly quality controlled, thoroughly documented, and available under dual licensing model."
  • Site: https://www.state-machine.com/qpcpp/
  • Repo: https://github.com/QuantumLeaps/qpcpp
  • License: GPL for open source, commerical for closed source.
• ProXC [C Library] - "CSP-inspired concurrency library for modern C - This is a library for C which enables Communicating Sequential Processes (CSP) like structuring of your code. Programming languages such as Occam and XC utilizes and builds around this very paradigm, but sadly is hardware locked. Many good CSP libraries for general purpose programming languages has been made, including both for Java (JCSP) and C++ (C++CSP2), but not for C. There does exists plenty of libraries for C which implements many features from CSP, such as coroutines, channels, etc., but not all in a single library. ProXC aims to do this, and with no macro magic!"
  • Site: https://github.com/edvardsp/libproxc

General Data Structures

• Boost.Lockfree
  • Site: https://www.boost.org/doc/libs/1_71_0/doc/html/lockfree.html
  • Brief: Lock-free data structures provided by Boost Library.
• CSD - Concurrent Data Structures library [LOCK-FREE]
  • Site: http://libcds.sourceforge.net/doc/cds-api/index.html
  • Repo: https://github.com/khizmax/libcds (Mirror)
  • Brief: "Provide many lock-free data structures: stack, queue, deque, priority queue, map, set, list and tree."
  • "This library is a collection of lock-free and lock-based fine-grained algorithms of data structures like maps, queues, list etc. The library contains implementation of well-known data structures and memory reclamation schemas for modern processor architectures. The library is written on C++11."
• Xenium
  • Site: https://mpoeter.github.io/xenium/
  • Repo: https://github.com/mpoeter/xenium/
  • Brief: A C++ library providing various concurrent data structures and reclamation schemes.
  • "xenium is a collection of concurrent data structures and memory reclamation algorithms. The data structures are parameterized so that they can be used with various reclamation schemes (similar to how the STL allows customization of allocators). The documentation provides more details."
• lock_free [LOCK-FREE] [HEADER-ONLY]
  • Repo: https://github.com/Lingxi-Li/lock_free
  • "A C++17 Lock-Free Data Structure Library. This is a library for lock-free data structures with the following features: Written purely in standard C++17 with no platform-dependent code; Header-only; Designed for low worst-case latency; Designed for exception safety; Provides first-class support, like emplace construction; for aggregate types."
• ASCYLIB(Cpp) + OPTIK
  • Repo: https://github.com/LPD-EPFL/ASCYLIB-Cpp
  • "ASCYLIB (with OPTIK) is a concurrent data-structure library. The original C version (found at https://github.com/LPD-EPFL/ASCYLIB) contains over 40 implementations of linked lists, hash tables, skip lists, binary search trees (BSTs), queues, priority queues, and stacks, containing sequential, lock-based, and lock-free implementations for each data structure."
• Junction - Concurrent Data Structures in C++
  • Repo: https://github.com/preshing/junction
  • "Junction is a library of concurrent data structures in C++. It contains several hash map implementations: junction::ConcurrentMap_Crude; junction::ConcurrentMap_Linear; junction::ConcurrentMap_Leapfrog and junction::ConcurrentMap_Grampa"
• Excess C++
  • Repo: https://github.com/excess-project/data-structures-library
  • EXCESS C++ Concurrent Data Structures (Adapter) Library
• libfds [C Library]
  • Site: https://liblfds.org/
  • "liblfds, a portable, license-free, lock-free data structure library written in C. Lock-free data structures are process, thread and interrupt safe (i.e. the same data structure instance can be safely used concurrently and simultaneously across cores, processes, threads and both inside and outside of interrupt handlers), never sleep (and so are safe for kernel use when sleeping is not permitted), operate without context switches, cannot fail (no need to handle error cases, as there are none), perform and scale literally orders of magnitude better than locking data structures, and liblfds itself (as of release 7.0.0) is implemented such that it performs no allocations (and so works with NUMA, stack, heap and shared memory) and compiles not just on a freestanding C89 implementation, but on a bare C89 implementation."

Immutable Data Structures:

• Immer - Immutable concurrent data structures [IMMUTABLE] [FUNCTIONAL PROGRAMMING]
  • Repo: https://github.com/arximboldi/immer
  • "immer is a library of persistent and immutable data structures written in C++. These enable whole new kinds of architectures for interactive and concurrent programs of striking simplicity, correctness, and performance."
  • Why: "In the last few years, there has been a growing interest in immutable data structures, motivated by the horizontal scaling of our processing power and the ubiquity of highly interactive systems. Languages like Clojure and Scala provide them by default, and implementations for JavaScript like Mori and Immutable.js are widely used, specially in combination with modern UI frameworks like React."

Message Queues for thread producer/consumer synchronization

• MPMCQueue (Message Queue, aka Mailbox)
  • Repo: https://github.com/rigtorp/MPMCQueue
  • Brief: A bounded multi-producer multi-consumer lock-free queue written in C++11
  • "A bounded multi-producer multi-consumer lock-free queue written in C++11. It's battle hardened and used daily in production: In the Frostbite game engine developed by Electronic Arts for the following games: Anthem (2019); Battlefield V (2018); FIFA 18 (2017); Madden NFL 18 (2017); Need for Speed: Payback (2017). In the low latency trading infrastructure at Charlesworth Research and Marquette Partners."
  • It's been cited by the following papers:
    • Peizhao Ou and Brian Demsky. 2018. Towards understanding the costs of avoiding out-of-thin-air results. Proc. ACM Program. Lang. 2, OOPSLA, Article 136 (October 2018), 29 pages. DOI: https://doi.org/10.1145/3276506
• SPSCQueue (Message Queue, aka Mailbox)
  • Repo: https://github.com/rigtorp/SPSCQueue
  • Brief: A bounded single-producer single-consumer wait-free and lock-free queue written in C++11
  • SPSCQueue have been cited by the following papers:
    • Peizhao Ou and Brian Demsky. 2018. Towards understanding the costs of avoiding out-of-thin-air results. Proc. ACM Program. Lang. 2, OOPSLA, Article 136 (October 2018), 29 pages. DOI: https://doi.org/10.1145/3276506

Misc - Non Categorized

• Seqlock
  • Repo: https://github.com/rigtorp/Seqlock
  • "An implementation of Seqlock in C++11. A seqlock can be used as an alternative to a readers-writer lock. It will never block the writer and doesn't require any memory bus locks."
• LibRCU
  • Site: http://liburcu.org/
  • "liburcu is a LGPLv2.1 userspace RCU (read-copy-update) library. This data synchronization library provides read-side access which scales linearly with the number of cores. liburcu-cds provides efficient data structures based on RCU and lock-free algorithms. Those structures include hash tables, queues, stacks, and doubly-linked lists."
• SimonCqk/booty
  • Repo: https://github.com/SimonCqk/booty
  • Utility mordern c++ components library in real development.
  • Provides many components for concurrent programming such as: thread pools, singla-slot, timestamp, unbounded lock queue, fast user-space mutexes, saturing semaphores.

See also:

• GitHub - rigtorp/awesome-lockfree
  • A collection of resources on wait-free and lock-free programming.
• GitHub - jfuentes/concurrent-data-structures
  • Compilation of concurrent data structures with at least lock-free or wait-free properties.

• libuv - "libuv is a multi-platform support library with a focus on asynchronous I/O. It was primarily developed for use by Node.js, but it's also used by Luvit, Julia, pyuv, and others."
  • Site: https://github.com/libuv/libuv
  • Full-featured event loop backed by epoll, kqueue, IOCP, event ports.
  • Asynchronous TCP and UDP sockets
  • Asynchronous DNS resolution
  • Asynchronous file and file system operations
  • File system events
  • ANSI escape code controlled TTY
  • IPC with socket sharing, using Unix domain sockets or named pipes (Windows)
  • Child processes
  • Thread pool
  • Signal handling
  • High resolution clock
  • Threading and synchronization primitives
• hhggit/uw - "UW is a single-header C++11 wrapper of libuv."

Coroutines

• Boost Coroutines 2 - "Boost.Coroutine2 provides templates for generalized subroutines which allow suspending and resuming execution at certain locations. It preserves the local state of execution and allows re-entering subroutines more than once (useful if state must be kept across function calls). Coroutines can be viewed as a language-level construct providing a special kind of control flow. In contrast to threads, which are pre-emptive, coroutine switches are cooperative (programmer controls when a switch will happen). The kernel is not involved in the coroutine switches."
  • https://www.boost.org/doc/libs/1_70_0/libs/coroutine2/doc/html/index.html
• Cppcoro [EXPERIMENTAL] - "This library is an experimental library that is exploring the space of high-performance, scalable asynchronous programming abstractions that can be built on top of the C++ coroutines proposal. It has been open-sourced in the hope that others will find it useful and that the C++ community can provide feedback on it and ways to improve it. It requires a compiler that supports the coroutines TS."
  • https://github.com/lewissbaker/cppcoro

Fibers

• Boost Fibers [USER SPACE THREADS] - "Provides a framework for micro-/userland-threads (fibers) scheduled cooperatively. The API contains classes and functions to manage and synchronize fibers similar to boost.thread. A fiber is able to store the current execution state, including all registers and CPU flags, the instruction pointer, and the stack pointer and later restore this state. The idea is to have multiple execution paths running on a single thread using a sort of cooperative scheduling (threads are preemptively scheduled) - the running fiber decides explicitly when it yields to allow another fiber to run (context switching). A context switch between threads costs usually thousands of CPU cycles on x86 compared to a fiber switch with less than 100 cycles. A fiber can only run on a single thread at any point in time. Boost.fiber requires C++11!"
  • Site: https://www.boost.org/doc/libs/1_67_0/libs/fiber/doc/html/index.html
  • Repo: https://github.com/boostorg/fiber
• IOFiber - "IOFiber is a fiber library built on top of Boost.Context and Boost.Asio - This library is not a competitor to Boost.Fiber. This library aims to have tight integration with Boost.Asio execution engine."
  • https://vinipsmaker.github.io/iofiber/
  • Repo: https://github.com/blinktrade/iofiber
• FiberTaskingLib - "This is a library for enabling task-based multi-threading. It allows execution of task graphs with arbitrary dependencies. Dependencies are represented as atomic counters. Under the covers, the task graph is executed using fibers, which in turn, are run on a pool of worker threads (one thread per CPU core). This allows the scheduler to wait on dependencies without task chaining or context switches. This library was created as a proof of concept of the ideas presented by Christian Gyrling in his 2015 GDC Talk 'Parallelizing the Naughty Dog Engine Using Fibers'"
  • https://github.com/RichieSams/FiberTaskingLib

• Intel TBB - Threading Building Blocks - "This application is a widely used C++ library for shared-memory parallel programming and heterogeneous computing (intra-node distributed memory programming). The library provides a wide range of features for parallel programming, including generic parallel algorithms, concurrent containers, a scalable memory allocator, work-stealing task scheduler, and low-level synchronization primitives. Threading Building Blocks (TBB) is a library only solution for task-based parallelism and does not require any special compiler support. It ports to multiple architectures including Intel® architectures, ARM*, and Power Architecture*."
  • Site: https://software.intel.com/en-us/intel-tbb
  • Repo: https://github.com/intel/tbb
• Intel Parallel-STL - "Parallel STL is an implementation of the C++ standard library algorithms with support for execution policies, as specified in ISO/IEC 14882:2017 standard, commonly called C++17. The implementation also supports the unsequenced execution policy specified in Parallelism TS version 2 and proposed for the next version of the C++ standard in the C++ working group paper P1001R1. Parallel STL offers a portable implementation of threaded and vectorized execution of standard C++ algorithms, optimized and validated for Intel(R) 64 processors. For sequential execution, it relies on an available implementation of the C++ standard library. The source code in this repository corresponds to the releases of Parallel STL with Intel(R) C++ Compiler or with Threading Building Blocks."
  • Site: https://software.intel.com/en-us/articles/get-started-with-parallel-stl
  • Site: https://github.com/intel/parallelstl
• HPX - High Performance ParalleX - "HPX is a C++ Standard Library for Concurrency and Parallelism. It implements all of the corresponding facilities as defined by the C++ Standard. Additionally, in HPX we implement functionalities proposed as part of the ongoing C++ standardization process. We also extend the C++ Standard APIs to the distributed case. The goal of HPX is to create a high quality, freely available, open source implementation of a new programming model for conventional systems, such as classic Linux based Beowulf clusters or multi-socket highly parallel SMP nodes. At the same time, we want to have a very modular and well designed runtime system architecture which would allow us to port our implementation onto new computer system architectures. We want to use real-world applications to drive the development of the runtime system, coining out required functionalities and converging onto a stable API which will provide a smooth migration path for developers. The API exposed by HPX is not only modeled after the interfaces defined by the C++11/14/17/20 ISO standard, it also adheres to the programming guidelines used by the Boost collection of C++ libraries. We aim to improve the scalability of today's applications and to expose new levels of parallelism which are necessary to take advantage of the exascale systems of the future."
  • Site: http://stellar-group.org/libraries/hpx/
  • Repo: https://github.com/STEllAR-GROUP/hpx
• CPP Taskflow
  • "Cpp-Taskflow is by far faster, more expressive, and easier for drop-in integration than existing parallel task programming libraries such as OpenMP Tasking and Intel TBB FlowGraph in handling complex parallel workloads. Cpp-Taskflow lets you quickly implement task decomposition strategies that incorporate both regular and irregular compute patterns, together with an efficient work-stealing scheduler to optimize your multithreaded performance."
    • Site: https://cpp-taskflow.github.io
    • Repo: https://github.com/cpp-taskflow/cpp-taskflow

SIMD - Data Parallelism, CPU vector instructions (SIMD) wrappers.

• xsimd - "Modern, portable C++ wrappers for SIMD intrinsics and parallelized, optimized math implementations (SSE, AVX, NEON, AVX512). SIMD (Single Instruction, Multiple Data) is a feature of microprocessors that has been available for many years. SIMD instructions perform a single operation on a batch of values at once, and thus provide a way to significantly accelerate code execution. However, these instructions differ between microprocessor vendors and compilers. xsimd provides a unified means for using these features for library authors. Namely, it enables manipulation of batches of numbers with the same arithmetic operators as for single values. It also provides accelerated implementation of common mathematical functions operating on batches."
  • Docs: https://xsimd.readthedocs.io/en/latest/
  • See: Bye bye boost.simd, welcome xsimd
• nsimd - "NSIMD is a vectorization library that abstracts SIMD programming. It was designed to exploit the maximum power of processors at a low development cost. To achieve maximum performance, NSIMD mainly relies on the inline optimization pass of the compiler. Therefore using any mainstream compiler such as GCC, Clang, MSVC, XL C/C++, ICC and others with NSIMD will give you a zero-cost SIMD abstraction library. To allow inlining, a lot of code is placed in header files. Small functions such as addition, multiplication, square root, etc, are all present in header files whereas big functions such as I/O are put in source files that are compiled as a .so/.dll library. NSIMD provides C89, C++98, C++11 and C++14 APIs. All APIs allow writing generic code. For the C API this is achieved through a thin layer of macros; for the C++ APIs it is achieved using templates and function overloading. The C++ API is split in two. The first part is a C-like API with only function calls and direct type definitions for SIMD types while the second one provides operator overloading, higher level type definitions that allows unrolling. C++11, C++14 APIs add for instance templated type definitions and templated constants."

Listing of C++ template libraries for general purpose computing on GPUs using C++11 to C++17 without any extension language such as CUDA, OpenACC, OpenCL and so on.

General Template Libraries - akin to C++ STL

• Boost.Compute [VENDOR NEUTRAL]
  • Site 1: http://boostorg.github.io/compute/
  • Site 2: https://www.boost.org/doc/libs/1_71_0/libs/compute/doc/html/index.html
  • Repo: https://github.com/boostorg/compute
  • "Boost.Compute is a GPU/parallel-computing library for C++ based on OpenCL. The core library is a thin C++ wrapper over the OpenCL API and provides access to compute devices, contexts, command queues and memory buffers. On top of the core library is a generic, STL-like interface providing common algorithms (e.g. transform(), accumulate(), sort()) along with common containers (e.g. vector<T>, flat_set<T>). It also features a number of extensions including parallel-computing algorithms (e.g. exclusive_scan(), scatter(), reduce()) and a number of fancy iterators (e.g. transform_iterator<>, permutation_iterator<>, zip_iterator<>)."
  • See:
    • GPU DSP — Latency – Cycfi Research - Joel de Guzman
    • Has anyone had success using Boost Compute to abstract away OpenCL? : cpp
• TrySYCL [VENDOR NEUTRAL] [KHRONOS GROUP] [SYCL STANDARD]
  • Brief: Implementation of Khronos Group SYCL open standard.
  • Site: http://www.khronos.org/sycl
  • Repo: https://github.com/triSYCL/triSYCL
  • "triSYCL is an open source implementation to experiment with the specification of the SYCL C++ layer and to give feedback to the Khronos Group SYCL and OpenCL C++ 2.2 kernel language committees and also to the ISO C++ committee. This SYCL implementation is mainly based on C++17 and OpenMP or TBB for execution on the CPU, with Boost.Compute for the non single-source OpenCL interoperability layer and with LLVM/Clang for the device compiler providing full single-source SYCL experience, typically targeting a SPIR device. Since in SYCL there is a host fall-back, this CPU implementation can be seen as an implementation of this fall-back too… For legal reasons, the specification used for this open source project is the published current provisional specification and not the last one currently discussed in the Khronos SYCL committee. If you are a Khronos member, you can access to https://gitlab.khronos.org/sycl/triSYCL where you might find more futuristic branches."
  • See also:
    • Videos | SYCL.tech
    • SYCL for OpenCL - Khronos Group
• ComputeCPP [VENDOR NEUTRAL] [KHRONOS GROUP] [SYCL STANDARD] [COMMERCIAL]
  • Brief: Implementation of Khronos Group SYCL open standard.
  • Site: https://www.codeplay.com/products/computesuite/computecpp
  • "The SYCL standard from the Khronos™ Group is for developers who want to take software written using C++ single-source programming models like CUDA® or C++AMP and port to a wide range of OpenCL™ devices. The current early-access ComputeCpp Community Edition release provides pre-conformance SYCL v1.2 support for AMD® and Intel® OpenCL GPUs and CPUs. Further operating system and device support is on its way. This version will let developers work on acceleration of open-source C++ software such as TensorFlow, Eigen and the C++ 17 Parallel STL."
  • Note: The community edition is free.
• EasyCL [VENDOR NEUTRAL] [LOW LEVEL]
  • Repo: https://github.com/hughperkins/EasyCL
  • "Easy to run kernels using OpenCL. (renamed from OpenCLHelper); makes it easy to pass input and output arguments; handles much of the boilerplate; uses clew to load opencl dynamically"
• EasyOpenCL [VENDOR NEUTRAL]
  • Repo: https://github.com/Gladdy/EasyOpenLC
  • "No exposed low-level C, just the C++ standard library. Features: Focus on programming the GPU instead of messing about with long C-style OpenCL function calls and manual memory management; CMake support for Linux and Mac - No more linking problems when you have installed the correct driver; Support for scalar values: pass additional structs to your kernel, eg. transformation matrices or custom constants; Chain kernels together in order to create a true pipeline on your GPU in which kernels can depend on multiple others;"
  • See:
    • EasyOpenCL – The easiest way to get started with GPU programming | Hacker News
• Chlorine [VENDOR NEUTRAL]
  • Site: https://polytonic.github.io/Chlorine/
  • Repo: https://github.com/Polytonic/Chlorine
  • "Dead Simple OpenCL. Chlorine is the easiest way to interact with OpenCL compatible devices. It is a header-only C++11 library that allows you to write cross-platform code that runs on GPUs without ever touching the complicated OpenCL API, leaving you free to write code that matters: kernels that process data."
• Thrust [NVidia GPUs ONLY]
  • Site: https://thrust.github.io/
  • Repo: https://github.com/thrust/thrust
  • Note: Only works for Nvidia GPUs
  • "Thrust is a C++ parallel programming library which resembles the C++ Standard Library. Thrust's high-level interface greatly enhances programmer productivity while enabling performance portability between GPUs and multicore CPUs. Interoperability with established technologies (such as CUDA, TBB, and OpenMP) facilitates integration with existing software. Develop high-performance applications rapidly with Thrust! Thrust is distributed with the CUDA Toolkit in addition to GitHub."
• HSA-Bolt [AMD GPUs ONLY]
  • Site: https://github.com/HSA-Libraries/bolt/wiki
  • Repo: https://github.com/HSA-Libraries/Bolt
  • "Bolt is a C++ template library optimized for heterogeneous computing. Bolt is designed to provide high-performance library implementations for common algorithms such as scan, reduce, transform, and sort. The Bolt interface was modeled on the C++ Standard Template Library (STL). Developers familiar with the STL will recognize many of the Bolt APIs and customization techniques. The primary goal of Bolt is to make it easier for developers to utilize the inherent performance and power efficiency benefits of heterogeneous computing. It has interfaces that are easy to use, and has comprehensive documentation for the library routines, memory management, control interfaces, and host/device code sharing. Compared to writing the equivalent functionality in OpenCL™, you’ll find that Bolt requires significantly fewer lines-of-code and less developer effort. Bolt is designed to provide a standard way to develop an application that can execute on either a regular CPU, or use any available OpenCL™ capable accelerated compute unit, with a single code path."
• GOOPAX [COMMERCIAL]
  • Site: http://goopax.com/
  • Example: http://goopax.com/examples
  • "GOOPAX is the world's first language-embedded programming solution for GPGPU applications. Our unique programming model greatly simplifies the development of GPGPU applications, making it featible to use the immense computing power of GPUs even for very complex applications. The unique programming model of language-embedded programming results in a number of advantages: perfect integration of the GPU kernels into the host code; programs are compiled with a standard C++ compiler of your choice; shorter programs due to code reusability; higher performance due to meta-programming, profiling, and just-in-time compilation; more reliability: Race conditions and other programming errors are detected automatically; cross-platform development: Programs written in GOOPAX can run on all major target platforms and operating systems; performance portability: GOOPAX detects the graphics card at run-time and creates tailor-made GPU kernels. Your application runs at maximum performance on all hardware."
  • Typical fields of application are:
    • simulations: CFD, weather forecasts, astrophysics, protein folding, combustion processes, etc.
    • blockchains, cryptocurrency mining
    • image recognition: quality assurance in manufacturing, face recognition, analysis of aereal images, autonomous driving, surveilance, etc.
    • CAD, FE, engineering, product optimization
    • planning, classification, text recognition, search engines, machine learning, deep learning, AI, financial markets
    • computer games, VR, video processing, video codecs

GPU Accelerated Libraries

• CUDA Acclerated Libraries [NVidia GPUs Only]
  • Site: https://developer.nvidia.com/gpu-accelerated-libraries
  • Brief: Lots of GPU Accelerated libraries for a wide variety of fields and applications. The advantage of those GPU accelerated libraries is that they can easily replace many non-accelerated libraries and free the user from parallelizing algorithms and portingt them to GPUs.
  • "NVIDIA GPU-accelerated libraries provide highly-optimized functions that perform 2x-10x faster than CPU-only alternatives. Using drop-in interfaces, you can replace CPU-only libraries such as MKL, IPP and FFTW with GPU-accelerated versions with almost no code changes. The libraries can optimally scale your application across multiple GPUs. GPU-accelerated libraries for linear algebra, signal processing, image and video processing lay the foundation for compute-intensive applications in areas such as molecular dynamics, computational chemistry, medical imaging and seismic exploration. For deep learning, NVIDIA provides specialized libraries that are integrated with all the leading deep learning frameworks. NVIDIA libraries use optimized precision to maximize performance for applications such as computer vision, speech processing and natural language processing. Today, NVIDIA’s libraries are running from resource constrained IoT devices, to self driving cars, to the largest supercomputers on the planet. With NVIDIA’s libraries, you get highly efficient implementations of algorithms that are regularly extended and optimized. Whether you are building a new application or trying to speed up an existing application, NVIDIA’s libraries provide the easiest way to get started with GPUs. You can download NVIDIA libraries as part of the CUDA Toolkit."
  • Accelerated libraries:
    • cuFFT => Fast Forier Transform
    • cuBLAS => (BLAS = Basic Linear Algebra Subprogram) - for linear algebra, matrix and vector computations.
    • cuSPARSE => Sparse Matrix Computations.
    • cuSOLVER => Eingenvalue solver
    • cuDNN => GPU accelerated library of primitives for deep neural networks
    • cuRAND => GPU accelerated random number generator (RNG)
    • cuSOLVER => Dense and sparse direct solvers for Computer Vision, CFD, Computational Chemistry, and Linear Optimization applications
    • TensorRT
• VexCL [VENDOR NEUTRAL]
  • Repo: https://github.com/ddemidov/vexcl
  • Site: https://vexcl.readthedocs.io/en/latest/
  • "VexCL is a vector expression template library for OpenCL/CUDA. It has been created for ease of GPGPU development with C++. VexCL strives to reduce amount of boilerplate code needed to develop GPGPU applications. The library provides convenient and intuitive notation for vector arithmetic, reduction, sparse matrix-vector products, etc. Multi-device and even multi-platform computations are supported. The library source code is available under MIT license at https://github.com/ddemidov/vexcl."
  • See:
    • Generating OpenCL/CUDA source code from C++ expressions in VexCL - YouTube
• ViennaCL [VENDOR NEUTRAL]
  • Site: http://viennacl.sourceforge.net/
  • "ViennaCL is a free open-source linear algebra library for computations on many-core architectures (GPUs, MIC) and multi-core CPUs. The library is written in C++ and supports CUDA, OpenCL, and OpenMP (including switches at runtime). The highlights of the latest 1.7.x release family are: Fast sparse matrix-matrix multiplications, outperforming CUBLAS and MKL; Fine-grained parallel algebraic multigrid preconditioners for CPUs, Xeon Phis, and GPUs; Fine-grained parallel incomplete LU factorization preconditioners for CPUs, Xeon Phis, and GPUs."
• ArrayFire [VENDOR NEUTRAL]
  • Repo: https://github.com/arrayfire/arrayfire
  • "ArrayFire is a general-purpose library that simplifies the process of developing software that targets parallel and massively-parallel architectures including CPUs, GPUs, and other hardware acceleration devices. Several of ArrayFire's benefits include: Easy to use, stable, well-documented API; Rigorously tested for performance and accuracy; Commercially friendly open-source licensing; Commercial support from ArrayFire; Read about more benefits on arrayfire.com. ArrayFire provides software developers with a high-level abstraction of data which resides on the accelerator, the af::array object. Developers write code which performs operations on ArrayFire arrays which, in turn, are automatically translated into near-optimal kernels that execute on the computational device. ArrayFire is successfully used on devices ranging from low-power mobile phones to high-power GPU-enabled supercomputers. ArrayFire runs on CPUs from all major vendors (Intel, AMD, ARM), GPUs from the prominent manufacturers (NVIDIA, AMD, and Qualcomm), as well as a variety of other accelerator devices on Windows, Mac, and Linux."
• HPL-Gpu [VENDOR NEUTRAL] [LINEAR ALGEBRA]
  • Site: https://github.com/davidrohr/hpl-gpu/wiki
  • Repo: https://github.com/davidrohr/hpl-gpu
  • "High Performance Linpack for GPUs (Using OpenCL, CUDA, CAL). This is a largely rewritten version of the traditional High Performance Linpack as published on netlib.org. It has been modified to make use of modern multi-core CPUs, enhanced lookahead and a high performance DGEMM for AMD GPUs. It can use AMD CAL, OpenCL, and CUDA as GPU backend."
• CLBLast [VENDOR NEUTRAL] [LINEAR ALGEBRA]
  • Repo: https://github.com/CNugteren/CLBlast
  • Site: "CLBlast is a modern, lightweight, performant and tunable OpenCL BLAS library written in C++11. It is designed to leverage the full performance potential of a wide variety of OpenCL devices from different vendors, including desktop and laptop GPUs, embedded GPUs, and other accelerators. CLBlast implements BLAS routines: basic linear algebra subprograms operating on vectors and matrices. See the CLBlast website for performance reports on various devices as well as the latest CLBlast news. The library is not tuned for all possible OpenCL devices: if out-of-the-box performance is poor, please run the tuners first. See below for a list of already tuned devices and instructions on how to tune yourself and contribute to future releases of the CLBlast library. See also the CLBlast feature roadmap to get an indication of the future of CLBlast."
• DeepCL [VENDOR NEUTRAL] [MACHINE LEARNING] [AI]
  • Repo: https://github.com/hughperkins/DeepCL/
  • "OpenCL library to train deep convolutional neural networks."
• MACE [VENDOR NEUTRAL] [MACHINE LEARNING] [AI]
  • Repo: https://github.com/XiaoMi/mace
  • "MACE is a deep learning inference framework optimized for mobile heterogeneous computing platforms. Mobile AI Compute Engine (or MACE for short) is a deep learning inference framework optimized for mobile heterogeneous computing on Android, iOS, Linux and Windows devices."
• libclsph [VENDOR NEUTRAL] [CFD] [ENGINEERING]
  • Repo: https://github.com/libclsph/libclsph
  • "An OpenCL based GPU accelerated SPH fluid simulation library. Libclsph was created to explore the possibilty of using the power of OpenCL to speed up the simulation of SPH fluid mechanics. Smoothed particle hydrodynamics is a fluid simulation technique that can be used to produce realistic simulations for animation,CGI or videogames."
• Sol-R * [VENDOR NEUTRAL]
  • Repo: https://github.com/cyrillefavreau/Sol-R
  • "Sol-R is a CUDA/OpenCL-based realtime ray-tracer compatible with Oculus Rift DK1, Kinect, Razor Hydra and Leap Motion devices. Sol-R was used by the Interactive Molecular Visualiser project (http://www.molecular-visualization.com) A number of videos can be found on my channel: https://www.youtube.com/user/CyrilleOnDrums Sol-R was written as a hobby project in order to understand and learn more about CUDA and OpenCL. Most of the code was written at night and during week-ends, meaning that it's probably not the best quality ever ;-) The idea was to produce a Ray-Tracer that has its own "personality". Most of the code does not rely on any litterature about ray-tracing, but more on a naive approach of what rays could be used for. The idea was not to produce a physically based ray-tracer, but a simple engine that could produce cool images interactively."

MPI - Message Passing Interface

• Boost.MPI
  • Brief: "Boost.MPI is a library for message passing in high-performance parallel applications. A Boost.MPI program is one or more processes that can communicate either via sending and receiving individual messages (point-to-point communication) or by coordinating as a group (collective communication). Unlike communication in threaded environments or using a shared-memory library, Boost.MPI processes can be spread across many different machines, possibly with different operating systems and underlying architectures."
• MPICH - "MPICH is a high performance and widely portable implementation of the Message Passing Interface (MPI) standard. MPICH and its derivatives form the most widely used implementations of MPI in the world. They are used exclusively on nine of the top 10 supercomputers (June 2016 ranking), including the world’s fastest supercomputer: Taihu Light."
• Open MPI - "A High Performance Message Passing Library. The Open MPI Project is an open source Message Passing Interface implementation that is developed and maintained by a consortium of academic, research, and industry partners. Open MPI is therefore able to combine the expertise, technologies, and resources from all across the High Performance Computing community in order to build the best MPI library available. Open MPI offers advantages for system and software vendors, application developers and computer science researchers."
• Microsoft MPI
  • Repo: https://github.com/microsoft/Microsoft-MPI
  • "Microsoft MPI (MS-MPI) is a Microsoft implementation of the Message Passing Interface standard for developing and running parallel applications on the Windows platform. MS-MPI offers several benefits: Ease of porting existing code that uses MPICH; Security based on Active Directory Domain Services; High performance on the Windows operating system; Binary compatibility across different types of interconnectivity options."
• BigMPI
  • Repo: https://github.com/jeffhammond/BigMPI
  • "Interface to MPI for large messages, i.e. those where the count argument exceeds INT_MAX but is still less than SIZE_MAX. BigMPI is designed for the common case where one has a 64b address space and is unable to do MPI communication on more than 2^31 elements despite having sufficient memory to allocate such buffers. BigMPI does not attempt to support large-counts on systems where C int and void* are both 32b."
• MPL
  • Site: https://rabauke.github.io/mpl/html/
  • Repo: https://github.com/rabauke/mpl
  • "MPL is a message passing library written in C++11 based on the Message Passing Interface (MPI) standard. Since the C++ API has been dropped from the MPI standard in version 3.0 it is the aim of MPL to provide a modern C++ message passing library for high performance computing. MPL will neither bring all functions of the C language MPI-API to C++ nor provide a direct mapping of the C API to some C++ functions and classes. Its focus lies on the MPI core message passing functions, ease of use, type safety, and elegance. This library is must useful for developers who have at least some basic knowledge of the Message Passing Interface and would like to utilize it via a more user friendly interface."
• Tampi
  • Repo: https://github.com/bsc-pm/tampi
  • "The Task-Aware MPI or TAMPI library extends the functionality of standard MPI libraries by providing new mechanisms for improving the interoperability between parallel task-based programming models, such as OpenMP or OmpSs-2, and both blocking and non-blocking MPI operations. By following the MPI Standard, programmers must pay close attention to avoid deadlocks that may occur in hybrid applications (e.g., MPI+OpenMP) where MPI calls take place inside tasks. This is given by the out-of-order execution of tasks that consequently alter the execution order of the enclosed MPI calls. The TAMPI library ensures a deadlock-free execution of such hybrid applications by implementing a cooperation mechanism between the MPI library and the parallel task-based runtime system."
• MMX
  • Repo: https://github.com/patflick/mxx
  • "mxx is a C++/C++11 template library for MPI. The main goal of this library is to provide two things: Simplified, efficient, and type-safe C++11 bindings to common MPI operations; A collection of scalable, high-performance standard algorithms for parallel distributed memory architectures, such as sorting; As such, mxx is targeting use in rapid C++ and MPI algorithm development, prototyping, and deployment."
  • Features:
    • All functions are templated by type. All MPI_Datatype are deducted from the C++ type given to the function.
    • Custom reduction operations as lambdas, std::function, functor, or function pointer.
    • Send/Receive and Collective operations take size_t sized input and automatically handle sizes larger than INT_MAX.
    • Plenty of convenience functions and overloads for common MPI operations with sane defaults (e.g., super easy collectives: std::vector<size_t> allsizes = mxx::allgather(local_size)).
    • Automatic type mapping of all built-in (int, double, etc) and other C++ types such as std::tuple, std::pair, and std::array.
    • Non-blocking operations return a mxx::future<T> object, similar to std::future.
    • Google Test based MPI unit testing framework
    • Parallel sorting with similar API than std::sort (mxx::sort)
• WI4MPI
  • Repo: https://github.com/cea-hpc/wi4mpi
  • "This is WI4MPI, Wrapper Interface For MPI performing a light translation between MPI constants and MPI objects from an MPI implementation to another one."
• Mimir
  • Repo: https://github.com/TauferLab/Mimir
  • "Mimir is a new implementation of MapReduce over MPI. Mimir inherits the core principles of existing MapReduce frameworks, such as MR-MPI, while redesigning the execution model to incorporate a number of sophisticated optimization techniques that achieve similar or better performance with significant reduction in the amount of memory used."
• Splatt
  • Repo: https://github.com/ShadenSmith/splatt
  • "The Surprisingly ParalleL spArse Tensor Toolkit. SPLATT is a library and C API for sparse tensor factorization. SPLATT supports shared-memory parallelism with OpenMP and distributed-memory parallelism with MPI."
• Dash-project
  • Site: http://www.dash-project.org/
  • Repo: https://github.com/dash-project/dash
  • "DASH is a C++ Template Library for Distributed Data Structures with Support for Hierarchical Locality for HPC and Data-Driven Science. Exascale systems are scheduled to become available in the coming years and will be characterized by extreme scale and a multilevel hierarchical organization. Efficient and productive programming of these systems will be a challenge, especially in the context of data-intensive applications. Adopting the promising notion of Partitioned Global Address Space (PGAS) programming the DASH project develops a data-structure oriented C++ template library that provides hierarchical PGAS-like abstractions for important data containers (multidimensional arrays, lists, hash tables, etc.) and allows a developer to control (and explicitly take advantage of) the hierarchical data layout of global data structures. In contrast to other PGAS approaches such as UPC, DASH does not propose a new language or require compiler support to realize global address space semantics. Instead, operator overloading and other advanced C++ features are used to provide the semantics of data residing in a global and hierarchically partitioned address space based on a runtime system with one-sided messaging primitives provided by MPI or GASNet. As such, DASH can co-exist with parallel programming models already in widespread use (like MPI) and developers can take advantage of DASH by incrementally replacing existing data structures with the implementation provided by DASH. Efficient I/O directly to and from the hierarchical structures and DASH-optimized algorithms such as map-reduce are also part of the project. Two applications from molecular dynamics and geoscience are driving the project and are adapted to use DASH in the course of the project."

• libv - "libv implements common data structures such as linked lists, dynamic arrays, binary trees, AVL-trees, maps, hashes, stacks, queues and others."
  • Summary: Library that provides common data structures missing in C standard library.
  • Repository/Site: http://libv.sourceforge.net/
• tbox - "TBOX is a glib-like cross-platform C library that is simple to use yet powerful in nature. The project focuses on making C development easier and provides many modules (.e.g stream, coroutine, regex, container, algorithm …), so that any developer can quickly pick it up and enjoy the productivity boost when developing in C language."
  • Site: https://tboox.org
  • Repository: https://github.com/tboox/tbox
• Eina (Enlightment Project) - "The Eina library is a library which implements an API for data types in an efficient way. It also provides some useful tools like opening shared libraries, error management, type conversion, time accounting and memory pools. This library is cross-platform and can be compiled and used on Linux, BSD, and Windows."
  • Site: https://www.enlightenment.org/_legacy_embed/eina_main.html
• APR - Apache Portable Runtime - Supporting library for providing cross-platform portability to the Apache Web Server. The library provides a common API to many different operating systems. It provides facilities for: Atomic operations; Dynamic Shared Object loading; File I/O; Locks (mutexes, condition variables, etc); Memory management (high performance allocators); Memory-mapped files; Multicast Sockets; Network I/O; Shared memory; Thread and Process management and also may data structures such as tables, hashes, priority queues, etc.
  • Web Site: https://apr.apache.org/
  • Mirror Repository: https://github.com/apache/apr
  • Documentation: https://apr.apache.org/docs/apr/1.7/modules.html
• SDS - Simple Dynamic Strings library for C - "SDS is a string library for C designed to augment the limited libc string handling functionalities by adding heap allocated strings that are: Simpler to use; Binary safe; Computationally more efficient; But yet… Compatible with normal C string functions."
  • Note: It comes from Redis database.
  • https://github.com/antirez/sds
• ConcurrencyKit - "Concurrency primitives, safe memory reclamation mechanisms and non-blocking (including lock-free) data structures designed to aid in the research, design and implementation of high performance concurrent systems developed in C99+"
  • http://concurrencykit.org/
  • https://github.com/concurrencykit/ck
• CException - "CException is simple exception handling in C. It is significantly faster than full-blown C++ exception handling but loses some flexibility. It is portable to any platform supporting setjmp/longjmp."
  • https://github.com/ThrowTheSwitch/CException
  • http://www.throwtheswitch.org/cexception
• Sokol - "minimal cross-platform standalone C headers. Minimalistic header-only cross-platform libs in C: sokol_gfx.h: 3D-API wrapper (GL + Metal + D3D11); sokol_app.h: app framework wrapper (entry + window + 3D-context + input); sokol_time.h: time measurement; sokol_audio.h: minimal buffer-streaming audio playback; sokol_fetch.h: asynchronous data streaming from HTTP and local filesystem; sokol_args.h: unified cmdline/URL arg parser for web and native apps".
  • https://github.com/floooh/sokol
  • https://github.com/floooh/sokol-tools

• MinUnit - "Minunit is a minimal unit testing framework for C/C++ self-contained in a single header file. It provides a way to define and configure test suites and a few handy assertion types. It reports the summary of the number of tests run, number of assertions and time elapsed."
  • https://github.com/siu/minunit
• Check - "Check is a unit testing framework for C. It features a simple interface for defining unit tests, putting little in the way of the developer. Tests are run in a separate address space, so Check can catch both assertion failures and code errors that cause segmentation faults or other signals. The output from unit tests can be used within source code editors and IDEs."
  • https://github.com/libcheck/check
• LibTap - "tap is an easy to read and easy to write way of creating tests for your software. This library creates functions that can be used to generate it for your C programs. It is implemented using macros that include file and line info automatically, and makes it so that the format message of each test is optional. It is mostly based on the Test::More Perl module."
  • https://github.com/zorgnax/libtap

• LibUSB (Access USB - Universal Serial Bus) - "A cross-platform user library to access USB devices - libusb is a C library that provides generic access to USB devices. It is intended to be used by developers to facilitate the production of applications that communicate with USB hardware. It is portable: Using a single cross-platform API, it provides access to USB devices on Linux, OS X, Windows, Android, OpenBSD, etc. It is user-mode: No special privilege or elevation is required for the application to communicate with a device. It is version-agnostic: All versions of the USB protocol, from 1.0 to 3.1 (latest), are supported."
  • Repository: https://github.com/libusb/libusb
• OpenSC (Access Smart Cards) - "OpenSC provides a set of libraries and utilities to work with smart cards. Its main focus is on cards that support cryptographic operations, and facilitate their use in security applications such as authentication, mail encryption and digital signatures. OpenSC implements the standard APIs to smart cards, e.g. PKCS#11 API, Windows’ Smart Card Minidriver and macOS Tokend."
• LibNFC (NFC - Near Field Communication) - "libnfc is a library which allows userspace application access to NFC devices."
  • Respository: https://github.com/nfc-tools/libnfc

• Boost.Python
  • Brief: "The Boost Python Library is a framework for interfacing Python and C++. It allows you to quickly and seamlessly expose C++ classes functions and objects to Python, and vice-versa, using no special tools – just your C++ compiler. It is designed to wrap C++ interfaces non-intrusively, so that you should not have to change the C++ code at all in order to wrap it, making Boost.Python ideal for exposing 3rd-party libraries to Python. The library's use of advanced metaprogramming techniques simplifies its syntax for users, so that wrapping code takes on the look of a kind of declarative interface definition language (IDL)."
• pybind11 [BEST]
  • Brief: Allows to create Python modules in native code, aka libraries, with C++ >= C++11.
• SIP [TOOL] [BEST] - Tool for creating python bindings (libraries, aka modules) to existing C or C++ libraries. It is a code generator tool similar to SWIG that parses the codebase and generates the code C or C++ for Python native extension API. SIP was used for generating binding to PyQT.

• CxxWrap
  • "This package aims to provide a Boost.Python-like wrapping for C++ types and functions to Julia. The idea is to write the code for the Julia wrapper in C++, and then use a one-liner on the Julia side to make the wrapped C++ library available there. The mechanism behind this package is that functions and types are registered in C++ code that is compiled into a dynamic library. This dynamic library is then loaded into Julia, where the Julia part of this package uses the data provided through a C interface to generate functions accessible from Julia. The functions are passed to Julia either as raw function pointers (for regular C++ functions that don't need argument or return type conversion) or std::functions (for lambda expressions and automatic conversion of arguments and return types). The Julia side of this package wraps all this into Julia methods automatically."
• Cxx.jl
  • "The Julia C++ Foreign Function Interface (FFI) and REPL. This package contains an experimental C++ REPL feature. Using the package will automatically add a new pane to your REPL that is accessible by pressing the < key."

• Rice - "Rice is a C++ interface to Ruby's C API. It provides a type-safe and exception-safe interface in order to make embedding Ruby and writing Ruby extensions with C++ easier. It is similar to Boost.Python in many ways, but also attempts to provide an object-oriented interface to all of the Ruby C API."
  • Doxygen: http://jasonroelofs.github.io/rice/

• JavaCPP - "JavaCPP provides efficient access to native C++ inside Java, not unlike the way some C/C++ compilers interact with assembly language. No need to invent new languages such as with SWIG, SIP, C++/CLI, Cython, or RPython. Instead, similar to what cppyy strives to do for Python, it exploits the syntactic and semantic similarities between Java and C++. Under the hood, it uses JNI, so it works with all implementations of Java SE, in addition to Android, Avian, and RoboVM (instructions)."

• CppSharp - "CppSharp is a tool and set of libraries which allows programmers to use C/C++ libraries with high-level programming languages (such as C#). It is a tool that takes C/C++ header and library files and generates the necessary glue to surface the native API as a managed API. Such an API can be used to consume an existing native library in your high-level code or add scripting support to a native codebase. The supported target languages at present are C# and C++/CLI. It can also be used as a library to parse native code into a syntax tree with a rich declaration and type information model."

• nbind
  • "nbind is a set of headers that make your C++11 library accessible from JavaScript. With a single #include statement, your C++ compiler generates the necessary bindings without any additional tools. Your library is then usable as a Node.js addon or, if compiled to asm.js with Emscripten, directly in web pages without any plugins. nbind works with the autogypi dependency management tool, which sets up node-gyp to compile your library without needing any configuration (other than listing your source code file names). nbind is MIT licensed and based on templates and macros inspired by embind."
• v8pp
  • "Header-only library to expose C++ classes and functions into V8 to use them in JavaScript code. v8pp uses heavy template metaprogramming and variadic template parameters which requires modern compiler with C++11 support."

• PHP-CPP - "The PHP-CPP library is a C++ library for developing PHP extensions. It offers a collection of well documented and easy-to-use classes that can be used and extended to build native extensions for PHP. The full documentation can be found on http://www.php-cpp.com."

• google/cliff - "C++ Language Interface Foundation (CLIF) - CLIF provides a common foundation for creating C++ wrapper generators for various languages."

• Boost Math toolkit
  • Chapter 5. Statistical Distributions and Functions
  • Interpolation
  • Quadrature and Differentiation
• GNU Scientific Library - GSL (C-Library) - "The library provides a wide range of mathematical routines such as random number generators, special functions and least-squares fitting. There are over 1000 functions in total with an extensive test suite."
  • Site:
    • https://www.gnu.org/software/gsl/
  • Documentation:
    • https://www.gnu.org/software/gsl/doc/html/index.html
  • Repository:
• GLPK - GNU Linear Programming Kit (C and Fortran Library) - "The GLPK (GNU Linear Programming Kit) package is intended for solving large-scale linear programming (LP), mixed integer programming (MIP), and other related problems. It is a set of routines written in ANSI C and organized in the form of a callable library."
  • Site: https://www.gnu.org/software/glpk/
  • Example:
    • https://en.wikibooks.org/wiki/GLPK/Using_the_GLPK_callable_library
  • GPLK for Windows: http://winglpk.sourceforge.net/
• NAG C Libraries from Numerical Algorithm Group [COMMERCIAL] - "The world’s largest collection of robust, documented, tested and maintained numerical algorithms."
  • Site: https://www.nag.co.uk/nag-c-library
  • C++ Wrappers
• IMSL (International Mathematics and Statistics Library) Numeric Libraries [COMMERCIAL] (C and Fortran)
  • "The IMSL Numerical Libraries are a comprehensive set of mathematical and statistical functions that programmers can embed into their software applications. Using these libraries adds performance and quality to an application and saves developers time because they don't need to write the functionality themselves. IMSL is composed of the following types of functions: Matrix Operations, Linear Algebra, Interpolation, Approximation, Numerical Quadrature, OPtimization, Special Functions, Finance adn Bond Calculation, Statistics, Time Series & Forecatising, Da minining, Distribution Functions, Neural Network"
  • See:
    • IMSL Licensing Frequently Asked Questions
    • IMSL Numerical Libraries
  • Documentation:
    • https://docs.roguewave.com/en/imsl/
• Intel MKL - Intel Math Kernel Library - [FREWARE] (C and Fortran Library) - "Intel® Math Kernel Library (Intel® MKL) optimizes code with minimal effort for future generations of Intel® processors. It is compatible with your choice of compilers, languages, operating systems, and linking and threading models.". Note: only C shared and static libraries are provided, not the source code.
  • Site: https://software.intel.com/en-us/mkl
  • License:
    • Intel Simplified Software License (Version April 2018)
    • FAQ
  • Documentation:
    • https://software.intel.com/en-us/mkl-developer-reference-c
  • Wikipedia:
    • https://en.wikipedia.org/wiki/Math_Kernel_Library
  • Github:
    • https://github.com/intel/mkl-dnn
• Ceres Solver "Ceres Solver [1] is an open source C++ library for modeling and solving large, complicated optimization problems. It can be used to solve Non-linear Least Squares problems with bounds constraints and general unconstrained optimization problems. It is a mature, feature rich, and performant library that has been used in production at Google since 2010. For more, see Why?. "
  • Site: http://ceres-solver.org/
  • Docs: http://ceres-solver.org/tutorial.html
  • Repo: https://github.com/ceres-solver/ceres-solver
• ARB - C library for arbitrary-precision ball arithmetic
  • "Arb is a C library for rigorous real and complex arithmetic with arbitrary precision. Arb tracks numerical errors automatically using ball arithmetic, a form of interval arithmetic based on a midpoint-radius representation. On top of this, Arb provides a wide range of mathematical functionality, including polynomials, power series, matrices, integration, root-finding, and many transcendental functions. Arb is designed with efficiency as a primary goal, and is usually competitive with or faster than other arbitrary-precision packages. The code is thread-safe, portable, and extensively tested. Arb is free software distributed under the GNU Lesser General Public License (LGPL), version 2.1 or later"
  • Site: http://arblib.org/
  • Repo: https://github.com/fredrik-johansson/arb/
• Trillinos (Develped by Sandia National Laboratories) - "The Trilinos Project is an effort to develop algorithms and enabling technologies within an object-oriented software framework for the solution of large-scale, complex multi-physics engineering and scientific problems. A unique design feature of Trilinos is its focus on packages."
  • Site: https://trilinos.github.io/
  • Repo: https://github.com/trilinos/Trilinos
  • See:
    • https://en.wikipedia.org/wiki/Trilinos
• FFTW - "FFTW is a C subroutine library for computing the discrete Fourier transform (DFT) in one or more dimensions, of arbitrary input size, and of both real and complex data (as well as of even/odd data, i.e. the discrete cosine/sine transforms or DCT/DST). We believe that FFTW, which is free software, should become the FFT library of choice for most applications."
  • Site: http://www.fftw.org/
• Apophenia - "Apophenia is an open statistical library for working with data sets and statistical models. It provides functions on the same level as those of the typical stats package (such as OLS, Probit, or singular value decomposition) but gives the user more flexibility to be creative in model-building. The core functions are written in C, but experience has shown them to be easy to bind to in Python/Julia/Perl/Ruby/&c. It is written to scale well, to comfortably work with gigabyte data sets, million-step simulations, or computationally-intensive agent-based models."
  • Site: http://apophenia.info/
  • Repo: https://github.com/b-k/apophenia

• TinyExpr - tiny recursive descent expression parser, compiler, and evaluation engine for math expressions.
  • Site: https://codeplea.com/tinyexpr
  • Repo: https://github.com/codeplea/tinyexpr
• SymEngine - SymEngine is a fast symbolic manipulation library, written in C++
  • Site: https://www.sympy.org/en/index.html
  • Repo: https://github.com/symengine/symengine
• GiNac - "GiNaC is a C++ library. It is designed to allow the creation of integrated systems that embed symbolic manipulations together with more established areas of computer science (like computation- intense numeric applications, graphical interfaces, etc.) under one roof. It is distributed under the terms and conditions of the GNU general public license (GPL). GiNaC is an iterated and recursive acronym for GiNaC is Not a CAS, where CAS stands for Computer Algebra System."
  • Site: https://ginac.de/
• FORM - The FORM project for symbolic manipulation of very big expressions.
  • Site: https://www.nikhef.nl/~form/aboutform/aboutform.html
  • Repository: https://github.com/vermaseren/form
• Exprtk (Formula parser and evaluator) - "The C++ Mathematical Expression Toolkit Library (ExprTk) is a simple to use, easy to integrate and extremely efficient run-time mathematical expression parser and evaluation engine. ExprTk supports numerous forms of functional, logical and vector processing semantics and is very easily extendible."
  • Site: http://www.partow.net/programming/exprtk/
  • Repo: https://github.com/ArashPartow/exprtk
• IXION - (Formula/spreadsheet evaluator) - "Ixion is a general purpose formula parser & interpreter that can calculate multiple named targets, or "cells". The goal of this project is to create a library for calculating the results of formula expressions stored in multiple named targets, or "cells". The cells can be referenced from each other, and the library takes care of resolving their dependencies automatically upon calculation. The caller can run the calculation routine either in a single-threaded mode, or a multi-threaded mode. The library also supports re-calculations where the contents of one or more cells have been modified since the last calculation, and a partial calculation of only the affected cells need to be calculated."
  • Site: https://ixion.readthedocs.io/en/latest/cpp/index.html
  • Repo: https://gitlab.com/ixion/ixion

• Boost.Ublas - "uBLAS is a C++ template class library that provides BLAS level 1, 2, 3 functionality for dense, packed and sparse matrices. The design and implementation unify mathematical notation via operator overloading and efficient code generation via expression templates."
• Eigen - "Eigen is a C++ template library for linear algebra: matrices, vectors, numerical solvers, and related algorithms."
• Armadillo - "C++ library for linear algebra & scientific computing"
• Blitz++ - "Blitz++ is a C++ class library for scientific computing which provides performance on par with Fortran 77/90. It uses template techniques to achieve high performance. Blitz++ provides dense arrays and vectors, random number generators, and small vectors (useful for representing multicomponent or vector fields)."
• Blaze - "Blaze is an open-source, high-performance C++ math library for dense and sparse arithmetic. With its state-of-the-art Smart Expression Template implementation Blaze combines the elegance and ease of use of a domain-specific language with HPC-grade performance, making it one of the most intuitive and fastest C++ math libraries available."
• ETL - Expression Templates Library (ETL) with GPU support
• SLEEF - SLEEF Vectorized Math Library - " SLEEF stands for SIMD Library for Evaluating Elementary Functions. It implements vectorized versions of all C99 real floating point math functions. It can utilize SIMD instructions of modern processors. SLEEF is designed to fully utilize SIMD computation by reducing the use of conditional branches and scatter/gather memory access. Our benchmarks show that the performance of SLEEF is comparable to that of the best commercial library. Unlike vendor-tuned libraries, SLEEF is portable : it can be easily ported to other architectures by writing a helper file, which is a thin abstraction layer of SIMD intrinsics. SLEEF is also designed to work with various operating systems and compilers."
  • https://github.com/shibatch/sleef

• Optmlib - "OptimLib is a lightweight C++ library of numerical optimization methods for nonlinear functions."
  • https://github.com/kthohr/optim
• NLOpt - "NLopt is a free/open-source library for nonlinear optimization, providing a common interface for a number of different free optimization routines available online as well as original implementations of various other algorithms."
  • https://nlopt.readthedocs.io/en/latest/

• getfem - "GetFEM++ is an open source library based on collaborative development. It aims to offer the most flexible framework for solving potentially coupled systems of linear and nonlinear partial differential equations with the finite element method. GetFEM++ is interfaced with some script languages (Python, Scilab and Matlab) so that almost all of the functionalities can be used just writing scripts. It works in arbitrary dimension and allow to couple 1D, 2D and 3D problems. GetFEM++ can be used to construct very generic finite element codes, where finite element methods, integration methods and the dimension of the problem are the parameters that can be changed very easily. This allows a wide range of experiments. Many examples and demos are provided."
  • Site: http://getfem.org/
• MFem - MFEM is a free, lightweight, scalable C++ library for finite element methods.
  • Features
    • Arbitrary high-order finite element meshes and spaces.
    • Wide variety of finite element discretization approaches.
    • Scalable to hundreds of thousands of cores.
  • Site: https://mfem.org/
  • Repo: https://github.com/mfem/mfem
• OFELI - An Object Oriented Finite Element Library
  • "Based on a long experience in the development of finite element software, OFELI (Object Finite Element LIbrary) is a framework of C++ classes for the development of finite element programs. Its main features are:"
    • Various storage schemes of matrices (dense, sparse, skyline).
    • Direct methods of solution of linear systems of equations as well as various combinations of iterative solvers and preconditioners.
    • Shape functions of most "popular" finite elements
    • Numerical solution of eigenvalue problems
    • Classes for the solution of most popular problems (Heat Transfer, Fluid Flow, Solid Mechanics, Electromagnetics, …).
  • Site: http://www.ofeli.org/

String Processing Libraries

• StrTk - C++ String Toolkit Library - " The C++ String Toolkit Library (StrTk) consists of robust, optimized and portable string processing algorithms for the C++ language. StrTk is designed to be easy to use and integrate within existing code bases. Furthermore the library has a rich set of features that makes light work of any kind of string processing task."

Parser Framework Libraries

• Boost Spirit - Framework for building parsers which makes heavy use of template metaprogramming.
• PEGTL - "The Parsing Expression Grammar Template Library (PEGTL) is a zero-dependency C++ header-only parser combinator library for creating parsers according to a Parsing Expression Grammar (PEG)."
• Bnflite - "BNFLite is a C++ template library for lightweight flexible grammar parsers. BNFLite offers creative approach when the developer can specify a language for further parsing directly in the C++ code. Moreover, such 'specifications' are executable now! Once the author participated in the development of some tool which was invented to integrate together a lot of proprietary modules. There were thousands combinations of command line options, poor examples, ambiguous docs. So the command line was not compatible from version to version. Up-to-date formal BNF specs of the command line language could help but not for projects with limited budget. Starting YACC era, there is a solution to support some extra executable code describing language specifics. As a rule, usage of such means is too heavy because it is extra stuff and it is not BNF. BNFLite does not have such drawbacks!"
• TheLartians/Parser - "Build your own programming language! A C++17 PEG parser generator supporting parser combination, memoization, left-recursion and context-dependent grammars. A linear-time C++17 PEG parser generator supporting memoization, left-recursion and context-dependent grammars."
• jwtowner/lug - "Parsing expression grammar (PEG) embedded domain specific language and parsing machine for C++17."
  • Features:
    • Natural syntax more akin to external parser generator languages
    • Separation of syntatic and lexical rules, with customizable implicit whitespace skipping
    • Direct and indirect left recursion with precedence levels to disambiguate subexpressions with mixed left/right recursion
    • Header only library using C++17 language and library features
    • Relatively small with the intent of parser core to remain under 1500 lines of terse code
    • … and more …
• STX-EXPARSER - "The STX Expression Parser provides a C++ framework, which can process user-specified expression strings containing program-specific variables. It can be integrated into applications to allow user-customized data selection and filtering. The expresssion strings are intuitive SQL-like WHERE-clauses and can contain arbitrarily complex arithmetic. At the same time the parse tree evaluation speed is guaranteed to be fast enough to safely iterate over larger data sets. The framework uses the Boost.Spirit parser library combined with a versatile custom scalar value class. The expression parser can process arbitrarily complex arithmetic expressions like those seen below. To access application-defined data, functions and variables may be included in the expression. An expression can be used as a boolean filter by using comparison and logic operators."
• PCOMB - "A lightweight parser combinator library written in C++14. Efficiency is not the goal of this library. After all, parsing is almost never a perfomrance bottleneck of a program analysis system. That being said, I try to avoid using heap allocation as much as possible. Most part of the parser is implemented with template metaprogramming and a small part is implemented using class inheritance. "
• Abulafia - "A standalone C++ parsing framework - Abulafia is a C++ expression templates library that generates parsers. The idea is to let programs contain ABNF-like grammars embedded directly within the code. It's heavily inspired by Boost::spirit::QI, but differs fundamentally from it in a number of respects. WARNING: Abulafia is still in early development. While many features work as intended, there are still a LOT of work to be done before it can be considered usable in a real environment."

Parser Code Generator

• ANTLR - "ANTLR (ANother Tool for Language Recognition) is a powerful parser generator for reading, processing, executing, or translating structured text or binary files. It's widely used to build languages, tools, and frameworks. From a grammar, ANTLR generates a parser that can build and walk parse trees."
  • Note: Tool similar to flex/bison. It is Java application (jar executable) that can generate parser code for many programming languages including C++, C# (CSharp), Java, Python and ECMaScript (JavaScript).
  • See:
    • https://tomassetti.me/getting-started-antlr-cpp/
    • https://github.com/antlr/antlr4/blob/master/doc/cpp-target.md
    • https://github.com/antlr/grammars-v4 - Colleciton of Antlr 4 Grammars.

Types of XML Parser Libraries:

• DOM (Document Object Model) based => Parses the XML building an tree data structure in the memory.
• SAX (Simple API for XML) based => Event driven API that works by defining callbacks that are called when the tree is parsed. The advantage is that the XML is not loaded entirely in the memory at once which gives a small memory footprint.
• XPath based => The XML is parsed directly using XPATH query language.

Some XML Libraries

• RapidXML
• Libxml2
• Xerces C++
• Pugixml
• TinyXML

• RapidJSON - [HEADER ONLY] "A fast JSON parser/generator for C++ with both SAX/DOM style API. RapidJSON is a JSON parser and generator for C++. It was inspired by RapidXml."
  • Documentation: http://rapidjson.org/
  • Developed by: Tencent
  • RapidJSON is small but complete. It supports both SAX and DOM style API. The SAX parser is only a half thousand lines of code.
  • RapidJSON is fast. Its performance can be comparable to strlen(). It also optionally supports SSE2/SSE4.2 for acceleration.
  • RapidJSON is self-contained and header-only. It does not depend on external libraries such as BOOST. It even does not depend on STL.
  • RapidJSON is memory-friendly. Each JSON value occupies exactly 16 bytes for most 32/64-bit machines (excluding text string). By default it uses a fast memory allocator, and the parser allocates memory compactly during parsing.
  • RapidJSON is Unicode-friendly. It supports UTF-8, UTF-16, UTF-32 (LE & BE), and their detection, validation and transcoding internally. For example, you can read a UTF-8 file and let RapidJSON transcode the JSON strings into UTF-16 in the DOM. It also supports surrogates and "\u0000" (null character).
• taoJSON [Requires C++17] - "taoJSON is a zero-dependency C++ header-only JSON library that provides a generic Value Class, uses Type Traits to interoperate with C++ types, uses an Events Interface to convert from and to JSON, JAXN, CBOR, MsgPack and UBJSON, and much more…"
• JSON11 - "json11 is a tiny JSON library for C++11, providing JSON parsing and serialization."
  • Developed by: Dropbox
  • Maintenance note: "This repo is stable but no longer actively maintained. No further development is planned, and no new feature PRs will be merged. Bug fixes may be merged on a volunteer basis. If you have questions or want to talk to other users of Djinni, you can join the Slack community via the link at the end of this document."
• Github - nlohmann/json - "JSON for Modern C++"
  • Doxygen: https://nlohmann.github.io/json/
• PicoJSON - "PicoJSON is a tiny JSON parser / serializer for C++ with following properties: header-file only, no external dependencies (only uses standard C++ libraries), STL-frendly (arrays are represented by using std::vector, objects are std::map), provides both pull interface and streaming (event-based) interface."
• YAJL [C Library] - "A fast streaming JSON parsing library in C."
  • Site: http://lloyd.github.io/yajl/
  • "YAJL is data representation independent - BYODR! Many JSON libraries impose a structure based data representation on you. This is a benefit in some cases and a drawback in others. YAJL uses callbacks to remain agnostic of the in-memory representation. So if you wish to build up an in-memory representation, you may do so using YAJL, but you must bring the code that defines and populates the in memory structure."
  • "AJL supports stream parsing - This means you do not need to hold the whole JSON representation in textual form in memory. This makes YAJL ideal for filtering projects, where you're converting YAJL from one form to another (i.e. XML). The included JSON pretty printer is an example of such a filter program."
  • "YAJL is fast - Minimal memory copying is performed. YAJL, when possible, returns pointers into the client provided text (i.e. for strings that have no embedded escape chars, hopefully the common case). I've put a lot of effort into profiling and tuning performance, but I have ignored a couple possible performance improvements to keep the interface clean, small, and flexible. My hope is that YAJL will perform comparably to the fastest JSON parser out there."

• rapidcsv - "Rapidcsv is a C++ header-only library for CSV parsing. While the name admittedly was inspired by the rapidjson project, the objectives are not the same. The goal of rapidcsv is to be an easy-to-use CSV library enabling rapid development. For optimal performance (be it CPU or memory usage) a CSV parser implemented for the specific use-case is likely to be more performant."
  • License: BSD-3
• csvstream - "An easy-to-use CSV file parser for C++."
  • License: MIT
• fast-cpp-csv-parser - "This is a small, easy-to-use and fast header-only library for reading comma separated value (CSV) files."
  • License: BSD-3
  • Features:
    • Automatically rearranges columns by parsing the header line.
    • Disk I/O and CSV-parsing are overlapped using threads for efficiency.
    • Parsing features such as escaped strings can be enabled and disabled at compile time using templates. You only pay in speed for the features you actually use.
    • Can read multiple GB files in reasonable time.
    • Support for custom columns separators (i.e. Tab separated value files are supported), quote escaped strings, automatic space trimming.
    • Works with *nix and Windows newlines and automatically ignores UTF-8 BOMs.
    • Exception classes with enough context to format useful error messages. what() returns error messages ready to be shown to a user.

Overview:

HCON is a configuration file-format that is more ligthweight and readable than JSON. The syntax looks like JSON and QT's QML.

• Specification: https://github.com/lightbend/config/blob/master/HOCON.md

Parsers

• cpp-hcon - A C++ port of the Typesafe Config library.

• Boost Asio - "Boost.Asio is a cross-platform C++ library for network and low-level I/O programming that provides developers with a consistent asynchronous model using a modern C++ approach."
• ACE - Adaptive Communication Environment - "The ADAPTIVE Communication Environment (ACE) is a freely available, open-source object-oriented (OO) framework that implements many core patterns for concurrent communication software. ACE provides a rich set of reusable C++ wrapper facades and framework components that perform common communication software tasks across a range of OS platforms. The communication software tasks provided by ACE include event demultiplexing and event handler dispatching, signal handling, service initialization, interprocess communication, shared memory management, message routing, dynamic (re)configuration of distributed services, concurrent execution and synchronization. ACE is targeted for developers of high-performance and real-time communication services and applications. It simplifies the development of OO network applications and services that utilize interprocess communication, event demultiplexing, explicit dynamic linking, and concurrency. In addition, ACE automates system configuration and reconfiguration by dynamically linking services into applications at run-time and executing these services in one or more processes or threads."
• evpp - "evpp is a modern C++ network library for developing high performance network services using TCP/UDP/HTTP protocols. evpp provides a TCP Server to support multi-threaded nonblocking event-driven server and also a HTTP, UDP Server to support HTTP and UDP protocols."
  • Note: Also provides HTTP server classes.
  • Features: Modern C++11 interface; Modern functional/bind style callback instead of C-style function pointer; Multi-core friendly and thread-safe; A nonblocking multi-threaded TCP server; A nonblocking TCP client; A nonblocking multi-threaded HTTP server based on the buildin http server of libevent; A nonblocking HTTP client; A nonblocking multi-threaded UDP server; Async DNS resolving; EventLoop/ThreadPool/Timer; Well tested — evpp is well tested with unit tests and stress tested daily in production. It has been used in production and processes 1000+ billions networking communications every day in our production; Easy install — evpp can be packaged as a deb, rpm, tar.gz with a single command for straight forward distribution and integration.
• yojimbo [GAMES] - "A network library for client/server games with dedicated servers. yojimbo is a network library for client/server games with dedicated servers. It's designed around the networking requirements of competitive multiplayer games like first person shooters. It has the following features: Cryptographically secure authentication via connect tokens; Client/server connection management and timeouts; Encrypted and signed packets sent over UDP; Reliable-ordered messages and data blocks; Packet fragmentation and reassembly; Estimates of packet loss, latency and bandwidth usage. yojimbo is stable and well tested having been used in AAA game projects for over 2 years now."
• ZeroMQ - Framework fro building distributed message systems or message brokers.
• libsourcey - "LibSourcey is a collection of cross platform C++11 modules and classes that provide developers with an arsenal for rapidly developing high performance network based p2p and media streaming applications. Think of it as the power of libuv combined with the features of FFmpeg, OpenCV and WebRTC, all integrated with the ease and readability of the stl (C++ Standard Library)."
• LCM - Lightweight Communications and Marshalling (LCM)
  • "LCM is a set of libraries and tools for message passing and data marshalling, targeted at real-time systems where high-bandwidth and low latency are critical. It provides a publish/subscribe message passing model and automatic marshalling/unmarshalling code generation with bindings for applications in a variety of programming languages."
  • Features: Low-latency inter-process communication; Efficient broadcast mechanism using UDP Multicast; Type-safe message marshalling; User-friendly logging and playback; No centralized "database" or "hub" – peers communicate directly; No daemons; Few dependencies.
  • Note: LCM was originally developed in 2006 for the MIT DARPA Urban Challenge team, and has since been used in many robotic and autonomous systems, in both research and production environments.
• Jrtplib - (RTP Protocol) "JRTPLIB is an object-oriented RTP library written in C++. It was first developed for my thesis at the School for Knowledge Technology (or 'School voor Kennistechnologie' in Dutch), a cooperation between the Hasselt University and the Maastricht University."

• Curlpp - [HTTP] [MULTI-PROTOCOL CLIENT]
  • "cURLpp is a C++ wrapper for ibcURL. libcURL is described as: a free and easy-to-use client-side URL transfer library, supporting FTP, FTPS, HTTP, HTTPS, GOPHER, TELNET, DICT, FILE and LDAP. libcurl supports HTTPS certificates, HTTP POST, HTTP PUT, FTP uploading, kerberos, HTTP form based upload, proxies, cookies, user+password authentication, file transfer resume, http proxy tunneling and more!"
• cpp-netlib - [BOOST NAMESPACE] A collection of open-source libraries for high level network programming.
  • "cpp-netlib is a collection of network-related routines/implementations geared towards providing a robust cross-platform networking library. cpp-netlib offers the following implementations: Common Message Type – A generic message type which can be used to encapsulate and store message-related information, used by all network implementations as the primary means of data exchange; Network protocol message parsers – A collection of parsers which generate message objects from strings; Adapters and Wrappers – A collection of Adapters and wrappers aimed towards making the message type STL friendly; Network protocol client and server implementations – A collection of network protocol implementations that include embeddable client and server types."

• restbed - "Restbed is a comprehensive and consistent programming model for building applications that require seamless and secure communication over HTTP, with the ability to model a range of business processes, designed to target mobile, tablet, desktop and embedded production environments. It's akin to embedding NGINX into your companies own product line. – Solutions Architect, Bellrock Technology"
  • Features: WebSockets; Server-Sent Events; SSL/TSL; HTTP Pipelining; Path Parameters; Logging; Compression; Rules Engines.
  • License: Dual - AGPL or Commercial.
• Wt, Web Toolkit - "Wt is a C++ library for developing web applications. It consists of: libwt, a widget/rendering library; libwthttp, an (async I/O) HTTP/WebSockets server; libwtfcgi, a FastCGI connector library (Unix); libwtisapi, an ISAPI connector library (Windows); libwttest, a test connector environment. It also contains a C++ ORM, which can be used in a web application (obviously), but can also be used on its own: libwtdbo, a C++ ORM; libwtdbopostgres, PostgreSQL backend; libwtdbosqlite3, Sqlite3 backend; libwtdbomysql, MySQL and MariaDB backend; libwtdbomssqlserver, Microsoft SQL Server backend; libwtdbofirebird, Firebird backend."
  • Note: Provides Widgets with an API similar to Desktop user interface GUI toolkits such as WxWidgets or Qt Framework.
  • Web Site: https://www.webtoolkit.eu/wt
• Reason C++ framework - "Reason is a cross platform Web framework designed to bring the ease of use of Java, .Net, or Python to developers who require the performance and strength of C++."
  • License: Dual license GPL v2.0 and commercial.
• Boost.Beast - "Beast is a C++ header-only library serving as a foundation for writing interoperable networking libraries by providing low-level HTTP/1, WebSocket, and networking protocol vocabulary types and algorithms using the consistent asynchronous model of Boost.Asio."
• Silicon Framework - "A high performance, middleware oriented C++14 http web framework"
  • Repo: https://github.com/matt-42/silicon
• served - "Served is a C++ library for building high performance RESTful web servers. Served builds upon Boost.ASIO to provide a simple API for developers to create HTTP services in C++. Features: HTTP 1.1 compatible request parser; Middleware / plug-ins; Flexible handler API; Cross-platform compatible".
• Mongoose - "Mongoose Embedded Web Server Library - Mongoose is more than an embedded webserver. It is a multi-protocol embedded networking library with functions including TCP, HTTP client and server, WebSocket client and server, MQTT client and broker and much more. Mongoose is ideal for embedded environments. It has been designed for connecting devices and bringing them online. On the market since 2004, used by vast number of open source and commercial products - it even runs on the International Space station! Mongoose makes embedded network programming fast, robust, and easy."
  • Note: GPL 2.0 License and commercial license for closed source.
• WebSocketpp, aka WebSocket++ - [WEB SOCKET SERVER] "WebSocket++ is a header only C++ library that implements RFC6455 The WebSocket Protocol. It allows integrating WebSocket client and server functionality into C++ programs. It uses interchangeable network transport modules including one based on raw char buffers, one based on C++ iostreams, and one based on Asio (either via Boost or standalone). End users can write additional transport policies to support other networking or event libraries as needed."
• gSOAP - "Our gSOAP toolkit allows C/C++ developers to focus on application logic instead of infrastructure, resulting in reduced development time, fewer bugs, and faster time to market."
• Httpp - "Micro http server and client written in C++"
• Silicon C++ Web Framework - "Write Fast and Robust Web APIs with C++"
• Ngrest - "Fast and easy C++ RESTful WebServices framework"

• RPCLIB - "rpclib is a RPC library for C++, providing both a client and server implementation. It is built using modern C++14, and as such, requires a recent compiler. Main highlights: Expose functions of your program to be called via RPC (from any language implementing msgpack-rpc); Call functions through RPC (of programs written in any language); No IDL to learn; No code generation step to integrate in your build, just C++."
  • Repository: https://github.com/rpclib/rpclib
• CAPNPROTO - RPC system with a Cap'n proto serialziation format which the library page claims to be much faster than JSON and protocol buffers.
  • Repository: https://github.com/capnproto/capnproto
  • Features:
    • "The Cap’n Proto encoding is appropriate both as a data interchange format and an in-memory representation, so once your structure is built, you can simply write the bytes straight out to disk!"
    • "mmap: Read a large Cap’n Proto file by memory-mapping it. The OS won’t even read in the parts that you don’t access."
    • "Inter-language communication: Calling C++ code from, say, Java or Python tends to be painful or slow. With Cap’n Proto, the two languages can easily operate on the same in-memory data structure."
    • "_Inter-process communication_: Multiple processes running on the same machine can share a Cap’n Proto message via shared memory. No need to pipe data through the kernel. Calling another process can be just as fast and easy as calling another thread."
• ICE - "Ice is a comprehensive RPC framework with support for C++, C#, Java, JavaScript, Python, and more."
  • License: GPLv2 for open source projects, any commercial project requires buying a proper license.

Low level socket manipulation and raw socket

• Libtins - "libtins is a high-level, multiplatform C++ network packet sniffing and crafting library. Its main purpose is to provide the C++ developer an easy, efficient, platform and endianness-independent way to create tools which need to send, receive and manipulate network packets."
• PcapPlusPlus - "PcapPlusPlus is a multiplatform C++ network sniffing and packet parsing and crafting framework. It's meant to be lightweight, efficient and easy to use."

• glfw - "GLFW is an Open Source, multi-platform library for OpenGL, OpenGL ES and Vulkan application development. It provides a simple, platform-independent API for creating windows, contexts and surfaces, reading input, handling events, etc. GLFW natively supports Windows, macOS and Linux and other Unix-like systems. On Linux both X11 and Wayland is supported. GLFW is licensed under the zlib/libpng license."
  • Web Site: https://www.glfw.org
• GLM - OpenGL Mathematics - "OpenGL Mathematics (GLM) is a header only C++ mathematics library for graphics software based on the OpenGL Shading Language (GLSL) specifications."
• bgx - "Cross-platform, graphics API agnostic, "Bring Your Own Engine/Framework" style rendering library. Supported rendering backends: Direct3D 9; Direct3D 11; Direct3D 12; Metal; OpenGL 2.1; OpenGL 3.1+; OpenGL ES 2; OpenGL ES 3.1; Vulkan; WebGL 1.0; WebGL 2.0"
  • Summary: Open-GL like library that abstract over many different GPU computer-graphics APIs such as OpenGL, DirectX and Metal (Apple).
  • See:
    • Documentation: https://bkaradzic.github.io/bgfx/overview.html
• oogplus - C++ Wrapper for OpenGL
  • "OGLplus is a collection of open-source, cross-platform libraries which implement an object-oriented facade over the OpenGL® (version 3 and higher) and also OpenAL® (version 1.1) and EGL (version 1.4) C-language APIs. It provides wrappers which automate resource and object management and make the use of these libraries in C++ safer and more conve… http://oglplus.org/"
• glbinding - "glbinding leverages C++11 features like enum classes, lambdas, and variadic templates, instead of relying on macros; all OpenGL symbols are real functions and variables. It provides type-safe parameters, per feature API header, lazy function resolution, multi-context and multi-thread support, global and local function callbacks, meta information about the generated OpenGL binding and the OpenGL runtime, as well as tools and examples for quick-starting your projects. Based on the OpenGL API specification (gl.xml) glbinding is generated using python scripts and templates that can be easily adapted to fit custom needs."
  • Site: https://glbinding.org
• Glew - The OpenGL Extension Wrangler Library - " The OpenGL Extension Wrangler Library (GLEW) is a cross-platform open-source C/C++ extension loading library. GLEW provides efficient run-time mechanisms for determining which OpenGL extensions are supported on the target platform. OpenGL core and extension functionality is exposed in a single header file. GLEW has been tested on a variety of operating systems, including Windows, Linux, Mac OS X, FreeBSD, Irix, and Solaris."
• mathfu
  • "MathFu is a C++ math library developed primarily for games focused on simplicity and efficiency. It provides a suite of vector, matrix and quaternion classes to perform basic geometry suitable for game developers. This functionality can be used to construct geometry for graphics libraries like OpenGL or perform calculations for animation or physics systems. The library is written in portable C++ with SIMD compiler intrinsics and has been tested on the following platforms: Android; Linux (x86_64); OS X and Windows"

• godot - "Godot Engine is a feature-packed, cross-platform game engine to create 2D and 3D games from a unified interface. It provides a comprehensive set of common tools, so that users can focus on making games without having to reinvent the wheel. Games can be exported in one click to a number of platforms, including the major desktop platforms (Linux, Mac OSX, Windows) as well as mobile (Android, iOS) and web-based (HTML5) platforms."
  • Site: https://godotengine.org/
  • Twitter: https://twitter.com/godotengine?lang=en
  • Reddit: https://www.reddit.com/r/godot/
• Ogre3D - Object-Oriented Graphics Rendering Engine
  • API Docs: https://ogrecave.github.io/ogre/api/latest/
• SDL - "Simple DirectMedia Layer is a cross-platform development library designed to provide low level access to audio, keyboard, mouse, joystick, and graphics hardware via OpenGL and Direct3D. It is used by video playback software, emulators, and popular games including Valve's award winning catalog and many Humble Bundle games."
• Allegro - "Allegro is a cross-platform library intended for use in computer games and other types of multimedia programming."
• SFML - "SFML provides a simple interface to the various components of your PC, to ease the development of games and multimedia applications. It is composed of five modules: system, window, graphics, audio and network."
• raylib - "raylib is a simple and easy-to-use library to enjoy videogames programming. raylib is highly inspired by Borland BGI graphics lib and by XNA framework."
  • https://github.com/raysan5/raylib
• Magnum Engine - "Lightweight and modular C++11/C++14 graphics middleware for games and data visualization."
• Cinder - "Cinder is a C++ library for programming with aesthetic intent - the sort of development often called creative coding. This includes domains like graphics, audio, video, and computational geometry. Cinder is cross-platform, with official support for macOS, Windows, Linux, iOS, and Windows UWP."
• Bgfx - Cross-platform, graphics API agnostic, “Bring Your Own Engine/Framework” style rendering library, licensed under permissive BSD-2 clause open source license.
• Openframeworks - "openFrameworks is an open source C++ toolkit for creative coding."

• Plplot - "PLplot is a cross-platform software package for creating scientific plots whose (UTF-8) plot symbols and text are limited in practice only by what Unicode-aware system fonts are installed on a user's computer. The PLplot software, which is primarily licensed under the LGPL, has a clean architecture that is organized as a core C library, separate language bindings for that library, and separate device drivers that are dynamically loaded by the core library which control how the plots are presented in noninteractive and interactive plotting contexts. The PLplot core library can be used to create standard x-y plots, semi-log plots, log-log plots, contour plots, 3D surface plots, mesh plots, bar charts and pie charts. Multiple graphs (of the same or different sizes) may be placed on a single page, and multiple pages are allowed for those device formats that support them."
  • Repository: https://github.com/PLplot/PLplot (Mirror)
• Kitware/VTK [Scientific visualization] - "VTK is an open-source software system for image processing, 3D graphics, volume rendering and visualization. VTK includes many advanced algorithms (e.g., surface reconstruction, implicit modelling, decimation) and rendering techniques (e.g., hardware-accelerated volume rendering, LOD control). VTK is used by academicians for teaching and research; by government research institutions such as Los Alamos National Lab in the US or CINECA in Italy; and by many commercial firms who use VTK to build or extend products. The origin of VTK is with the textbook "The Visualization Toolkit, an Object-Oriented Approach to 3D Graphics" originally published by Prentice Hall and now published by Kitware, Inc. (Third Edition ISBN 1-930934-07-6). VTK has grown (since its initial release in 1994) to a world-wide user base in the commercial, academic, and research communities."
  • Site: https://vtk.org/
  • https://en.wikipedia.org/wiki/VTK
• OpenSceneGraph (Scene Graph)
  • "The OpenSceneGraph is an open source high performance 3D graphics toolkit, used by application developers in fields such as visual simulation, games, virtual reality, scientific visualization and modelling. Written entirely in Standard C++ and OpenGL it runs on all Windows platforms, OSX, GNU/Linux, IRIX, Solaris, HP-Ux, AIX and FreeBSD operating systems. The OpenSceneGraph is now well established as the world leading scene graph technology, used widely in the vis-sim, space, scientific, oil-gas, games and virtual reality industries."
• OpenCascade (CAD/CAM Engine)
  • "Open CASCADE Technology (OCCT) is an object-oriented C++ class library designed for rapid production of sophisticated domain-specific CAD/CAM/CAE applications. OCCT library is designed to be truly modular and extensible, providing C++ classes for: Basic data structures (geometric modeling, visualization, interactive selection and application specific services); Modeling algorithms; Working with mesh (faceted) data; Data interoperability with neutral formats (IGES, STEP);"
• buserror/libc3 (Scene Graph) [C Library]
  • "WARNING This API is not your nanny. It is made to be lean, mean, efficient with no frill, no asserts, no bounds checking, no sugar coating. On the other hand it's fast, reasonably clean and is a micro-fraction of the other giganormous 'scene graphs' or 'game engine' libraries around. It's vaguely inspired by THREE.js funnily enough, because it allows you to hack around and quickly get stuff on screen with the minimal amount of effort."

• entt - "EnTT is a header-only, tiny and easy to use library for game programming and much more written in modern C++, mainly known for its innovative entity-component-system (ECS) model. Among others, it's used in Minecraft by Mojang and the ArcGIS Runtime SDKs by Esri. Open an issue or submit a PR if you don't see your project in the list!"
  • https://github.com/skypjack/entt/wiki
• entityx - "EntityX - A fast, type-safe C++ Entity-Component system"
• anax - "anax is an open source C++ entity system designed to be portable, lightweight and easy to use. It is aimed toward Game Development, however it would be possible to use it for other projects."

• assimp - Open Asset Import Library (assimp)
  • Brief: Library for importing a broad range of game assets.
  • "Official Open Asset Import Library Repository. Loads 40+ 3D file formats into one unified and clean data structure. http://www.assimp.org"
• glad - Multi-Language Vulkan/GL/GLES/EGL/GLX/WGL Loader-Generator based on the official specs. https://glad.dav1d.de/
• nanogui - "NanoGUI is a minimalistic cross-platform widget library for OpenGL 3.x or higher. It supports automatic layout generation, stateful C++11 lambdas callbacks, a variety of useful widget types and Retina-capable rendering on Apple devices thanks to NanoVG by Mikko Mononen. Python bindings of all functionality are provided using pybind11."
• Imgui - Imediate mode GUI Library for games
• neogfx - Cross-platform GPU-oriented C++ application/game framework
  • "neoGFX is a cross-platform GPU-oriented C++ application/game framework. neoGFX is still a work in progress (incomplete) so is not yet suitable for making apps or games. Currently neogfx has only been built for and tested on Windows."
  • Site: https://neogfx.org/
  • Features:
    • clean modern C++ design including full exception safety supporting various widget allocation patterns (stack, member variable or free store);
    • use of standard non-proprietary C++ data types including using standard string classes (UTF-8 encoding) and containers from the C++ standard library;
    • scripting engine, neos, that will be able to support a wide range of scripting languages (on release: neoscript, JavaScript and Lua);
    • Pure ECS (Entity-component-system) usable by both games and apps;
    • support for OpenGL, DirectX and Vulkan.
• nanovg - NanoVG is small antialiased vector graphics rendering library for OpenGL. It has lean API modeled after HTML5 canvas API. It is aimed to be a practical and fun toolset for building scalable user interfaces and visualizations.
• Visionary - Visionaray - A C++ ray tracing template library
  • https://github.com/szellmann/visionaray
• apitrace [TOOL, APP] - "apitrace consists of a set of tools to: trace OpenGL, OpenGL ES, Direct3D, and DirectDraw APIs calls to a file; replay OpenGL and OpenGL ES calls from a file; inspect OpenGL state at any call while retracing; visualize and edit trace files."

• ETLCPP - Embedded Template Library
• CPPREG - "cppreg is a header-only C++11 library to facilitate the manipulation of MMIO registers (i.e., memory-mapped I/O registers) in embedded devices. The idea is to provide a way to write expressive code and minimize the likelihood of ill-defined expressions when dealing with hardware registers on a MCU (Microcontroller Unit)."
• LIVUAVCAN - "Portable reference implementation of the UAVCAN protocol stack in C++ for embedded systems and Linux. UAVCAN is a lightweight protocol designed for reliable communication in aerospace and robotic applications via CAN bus."
  • Site: https://uavcan.org/
  • Repos:
    • https://github.com/UAVCAN/libuavcan
    • https://github.com/UAVCAN/libuavcan_stm32
• CppUtest - "CppUTest unit testing and mocking framework for C/C++ - CppUTest is a C /C++ based unit xUnit test framework for unit testing and for test-driving your code. It is written in C++ but is used in C and C++ projects and frequently used in embedded systems but it works for any C/C++ project."
  • http://cpputest.github.com
  • https://github.com/cpputest/cpputest
• Mongoose - "Mongoose Embedded Web Server Library - Mongoose is more than an embedded webserver. It is a multi-protocol embedded networking library with functions including TCP, HTTP client and server, WebSocket client and server, MQTT client and broker and much more. Mongoose is ideal for embedded environments. It has been designed for connecting devices and bringing them online. On the market since 2004, used by vast number of open source and commercial products - it even runs on the International Space station! Mongoose makes embedded network programming fast, robust, and easy."
  • Note: GPL 2.0 License and commercial license for closed source.
• tianocore/edk2
  • "A modern, feature-rich, cross-platform firmware development environment for the UEFI and PI specifications from www.uefi.org. The majority of the content in the EDK II open source project uses a BSD-2-Clause Plus Patent License. The EDK II open source project contains the following components that are covered by additional licenses: …"
• Arduino Library List - "A list of the 2303 libraries registered in the Arduino Library Manager."

• Contiki - "Contiki is an open source operating system for the Internet of Things. Contiki connects tiny low-cost, low-power microcontrollers to the Internet. Contiki is a powerful toolbox for building complex wireless systems. Contiki is developed by a world-wide team of developers with contributions from Atmel, Cisco, ETH, Redwire LLC, SAP, Thingsquare, and many others, led by Adam Dunkels of Thingsquare."
  • Repository: https://github.com/contiki-os/contiki
• Zephyr - "The Zephyr Project is a scalable real-time operating system (RTOS) supporting multiple hardware architectures, optimized for resource constrained devices, and built with security in mind. The Zephyr OS is based on a small-footprint kernel designed for use on resource-constrained systems: from simple embedded environmental sensors and LED wearables to sophisticated smart watches and IoT wireless gateways. The Zephyr kernel supports multiple architectures, including ARM Cortex-M, Intel x86, ARC, Nios II, Tensilica Xtensa, and RISC-V, and a large number of supported boards."
  • Repository: https://github.com/zephyrproject-rtos/zephyr

• QP/C++ - RTOS kernel - License: dual GPL. Closed source applications require a commercial license.
• distortos - object-oriented C++ RTOS for microcontrollers
• FreeRTOS Kernel / RTOS
• Linux Xenomai - " Xenomai brings POSIX and traditional RTOS APIs for porting time-critical applications to Linux-based platforms. When the native Linux kernel cannot meet the response time requirements of the application, Xenomai supplements it with Cobalt, a small real-time infrastructure which schedules time-critical activities independently from the main kernel logic."
  • Repository: https://gitlab.denx.de/Xenomai/xenomai
  • See:
    • Xenomai Wiki
    • Xenomai 3 - An Overview of the Real-Time Framework for Linux
    • Real Time Linux explained, and constrated with Xenomai adn RTAI
• RTEMS / RTOS - Real-Time Executive for Multiprocessor Systems
  • "The Real-Time Executive for Multiprocessor Systems or RTEMS is an open source Real Time Operating System (RTOS) that supports open standard application programming interfaces (API) such as POSIX. It is used in space flight, medical, networking and many more embedded devices using processor architectures including ARM, PowerPC, Intel, Blackfin, MIPS, Microblaze and more. Commercial support is available from US and European companies, and free support comes via the active global community."
  • Comes from: Aerospace Industry
  • See:
    • Qt on Microcontrollers (MCU)
    • NASA Solar Dynamic Observatory Launched
• eCOS / RTOS - Open Source Real Time Operating System
  • "eCos is a free open source real-time operating system intended for embedded applications. The highly configurable nature of eCos allows the operating system to be customised to precise application requirements, delivering the best possible run-time performance and an optimised hardware resource footprint. A thriving net community has grown up around the operating system ensuring on-going technical innovation and wide platform support."
  • Comes from: Automotive Industry

• Orocos - Open Robot Control Software - Set of libraries for implementing robot control software.
  • Repositories:
    • https://github.com/orocos-toolchain/
    • https://github.com/orocos
• ROS - Robot Operating System - "Set of software libraries and tools that help you build robot applications. From drivers to state-of-the-art algorithms, and with powerful developer tools, ROS has what you need for your next robotics project. And it's all open source."

• libmodbus - "A Modbus library for Linux, Mac OS X, FreeBSD, QNX and Win32"
• QModMaster - Modbus TCP,RTU Master Software - "QModMaster is a free Qt-based implementation of a ModBus master application. A graphical user interface allows easy communication with ModBus RTU and TCP slaves. QModMaster also includes a bus monitor for examining all traffic on the bus."
• modbuspp - A C++ Library for Modbus TCP Protocol

• CuteHMI
  • "CuteHMI is meant to be a set of software components (libraries and executables) targeted at building HMI ( Human Machine Interface) applications. These components aim to fill the gap, between open-source editions of Qt and commercial software targeted at physical computing (HMI / SCADA / IoT / BMS / RMS / etc) build around it, thus providing complete open-source suite for such types of applications for home and industrial use. Example use case is to create user interface that can be used to communicate with PLC (programmable logic controller) to turn on air conditioning in the building for example."
  • Web Site:
    • https://cutehmi.kde.org/
  • Repository:
    • https://invent.kde.org/kde/cutehmi
  • Github Mirror:
    • https://github.com/michpolicht/CuteHMI
• QSimpleScada
  • "Qt/C++ based simple SCADA framework, with dashboard, static and dynamic components. By using QSimpleScada framework you can build complex SCADA uis for your needs."

• QT Framework
  • See: Qt on Microcontrollers (MCU)
• microwindows - Microwindows or the Nano-X Window System
  • "Microwindows or Nano-X is a small graphical windowing system that implements both Win32 and Nano-X (X11-like) APIs for clipped graphics drawing in windows on Linux, Mac OS X, EMSCRIPTEN, Android and other platforms. It is Open Source and licenced under the the Mozilla Public License. For creating GUIs, the Nuklear immediate mode GUI, Win32 builtin controls, and TinyWidget's controls based on Nano-X are included. FLTK can be used with the X11 compability library NX11."
  • Platform support: Currently supported platforms include Linux, Mac OS X, Android, EMSCRIPTEN, Nuklear GUI, Windows, Raspberry Pi, DOS DJGPP, RTEMS, ECOS, Sony PSP, Nintendo DS and more. Currently supported screen drivers include Memory-mapped framebuffer, X11, SDL 2, Allegro 5, Windows and an X11 based framebuffer emulator. Support for cross-compiler toolchains on x86, x86_64, ARM, PowerPC and MIPS, big- and little-endian, and other processors.

• BusyBox (Application - GPL v2.0)
  • "BusyBox combines tinyversions of many common UNIX utilities into a single small executable. It provides minimalist replacements for most of the utilities you usually find in bzip2, coreutils, dhcp, diffutils, e2fsprogs, file, findutils, gawk, grep, inetutils, less, modutils, net-tools, procps, ed, shadow, sysklogd, sysvinit, tar, util-linux, and vim. The utilities in BusyBox often have fewer options than their full-featured cousins; however, the options that are included provide the expected functionality and behave very much like their larger counterparts. BusyBox has been written with size-optimization and limited resources in mind, both to produce small binaries and to reduce run-time memory usage. Busybox is also extremely modular so you can easily include or exclude commands (or features) at compile time. This makes it easy to customize embedded systems; to create a working system, just add /dev, /etc, and a Linux kernel. Busybox (usually together with uClibc) has also been used as a component of "thin client" desktop systems, live-CD distributions, rescue disks, installers, and so on."
  • Official GIT Repo: https://git.busybox.net/busybox/
  • Mirror Repository: https://github.com/mirror/busybox
  • Busybox for Android: https://github.com/meefik/busybox
• ToyBox (BusyBox Clone with BSD License)
  • "Toybox combines common Linux command line utilities together into a single BSD-licensed executable that's simple, small, fast, reasonably standards-compliant, and powerful enough to turn Android into a development environment."
  • Site: http://landley.net/toybox/
  • Repo: https://github.com/landley/toybox
• ELL - Embedded Linux Library
  • "The Embedded Linux* Library (ELL) provides core, low-level functionality for system daemons. It typically has no dependencies other than the Linux kernel, C standard library, and libdl (for dynamic linking). While ELL is designed to be efficient and compact enough for use on embedded Linux platforms, it is not limited to resource-constrained systems."
  • Features:
    • Event loop that may run standalone or be integrated with another event loop
    • D-Bus client
    • Generic Netlink client
    • Timeout handling
    • Signal handling
    • Runtime plugins
    • Asynchronous/non-blocking I/O framework
    • Data structures: Queues (linked list), hash tables, ring buffers
    • String handling
    • Base64 encode/decode
    • File parsing (PEM, hwdb, settings)
    • Symmetric ciphers (kernel support required)
    • RSA cryptography (kernel support required)
    • Key handling

Note: Listing of alternative Linux C-runtime libraries to the GLIBC (GNU LibC / GPL).

• MUSL
  • License: MIT
  • Musl is a lightweight Linux C-runtime library suitable for generating portable static-linked self-contained executables.
  • "musl is a “libc”, an implementation of the standard library functionality described in the ISO C and POSIX standards, plus common extensions, intended for use on Linux-based systems. Whereas the kernel (Linux) governs access to hardware, memory, filesystems, and the privileges for accessing these resources, the C library is responsible for providing the actual C function interfaces userspace applications see, and for constructing higher-level buffered stdio, memory allocation management, thread creation and synchronization operations, and so on using the lower-level interfaces the kernel provides, as well as for implementing pure library routines of the C language like strstr, snprintf, strtol, exp, sqrt, etc."
  • Repository Mirror: https://github.com/ifduyue/musl
• DietLibc
  • "The diet libc is a libc that is optimized for small size. It can be used to create small statically linked binaries for Linux on alpha, arm, hppa, ia64, i386, mips, s390, sparc, sparc64, ppc and x86_64."
• ULIBC
  • License: LGPL-2.1
  • "uClibc-ng is a small C library for developing embedded Linux systems. It is much smaller than the GNU C Library, but nearly all applications supported by glibc also work perfectly with uClibc-ng."
  • Web Sites:
    • https://uclibc-ng.org/
    • https://uclibc.org/
• Bionic - Android CRT C-Runtime Library created by Google for Android Operating System. Unlike most Linux distribution built on top of Linux Kernel which uses the GLIBC (GNU C Library) as CRT, Android uses Bionic C library which is based on BSD C Library.
  • License: BSD-3
  • Repository: https://android.googlesource.com/platform/bionic
• uClibC++ (C++ Runtime Library)
  • "This is the page for the uClibc++ C++ library. It is currently in development and might as well be called alpha software. Nonetheless is it quite usable. More testing is needed, as always. For more information, check out the About, FAQ or Status pages to the left."
• EGLIBC [DISCONTINUED]
  • License: LGPL-2.1
  • " Embedded GLIBC (EGLIBC) was a variant of the GNU C Library (GLIBC) that was designed to work well on embedded systems. EGLIBC strived to be source and binary compatible with GLIBC. EGLIBC's goals included reduced footprint, configurable components, better support for cross-compilation and cross-testing."
• RT0 - "A minimal C runtime for Linux i386 & x86_64"

See also:

Comparison between Linux C-Runtime Libraries:

• http://www.etalabs.net/compare_libcs.html

C Library Comparison:

• https://wiki.osdev.org/C_Library

Choosing System C Library:

• https://events.static.linuxfound.org/sites/events/files/slides/libc-talk.pdf

C library system-call wrappers, or the lack thereof

• https://lwn.net/Articles/771441/