[[Concept:Library]]

APEL stands for "A Portable Emacs Library" and contains these modules:

apel

alist: utility for Association-list
calist: utility for condition tree and condition/situation-alist
filename: utility to make file-name
install: utility to install emacs-lisp package
mule-caeser: ROT 13-47-48 Caesar rotation utility
path-util: utility for path management or file detection

emu

broken: provide information of broken facilities of Emacs.
invisible: provide features about invisible region
mcharset: provide MIME charset related features
pces: provide portable character encoding scheme features
pccl: utility to write portable CCL program
pcustom: provide portable custom environment
poe: emulation module for basic functions and special forms/macros
poem: provide basic functions to write portable MULE programs
static: utility for static evaluation

Note

This package is a variant of APEL. The most remarkable feature is that it uses lexical binding and supports only Emacs 24.5 and later. See Wikidata for details of original APEL.

Apophenia: 'Apophenia' is a statistical library for C. It provides functions on the same level as those of the typical stats package (OLS, probit, singular value decomposition, &c.) but doesn't tie the user to an ad hoc language or environment. It uses the GNU Scientific Library for number crunching and SQLite for data management, so the library itself focuses on model estimation and quickly processing data.

App: 'App' is a C++ preprocessor for that accepts as input arbitrary C++ code that may contain embedded constructs for specifying algebraic data types and associated pattern matching operations, and produces as output the same code with all such constructs translated to normal C++. 'app' provides for C++ the same capabilities that functional languages have regarding algebraic types. 'Applib' is the associated runtime library that supports the core run time requirements of the translated code, and which provides additional utilities.

AppTools

The AppTools project includes a set of packages that Enthought has found useful in creating a number of applications. They implement functionality that is commonly needed by many applications

enthought.appscripting: Framework for scripting applications.
enthought.help: Provides a plugin for displaying documents and examples and running demos in Envisage Workbench applications.
enthought.io: Provides an abstraction for files and folders in a file system.
enthought.naming: Manages naming contexts, supporting non-string data types and scoped preferences.
enthought.permissions: Supports limiting access to parts of an application unless the user is appropriately authorised (not full-blown security).
enthought.persistence: Supports pickling the state of a Python object to a dictionary, which can then be flexibly applied in restoring the state of the object.
enthought.preferences: Manages application preferences.
enthought.resource: Manages application resources such as images and sounds.
enthought.scripting: A framework for automatic recording of Python scripts.
enthought.sweet_pickle: Handles class-level versioning, to support loading of saved data that exist over several generations of internal class structures.
enthought.template: Supports creating templatizable object hierarchies.
enthought.type_manager: Manages type extensions, including factories to generate adapters, and hooks for methods and functions.
enthought.undo: Supports undoing and scripting application commands.

Argtable: Argtable is a freely available C/C++ programmer's library for parsing the command line arguments. Having only a few functions and a simple set of rules, it is capable of handling most aspects of command line parsing and error reporting with a minimum of fuss.

Armadillo: C++ library: Armadillo is a C++ linear algebra library (matrix and vector maths) aiming towards a good balance between efficiency and ease of use while staying lean. This library is useful if C++ has been decided as the language of choice (due to speed and/or integration capabilities), rather than another language like Matlab ÃÂ® or GNU Octave. Armadillo uses a delayed evaluation approach in order to combine several operations into one and reduce (or eliminate) the need for temporaries. This is accomplished through extensive use of recursive templates and template meta-programming.

Aspell: GNU Aspell is a spell checker that can be used either as a library or as an independent spell checker. It does a much better job of coming up with possible suggestions than other English language spell checkers. Other technical enhancements over Ispell include shared memory for dictionaries and intelligent handling of personal dictionaries when more than one Aspell process is open.

Astronomical Papers Library: A C library containing theories of motion of solar system objects that have been published in various astronomical journals such as Astronomy & Astrophysics, the Astronomical Journal, and Astronimcal Papers prepared for the use of the American Ephemeris. Currently this includes such theories as Newcomb's "Tables of the Sun" and all the planets as well as the theory known as "The Improved Lunar Ephemeris".

Async-timeout: Used in cases where part of the software being developed is time-sensitive, so that the code block doesn't wait too much time for certain event to complete.

At-spi: AT-SPI is a D-Bus based accessibility framework. It defines a D-Bus protocol for providing and accessing application accessibility information. The project includes a library for bridging the D-Bus protocol to the ATK API, allowing Gtk based applications to be made accessible. It also contains a client (AT) side library in C and a wrapper for Python.

