| Non-intrusive CMake dependency management.

| A CMake script that adds dependency management capabilities to CMake. It's built as a thin wrapper around CMake's FetchContent module that adds version control, caching, a simple API and more.

| A CMake driven cross-platform package manager for C/C++ projects.

{{librow | Aquila | https://github.com/zsiciarz/aquila | Open-source and cross-platform DSP library for C++11. | MIT | CMake}}

{{librow | Essentia | https://essentia.upf.edu/index.html | Open-source library and tools for audio and music analysis, description and synthesis (MIR) ([https://github.com/MTG/essentia Src]) | [https://www.gnu.org/licenses/agpl.html Affero GPLv3]}}

{{librow | FFTW | https://www.fftw.org/ | A library for computing the DFT (SSE/SSE2/AVX/Altivec/ARM Neon). ([https://github.com/FFTW/fftw3 Src]) | GPL-2.0 | CMake}}

{{librow | KFR | https://www.kfrlib.com | Fast, modern, C++17, open source, cross-platform DSP/DFT framework, supports Audio resampling, FIR/IIR filters, Biquad, (SSE, AVX, AVX-512, ARM NEON). ([https://github.com/kfrlib/kfr Src]) | GPL-2.0 | CMake}}

{{librow | soundtouch | https://www.surina.net/soundtouch/ | SoundTouch is an open-source cross-platform audio processing library for changing the Tempo, Pitch and Playback Rates of audio streams or audio files. ([https://gitlab.com/soundtouch/soundtouch Src]) | [https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html LGPL-2.1] | Makefile}}

{{librow | libkcompactdisc | https://github.com/KDE/libkcompactdisc | Library for interfacing with CDs | GPL v2.0 | CMake}}

{{librow | chromaprint | https://acoustid.org/chromaprint | Chromaprint is an audio fingerprint library designed to identify near-identical audio. It trades precision and robustness for search performance. Chromaprint can use multiple FFT libraries - FFmpeg, FFTW3, KissFFT or vDSP. ([https://github.com/acoustid/chromaprint Src]) | MIT, LGPL 2.1 | CMake}}

{{librow | libmusicbrainz | https://musicbrainz.org/doc/libmusicbrainz | The MusicBrainz Client Library (libmusicbrainz), also known as mb_client, is a development library geared towards developers who wish to add MusicBrainz lookup capabilities to their applications. The library supports Windows, Linux and Mac OS X ([https://github.com/metabrainz/libmusicbrainz Src]) | LGPL-2.1 | CMake}}

{{librow | libofa | https://github.com/tanob/libofa/ | Open-source audio fingerprint by MusicIP | [https://github.com/tanob/libofa/blob/master/COPYING APL] | makefile}}

{{librow | audiofile | https://audiofile.68k.org/ | AudioFile Library handles reading and writing audio files in many common formats. ([https://github.com/mpruett/audiofile/ Src]) | LGPL-2.1 | makefile}}

{{librow | flac | https://xiph.org/flac/ | FLAC stands for Free Lossless Audio Codec, meaning that audio is compressed in FLAC without any loss in quality. FLAC stands out as the fastest and most widely supported lossless audio codec, non-proprietary, is unencumbered by patents. | [https://opensource.org/docs/definition.php Open Source], BSD, GPL}}

{{librow | libsndfile | http://www.mega-nerd.com/libsndfile/ | Libsndfile is a cross-platform, open-source library for reading and writing files containing sampled sound (such as Windows WAV and the Apple/SGI AIFF format) through one standard library interface. | LGPL v2.0 or v3.0}}

{{librow | taglib | https://taglib.org/ | TagLib Audio Metadata Library is a library for reading and editing the meta-data of several popular audio formats: ID3v1, ID3v2 for MP3 files, Ogg Vorbis comments and ID3 tags and Vorbis comments in FLAC, MPC, Speex, WavPack, TrueAudio, WAV, AIFF, MP4 and ASF files. ([https://github.com/taglib/taglib Src]) | [https://www.gnu.org/licenses/lgpl.html LGPL] and [https://www.mozilla.org/MPL/MPL-1.1.html MPL v1.1]}}

{{librow | benchmark | https://github.com/google/benchmark | A library to benchmark code snippets, similar to unit tests | Apache 2.0 | CMake}}

{{librow | Celero | https://github.com/DigitalInBlue/Celero | Feature-rich C++ Benchmark Authoring Library/Framework. Supports Windows, Linux, and OSX using C++11. | Apache | CMake}}

{{librow | gperftools | https://github.com/gperftools/gperftools | 'Google Performance Tools' includes a high-performance, multi-threaded malloc implementation plus tools for benchmarking heap allocation and CPU utilization. | BSD 3-Clause "New" or "Revised" | configure}}

{{librow | nanobench | https://nanobench.ankerl.com | Simple, fast, accurate single-header microbenchmarking functionality for C++11/14/17/20. ([https://github.com/martinus/nanobench Src]) | MIT | CMake}}

{{librow | plf::nanotimer | https://github.com/mattreecebentley/plf_nanotimer | Lowest-overhead, cross-platform simple timer class for benchmarking. | zlib}}

{{librow | ACE | https://www.dre.vanderbilt.edu/~schmidt/ACE.html | asynchronous networking, event demultiplexing, messaging}}

{{librow | Boost.Asio | https://boost.org/libs/asio/ | asynchronous and synchronous networking, timers, serial I/O | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.Beast | https://boost.org/libs/beast/ | HTTP and WebSocket library built on top of Boost.Asio | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Breep | https://github.com/Organic-Code/Breep | Event based, high-level, peer-to-peer library, allowing users to directly send and receive objects. | European Union Public License 1.1 | CMake}}

{{librow | brpc | https://brpc.apache.org | Industrial-grade RPC framework used throughout Baidu, with 1,000,000+ instances and thousands kinds of services. ([https://github.com/apache/incubator-brpc/ Src]) ([https://brpc.apache.org/docs/ Doc]) | Apache 2.0 | CMake}}

{{librow | C++ REST SDK | https://github.com/Microsoft/cpprestsdk | asynchronous HTTP client and listener, asynchronous Stream, URI, JSON | MIT | CMake}}

{{librow | cpp-netlib | https://github.com/cpp-netlib/cpp-netlib | cpp-netlib: The C++ Network Library | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0] | CMake}}

{{librow | cppsimpleuri | https://github.com/salzaverde/cppsimpleuri | A modern C++ uri & query parser | MIT | CMake}}

{{librow | cpr | https://github.com/whoshuu/cpr | a modern C++ HTTP requests library | MIT | CMake}}

{{librow | Crow | https://github.com/CrowCpp/crow | A header-only C++ micro web framework (inspired by Python Flask) | BSD-3-Clause | CMake}}

{{librow | DumaisLib | https://github.com/pdumais/DumaisLib | Various utilities such as WebServer, JSON, WebSocket server, REST framework (a library for creating a REST API in your c++ app) | MIT | Makefile}}

{{librow | EasyHttp | https://github.com/sony/easyhttpcpp | A cross-platform HTTP client library with a focus on usability and speed, supporting http response caching and more. | MIT | CMake}}

{{librow | eCAL | https://github.com/eclipse-ecal/ecal | high performance inter-process communication | Apache 2.0 | CMake}}

{{librow | fineftp-server | https://github.com/eclipse-ecal/fineftp-server | ftp server library for Windows and Unix | MIT | CMake}}

{{librow | gsoap | http://gsoap2.sourceforge.net/ | C/C++ development toolkit for XML data bindings, fast WSDL/SOAP/XML Web services, WS-Security, JSON/XML-RPC RESTful services}}

{{librow | hmbdc | https://github.com/hmbdc-dev/hmbdc | Headers-only, lightweight and high performance C++17 message pub/sub middleware framework/lib||Headers-only}}

{{librow | HTTPP | https://github.com/daedric/httpp | Simple, production ready HTTP server built on top of Boost and a client built on top of libcurl. | BSD 2-Clause "Simplified" | CMake, Makefile}}

{{librow | IXWebSocket | https://github.com/machinezone/IXWebSocket | Open-source WebSocket + HTTP library without dependency, supports SSL and the per message deflate WebSocket extension. | BSD 3-Clause "New" or "Revised" | CMake, Makefile}}

{{librow | KCP | https://github.com/skywind3000/kcp/blob/master/README.en.md | A fast and reliable ARQ protocol that helps applications to reduce network latency. | MIT | CMake}}

{{librow | libashttp | https://github.com/tghosgor/libashttp | asynchronous HTTP client library | GNU Lesser General Public v3.0}}

This framework provides cross platform JSON-RPC (remote procedure call) support for C++. It is fully JSON-RPC 2.0 & 1.0 compatible. | MIT | CMake, Conan}}

{{librow | libnavajo | https://github.com/titi38/libnavajo | C++ framework including a fast multithreaded http server, HTML5 Websockets, SSL, X509 and HTTP authentification, compression, cookies and advanced session management, IPv4 and IPv6 (CeCILL-C). | CeCILL-C FREE SOFTWARE LICENSE AGREEMENT | CMake}}

{{librow | libtins | https://libtins.github.io/ | Network packet crafting and sniffing library}}

{{librow | LiteNetLibPP | https://github.com/Revan600/LiteNetLibPP | Lightweight reliable UDP library for games | MIT | CMake}}

{{librow | mailio | https://github.com/karastojko/mailio | MIME and email library | BSD 2-Clause "Simplified" | CMake}}

{{librow | nanomsg | https://nanomsg.org/ | fast message queue, zeromq successor}}

{{librow | netif | https://github.com/gmlc-tdc/netif | Header-only C++14 library for getting network addresses on Windows, Linux, macOS, and FreeBSD. | BSD 3-Clause "New" or "Revised" | CMake}}}

{{librow | nghttp2 | https://github.com/nghttp2/nghttp2 | HTTP/2 C Library and tools (server, client, proxy and benchmarking tools) | MIT | CMake, configure}}

{{librow | ngrest | https://github.com/loentar/ngrest | Fast and easy in use JSON RESTful Web Services Framework | Apache 2.0 | CMake}}

{{librow | nng | https://nng.nanomsg.org/ | fast message queue, nanomsg successor}}

{{librow | Oat++ | https://oatpp.io/ | Web framework: REST-API and Request implementation ([https://github.com/oatpp/oatpp Src]) ([https://oatpp.io/docs/start/ Doc]) | Apache 2.0 | CMake}}

{{librow | omniORB | http://omniorb.sourceforge.net | the fastest, complete and portable CORBA ORB implementation in C++}}

{{librow | Paho MQTT | https://github.com/eclipse/paho.mqtt.cpp/ | Modern C++ client for MQTT from Eclipse | | CMake}}

{{librow | paozhu | https://github.com/hggq/paozhu | C++20 Web Framework Support HTTP/2 ORM WebSocket | MIT | CMake}}

{{librow | POCO | https://pocoproject.org/ | networking: encryption, HTTP; Zip files ([https://pocoproject.org/documentation.html Doc])}}

{{librow | rest_rpc | https://github.com/topcpporg/rest_rpc | modern, simple, easy to use rpc framework | | CMake}}

{{librow | restbed | https://github.com/corvusoft/restbed | Restbed framework brings asynchronous RESTful functionality to C++11 applications. | [https://github.com/Corvusoft/restbed/blob/master/LICENSE License] | CMake}}

{{librow | restc-cpp | https://github.com/jgaa/restc-cpp | Takes the pain out of accessing JSON API's from C++. HTTP Client, native C++ class to/from JSON serialization, asynchronous IO trough boost::asio coroutines. C++14. | MIT | CMake}}

{{librow | restful_mapper | https://github.com/logandk/restful_mapper | ORM for consuming RESTful JSON APIs in C++ | | CMake, Makefile}}

{{librow | seastar | https://github.com/scylladb/seastar | High performance server-side application framework, based on C++14/C++17. | Apache 2.0 | CMake, etc.}}

{{librow | Silicon | https://siliconframework.org | The Silicon C++14 Web Framework: Fast and Robust Web APIs | MIT |CMake}}

{{librow | sockpp | https://github.com/fpagliughi/sockpp | A simple, modern C++ socket library | BSD 3-Clause "New" or "Revised" | CMake}}

{{librow | stream-client | https://github.com/TinkoffCreditSystems/stream-client | Lightweight, header-only, Boost-based client-side socket/connector/socket pool/resolver | Apache 2.0 | CMake}}

{{librow | tacopie | https://github.com/Cylix/tacopie/ | C++11 TCP Library | MIT | CMake}}

{{librow | taox11 | https://www.taox11.org | C++11 based CORBA implementation | MIT}}

{{librow | Unicomm | https://sourceforge.net/projects/libunicomm/ | asynchronous networking, high-level TCP communication framework}}

{{librow | uvw | https://github.com/skypjack/uvw | libuv wrapper in modern C++ | MIT | CMake}}

{{librow | WNetWrap | https://github.com/hack-tramp/wnetwrap | WinInet wrapper in C++ | MIT}}

{{librow | wvstreams | https://github.com/apenwarr/wvstreams | C++ networking library including UniConf and a convenient D-Bus API | GPL}}

{{librow | zeromq | https://zeromq.org/ | fast message queue}}

{{librow | AdaptiveCpp | https://github.com/AdaptiveCpp/AdaptiveCpp | Provides a SYCL and C++ parallel STL offloading compiler and runtime system for CPUs and GPUs from NVIDIA, AMD, Intel | BSD-2-Clause | CMake}}

{{librow | Asyncpp | https://github.com/vishnuvijayanklm/Asyncpp | An asynchronous c++ library  that provides various concurrent operations | MIT | CMake}}

{{librow | Boost.Atomic | https://www.boost.org/doc/libs/release/doc/html/atomic.html | provides atomic data types and operations on these data types, as well as memory ordering constraints required for coordinating multiple threads through atomic variables. | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.Compute | https://github.com/kylelutz/compute | (unofficial) GPU/parallel-computing library for C++ based on OpenCL. | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0] | CMake}}

{{librow | Boost.Interprocess | https://www.boost.org/doc/libs/release/doc/html/interprocess.html | simplifies the use of 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, named versions of the synchronization objects, file locking, message queues. | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.Lockfree | https://www.boost.org/doc/libs/release/doc/html/lockfree.html | provides non-blocking (aka lock-free) concurrent data structures: a queue, a stack, and a ringbuffer (spsc_queue). | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.Thread | https://www.boost.org/doc/libs/release/doc/html/thread.html | enables the use of multiple threads of execution with shared data and means for synchronizing data between the threads. | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | concurrencpp | https://github.com/David-Haim/concurrencpp | Modern concurrency for C++. Tasks, executors, timers and C++20 coroutines. | MIT | CMake}}

{{librow | dispenso | https://github.com/facebookincubator/dispenso | High-performance concurrency for C++. parallel_for, Futures, pipelines, timers, timed/periodic tasks, and concurrent data structures. | MIT | CMake}}

{{librow | Highway | https://github.com/google/highway | provides performance-portable, length-agnostic SIMD/vector intrinsics. Supports: SSE3, SSE4, AVX*, NEON, SVE*, WASM SIMD, RISC-V, POWER. ([https://github.com/google/highway/tree/master/g3doc Doc]) | [https://github.com/google/highway/blob/master/LICENSE Apache-2.0] | CMake}}

| Intel® TBB is a cross-platform C++ library for shared memory parallel programming and heterogeneous computing. The library provides: generic parallel algorithms, concurrent containers, a scalable memory allocator, work-stealing task scheduler, and low-level synchronization primitives. ([https://github.com/oneapi-src/oneTBB Src]) ([https://software.intel.com/content/www/us/en/develop/tools/threading-building-blocks/documentation.html Doc]) | [https://github.com/oneapi-src/oneTBB/blob/tbb_2020/LICENSE Apache-2.0] or Commercial | CMake, Makefile}}

{{librow | libsimdpp | https://github.com/p12tic/libsimdpp | A portable header-only zero-overhead C++ low level SIMD library. | Boost | CMake}}

{{librow | MPL | https://github.com/rabauke/mpl | A C++-17-friendly header-only interface to the standard [https://www.mpi-forum.org/ Message Passing Interface] | BSD 3-Clause "New" or "Revised" | CMake}}

{{librow | MutexGear | https://github.com/oleh-derevenko/mutexgear | Mutex-only synchronization (wheel, rwlock, work queues) | The MutexGear Library | configure, MSVC}}

{{librow | PoCL | http://portablecl.org/index.html | A portable retargetable open source (LLVM based) implementation of the OpenCL standard. ([https://github.com/pocl/pocl Src]) ([http://portablecl.org/docs/html Doc]) | MIT | CMake}}

{{librow | RaftLib | https://raftlib.io | C++17 stream-like concurrent actors that enable parallel data-flow computations | Apache-2.0 | CMake}}

{{librow | stdgpu | https://github.com/stotko/stdgpu | Efficient STL-like Data Structures on the GPU | Apache 2.0 | CMake}}

{{librow | subprocess | https://github.com/benman64/subprocess | C++17/20 cross platform library for running subprocesses | MIT | CMake, Teaport}}

{{librow | Taskflow | https://github.com/taskflow/taskflow | Parallel Task Programming in Modern C++ | [https://github.com/taskflow/taskflow/blob/master/LICENSE TASKFLOW MIT] | CMake}}

{{librow | task-thread-pool | https://github.com/alugowski/task-thread-pool | Fast and lightweight thread pool for C++11 and newer. | BSD-2-Clause or MIT or BSL-1.0 | CMake, vcpkg, single header}}

{{librow | ThreadPool | https://github.com/hosseinmoein/Leopard | C++ simple, light-weight, and header-only thread pool | BSD-3-Clause | CMake, Makefile}}

{{librow | thread_pool | https://github.com/DeveloperPaul123/thread-pool | A modern, fast, lightweight thread pool | [https://github.com/DeveloperPaul123/thread-pool/blob/master/LICENSE MIT] | CMake}}

{{librow | Thrust | https://thrust.github.io/ | STL-like parallel algorithms and data-structures on top of CUDA, TBB, or OpenMP | [https://github.com/NVIDIA/thrust#licensing Apache v2.0, Boost v1.0.] | CMake}}

{{librow | TimerAlarm | https://github.com/hosseinmoein/Cheetah | Header-only C++ Timers and Alarms based on threads. | BSD-3-Clause | CMake, Makefile}}

{{librow | VexCL | https://github.com/ddemidov/vexcl | C++ vector expression template library for OpenCL, CUDA, OpenMP | MIT | CMake}}

{{librow | Xenium | https://github.com/mpoeter/xenium | A header-only C++17 library that provides various concurrent data structures and reclamation schemes. | MIT | CMake}}

{{librow | figcone | https://github.com/kamchatka-volcano/figcone | Read JSON, YAML, TOML, XML or INI configuration by declaring a struct | MS-PL | CMake}}

{{librow | libconfini | https://madmurphy.github.io/libconfini/ | INI parser}}

{{librow | uconfig | https://github.com/TinkoffCreditSystems/uconfig | Lightweight, header-only, C++17 configuration library | Apache 2.0 | CMake}}

{{librow | CLI11 | https://github.com/CLIUtils/CLI11 | A header-only command line parser for C++11 and beyond that provides a rich feature set with a simple and intuitive interface. | BSD-3-Clause | CMake}}

{{librow | cmdlime | https://github.com/kamchatka-volcano/cmdlime | A C++17 library for command-line parsing that provides a concise, declarative interface with support for subcommands, validators, and the ability to choose either the GNU, POSIX, or X11 command-line options format. | MS-PL | CMake}}

{{librow | cxxopts | https://github.com/jarro2783/cxxopts | A lightweight header-only C++11 (or C++17) command-line arguments parser, supporting the standard GNU style syntax for options. | MIT | CMake}}

{{librow | gflags | https://gflags.github.io/gflags/ | Library that implements commandline flags processing. It includes built-in support for standard types such as string and the ability to define flags in the source file in which they are used. | BSD | CMake}}

{{librow | morrisfranken/argparse | https://github.com/morrisfranken/argparse | A lightweight header-only library for parsing command line arguments in an elegant manner. | Apache 2 | CMake}}

{{librow | p-ranav/argparse | https://github.com/p-ranav/argparse | Single header argument Parser for C++17 | MIT | CMake}}

{{librow | tclap | https://sourceforge.net/projects/tclap/ | A simple templatized C++ library for parsing command line arguments. The library provides a simple, flexible object-oriented interface. | MIT | CMake}}

{{librow | cpp-hocon | https://github.com/puppetlabs/cpp-hocon/tree/master/lib/src | The C++ implementation of the HOCON format developed by Pupplet.}}

{{librow | ArduinoJson | https://github.com/bblanchon/ArduinoJson | ArduinoJson}}

{{librow | Boost.JSON | https://www.boost.org/doc/libs/release/libs/json/doc/html/index.html | JSON parsing, serialization, and DOM in C++11/17 | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | DAW JSON Link | https://github.com/beached/daw_json_link | C++17 static C++ bindings with type checking allowing of parsing directly to user data structures without library allocation, push/pull modes, allocator support, constexpr | BSL 1.0 | CMake}}

{{librow | jansson | https://www.digip.org/jansson/ | Jansson is C library for encoding, decoding and manipulating JSON data.}}

{{librow | jeayeson | https://github.com/jeaye/jeayeson | A very sane (header only) C++14 JSON library}}

{{librow | jios | https://github.com/castedo/jios | JSON Input Output Streams | MIT | CMake}}

{{librow | json | https://github.com/nlohmann/json | Niels Lohmann JSON}}

{{librow | JSON Voorhees | https://tgockel.github.io/json-voorhees/ | Killer JSON for C++}}

{{librow | json11 | https://github.com/dropbox/json11 | json11 is a tiny JSON library for C++11, providing JSON parsing and serialization.}}

{{librow | JsonBox | https://github.com/anhero/JsonBox}}

{{librow | jsoncons | https://github.com/danielaparker/jsoncons/ | A header-only library for JSON and JSON-like data formats, with JSON Pointer, JSON Patch, JSONPath, CSV, MessagePack, CBOR, BSON, UBJSON.}}

{{librow | jsoncpp | https://github.com/open-source-parsers/jsoncpp | | MIT | CMake, Conan, vcpkg}}

{{librow | jsonme-- | https://github.com/pibara/jsonme--}}

{{librow | minijson | https://giacomodrago.github.io/minijson/ | C++ DOM-less and allocation-free JSON parsing and serialization}}

{{librow | Neyson | https://github.com/Neyn/neyson | Lightweight C++11 JSON Library | BSD-3-Clause | CMake}}

{{librow | nosjob | https://fossil.wanderinghorse.net/r/nosjob | C++98 library for generating and consuming JSON data | MIT | make}}

{{librow | rapidjson | https://github.com/miloyip/rapidjson}}

{{librow | simdjson | https://github.com/simdjson/simdjson | Parsing gigabytes of JSON per second taking advantage of modern micro-architectures and parallelizing with SIMD ([https://arxiv.org/abs/1902.08318 Doc]) ([https://youtu.be/wlvKAT7SZIQ Kino]) | Apache-2.0 | CMake, vcpkg}}

{{librow | struct_mapping | https://github.com/bk192077/struct_mapping | Mapping json to and from a c++ structure}}

{{librow | ThorsSerializer | https://github.com/Loki-Astari/ThorsSerializer | JSON/BSON/YAML Input Output Streams | MIT | Makefile}}

{{librow | ujson | https://bitbucket.org/awangk/ujson | µjson is a small, C++11, UTF-8, JSON library}}

{{librow | yyjson | https://github.com/ibireme/yyjson | A high performance JSON library written in ANSI C | MIT | CMake}}

{{librow | zoolib | https://github.com/zoolib/zoolib_cxx | ZooLib is a C++ toolkit. | MIT}}

{{librow | ai-xml | https://github.com/CarloWood/ai-xml | Serialize objects to <em>and</em> from XML by adding a single, minimal, function to a class. Uses libxml++ under the hood.}}

{{librow | GPDS | https://github.com/simulton/gpds | General purpose data serializer to serialize objects to and from XML. Uses TinyXML under the hood.}}

{{librow | libxml++ | http://libxmlplusplus.sourceforge.net/}}

{{librow | pugixml | https://pugixml.org/ | Light-weight, simple and fast XML parser for C++ with XPath support | MIT | CMake, Conan}}

{{librow | yaml-cpp | https://github.com/jbeder/yaml-cpp}}

{{librow | Boost.Bimap | https://www.boost.org/doc/libs/release/libs/bimap/ | a bidirectional maps library that offers associative containers such as {{tt|bimap<X,Y>}} in which both {{tt|X}} and {{tt|Y}} can be used as a key. ([https://github.com/boostorg/boost Src]) | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.Container | https://www.boost.org/doc/libs/release/libs/container/ | a header-only library that implements several well-known containers, including STL-like containers, as well as recursive containers, and new useful containers: {{tt|flat_map}}, {{tt|flat_set}}, {{tt|flat_multimap}}, {{tt|flat_multiset}}, {{tt|stable_vector}}, {{tt|static_vector}}, {{tt|small_vector}}, {{tt|devector}}. ([https://github.com/boostorg/boost Src]) | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.Fusion | https://www.boost.org/doc/libs/release/libs/fusion/ | a library for working with heterogeneous collections of ''tuples''. Provides a set of containers ({{tt|vector}}, {{tt|list}}, {{tt|set}} and {{tt|map}}), along with transformed presentation of their underlying data, a.k.a ''views''." ([https://github.com/boostorg/boost Src]) | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.Heap | https://www.boost.org/doc/libs/release/libs/heap/ | an implementation of ''priority queues'' with more functionality and different performance characteristics, than STL has. ([https://github.com/boostorg/boost Src]) | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.Pointer Container | https://www.boost.org/doc/libs/release/libs/ptr_container/ | provides containers for holding ''heap-allocated objects'' in an exception-safe manner and with minimal overhead. ([https://github.com/boostorg/boost Src]) | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.Tuple | https://www.boost.org/doc/libs/release/libs/tuple/ | implements pre-C++11 n-{{tt|tuple}} (a fixed size collection of elements) ([https://github.com/boostorg/boost Src]) | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.Variant | https://www.boost.org/doc/libs/release/libs/variant/ | implements pre-C++17 {{tt|variant}} (a safe, generic, stack-based discriminated {{tt|union}} container) ([https://github.com/boostorg/boost Src]) | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | C++ Allocators | https://github.com/hosseinmoein/Cougar | STL conformant allocators for fixed size static and stack based memory + another conformant allocator that allows custom boundary allocation | BSD-3-Clause | CMake, Makefile}}

{{librow | cpp-btree | https://github.com/diegocaro/cpp-btree/ | header-only; B-tree containers make better use of the CPU cache: {{tt|btree_map}}, {{tt|btree_set}}, {{tt|btree_multimap}},

 

{{tt|btree_multiset}}. ([https://code.google.com/archive/p/cpp-btree/source/default/source Src]) | [https://www.apache.org/licenses/LICENSE-2.0 Apache-2.0] | CMake}}

{{librow | DataFrame | https://github.com/hosseinmoein/DataFrame | C++ DataFrame for statistical, Financial, and ML analysis -- in modern C++ using native types and continuous memory storage | BSD-3-Clause | CMake, Makefile, Conan, vcpkg}}

{{librow | eggs::variant | https://github.com/eggs-cpp/variant | Eggs.Variant is a C++11/14/17 generic, type-safe, discriminated union. It is notable in particular for having very good {{lc|constexpr}} support. | [https://github.com/eggs-cpp/variant/blob/master/LICENSE.txt BSL-1.0] | CMake}}

{{librow | Frozen | https://github.com/serge-sans-paille | {{lc|constexpr}} perfect-hashing-based frozen sets and maps | [https://www.apache.org/licenses/LICENSE-2.0 Apache-2.0]}}

{{librow | Immer | https://github.com/arximboldi/immer | A library of persistent and immutable data structures | Boost | CMake}}

{{librow | plf::colony | https://www.plflib.org/colony.htm | Unordered "bag-like" container which outperforms {{tt|std::}} containers in high-modification scenarios while maintaining valid pointers to non-erased elements regardless of insertion and erasure. C++98/11/14/etc-compatible. See also {{stddoc|P0447|P0447, std::hive}}. ([https://github.com/mattreecebentley/plf_colony Src]) | [https://en.wikipedia.org/wiki/Zlib_License zlib ] | [https://github.com/alaingalvan/conan-plf-colony conan] [https://cppget.org/plf-colony build2]}}

{{librow | plf::list | https://www.plflib.org/list.htm | {{lc|std::list}} implementation which sacrifices range-splicing for cache-friendliness, yielding faster insertion, erasure and iteration. C++98/11/14/etc-compatible. ([https://github.com/mattreecebentley/plf_list Src]) | [https://en.wikipedia.org/wiki/Zlib_License zlib ]}}

{{librow | plf::reorderase | https://www.plflib.org/reorderase.htm | An extension and optimization of the "swap-and-pop"/"move-and-pop" idiom for random access containers to increase random_access container erase performance, when post-erasure order is unimportant. Covers single, range and std::erase_if-style erasures. C++98/11/14/etc-compatible. ([https://github.com/mattreecebentley/plf_reorderase Src]) | [https://en.wikipedia.org/wiki/Zlib_License zlib ]}}

{{librow | plf::queue | https://www.plflib.org/queue.htm | Drop-in replacement container for the {{lc|std::queue}} container adaptor with better performance than {{lc|std::deque}} and {{lc|std::list}} in a queue context. C++98/11/14/etc-compatible. ([https://github.com/mattreecebentley/plf_queue Src]) | [https://en.wikipedia.org/wiki/Zlib_License zlib ]}}

{{librow | plf::stack | https://www.plflib.org/stack.htm | Drop-in replacement container for the {{lc|std::stack}} container adaptor with better performance than {{lc|std::vector}} and {{lc|std::deque}} in a stack context. C++98/11/14/etc-compatible. ([https://github.com/mattreecebentley/plf_stack Src]) | [https://en.wikipedia.org/wiki/Zlib_License zlib ]}}

{{librow | ring_span | https://github.com/martinmoene/ring-span-lite | A header-only lite implementation of Arthur O'Dwyer's {{tt|ring_span}}, a.k.a. circular buffer view. C++98- compatible. | [https://github.com/martinmoene/ring-span-lite/blob/master/LICENSE.txt BSL-1.0] | CMake}}

{{librow | strict_variant | https://github.com/cbeck88/strict-variant | A realtime/embedded-friendly (i.e. {{tt|-fno-exceptions}}/{{tt|-fno-rtti}} compatible), never-empty {{tt|variant}} targetting C++11. Fast, prevents many undesirable implicit conversions. | BSL-1.0 | CMake}}

{{librow | Ygg | https://github.com/tinloaf/ygg | An intrusive C++11 implementation of high-performance containers and data structures such as a {{enwiki|Red–black tree}}, an {{enwiki|Interval tree}} and an Interval Map. | MIT | CMake}}

{{librow | Botan | https://botan.randombit.net/ | Cryptography Toolkit. ([https://github.com/randombit/botan Src]) | BSD 2-Clause "Simplified" | Makefile}}

{{librow | crypto++ | https://www.cryptopp.com/ | Free C++ Class Library of Cryptographic Schemes. ([https://github.com/weidai11/cryptopp Src]) | Boost | Makefile}}

{{librow | gnutls | https://www.gnutls.org/ | A secure communications library implementing the SSL, TLS and DTLS protocols and technologies around them. ([https://gitlab.com/gnutls/gnutls Src]) | LGPL-2.1 | Makefile}}

{{librow | openssl | https://www.openssl.org/ | A robust, commercial-grade, full-featured toolkit for general-purpose cryptography and secure communication. ([https://github.com/openssl/openssl Src]) | Apache-2.0 | Makefile}}

{{librow | TomCrypt | https://www.libtom.net/ | A fairly comprehensive, modular and portable cryptographic toolkit that provides developers with a vast array of well known published block ciphers, one-way hash functions, chaining modes, pseudo-random number generators, public key cryptography and a plethora of other routines. ([https://github.com/libtom/libtomcrypt Src]) | public domain | CMake, Makefile}}

{{librow | Boost::MySQL | https://www.boost.org/doc/libs/release/libs/mysql/doc/html/index.html | MySQL client library | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0] | }}

{{librow | cpp-redis | https://github.com/cpp-redis/cpp_redis | C++11 Lightweight Redis client: async, thread-safe, no dependency, pipelining, multi-platform. ([https://github.com/cpp-redis/cpp_redis/wiki/Redis-Client Doc]) | MIT | CMake }}

{{librow | DTL | http://dtemplatelib.sourceforge.net/ | Makes ODBC recordsets look just like an STL container ([https://sourceforge.net/projects/dtemplatelib/files/ Src]) ([https://dtemplatelib.sourceforge.net/table_of_contents.htm Doc]) }}

{{librow | EasyQtSql | https://github.com/kramolnic/EasyQtSql | A lightweight header-only C++11 (Qt based) library for quick and easy SQL querying | MIT | qmake }}

{{librow| Galera | https://galeracluster.com/downloads/ | The Galera Cluster is the synchronous multi-master replication library (Galera) and a Write Set Replication (WSREP) API for MySQL/MariaDB ([https://github.com/codership/galera Src]) | GPLv2 | CMake, Scons}}

{{librow | LevelDB | https://github.com/google/leveldb | A C++ library developed by Google that handles billion-scale Key-Value data persistence storage. ([https://github.com/google/leveldb/blob/main/doc/index.md Doc]) | BSD-3 | CMake }}

{{librow | libpqxx | https://pqxx.org/development/libpqxx/ | The C++ connector for PostgreSQL ([https://github.com/jtv/libpqxx Src]) | BSD-3 | CMake, Make }}

{{librow | lmdb++ | https://github.com/bendiken/lmdbxx | C++11 wrapper for the LMDB embedded B+ tree database library. | [https://github.com/drycpp/lmdbxx/blob/master/UNLICENSE Unlicense] | Make }}

{{librow | mongocxx | https://github.com/mongodb/mongo-cxx-driver/tree/master | Official C++11 driver library for MongoDB ([https://www.mongodb.com/docs/drivers/cxx Doc]). It offers optimized APIs for CRUD operations, indexing, and aggregation. Supporting BSON and featuring connection pooling and authentication mechanisms, it provides high-performance and scalable solutions for building C++ applications that leverage MongoDB.| [https://github.com/mongodb/mongo-cxx-driver/blob/master/LICENSE Apache 2.0] | CMake }}

{{librow | mysql++ | https://dev.mysql.com/ | MySQL DB and tools }}

{{librow | nanodbc | https://github.com/nanodbc/nanodbc | A small, cross-platform, C++14 wrapper for the native C ODBC API | MIT | CMake}}

{{librow | ODB | https://www.codesynthesis.com/products/odb/ | ODB is an open-source, cross-platform, and cross-database object-relational mapping (ORM) system for C++. ODB supports MySQL, SQLite, PostgreSQL, Oracle, and Microsoft SQL Server relational databases as well as C++98/03 and C++11 language standards. | GPL2 and/or NCUEL}}

{{librow | OTL | http://otl.sourceforge.net/ | OTL is a C++ template based database library for Oracle DB, ODBC and DB2-CLI. ([https://otl.sourceforge.net/otl3_down.htm Src]) }}

{{librow | Pgfe | https://github.com/dmitigr/pgfe/ | The PostgreSQL client (FrontEnd) API in modern C++ | Zlib | CMake}}

{{librow | QTL | https://github.com/znone/qtl | A friendly and lightweight C++ database library for MySQL, SQLite and ODBC. | Apache-2.0 | Make }}

{{librow | QUINCE | https://quince-lib.com/ | QUeries IN C++ Expressions (ORM+EDSL) | Boost}}

{{librow | QxOrm | https://www.qxorm.com/ | Object Relational Mapping (ORM) database library for C++/Qt, supports most common databases, serialization (JSON, binary, XML); standalone multi-threaded HTTP web server | GPLv3 or Proprietary}}

{{librow | redis-cpp | https://github.com/tdv/redis-cpp/ | C++17 Lightweight C++ client header-only library for executing Redis commands. | MIT | CMake }}

{{librow | redis-plus-plus | https://github.com/sewenew/redis-plus-plus | A Redis client written in C++ 11, and supports Redis Sentinel, Redis Cluster, pipeline, transaction, pubsub, connection pool and STL-like interface | Apache-2.0 | CMake }}

{{librow | SOCI | http://soci.sourceforge.net/ | A plugin-based database library that embeds SQL queries in a regular C++ code; supported backends include: DB2, Firebird, MySQL, ODBC (generic backend), Oracle, PostgreSQL, SQLite3. ([https://github.com/SOCI/soci Src]) ([https://soci.sourceforge.net/doc/master/ Doc]) | Boost | CMake }}

{{librow | SQLAPI++ | https://www.sqlapi.com/ | A middleware C++ database library that supports multiple SQL database systems: Oracle, SQL Server, DB2, Sybase, MySQL, PostgreSQL, SQLite, Informix, InterBase / Firebird, SQLBase, SQL Anywhere, ODBC, MariaDB. ([https://www.sqlapi.com/Download/ Src]) ([https://www.sqlapi.com/ApiDoc/ Doc]) | [https://www.sqlapi.com/Order/license/ Custom] | Make }}

{{librow | SQLiteCPP | https://github.com/SRombauts/SQLiteCpp | Lean and easy to use C++ SQLite3 wrapper. | MIT | CMake, Meson, vcpkg }}

{{librow | SQLite ORM | https://github.com/fnc12/sqlite_orm | An Embedded Domain-Specific Language (EDSL) for SQL, as understood by SQLite, that comes as a header-only library for modern C++. | AGPL-3.0, MIT | CMake, vcpkg }}

{{librow | sqlpp11 | https://github.com/rbock/sqlpp11 | A type safe embedded domain specific language for SQL queries and results in C++. | BSD-2 | CMake }}

{{librow | taoPQ | https://github.com/taocpp/taopq | Lightweight C++17 PostgreSQL client library | Boost | CMake}}

{{librow | Jinx | https://jamesboer.github.io/Jinx/index.htm | Scripting language designed for videogames. | MIT | CMake}}

{{librow | muparser | https://beltoforion.de/en/muparser/ | Many applications require the parsing of mathematical expressions. The main objective muparser is to provide a fast, easy and secure way of doing this. muparser is an extensible high performance math expression parser library written in C++. | BSD-2-Clause | CMake}}

{{librow | PythonQt | http://pythonqt.sourceforge.net/ | Dynamic Python binding for the Qt framework. It offers an easy way to embed the Python scripting language into C++ Qt applications. | LGPL 2.1}}

{{librow | ScriptCaller | https://github.com/Baduit/ScriptCaller | a header only library allowing us to call ruby scripts.}}

{{librow | lua | https://www.lua.org | Lightweight multi-paradigm scripting language designed primarily for embedded use. C library. | MIT}}

{{librow | sol2 | https://github.com/ThePhD/sol2 | A modern header-only C++ library binding to Lua. | MIT | CMake}}

{{librow | v8pp | https://github.com/pmed/v8pp | Bind C++ functions and classes into V8 JavaScript engine.}}

{{librow | distortos | https://distortos.org/ | object-oriented C++ RTOS for microcontrollers}}

{{librow | ETL | https://www.etlcpp.com | Embedded Template Library - C++03, Portable template library tailored for low resource (embedded) platforms ([https://github.com/ETLCPP/etl.git Src]) | MIT}}

{{librow | DataFrame | https://github.com/hosseinmoein/DataFrame | C++ DataFrame for statistical, Financial, and ML analysis -- in modern C++ using native types and continuous memory storage | BSD-3-Clause | CMake, Makefile, Conan}}

{{librow | QuantLib | https://www.quantlib.org/ | Quantitative finance Library - A free/open-source library for quantitative finance | modified BSD}}

{{librow | Anax | https://github.com/miguelishawt/anax | An open source C++ entity system | MIT | CMake }}

{{librow | Anura | https://github.com/anura-engine/anura | A fully-featured game engine and the tech behind the [https://github.com/frogatto/frogatto/wiki Frogatto & Friends]. | [https://github.com/anura-engine/anura/blob/trunk/LICENSE Custom] Open Source | make, vcpkg }}

{{librow | BOX2D | https://box2d.org/ | Physics engine | MIT | CMake }}

{{librow | EntityPlus | https://github.com/Yelnats321/EntityPlus | A C++17 Entity Component System | BSD-1.0 | CMake }}

{{librow | EntityX | https://github.com/alecthomas/entityx | A fast, type-safe C++ Entity-Component system | MIT | CMake }}

{{librow | EnTT | https://github.com/skypjack/entt | A header-only tiny library for game dev and more written in modern C++ | MIT | CMake, bazel, Conan, vcpkg, brew, cppget }}

{{librow | Kigs-framework | https://github.com/Kigs-framework/kigs | Modular Multi-purpose Cross Platform Framework | MIT}}

{{librow | SDL | https://www.libsdl.org/ | Simple DirectMedia Layer: cross-platform (Windows, macOS, Linux, iOS, Android, and others), low level access to audio, keyboard, mouse, joystick, and graphics hardware via that platform's graphics API (OpenGL/Direct3D/Metal/Vulkan) ([https://wiki.libsdl.org/SDL3/FrontPage Doc]) ([https://github.com/libsdl-org/SDL Src]) | zlib | CMake}}

{{librow | SFML | https://www.sfml-dev.org/index.php | Simple and Fast Multimedia Library; multi-platform (Windows, Linux, macOS and soon Android & iOS); provides a simple interface to ease the development of games and multimedia applications. It is composed of five modules: system, window, graphics (over OpenGL), audio and network. | zlib/png | CMake}}

{{librow | SIGIL | http://www.libsigil.com/ | Sound, Input, and Graphics Integration Library; mind-bogglingly simple, cross-platform, minimalist library for text, shapes, input, audio, and 2D images. Supported platforms: Windows, Linux and Raspberry Pi | [https://gitlab.com/geoff-nagy/sigil/-/blob/master/LICENSES.txt License] | CMake}}

{{librow | Abseil | https://abseil.io/ | An open-source collection of C++ library code from Google designed to augment the C++ standard library. ([https://abseil.io/docs/ Doc]) ([https://github.com/abseil/abseil-cpp Src]) | [https://github.com/abseil/abseil-cpp/blob/master/LICENSE Apache-2.0 ] | CMake}}

{{librow | Au | https://aurora-opensource.github.io/au/main/ | A C++14-compatible physical units library with no dependencies and a single-file delivery option. Emphasis on safety, accessibility, performance, and developer experience. | [https://github.com/aurora-opensource/au/blob/main/LICENSE.txt Apache 2.0] | }}

{{librow | Better Enums | https://github.com/aantron/better-enums | Reflective enums (enum to string, iteration, etc.) with constexpr support. | BSD}}

{{librow | Boost | https://www.boost.org/doc/libs | large collection of generic libraries | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Cinder | https://libcinder.org/ | A community-developed, free and open source library for professional-quality creative coding in C++. ([https://libcinder.org/docs/ Doc]) ([https://github.com/cinder/Cinder Src]) | [https://github.com/cinder/Cinder/blob/master/COPYING Modified BSD] | CMake}}

{{librow | CommonPP | https://github.com/daedric/commonpp | Multi-purpose library with a strong emphasis on getting metrics out of a project. | BSD}}

{{librow | Dlib | https://dlib.net | networking, threads, graphical interfaces, data structures, linear algebra, machine learning, XML and text parsing, numerical optimization, Bayesian nets, and numerous other tasks | Boost}}

{{librow | eventpp | https://github.com/wqking/eventpp | eventpp is a C++ event library for callbacks, event dispatcher, and event queue. With eventpp you can easily implement signal and slot mechanism, publisher and subscriber pattern, or observer pattern. | Apache 2.0}}

{{librow | Folly | https://github.com/facebook/folly | Facebook open-source library. A crossplatform library of C++14 components designed with practicality and efficiency in mind. ([https://github.com/facebook/folly/blob/main/folly/docs Doc]) | [https://github.com/facebook/folly/blob/main/LICENSE Apache-2.0] | CMake, vcpkg}}

{{librow | GSL | https://github.com/Microsoft/GSL | C++ Core '''G'''uidelines '''S'''upport '''L'''ibrary implementation, recommended by Bjarne Stroustrup, Herb Sutter and Co in [https://isocpp.github.io/CppCoreGuidelines C++ Core Guidelines] | [https://github.com/microsoft/GSL/blob/main/LICENSE MIT] | CMake, vcpkg}}

{{librow | gsl-lite | https://github.com/martinmoene/gsl-lite | A single-file header-only version of ISO C++ Guideline Support Library (GSL) for C++98, C++11 and later | MIT}}

{{librow | GUL14 | https://gul14.info/ | General Utility Library for C++14 from [https://www.desy.de/ DESY]: Often-used utility functions and types, including String utilities, Statistics and Numeric functions, Containers, Debugging means, etc. ([https://github.com/gul-cpp/gul14 Src])| LGPL-2.1 | Meson, vcpkg}}

{{librow | Kerbal | https://github.com/WentsingNee/Kerbal | Backports of modern STL facilities to previous standard. More features! More constexpr! | LGPL-3.0 | CMake, header-only}}

{{librow | libsourcey | https://github.com/sourcey/libsourcey | Cross-platform C++14 library for high speed networking and media encoding. HTTP, WebSockets, TURN, STUN, Symple and more. | LGPL-2.1 | CMake}}

{{librow | LLNL/units | https://github.com/LLNL/units | A run-time C++ library for working with units of measurement and conversions between them and with string representations of units and measurements | BSD 3-Clause "New" or "Revised" | CMake}}

{{librow | Loki | http://loki-lib.sourceforge.net/ | design patterns}}

{{librow | nonstd-lite | https://github.com/martinmoene/nonstd-lite | Parent of *-lite repositories, a migration path to post-C++11 features for pre-C++11 environments | Boost}}

{{librow | nytl | https://github.com/nyorain/nytl | Generic C++17 header-only utility template library. | Boost}}

{{librow | Reason | http://www.reasoning.biz/index.htm | ?? xml, xpath, regex, threads, sockets, http, sql, date-time, streams, encoding and decoding, filesystem, compression | GPL}}

{{librow | SaferCPlusPlus | https://github.com/duneroadrunner/SaferCPlusPlus | Safe compatible substitutes for unsafe C++ primitives, including pointers, int and std::vector. | Boost}}

{{librow | Smart Enum | https://github.com/krabicezpapundeklu/smart_enum | "to_string", "from_string" and more for your enums. | Boost}}

{{librow | units | https://github.com/nholthaus/units | A compile-time, header-only, dimensional analysis and unit conversion library built on c++14 with no dependencies | MIT}}

{{librow | yaal | https://github.com/AmokHuginnsson/yaal | '''Y'''et '''A'''nother '''A'''bstraction '''L'''ayer - algorithms, collections, arbitrary precision calculation, generic-DSL grammar driven parsers and more | CC BY-ND-NC 4.0 | CMake}}

{{librow | Yato | https://github.com/agruzdev/Yato | Modern C++(14/17) cross-platform STL-styled and STL-compatible library with implementing containers, ranges, iterators, type traits and other tools; actors system; type-safe config interface. | Apache-2.0 | CMake}}

{{librow | yomm2 | https://github.com/jll63/yomm2 | Open multi-methods for C++17 | Boost}}

{{librow | gpsd | https://gpsd.gitlab.io/gpsd/ | '''gpsd''' is an open-source, cross-platform (Linux/Unix/BSD flavors, including Android and OS X) GPS-aware set of tools, such as a translator and replicator daemon for GPS devices, AIS radios, and other navigational sensors. '''gpsd''' is mostly written in C and Python, but also has C++ wrapper. '''gpsd''' is everywhere in mobile embedded systems. Every location-aware Android app is indirectly a '''gpsd''' client. ([https://gpsd.io/#documentation Doc]) ([https://download.savannah.gnu.org/releases/gpsd/ Src]) | [https://www.openhub.net/licenses/bsd_2clause_ish BSD 2-clause] | scons}}

{{librow | nanogui | https://github.com/wjakob/nanogui | Minimalistic cross-platform widget library for OpenGL 3.x or higher ([https://nanogui.readthedocs.io/en/latest/ Doc])}}

{{librow | tiny file dialogs | http://tinyfiledialogs.sourceforge.net | a single C C++ cross-platform file (no init, no main loop, 6 modal function calls)}}

{{librow | U++ | https://www.ultimatepp.org | Cross-platform (Windows, GNU/Linux, macOS) rapid application development framework with bundled IDE. C++17 Compatible. ([https://www.ultimatepp.org/www$uppweb$documentation$en-us.html Doc]) ([https://github.com/ultimatepp/ultimatepp Src]) | BSD-3-Clause | Makefile}}

{{librow | WxWidgets | https://wxwidgets.org/ | A free and open source cross-platform (Windows, GNU/Linux, macOS) C++ framework for writing advanced GUI applications using native controls. ([https://docs.wxwidgets.org Doc]) | Modified LGPL | CMake, Makefile}}

{{librow | xtd | https://gammasoft71.github.io/xtd/ | Modern C++17/20 framework to create console, GUI and unit tests applications on Windows, macOS, Linux, iOS, and Android. ([https://github.com/gammasoft71/xtd Src]) ([https://gammasoft71.github.io/xtd/reference_guides/latest/index.html Doc]) | MIT | CMake}}

{{librow | CopperSpice | https://www.copperspice.com/ | A set of C++ libraries used to develop cross-platform software applications. It uses modern idiomatic C++ and integrates seamlessly with the STL. CopperSpice was derived from the Qt framework. ([https://www.copperspice.com/documentation-copperspice.html Doc]) ([https://github.com/copperspice/copperspice Src]) | LGPL-2.1 | CMake}}

{{librow | CsSignal | https://github.com/copperspice/cs_signal | Standalone C++ thread aware signal/slot library | LGPL-2.1 | CMake}}

{{librow | CsString | https://github.com/copperspice/cs_string | Standalone C++ unicode aware string library | LGPL-2.1 | CMake}}

{{librow | libGuarded | https://github.com/copperspice/libguarded | Standalone C++ multithreading library for managing access to shared data | LGPL-2.1 | CMake}}

{{librow | QuickQanava | https://github.com/cneben/QuickQanava | C++14 network/graph visualization library / Qt node editor. | BSD 2.0 | CMake}}

{{librow | U++ | https://www.ultimatepp.org/ | U++ is a C++ cross-platform rapid application development framework focused on programmers productivity. It includes a set of libraries (GUI, SQL, etc.), and an integrated development environment. ([https://www.ultimatepp.org/www$uppweb$download$en-us.html Src/Bin]) | BSD}}

{{librow | upp-components | https://github.com/ismail-yilmaz/upp-components | A collection of 3rd party packages for U++ like TerminalCtrl, MessageCtrl etc.. | BSD-3-Clause}}

{{librow | bgfx | https://github.com/bkaradzic/bgfx | Powerful cross-platform 2D/3D graphics rendering shaders aware library, supported platforms include Windows, Mac, Linux, iOS, Android, Web; rendering backends are: DX, opengl, metal, webgl, vulkan etc. ([https://bkaradzic.github.io/bgfx/bgfx.html Doc]) | BSD-2 | Makefile }}

{{librow | dfpsr | https://dawoodoz.com/dfpsr.html | 2D, 3D and isometric software renderer with desktop GUI toolkit, minimalistic dependency, designed for long time maintenance and can run without any 3D accelerated drivers | zlib}}

{{librow | gegl | https://gegl.org/ | '''GEGL''' (Generic Graphics Library) is a data flow based image processing framework, providing floating point processing and non-destructive image processing capabilities. ([https://gitlab.gnome.org/GNOME/gegl/ Src]) | LGPL}}

{{librow | io2d | https://github.com/cpp-io2d/P0267_RefImpl | Reference Implementations of [https://github.com/cpp-io2d/io2dts P0267], the proposed {{stddoc|P0267|2D graphics API for ISO C++}} | Boost | CMake}}

{{librow | nanovg | https://github.com/memononen/nanovg | 2D drawing library based on openGL/DX/metal.}}

{{librow | pangomm | https://gitlab.gnome.org/GNOME/pangomm | is the official C++ interface for the [https://www.pango.org/ Pango] font layout library. ([https://gitlab.gnome.org/GNOME/pango Src]) | [https://gitlab.gnome.org/GNOME/pangomm/-/blob/master/COPYING LGPL v2.1] | Makefile}}

{{librow | Skia | https://skia.org/ | is an open-source 2D-graphics library written in C++. {{enwiki|Skia Graphics Engine}} is used in Google Chrome, Chrome OS, Mozilla Firefox, Android, LibreOffice, Flutter, etc. '''Skia''' has several back-ends: software rasterization, (PDF) output, OpenGL, SVG, etc. | {{enwiki|New BSD License|New BSD}}}}

{{librow | ULIS | https://github.com/Praxinos/ULIS | Cross-Platform C++14 Library, Generic digital image processing, 2D Software rasterizer, Unlimited image formats ({{tt|u8}}, {{tt|u16}}, {{tt|u32}}, {{co|float}}, {{co|double}}), Custom bit-ordered memory layout, All Photoshop pixel blending modes + 11 additional modes, Color models (RGB, HSL, HSV, CMYK, ...), Color-managed pipelines, Color Space support (icm profiles and device-independant), Optimized algorithms with multithreading, Optimized algorithms with SIMD Extensions (SSE2), Image pools and caches for optimisations, Memory storage of animated image sequences | Custom (free-of-charge for non-commercial purposes only) | CMake}}

{{librow | bgfx | https://github.com/bkaradzic/bgfx#bgfx---cross-platform-rendering-library | Cross-platform, graphics API agnostic, "Bring Your Own Engine/Framework" style rendering library.}}

{{librow | Epoxy | https://github.com/anholt/libepoxy | Modern successor to GLEW. Abstracts difference between some kinds of GL contexts, which makes it sometimes simpler to use than GLEW. Used by GTK+ project since 2015.}}

{{librow | GLAD | https://glad.dav1d.de/ | Customizable, lightweight library for loading OpenGL functions}}

{{librow | GLEW | http://glew.sourceforge.net/ | OpenGL function loading}}

{{librow | GLFW | https://www.glfw.org/ | OpenGL window manager}}

{{librow | GLM | https://github.com/g-truc/glm | Header only C++ mathematics library for rendering}}

{{librow | Godot | https://github.com/godotengine/godot | Full featured multi-platform 2D and 3D game engine in C++17 with a GUI editor written on itself and a python-inspired script language. | MIT | SCons}}

{{librow | hlsl++ | https://github.com/redorav/hlslpp | Header only C++ math library for rendering using hlsl syntax. Supports SSE and NEON}}

{{librow | Horde3D | https://www.horde3d.org/ | Horde3D is a small open source 3D rendering engine. It is written in an effort to create a graphics engine that offers the stunning visual effects expected in next-generation games being lightweight and as clean as possible.}}

{{librow | klein | https://github.com/jeremyong/klein | C++11/14/17 SSE-optimized Projective Geometric Algebra library for graphics and animation}}

{{librow | Magnum | https://magnum.graphics | Lightweight and modular C++11/C++14 graphics middleware for games and data visualization}}

{{librow | O3DE | https://github.com/o3de/o3de | '''O'''pen-source '''3D''' '''E'''ngine (former Amazon's Lumberyard) is a C++ multi-platform 3D engine to build AAA games, cinema-quality 3D worlds, and high-fidelity simulations. Includes physics simulation, script engine, networking, and [https://o3de.org/docs/welcome-guide/features-intro/ more]. ([https://o3de.org Doc]) | Apache 2.0 | CMake}}

{{librow | Ogre3D | https://ogrecave.github.io/ogre/api/latest/manual.html | OGRE - Object-Oriented Graphics Rendering Engine - is a multipurpose visualization library, suitable for scientific visualization, games, simulation, virtual reality and other graphic projetcs. It is multiplatform and very robust, with a good documentation. | MIT | CMake}}

{{librow | Vulkan | https://www.khronos.org/vulkan/ | Vulkan is by design a low-level API that removes many of the abstractions found in previous generation graphics APIs. This is great for delivering maximum performance, but has the side effect of exposing more complexity to the developer. Fortunately, several excellent tutorials exist to help clear this hurdle and get productive quickly.}}

{{librow | Adobe/boost GIL | https://boost.org/libs/gil | high-level generic library, focused on algorithms that operate on 2D images. Very limited I/O options. | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | agge | https://github.com/tyoma/agge | Anti-Grain Evolution. 2D graphics engine for Speed and Quality in C++ | MIT | CMake}}

{{librow | FreeImageRe | https://github.com/agruzdev/FreeImageRe | A fork from the Open-Source library FreeImage v3.18 to support image codecs updates and adjust for comfortable usage. All original formats and plugins are maintained. | GPLv2, GPLv3, FIPL | CMake }}

{{librow | SAIL | https://sail.software | Reading and writing static, animated, multi-paged images along with their meta data and ICC profiles. Converting capabilities. Targets simplicity and speed. | MIT | CMake}}

{{librow | stb | https://github.com/nothings/stb | The header-only libraries for C/C++, mostly game-dev oriented. The noteworthy caps: image loader/writer/resizer; font text rasterizer; type-safe containers; ogg vorbis decoder; real-time DXT compressor; Perlin noise generator; lexer for pet DSLs; fast sprintf. | MIT | header-only}}

{{librow | Matplot++ | https://github.com/alandefreitas/matplotplusplus | A '''gnuplot''' based C++ Graphics Library for Data Visualization. '''Matplot++''' can take advantage of the following libs: OpenCV, OpenGL, LAPACK, BLAS, FFTW, JPEG, TIFF, ZLIB, PNG, GLAD, GLFW3. ([https://github.com/alandefreitas/matplotplusplus/blob/master/docs/README.md Doc]) | MIT | CMake}}

{{librow | sciplot | https://github.com/sciplot/sciplot | A modern header-only C++ scientific plotting library powered by [http://www.gnuplot.info/ gnuplot], with the export to pdf, svg, png, eps, etc. | MIT | CMake, vcpkg}}

{{librow | Halide | https://github.com/halide/Halide | A C++-embedded DSL for high-performance processing of images and tensors. | MIT | CMake, vcpkg}}

{{librow | ITK - Insight Toolkit | https://itk.org | ITK is an open-source, cross-platform library that provides developers with an extensive suite of software tools for image analysis.  Developed through extreme programming methodologies, ITK builds on a proven, spatially-oriented architecture for processing, segmentation, and registration of scientific images in two, three, or more dimensions. | Apache 2.0 | CMake}}

{{librow | gettext | https://www.gnu.org/software/gettext/ | GNU internationalization library. | GPL | Makefile}}

{{librow | ICU | https://icu.unicode.org/ | '''I'''nternational '''C'''omponents for '''U'''nicode is a mature, widely used set of C/C++ libraries providing Unicode and Globalization support for software applications. ([https://github.com/unicode-org/icu Src]) | [https://github.com/unicode-org/icu/blob/main/icu4c/LICENSE icu4c/LICENSE] | Makefile}}

{{librow | spirit-po | https://github.com/cbeck88/spirit-po | A small, header-only library which parses po-files and provides an interface similar to GNU libintl. Based on boost::spirit. | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0] | Header only}}

{{librow | uni-algo | https://github.com/uni-algo/uni-algo | Unicode Algorithms Implementation for C/C++ | MIT/Unlicense | CMake, Conan, vcpkg}}

{{librow | Backward | https://github.com/bombela/backward-cpp | Printing nice Python-styled stack traces with colors and source snippets, especially on crashes. Header-only. | MIT | CMake, Conan}}

{{librow | clutchlog | https://github.com/nojhan/clutchlog | Single-header logging system which targets versatile DEBUGGING instead of service event storage. | BSD | CMake}}

{{librow | glog | https://github.com/google/glog | Google Logging Library for C++98 based on C++-style streams | [https://github.com/google/glog/blob/master/COPYING License] | Bazel, CMake, vcpkg}}

{{librow | Log4cplus | https://github.com/log4cplus/log4cplus | Cross-platform, C++17 Logging API (modeled after the Java log4j API) providing thread-safe, flexible, and arbitrarily granular control over log management and configuration. | [https://github.com/log4cplus/log4cplus/blob/master/LICENSE BSD (two clause) or Apache 2.0] | Autotools, CMake, Visual Studio}}

{{librow | log4cxx | https://logging.apache.org/log4cxx/latest_stable/index.html | Apache log4cxx is a logging framework for C++ patterned after Apache log4j. ([https://github.com/apache/logging-log4cxx Src]) | [https://www.apache.org/licenses Apache] | CMake}}

{{librow | lwlog | https://github.com/ChristianPanov/lwlog | Extremely fast synchronous and asynchronous C++17 logging library | MIT | CMake}}

{{librow | Pantheios | http://www.pantheios.org/ | Diagnostic Logging API library, offering a combination of type-safety, efficiency, genericity and extensibility | BSD-style |}}

{{librow | plog | https://github.com/SergiusTheBest/plog | Portable and simple log for C++ in less than 1000 lines of code | [https://github.com/SergiusTheBest/plog/blob/master/LICENSE MPL-2.0]}}

{{librow | Quill | https://github.com/odygrd/quill | Cross-platform, C++14 Asynchronous [https://github.com/odygrd/quill#Performance Low Latency] Logging Library | MIT | CMake}}

{{librow | spdlog | https://github.com/gabime/spdlog | Super fast, header only, C++ logging library | MIT | CMake, Conan}}

{{librow | Boost.LEAF | https://www.boost.org/doc/libs/release/libs/leaf/doc/html/index.html | Lightweight error-handling library for C++11: single-header format, no dependencies, no dynamic memory allocations, can be used with or without exception handling, multi-threading ready. | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | ArrayFire | https://www.arrayfire.com/docs/index.htm | is a cross-platform (Windows/OSX/Linux) general purpose HPC (CPU/GPU/OpenCL/CUDA/GPGPU) library for parallel computing. ArrayFire domains are: Vector Algorithms, Image Processing, Computer Vision, Signal Processing, Linear Algebra, Statistics, and more. ([https://github.com/arrayfire/arrayfire Src]) | [https://github.com/arrayfire/arrayfire/blob/master/LICENSE Custom]}}

{{librow | Boost.Math | https://www.boost.org/doc/libs/release/libs/math/doc/html/math_toolkit/main_intro.html | includes several contributions in the domain of mathematics: Floating Point Utilities, Mathematical Constants, Statistical Distributions and Functions, Statistics, Vector Functionals - Norms, Special Functions, Root Finding & Minimization Algorithms, Polynomials and Rational Functions, Interpolation, Quadrature and Differentiation, Filters, Complex Number Functions, Quaternions, Octonions, Integer Utilities (Greatest Common Divisor and Least Common Multiple), Series, Rationals and Continued Fractions. | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.Random | https://www.boost.org/doc/libs/release/doc/html/boost_random.html | provides a variety of generators and distributions to produce random numbers having useful properties, such as uniform distribution. | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.SafeNumerics | https://www.boost.org/doc/libs/release/libs/safe_numerics/doc/html/index.html | C++14, header only, Guaranteed Correct Integer Arithmetic, a drop-in replacement for the built-in integer types. | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | cpp-measures | https://github.com/carlomilanesi/cpp-measures/ | A header-only C++11 library to handle physical measures}}

{{librow | G+Smo | https://github.com/gismo/gismo/wiki | cross-platform library for isogeometric analysis}}

{{librow | GNU MP bignum C++ interface | https://gmplib.org/manual/C_002b_002b-Class-Interface.html#C_002b_002b-Class-Interface | C++ convenience class interface that offers overloaded functions and operators. The [https://gmplib.org/ GMP] is a free C library for arbitrary precision arithmetic, operating on signed integers, rational and floating-point numbers. | GNU LGPL v3 and GNU GPL v2}}

{{librow | libmpdec++ | https://www.bytereef.org/mpdecimal/index.html | Cross-platform library for correctly-rounded arbitrary precision decimal floating point arithmetic. | BSD-2-Clause | Autoconf, Visual Studio build scripts}}

{{librow | StatsLib | https://github.com/kthohr/stats | A templated, header-only library of statistical distribution functions.}}

{{librow | yasmine | https://yasmine.seadex.de/yasmine.html | C++11 UML state machine framework ([https://yasmine.seadex.de/libyasmine_%28documentation%29.html Doc]) ([https://yasmine.seadex.de/Downloads.html Src]) | [https://yasmine.seadex.de/License.html License]}}

{{librow | BigNumber | https://github.com/limeoats/BigNumber | C++ class for creating and computing arbitrary-length integers | Apache 2.0 | CMake}}

{{librow | CNL | https://johnmcfarlane.github.io/cnl/ | Compositional Numeric Library - fixed-precision numeric types | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0] | CMake, Conan}}

{{librow | fpm | https://github.com/MikeLankamp/fpm | A C++11 header-only '''f'''ixed-'''p'''oint '''m'''ath library that provides standard library's floating-point functionality on integers. Useful if your target platform lacks an FPU, or deterministic calculations required. | MIT | CMake}}

{{librow | Universal Numbers| https://github.com/stillwater-sc/universal | A C++17/20 template library providing plug-in replacements for the native arithmetic types (integer/decimal/fixed-point/floating-point/posits/logarithmic/interval) | MIT | CMake, Vcpkg, Conan}}

{{librow | CGAL | https://www.cgal.org/ | Computational geometry algorithms library | GPL-3.0 or commercial | CMake}}

{{librow | CXXGraph | https://github.com/ZigRazor/CXXGraph | A C++17 Header-Only Library for Graph Representation, Manipulation, Partitioning and Algorithms | [https://github.com/ZigRazor/CXXGraph/blob/master/LICENSE AGPL-3.0] | CMake}}

{{librow | GTpo | https://github.com/cneben/QuickQanava/tree/master/GTpo | A C++14 directed graphs modelling library, part of [https://github.com/cneben/QuickQanava QuickQanava project] | BSD | QMake, CMake}}

{{librow | OGDF | https://ogdf.uos.de/ | Open Graph algorithms and Data structures Framework - is a C++ library for graph algorithms, in particular for automatic graph drawing. | GPL v2 or v3}}

{{librow | Armadillo | http://arma.sourceforge.net/ | A C++ template library for linear algebra and scientific computing featuring wrappers for OpenBLAS, Intel MKL, LAPACK, ATLAS, ARPACK, SuperLU and FFTW. Useful for ML, pattern recognition, DSP, bioinformatics, statistics, finance, etc. | Apache 2.0 | }}

{{librow | Blasw | https://github.com/Mathific/Blasw | C++11 Header-Only BLAS and Parts of LAPACK Wrapper | BSD-3-Clause | CMake}}

{{librow | Blitz++ | https://github.com/blitzpp/blitz | A C++ template class library that provides high-performance dense arrays and vectors, random number generators, and small vectors. | GPL-3.0, LGPL-3.0, Custom | CMake }}

{{librow | C++ Matrix | https://github.com/hosseinmoein/Tiger | High performance and accurate (e.g. edge cases) matrix math library with expression template arithmetic operators | BSD-3-Clause | CMake, Makefile}}

{{librow | DecompLib | https://github.com/jmatta1/DecompLib | A header-only C++11 library to decompose a vector into a set of positive definite weighted basis vectors.}}

{{librow | Eigen | https://eigen.tuxfamily.org | A C++ template library for linear algebra: matrices, vectors, numerical solvers, and related algorithms. | MPL2 | CMake, Conan}}

{{librow | Matrix | https://github.com/mlcpp/Matrix | Easy-to-use Scientific Computing library in/for C++ available for Linux and Windows. | MIT | CMake}}

{{librow | NumCpp | https://github.com/dpilger26/NumCpp | NumCpp: A templatized header only C++ implementation of the Python NumPy library | MIT | CMake, vcpkg, Conan}}

{{librow | Spectra | https://spectralib.org/ | '''Sp'''arse '''E'''igenvalue '''C'''omputation '''T'''oolkit as a '''R'''edesigned '''A'''RPACK is an open-source header-only C++ library for large scale eigenvalue problems, built on top of [https://eigen.tuxfamily.org Eigen] linear algebra library (also open-source and header-only). ([https://github.com/yixuan/spectra/ Src]) | [https://github.com/yixuan/spectra/blob/master/LICENSE MPL-2.0] | CMake, vcpkg}}

{{librow | Tense | https://github.com/Mathific/Tense | Fast C++17 Header-Only Expression Template Matrix and Tensor Library | BSD-3-Clause | CMake}}

{{librow | Dlib | http://dlib.net/ml.html | machine learning tools}}

{{librow | FANN | https://leenissen.dk/fann/wp/ | Fast Artificial Neural Network Library}}

{{librow | gaenari | https://github.com/greenfish77/gaenari | C++17 based incremental decision tree | Apache-2.0 | CMake}}

{{librow | libtorch | https://pytorch.org/ | C++ frontend to the popular PyTorch Python library (backend is written in C++) | BSD-style | CMake}}

{{librow | MLPACK | http://mlpack.org | machine learning package}}

{{librow | Shogun | https://shogun-toolbox.org | large scale machine learning toolbox}}

{{librow | tensorflow | https://github.com/tensorflow/tensorflow | An Open Source Machine Learning Framework for Everyone; provides stable [https://www.tensorflow.org/api_docs/cc C++ API] and written mainly in C++ | Apache-2.0}}

{{librow | LibBF | https://bellard.org/libbf | An arbitrary precision numerical calculation library developed by Bellard with a sample program that calculates pi to billions of bits}}

{{librow | ceres-solver | https://github.com/ceres-solver/ceres-solver | Open-source C++ library for modeling and solving large, complicated optimization problems. It is a feature rich, mature and performant library which has been used in production at Google since 2010. | Apache | CMake, Conan}}

{{librow | CasADi | https://web.casadi.org/ | Symbolic framework for nonlinear optimization and algorithmic differentiation. Supports C++ code generation for symbolic expressions and dynamic connection of compiled generated code. | LGPLv3.0 | CMake}}

{{librow | ExprTk | https://www.partow.net/programming/exprtk/index.html | The C++ Mathematical Expression Toolkit Library (ExprTk) is a simple to use, header-only, 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. | [https://opensource.org/licenses/MIT MIT]}}

{{librow | GiNaC | https://www.ginac.de/ | The library 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. | [https://www.gnu.org/licenses/gpl-3.0.html GPLv3]}}

{{librow | mathiu.cpp | https://github.com/BowenFu/mathiu.cpp | A simple computer algebra system in C++17 | Apache-2.0 | CMake}}

{{librow | SEMT | https://github.com/st-gille/semt | Compile time symbolic differentiation | [https://github.com/st-gille/semt/blob/master/LICENSE License] | Makefile}}

{{librow | SymbolicC++ | https://issc.uj.ac.za/symbolic/symbolic.html | SymbolicC++ is a general purpose computer algebra system | [https://www.gnu.org/licenses/gpl-2.0.html GPLv2] | Autoconf}}

{{librow | SymCC | https://www.s3.eurecom.fr/tools/symbolic_execution/symcc.html | SymCC is a compiler wrapper which embeds symbolic execution into the program during compilation, and an associated run-time support library. In essence, the compiler inserts code that computes symbolic expressions for each value in the program. The actual computation happens through calls to the support library at run time. | [https://github.com/eurecom-s3/symcc/blob/master/LICENSE GPLv3] | CMake}}

{{librow | SymEngine | https://symengine.org | SymEngine is a standalone fast C++ symbolic manipulation library. | [https://github.com/symengine/symengine/blob/master/LICENSE MIT] | CMake}}

{{librow | ViennaMath | https://viennamath.sourceforge.net | ViennaMath is a symbolic math library that enables a convenient instantiation, manipulation, and evaluation of mathematical expressions at run time and compile time. | [https://github.com/viennamath/viennamath-dev/blob/master/LICENSE MIT] | CMake}}

{{librow | Boost.CallableTraits | https://www.boost.org/doc/libs/release/libs/callable_traits/doc/html/index.html | | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.Hana | https://www.boost.org/doc/libs/release/libs/hana/doc/html/index.html | New metaprogramming library for both types and values | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.Metaparse | https://www.boost.org/doc/libs/release/doc/html/metaparse.html | Compile-time parser library, producing types, values, and metafunctions from compile-time strings | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.Mp11 | https://www.boost.org/doc/libs/release/libs/mp11/doc/html/mp11.html | | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.MPL | https://www.boost.org/doc/libs/release/libs/mpl/doc/index.html | Original metaprogramming library, targeted at C++03, slow | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | Boost.PFR | https://www.boost.org/doc/libs/release/doc/html/boost_pfr.html | A header only C++14 library for basic reflection (without macros): visiting members of a user defined type by index, IO streaming. | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0]}}

{{librow | CoMeta | https://github.com/kfrlib/cometa | Lightweight, header-only C++14 metaprogramming library}}

{{librow | Refureku | https://github.com/jsoysouvanh/Refureku | C++17 runtime reflection and code generation library | MIT | CMake}}

{{librow | HARU | https://libharu.org/}}

{{librow | JagPDF | http://www.jagpdf.org/}}

{{librow | PoDoFo | http://podofo.sourceforge.net/}}

{{librow | Bullet | https://pybullet.org/wordpress | Physics simulation for games, visual effects, robotics and reinforcement learning}}

{{librow | HELICS | https://github.com/GMLC-TDC/HELICS | Co-simulation framework for synchronizing time and exchanging data between different types of simulators | BSD 3-Clause "New" or "Revised" | CMake}}

{{librow | ProjectCHRONO | https://projectchrono.org | An Open Source Multi-physics Simulation Engine}}

{{librow | ReactPhysics3D | https://www.reactphysics3d.com | C++ physics engine library for 3D simulations and game}}

{{librow | GTSAM | https://gtsam.org | Sensor Fusion, SLAM, SFM, VO, Computer vision ([https://github.com/borglab/gtsam Src]) | BSD | CMake}}

{{librow | opencv | https://opencv.org/ | Computer vision and perception, Calibration, Feature Matching ([https://github.com/opencv/opencv Src]) ([https://docs.opencv.org/ Doc]) | BSD, Apache 2 | CMake}}

{{librow | cereal | https://uscilab.github.io/cereal/ | C++11 serialization | BSD}}

{{librow | cista | https://cista.rocks | A simple, high-performance, zero-copy C++ serialization & reflection library. ([https://github.com/felixguendling/cista Src]) | MIT | CMake}}

{{librow | cppcodec | https://github.com/tplgy/cppcodec | Header-only C++11 library to encode/decode base64, base32 and hex with consistent, flexible API | MIT}}

{{librow | GPDS | https://github.com/simulton/gpds | General purpose data serializer to serialize objects to and from XML. Uses TinyXML under the hood.}}

{{librow | gSOAP | http://gsoap2.sourceforge.net | accurate XML serialization}}

{{librow | iguana | https://github.com/qicosmos/iguana | A modern, universal and easy-to-use serialization engine developed in C++17, based on compile-time Reflection. Supported formats: JSON, XML, user-defined. | Apache-2.0 | CMake}}

{{librow | jios | https://github.com/castedo/jios | JSON serialization | MIT | CMake}}

{{librow | libs11n | https://www.s11n.net}}

{{librow | protobuf | https://github.com/google/protobuf/}}

{{librow | rpnx-serial | https://github.com/Exaeta/rpnx-serial | A library that can (de)serialize types like std::map, std::vector, etc.}}

{{librow | Serio | https://github.com/ShahriarSS/serio | Fast Lightweight Header-only C++ Serialization Library | BSD-3-Clause | CMake}}

{{librow | ThorsSerializer | https://github.com/Loki-Astari/ThorsSerializer | C++ Serialization library for JSON | MIT | Makefile}}

{{librow | YAS | https://github.com/niXman/yas | '''Y'''et '''A'''nother '''S'''erialization. YAS is C++11 library; no third-party libraries dependencies. Archives can be binary, text, JSON | Boost | Header only}}

{{librow | blobify | https://github.com/neobrain/blobify | C++17 header-only, infers the serialized layout from the structure definition alone. | Boost | CMake}}

{{librow | bson-cxx | https://github.com/dwight/bson-cxx | C++ implementation in BSON format.}}

{{librow | fast_ber | https://github.com/Samuel-Tyler/fast_ber | High-performance serialization using BER/DER encoding rules. Encoding layout is defined by ASN.1 schemas. Follows modern C++ practices, written in C++11.}}

{{librow | UBjsonCpp | https://github.com/WhiZTiM/UbjsonCpp | High-performance UBJson read-write library based on C++14}}

{{librow | Indiesort | https://plflib.org/indiesort.htm | Templated sort-wrapper function which allows use of std::sort (and other random-access sort methods) with non-random-access containers. It also increases the performance of sorting large types in random-access containers and arrays | zlib}}

{{librow | Timsort | https://github.com/gfx/cpp-TimSort | Templated stable sorting function which outperforms quicksort-based algorithms including std::sort, for reversed or semi-sorted data. | MIT}}

{{librow | Infoware | https://github.com/ThePhD/infoware | C++ Library for pulling system and hardware information, without hitting the command line. | Creative Commons v1.0 | CMake}}

{{librow | cli | https://github.com/daniele77/cli | A cross-platform header-only library for interactive command line interfaces in modern C++. | [https://github.com/daniele77/cli/blob/master/LICENSE BSL-1.0] | make, cmake, nmake, vcpkg}}

{{librow | cwidget | https://salsa.debian.org/cwidget-team | high-level terminal interface library for C++, modeled on GTK+ and Qt, but using `curses` as its display layer | GPL v2.0 | make}}

{{librow | bandit | https://banditcpp.github.io/bandit/ | Human-friendly unit testing for C++11. ([https://github.com/banditcpp/bandit Src]) | MIT | CMake}}

{{librow | Boost.Test | https://www.boost.org/libs/test/ | A C++03/11/14/17 unit testing library, available on a wide range of platforms and compilers. ([https://github.com/boostorg/test Src]) | [https://www.boost.org/LICENSE_1_0.txt BSL-1.0] | CMake, b2}}

{{librow | Catch2 | https://github.com/catchorg/Catch2 | A modern, C++-native, test framework for unit-tests, TDD and BDD - using C++14, C++17 and later | Boost | CMake}}

{{librow | cppunit | http://sourceforge.net/projects/cppunit/ | C++ port of the famous JUnit framework for unit testing | LGPL-2.1 | Makefile}}

{{librow | CUTE | https://github.com/PeterSommerlad/CUTE | C++ Unit Testing Easier (no reliance on static initialization for registration), integrated into [https://cevelop.com Cevelop] for TDD | MIT | Header only}}

{{librow | doctest | https://github.com/onqtam/doctest | The lightest feature-rich C++ single-header testing framework for unit tests and TDD | MIT | CMake}}

{{librow | ELFspy | https://github.com/mollismerx/elfspy | Testing in isolation with fakes and spies - Linux only | GPL-2.0 | Makefile}}

{{librow | faker-cxx | https://github.com/cieslarmichal/faker-cxx | Modern C++20 Faker library for generating testing data. | MIT | CMake}}

{{librow | Google Test | https://google.github.io/googletest | Google Testing and Mocking Framework. ([https://github.com/google/googletest Src]) | BSD 3-Clause "New" or "Revised" | Bazel, CMake}}

{{librow | lest | https://github.com/martinmoene/lest | A modern, C++11-native, single-file header-only, tiny framework for unit-tests, TDD and BDD (includes C++98 variant). | Boost | CMake}}

{{librow | liblittletest | https://github.com/etr/liblittletest | Portable, one file header-only testing framework | LGPL-2.1 | Header only}}

{{librow | snitch | https://github.com/cschreib/snitch | Lightweight C++20 testing framework. | Boost | CMake}}

{{librow | tunit | https://github.com/gammasoft71/tunit | Modern c++17 unit testing library on Windows, macOS, Linux, iOS, and Android. [https://gammasoft71.wixsite.com/tunit Office site] | MIT | CMake}}

{{librow | strsuite | https://github.com/Loara/StringSuite | A C++20 library to manage strings with different encodings | LGPL3.0 | CMake}}

{{librow | uchardet | https://github.com/BYVoid/uchardet | The ability to guess string encoding is basically the same as the uchardet function in Python. | MOZILLA PUBLIC LICENSE v1.1 | CMake}}

{{librow | win-iconv | https://github.com/win-iconv/win-iconv | The character set encoding conversion library for Linux and Mac. The Windows implementation of iconv is based on the Win32 Character Set Conversion API. | public domain | CMake}}

{{librow | coformat | https://gitlab.com/44100Hz/coformat | A companion C++ library for {{lc|std::format}} to enable text colorization and styling. | public domain | header only}}

{{librow | fmt | https://github.com/fmtlib/fmt | Open-source formatting library providing a fast and safe alternative to C stdio and C++ iostreams. Prototype for C++20 {{lc|std::format}} family. | [https://github.com/fmtlib/fmt/blob/master/LICENSE.rst License] | CMake, Conan}}

{{librow | BNFlite | https://github.com/r35382/bnflite | A single file lightweight grammar parser library | MIT | Header only}}

{{librow | PEGTL | https://github.com/taocpp/PEGTL | Parsing Expression Grammar Template Library | Boost | Header only}}

{{librow | clucene | http://clucene.sourceforge.net | CLucene is a cross platform, full-featured, open-source indexing and searching engine/API. ([https://sourceforge.net/p/clucene/code/ci/master/tree/ Src]) ([http://clucene.sourceforge.net/doc/html/ Doc]) | LGPL v2.1 | CMake}}

{{librow | Step20 | https://github.com/storm-ptr/step20 | Ukkonen's online algorithm for constructing {{enwiki|Suffix tree}}, Manber's algorithm for constructing {{enwiki|Suffix array}}. | MIT | Header only}}

{{librow | xapian | https://xapian.org/ | Open-source search engine with indexing facilities ([https://xapian.org/download Src]) ([https://xapian.org/docs/ Doc]) | GPL v2+| make}}

{{librow | inja | https://github.com/pantor/inja | Header-only Template Engine for C++17. | MIT | CMake, Conan, vcpkg, etc.}}

{{librow | Jinja2C++ | https://github.com/jinja2cpp/Jinja2Cpp | C++14/17 implementation of Jinja2 templates | MPL-2.0 | CMake, Conan}}

{{librow | coo-semver | https://github.com/easz/cpp-semver | The C++ operation library for semantic version numbers.}}

{{librow | LibGit2 | https://libgit2.org/ | Version Control System Git's core library.}}

{{librow | OpenH264 | https://www.openh264.org/ | Multi-platform, multi-architecture, open source library which supports H.264 encoding and decoding ([https://github.com/cisco/openh264 Src]) | [https://github.com/cisco/openh264/blob/master/LICENSE BSD-2 Clause] | Meson}}

{{librow | ffead-cpp | https://github.com/sumeetchhetri/ffead-cpp | Framework for Enterprise Application Development in c++, HTTP1/HTTP2/HTTP3 compliant, Supports multiple server backends | Apache 2.0 | CMake}}

{{librow | libhttpserver | https://github.com/etr/libhttpserver | libhttpserver is a C++ library for building high performance RESTful web servers. libhttpserver is built upon libmicrohttpd to provide a simple API for developers to create HTTP services in C++. | LGPL-v2.1 | autotools}}

{{librow | Molybden | https://teamdev.com/molybden | An SDK for building cross-platform C++ desktop apps with HTML/CSS/JS GUI. ([https://docs.molybden.io/ Doc]) ([https://api.molybden.io/preview/files.html Src]) | [https://docs.molybden.io/faq/ License] | [https://docs.molybden.io/quick-start/ npm] }}

{{librow | oatpp | https://oatpp.io/ | Light and powerful web-framework for IoT and high-performance web-services. Zero-dependency and easy-portable.}}

{{librow | uri-template | https://github.com/TinkoffCreditSystems/uri-template | URI Templates expansion and reverse-matching for C++ | Apache 2.0 | CMake}}

{{librow | userver | https://github.com/userver-framework/userver | The C++ Asynchronous Framework | Apache 2.0 | CMake}}

{{librow | Wt | https://www.webtoolkit.eu/wt/ | Widgets and building blocks to build web apps, built-in security, PDF rendering, 2D and 3D painting, ORM, charting, authentication frameworks. ([https://www.webtoolkit.eu/wt/doc/reference/html/index.html Doc]) ([https://www.webtoolkit.eu/wt/download Src]) | GNU GPL or Commercial}}