Atomthreads: Atomthreads is a free, lightweight, portable, real-time scheduler for embedded systems. It is targeted at systems that need only a scheduler and the usual RTOS primitives. No file system, IP stack or device drivers are included, but developers can bolt on their own as required. Atomthreads will always be a small number of C files which are easy to port to any platforms that require threading by adding a simple architecture-specific file.

Aubio: aubio is a library for audio labeling. Its features include segmenting a sound file before each of its attacks, performing pitch detection, tapping the beat and producing midi streams from live audio. The name aubio comes from 'audio' with a typo: several transcription errors are likely to be found in the results too. The aim of this project is to provide these automatic labeling features to other audio softwares. Functions can be used off-line in sound editors and software samplers, or online in audio effects and virtual instruments.

Autogen

'AutoGen' generates program files that contain repetitive text with varied substitutions. It simplifies the maintenance of programs with large amounts of repetitive text, which is useful if several blocks of such text must be synchronized. It includes:

AutoOpts - automates the handling of command line, environment and config file options, including usage text, man pages, and the invoking section of an info doc
getdefs - extracts AutoGen definitions from stylized comments embedded in source code
columns - tabularizes lists for improved output appearance
AutoXDR - NFSv4 specifies that its remote procedure calls be batched. AutoGen generates the code for marshalling and unmarshalling the arguments on both sides of the RPC request
AutoFSM - produces a transition table and prototype finite state machine where it is possible to determine a state transition type (token code) without reference to the current state
xml2ag - lets AutoGen use any XML file as if it were a set of AutoGen definitions

Autotrace: Autotrace is a program which converts bitmap images to vector images. It can import images in BMP, TGA, PNM, PPM, PGM, PBM and those supported by ImageMagick, and can output Postscript, svg, xfig, swf, pstoedit, emf, dxf, cgm, mif, p2e and sk

Avaneya: Whether you are a fan of science fiction, a space–science enthusiast, hobbyist, photographer, gamer or a patron of grass–roots libre arts and technology, you are sure to find the first successful images from the surface of Mars highly captivating. These mind blowing images were taken by NASA's Viking landers during the highly ambitious, billion–dollar mission first launched in 1975. However, many images were nearly lost to history due to magnetic tape deterioration and archaic proprietary technology. With NASA's blessing, our team developed the technology to recover many of these images. This research tool was part of the design phase of our parent project, Avaneya — our upcoming libre cerebral science fiction game for the GNU operating system set on Mars, described in the words of Richard Stallman as an exciting, pioneering project. Originally an internal research tool, overwhelming public interest compelled us to release the technology on this DVD for all. Now everyone can relive the original breathtaking experience that captured the world's attention and marked the first successful moment in history that humanity saw Mars — not as a distant, impersonal, celestial body, beheld through a telescope for centuries, but as a tangible and alien world well within its reach.

Avl: libavl is a collection of computer subroutines for constructing and manipulating binary trees and balanced trees. It includes unthreaded, right threaded, and fully threaded variants of AVL tree, as well as unthreaded red-black trees. It features self-test routines as well as insertion, deletion, tree count, tree copy, tree walking and traversal, search, and threading and unthreading routines. Each function has a comment describing its interface, and each step in the algoritms the program uses has a comment also. Each source code file includes a built-in test routine.

B-Forms: 'B-Forms' is an object-oriented PHP library for developing Webform-based applications. It supports tabular forms with multiple records of the same type being edited simultaneously, and provides security mechanism against data tampering. The library provides two base layouts that cover the the vast majority of cases. Only in very tricky form layouts would you have to write HTML code to specify the form layout. It also automatically saves and restores hidden fields. 'B-Forms' divides a script into three logical areas: form definition, data management, and form presentation. Forms have a powerful block architecture, each block typically representing a different data object within the form. Each block can be used to edit several objects at once- the library handles record management.

BLAS: The BLAS (Basic Linear Algebra Subprograms) are routines that provide standard building blocks for performing basic vector and matrix operations. The Level 1 BLAS perform scalar, vector and vector-vector operations, the Level 2 BLAS perform matrix-vector operations, and the Level 3 BLAS perform matrix-matrix operations. Because the BLAS are efficient, portable, and widely available, they are commonly used in the development of high quality linear algebra software, LAPACK for example.

BRL-CAD: BRL-CAD includes an interactive geometry editor, parallel ray-tracing support for rendering and geometric analysis, path-tracing for realistic image synthesis, network distributed framebuffer support, image-processing and signal-processing tools.

Babel

A collection of tools for internationalizing Python applications Babel is composed of two major parts:

tools to build and work with gettext message catalogs
a Python interface to the CLDR (Common Locale Data Repository), providing access to various locale display names, localized number and date formatting, etc.

Backbone.js: Backbone.js gives structure to web applications by providing models with key-value binding and custom events, collections with a rich API of enumerable functions, views with declarative event handling, and connects it all to your existing API over a RESTful JSON interface.

Badger: Badger is a library used to generate badge sheets for events, given a PDF template and data for the badges.

Barcode

GNU barcode is a tool to convert text strings to printed bars. It supports a variety of standard code to represent the strings and creates postscript output. Features include:

available as both a library and a command line frontend (so you can include barcode printing in your application)
supports UPC, EAN, ISBN, CODE39, and other encoding standards
Postscript and encapsulated postscript output (other backends can be added as needed)
Accepts sizes and positions as inches, millimeters, and centimeters
Can create tables of barcodes (to print labels on sticker pages)

Bcfg2: Bcfg2 allows you to describe and deploy complex configurations across pools of GNU/Linux and Unix systems, leading to a consistent, reproducible, and verifiable description of your environment. Bcfg2's visualization and reporting tools aid in your day-to-day administrative tasks. Its unique analysis features help you cope with the ever-increasing complexity of your networks.

Beanstalkc: beanstalkc is a simple beanstalkd client library for Python. beanstalkd is a fast, distributed, in-memory workqueue service.

BeeCrypt: BeeCrypt is a cryptography library that contains highly optimized C and assembler implementations of many well-known algorithms including Blowfish, MD5, SHA-1, Diffie-Hellman, and ElGamal. Unlike some other crypto libraries, BeeCrypt is not designed to solve one specific problem, like file encryption, but to be a general purpose toolkit which can be used in a variety of applications. There are also no patent or royalty issues associated with BeeCrypt.

Bennu: Bennu is a software library written in PHP that implements the functionality of the IETF iCalendar 2.0 specification (RFC 2445). Its purpose is to enable applications which have an interest in this format (e.g. calendaring, scheduler and organizer programs) to support iCalendar in an easy, powerful, and extensible way.

BigMath: Based partly on Knuth's Seminumerical Algorithms and written in C, BigMath aims to be light-weight and fast. Its original implementation was for use within a kernel extension - thus size and speed were essential. BigMath supports only integer math, including add, sub, mul, div, mod, modpow, modinv, pow, gcd, factorial, radix conversion, scientific notation and various comparisons.

Bill's OpenGL Library: BOGL - an OpenGL scenegraph/renderer supporting modern hardware (vertex and pixel programs via Cg, buffer objects, etc), freetype fonts, XML resource files, bezier patches, state sorting, separate render and simulation threads.

Binary I O library: 'libbinio' uses its own protocol to store and retrieve binary data portably. It uses an fprintf/fscanf interface, exporting eight functions: fputf, vfputf, fgetf, vfgetf, fwputf, vfwputf, fwgetf, and vfwgetf. Rather than using data types such as "16 bits", it uses standard C types and uses printf/scanf-style argument lists (it even uses GNU argument checking if available). It should be a drop-in replacement for printf/scanf and still work perfectly well. It aims to be portable to every C89-conforming implementation, but can use C99 and GNU extensions if available.

Bioinformatics Template Library: This library focuses on the data structures and algorithms used in bioinformatics and molecular modelling, following closely the approach of the Standard Template Library (STL) to implement efficient generic programming modules using compile time mechanisms. Although the BTL was designed with biomolecular applications in mind it contains classes of more general utility: for instance, the Matrix class could be used for matrix algebra in many contexts.

BirdFont: BirdFont is a font editor which can generate fonts in SVG, EOT and TTF format.

Biskit: Biskit is a python library for structural bioinformatics research. It simplifies the analysis of macromolecular structures, protein complexes, and molecular dynamics trajectories and offers a platform for the rapid integration of external programs.

Bit Vector: Bit::Vector is a (stand-alone) C library and an object-oriented Perl module (with overloaded operators) which allows you to handle bit vectors, sets (of integers), "big integer arithmetic" (e.g. for cryptography), and boolean matrices (all of arbitrary size) very efficiently. The package also includes an object-oriented Perl module for accessing the C library from Perl (the library can also be used by itself, without Perl). Optionally, it features overloaded operators for maximum ease of use.

Bitap: The bitap library is a clean implementation of regular expression (regex/grep) string matching using the bitap algorithm. Approximate (a.k.a. fuzzy) matching is allowed. This is the same algorithm as the one used in Glimpse and agrep, but it is much more complete with regard to regular expression syntax, and is much cleaner. It is quite fast compared to other greps due to the bitap algoritm and modern CPU architechture. Modifying code for special cases speeds things up even futher. Note that the complete 'search' string must be matched by the pattern. If you want to search for substrings of the search string, prefix and postfix the pattern with '.*'.

Bitpacket: BitPacket is a Python module to represent bit field structures in an easy object-oriented way. BitPacket provides three classes: BitField, BitStructure and BitVariableStructure which represent simple bit fields, and fixed and variable structures of bit fields respectively. BitStructure and BitVariableStructure are BitField themselves and all of them can be used together in order to build packets. That is, we can add any BitField subclass into a BitStructure or BitVariableStructure.

Bitstring: bitstring is a pure Python module designed to help make the creation and analysis of binary data as simple and natural as possible. BitStrings can be constructed from integers (big and little endian), hex, octal, binary, strings or files. They can be sliced, joined, reversed, inserted into, overwritten, etc. with simple functions or slice notation. They can also be read from, searched and replaced, and navigated in, similar to a file or stream.

Bitwise enums: A very simple, 0-overhead, and yet type-safe 1-file library for doing bitwise operations between masks represented by enums. Please note: This library has been subsumed into MiLi and is no longer being maintained individually.

Blib: 'blib' is the Blinkenlights Library, a programming library that gives you a kick start into development with Blinkenlights/Arcade. 'blib' also provides the Game API with which games for Arcade can be developed. 'blib' provides functions to read and write BLM, BML, and MNG animations, and to receive and send the Blinkenlights protocol.

Blip Buffer: Blip_Buffer implements efficient band-limited sound synthesis buffers, allowing high-quality emulation of video game sound chips. After setting the source clock rate and output sampling rate, waveforms are generated by specifying the time points where amplitude changes occur. Treble and bass adjustments are also supported. Many examples are included that show basic waveform generation, sample buffering schemes, and more advanced topics. They can be made to write output to a wave sound file, or optionally use the SDL multimedia library for real-time playback, waveform display, and mouse control of parameters.

BlockCanvas: The BlockCanvas project provides a visual environment for creating simulation experiments, where function and data are separated. Thus, you can define your simulation algorithm by visually connecting function blocks into a data flow network, and then run it with various data sets (known as "contexts"); likewise, you can use the same context in a different functional simulation. The project provides support for plotting, function searching and inspection, and optimization. It includes a stand-alone application that demonstrates the block-canvas environment, but the same functionality can be incorporated into other applications. The BlockCanvas project relies on included libraries that allow multiple data sets using Numeric arrays to be incorporated in a Traits-based model in a way that is simple, fast, efficient, and consistent.

Bmrblib: Bmrblib is a Python API abstracting the Biological Magnetic Resonance Data Bank (BioMagResBank or BMRB) NMR-STAR format (http://www.bmrb.wisc.edu/). It allows the writing of NMR-STAR files for BMRB data deposition and the reading and easy extraction of data from files residing in the BMRB data bank, all without knowledge of the Self-Defining Text Archive and Retrieval (STAR) format.

Bobcat: The (shared) Bobcat library contains classes and templates used by, e.g., the Stealth and Bisonc++ programs. The Bobcat library contains a variety of C++ classes and templates, some of them based on well-known Design Patterns. The library offers classes handling, e.g., Child Processes, Forks, Pipes and Redirection Command-to-Function associations Command-line arguments and history handling Command-line editing using streams Configuration Files Decryption and Encryption Extended String Operations Hash-tables Integers of unlimited size File-descriptor based streams (e.g. handle sockets using streams) Mail headers and mail filtering (milters) Message Digests Pattern matching Single (Direct) Key Input Syslog- and other kinds of messages Temporary files Universal Type Conversions (Templates)

Boehm garbage collector: A conservative garbage collector which can be used as a garbage collecting replacement for C malloc or C++ new and as a malloc leak detector.

Bond: BOND (building object network databases) is a rapid application development tool which allows you to develop GUI front ends to PostgreSQL databases. It uses XML to define widget layout and how to obtain information from databases. This project is designed to simplify the process of developing database applications for GTK.

Booleano: Booleano is an interpreter of boolean expressions, a library to define and run filters available as text (e.g., in a natural language) or in Python code. In order to handle text-based filters, Booleano ships with a fully-featured parser whose grammar is adaptive: Its properties can be overridden using simple configuration directives.

Boost

Boost is a repository of portable and peer-reviewed C++ libraries.

Accumulators: Framework for incremental calculation, and collection of statistical accumulators. Math and numerics
Algorithm: A collection of useful generic algorithms. Algorithms
Any: Safe, generic container for single values of different value types. Data structures
Array: STL compliant container wrapper for arrays of constant size. Containers
Asio: Portable networking, including sockets, timers, hostname resolution and socket iostreams. Concurrent Programming
Assign: Filling containers with constant or generated data has never been easier. Input/Output
Bimap: Bidirectional maps library for C++. With Boost.Bimap you can create associative containers in which both types can be used as key. Containers
Bind: boost::bind is a generalization of the standard functions std::bind1st and std::bind2nd. It supports arbitrary function objects, functions, function pointers, and member function pointers, and is able to bind any argument to a specific value or route input arguments into arbitrary positions. Function objects and higher-order programming
Call Traits: Defines types for passing parameters. Generic Programming
Chrono: Useful time utilities. Domain Specific
Circular Buffer: A STL compliant container also known as ring or cyclic buffer. Containers
Compatibility: Help for non-conforming standard libraries. Broken compiler workarounds
Compressed Pair: Empty member optimization. Data structures
Concept Check: Tools for generic programming. Generic Programming
Config: Helps Boost library developers adapt to compiler idiosyncrasies; not intended for library users. Broken compiler workarounds
Container: Standard library containers and extensions. Containers
Context: Context switching library. Concurrent Programming
Conversion: Polymorphic and lexical casts. String and text processing
CRC: The Boost CRC Library provides two implementations of CRC (cyclic redundancy code) computation objects and two implementations of CRC computation functions. The implementations are template-based. Domain Specific
Date Time: A set of date-time libraries based on generic programming concepts. Domain Specific
Dynamic Bitset: The dynamic_bitset class represents a set of bits. It provides accesses to the value of individual bits via an operator[] and provides all of the bitwise operators that one can apply to builtin integers, such as operator& and operator<<. The number of bits in the set is specified at runtime via a parameter to the constructor of the dynamic_bitset. Containers
Enable If: Selective inclusion of function template overloads. Generic Programming
Exception: The Boost Exception library supports transporting of arbitrary data in exception objects, and transporting of exceptions between threads. Language Features Emulation
Filesystem: The Boost Filesystem Library provides portable facilities to query and manipulate paths, files, and directories. System
Flyweight: Design pattern to manage large quantities of highly redundant objects. Patterns and Idioms
Foreach: In C++, writing a loop that iterates over a sequence is tedious. We can either use iterators, which requires a considerable amount of boiler-plate, or we can use the std::for_each() algorithm and move our loop body into a predicate, which requires no less boiler-plate and forces us to move our logic far from where it will be used. In contrast, some other languages, like Perl, provide a dedicated "foreach" construct that automates this process. BOOST_FOREACH is just such a construct for C++. It iterates over sequences for us, freeing us from having to deal directly with iterators or write predicates. Algorithms
Format: 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 and text processing
Function: Function object wrappers for deferred calls or callbacks. Function objects and higher-order programming
Function Types: Boost.FunctionTypes provides functionality to classify, decompose and synthesize function, function pointer, function reference and pointer to member types. Generic Programming
Functional: The Boost.Function library contains a family of class templates that are function object wrappers. Function objects and higher-order programming
Functional/Factory: Function object templates for dynamic and static object creation Function objects and higher-order programming
Functional/Forward: Adapters to allow generic function objects to accept arbitrary arguments Function objects and higher-order programming
Functional/Hash: A TR1 hash function object that can be extended to hash user defined types. Function objects and higher-order programming
Functional/Overloaded Function: Overload different functions into a single function object. Function objects and higher-order programming
Fusion: Library for working with tuples, including various containers, algorithms, etc. Template Metaprogramming
Geometry: Geometry Library. Algorithms
GIL: Generic Image Library Containers
Graph: The BGL graph interface and graph components are generic, in the same sense as the the Standard Template Library (STL). Containers
Heap: Priority queue data structures. Data structures
ICL: Interval Container Library, interval sets and maps and aggregation of associated values Containers
Identity Type: Wrap types within round parenthesis so they can always be passed as macro parameters. Preprocessor Metaprogramming
In Place Factory, Typed In Place Factory: Generic in-place construction of contained objects with a variadic argument-list. Generic Programming
Integer: The organization of boost integer headers and classes is designed to take advantage of <stdint.h> types from the 1999 C standard without resorting to undefined behavior in terms of the 1998 C++ standard. The header <boost/cstdint.hpp> makes the standard integer types safely available in namespace boost without placing any names in namespace std. Math and numerics
Interprocess: Shared memory, memory mapped files, process-shared mutexes, condition variables, containers and allocators. Concurrent Programming
Interval: Extends the usual arithmetic functions to mathematical intervals. Math and numerics
Intrusive: Intrusive containers and algorithms. Containers
IO State Savers: The I/O sub-library of Boost helps segregate the large number of Boost headers. This sub-library should contain various items to use with/for the standard I/O library. Input/Output
Iostreams: Boost.IOStreams provides a framework for defining streams, stream buffers and i/o filters. String and text processing
Iterators: The Boost Iterator Library contains two parts. The first is a system of concepts which extend the C++ standard iterator requirements. The second is a framework of components for building iterators based on these extended concepts and includes several useful iterator adaptors. Iterators
Lambda: Define small unnamed function objects at the actual call site, and more. Function objects and higher-order programming
Lexical Cast: General literal text conversions, such as an int represented a string, or vice-versa, from Kevlin Henney. String and text processing
Local Function: Program functions locally, within other functions, directly within the scope where they are needed. Function objects and higher-order programming
Locale: Provide localization and Unicode handling tools for C++. String and text processing
Math: Boost.Math includes several contributions in the domain of mathematics: The Greatest Common Divisor and Least Common Multiple library provides run-time and compile-time evaluation of the greatest common divisor (GCD) or least common multiple (LCM) of two integers. The Special Functions library currently provides eight templated special functions, in namespace boost. The Complex Number Inverse Trigonometric Functions are the inverses of trigonometric functions currently present in the C++ standard. Quaternions are a relative of complex numbers often used to parameterise rotations in three dimentional space. Octonions, like quaternions, are a relative of complex numbers. Math and numerics
Math Common Factor: Greatest common divisor and least common multiple. Math and numerics
Math Octonion: Octonions. Math and numerics
Math Quaternion: Quaternions. Math and numerics
Math/Special Functions: A wide selection of mathematical special functions. Math and numerics
Math/Statistical Distributions: A wide selection of univariate statistical distributions and functions that operate on them. Math and numerics
Member Function: Generalized binders for function/object/pointers and member functions. Function objects and higher-order programming
Meta State Machine: A very high-performance library for expressive UML2 finite state machines. State Machines
Min-Max: Standard library extensions for simultaneous min/max and min/max element computations. Algorithms
Move: Portable move semantics for C++03 and C++11 compilers. Language Features Emulation
MPI: Message Passing Interface library, for use in distributed-memory parallel application programming. Concurrent Programming
MPL: The Boost.MPL library is a general-purpose, high-level C++ template metaprogramming framework of compile-time algorithms, sequences and metafunctions. It provides a conceptual foundation and an extensive set of powerful and coherent tools that make doing explict metaprogramming in C++ as easy and enjoyable as possible within the current language. Template Metaprogramming
Multi-Array: Boost.MultiArray provides a generic N-dimensional array concept definition and common implementations of that interface. Containers
Multi-Index: The Boost Multi-index Containers Library provides a class template named multi_index_container which enables the construction of containers maintaining one or more indices with different sorting and access semantics. Containers
Numeric Conversion: Optimized Policy-based Numeric Conversions. Math and numerics
Operators: Templates ease arithmetic classes and iterators. Iterators
Optional: Discriminated-union wrapper for optional values. Miscellaneous
Parameter: Boost.Parameter Library - Write functions that accept arguments by name. Programming Interfaces
Phoenix: Define small unnamed function objects at the actual call site, and more. Function objects and higher-order programming
Pointer Container: Containers for storing heap-allocated polymorphic objects to ease OO-programming. Containers
Polygon: Booleans/clipping, resizing/offsetting and more for planar polygons with integral coordinates. Miscellaneous
Pool: Memory pool management. Memory
Preprocessor: Preprocessor metaprogramming tools including repetition and recursion. Preprocessor Metaprogramming
Program Options: The program_options library allows program developers to obtain program options, that is (name, value) pairs from the user, via conventional methods such as command line and config file. Input/Output
Property Map: Concepts defining interfaces which map key objects to value objects. Containers
Property Tree: A tree data structure especially suited to storing configuration data. Containers
Proto: Expression template library and compiler construction toolkit for domain-specific embedded languages. Template Metaprogramming
Python: 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. Inter-language support
Random: A complete system for random number generation. Math and numerics
Range: A new infrastructure for generic algorithms that builds on top of the new iterator concepts. Algorithms
Ratio: Compile time rational arithmetic. Math and numerics
Rational: A rational number class. Math and numerics
Ref: A utility library for passing references to generic functions. Function objects and higher-order programming
Regex: Regular expression library. String and text processing
Result Of: Determines the type of a function call expression. Function objects and higher-order programming
Scope Exit: Execute arbitrary code at scope exit. Language Features Emulation
Serialization: Serialization for persistence and marshalling. Input/Output
Signals: Managed signals & slots callback implementation. Function objects and higher-order programming
Signals2: Managed signals & slots callback implementation (thread-safe version 2). Function objects and higher-order programming
Smart Ptr: Smart pointer class templates. Memory
Spirit: LL parser framework represents parsers directly as EBNF grammars in inlined C++. String and text processing
Statechart: Boost.Statechart - Arbitrarily complex finite state machines can be implemented in easily readable and maintainable C++ code. State Machines
Static Assert: Static assertions (compile time assertions). Generic Programming
String Algo: String algorithms library. String and text processing
Swap: Enhanced generic swap function. Miscellaneous
System: Operating system support, including the diagnostics support that will be part of the C++0x standard library. System
Test: Support for simple program testing, full unit testing, and for program execution monitoring. Correctness and testing
Thread: Portable C++ multi-threading. Concurrent Programming
Timer: Event timer, progress timer, and progress display classes. Miscellaneous
Tokenizer: Break of a string or other character sequence into a series of tokens. String and text processing
TR1: The TR1 library provides an implementation of the C++ Technical Report on Standard Library Extensions. This library does not itself implement the TR1 components, rather it's a thin wrapper that will include your standard library's TR1 implementation (if it has one), otherwise it will include the Boost Library equivalents, and import them into namespace std::tr1. Miscellaneous
Tribool: 3-state boolean type library. Miscellaneous
Tuple: Ease definition of functions returning multiple values, and more. Data structures
Type Traits: Templates for fundamental properties of types. Generic Programming
Typeof: Typeof operator emulation. Language Features Emulation
uBLAS: uBLAS provides matrix and vector classes as well as basic linear algebra routines. Several dense, packed and sparse storage schemes are supported. Math and numerics
Units: Zero-overhead dimensional analysis and unit/quantity manipulation and conversion. Domain Specific
Unordered: Unordered associative containers. Containers
Utility: Class noncopyable plus checked_delete(), checked_array_delete(), next(), prior() function templates, plus base-from-member idiom. Algorithms
Uuid: A universally unique identifier. Data structures
Value Initialized: Wrapper for uniform-syntax value initialization, based on the original idea of David Abrahams. Miscellaneous
Variant: Safe, generic, stack-based discriminated union container. Containers
Wave: The Boost.Wave library is a Standards conformant, and highly configurable implementation of the mandated C99/C++ preprocessor functionality packed behind an easy to use iterator interface. String and text processing
Xpressive: Regular expressions that can be written as strings or as expression templates, and which can refer to each other and themselves recursively with the power of context-free grammars. String and text processing

Boost Numeric Bindings: Boost Bindings is a bindings library (not just) for Boost.Ublas. It offers an easy way of calling BLAS, LAPACK, UMFPACK, MUMPS and many other mature legacy numerical codes from within C++.

Bootstrap: Bootstrap is a mobile-first, responsive Web front-end framework. It is a very popular framework made by Twitter, and can be easily themed and customized.

Bootswatch: Bootswatch is a set of free themes for Bootstrap.

Free Software Foundation!

Semantic search

Query log

apel

emu

Note

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Interaction

Navigation

Creation

Print

Tools