[[Interface::library]]

8sync ,: 8sync (pronounced eight-sync) is an asynchronous programming library for GNU Guile. It makes use of delimited continuations to avoid a mess of callbacks, resulting in clean, easy-to-read, non-blocking code.

ADOdb is a database abstraction library for PHP. The PHP version currently supports an amazing number of databases, thanks to the wonderful ADOdb community: MySQL, PostgreSQL, Interbase, Firebird, Informix, Oracle, MS SQL, Foxpro, Access, ADO, Sybase, FrontBase, DB2, SAP DB, SQLite, Netezza, LDAP, and generic ODBC, ODBTP. The Sybase, Informix, FrontBase and PostgreSQL, Netezza, LDAP, ODBTP drivers are community contributions. Some reasons why ADOdb is popular include:

Designed for speed. It is probably the fastest free software database abstraction library available for PHP. See benchmarks.
Provides extensive portability support such as date and type-handling and portable schema creation. See portable sql tips
Support many enterprise features such as database backed sessions (with session expiry notification), SQL code generation, pivot tables, SELECT LIMIT emulation for all databases, performance monitoring.
Easy to learn.
Extensive QA, every release is unit-tested on Access, MySQL, PostgreSQL, MS SQL, Oracle 9.
Mature, continuously developed since August 2000. Has a large community of users.
Powerful Active Record support. See docs.
Very reasonable licensing terms (BSD). This means that you can incorporate (and even compile) it into your software applications royalty-free without asking the author's permission, provided you include license.txt in your release.

ADOdb Lite: A small, fast replacement for ADODB that uses 1/6th of the memory and upto 300% faster while being compatible with ADODB using a subset of the most often used ADODB commands.. Supports Frontbase, MaxDB, MiniSql, MSSQL, MySql, Postgres, SqLite and Sybase.

ADOdb for Python

ADOdb is a database abstraction library. ADOdb was originally developed for PHP, and ported to Python. The Python version implements a subset of the PHP version. You might ask why Python needs a database abstraction library when Python provides the official DB API. Unfortunately the DB API does not encapsulate differences in the database implementations. For example, to select a limited number of rows, say 10 rows, you would have to use very different SQL for different databases:

MS SQL select top 10 from table
MySQL and PostgreSQL select * from table limit 10
Oracle select * from (select * from table) where rownum <= 10
These differences are handled by ADOdb (using SelectLimit), but not by the Python DB API. Other important database differences transparently handled by ADOdb include date-formating, associative arrays (records as dictionaries) and LOB-handling.

ALSA OSS

The Advanced Linux Sound Architecture (ALSA) provides audio and MIDI functionality to the GNU/Linux operating system. ALSA has the following significant features:

Efficient support for all types of audio interfaces, from consumer sound cards to professional multichannel audio interfaces.
Fully modularized sound drivers.
SMP and thread-safe design.
User space library (alsa-lib) to simplify application programming and provide higher level functionality.
Support for the older Open Sound System (OSS) API, providing binary compatibility for most OSS programs.

ALSA library

The Advanced Linux Sound Architecture (ALSA) provides audio and MIDI functionality to the GNU/Linux operating system. ALSA has the following significant features:

Efficient support for all types of audio interfaces, from consumer sound cards to professional multichannel audio interfaces.
Fully modularized sound drivers.
SMP and thread-safe design.
User space library (alsa-lib) to simplify application programming and provide higher level functionality.
Support for the older Open Sound System (OSS) API, providing binary compatibility for most OSS programs.

APE Tag Libraries: C, Clojure, Erlang, Lua, Python, Ruby Libraries for reading/writing APEv2 tags.

ASCEND: ASCEND IV is an object-oriented mathematical modeling environment, with similar functionality to programs such as GAMS, AMPL, Aspen, or Dymola. If can be used to solve difficult non-linear systems of equations and to plot dynamic behaviour of such systems. Although ASCEND has primarily been developed by Chemical Engineers, great care has been exercised to assure that it is domain independent. ASCEND can support modeling activities in fields from Architecture to (computational) Zoology.

ATK: 'Accessibility' means enabling people with disabilities to participate in substantial life activities that include work and the use of services, products, and information. GNOME Accessibility is the suite of software services and support in GNOME that provides accessibility interfaces to other applications and toolkits.

ATM SAR Library (SARLib): SARLib can be used as an AAL5 ATM Segmentation and Reassembly engine.

AVbin

AVbin is a thin wrapper around FFmpeg, providing binary compatibility for applications and languages that need it. FFmpeg is a collection of audio and video codecs widely used in projects such as mplayer, xine, gstreamer and VLC. It is under continuous development; so much so that its developers rarely provide a release, and SVN snapshots of the library must be statically linked to avoid version incompatibilities. AVbin allows programs that require dynamic linkage to use FFmpeg. It does this by providing:

an accurate version number within the shared library, allowing applications to select the appropriate data structures and functions to use at runtime, and
a simplified interface with an unchanging ABI to the most common decoding functionality within FFmpeg.
AVbin is distributed as a single dynamic library (.so on GNU/Linux, .dylib on Mac OS X, and .dll on Windows) that depends on no other files or installations. This eliminates the many complexities of building FFmpeg on platforms other than GNU/Linux; however you can still build it from source if you prefer.

Aalib: 'Aalib' is a low level gfx library that works on any kind of terminal. It does not require graphics devices (in fact, no graphical output is possible), and is particularly useful for those with older hardware who do not want to worry about overloading their systems with graphical applications.

Abclock: 'abclock' gives a spatial representation of time. It isn't tied to the design of a mechanical clock, but instead uses the natural properties of bitmaps: straight lines and rectangles. The clock uses ordinary hours and minutes. Placement and movement of objects is analogous to mechanical clocks. Time has a symmetrical property that is reflected in the way time changes in this clock. It is clear and exact up to parts of minutes, even when the bitmap is very small.

Achievo ATK: Achievo ATK is an object oriented Web-application Framework, written in PHP. It is targeted at developers who wish to focus on business logic, instead of coding HTML. Where other application frameworks mainly provide a large set of utility classes, ATK provides a complete framework that requires only small amounts of code to get usable applications, while maintaining full flexibility. It is currently the back-end software for the 'achievo' project management/project tracking tool.

Ad-hoc Support Library: Ad-hoc Support Library (ASL) is a user-space library which provides an API to faciliate implementation of routing protocols for wireless ad-hoc networks in GNU/Linux.

Ada Components: A component library for the Ada language. The four main categories are data structures, math, Ada programming tools, and OS interface.

Ada Motif binding library: SERC's Ada/Motif is a complete binding to X Windows and OSF/Motif for the Ada programming language it was based in part upon the SAIC/Unisys (STARS) public-domain bindings it incorporates many of the bug fixes and additional capabilities beyond the public-domain releases in Ada/Motif. Most noteworthy are the capabilities included in Ada/Motif for Ada tasking, callback registration, memory leak detection/prevention and capabilities for developing customized widgets. Paramax/STARS considers Ada/Motif to be the commercial version of their STARS bindings, according to SERC.

AdaSockets: 'AdaSockets' is a library that lets you use sockets in Ada 95. It supports unicast and multicast sockets, and uses object oriented structures to ease sockets manipulation.

AdaUnits: 'AdaUnits' provides an implementation of dimensioned values for Ada. Unit checks are made at run-time, if not optimized out by the compiler. The package supports SI and irregular measurement units and shifted units (like degrees Celsius). Conversions from and back to strings are provided for all various irregular units.

Adns: adns is a DNS resolver library for C (and C++) programs, and a collection of useful DNS lookup utilities. The C library, and the command line utilities, provide a convenient interface. adns is capable of doing DNS lookups in an asynchronous, event-driven, fashion.

Aften: Aften is a simple A/52 (AC-3) audio encoder based on the FFMpeg libraries. The name is an acronym for A/Fifty-Two ENcoder. It is also Danish and Norwegian word for 'evening'. It is able to create stereo and multi-channel AC3-compatible audio streams.

Aiodns: Supports A, AAAA, ANY, CNAME, MX, NAPTR, NS, PTR, SOA, SRV, and TXT DNS queries.

Aiohttp: Supports WebSocket and can provide middlewares and pluggable routing for servers.

Airhook: Airhook is a reliable data delivery protocol, like TCP. Unlike TCP, Airhook gracefully handles intermittent, unreliable, or delayed networks. Other features include session recovery, queue control, and delivery status notification. Airhook is useful for keeping connections running over bad wireless networks (like CDPD), intermittent dial-up connections, and any other network that doesn't work very well. The implementation includes a TCP proxy (so you can use HTTP, SSH, etc.) and a protocol library for applications that want more control (real-time media delivery, games, etc).

Alchemist: This package provides a functional, Ruby Domain-Specific Language (DSL) for casting, transforming and transposing objects. The project's README file provides the following explanation of the purpose of this library:

Rationale

Casting complex objects from one type to another can be an uncomfortable process to express well. Objects that we use on a daily basis are not always in our control, and, even when they are, some don't lend themselves to simple construction. Remote service communication objects or complex data structures from libraries we use in our applications can result in large piles of casting code.
This circumstance often produces large swaths of procedural code, even if split up into separate function calls. This code can be not only difficult to understand, but difficult to test if an object requires a great deal of set up. Field or method assignments midway through can change and break the entire operation.
The goal of this project is to provide a method of defining easily digestible specifications for object translation that are also easily testable and changeable. The project focuses on writing specifications for transformations and not doing direct mutation in the recipes. The result is something that should seem somewhat functional, but also exceedingly separable.

Algart

AlgART are free software Java libraries, supporting generalized smart arrays and matrices with elements of any types (1 bit, 8/16/32/64-bit integers, 32/64-bit floating point values and any other Java types), including a wide set of of 2D-, 3D- and multidimensional image processing and other algorithms, working with arrays and matrices.

Main Features

The libraries use 63-bit addressing of array elements (all indexes and length are represented by 64-bit long type). So, it's theoretically possible to create and process arrays and matrices containing up to 2^63-1 (~10^19) elements of any primitive or non-primitive types, if OS and hardware can provide necessary amount of memory or disk space.

Memory model concept allows storing AlgART arrays in different schemes, from simple Java arrays to mapped disk files; all necessary data transfers are performed automatically while every access to an element or a block of elements.

Most of algorithms are based on wide usage of lazy evaluations. Typical operations, like elementwise summing or geometrical matrix transformations, are implemented via lazy views of the source array or matrix.

- For example, you can take a multidimensional matrix, rotate it (or perform any other affine or projective transform), and then extract a submatrix from the result. All these operations will be performed virtually (not requiring time), and actual calculations will be performed only at the moment of accessing elements, usually while copying the resulting matrix to a newly created one. Moreover, in many cases the libraries will "understand" itself, that the user wants to perform rotation or another transform, and will split the matrix into suitable rectangular blocks (fitting in RAM) and choose the best algorithm for this task at the moment of copying operation.

The libraries contain a wide set of image processing algorithms over matrices: linear filtering, mathematical morphology, rank operations, spectral transformation (FFT), etc.

There is also skeletonization and measuring of binary images.

Allegro: Allegro is multi-platform game programming library for C/C++ developers distributed freely, that provides many functions for graphics, sounds, player input (keyboard, mouse and joystick) and timers. It also provides fixed and floating point mathematical functions, 3d functions, file management functions, compressed datafile and a GUI. It can also be used for other types of multimedia programming.

Alliance: Complete set of free CAD tools and portable libraries for VLSI design. It includes a VHDL compiler and simulator, logic synthesis tools, and automatic place and route tools. Advanced verification tools for functional abstraction and static timing analysis are part of the system. A complete set of portable CMOS libraries is provided, including a RAM generator, a ROM generator, and a data-path compiler.

Alogg: 'alogg' is a library which makes it easier to use Ogg/Vorbis streams with Allegro. It offers facilities to decode, stream, and encode Ogg/Vorbis streams, and integrates those facilities with Allegro's datafile and sample loading routines. 'alogg' comes with a sample player, streamer, and encoder based on Allegro's sound routines.

Alpy: Alpy provides a Python binding to the C Allegro game programming library. This binding is mostly focused with providing a basic "raw" interface to the library, trying to preserve most of the Python API similar to the C version to ease the transition to C programmers.

Amara: Library for XML processing in Python, designed to balance the native idioms of Python with the native character of XML.

Anemone: Anemone is a Ruby library that makes it quick and painless to write programs that spider a website. It provides a simple DSL for performing actions on every page of a site, skipping certain URLs, and calculating the shortest path to a given page on a site. The multi-threaded design makes Anemone fast. The API makes it simple. And the expressiveness of Ruby makes it powerful.

AngelScript: The AngelCode Scripting Library, or AngelScript as it is also known, is an extremely flexible cross-platform scripting library designed to allow applications to extend their functionality through external scripts. Featuring a syntax similar to C/C++, it has been designed from the beginning to be an easy to use component, both for the application programmer and the script writer.

AntTweakBar: AntTweakBar allows programmers to quickly add a light and intuitive graphical user interface into graphic programs to interactively tweak them. It is a small and easy to use C/C++ library that can be readily integrated into OpenGL and DirectX applications. It targets graphical programs that need an easy way to tweak parameters and see the result in real-time like 3D demos, light inline game editors, small 3D applications, prototypes, debug facilities of weighter graphical programs, etc. Programmers are not required to design the graphical interface by providing coordinates or by using a visual UI editor. Controls are automatically organized following an optional given hierarchy. In most cases, only one line of code is needed to add a new variable to a tweak bar. AntTweakBar can be easily integrated with your own windowing system or with existing toolkits. Examples of integration with GLFW, SDL, GLU are provided.

Apel

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.

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.

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.

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

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.

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.

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.

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 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.

Botan: Botan (formerly OpenCL) is a library of cryptographic algorithms. It includes a wide selection of block and stream ciphers, public key algorithms, hash functions, and message authentication codes, plus a high level filter-based interface. The home page has a list of supported algorithms.

Botnet: BotNet is a library written in C, intended to assist in development of an IRC bot (or even an IRC client). It provides an easy-to-use model of communication with the IRC server by giving you string-sending functions and by returning messages from the IRC server into events to your application's main(). It also contains functions for easy DCC CHAT and SEND connections and an excess flood protection mechanism.

Brother ql: brother_ql is a software package to facilitate printing labels on Brother’s QL-Series label printers. It was designed to be used from the command line but also supports usage from other software packages (via its command line interface or via its Python API).

Bugs

BUGS is the Big and Useful Great Security key encryption algorithm and applications. It is easy to use, and includes sample applications and documentation. The cryptography library can also be used with your own programs. Features include:

Private key algorithm
Dynamic cryptography algorithm
Source code can be made public without making the algorithm weak
Infinite key lengths
Bilateral bits swwapping with various windows
Bilateral Pseudo randomly binary operations
Random number added to key
Random number generator using the ISAAC algorithm
Possibility of generating your own RNG seed
Five different cryptography levels, for the best possible
combination of efficiency and speed
Seed and shuffle functions
A clear text can be crypted using its own data
Two methods of execution: direct disk access or memory cache
Strong key generator

C++ Sockets: This is a GPL licensed C++ class library wrapping the Berkeley sockets C API. It treats one socket as one object. KThis is how the Socket class was born. This class, in itself, has all the functions needed for address translation (hostname to ip, ip to hostname etc). It owns the file descriptor / SOCKET handle. But it can't do anything. Code for actually doing something with the socket is implemented in other, Socket derived classes.

C-ares: 'c-ares' is a C library that resolves names asynchronously. It is meant for applications that perform DNS queries without blocking or multiple DNS queries in parallel (ie servers that communicate with multiple clients and programs with GUIs).

C2lib: c2lib is a library of basic tools for use by C programmers. It contains features heavily influenced by both Perl's string handling and C++'s Standard Template Library (STL). Its goal is to provide some of the advantages of Perl with only around a factor of 2-3 code-size expansion, while retaining most of the efficiency advantages of C and remaining compatible with existing libc functions.

C3.js: Enables deeper integration of charts into web applications.

CDBlib: Read and write cdb ("constant database") files. Cdblib contains classes to read and write cdb ("constant database") files. Cdb files map string keys to string values with very fast record lookups. Cdblib also allows for in-memory indexes to enable even faster lookups.

CFFI: Convenient and reliable way of calling C code from Python. The aim of this project is to provide a convenient and reliable way of calling C code from Python. It keeps Python logic in Python, and minimises the C required. It is able to work at either the C API or ABI level, unlike most other approaches, that only support the ABI level.

CGAL: The goal of the CGAL Project is to provide easy access to efficient and reliable geometric algorithms in the form of a C++ library. CGAL is used in various areas needing geometric computation, such as: computer graphics, scientific visualization, computer aided design and modeling, geographic information systems, molecular biology, medical imaging, robotics and motion planning, mesh generation, numerical methods...
CGAL offers data structures and algorithms like triangulations (2D constrained triangulations and Delaunay triangulations in 2D and 3D), Voronoi diagrams (for 2D and 3D points, 2D additively weighted Voronoi diagrams, and segment Voronoi diagrams), Boolean operations on polygons and polyhedra, arrangements of curves and their applications (2D and 3D envelopes, Minkowski sums) mesh generation (2D Delaunay mesh generation and 3D surface mesh generation, skin surfaces), geometry processing (surface mesh simplification, subdivision and parameterization, as well as estimation of local differential properties, and approximation of ridges and umbilics), alpha shapes, convex hull algorithms (in 2D, 3D and dD), operations on polygons (straight skeleton and offset polygon), search structures (kd trees for nearest neighbor search, and range and segment trees), interpolation (natural neighbor interpolation and placement of streamlines), shape analysis, fitting, and distances (smallest enclosing sphere of points or spheres, smallest enclosing ellipsoid of points, principal component analysis), and kinetic data structures. All these data structures and algorithms operate on geometric objects like points and segments, and perform geometric tests on them. These objects and predicates are regrouped in CGAL Kernels.

CGKit (Python Computer Graphics Kit): The Python Computer Graphics Kit is a collection of Python modules that contain the basic types and functions to be able to create 3D computer graphics images (focusing on Pixar's RenderMan interface).

CImg: The CImg (Cool Image) Library is a C++ toolkit that provides simple classes and functions for loading, saving, processing and displaying images in your own C++ code. It contains useful image processing algorithms for loading/saving, resizing/rotating, filtering, object drawing (text, lines, faces, ellipses,..), and more. Images are instancied by a class able to represent images up to 4-dimension wide (from 1-D scalar signals to 3-D volumes of vector-valued pixels), with template pixel types. The package compiles it with only the standard C libraries.

CLN: CLN is a C++ class library for numbers: integers, rational, float, complex, modular integer. It implements elementary, logical, transcendental functions. Unlimited precision, 100 million digits are no problem. Easy to use because of algebraic syntax and automatic memory management.

CMUSphinx- base: Sphinx is a speaker-independent large vocabulary continuous speech recognizer. It is also a collection of free software tools and resources that allows researchers and developers to build speech recognition systems. The packages that the CMU Sphinx Group is releasing are a set of reasonably mature, world-class speech components that provide a basic level of technology to anyone interested in creating speech-using applications without the once-prohibitive initial investment cost in research and development; the same components are open to peer review by all researchers in the field, and are used for linguistic research as well.

CUnit: CUnit is a light-weight library that allows programmers to test their C code. Test results can be browsed in multiple formats or built-in interfaces.

CWXML: CWXML is a C library for parsing and generating XML and BXML formats with a straightforward API. Initial testing indicates that it is 3 or more times faster than other popular libraries such as expat and libxml2 at parsing XML and much faster again with BXML (a free, patent-unencumbered binary-encoding format for XML data that is a replacement for an XML file that mirrors the XML markup structures in a way similar to the in-memory representations of many parser libraries).

Cairo: Cairo is a 2D graphics library with support for multiple output devices. Currently supported output targets include the X Window System (via both Xlib and XCB), Quartz, Win32, image buffers, PostScript, PDF, and SVG file output. Experimental backends include OpenGL, BeOS, OS/2, and DirectFB. Cairo is designed to produce consistent output on all output media while taking advantage of display hardware acceleration when available (eg. through the X Render Extension). The cairo API provides operations similar to the drawing operators of PostScript and PDF. Operations in cairo including stroking and filling cubic Bézier splines, transforming and compositing translucent images, and antialiased text rendering. All drawing operations can be transformed by any affine transformation (scale, rotation, shear, etc.) Cairo is implemented as a library written in the C programming language, but bindings are available for several different programming languages.

CamlTemplate: 'CamlTemplate' is a small template processor library for Objective Caml. It can be used to generate Web pages, scripts, SQL queries, XML documents, and other sorts of text files. It provides a versatile, easy-to-learn template syntax that supports common scripting-language constructs, while encouraging a separation between presentation logic and application logic. The supported Caml data structures accomodate lists, tables, and trees of items in a straightforward manner. CamlTemplate works well with mod_caml, supports any ASCII-compatible encoding, including UTF-8, and includes optional support for multithreading.

Carrot: carrot is an AMQP messaging queue framework. AMQP is the Advanced Message Queuing Protocol, an open standard protocol for message orientation, queuing, routing, reliability and security. The aim of carrot is to make messaging in Python as easy as possible by providing a high-level interface for producing and consuming messages. At the same time it is a goal to re-use what is already available as much as possible. carrot has pluggable messaging back-ends, so it is possible to support several messaging systems. At the time of release, the py-amqplib based backend is considered suitable for production use. Several AMQP message broker implementations exists, including RabbitMQ, ZeroMQ and Apache ActiveMQ. You'll need to have one of these installed, personally we've been using RabbitMQ. Before you start playing with carrot, you should probably read up on AMQP, and you could start with the excellent article about using RabbitMQ under Python, Rabbits and warrens. For more detailed information, you can refer to the Wikipedia article about AMQP.

Castle Game Engine: Castle Game Engine is a cross-platform 3D and 2D game engine for Object Pascal (FPC and Lazarus). - It supports many formats for game assets, including X3D, VRML, Collada, Spine JSON, MD3 and others. - Many graphic effects are possible, including bump mapping, shadows, shaders, mirrors, screen effects. - Animation, collision detection, 3D sound and more features are available. - An extensible system of 3D objects can be used, with out-of-the-box levels, items, intelligent creatures and more. - The engine is portable -- for desktop, mobile, web plugin. The engine is also used to develop view3dscene - a full-featured X3D / VRML browser and a viewer for many other 3D and 2D game formats.

Cbase: Cbase formerly known as CFL (C Foundation Library) is a C library that simplifies systems software development on *nix systems. It includes functions for memory management, string parsing, sub-process execution, filesystem traversal, I/O, interfaces to IPC mechanisms including pseudo-terminals, shared memory, semaphores, and other facilities. It also has implementations of common dynamic data structures like linked lists, queues, stacks, and hash tables, a real-time scheduler similar to 'cron', and high-level APIs to Berkeley sockets and other networking functions. Full documentation is included. This package was formerly known as the Ping Utility Library.

Ccaudio: GNU ccAudio is a stand-alone C++ class library and newly designated GNU package for manipulating audio data, whether on disk or in memory. GNU ccAudio offers the ability to work with audio file formats on disk by treating audio data as sequenced arrays of sample data rather than as arbitrary octets as some audio file manipulation libraries do. In addition to being audio content aware, GNU ccAudio allows header manipulation for setting things like annotation fields. GNU ccAudio is also endian aware and highly portable to both posix and win32 based systems. GNU ccAudio also offers basic audio signal processing including tone data set generation and pluggable codec operations. In the future we will provide loadable free software audio codec modules for many common audio encoding formats where not patent encumbered.

Ccl: 'ccl' is the 'customizable configuration library': a collection of functions for application programmers who want to interface with user-editable configuration files containing key/value pairs. The comment, key/value, and string literal delimiters can be programatically specified at runtime. 'ccl' is designed to be simple and portable; it has a small interface consisting of five functions. It uses avl's implemenation of binary search trees for backend storage.

Cday-php: The CDAY Calendar Almanac displays historical anniversaries such as birthdays and general events. It displays the equivalent date in multiple calendar systems, including Hebrew, Julian, JDNs, Great Underground Empire (Zork), and Shire (Lord of the Rings). Separate command line and Web-based versions are available, along with a free library of thousands of events.

Ceegeye: Renamed jwcgi library to ceegeye, ceegeye is a C++ library for creating CGI (Common Gateway Interface) programs, xhtml bindings, javascript helpers, etc. Comes with several example programs to help you get acquainted with its usage. ceegeye is platform independent.

Cgi-util: Cgi-util is a small C library for creating CGI programs for Websites. Functions are available for initialization (parsing), grabbing fields (by string, integer, double or boolean value), embedding HTML files, and more. It accepts both POST and GET request methods and has extensive error handling and support for cookies.

Cgipplib: 'cgipplib' is a small collection of support classes used to build CGI applications.

Cgixx: The cgixx C++ CGI class library is intended as a modern Common Gateway Interface library for ISO standard C++ compilers. It is not meant to generate complex HTML forms, but rather to ensure fast and reliable conversations between a Web server's CGI and your C++ code. 'cgixx' supports standard GET, POST, HEAD, and PUT CGI methods and cookies as defined in the version 1.1 specification.

Cheap Threads: Cheap Threads is a collection of routines for implementing synchronous threads. It includes a scheduler and a facility for passing messages among threads. Threads may run in a round robin or according to a priority scheme. Each thread must voluntarily relinquish control from time, via an ordinary function return, so that other threads can run. Since the threads are synchronous, i.e. they don't interrupt each other, they don't need to use semaphores, mutexes, critical sections, or other facilities to keep from interfering with each other. One version of Cheap Threads is designed for embedded systems.

Checker: Checker is a debugging tool suite which is used to find memory errors at runtime. 'Checker' can help find bugs that standard tools cannot always find. The best example is memory leaks. A memory leak is a zone of memory, allocated with malloc that is not used anymore. So the memory allocated is lost. This means you program needs more memory and runs slower, since your OS might have to start swapping. It detects bad memory accesses such as: reading uninitialized memory, writing in a freed zone, writing or reading outside of a memory block, and using NULL pointers. This is particularly useful for big programs with many functions. Checker maintains bitmaps to keep track of the status of each byte of memory. The status can be writable, readable, both, or none. When memory is allocated, the new memory becomes write-only: you are not allowed to read it because it has not been initialized. But when you you write to this new block, those bytes become readable and writable. When the block is freed, the bytes become unreadable and unwritable. Red zones are unreadable and unwritable memory, so that each access to a red zone produces a warning.

Chicken: CHICKEN is a simple Scheme-to-C compiler supporting the language features as defined in the 'Revised^5 Report on Scheme'. It supports full tail-recursion and first-class continuations. The code it generates is quite portable; compiled files generated by it (including itself) should work with either no or minor changes on other systems. Linking to C modules and C library functions is straightforward, and compiled programs can easily be embedded into existing C code. The package includes many extra libraries.

Chipmunk

Chipmunk is a fast 2D rigid body physics library written in C. Supports fast circle, segment, and convex polygon collisions.

Designed for 2D video games.
Circle, convex polygon, and line segment collision primitives.
Multiple collision primitives can be attached to the same rigid body.
Fast collision detection by using a spatial hash for the broad phase.
Extremely fast impulse solving by utilizing Erin Catto's contact persistence algorithm.
Support for collision callbacks based on object types.
Impulses applied to contact points can be retrieved after the impulse solver has finished.
Several kinds of joints available.
C99 implementation, no external dependencies.
Ruby extension available.
Simple, read the documentation.

Chomoko

Chomoko is a C++ Message-Queue Library Enterprise, Persistent, Message-Oriented Middleware Technical Aspects:

No dependencies
Cross-Platform
No Server Required
No Install Needed
Network-Based

Chopstx: This library has support for threads, the USB CDC class, UARTs, GPIOs, PWMs, etc

Clanlib: ClanLib is a medium level development kit. At its lowest level, it provides a platform independent way of dealing with display, sound, input, networking, files, threading, etc. Beyond that ClanLib builds a generic game development framework, giving you easy handling of resources, network object replication, graphical user interfaces (GUI) with theme support, game scripting and more. It lets game developers avoid lowlevel trivials like setting up a directdraw window, sound mixing, reading image files, etc. All those things are simplified into object oriented classes and function calls. ClanLib uses a resource system to keep track of images, fonts, samples and music. It supports Targa, PCX, JPEG, PNG and BMP for images; wave files for sample; and Ogg Vorbis and MikMod for music. The resource system separates physical data formats from your code, and makes it easy to make themes and other plugins for your game. All classes in clanlib focus on making simple interfaces that are customizeable and expandable. This keeps your game code clean and simple, but still lets you to do advanced work. ClanLib is object oriented, which lets you operate at both high and low levels, minimizing redundant code but still letting you do things not supported by clanlib's high level APIs.

Classpath: GNU Classpath (Essential Libraries for Java) is a project to create free core class libraries for use with virtual machines, compilers and tools for the Java programming language. It includes all native methods and core classes necessary for a completely functional Java runtime.s

Classpathx: The GNU Classpath Extensions project, aka classpathx builds packages in the javax namespace. It is a companion project of the GNU Classpath project. Packages currently under development include javabeans activation framework, javabean infobus, java mail, GNU inetlib and a servlet API.

ClearSilver: ClearSilver is a high-performance, powerful, and language-neutral HTML template system. It enforces a separation between presentation code and application logic which makes writing, debugging, and maintaining Web pages easier. It can be used from C/C++, Python, Perl, Java, and Ruby.

Cloudgizer: Cloudgizer is a tool for building web applications as Apache modules in C language enhanced with simple markup, with emphasis on performance, small-footprint, and more productive and safer programming in C. It combines the ease of scripting with the power of C, improving the resource utilization for cloud applications. The programmer writes simple markup language mixed with C code, which is then translated entirely into C code and compiled natively as Apache module. The resulting application is fast and takes less memory, as there are no interpreters or virtual machines. Features include easy markups to use MariaDB database, HTML input parameters, cookies, simpler outputting of web pages, files storage and manipulation, encryption, encoding, program execution, web calls, safer and easier string manipulation etc. - the list is too long to place in one sentence. Overall Cloudgizer does a lot of stuff for you that you'd otherwise need to do yourself. A memory garbage collection system and memory overwrite/underwrite detection comes in handy for program stability. The same goes for string and memory handling markups to help write applications that won't crash. Also included is an application packaging system and an automated application installer. This makes rollout of products and release cycle more manageable. Cloudgizer source files have extension .v. Cloudgizer pre-compiler (cld program) will turn your .v files into .c files, ready for compilation as pure C programs. Then, your program will be compiled and linked with Apache web server on RH/Centos systems. It links with Apache as an Apache module in a "prefork" configuration. It does the work of communicating with Apache, and it makes it easier to write high-performance/small-footprint web programs in C. Cloudgizer is not designed to be thread-safe as it works in a "prefork" configuration of Apache. You can also build command-line programs. The same program can serve as both command-line utility and a web program linked with Apache. Cloudgizer works with RedHat/Centos 7 operating system, Apache web server and mariaDB database.

CodePY

CodePy is a C/C++ metaprogramming toolkit for Python. It handles two aspects of native-code metaprogramming:

Generating C/C++ source code.
Compiling this source code and dynamically loading it into the Python interpreter.
Both capabilities are meant to be used together, but also work on their own. In particular, the code generation facilities work well in conjunction with PyCuda. Dynamic compilation and linking are so far only supported in GNU/Linux with the GNU toolchain.

CodeTools: The CodeTools project includes packages that simplify meta-programming and help the programmer separate data from code in Python. This library contains classes that allow defining simple snippets, or "blocks", of Python code, analyze variable dependencies in the code block, and use these dependencies to construct or restrict an execution graph. These (restricted) code blocks can then be executed in any namespace. However, this project also provides a Traits-event-enhanced namespace, called a "context", which can be used in place of a vanilla namespace to allow actions to be performed whenever variables are assigned or retrieved from the namespace. This project is used as the foundation for the BlockCanvas project.

Codebird-js: Use codebird-js to connect your website or JavaScript app with the Twitter API. Support for API 1.1 is baked in!

Coin: Coin is a platform-independent retained-mode 3D graphics library that uses scene-graph data structures to render real-time graphics+suitable for mostly all kinds of scientific and engineering visualization applications. It is fully compatible with Open Inventor 2.1. Coin is built on the OpenGL immediate-mode rendering library, adds abstractions for higher-level primitives, provides 3D interactivity, increases programmer convenience and productivity, and contains optimization features for fast +rendering that are transparent for the application programmer.

Commoncpp: Common C++ is a C++ class library that abstracts various system services in a portable manner, thereby making the creation of portable applications much easier. It is portable code, with very low runtime overhead, that works well on a very wide range of target platforms and C++ compilers in everyday use. It includes the 'ape' project, which was formerly a separate package. Common C++ manages threads, synchronization, and network sockets by offering portable C++ classes that abstract these services, as well as supporting "serial" I/O, daemon specific event logging, object serialization (persistence), block/record/page/ oriented file I/O, and configuration file parsing. It also provides an inheritable class architecture for your application that exploits C++ as needed. There are two source trees: one for "POSIX" systems such as GNU/Linux and the Hurd, the other for the Windows API. This makes Common C++ portable at the source level, as the two trees implement a functionally similar class interface. Commoncpp also includes uCommon C++, a lightweight C++ library with features such as rtti and exception handling removed. It is intended for programs linking to C libraries and not the standard C++ library.

Conexus

A generalized C++ I/O library that includes support for

BSD sockets (IPv4, IPv6, TCP, UDP)
OpenSSL secure streams
NSPR sockets
NSS secure streams
Kernel message queues
Files and pipes
Serial/tty
Gtkmm widgets
et. al.

Confuse: 'libConfuse' is a configuration file parser library. It supports sections and (lists of) values (strings, integers, floats, booleans or other sections), as well as other features (such as single/double-quoted strings, environment variable expansion, functions and nested include statements). It is easy to add configuration file capability to a program via a simple API. 'libConfuse' is not meant to be a configuration file parser library with a gazillion features; rather, it aims to be easy to use and quick to integrate with your code. 'libConfuse' was formerly called libcfg; the name was changed to avoid confusion with other similar libraries.

Coronet: The coronet library implements an epoll and coroutine based library that allows for async operations over certain kinds of files (any file that supports poll(2) and the O_NONBLOCK fcntl(2) flag can be hosted - like sockets, pipes, ...). The coronet library uses the epoll support available in the 2.6 series of Linux kernels, and the libpcl library for coroutine support.

Couchdb-python

This is a Python library for CouchDB. It provides a convenient high level interface for the CouchDB server. This package currently encompasses four primary modules:

couchdb.client: the basic client library
couchdb.design: management of design documents
couchdb.schema: a higher-lever API for mapping between CouchDB documents and Python objects
couchdb.view: a CouchDB view server that allows writing view functions in Python

CrackLib: A password checking library.

CreoleParser: Creoleparser is a Python library for converting Creole wiki markup for output on the web. It is a full implementation of the Creole 1.0 specification and aims to follow the spec exactly.

Crypton: Crypton is a software framework for remote storage, where the remote server has no knowledge of what is being stored. The content is encrypted client-side before it reaches the server. The framework is designed to be easy for application developers to use, without needing experience in encryption.

Cssutils: Partly implement the DOM Level 2 CSS interfaces. Additional some cssutils only convenience and (hopefully) more pythonic methods are integrated.

CsvUtils: Transformation utilities for csv (or csv-like) generated rows. The standard csv module is very useful for parsing tabular data in CSV format. Typically though, one or more transformations need to be applied to the generated rows before being ready to be used; for instance "convert the 3rd column to int, the 5th to float and ignore all the rest". This module provides an easy way to specify such transformations upfront instead of coding them every time by hand. Two classes are currently available, SequenceTransformer and MappingTransformer, that represent each row as a list (like csv.reader) or dict (like csv.DictReader), respectively.

CuTest: 'CuTest' is a unit tesing library for the C language whose tests ensure that your code keeps working as you make small changes in it. They tell you which subroutine is broken, so you can more quickly figure out what's broken. You can also keep adding to your old code without worrying about bad interactions: if there is a bad interaction the tests will catch it. Finally, if every time a bug is reported you write a quick test, you will guarantee that the bug never reappears.

Cuba: The Cuba library offers a choice of four independent routines for multidimensional numerical integration: Vegas, Suave, Divonne, and Cuhre. They work by very different methods, first three are Monte Carlo based. All four have a C/C++, Fortran interface and can integrate vector integrands. Their invocation is very similar, so it is easy to substitute one method by another for cross-checking. For further safeguarding, the output is supplemented by a chi-square probability which quantifies the reliability of the error estimate.

Curl: cURL is a command line tool for transferring data with URL syntax, supporting DICT, FILE, FTP, FTPS, Gopher, HTTP, HTTPS, IMAP, IMAPS, LDAP, LDAPS, POP3, POP3S, RTMP, RTSP, SCP, SFTP, SMTP, SMTPS, Telnet and TFTP. curl supports SSL certificates, HTTP POST, HTTP PUT, FTP uploading, HTTP form based upload, proxies, cookies, file transfer resume, user+password authentication (Basic, Digest, NTLM, Negotiate, kerberos...), proxy tunneling, and so on.
llibcurl
The client-side URL transfer library that the cURL command line tool uses to transfer data. In some distributions, this library is packaged separately.

CwMtx: 'CwMtx' provides the matrix and vector operations used in engineering and science problems, particularly the quaternion class which implements quaternion math. Quaternions are useful for attitude determination in 3D space because they do not suffer from singularities. Furthermore, successive rotations and transformations of vectors can be accomplished by simple quaternion multiplication. Attitude dynamics can be expressed in a very compact form using quaternions.

D3.js: JavaScript library for manipulating documents based on data. D3 helps you bring data to life using HTML, SVG and CSS. D3's emphasis on web standards gives you the full capabilities of modern browsers without tying yourself to a proprietary framework, combining powerful visualization components and a data-driven approach to DOM manipulation.

DSSI: DSSI is an API for audio plugins, with particular application for software synthesis plugins with native user interfaces. DSSI is an open specification developed for use in GNU/Linux audio applications, although it is portable to other platforms. It may be thought of as LADSPA-for-instruments, or something comparable to VSTi. This package contains the header file required for compiling hosts and plugins.

DUNE-Common

DUNE, the Distributed and Unified Numerics Environment is a modular toolbox for solving partial differential equations (PDEs) with grid-based methods. It supports the easy implementation of methods like Finite Elements (FE), Finite Volumes (FV), and also Finite Differences (FD). DUNE is free software licensed under the GPL (version 2) with a so called "runtime exception" (see license). This licence is similar to the one under which the libstdc++ libraries are distributed. Thus it is possible to use DUNE even in proprietary software. The underlying idea of DUNE is to create slim interfaces allowing an efficient use of legacy and/or new libraries. Modern C++ programming techniques enable very different implementations of the same concept (i.e. grids, solvers, ...) using a common interface at a very low overhead. Thus DUNE ensures efficiency in scientific computations and supports high-performance computing applications. DUNE is based on the following main principles:

Separation of data structures and algorithms by abstract interfaces.- This provides more functionality with less code and also ensures maintainability and extendability of the framework.
Efficient implementation of these interfaces using generic programming techniques.
Static polymorphism allows the compiler to do more optimizations, in particular function inlining, which in turn allows the interface to have very small functions (implemented by one or few machine instructions) without a severe performance penalty. In essence the algorithms are parametrized with a particular data structure and the interface is removed at compile time. Thus the resulting code is as efficient as if it would have been written for the special case.
Reuse of existing finite element packages with a large body of functionality.- In particular the finite element codes UG, ALBERTA, and ALUGrid have been adapted to the DUNE framework. Thus, parallel and adaptive meshes with multiple element types and refinement rules are available. All these packages can be linked together in one executable.
The framework consists of a number of modules which are downloadable as separate packages. The current core modules are:
dune-common- contains the basic classes used by all DUNE-modules. It provides some infrastructural classes for debugging and exception handling as well as a library to handle dense matrices and vectors.
dune-grid- is the most mature module. It defines nonconforming, hierarchically nested, multi-element-type, parallel grids in arbitrary space dimensions. Graphical output with several packages is available, e.g. file output to IBM data explorer and VTK (parallel XML format for unstructured grids). The graphics package Grape has been integrated in interactive mode.
dune-istl (Iterative Solver Template Library)- provides generic sparse matrix/vector classes and a variety of solvers based on these classes. A special feature is the use of templates to exploit the recursive block structure of finite element matrices at compile time. Available solvers include Krylov methods, (block-) incomplete decompositions and aggregation-based algebraic multigrid.

DUNE-Grid

Separation of data structures and algorithms by abstract interfaces.- This provides more functionality with less code and also ensures maintainability and extendability of the framework.
Efficient implementation of these interfaces using generic programming techniques.
Static polymorphism allows the compiler to do more optimizations, in particular function inlining, which in turn allows the interface to have very small functions (implemented by one or few machine instructions) without a severe performance penalty. In essence the algorithms are parametrized with a particular data structure and the interface is removed at compile time. Thus the resulting code is as efficient as if it would have been written for the special case.
Reuse of existing finite element packages with a large body of functionality.- In particular the finite element codes UG, ALBERTA, and ALUGrid have been adapted to the DUNE framework. Thus, parallel and adaptive meshes with multiple element types and refinement rules are available. All these packages can be linked together in one executable.
The framework consists of a number of modules which are downloadable as separate packages. The current core modules are:
dune-common- contains the basic classes used by all DUNE-modules. It provides some infrastructural classes for debugging and exception handling as well as a library to handle dense matrices and vectors.
dune-grid- is the most mature module. It defines nonconforming, hierarchically nested, multi-element-type, parallel grids in arbitrary space dimensions. Graphical output with several packages is available, e.g. file output to IBM data explorer and VTK (parallel XML format for unstructured grids). The graphics package Grape has been integrated in interactive mode.
dune-istl (Iterative Solver Template Library)- provides generic sparse matrix/vector classes and a variety of solvers based on these classes. A special feature is the use of templates to exploit the recursive block structure of finite element matrices at compile time. Available solvers include Krylov methods, (block-) incomplete decompositions and aggregation-based algebraic multigrid.

DUNE-ISTL

Separation of data structures and algorithms by abstract interfaces.- This provides more functionality with less code and also ensures maintainability and extendability of the framework.
Efficient implementation of these interfaces using generic programming techniques.
Static polymorphism allows the compiler to do more optimizations, in particular function inlining, which in turn allows the interface to have very small functions (implemented by one or few machine instructions) without a severe performance penalty. In essence the algorithms are parametrized with a particular data structure and the interface is removed at compile time. Thus the resulting code is as efficient as if it would have been written for the special case.
Reuse of existing finite element packages with a large body of functionality.- In particular the finite element codes UG, ALBERTA, and ALUGrid have been adapted to the DUNE framework. Thus, parallel and adaptive meshes with multiple element types and refinement rules are available. All these packages can be linked together in one executable.
The framework consists of a number of modules which are downloadable as separate packages. The current core modules are:
dune-common- contains the basic classes used by all DUNE-modules. It provides some infrastructural classes for debugging and exception handling as well as a library to handle dense matrices and vectors.
dune-grid- is the most mature module. It defines nonconforming, hierarchically nested, multi-element-type, parallel grids in arbitrary space dimensions. Graphical output with several packages is available, e.g. file output to IBM data explorer and VTK (parallel XML format for unstructured grids). The graphics package Grape has been integrated in interactive mode.
dune-istl (Iterative Solver Template Library)- provides generic sparse matrix/vector classes and a variety of solvers based on these classes. A special feature is the use of templates to exploit the recursive block structure of finite element matrices at compile time. Available solvers include Krylov methods, (block-) incomplete decompositions and aggregation-based algebraic multigrid.

Dajax: Dajax, the new easy to use ajax library for your django projects. All the power of ajax now available for django.

Database Template Library: The Database Template Library makes ODBC recordsets look just like STL containers. Users move through containers using standard STL iterators, and if they insert(), erase(), or replace() records in the containers, changes are automatically committed to the database. Since 'dtl' complies with STL iterator and container standards, users can plug abstractions into a range of STL algorithms for data storage, searching, and manipulation. The C++ reflection mechanism used to bind to database tables lets users add generic indexing and lookup properties to the containers without requiring special code. Since the code takes full advantage of the template mechanism, 'dtl' adds minimal overhead (compared with using raw ODBC calls).

DataparkSearch

DataparkSearch is an Internet and Intranet search engine tool. Key features:

Support for http, https, ftp, nntp and news URL schemes.
htdb virtual URL scheme support for indexing SQL databases.
text/html, text/xml, text/plain, audio/mpeg (MP3) and image/gif mime types built-in support.
External parsers support for other document types.
Ability to index multilangual sites using content negotiagion.
Searching all of the word forms using ispell affixes and dictionaries.
Stopwords and synonyms lists.
Boolean query language support.
Results sorting by relevancy, popularity rank, last modified time and by importance (a multiplication of relevancy and popularity rank).
Various character sets support.
Accent insensitive search.
Phrases segmenting for Chinese, Japanese, Korean, and Thai.
mod_dpsearch - search module for Apache web server.
Internationalized Domain Names support

Date Calc: The Date::Calc package consists of a C library and a Perl module (which uses the C library internally) for all kinds of date calculations based on the Gregorian calendar (the one used in all Western countries today), thereby complying with all relevant norms and standards: ISO/R 2015-1971, DIN 1355 and, to some extent, ISO 8601 (where applicable). The package is designed as a toolbox, not a ready-made application. It provides extensive documentation and examples of use, multi-language support, and special functions for business needs. The C library is specifically designed so that it can be used stand-alone, without Perl. Version 5.0 features date objects with overloaded operators, and a set of modules for calculations which take legal holidays into account (both in Perl only).

Dbug: dbug is a macro-based library to see program flow, variables, timings, errors, warnings, etc.

Dead Souls: The Dead Souls MUD Library is a multi-user, text based adventure creation system. It lets you build adventure games which can be played over the Internet simultaneously by many people. It is for both experienced and beginner MUD admins. It includes an easy-to-use creation system.

Deal.II: 'deal.II' is a software library that supports finite element computations on adaptive 1d, 2d, and 3d meshes. It comes with mesh handling, supports a large number of finite elements, can input and output in various formats, and has a large collection of support classes. The handling of different space dimensions is hidden behind C++ templates; this lets users treat problems in different space dimensions simultaneously within the same program, and to switch dimensions simply by recompilation. This means users can test their application in 2d, and then run production runs in 3d without having to debug the program again. It comes with full documentation of all APIs and 18 example programs showing how to build finite element programs from simple to very complex. The documentation now runs about 4000 pages.

Debea Database Library: Debea is an Object Relational Mapping library (ORM) for C++. It allows you to map C++ objects to relations in various SQL and file databases.

Decibel: Decibel is a realtime communication framework based on Telepathy. It is meant to integrate VoIP, text chat, CTI (computer telephone integration), and similar applications into the user's desktop. Decibel consists of a desktop neutral policy daemon called Houston and desktop specific components for user interaction.

Deliantra Archetypes: Deliantra is a free software cooperative multiplayer RPG and adventure game, much similar in style (and setting) to nethack and moria, but is fully graphical and runs in realtime. It is set in a classical medieval environment with ubiquitous weapons and magic. What makes this game special is its depth and the sheer amount of maps to explore: The world is vast (multiple continents, over 4000 manually designed maps, hundreds of monsters and countless variations of generated content) and complex (16 unique races, 17 classes, 40 skills and hundreds of spells to choose from and combine with each other), so there is a lot to explore. The game play is open and sets very few limits on character development. And of course a lot of fun is to be had by playing cooperatively with others exploring the same world.

Detect: 'detect' can be used in any program that needs hardware detection features such as configuration tools, installation programs, etc. You can use it to detect sound cards, CPUs, networking devices, webcams, joysticks, etc. It scans the IDE, PCI, ISA, USB, and SCSI busses to find hardware.

Developer's Image Library: Developer's Image Library (DevIL) is a cross-platform image library utilizing a simple syntax to load, save, convert, manipulate, filter, and display a variety of images with ease.

Device-Cdio: Device::Cdio is a interface to the GNU CD Input and Control library (libcdio) and it's ISO 9660 library (libiso9660) which are written in C. The library encapsulates CD-ROM reading and control and ISO 9660 handling. Perl programs wishing to be oblivious of the OS- and device-dependent properties of a CD-ROM can use this library.

DiVinE: DiVinE is an extensible system for distributed formal verification of concurrent systems. DiVinE as such can be viewed from two very different points of view: as a tool for distributed state space analysis and LTL model-checking, and as a development and fast prototyping environment.

DiaCanvas2: DiaCanvas2 is a flexible diagramming widget based on GnomeCanvas. It uses its own constraint solver to maintain object relationships. It is Model/View/Controller-based and makes full use of GnomeCanvas' features, and can rotate/shear/resize/etc objects without recalculating shapes. It includes export facilities for both GnomePrint and SVG. Except for its look and feel, DiaCanvas is not related to the diagramming tool DIA.

Diet libc: Diet libc is a C library that is optimized for small size. It has has the bare minimum of files: the system call wrappers (including socket stuff) and malloc, etc. to create small statically linked binaries under Sparc, x86, PPC, ARM, MIPS, and Alpha-Linux.

Dimnum: The dimnum library contains templated C++ classes for storage and manipulation of dimensionful numbers, as encountered in physics and engineering. Since it uses templates, there is no size or speed penalty with respect to normal variables (depending on compiler optimisations).

DirectFB: 'DirectFB' is a thin library that provides developers with hardware graphics acceleration, input device handling and abstraction, an integrated windowing system with support for translucent windows and multiple display layers on top of the framebuffer device. It is a complete hardware abstraction layer with software fallbacks for every graphics operation that is not supported by the underlying hardware.

Dmbcs-kraken-api: Kraken is a virtual currency exchange, which also handles fiat (real) currency amounts. Subscribers to the service have an account with associated funds attached. The web site (www.kraken.com) provides the user with an account overview (i.e. current balance), currency-pair exchange market status (history of prices and current order book), and the means to place entries on the order book; bids for a currency which can be immediately met with orders to sell the currency are automatically transacted, with the Kraken site taking a small and variable cut of the deal. Kraken also provide a stateless, web-based API by which all of the above actions can be undertaken programmatically. This is fully open, and described at the Kraken exchange web site. The DMBCS client-side C++ library implements all features of the API in a fully encapsulated C++ class, allowing users to implement algorithmic or robotic trading and dynamic exchange modelling.

Doodle: Doodle quickly searches the documents on a computer, then builds an index using meta-data contained in the documents and allows fast searches on the resulting database. It supports approximate searches and full-text indexing, and comes with a library for accessing the doodle database and making it easy to integrate doodle's functionality into other applications or user interfaces. Users can keep the doodle database always up-to-date by updating the database on-the-fly by using 'doodled' and 'fam' whenever files on the system change. They can also build one doodle database for all users on a multi-user system without compromising user privacy.

Duktape

Duktape is easy to integrate into a C/C++ project: add duktape.c, duktape.h, and duk_config.h to your build, and use the Duktape API to call ECMAScript functions from C code and vice versa.

Main features

Embeddable, portable, compact: can run on platforms with 160kB flash and 64kB RAM
ECMAScript E5/E5.1, with some semantics updated from ES2015+
Partial support for ECMAScript 2015 (E6) and ECMAScript 2016 (E7), see Post-ES5 feature status and kangax/compat-table
ES2015 TypedArray and Node.js Buffer bindings
CBOR bindings
Encoding API bindings based on the WHATWG Encoding Living Standard
performance.now()
Built-in debugger
Built-in regular expression engine
Built-in Unicode support
Minimal, retargetable platform dependencies
Combined reference counting and mark-and-sweep garbage collection with finalization
Coroutines
Property virtualization using a subset of ECMAScript ES2015 Proxy object
Bytecode dump/load for caching compiled functions
Distributable includes an optional logging framework, CommonJS-based module loading implementations, etc
Liberal license (MIT)

Duro

The goal of the Duro project is to create a library which is as compliant with the proposed database language D as it is possible for a C library. This library is supposed to serve as a basis for a truly relational database management system (TRDBMS).

Tuples and tables (relvars).
Relational algebra: RENAME, select (restrict), project, EXTEND, JOIN, SEMIJOIN, UNION, INTERSECT, MINUS, SEMIMINUS, SUMMARIZE PER, DIVIDEBY PER, WRAP, UNWRAP, GROUP, and UNGROUP.
Virtual tables (views).
Locking and nested transactions.
Duro tables are true sets -- uniqueness of tuples (rows) is always enforced. When creating real tables, at least one candidate key must be supplied. A candidate key may be empty.
User-defined types (including type constraints) and operators.
Declarative integrity.
Tcl interface, including support for relational expressions in Tutorial D syntax and operators implemented in Tcl ("stored procedures").
Simple GUI admin tool.

xs Duro is implemented on top of the Berkeley DB database library.

DynObj

DynObj is a C/C++ library for cross compiler plugin libraries. It enables exposing and sharing run-time type information for C++ classes. This allows for loading binary plugins, and interacting with them in type safe ways:

A program working with sound can install additional effect filters while running.
A file manager can add plugins that handles new archive types.
Or it can add file popup menu handlers, or toolbar commands from plugins.
A text editor can add an editing mode (say Python editing) when the text editor is running.
So, plugins can make a static application a lot more dynamic. And DynObj does this in a generic, type safe way.

EHS: The Embedded HTTP Server (EHS) is a C++ class which can be inherited from to give HTTP server functionality to any class or application. It supports form data via POST or GET, and uploads via multi-part form attachments. It is useful for adding Web-based administration or statistics to any C++ program.

EMAN: EMAN is a scientific image processing suite designed mainly to perform single-particle reconstructions of individual molecules. In this method, a transmission electron microscope is used to collect images of thousands of individual molecules. A complex series of algorithms then turns the individual 2D images into a high-resolution 3D structure of the molecule. The core of EMAN is a C++ based scientific image processing library.

EMI TOC Generator: eMI TOC Generator is a simple cross-platform library that dynamically generates a table of contents (TOC) in an HTML 5 page on rendering.

EMI User Controls Library: eMI User Controls Library is a library for the .NET Framework that provides a closeable tab item for the tab control of the Windows Presentation Framework (WPF) and a file system browser window.

EMI eMailer: eMI eMailer is a simple cross-platform object-oriented SMTP client implemented in PHP. It is primarily intended to transfer MIME e-mail messages generated by PHP on the same host as the SMTP server of the sender.

ETS- Enthought Tool Suite: The Enthought Tool Suite (ETS) is a collection of components developed by Enthought and our partners, which we use every day to construct custom scientific applications. This project is a "meta-project wrapper" that bundles up all the other projects in ETS.

EXcavator: eXcavator is an XML query processing class for PHP. Queries are constructed using a small query language, and query results are returned as either loosely formed or strict XML, in formats suitable for both text and HTML. One of eXcavator's most useful features is its facility to insert query results into user-defined templates, which allow for a free interpolation of user text and the data extracted by the query. It runs on top of XML_PullParser, but uses a completely independent API. However, it does offer opportunities to use the facilities of both packages side by side for programmers familiar with both.

EZWGL: EZwgl is a library of C functions, based on Xlib, whose purpose is to provide a tool that simplifies the task of graphical user interface (GUI) programming under the X window system environment. It is best for building a nice graphical user interface for an application, or for graphics programming under the X window system programming environment. EZWGL supports application resources, geometry management and drag-and-drop. It also includes about 100 OpenGL(TM)-like graphics functions and procedures that provides high level support for 3D graphics, including features like zbuffer, double-buffer and lighting.

Easyval: 'Easyval' is a basic implementation of interval arithmetic that uses hardware doubles as interval bounds. The first goal of this library is to respect the interval arithmetic containment criterium.

Ecc: 'ecc' is a class library for working with elliptic curves in cryptography. It consists of a set of TCP/IP client server examples for digital signature, encryption, and key exchange (such as Diffie-Hellman key exchangei, Massey Omura encryption, or DSA style signatures in the elliptic curve case).

Edlib: Lightweight, super fast C/C++ library for sequence alignment using edit distance.

Edma: EDMA is library that implements several object oriented features in plain C. The GNU/EDMA system is a framework designed to provide object oriented programming and component based features to generic applications, despite of the underlying programming language. The system is physically a library plus a set of language bindings that provides a development environment and a set of functions for object-oriented programming and component-based development. Its name is an acronym for Entorno de Desarrollo Modular y Abierto.

Elektra: Elektra is a configuration management framework, it mounts configuration files into global keys database creating sort of virtual file system for easier access, changing and locating the configuration parameters. A wide range of plugins is available used to specify format (JSON, INI, XML and others), default settings , validation, etc. Use High-level API to elektrify your application for easier maintenance and generate type-safe configuration access code based on same specification used for validation. The core is the library implemented in C, bindings to another languages are provided.

Element Tree: The Element type is a simple but flexible container object, designed to store hierarchical data structures, such as simplified XML infosets, in memory. The element type can be described as a cross between a Python list and a Python dictionary. The ElementTree wrapper type adds code to load XML files as trees of Element objects, and save them back again. The Element type is available as a pure-Python implementation for Python 1.5.2 and later. A C implementation is also available, for use with CPython 2.1 and later. The core components of both libraries are also shipped with Python 2.5 and later.

Elib

Elib is designed as a collection of useful routines that don't have to be reinvented each time a new program is written. It contains code for container data structures, minibuffer and string handling functions missing in standard GNU Emacs, and routines for handling lists of cookies in a buffer.

Elib has been decommissioned as a separate package since its useful functions have long since been included in Emacs.

Emacs Common Lisp: Emacs Common Lisp is an implementation of Common Lisp, written in Emacs Lisp. The implementation provides a Common Lisp environment, separate from Emacs Lisp, running in Emacs. It does not intend to extend Emacs Lisp with Common Lisp functionality; however, Emacs Lisp functions can call Common Lisp functions and vice versa.

Enca: 'Enca' (Extremely Naive Charset Analyser) detects the encoding of text files, based on knowledge of their language. It can also convert them to other encodings, letting you to recode files without knowing their current encoding. It supports most of Central and East European languages, and a few Unicode variants, independently of language.

Enlightenment: Enlightenment is a themeable, fast, flexible, and powerful window manager that runs on everything from small mobile devices to powerful multi-core desktops. The Enlightenment Foundation Libraries (EFL) comprise a suite of libraries to help you create beautiful user interfaces.

EnthoughtBase

* " This package has now been DEPRECATED since ETS 4.0. These functionalities have now been moved into other projects: 'etsconfig' is now part of traits, 'logger' is now part of apptools and 'util' is now part of pyface, and other packages. The etsproxy project allows you to run code that relied on this package or to convert source code to the new namespace with the 3to4 utility. " The EnthoughtBase project includes a few core packages that are used by many other projects in the Enthought Tool Suite:

etsconfig: Supports configuring settings that need to be shared across multiple projects or programs on the same system. Most significant of these is the GUI toolkit to be used. You can also configure locations for writing application data and user data, and the name of the company responsible for the software (which is used in the application and user data paths on some systems).
logger: Provides convenience functions for creating logging handlers.
util: Provides miscellaneous utility functions.

Epeios: The purpose of this project was to develop a framework to make powerful, reliable software components that could be used whatever the target platform, the environment or the interface in use. The project source code currently contains useful applications and undocumented related libraries. Among all the software components available, there is, for example, MMUAq, an application which allows to handle several mail accounts as a global one. As each one, it is based on the Epeios framework.

Ephemeris: 'Ephemeris' reads, writes, and interpolates the JPL planetary ephemeris data that is the world standard planetary dataset. It should compile on any machine that uses gcc and supports IEEE floating point arithmetic, and has been tested under GNU/Linux. It uses an included library, gnulliver.c, that automatically handles integer and floating point Big-endian/Little-endian byte swapping to match Big-endian/network order on any computer. gnulliver.c can be used separately under the LGPL 2.1. This is a redesign of JPL's original FORTRAN code, available on JPL's FTP website (ftp://ssd.jpl.nasa.gov/pub/eph/export/), with some added flexibility (including patching some inconsistencies in the original JPL data files). 'Ephemeris' is not associated with JPL or NASA, but just uses JPL's data.

Epix: 'ePiX', a collection of batch programs, creates mathematically accurate fgures, plots, and animations containing LaTeX typography. The input syntac is easy to learn. The output -- vector image files or LaTeX picture-like environments -- is expressly designed for use with LaTeX.

Epto: 'epto' is a library for industrial strength shell script programming with sh. It features convenient error handling, tracing, logging, option handling, documentation template, process level transaction safety (sort of), and more. It takes less than five minutes of learning to start using it.

ExactImage: ExactImage is a fast C++ image processing library. Unlike ImageMagick, it allows operation in several color spaces and bit depths natively, resulting in much lower memory and computational requirements. Some optimized algorithms operate in 1/20 of the time ImageMagick requires, and displaying large images can be as fast as 1/10 of the time the "display" program takes.

Experimental Robotics Framework: The Experimental Robotics Framework is a framework for developing composable applications. The idea is to develop software components that interact with others previously developed in other applications and other components developed by other researchers. It is not a new concept in the field, it is very similar to IBM eclipse but in this case for 3d applications and based on C++ instead of Java.

FAM: FAM, the File Alteration Monitor, provides an API which applications can use to be notified when specific files or directories are changed. It comes in two parts: fam, the daemon which listens for requests and delivers notification, and libfam, a library which client applications can use to communicate with fam

FANN: Fast Artificial Neural Network Library (fann) implements multi-layer feedforward networks that support both fully connected and sparsely connected networks. It supports execution in fixed point arithmetic to allow for fast execution on systems with no floating point processor. To overcome the problems of integer overflow, the library calculates a position of the decimal point after training and guarantees that integer overflow cannot occur with this decimal point. FANN is designed to be fast, versatile, and easy to use. Several benchmarks have been executed to test its performance. It is significantly faster than other libraries on systems without a floating point processor, and comparable to other highly optimized libraries on systems with a floating point processor.

FINAL CUT: The FINAL CUT is a C++ class library and widget toolkit with full mouse support for creating a text-based user interface. The library supports the programmer to develop an application for the text console. It allows the simultaneous handling of multiple text windows on the screen. The structure of the Qt framework was originally the inspiration for the C++ class design of FINAL CUT. It provides common controls like dialog boxes, push buttons, check boxes, radio buttons, input lines, list boxes, status bars and so on.

FLIF: FLIF is a novel lossless image format which outperforms existing image formats in terms of compression ratio. It works well on any kind of image (photographic, line art, computer graphics, etc.) and also supports animations. FLIF images (or animations) can be progressively decoded, which makes the format potentially very suitable for responsive web design. This is the reference implementation of FLIF, which includes a command-line tool (flif) to convert between FLIF and PNG/PNM/PAM, a decoding library (libflif_dec), an encoding library (libflif_enc), some scripts (gif2flif, apng2flif, raw2flif, ...), and a simple image/animation viewer (viewflif).

FXT: 'FXT' is a C++ library containing code for various fast orthogonal transforms and related algorithms for real, complex, n-dim fourier transforms, hartley transform, 1dim and 2dim, number theoretic transforms, walsh, haar, and wavelet transforms, convolution, correlation and power spectrum, mass-storage FFTs and convolution, fast multiplication routines, sine and cosine transforms, and z-transform.

Farstream: The Farstream (formerly Farsight2) project is an effort to create a framework to deal with all known audio/video conferencing protocols. On one side it offers a generic API that makes it possible to write plugins for different streaming protocols, on the other side it offers an API for clients to use those plugins. This package provides Python bindings for Farstream.

Fast rendering toolkit: FRT is a toolkit for the generation of 3D animations using low-end machines (slow CPUs, low memory and small harddisks); of course, you can still use it with higher-end machines. The program is simple; the whole library is about 1000 lines of code. FRT has been designed with a *NIX-like operating system in mind: to avoid filling the harddisk, FRT establishes a master/slave relationship with mpeg_encode and renders frames on demand.

Fastclick: The aim is to make your application feel less laggy and more responsive while avoiding any interference with your current logic. FastClick is developed by FT Labs, part of the Financial Times.

Fftw: C subroutine library for computing the Discrete Fourier Transform in one or more dimensions, of both real and complex data, and of arbitrary input size. The FFTW team's benchmarks, performed on a variety of platforms, show that FFTW's performance is typically superior to that of other publicly available FFT software. Moreover, FFTW's performance is portable: the program will perform well on most architectures without modification. However, FFTW appears to be the fastest program most of the time for in-order transforms, especially in the multi-dimensional and real-complex cases.

FireDNS: This is a candidate for deletion: Links broken. No links to page. Email to maintainer broken. Poppy-one (talk) 12:09, 30 July 2018 (EDT) 'libfiredns' is a library for handling asynchronous DNS requests. It provides a very simple interface for sending requests and parsing reponses, as well as low-timeout blocking functions. 'libfiredns' functions have much lower timeouts than the stock functions and tend to be faster because they send requests to all configured system nameservers at the same time.

FireString: This is a candidate for deletion: Links broken. No links to page. Email to maintainer broken. Poppy-one (talk) 12:18, 30 July 2018 (EDT) FireString is a library to make string handling easier in C. It provides replacements for some non-ANSI libc string functions, binary and length-safe string functions, and an interface for easy, intelligent configuration file parsing.

Firehose: Firehose is a simple library which stripes multiple, inexpensive, network devices to provide very high speed data transfers. It will support any number of devices as long as each device has a TCP/IP layer.

Flate: This is a candidate for deletion: Links broken. No links to page. Email to maintainer broken. Poppy-one (talk) 03:41, 31 July 2018 (EDT) Flate is a template library used to deal with HTML code in CGI applications. It includes C and Perl support. All HTML code is put in an external file (the template) and printed using the library functions: variables, zones (parts to be displayed or not), and tables (parts to be displayed 0 to n times). You don't need to modify/recompile your application when modifying HTML code, printing order doesn't matter in your CGI code, and your CGI code is cleaner.

Fontconfig

fontconfig is a library for customizing and configuring fonts in a system, providing configuration, enumeration and substitution of fonts to other programs. Applications can use fontconfig in two ways:

by querying it for the available fonts on the system, or
by querying it for a font matching certain parameters (comprising a pattern) as closely as possible.

To perform font matching, fontconfig stores typesetting information about all of the installed fonts, including the name of the font family, style, weight, dots per inch (DPI), and Unicode coverage. This information is also used to perform font substitution.

Features

fontconfig can:

discover new fonts when installed automatically, removing a common source of configuration problems.
perform font name substitution, so that appropriate alternative fonts can be selected if fonts are missing.
identify the set of fonts required to completely cover a set of languages.
have GUI configuration tools built as it uses an XML-based configuration file (though with autodiscovery, we believe this need is minimized).
efficiently and quickly find the fonts you need among the set of fonts you have installed, even if you have installed thousands of fonts, while minimizing memory usage.
be used in concert with the X Render Extension and FreeType to implement high quality, anti-aliased and subpixel rendered text on a display.

fontconfig does not:

render the fonts themselves (this is left to FreeType or other rendering mechanisms)
depend on the X Window System in any fashion, so that printer only applications do not have such dependencies

Fontutils: The GNU Font Utilities (a.k.a. Fontutils) create fonts for use with Ghostscript or TeX. They also contain general conversion programs and other utilities. Some of the programs in Fontutils include bpltobzr, bzrto, charspace, fontconvert, gsrenderfont, imageto, imgrotate… The main purpose of these programs is to form a tool chain to generate Metafont or PostScript fonts from scanned images.

Form Alchemy: FormAlchemy eliminates boilerplate by autogenerating HTML input fields from a given model. FormAlchemy will try to figure out what kind of HTML code should be returned by introspecting the model's properties and generate ready-to-use HTML code that will fit the developer's application. Of course, FormAlchemy can't figure out everything, i.e, the developer might want to display only a few columns from the given model. Thus, FormAlchemy is also highly customizable.

FreeLing

The FreeLing package consists of a library providing language analysis services. FreeLing is designed to be used as an external library from any application requiring Natural Language Processing services (machine translators, intelligent web searchers, automatic summarizers, NL interfaces, etc.) Also, a simple main program is also provided as a basic interface to the library, which enables the user to analyze text files from the command line. Current version analyzes text in English, Spanish, Catalan, Galician, and Italian. New languages can be easily added if linguistic data are available.

Features:
Text tokenization
Sentence splitting.
Morphological analysis.
Named entity detection.
Date/number/currency/ratios recognition.
Physical magnitudes detection (speed, weight, temperature, density, etc.)
PoS tagging.
Named entity classification.
Chart-based shallow parsing.
WordNet based sense annotation
Dependency parsing.

Freecell Solver: Freecell Solver is a library written in C, that automatically solves layouts of Freecell and similar Solitaire variants (including Simple Simon boards). It is accompanied by several stand-alone command line programs.

Freeipmi: FreeIPMI is a collection of in-band and out-of-band IPMI software in accordance with the IPMI v1.5/2.0 specification. These programs provide a set of interfaces for platform management. Common functionality includes sensor monitoring, system event monitoring, power control and serial-over-LAN.

FtpUtil: ftputil is a high-level FTP client library for the Python programming language. ftputil implements a virtual file system for accessing FTP servers, that is, it can generate file-like objects for remote files. The library supports many functions similar to those in the os, os.path and shutil modules. ftputil has convenience functions for conditional uploads and downloads, and handles FTP clients and servers in different timezones.

FuzzPy: Library for fuzzy sets, fuzzy graphs, and general fuzzy mathematics for Python.

G-golf ,: GNU G-Golf (GNOME: (Guile Object Library for)) G-Golf is a tool to develop fast and feature-rich graphical applications, with a clean and recognizable look and feel. Here is an overview of the GNOME platform libraries, accessible using G-Golf. In particular, libadwaita provides a number of widgets that change their layout based on the available space. This can be used to make applications adapt their UI between desktop and mobile devices. The GNOME Web (best known through its code name, Epiphany, is a good example of such an adaptive UI. G-Golf uses Glib, GObject and GObject Introspection. As it imports a Typelib (a GObject introspectable library), G-Golf defines GObject classes as GOOPS (the Guile Object Oriented System) classes. GObject methods are defined and added to their corresponding generic function. Simple functions are defined as scheme procedures.

G-wrap: 'G-Wrap' is a tool (and Guile library) for generating function wrappers for inter-language calls. It currently supports generating Guile wrappers for C functions.

GAIL: 'GAIL' is a GTK+ module that provides accessibility support for GTK+ and libgnomecanvas by implementing AtkObjects for widgets in the two libraries. For example, if the module is loaded in a program which calls gtk_widget_get_accessible() for a GtkEntry, an instance of GailEntry is returned. This module is normally used with the atk-bridge GTK+ module from at-spi to allow an assistive technology, e.g a screenreader, to query or drive the program.

GAUL: The Genetic Algorithm Utility Library (GAUL) is a programming library designed to assist in the development of code requiring genetic algorithms. The steady-state, generation based and the island model of evolution are supported, using the Darwinian, Lamarkian or Baldwininan evolutionary schemes. Standard mutation, crossover and selection operators are provided, while code hooks additionally allow custom operators. It provides data structures and functions for handling and manipulation of the data required for a genetic algorithm. Additional stochastic algorithms are provided for comparison to the genetic algorithms. Much of the functionality is also available through a simple S-Lang interface.

GDL: The Gnu Data Language (GDL) is a free alternative to the data visualization and analysis tool, called IDL (Interactive Data Language), frequently used by scientists. GDL and its library routines are designed as a tool for numerical data analysis and visualisation. GDL is dynamically typed, vectorized and has object-oriented programming capabilities. The library routines handle numerical calculations, data visualisation, signal/image processing, file input/output (incl. graphical and scientific data formats such as TIFF, PNG, netCDF, HDF etc) and interaction with host OS. Despite its name, GDL is not a GNU package.

GDSL: The Generic Data Structures Library (GDSL) is a collection of routines for generic data structures manipulation. It is a portable and re-entrant library designed to let C programmers access common data structures with powerful algorithms and hidden implementation. Available structures are lists, queues, stacks, hash tables, binary trees, binary search trees, red-black trees, 2D arrays, and permutations.

GEGL: GEGL is a graph-based image processing framework offering non-destructive image processing and compositing on large images. It is suitable for projects ranging from small one-off projects to interactive applications.

GEOS: 'GEOS' is a C++ implementation of the functions and predicates defined in the OpenGIS "Simple Features for SQL" specification. It includes high quality implementations of all important spatial relationships and operations, robust versions of all functions in the dimensionally extended 9 intersection predicate model, and implementations of the operators Buffer(), Union(), and Intersection() and all other SFSQL functions including Area(), Length(), Centroid(), etc.

GGZ Gaming Zone: The GGZ Gaming Zone develops a free gaming environment, based on a client-server architecture. More than 20 games are already available directly from the project, and integration into the major free desktops like KDE and GNOME is also being done. Player privacy, lack of advertisements and source code availability for game routine verification make this project a reliable platform for free games. Several independent game projects do already support playing over GGZ.

GJrand: A programmer's library for random numbers. Also random number generator testing code. Intended for simulation, games and "Monte-Carlo" algorithms.

GLTT: 'GLTT' is a library that allows you to read and draw TrueType fonts in any OpenGL application. It supports bitmapped and anti-aliased font drawing as well as vectorized and polygonized drawing.

GMM: The Guarded Memory Move tool is useful for studying buffer overflows and catching them together with a "good" stack image. Once a stack overflow has been exploited, the back trace is already gone, as is information about parameters and local variables that are very important in understanding how the attacker is working out the exploit. The GMM library uses dynamic function call interception to catch the most common functions that attackers use to exploit stack buffers. It uses the LD_PRELOAD capability and offers two services: first, it avoids buffer overflow to allow the attacker to execute shell-code on your machine. Second, where an exploit is detected, it saves the stack content and triggers a segmentation fault. The resulting core dump has the necessary information to debug the exploit and fix the software.

GNUe Common Library: GNUe Common Library is the basis for the GNUe tools, such as Forms, Reports, Application Server, and Designer. It implements a database-abstraction layer that provides support for most major databases. A builtin XML-to-Object parser and Object-to-XML marshaller are used by Forms, Reports, and Designer to save and read Forms/Report definitions to and from an XML file. It also defines and implements an RPC abstraction layer that will allow server processes to define their public methods once and have them available XML-RPC and Pyro clients.

GNUe Forms: GNUe Forms is a generator for data aware user interfaces with support for different platforms and data sources. From an XML file containing both the layout definition and the program logic required, GNUe Forms generates native interactive data entry screens for a number of user interface frameworks, including GNOME, KDE, and a curses based text interface. GNUe Forms can interact with all data sources supported by GNUe Common, which includes GNUe AppServer, SQLite, MySQL, Firebird, PostgreSQL, MaxDB, or plain CSV files.

GOffice: GOffice is a library of document-centric objects and utilities building on top of GLib and Gtk+ and used by software such as Gnumeric.

GPGME: GnuPG Made Easy (GPGME) is a library designed to make access to GnuPG easier for applications. It provides a High-Level Crypto API for encryption, decryption, signing, signature verification and key management. Currently it uses GnuPG as its backend but the API isn't restricted to this engine; in fact, there is already a backend for CMS (S/MIME).

GPStk: 'GPSTk' is a set of both fundamental and advanced GPS processing algorithms. The library provides functions including RINEX I/O, ephemeris calculation, atmospheric refraction models, and positioning algorithms. The applications include cycle slip detection and removal, calculation of the Total Electron Content (TEC) of the ionosphere, bindings to 'octave', and RINEX file manipulation.

GRX: GRX is a 2D graphics library originally written for DJGPP. It supports DOS, GNU/Linux console (svgalib and framebuffer drivers), X11, and Win32 (using the Mingw compiler).

GSOAP: gSOAP is a toolkit for web services development. It includes utilities for conversion of C/C++ header files to SOAP stubs and generating C/C++ header files from WSDL. Also included are C/C++ development files needed for building SOAP client and server applications. gSOAP implements most current standards including SOAP 1.1/2, WSDL 1.1 and UDDI 2. It is compatible with many popular SOAP implmentations.

GStreamer-Editor: The GStreamer Pipeline Editor (gst-editor) is a graphical pipeline contruction and manipulation tool. Using the Gnome Canvas as the foundation, it lets users draw media pipelines very quickly. It's written as a library, so it can easily be embedded into applications, and reads and writes standard XML descriptions of pipelines. Additionally, it is threadsafe, supports rapid prototyping, has iterative, graphical bin sorting functionality, and is integrated with GStreamer's debugging subsystem.

GTS: The GNU Triangulated Surface Library (GTS) provides a set of useful functions to deal with 3D surfaces meshed with interconnected triangles. It features metric operations (area, volume, curvature, etc.), 2D Delaunay and constrained Delaunay triangulations, robust geometric predicates and set operations on surfaces (union, intersection, etc.), surface refinement and coarsening (multiresolution models), and bounding-boxes trees for collision/intersection detection.

GUASI: The GUASI library implements a thread based generic asyncronous execution engine, to be used to give otherwise syncronous calls an asyncronous behaviour. It can be used to wrap any syncronous call, so that it can be scheduled for execution, and whose result can be fetched at later time (hence not blocking the submitter thread). The GUASI library can be used as complement to standard event retrieval interfaces like poll(2), select(2) or epoll(4).

Gama: Gama is a program for the adjustment of geodetic networks. It is useful in measurements where Global Positioning System (GPS) is not available, such as underground. It features the ability to adjust in local Cartesian coordinates as well as partial support for adjustments in global coordinate systems. Network adjustment in a local coordinate system and its functionality is represented by the program gama-local, which adjusts geodetic (free) networks of observed distances, directions, angles, height differences, 3D vectors and observed coordinates (coordinates with given variance-covariance matrix). Global coordinate network adjustment model is based on geocentric coordinate system (adjustment model on ellipsoid). Its functionality is represented by the program gama-g3.

GapBuffer: Gap buffers are efficient mutable sequences that are often used to store text in text editors. They utilize locality of modification to avoid copying large amounts of data and allocate extra elements to avoid memory allocation dominating performance.

Gconf: GConf is a "registry" system, a library applications can use to store key-value pairs persistently. It's written for GNOME, but it does not require GNOME or even X to work. Use outside GNOME is encouraged and will be supported.

Gdbm: GDBM is a library for manipulating hashed databases. It is used to store key/value pairs in a file in a manner similar to the Unix dbm library and provides interfaces to the traditional file format. This is a GNU package.

Gdome2: Gdome2, aka libgdome, is the DOM C library developed for the Gnome project (it can also be used stand-alone). The Document Object Model is a platform and language-neutral interface that lets programs and scripts dynamically access and update the content, structure and style of documents. A DOM implementation (also called a host implementation) takes a parsed XML or HTML document and makes it available for processing via the DOM interfaces. A browser contains a host implementation, for example. gdome2 currently supports the "Core", "XML", "Events" and "MutationEvents" modules.

Gearman: Gearman client, worker, and server libraries for Python.

Gecode: Gecode is an open, free, portable, accessible, and efficient environment for developing constraint-based systems and applications. It is written in C++.

Geniustrader

GeniusTrader aims to be a full featured toolbox to create trading systems. Powerful systematic trading requires several things:

many indicators and corresponding signals
money management rules
- deciding what is a reasonable amount of money to put on a single trade (to limit the risk associated to that trade)
- combining different values within the portfolio (to limit the global risk)

flexibility to be able to test all
combinations with the above items
backtesting system with analysis of results

GeniusTrader already has support of most of this. GeniusTrader consists of a bunch of Perl modules associated to a few perl scripts.

Genshi: Genshi is a Python library that provides an integrated set of components for parsing, generating, and processing HTML, XML or other textual content for output generation on the web. The main feature is a template language that is smart about markup: unlike conventional template languages that only deal with bytes and (if you're lucky) characters, Genshi knows the difference between tags, attributes, and actual text nodes, and uses that knowledge to your advantage.

Gettext: Gettext is a package providing a framework for translating the textual output of programs into multiple languages. It provides translators with the means to create message catalogs, and a runtime library to load translated messages from the catalogs. Nearly all GNU packages use Gettext.

Gexiv2: GExiv2 is a GObject wrapper around the Exiv2 photo metadata library. It allows for GNOME applications to easily inspect and update EXIF, IPTC, and XMP metadata in photo and video files of various formats. This package contains the shared library.

Ghostscript: Ghostscript is an interpreter for the PostScript language and the PDF file format. It also includes a C library that implements the graphics capabilities of the PostScript language. It supports a wide variety of output file formats and printers.

Giac: Giac/Xcas is a free computer algebra system. It has a compatibility mode for maple, mupad and the TI89. It is available as a standalone program (graphic or text interfaces) or as a C++ library.

Giflib: giflib is a library for reading and writing gif images. It is API and ABI compatible with libungif which was in wide use while the LZW compression algorithm was patented.

GitPython: GitPython is a python library used to interact with Git repositories. GitPython provides object model access to your git repository. Once you have created a repository object, you can traverse it to find parent commit(s), trees, blobs, etc. GitPython is a port of the grit library in Ruby created by Tom Preston-Werner and Chris Wanstrath.

Gksu: GKSu is a library that provides a Gtk+ frontend to su and sudo. It supports login shells and preserving environment when acting as a su frontend. It is useful to menu items or other graphical programs that need to ask a user's password to run another program as another user.

Glade: Glade is a rapid application development (RAD) tool to enable quick and easy development of user interfaces for the GTK+ toolkit and the GNOME desktop environment. The user interfaces designed in Glade are saved as XML and these can be loaded by applications dynamically as needed by using GtkBuilder or used directly to define a new GtkWidget derived object class using Gtk+ new template feature. The Glade XML files can also be used in numerous programming languages.

Gleem: Gleem (OpenGL Extremely-Easy-to-use Manipulators) is a library for Java and C++ offering a set of 3D widgets that support direct user interaction with a 3D scene. These widgets are used to translate along a line, translate in a plane, and do three-dimensional translation and rotation.

Glib: GLib is the low-level core library that forms the basis for projects such as GTK+ and GNOME. It provides data structure handling for C, portability wrappers, and interfaces for such runtime functionality as an event loop, threads, dynamic loading, and an object system. GLib provides the core application building blocks for libraries and applications written in C. It provides the core object system used in GNOME, the main loop implementation, and a large set of utility functions for strings and common data structures.

Glpk: GLPK is a C library for solving large-scale linear programming (LP), mixed integer programming (MIP), and other related problems. It supports the GNU MathProg modeling language, a subset of the AMPL language, and features a translator for the language. In addition to the C library, a stand-alone LP/MIP solver is included in the package. This is a GNU package.

Gmime: GMime provides a core library and set of utilities which may be used for the creation and parsing of messages using the Multipurpose Internet Mail Extension (MIME).

Gmp: GMP is a library for arbitrary precision arithmetic, operating on signed integers, rational numbers and floating point numbers. The precision is only limited by the available memory. The library is highly optimized, with a design focus on execution speed. It is aimed at use in, for example, cryptography and computational algebra.

Gnash

Gnash is a GNU Flash movie player. Flash is an animation file format pioneered by Macromedia which continues to be supported by their successor company, Adobe. Flash has been extended to include audio and video content, and programs written in ActionScript, an ECMAScript-compatible language. Gnash is based on GameSWF, and supports most SWF v7 features and some SWF v8 and v9. Features:

Runs as a standalone application - Gnash can run standalone to play flash movies.
IceCat plugin - Gnash can also run as a plugin from within IceCat.
SWF v7 compliant - Gnash can play many current flash movies.
XML Message server - Gnash also supports an XML based message system as is documented in the Flash Format specification.
High Quality Output - Gnash uses OpenGL for rendering the graphics.

Gnet

GNet is a simple network library. It is written in C, object-oriented, and built upon glib. It is meant to be small, fast, easy to use, and easy to port. The interface is similar to the interface for Java's network library. Features include:

TCP 'client' sockets
TCP 'server' sockets
v
USP
IP Multicast
Internet address abstraction
Non-blocking TCP sockets and address lookup

Gnome Application Library (gal): Gal is the Gnome Application Library, a collection of widgets and other helper functions from Evolution and Gnumeric.

Gnome VFS: GnomeVFS is a library that allows applications to transparently access various types of filesystems through a uniform interface. GnomeVFS modules include support for things such as WebDAV, ftp, local filesystem, gzip, bzip2, cdda, and others. GNOME VFS is currently used as one of the foundations of the Nautilus file manager

Gnonlin: Gnonlin is a library for creating non-linear video editors. It works together with the GStreamer multimedia framework to give developers a powerful and flexible set of tools for quickly assembling applications which need to handle non-linear video editing.

Gnu3dkit: The GNU 3DKit is an object oriented graphics framework for creating 3D graphics applications in the Objective-C language. Its main application is to render 3D graphics in real-time on commodity hardware, using a scene graph architecture. It is based on OpenGL graphics library to achieve this goal. The GNU 3DKit was officially part of the GNU project as an extension to GNUStep .

Gnulib: Gnulib is intended to be the canonical source for most of the important "portability" and/or common files for GNU projects. These are files intended to be shared at the source level; Gnulib is not a library meant to be installed and linked against. Unlike most projects, Gnulib does not normally generate a source tarball distribution; instead, developers should just grab modules directly from the repository. While portability across operating systems is not one of GNU's primary goals, it has helped introduce many people to the GNU system, and is worthwhile when it can be achieved at a low cost. This collection helps lower that cost.

Gnupg: GnuPG is a complete implementation of the OpenPGP standard. It is used to encrypt and sign data and communication. It features powerful key management and the ability to access public key servers. This package, also known as GPG, is a command line tool with features for easy integration with other applications. A wealth of frontend applications and libraries are available.
Notes

Even if you have nothing to hide, using encryption helps protect the privacy of people you communicate with, and makes life difficult for bulk surveillance systems. If you do have something important to hide, you are in good company; GnuPG is one of the tools that Edward Snowden used to uncover the secrets of the NSA.
See also the Email Self-Defense site to learn how and why you should use GnuPG for your electronic communication.

Gnuprologjava: "GNU Prolog for Java" is a library which is designed to embedd into Java applications which need Prolog to solve some tasks. The interpreter is intended for applications where Prolog performs combinatory search and Java does the rest. The library allows easy communication between Java and Prolog.

Gnurl: Gnurl is a microfork of cURL, a command line tool for transferring data with URL syntax. While cURL supports many crypto backends, libgnurl only supports HTTP, HTTPS and GnuTLS.

Gnustep: Provides an object oriented application development framework and tool set for use on a wide variety of platforms. It provides a generalized visual interface design and a cohesive user interface. It also uses a common imaging model called Display PostScript (based on PostScript) to do all its drawing, so the program is truly WYSIWYG. GNUstep is written in the Objective-C language, a simple yet powerful object-oriented language based on C that gives you the full power of an object-oriented language with exactly one syntax addition to C and a dozen or so additional keywords.

Gnustep-back ,: This is the back-end component for the GNUstep GUI Library. GNUstep is a cross-platform, object-oriented set of frameworks for desktop application development. The set of frameworks, based on Cocoa (previously OpenStep), enables developers to rapidly build sophisticated software by employing a large library of reusable software components. This GUI uses an abstraction layer to talk to the windowing system. It uses the GNUstep back library to handle all of the windowing-system-specific details. It currently works via a DPS emulation engine to emulate the DPS functions required by the front-end system. More recently, a back end based on Cairo was implemented. This is a high-performance 2D graphics library supporting vector and composing operations. Another back-end runs on top of the X Window System and uses only Xlib calls for graphics, but seems deprecated. (There is also a back end supporting the Windows GDI, allowing GNUstep applications to run on Windows)

Gnustep-base: The GNUstep Base Library is a library of general-purpose, non-graphical Objective C objects. For example, it includes classes for strings, object collections, byte streams, typed coders, invocations, notifications, notification dispatchers, moments in time, network ports, remote object messaging support (distributed objects), and event loops. It provides functionality that aims to implement the non-graphical portion of the Apple's Cocoa frameworks (the Foundation library) which came from the OpenStep standard.

Gnustep-gui: The GNUstep GUI Library is an object-oriented application programming interface (API) for writing graphical applications. These classes include graphical objects such as buttons, text fields, popup lists, browser lists, and windows; there are also many associated classes for handling events, colors, fonts, pasteboards and images. It is based on Cocoa (previously OpenStep). The library calls methods of the display server, while gnustep-back translates those calls to native calls of the operating system.

Gnutls ,: GnuTLS is a secure communications library implementing the SSL, TLS and DTLS protocols and technologies around them. It provides a simple C language application programming interface (API) to access the secure communications protocols as well as APIs to parse and write X.509, PKCS #12, and other required structures. The project strives to provide a secure communications back-end, simple to use and integrated with the rest of the base GNU/Linux libraries. A back-end designed to work and be secure out of the box, keeping the TLS and PKI complexity outside the applications.

Go: go is a small shell command for changing directories quickly. Typically you have a set of directories that you work in. Typing out the names of those dirs in full can be tedious.

Goblin Graph Library: The GOBLIN project consists of a C++ class library for a large series of graph optimization problems, GOSH, an extension of the Tcl/Tk scripting language to graph objects, and GOBLET, a graphical user interface to the library functions. GOBLET includes a graph editor, but provides only basic graph layout methods.

Goffice: GOffice is a GObject based C library. It provides easy API access to creating and manipulating graphs and canvases. It also includes a number of utilities and widgets that might be useful in office productivity software and similar. The GOffice code was originally a part of Gnumeric, but was split into a separate library in 2005. Today it is being used by projects such as Gnumeric, Gnucash, Abiword (optional), GChemUtils and more.

Google-adwords-dumper: google-adwords-dumper is a program to fetch basic data of an adwords account and some relevant performance reports of the account. It also fetches the data of child accounts if the given account is a master account.

Grace Library: This is a candidate for deletion: Links broken. Email to maintainer broken. Poppy-one (talk) 14:34, 2 August 2018 (EDT) Grace is a C++ library/enhancement for creating multithreaded server applications. It delivers basic building blocks for stable, readable code and makes it easy to exchange data with other systems.

Grapefruit

GrapeFruit is a pure Python module that let you easily manipulate and convert color information. Its Primary goal is to be natural and flexible. The following color systems are supported by GrapeFruit:

RGB (sRGB)
HSL
HSV
YIQ
YUV
CIE-XYZ
CIE-LAB (with the illuminant you want)
CMY
CMYK
HTML/CSS color definition (#RRGGBB, #RGB or the X11 color name)
RYB (artistic color wheel)

Graphics3D: 'Graphics3D' is a C++ library for game developers, researchers, and students. It is a base of robust and high performance code common to most 3D projects. It is not a standalone graphics or game engine--it is a set of pieces to jumpstart your own engine or graphics project. The library has two parts: G3D for pure math, and GLG3D for interacting with hardware acceleration via OpenGL. You can use G3D without GLG3D if you want to use another 3D API or don't like the OpenGL abstraction.

Gretl: Gretl, an acronym for Gnu Regression Econometrics and Time-series Library, is a package for performing statistical computations for econometrics. It consists of both a command-line client and a graphical client. It features a variety of estimators such as least-squares and maximum likelihood; several time series methods such as ARIMA and GARCH; limited dependent variables such as logit, probit and tobit; and a powerful scripting language. It can output models as LaTeX files. It also may be linked to GNU R and GNU Octave for further data analysis.

Groupserver: GroupsServer is a server package for hosting mailing lists, like GNU Mailman, or Sympa. But like Discourse and Loomio, is also has a feature rich web interface, allowing each mailing list it hosts to also be used as if it were a web forum. In keeping with its name GroupServer refers to each mailing list forum as a 'group'. Users can send, receive, read, and reply, to group messages by email, or they can read and post to the group from the web interface. Group admins can manage and moderate their groups using email commands, as in older mailing list packages, or using the web interface. A single GroupServer instance can host multiple organisations, each with multiple groups.

Gsasl: GNU SASL an implementation of the Simple Authentication and Security Layer (SASL) framework, consisting of a library with several plugins, command-line application, test-suite, documentation and source code usage examples. GNU SASL consists of a library (`libgsasl'), a command line utility (`gsasl') to access the library from the shell, and a manual. The library includes support for the framework (with authentication functions and application data privacy and integrity functions) and at least partial support for the CRAM-MD5, EXTERNAL, GSSAPI, ANONYMOUS, PLAIN, SECURID, DIGEST-MD5, SCRAM-SHA-1, SCRAM-SHA-1-PLUS, LOGIN, and NTLM mechanisms.

Gscope: A Software Oscilloscope Library: Gscope is a software oscilloscope library build using the GTK and GNOME toolkits. Gscope can be used to monitor, display and debug various types of "real-time" data. Additionally, the scope can be used for graphing file data that is in a tuple format.

Gsl: The GNU Scientific Library is a library for numerical analysis in C and C++. It includes a wide range of mathematical routines, with over 1000 functions in total. Subject areas covered by the library include: differential equations, linear algebra, Fast Fourier Transforms and random numbers.

Gss: GNU Generic Security Service Library implements the GSS-API framework and a Kerberos V5 mechanism (through Shishi). GSS-API and Kerberos V5 is used by network clients and servers to perform authentication, often using the SSH protocol for remote access or SMTP/IMAP/POP3 for email. This package contains also a command line tool for GSS.

Gstreamer: GStreamer is a library for constructing graphs of media-handling components. The applications it supports range from simple Ogg/Vorbis playback, audio/video streaming to complex audio mixing and video non-linear editing. Applications can take advantage of advances in codec and filter technology transparently. Developers can add new codecs and filters by writing a simple plugin with a clean, generic interface. This package provides the core library and elements.

Gtk+: GTK+ is a GUI Toolkit for creating graphical user interfaces. This package provides a complete set of widgets suitable for projects ranging from small one-off tools to complete application suites. In addition to basic widgets, such as buttons, check boxes, and text entries, it also provides Model-View-Controller (MVC) APIs for tree views, multi-line text fields, and menu and toolbar actions. GTK+ is the primary library used to construct user interfaces in GNOME. Its name stands for "GIMP Tool Kit", as originally it was explicitly written for that image manipulation program, and later extracted from it as a stand-alone library. Third-party language bindings designed for the GNU system are provided by the Guile-Gnome project.

Gtk2Hs: 'Gtk2Hs' is a GUI library for Haskell based on Gtk. It features automatic memory management, Unicode support, and bindings for the Mozilla browser rendering engine. It also includes bindings for several Gnome modules: libglade, for loading GUIs from xml files at run-time, so you can design an interface visually using the Glade user interface builder; GConf, for storing application preferences; and SourceView, a source code editor widget with syntax highlighting.

GtkHTML: GtkHTML is a HTML rendering/editing library. It is not designed to be the ultimate HTML browser/editor; instead, it is designed to be easily embedded into applications that require lightweight HTML functionality.

Guile-gcrypt: Guile-Gcrypt is a cryptography library for Guile using Libgcrypt. The API provides a Guile 2.x interface to a subset of the GNU Libgcrypt crytographic library, which is itself used by the GNU Privacy Guard (GPG).

Guile-git: This package provides Guile bindings to libgit2, a library to manipulate repositories of the Git version control system.

Guile-json

Guile-JSON is a JSON module for Guile. It supports parsing and building JSON documents according to the http://json.org specification. These are the main features:

Strictly complies to JSON specification.
Build JSON documents programmatically via macros.
Unicode support for strings.
Allows JSON pretty printing.

Guile-xcb: Guile XCB is an X11 client library written entirely in Guile. It makes use of the Guile compiler and virtual machine to turn XML descriptions of the X protocol provided by the XCB project into Guile object code files. Support is included for the core X protocol and twenty-seven extensions. Guile XCB also includes some simple code for running asynchronous event loops.

Gwenhywfar: 'Gwenhywfar' is a multi-purpose library that provides useful functions such as configuration file handling, a full featured message generation and parsing engine, and an operating system abstraction layer. It is used by Libchipcard, OpenHBCI, AqMoney, and various other projects.

HCluster

A hierarchical clustering package for Scipy. This library provides Python functions for hierarchical clustering. Its features include:

generating hierarchical clusters from distance matrices
computing distance matrices from observation vectors
computing statistics on clusters
cutting linkages to generate flat clusters
and visualizing clusters with dendrograms.

HPAlib: The HPA library offers functions for high precision arithmetic, a high precision math library and functions which apply high precision computation. The math library support includes evaluation of trigonometric, inverse trigonometric, hyperbolic, inverse hyperbolic, logarithm and exponential functions at the same precision as the floating point math itself. The version 1.0 of the HPA library supports high precision complex arithmetic and includes an extended precision complex math library.

HTML Defaultify: 'Defaultify' lets you populate any HTML form with default values that you specify-- it parses the HTML to find the tags representing form fields, and alters those tags so that the desired initial values will be set. It's useful for letting a user correct input errors, presenting a form to edit an existing database record (or user account information), maintaining a query form from one results page to the next, etc. HTML::Defaultify lets you completely separate the HTML from the program code, which means a non-technical designer can work on the HTML while a programmer works on the code. Also, it uses existing HTML, so you needn't rewrite old pages in a new format.

HTML Mason: HTML::Mason is a web site development and delivery system that constructs web pages and sites from shared, reusable building blocks called components. Components contain a mix of Perl and HTML, and can call each other and pass values back and forth like subroutines. They increase modularity and eliminate repetitive work. HTML::Mason is most powerful when used in conjunction with mod_perl, but can be used in standalone applications as well.

HTTPlib2: A comprehensive HTTP client library, httplib2 supports many features left out of other HTTP libraries.

Hachoir project- hachoir core

Hachoir is the french name for a mincer: a tool used by butchers to cut meat. Hachoir is also a tool written for hackers to cut a file or any binary stream. A file is split in a tree of fields where the smallest field can be just a bit. There are various field types: integer, string, bits, padding, sub file, etc. Hachoir has many interesting features:

Autofix: Hachoir is able to open invalid / truncated files
Lazy: Open a file is very fast since no information is read from file, data are read and/or computed when the user ask for it
Types: Hachoir has many predefined field types (integer, bit, string, etc.) and supports string with charset (ISO-8859-1, UTF-8, UTF-16, ...)
Addresses and sizes are stored in bit, so flags are stored as classic fields
Endian: You have to set endian once, and then number are converted in the right endian
Editor: Using Hachoir representation of data, you can edit, insert, remove data and then save in a new file.
Website: http://hachoir.org/wiki/hachoir-core

Hachoir project- hachoir regex: hachoir-regex is a Python library for regular expression (regex or regexp) manupulation. You can use a b (or) and a+b (and) operators. Expressions are optimized during the construction: merge ranges, simplify repetitions, etc. It also contains a class for pattern matching allowing you to search multiple strings and regex at the same time.

Hachoir project- hachoir subfile: hachoir-subfile is a tool based on hachoir-parser to find subfiles in any binary stream. It searches images, videos, SWF files, and all sub files in a drive.

Ham Radio Control Libraries: The HAM radio equipment control libraries allow you to write amateur radio equipment control programs for transceivers which use CAT or similar computer interfaces for control.

HapCluster++: HapCluster++ is a software package for linkage disequilibrium mapping using coalescent theory. It is based on a Bayesian Markov-chain Monte Carlo (MCMC) method for fine-scale linkage-disequilibrium gene mapping using high-density marker maps. HapCluster++ is a C++ implementation of the method described in the paper "Fine Mapping of Disease Genes via Haplotype Clustering" by E.R.B. Waldron, J.C. Whitaker, and D.J. Balding. Genetic Epidemiology. 30: 170Ãâ179. (2006).

Harminv: Harminv is a program (and accompanying library) to solve the problem of harmonic inversion. Given a discrete-time, finite-length signal that consists of a sum of finitely-many sinusoids (possibly exponentially decaying) in a given bandwidth, it determines the frequencies, decay constants, amplitudes, and phases of those sinusoids. Harminv can, in principle, provide much better accuracy than straightforwardly extracting FFT peaks because it assumes a specific form for the signal. (Fourier transforms, in contrast, attempt to represent *any* data as a sum of sinusoidal components.) It is also often more robust than directly least-squares fitting the data (which can have problematic convergence). Harminv employs the "filter diagonalization method" (FDM) of Mandelshtam and Taylor.

Hasard: This is a candidate for deletion: Links broken. Email to maintainer broken. Poppy-one (talk) 15:09, 2 August 2018 (EDT) Hasard is a pseudo-random random number generator (PRNG) library. It includes multiple engines (algorithms), examples: Park-Miller, Mersenne Twister and GNU/Linux built-in random PRNG. It has simple API but with strong code, eg. PRNG seed can be generated using strong entropy (hardware random number generator like /dev/random on GNU/Linux). The library is written in C and a Python binding is available. "Hasard" is the french word for "randomness".

Hashit: Hashit is a library of generic hash tables that supports different collision handling methods with one common interface. Both data and keys can be of any data type. It is small and easy to use.

Hfloat: The Huge-float package is for computations with very long (huge!) floating point numbers. With hfloat you can compute pi to several million digits.

Highlight.js

Highlight.js is a syntax highlighter for the Web.

135 languages and 65 styles (live demo)
Automatic language detection
Multi-language code highlighting
Available for Node.js
Works with any markup
Compatible with any JavaScript framework

Hk classes: 'hk_classes' is a set of C++ libraries for rapid development of database applications with all features a modern database application should have, like forms and reports. hk_classes is database and GUI independent. It also includes command line tools to use hk_classes in scripts.

Hoard: Hoard is a fast, scalable and memory-efficient allocator for multiprocessors. It solves the heap contention problem caused when multiple threads call dynamic memory allocation functions like malloc() and free() (or new and delete), and can dramatically improve the performance of multithreaded programs running on multiprocessors. it is a drop-in replacement for malloc(), etc., so you don't have to change your source code.

HotSwap: This is a candidate for deletion: Links broken. Email to maintainer broken. Poppy-one (talk) 16:46, 2 August 2018 (EDT) HotSwap provides a robust library for updating the implementation of an object at runtime (aka hotswapping). This is achieved through recompilation, dynamic class reloading, and object state migration throughout the life of an application. Hotswapping makes Java feel more like an interpreted language than a compiled language; it is fundamentally useful for runtime development of an application (application evolution or incremental development).

Hy: Hy is a Lisp front-end to the Python AST / Bytecode. This allows you to use the Python VM just as Clojure uses the Java VM. Hy is special, since not only can Hy invoke Python, but Python can also interop with Hy in a clean way.

IPStream: 'IPStream' is a C++ crossplatform library for working with TCP/UDP protocols. It is multithreaded and relies on the Boost libraries for this (particularly Boost.Thread It makes working with TCP/UDP easier due to serialization operators usage.

IPlib: A Python module for converting and managing pairs of address/netmask in the CIDR notation. Some example scripts ('ipconv', 'nmconv' and 'cidrinfo') are included.

ISO Master: ISO Master is a graphical editor for ISO images with support for ISO9660, RockRidge, and Joliet file names. It is useful for extracting, deleting, or adding files and directories to or from an ISO image. It is based on the bkisofs and GTK2 libraries.

ISODate: This module implements ISO 8601 date, time and duration parsing. The implementation follows ISO8601:2004 standard, and implements only date/time representations mentioned in the standard. If something is not mentioned there, then it is treated as non existent, and not as an allowed option. For instance, ISO8601:2004 never mentions 2 digit years. So, it is not intended by this module to support 2 digit years. (while it may still be valid as ISO date, because it is not explicitly forbidden.) Another example is, when no time zone information is given for a time, then it should be interpreted as local time, and not UTC. As this module maps ISO 8601 dates/times to standard Python data types, like date, time, datetime and timedelta, it is not possible to convert all possible ISO 8601 dates/times. For instance, dates before 0001-01-01 are not allowed by the Python date and datetime classes.

IbPy: IbPy is a third-party implementation of the API used for accessing the Interactive Brokers on-line trading system. IbPy implements functionality that the Python programmer can use to connect to IB, request stock ticker data, submit orders for stocks and options, and more.

Id3lib: 'id3lib' is a software development library for reading, writing, and manipulating meta-information in digital audio files. Currently id3lib supports reading and writing of ID3v1 and ID3v2 tags and other associated tasks such as conversion between tagging formats, identifying valid tags, converting sizes, synchronisation, compression, and padding. It also has a high level of support for the ID3v2 standard, to produce tags that will continue to comply with the standard well into the future.

Ilib: Ilib is an image manipulation library for developers. It's capable of reading and writing images (PPM/PGM, PNG, JPEG, GIF, XPM, BMP) and many drawing functions including drawing lines and text using any BDF (X11) font. It's great for generating GIFs/PNGs from a CGI or generating graphs.

ImLib3D: ImLib3D is a C++ library and visualization system for 3D (volumetric) image processing. It provides a library for developing image processing software in C++, an executable, for using image processors from the command line, and an executable, which is an interactive GUI for 3D volumetric visualization.

Image Fusion Library: Library for image fusion (i.e. combining several images while preserving as much information from each image as possible) written in C++. Fast and memory efficient.

Interpcom: 'interpcom' is a command interpreter library for building scientific applications. It contains an expression evaluator that can be used to parse the arguments of the commands. It is possible to define "objects" which are arrays of numbers having a name, and structures. The program also supports threads (several programs running simultaneously), and it is very easy to add new commands.

Intervals: The "Interval Arithmetic for Ada" library provides an implementation of intervals for Ada. It includes arithmetic and relational operations.

Ipfs: pleas add

Irc: This library is intended to encapsulate the IRC protocol at a quite low level. It provides an event-driven IRC client framework. It has a fairly thorough support for the basic IRC protocol, CTCP and DCC connections.

Ivy-Python: Links & maintainer email broken. Changed homepage to archive.org link. Poppy-one (talk) 12:26, 6 August 2018 (EDT) Ivy is a lightweight software bus for quick-prototyping protocols. It allows applications to broadcast information through text messages, with a subscription mechanism based on regular expressions.

JACK Audio Connection Kit: JACK is a low-latency audio server. It can connect a number of different applications to an audio device, as well as allowing them to share audio between themselves. Its clients can run in their own processes (i.e., as normal applications), or can they can run within the JACK server (as a "plugin"). JACK is different from other audio server efforts in that it has been designed from the ground up to be suitable for professional audio work. This means that it focuses on two key areas: synchronous execution of all clients, and low latency operation.

JBIG-KIT: JBIG-KIT implements a highly effective data compression algorithm for bi-level high-resolution images (ie faxes or scanned documents). It provides a portable C library of compression and decompression functions with a documented interface that can easily be included into image or document processing software. JBIG-KIT also provides ready-to-use compression and decompression programs with a simple command line interface (similar to the converters found in netpbm). It implements the specification ISO 11544 and ITU-T T.82, commonly referred to as the "JBIG1 standard".

JCIFS: 'jCIFS' is an SMB client library that follows the CIFS specification supporting Unicode, named pipes, batching, multiplexing IO of threaded callers, encrypted authentication, full transactions, domain/workgroup/host/share/file enumeration, NetBIOS sockets and name services, the smb:// URL protocol handler, a java.io.File like API, RAP calls, NTLM HTTP Authentication, and more.

JIGS: JIGS (Java Interface for GnuStep) allows Java programmers to use the GNUstep libraries from Java, but it is more than a set of bindings for GNUstep from Java: it takes advantage of the fact that Objective-C and Java are very similar languages to make it possible to use Objective-C classes from Java using exactly the same API (and vice versa). Moreover, JIGS can generate automatically wrappers for your own Objective-C GNUstep libraries.

JMusic: 'jMusic' provides a library of classes for generating and manipulating music, and is a solid framework for computer assisted composition in Java. jMusic supports composers by providing a music data structure based upon note/sound events, and methods for working with that musical data. jMusic can read and write MIDI files, audio files, and its own .jm files. jMusic is designed to be extendible, so you can build on its functionality by programming in Java to create your own music composition tools.

JSAM

JSON Storage Access Methods is a library for storage and retrieval of JavaScript Object Notation (JSON) encoded objects. Backends include:

file: directory of plain text JSON files
rcs: directory of plain text JSON files under RCS
cvs: directory of plain text JSON files under CVS (not tested)
svn: directory of plain text JSON files under SVN (not tested)
sqlite: object trees stored in an SQLite3 database
mysql: object trees stored in a MySQL database (barely tested)
Lookup methods include:
Collections: a jQuery-like method-chained interface
XPath-like query language (only supported for SQL backends)

JSONgrep: JSONgrep is a shell tool for extracting values from JSON documents. It supports shell-like globbing for property names, and emits the matched values separated by newlines.

JSONlib2: This is yet another library for reading/writing json. The goal is to be API compatible with simplejson, except that it is written purely in C and is thus 5x-20x faster for both encoding and decoding, depending on the data.

Jamdict: Jamdict is a command-line application as well as a Python 3 package for querying and managing Japanese dictionaries and resources (Jim Breen's JMdict, KanjiDic2, KRADFILE, JMnedict)

Jaraco.classes: Utility to construct Python classes.

Jaraco.collections: Additional classes and models to Python stdlib's collections.

Jaraco.functools: Additional functions to Python's stdlib.

Jaraco.logging: Parses logging into arguments.

Jaraco.text: Module for text manipulation.

Javascript Crypto Library: Provides web developers with an extensive and efficient set of cryptographic functions. The library aims to obtain maximum execution speed while preserving modularity and reusability. Includes the fastest JavaScript implementation of AES.

JobLib

A set of tools to run Python scripts as jobs; namely: persistence and lazy re-evaluation (between make and the memorize pattern), logging, and tools for reusing scripts. Joblib provides a set of tools to run Python scripts as jobs; namely:

1. persistence and lazy re-evaluation (between make and the memorize pattern),
2. logging,
3. tools for reusing scripts.
The original focus was on scientific-computing scripts, but any long-running succession of operations can profit from the tools provided by joblib.

Json-Type: Json-Type is a fully-compliant RFC 8259 and ECMA 404 push parser -- validating UTF8 as per the Unicode Standard 8.0.0 -- and a very efficient on-the-fly type checker of JSON text. Json-Type has a two-tiered structure: the core of its functionality is enclosed in a dynamic library, while the front-end, the main program assembles the variety of use-cases of the library into a convenient and comprehensive command line interface.

JsonPickle: Python library for serializing any arbitrary object graph into JSON. It can take almost any Python object and turn the object into JSON. Additionally, it can reconstitute the object back into Python.

Jsonrpclib

This library implements the JSON-RPC 2.0 proposed specification in pure Python. It is designed to be as compatible with the syntax of xmlrpclib as possible (it extends where possible), so that projects using xmlrpclib could easily be modified to use JSON and experiment with the differences. It is backwards-compatible with the 1.0 specification, and supports all of the new proposed features of 2.0, including:

Batch submission (via MultiCall)
Keyword arguments
Notifications (both in a batch and 'normal')
Class translation using the 'jsonclass' key.

Jwsmtp: 'jwsmtp' is a C/C++ library that facilitates sending email programmatically. It supports attachments, multiple recipients, Cc/Bcc recipients, both LOGIN and PLAIN authentication, and HTML and plain text formatting. The package does MX lookups or can send directly to an SMTP server.

KATCP: Karoo Array Telescope Communication Protocol library.

KSS (Kinetic Style Sheets) framework: KSS enables you write rich Ajax applications without having to code Javascript. It does this by using a CSS like resource, this is called a KSS file. All that you as a developer need to do is write files like these and implement server side Python. This Python package contains the Javascript engine and the server side infrastructure. The package forms the base for integration with specific web development frameworks. To see if there is support for your framework go to the KSS website.

KSquirrel-libs: ksquirrel-libs is a set of codecs for the KSquirrel image viewer. It supports dozens of image formats. Including: Windows bitmaps (.bmp), Compuserve GIF (static, animated), Windows icons (.ico), JPEG, JPEG2000, ZSoft PCX, Scalable Vector Graphics (.svg), Windows Metafile (.wmf), Portable Network Graphics, Portable Any Map (.pnm, .ppm, .pgm, .pbm), Sun Raster File (.ras), SGI, Targa (.tga), Tagged Image File Format, X Bitmaps (.xbm), X Pixmaps (.xpm), OpenEXR (.exr), PIX, SUN Icons, X Window Dump (.xwd), Photoshop PSD (RGB, CMYK, Greyscale, Indexed), FLI Animation, X cursors (static, animated), Wireless Bitmap, Photos from different cameras (CRW), Quake2 texture (.wal), HalfLife model (.mdl),* Commodore 64 KOALA (.koa), Dr. Halo CUT, Radiance HDR image (.hdr), Scitex CT, Homeworld LIF, MTV Ray tracer, AVS X, RAWRGB (internal, simple 24 or 32-bit format).

Kbde: 'kbde' is a keyboard emulator whose goal is to provide tools for emulating keyboard input on keyboardless (x86) computers. It includes an emulator driver, a user-space program, and a library which make it easy to write applications that can create keyboard input emulation.

Kdtree: kdtree is a simple, easy to use C library for working with kd-trees. Kd-trees are an extension of binary search trees to k-dimensional data. They facilitate very fast searching, and nearest-neighbor queries. This particular implementation is designed to be efficient and very easy to use. It is completely written in ANSI/ISO C, and thus completely cross-platform.

Kepler

Kepler is a library of C routines for astronomical calculations. It features the following:

The entire VSOP87 theory for calculating the positions of the eight planets.
The entire ELP 2000-82B theory for calculating the position of the Moon.
An analytical theory for calculating Pluto's position for the period 1700AD-2100AD.
The ability to convert osculating orbital elements to heliocentric coordinates.
The latest IAU 2006 precession and IAU 2000A nutation models.
Routines for calculating sidereal time using the current IAU resolutions.
An implementation of the Ron/Vondrak theory of annual aberration.
Routines for Julian date calculations.
Routines for coordinate transformations, rotations and parallax corrections.

Kexi: KEXI is a visual database application builder tool by KDE, designed to fill the gap between spreadsheets and database solutions requiring more sophisticated development. KEXI can be used for designing and implementing databases, data inserting and processing, and performing queries.

KiCad: KiCad is electronic design automation (EDA) software made for designing schematics of electronic circuits and printed circuit boards (PCB). KiCad is developed by the KiCad Developers Team, and features an integrated environment with schematic capture, bill of materials list, PCB layout and much more. KiCad is cross-platform, written with WxWidgets and runs on FreeBSD, GNU/Linux, Microsoft Windows and Mac OS X. A lot of component libraries are available. Also migrating tools for components are available (from other EDA software tools). File formats are plain text and well documented, which is good for CVS or Subversion and to make automated component generation scripts. Multiple languages are supported, such as English, Portuguese, Spanish, Czech, Polish, French, German, and Russian. The 3D PCB viewer use 3D model from Wings3D CAD.

Kiss FFT: Kiss FFT is a small and simple FFT library. It has no complicated platform-specific optimizations, can do either fixed or floating point with just a recompile, and is efficient enough for all but the most demanding applications.

Kiwi: Kiwi consists of a set of classes and wrappers for PyGTK that were developed to provide a sort of framework for applications. Fully object-oriented, and roughly Smalltalk's MVC, Kiwi provides a simple, practical way to build forms, windows and widgets that transparently access and display your object data. Kiwi was primarily designed to make implementing the UI for Stoq easier.

Klimt: Klimt is a 3D library, targeted for PDAs and mobile phones. Its API is very similiar to that of OpenGL and OpenGL ES. We do not claim conformance with these APIs. Nevertheless, Klimt is able to run Coin3D, a large scene-graph base library that builds on top of OpenGL. This product is based on the published OpenGLÃÂ® ES API, but is not an implementation which is certified or licensed by Silicon Graphics, Inc. under the OpenGLÃÂ® ES API. OpenGLÃÂ® and OpenGLÃÂ® ES are registered trademarks of Silicon Graphics, Inc. in the United States and/or other countries worldwide. Klimt is independent of Silicon Graphics, Inc.

Kniffel: 'Kniffel' features a library for dealing with first order predicate logic formulas and tools (command line and CGI versions included) that convert first order predicate logic to LaTeX, graphviz dot, and ASCII formats.

Kyoto Cabinet

Kyoto Cabinet is a library of routines for managing a database. The database is a simple data file containing records, each is a pair of a key and a value. Every key and value is serial bytes with variable length. Both binary data and character string can be used as a key and a value. There is neither concept of data tables nor data types. Records are organized in hash table. Kyoto Cabinet is developed as the successor of Tokyo Cabinet on the following purposes. They are achieved and Kyoto Cabinet replaces conventional DBM products.

improves space efficiency : smaller size of database file.
improves parallelism : higher performance in multi-thread environment.
improves portability : abstraction of the lower layer to support non-POSIX systems.
improves usability : simplified API, object-oriented design.

LAPACK: LAPACK is written in Fortran77 and provides routines for solving systems of simultaneous linear equations, least-squares solutions of linear systems of equations, eigenvalue problems, and singular value problems. The associated matrix factorizations (LU, Cholesky, QR, SVD, Schur, generalized Schur) are also provided, as are related computations such as reordering of the Schur factorizations and estimating condition numbers. Dense and banded matrices are handled, but not general sparse matrices. In all areas, similar functionality is provided for real and complex matrices, in both single and double precision.

LIBrary for SECure ReMoval: Libsecrm (LIBrary for SECure ReMoval of files) is a library which ensures secure data deleting by intercepting calls to some C library functions and replacing them by its own substitutes. The data that would be deleted from a file is first securely wiped, then the original functions are called. Libsecrm also takes care of memory security - some of the memory allocation functions are intercepted, and the allocated memory is wiped before passing it to the calling program.

LIPS Scheme: LIPS is a powerful Scheme based lisp interpreter written in JavaScript. The name is a recursive acronym which stands for LIPS Is Pretty Simple. The interpreter has very good integration with JavaScript.

LTI-Lib: The LTI-Lib is an object oriented library with algorithms and data structures frequently used in image processing and computer vision. It was developed at the RWTH-Aachen University as a part of many research projects on computer vision dealing with robotics, object recognition, sign language, and gesture recognition. It provides an object oriented C++ library that includes fast algorithms, which can be used in real applications.

LTchinese: ltchinese - A library of utilities for the Chinese language (pinyin, zhuyin, encodings, phonetics, etc.) from http://lost-theory.org.

LUCAS: Lets users configure network servers and/or services centrally The traditonal way to manage UN*X boxes is doing configuring work on a per host basis. While this works quite well on single host setups, it quickly becomes a nightmare when it comes to clustered systems, load balancing systems or server farms, where configurations have to be shared/spread/replicated between several more or less independant machines. The LUCAS project aims at creating a framework, where configuration data may be conviniently kept in an central LDAP database and is automatically send to the desired destination from there.

LXML: Powerful and Pythonic XML processing library combining libxml2/libxslt with the ElementTree API. lxml is a Pythonic, mature binding for the libxml2 and libxslt libraries. It provides safe and convenient access to these libraries using the ElementTree API. It extends the ElementTree API significantly to offer support for XPath, RelaxNG, XML Schema, XSLT, C14N and much more.

LZO: 'LZO' is a portable lossless data compression library. It offers pretty fast compression and very fast decompression. Decompression requires no memory. In addition there are slower compression levels achieving a quite competitive compression ratio while still decompressing at this very high speed.

Lcn2-calc

calc is an arbitrary precision arithmetic system that uses a C-like language. It's useful as a calculator, an algorithm prototype, and as a mathematical research tool. More importantly, calc provides a machine-independent means of computation. Its features include:

Arbitrary precision integers and floating-point, fractions and complex values
Logarithm, numeric, trig, hyperbolic functions
C-like syntax
calc shell scripts, resource files, linkable program library
User defined finctions and function loading
Over 283 built-in functions plus hooks for built-in custom extensions
Arrays, lists, dynamic strings, matrices, associate arrays, objects
Numeric, relational, boolean and variable access operators
Extensive string and binary block memory builtin functions
Matrix inversion, determinant, and other matrix operations
Fast and cryptographic pseudo-random numbers, cryptographic hashes
Factoring, primality tests, pi(x), multiplicative inverse, modular exp
Bernoulli numbers, Euler numbers, Catalan numbers
Uses REDC, splint-point and other high speed multi-precision algorithms
Extensive regression test suite
Resource functions: large prime tests, factoring, quaternions, etc.
File I/O, multi-precision printf and scanf, stdio-like functions
GNU Readline, user & system startup scripts, Emacs-style line editing
Online help

Ldns: 'ldns' is a library with the aim of simplifying DNS programing in C. It is heavily based upon the Net::DNS module from Perl.

Leg: Leg (Libraries and Engines for Games) is a set of libraries for game engines and game development. In addition to the libraries, it also includes resource editors designed to make game creation easier. The package is designed to be generic and modular, supporting many different styles of games.

Lib rHarris: A Python Internet Programming Library. lib_rharris is a modest Python library for pulling, parsing and pickling remote web page data and for related net-aware tasks.

LibCGI: LibCGI is a library to assist in the making of CGI applications in C. It supports string manipulation, linked lists, cookies, sessions, GET and POST methods, and more.

LibConfigpp: 'libConfig++' is a portable and flexible C++ library for reading configuration files written in C-style syntax. The syntax of the package's configuration file is like C++, so it will be familiar. You set up program variables from config via a simple and safe interface. Type control is made during compilation, which helps avoid invisible errors in sources. You can define your own types and the library will control this when you setup variables from config file. The library supports multifile configuration. Token "#include" lets you merge one config file with other.

LibDSP: 'libDSP' is a C++ library of digital signal processing functions including standard vector operations, digital filtering and transforms. It also includes wrappers for C.

LibGTop: A library that fetches information about the running system such as cpu and memory usage, active processes etc. The information is taken directly from the /proc filesystem.

LibGlass: 'libGlass' is a scalable set of components that applications use to perform distributed computing. Applications are built by reusing the available components as needed. One of the major goals of Glass is to be a user-friendly framework that is suitable for both new applications and legacy code (most available solutions for distributed computing require a substantial rewrite of legacy code).

LibGringotts: 'libGringotts' is a small, thread-safe C library originally developed for Gringotts. Its purpose is to encapsulate data in an encrypted and compressed file. It uses strong cryptographic algorithms (RIJNDAEL 128/256, SERPENT, TWOFISH, CAST256, SAFER+, LOKI97, and 3DES for encryption, and SHA1 and RIPEMD-160 for hashing) to ensure that data is as safe as possible, and that the user has complete control over all encryption, hashing, and compression algorithms used in the process. It also provides functions for encrypting temporary files and to securely manage memory. It is based upon libmcrypt and mhash, and supports pkgconfig.

LibID3: 'libID3' is a small C library to parse ID3 tags. It uses as little memory as possible, and has both DOM- and SAX-like models.

LibRadtran: Functions and programs to calculate solar and thermal radiation in the Earth's atmosphere.

LibStroke: LibStroke is a stroke translation library. Strokes are motions of the mouse that can be interpreted by a program as a command. Strokes are used extensively in CAD programs to select tools or perform actions; they are an extremely natural human-computer interface.

LibSysCtr: LibSysCTr intercepts system call functions on a GNU/Linux system. Process monitoring and sandboxing are just two of its potential uses. LibSysCTr uses the ptrace(2) functionalities by monitoring and reporting events to the library caller. LibSysCTr is callback driven, which means the user initializes the library with systr_init_library(), registers the system calls he wants to monitor with systr_trace_syscall(), and calls systr_run() to start receiving events in the form of callback invocation. For each intercepted system call, two calls to the registered callback function are performed: one during the system call entry, before the system call iteself will be executed by the kernel, and one after the kernel has processed the system call (right before returning the userspace). Utility functions are supplied to, retrieve information about the process, get/set the system call parameters, and read/write the monitored process address space.

LibTAP

'libTAP' (The Architectural Playground) is a prototyping system for virtual reality and augmented reality applications. It runs on a variety of platforms. RAP (rapid application prototyping) is done through the Lua interface, which mirrors the C++ namespace as closely as possible. libTAP has a small but distinctive feature set, focused on prototyping of realtime 3D simulations.

Also known as 'Tacitpixel'.

LibTMCG: LibTMCG is a C++ library for creating secure electronic card games. The most remarkable feature is the absence of a trusted third party (TTP), i.e. neither a central game server nor trusted hardware components are necessary. With the present library there is no need for an independent referee, because the applied protocols provide a basic level of confidentiality and fairness by itself. Consequently, the library is well-suited for peer-to-peer (P2P) environments where no TTP is available. Of course, we cannot avoid that malicious players share information about their private cards, but the protocols ensure that the shuffle of the deck is performed randomly (presumed that at least one player is honest) and thus the cards will be distributed uniformly among the players. Further, no coalition can learn the private cards of a player against his will (except for trivial conclusions). The corresponding cryptographic problem, actually called Mental Poker, has been studied since 1979 by many authors. LibTMCG provides the first practical implementation of such protocols.

LibTPT: TPT is a template scripting language implemented in C++ and designed to be integrated with C++ programs. The TPT interpreter runs in one pass, so there is no expensive compilation stage. The language relies on C++ for I/O, making TPT portable, small, and fast. There are no bulky modules to include. TPT does not execute as a program or script. The LibTPT parser transforms TPT templates into text. The parser, which integrates with your C++ code through a simple class API, is small and fast, focusing on functionality instead of rich feature sets. Uses include on-the-fly HTML, source code generation, or in any situation where there is a need to generate customized text.

LibTomCrypt: LibTomCrypt is a cryptographic toolkit that gives developers an array of well known published block ciphers, one-way hash functions, chaining modes, pseudo- random number generators, public key cryptography, and many other routines. It has been designed from the ground up to be very simple to use. It has a modular and standard API that allows new ciphers, hashes, and PRNGs to be added or removed without change to the overall end application. It features easy to use functions and a complete user manual which has many source snippet examples.

LibXDiff: The LibXDiff library implements basic and yet complete functionalities to create file differences/patches to both binary and text files. The library uses memory files as file abstraction to achieve both performance and portability.

LibYAML: A YAML 1.1 parser and emitter written in C.

Libao: 'Libao' is a cross-platform audio library that lets programs output audio using a simple API on a wide variety of platforms. It currently supports null output, WAV files, AU files, OSS (Open Sound System), esd, ALSA, AIX, Sun/NetBSD/OpenBSD, IRIX, and NAS (Network Audio Server).

Libassh: libassh is a free software library written in C that implements the Secure Shell protocol version 2. It enables writing ssh2 client and server applications using an event based API.

Libbatch: 'libbatch' implements typical batch process functions, including common SQL operations, functions for working with temp files and for using config files, logging functions (with severity, priority, colors, and verbosity), and functions that work with files and directories.

Libbnr: 'libbnr' implements of the Bayesian Noise Reduction (BNR) algorithm. All samples of text contain some degree of noise (data irrelevant to accurate statistical analysis of the sample where removal of the data would result in a cleaner analysis). The Bayesian noise reduction algorithm ensures cleaner machine learning by providing more useful data, which ultimately leads to better sample analysis. With the noisy data removed from the sample, only data relevant to the classification is left. 'libbnr' can be linked in with a classifier and called using the standard C interface.

Libbraille: 'Libbraille' makes it easy to access Braille displays and terminals. It can write text on a Braille display, directly draw Braille dots, or get the value of pressed keys. It is compatible with a wide range of Braille displays, and can autodetect some of them. The README, included with the distribution, lists the Braille dispays that 'libbraille' supports.

Libburn: Libburn is a library for reading and writing optical discs. Supported media are: CD-R, CD-RW, DVD-RAM, DVD+RW, DVD+R, DVD+R/DL, DVD-RW, DVD-R, DVD-R/DL, BD-R, and BD-RE.

Libc ,: The GNU C Library is the standard C library of the GNU system. It defines the system calls and other basic functionality necessary to write programs in the C language. It handles low-level functionality that communicates with the kernel, such as process and file management, as well as higher-level functionality such as string manipulation or command-line argument handling. In GNU/Linux distributions, the C library works with the Linux kernel to implement the operating system behavior seen by user applications. In GNU Hurd, it works with a microkernel and Hurd servers. The GNU C Library implements much of the POSIX.1 functionality in the GNU system, using configurations i[4567]86-*-gnu. The current Hurd support requires out-of-tree patches that will eventually be incorporated into an official GNU C Library release. It is one of the most important components of the GNU operating system and its variants GNU/Linux. It is used by almost all C programs and provides the most essential program interface.

Libcdaudio: 'libcdaudio' is a library designed to provide functions to control operation of a CD-ROM when playing audio CDs. It also contains functions for CDDB and CD Index lookup.

Libcddb: Libcddb is a library that implements the different protocols (CDDBP, HTTP, SMTP) to access data on a CDDB server. It tries to be as cross-platform as possible.

Libcdio

Libcdio is a library for CD-ROM and CD image file access. It allows the developer to add CD access to an application without having to worry about the OS- and device-dependent properties of CD-ROM or the specific details of CD image formats. It includes pycdio, a Python interface to libcdio, and libcdio-paranoia, a library providing jitter-free and error-free audio extraction from CDs. The libcdio package also contains a number of utility programs, including:

cd-info, displays CD information ;
cd-drive, decribes CD-ROM/DVD drive characteristics ;
cd-read, performs low-level block reading of a CD or CD image ;
iso-info, displays ISO-9660 information from an ISO-9660 image ;
iso-read, extracts files from an ISO-9660 image ;
cd-paranoia - extracts audio from a CD in a jitter.

Libcfg+: 'Libcfg+' is a C library with multi-command line and configuration file parsing. Users can set up special properties such as quoting characters, deliminator strings, file comment prefixes, multi-line postfixes, and more. 'Libcfg+' supports data types such as booleans, integers, decimal numbers, and strings with many additional data type flags (such as multiple values for a single option).

Libchromiumcontent: libchromiumcontent builds the Content Module of Chromium as a shared library (libcc). This allows other projects (such as Electron) to use the Content Module without needing to use or build Chromium itself.

Libcisco: 'libcisco' provides an API for accessing and configuring Cisco network equipment over a telnet session. kIt works making changes through the CLI of the target system (e.g. a privileged EXEC session under IOS). These library routines greatly simplify the process of writing scripts to make configuration changes and perform common tasks.

Libcomcom: Spawn an OS command with given input and receive its output. The main feature of this library is deadlock avoidance. (Deadlock in this case is when your program can't write to the input of another program because of waiting for its output which does not happen because of no input, so a vicious circle leading to infinite waiting time.) API docs: https://vporton.github.io/libcomcom-docs/ There are also Java and D wrappers. Please help to port it to Windows.

Libcroco: The Libcroco project is an effort to build a generic Cascading Style Sheet (CSS) parsing and manipulation toolkit that can be used by GNOME applications in need of CSS support. Its current features include a parser module that provides both a SAC-like API and a CSSOM-like API, a CSS2 selection engine, and an XML/CSS layout/rendering engine.

Libcsdbg: Libcsdbg is a C++ exception stack tracer. When an exception is thrown, caught and handled, libcsdbg offers the tools to create and process the exception stack trace, the path the exception has propagated up the call stack, unwinding it, up to the section were it was handled. The traces are detailed with demangled function signatures and additional addr2line info (the source code file and line that each function was called). Libcsdbg will perform flawlessly with single and multi-threaded (or multi-process) programs, with any dynamically linked shared object (DSO - Dynamic Shared Object) and with any statically linked library. Additionally, libcsdbg helps the developer/tester create sophisticated stack traces of any thread, at any given moment during a process execution, as a snapshot of the runtime call graph. This is very useful in cases of fatal errors, reception of terminating signals or process abortion/termination (such as segmentation faults). libcsdbg can use all the well-known objective code file formats (a.out, elf, coff, ecoff, etc.) and can easily be used as the base for your own instrumentation code. libcsdbg transparently loads the symbol tables of the chosen dynamic libraries and of the executable, demangles function symbols to complete signatures, and binds function names to runtime addresses (even for the DSO symbols).

Libcvs-perl: This libcvs is meant to facilitate writing tools around CVS. It does this by providing libraries which programmers can access directly in their tools. The current focus of the project are libraries which use the cvsclient protocol to talk to a cvs server and are targeted at the development of client applications. Libraries which understand the RCS file format and provide fast server side access are a future possibility. An ObjectiveC version is also underway.

Libcwd: Libcwd is a full-featured, professional, well-documented library to support C++ developers with debugging their applications. It includes support for ostream-based debug output, custom debug channels and devices, powerful memory allocation debugging, run-time sourcefile:linenumber information, and demangled type names of variables. Libcwd is thread-safe.

Libdaemon: 'libdaemon' is a lightweight C library that eases the process of writing UNIX daemons. It contains a daemonizing fork() wrapper, a powerful syslog() wrapper, PID file management, and signal serialization.

Libdecodeqr: "libdecodeqr" is a C/C++ library for docoding QR code, which based on JIS X 0510 and ISO/IEC18004. This library is able to decode miscellaneous images those are taken with a file, with a webcam, with a scanner, and so on.

Libdodo: project page This project, c++ cgi framework, is on itÃâs start, but it has much ideas and wish to implement them! It provides wide abilities for cgi programming! But also you can use it not only as cgi. It has very usefull modules to operate with databases, xml, threads, input/output, regexp, time and so on. Provides hooks, system tools, exceptions, and some more. libdodo - c++ library, cgi framework that provides different extensions in c++. database, xml, sockets, disk, stdin/stdout operations, regexp, cgi interface, cgi

Libds: 'libds' is a cross-platform library to support simple networking, threads, as well as data structures. It allows code reuse for common data structures, such as linked lists and hash tables, as well as support for complex entities such as config files.

Libdvbcsa

A free implementation of the DVB Common Scrambling Algorithm with encryption and decryption capabilities.

Portability. This library has been successfully tested on different processors with 32 bits, 64 bits and 128 bits word width, little-endian and big-endian bytes ordering.
Performance. It comes in two flavors: a classical single packet implementation and a faster parallel bitslice implementation. The parallel implementation can take advantages of MMX, SSE or Altivec instruction sets. Parallel implementation can process Mpeg TS packets at 300Mbps or more on recent processors.

Libdvdcss: 'libdvdcss' is a cross-platform library for transparent DVD device access with on-the-fly CSS decryption. It is used by libdvdread and most DVD players such as vlc because of its portability and because it does not require your DVD drive to be region locked. It is simple (only seven functions in the API) and is intended to remain so.

Libecc: 'libecc' is a C++ elliptic curve cryptography library that supports fixed-size keys for maximum speed. Its goal is to become the first free library to let users generate safe elliptic curves, and to provide an important source of information for anyone with general interest in ECC.

Libelf: 'Libelf' lets you read, modify or create ELF files in an architecture-independent way. The library takes care of size and endian issues, e.g. you can process a file for SPARC processors on an Intel-based system. This library is a clean-room rewrite of the System V Release 4 library and is supposed to be source code compatible with it. It was meant primarily for porting SVR4 applications to other operating systems but can also be used as the basis for new applications (and as a light-weight alternative to libbfd). In 2019, the domain went down and links now point to the wayback machine.

Libevent: The libevent API executes a callback function when a specific event occurs on a file descriptor or after a timeout has been reached. It also supports callbacks due to signals or regular timeouts. It is meant to replace the asynchronous event loop found in event-driven network servers. 'libevent' currently supports /dev/poll, kqueue(2), select(2), poll(2) and epoll(4). It also has experimental support for real-time signals. The internal event mechanism is independent of the exposed event API, so a simple update of libevent provides new functionality without having to redesign applications. As a result, Libevent allows for portable application development and provides the most scalable event notification mechanism available on an operating system.

Libevent-Python: A CPython extension module wrapping the libevent library.

Libextractor: 'libextractor' extracts meta-data from files of arbitrary type. It uses helper-libraries to perform the actual extraction, and is trivially extendable by linking against external extractors for additional file types. Its goal is to provide developers of file-sharing networks, file managers, and WWW-indexing bots with a universal library to obtain meta-data about files. 'libextractor' includes the command "extract" that can extract meta-data from a file and print the results to stdout. Currently, it supports the formats HTML, PDF, PS, OLE2 (doc, xls, ppt), StarOffice, OpenOffice, MAN, DVI, MP3 (ID3v1, ID3v2), OGG, WAV, JPEG, GIF, PNG, TIFF, DEB, RPM, TAR(.GZ), ZIP, Real, QT, MPEG, RIFF (AVI), ASF, and ELF. It also detects various MIME types, and can compute hash functions (SHA-1, MD5, ripemd160). A Java binding (JNI) is available.

Libferris: 'libferris' is a virtual filesystem that exposes hierarchical data of all kinds through a common C++ interface. Access to data is performed using C++ IOStreams and Extended Attributes (EA) can be attached to each datum to present metadata. Ferris uses a plugin API to read various data sources and expose them as contexts and to generate interesting EA. Current implementations include Native (kernel disk IO with event updates using fam), xml (mount an xml file as a filesystem), edb (mount a berkeley database), ffilter (mount an LDAP filter string) and mbox (mount your mailbox). EA generators include image, audio, and animation decoders.

Libffcall: A collection of four libraries used to build foreign function call interfaces in embedded interpreters. avcall - calling C functions with variable arguments callback - closures with variable arguments as first-class C functions (a reentrant combination of vacall and trampoline) Formerly known as ffcall. vacall - C functions accepting variable argument prototypes trampoline - closures as first-class C functions

Libffi: The libffi library provides a portable, high level programming interface to various calling conventions. This allows a programmer to call any function specified by a call interface description at run time. FFI stands for Foreign Function Interface. A foreign function interface is the popular name for the interface that allows code written in one language to call code written in another language. The libffi library really only provides the lowest, machine dependent layer of a fully featured foreign function interface. A layer must exist above libffi that handles type conversions for values passed between the two languages.

Libfrser: Library implementing the serprog protocol used between flashrom and microcontrollers. This library runs on the microcontroller side.

Libgaudio: Libgaudio is a C/C++ library to facilitate easy incorporation of sound and sound effects into games. Samples are loaded into memory and playback is then triggered or stopped. The system mixes any number of concurrently playing samples together (up to a predefined maximum). It is also possible to include a background MP3 soundfile in the mix.

Libgcrypt: This is a general purpose cryptographic library based on the code from GnuPG. It provides functions for all cryptograhic building blocks: symmetric ciphers (AES, DES, Blowfish, CAST5, Twofish, Arcfour), hash algorithms (MD4, MD5, RIPE-MD160, SHA-1, TIGER-192), MACs (HMAC for all hash algorithms), public key algorithms (RSA, ElGamal, DSA), large integer functions, random numbers and a lot of supporting functions.

Libgenrics: Libgenerics is a c++ library that provides object services to analyse class type at runtime sharing the definitions between dynamic modules. It provides serialization services abstraction too. It's an absolute generic library.

Libgeotiff: 'libgeotiff' is a library (normally built on top of libtiff) for reading and writing coordinate system information from/to GeoTIFF files. It includes CSV files for expanding projected coordinate system codes into full projections, and definitions and examples of transforming the definitions into a form that can be used with the PROJ.4 projections library. It also includes the sample applications listgeo (for dumping GeoTIFF information in readable form) and geotifcp (for applying geotiff tags to an existing TIFF or GeoTIFF file).

Libgit2: Libgit2 is a portable, pure C implementation of the Git core methods provided as a re-entrant linkable library with a solid API, allowing you to write native speed custom Git applications in any language with bindings.

Libglade: Libglade lets a program to load its user interface from an XML description at runtime. The XML file format is that of the user interface builder GLADE, so libglade acts as an alternative to GLADE's code generation approach. You can change the look of your application without recompiling. Libglade also provides a simple interface for connecting handlers to the various signals in the interface (on platforms where the gmodule library works correctly, it is possible to connect all the handlers with a single function call). Once the interface has been started, libglade gives no overhead, so there is no performance tradeoff beyond the initial interface loading time.

Libgnomecanvas: 'libgnomecanvas' is the library for the GNOME canvas, an engine for structured graphics that offers a rich imaging model, high performance rendering, and a powerful, high-level API. It is based on the Tk toolkit's canvas widget, and is one of the essential Gnome libraries.

Libgphoto: 'libgphoto2' is a user space library which provides applications with camera independent access to almost 300 digital cameras. It contains more than 30 drivers to complement the drivers in your operating system kernel. There is a list of supported cameras on the home page.

Libgpiv: 'LIBGPIV' is a library for the (Digital) Particle Image Velocimetry technique (PIV), an image analyzing technology that obtains a velocity field from a fluid flow (gas or liquid) that has been seeded with small tracer particles or smoke. 'LIBGPIV' contains the core functions for image evaluation (resulting into estimators of particle image displacements, i.e. PIV data), validation (on peak-locking effects, erroneous vectors or outliers), post-processing, input/output functions, utility functions like memory allocation etc. The project is designed for maximum flexibility for extending and adapting the code for different applications.

Libgsf: 'libgsf' is a simple i/o library that can read and write common file types and handle structured formats that provide file-system-in-a-file semantics. There are some additional utilities for document centric applications.

Libgtkol: Libgtkol is a GTK C++ Object Layer based on the libgenerics abstract services and the Gtk API. It offers the developpers a complete intuitive object API without restricting access to the Gtk functionalities themselves.

Libgtop: Libgtop is a library used by gnome-system-monitor and the system monitor applet to get various bits of information about usage of system resources, processes, etc.

Libhdate: 'hdate' is a library for obtaining Hebrew dates, holy days, times of day, and torah reading sequences. It is based on 'hdate' program for the Hebrew calendar. It includes the hcal and hdate programs. 'hcal' prints a calendar with both common and Hebrew dates for the specified month, or the whole year if no month is specified. If no arguments are given, it prints the current month. 'hdate' translates the specified date to the Hebrew calendar. If no arguments are given, it uses today's date.

LibhtmlTemplate: This is a candidate for deletion: Links broken. No archive.org entry. Email to maintainer broken. Poppy-one (talk) 15:09, 6 August 2018 (EDT) 'libhtmlTemplate' is a very simple and small library to aid you on developing CGI applications, by separating the output from the code.

Libiconv: Libiconv converts from one character encoding to another through Unicode conversion (see Web page for full list of supported encodings). It has also limited support for transliteration, i.e. when a character cannot be represented in the target character set, it is approximated through one or several similar looking characters. It is useful if your application needs to support multiple character encodings, but that support lacks from your system.

Libidn: Libidn is an implementation of the Stringprep (with the Nameprep and Kerberos 5 profiles), Punycode and IDNA specifications defined by +the IETF Internationalized Domain Names (IDN) working group, used for internationalized domain names. The library contains a generic Stringprep implementation (including Unicode 3.2 NFKC normalization, table mapping of characters, and Bidirectional Character handling), two Stringprep profiles; Nameprep (for IDN) and Kerberos5, as well as a Punycode and IDNA. This project was formerly known as 'libstringprep.'

Libintl-perl: 'libintl-perl' is a library that supports message translation for Perl. Its interface is a superset of the gettext family of functions in C, and it uses the same file formats as GNU 'gettext', so you can use all the available 'gettext' tools to integrate internationalized Perl code into mixed-language projects.

Libisoburn: Libisoburn is a frontend for the libraries libburn and libisofs. It handles the creation, loading, manipulation and burning of ISO-9660 filesystem images. This library provides a low-level API, called libisoburn API, which encapsulates the API of libburn and libisofs, and a higher level API, called xorriso API which encapsulates the API of libburn, libisofs, and libisoburn, and is also used by the xorriso program itself.

Libisofs: Libisofs creates ISO 9660 (also known as ECMA-119) file system images which can either be written to POSIX file objects or handed over to libburn for being written directly to optical media. It can read metadata of ISO 9660 filesystems, manipulate them, and use them to produce new complete file system images or add-on images to be appended to the read file system image. Supported extensions to ISO 9660 are Rock Ridge, Joliet, AAIP, zisofs. This package is part of the Libburnia Project.

Libjpeg

This package implements a JPEG codec (encoding and decoding) alongside various utilities for handling JPEG data. It is written in C and distributed as free software together with its source code under the terms of a custom permissive (BSD-like) free software license. The original variant is maintained and published by the Independent JPEG Group (IJG). Provision is made for supporting all variants of these processes, although some uncommon parameter settings aren't implemented yet. There has been no provision for supporting the hierarchical or lossless processes defined in the standard. A set of library routines is provided for reading and writing JPEG image files, plus two sample applications "cjpeg" and "djpeg", which use the library to perform conversion between JPEG and some other popular image file formats. The library is intended to be reused in other applications. In order to support file conversion and viewing software, there is considerable functionality beyond the bare JPEG coding/decoding capability; for example, the color quantization modules are not strictly part of JPEG decoding, but they are essential for output to colormapped file formats or colormapped displays. These extra functions can be compiled out of the library if not required for a particular application. There is also "jpegtran", a utility for lossless transcoding between different JPEG processes, and "rdjpgcom" and "wrjpgcom", two simple applications for inserting and extracting textual comments in JFIF files.

Forks

Libjpeg-turbo: libjpeg-turbo is a fork of libjpeg that uses SIMD instructions (MMX, SSE2, AVX2, Neon, AltiVec) to accelerate baseline JPEG compression and decompression on x86, x86-64, Arm, and PowerPC systems, as well as progressive JPEG compression on x86 and x86-64 systems. On such systems, libjpeg-turbo is generally 2-6x as fast as libjpeg, all else being equal. On other types of systems, libjpeg-turbo can still outperform libjpeg by a significant amount, by virtue of its highly-optimized Huffman coding routines. In many cases, the performance of libjpeg-turbo rivals that of proprietary high-speed JPEG codecs. libjpeg-turbo implements both the traditional libjpeg API as well as the less powerful but more straightforward TurboJPEG API. libjpeg-turbo also features colorspace extensions that allow it to compress from/decompress to 32-bit and big-endian pixel buffers (RGBX, XBGR, etc.), as well as a full-featured Java interface. libjpeg-turbo was originally based on libjpeg/SIMD, an MMX-accelerated derivative of libjpeg v6b developed by Miyasaka Masaru. The TigerVNC and VirtualGL projects made numerous enhancements to the codec in 2009, and in early 2010, libjpeg-turbo spun off into an independent project, with the goal of making high-speed JPEG compression/decompression technology available to a broader range of users and developers.

Libkml: This is a library for use with applications that want to parse, generate and operate on KML, a geo-data XML variant. It is an implementation of the OGC KML 2.2 standard. It is written in C++ and bindings are available via SWIG to Java and Python. This package contains the basic shared libraries for applications that use the KML format.

Liblo: 'liblo' is a simple, lightweight implementation of the OSC (Open Sound Control) protocol. Current features include a nonblocking mesage dispatcher (which is useful for single GUI-thread applications like Qt and GTK+), UNIX domain (FIFO) socket server/client support, TCP domain socket server/client support, the ability to stop server threads, and better regression tests.

Libmatheval: GNU libmatheval is a library that makes it possible to calculate mathematical expressions for given variable values and to calculate expression's derivative with respect to a given variable. The library supports arbitrary variable names in expressions, decimal constants, basic unary and binary operators and elementary mathematical functions. The library is stable and available for general use.

Libmemcache: 'libmemcache' is the C API for memcached(2), a high-performance, distributed memory object caching system.

Libmicrohttpd: Libmicrohttpd is a small, embeddable HTTP server implemented as a C library. It makes it easy to run an HTTP server as part of another application. The library is fully HTTP 1.1 compliant. It can listen on multiple ports, supports four different threading models, and supports IPv6. It also features security features such as basic and digest authentication and support for SSL3 and TLS.

Libmng: libmng is the reference library for MNG, the animation extension to the popular PNG format. It provides powerful animation features combined with PNG's robustness and patent freedom.

Libmodplug: libmodplug renders mod music files as raw audio data, for playing or conversion. libmodplug is based on the fast and high quality mod playing code written and released to the public domain by Olivier Lapicque. mod, .s3m, .it, .xm, and a number of lesser-known formats are supported. Optional features include high-quality resampling, bass expansion, surround and reverb.

Libmpeg2: libmpeg2 is a free library for decoding mpeg-2 and mpeg-1 video streams. Its main goals are:
* Conformance - libmpeg2 can decode all mpeg streams that conform to certain restrictions: "constrained parameters" for mpeg-1, and "main profile" for mpeg-2. * Speed - With typical video streams as found on DVD's, and doing only decoding with no display, you should get about 110 fps on a PIII/666, or 150 fps on an Athlon/950. This is less than 20 cycles per output pixel. * Portability - most of the code is in C; even platform-specific optimizations we always have a generic C routine to fall back on. This should be portable to all architectures. * Reuseability - we do not want libmpeg2 to include any project-specific code, but it should still include enough features to be used by very diverse projects.

Libnetdude: 'libnetdude' is the packet manipulation backend of the Netdude trace file editing framework. It lets you perform trace file manipulations at a much higher level of abstraction than code written directly for the pcap interface. It also supports plugins (dynamically loaded libraries) that can do whatever the programmer desires. When developers write their packet manipulation code as libnetdude plugins, other developers can use their tools. It provides data types and APIs for the most common situations when dealing with libpcap trace files: trace files of arbitrary size, packets, network protocols, packet iterators, and packet filters.

Libnids - NIDS E-component library: Libnids is a library that provides a functionality of one of NIDS (Network Intrusion Detection System) components, namely E-component. It means that libnids code watches all local network traffic, cooks received datagrams a bit (quite a bit), and provides convenient information on them to analyzing modules of NIDS. Libnids performs: a) assembly of TCP segments into TCP streams b) IP defragmentation c) TCP port scan detection

Libnofi: Python Library for managing notes. It can be used for easy development of note-taking applications. It supports some interesting features as tagging, smooth search, importing files and web pages, etc.

Libnomadii: The library for the suite that makes the driver that supports the Creative Nomad II, IIc and II MG under GNU/Linux running USB for file transfers and other operations.

Libnova: 'libnova' is a general purpose, double precision, celestial mechanics and astronomical calculation library. It can calculate aberration, nutation, apparent position, dynamical time, Julian day, precession, proper motion, sidereal time, solar coordinates (using VSOP87), coordinate transformations, planetary positions (Mercury - Neptune using VSOP87), planetary magnitude, illuminated disk and phase angle, lunar position (using ELP82), phase angle, elliptic motion of bodies (Asteroid + Comet positional and orbit data), asteroid + comet magnitudes, parabolic motion of bodies (comet positional data), orbit velocities and lengths, atmospheric refraction, rise/set/transit times, and semidiameters of the Sun, Moon, planets, and asteroids.

Libobjects

The GNU Objective C Class Library will implement the non-graphical Objective C objects of GNUstep. The GNUstep project is the Free Software Foundation's effort to implement a free-software version of NeXT's OpenStep standard. Libobjects is still in the development stages, but it already contains well over 60 classes of the GNUstep FoundationKit, and over 60,000 lines of code including both GNU and FoundationKit classes. The GNU classes in the library feature:

Collection objects for maintaining groups of objects,
strings for handling collections of characters,
Streams for I/O to various destinations,
Coders for formating objects and C types to byte streams,
ports for network packet transmission,
Distributed objects(remote object messaging),
pseudo-random number generators,
and time handling facilities.

This project is now a part of GNUStep.

Liboop: 'Liboop' provides a generic, callback-based event dispatch interface, and aims to ease the development of multiplexed, non-blocking, event-driven modular applications, components, and libraries under POSIX-based operating systems. It includes adapters for select(), poll(), the glib event loop, the TCL event loop, the W3C libwww, asynchronous DNS, and GNU readline.

Libopennet: 'Libopennet' lets developers open_net() files or URLs and get a file descriptor back that they can use to read data from. It supports HTTP (read-only) and FTP (read or write). It also comes with read_net() to do a forceful read(), and lseek_net() for calling lseek on the socket/file.

Liborigin

A library for reading OriginLab OPJ project files. FEATURES :

reads any worksheets with all columns
supports 4.1, 5.0, 6.0, 6.1, 7.0, 7.5 projects
full support for 7.5 project files (worksheets,functions,matrix,graphs,notes)

Libpcap: Library which provides a packet filtering mechanism based on the BSD packet filter (BPF). Most notably, tcpdump needs this to work, and there is also a perl module (still in beta) which can use this as well. In plain english, if you want to write your own network traffic analyzer, this is the place to start.

Libpcl: 'libpcl' is a Portable Coroutine Library implementation written in ANSI C. Coroutines can be used to implement cooperative threading among many tasks without overloading the OS with threads/processes. Since context switch between coroutines is very fast, certain applications might have performance gain in using this type of threading. It can use either the ucontext.h functionalities ( getcontext()/makecontest()/swapcontext() ) or the standard longjmp()/setjmp().

Libphish: Freshports link available but no download links available. All maintainer emails broken. Poppy-one (talk) 15:21, 6 August 2018 (EDT) Libphish is part of the Open Phishing Database project, an effort to create and maintain and open database of phishing sites in order to protect users, in addition to providing extensions to browsers that utilize the database. Libphish is a library which interacts with the Open Phishing Database, providing a consistent API which browsers and other programs can use to verify the safety and risk level of URLs.

Libping: Libping is a small C library designed to allow a programmer to make ICMP_ECHO requests directly from a script or program. The distribution includes pinger, a script-friendly utility linked to the library and intended to be invoked directly from scripts. Unlike most ping utilities, libping will timeout on both unreachable hosts and unreachable networks. It returns a value every time it is called, a feature which makes programming ICMP echo requests simpler and more reliable.

Libpropc++: 'libpropc++' is a template library for properties in C++ like this: widget.color = "red" will change the widget color to red. In class Widget use: prop::Property<Widget, Color, &Test::set_color, &Test::get_color> color; A future goal is to implement binding properties.

Libptp: 'libptp' is a Picture Transfer Protocol support library. It is used for downloading images from PTP cameras. It currently works with most modern Kodak, HP, SONY, Nikon, Canon, and other cameras that are PTP compatible (there is a full list on the Web site). It also works with some MP3 players, like the Kodak MP3. This package contains also 'ptpcam', the tool used to tweak camera properties.

Libptytty: Libptytty is a small library that offers pseudo-TTY management in an OS-independent way. It was created out of frustration over the many differences of PTY/TTY handling in different operating systems for use inside "rxvt-unicode". It also offers session database support (utmp and optional wtmp/lastlog updates for login shells) and supports forking after startup and dropping privileges in the calling process. It offers C++ and C-only APIs.

Libqalculate: Library for Qalculate and assorted modules.

Libqglviewer: 'libQGLViewer' is a C++ library which lets you quickly start the development of a new 3D application. It is designed for 3D developers, who can display and move around a 3D scene by simply providing the openGL orders that define their 3D geometry. The viewer is designed to be as general as possible and is not designed for a specific 3D application. It provides some useful classical functionalities such as a camera trackball, screenshot saving, mouse manipulated frames, stereo display, keyFrames and more. 'libQGLViewer' is not a 3D viewer that can be used directly to view 3D scenes in various formats; it is more likely to be the starting point for the coding of such a viewer.

Libquantum: 'libquantum' is a simulation of a quantum computer. It provides an interface for a quantum register and for all important quantum operations. An efficient model for decoherence allows an analysis of quantum computation in a realistic environment. Features include the simulation of arbitrary algorithms, high performance and low memory consumption and interfaces for quantum error correction (QEC) and the density operator formalism. The package includes implementations of Shor's factoring algorithm and Grover's search algorithm.

Libradix: C library for implementing Generic Radix sort and Radix sort of arbitrary length strings.

Library to create PostScript files: pslib is a C-library for generating PostScript files with little effort. It offers an easy way of generating PostScript text and graphics. Its text function are very sophisticated and support kerning, ligatures and some basic formatting. Hypertext functions are supported through pdfmarks which makes pslib in combination with ghostscript a viable alternative for libraries creating PDF.

Librep: librep is a shared library implementing a Lisp dialect that is lightweight, reasonably fast, and highly extensible. It contains an interpreter, byte-code compiler and virtual machine. Applications may use the interpreter as an extension language, or it may be used for standalone scripts.

Libressl

LibreSSL is a version of the TLS/crypto stack, forked from OpenSSL in 2014 with the goals of modernizing the codebase, improving security, and applying best practice development processes. This package also includes a netcat implementation that supports TLS. The source code is developed upstream by the OpenBSD project and regularly re-packaged for portable use. This package includes:

openssl, an utility which provides tools for managing keys and certificates
libcrypto: a library of cryptography fundamentals
libssl: a TLS library, backwards-compatible with OpenSSL
libtls: a new TLS library, designed to make it easier to write foolproof applications.

Librsb: librsb is a library for sparse matrix computations featuring the Recursive Sparse Blocks (RSB) matrix format. This format allows cache efficient and multi-threaded (that is, shared memory parallel) operations on large sparse matrices. The most common operations necessary to iterative solvers are available, e.g.: matrix-vector multiplication, triangular solution, rows/columns scaling, diagonal extraction / setting, blocks extraction, norm computation, formats conversion. The RSB format is especially well suited for symmetric and transposed multiplication variants. On these variants, librsb has been found to be faster than Intel MKL's implementation for CSR. Most numerical kernels code is auto generated, and the supported numerical types can be chosen by the user at build time. librsb implements the Sparse BLAS standard, as specified in the BLAS Forum documents.

Librsync: 'Librsync' provides checksum-based differencing. Currently its only application is rproxy, which provides diffs to previously cached Web pages and images in order to speed download time.

Libsafe: The exploitation of buffer overflow and format string vulnerabilities in process stacks are a significant portion of security attacks. 'libsafe' is based on a middleware software layer that intercepts all function calls made to library functions known to be vulnerable. A substitute version of the corresponding function implements the original function in a way that ensures that any buffer overflows are contained within the current stack frame, which prevents attackers from overwriting the return address and hijacking the control flow of a running program. The true benefit of using libsafe is protection against future attacks on programs not yet known to be vulnerable. The performance overhead of libsafe is negligible, it does not require changes to the OS, it works with existing binary programs, and it does not need access to the source code of defective programs, or recompilation or off-line processing of binaries.

Libshout: 'libshout' allows applications to easily communicate and broadcast to an Icecast streaming media server. It handles the socket connections, metadata communication, and data streaming for the calling application, and lets developers focus on feature sets instead of implementation details.

Libsigcpp: 'libsigc++' implements a full callback system for use in abstract interfaces and general programming. It is the most complete library of its kind with the ability to connect an abstract callback to a class method, function, or function object. It contains adaptor classes for connecting dissimilar callbacks and has an ease of use unmatched by other C++ callback libraries.

Libsigsegv: GNU libsigsegv is a library for handling page faults. A page fault occurs when a program tries to access a region of memory that is currently not available. Catching and handling a page fault is a useful technique for implementing garbage collectors, stack overflow handlers, persistent databases, and distributed shared memory.

Libslack: Libslack is a library of general utilities designed to make UNIX/C programming a bit easier on the eye. It was originally implemented as part of the daemon program. It is a small library with lots of functionality and is accurately documented and thoroughly tested. Good library naming conventions are not rigorously observed on the principle that common operations should always be easy to write and code should always be easy to read.

Libsmtp: This is a candidate for deletion: Links broken. No archive.org entry. Email to maintainer broken. Poppy-one (talk) 10:32, 10 August 2018 (EDT) Libsmtp allows programs to send mail directly through SMTP (no sendmail needed) and attaching and encoding mail in MIME standards. It is designed to be simple, secure, and small. It can send mail to multiple recipients in one go, and supports sending to CC and BCC recipients too.

Libsndfile: 'libsndfile' is a C library for reading and writing sound files such as AIFF, AU, WAV, and others through one standard interface. It can currently read/write 8, 16, 24 and 32-bit PCM files as well as 32 and 64-bit floating point WAV files and a number of compressed formats.

Libspectre: libspectre provides a convenient easy to use API for handling and rendering Postscript documents.

Libspf2: 'libspf2' implements the Sender Policy Framework, which verifies that the Sender address of an email message matches (according to some policy) the client IP address that submitted it. This is unlike the present SMTP standard for email, which allows anyone to forge anyone else's email address. SPF libspf2 is a complete and robust implementation of SPF which provides support for many MTAs. It is designed to be secure, correct, portable, flexible, and fast (in that order).

Libsrs2: 'libsrs2' is a Sender Rewriting Scheme library. SPF verifies that the Sender address of an email message matches (according to some policy) the client IP address that submitted itand rewrites this address to comply with SPF policy. The Sender Rewriting Scheme, or SRS, provides a standard for this rewriting that is not vulnerable to attacks by spammers.

Libstrfunc: Handy library for manipulating strings, string arrays, buffers, CGI forms, configuration files, textual templates, regular expressions, date/time parsing, et cetera. It handles base64, quoted-printable, url_encode, mime-words and other encoded data.

Libtar: Libtar is a C library for manipulating POSIX tar files. It handles adding and extracting files to/from a tar archive. Requires gcc, make, and zlib.

Libtasn1 ,: Libtasn1 is a library implementing the ASN.1 notation. It is used for transmitting machine-neutral encodings of data objects in computer networking, allowing for formal validation of data according to some specifications.

Libtecla: The Tecla library provides programs with interactive command line editing facilities, similar to those of the unix tcsh shell. It supports recall and editing of previously entered command lines, TAB completion of file names and application specific tokens, and in-line wild-card expansion of filenames. The optionally reentrant modules which perform TAB completion and wild-card expansion are also available separately for general use.

Libtheora: 'Theora' is Xiph.Org's first publicly released video codec, intended for use within the Ogg's project's Ogg multimedia streaming system. It is derived directly from the VP3 codec; currently the two are nearly identical, varying only in encapsulating decoder tables in the bitstream headers, although substantial changes and improvements may be expected in the future.

Libtiff: 'libtiff' provides support for the Tag Image File Format (TIFF), a widely used format for storing image data. This package includes a library (libtiff) for reading and writing TIFF, a small collection of tools for doing simple manipulations of TIFF images and documentation on the library and tools. A small assortment of TIFF-related software that has been contributed by others is also included. The library, along with associated tool programs, should handle most of your needs for reading and writing TIFF images on 32- and 64-bit machines.

Libtour: 'libtour' is a generic tournament processing library. The rules, participants, schedule, and results of a sporting tournament are defined in Scheme programming language and given to the library as input. Since 'libtour' only knows the structure of an event as it is roughly , it can therefore interpret any sporting tournament that conforms to the structure. A CLI application is provided as a reference client implementation. See http://freshmeat.net/projects/qtour/ for a Qt-based client.

Libtranslate: 'libtranslate' is a library for translating text and Web pages between natural languages. Its modular infrastructure lets users implement new translation services separately from the core library. It is shipped with a generic module that supports Web-based translation services (ie, BabelFish) and lets new services be added simply by adding a few lines to an XML file. The distribution also includes a command line interface.

Libtrash: 'libtrash' is a shared library which, when preloaded, intercepts calls to glibc's unlink() and rather than permanently deleting those files, moves them to a "trash can". Your mistakes (at least those of the "rm -rf dir /" class :-)) will no longer cause the loss of work or of your system's binaries.

Libundo: 'Libundo' is a simple, easy-to-use library which manages recording and playback of undo/redo information for application developers. It is intentionally simple so it can plug in to existing applications and require the writing of only a minimal amount of support code to support multi-level undo/redo.

Libuninum: libuninum is a library for converting Unicode strings to integers and integers to Unicode strings. Internal computation is done using arbitrary precision arithmetic, so there is no limit on the size of the integer that can be converted. Values are passed and returned as ASCII decimal strings, GNU MP mpz_t objects, or unsigned long integers. Auto-detection of the number system is provided. Group delimitation for output strings is fully controllable. Virtually all known number systems are supported.

Libunistring: Libunistring is a library providing functions to manipulate Unicode strings and for manipulating C strings according to the Unicode standard. Libunistring can be used by applications involving non-trivial text processing, such as upper/lower case conversions, line breaking, operations on words, or more advanced analysis of text. Text provided by the user can, in general, contain characters of all kinds of scripts. The text processing functions provided by this library handle all scripts and all languages. It also may be useful for an application that already uses the ISO C / POSIX <ctype.h>, <wctype.h> functions and the text it operates on is provided by the user and can be in any language. The library is also useful for applications using Unicode strings as internal in-memory representation.

Libusb: libusb is a library for use by user level applications to access USB devices regardless of OS. libusb is abstracted internally in such a way that it can hopefully be ported to other operating systems.

Libvisca: Libvisca provides an API for VISCA compliant cameras. VISCA is a protocol developed by Sony for their CCTV cameras, certain webcams and video-conference cameras. This protocol works over an RS232 link. Libvisca API allows you to control most parameters, such as exposure, zoom, focus, iris, and white balance. Libviscaalso supports multiple daisy chained cameras on a single RS232 port.

Libwebp: Provides libwebp.so, a library for encoding and decoding WebP image files. It also contains the command line tools 'cwebp' and 'dwebp'. libwebp is Google's official encoder for WebP images. It can encode in either lossy or lossless mode. Lossy images are essentially a wrapper around a VP8 frame. Lossless images are a separate codec developed by Google. Currently, libwebp only supports YUV420 for lossy and RGB for lossless due to limitations of the format and libwebp. Alpha is supported for either mode. Because of API limitations, if RGB is passed in when encoding lossy or YUV is passed in for encoding lossless, the pixel format will automatically be converted using functions from libwebp. This is not ideal and is done only for convenience.

Libxcpc: The libxcpc library implements automatic resource cleanup and exception handling in C. It offers the notion of Resource Containers organized in a hierarchical way, with automatic cleanup, embedded in C++ like exception handling.

Libxklavier: 'libxklavier' is a library providing high-level API for X Keyboard Extension known as XKB. It is meant to support XFree86 and other commercial X servers. It is useful for creating XKB-related software (layout indicators etc).

Libxmi: A standalone C/C++ function lib for rasterizing 2-D vector graphics. The program can draw 2-D vector graphics primitives, including wide polygonal line and circular and elliptical arcs, onto a user-supplied matrix of pixels. Sophisticated line styles, such as multicolored dashing patterns, can be specified. There is also support for filling and texturing polygons. The program is based on the vector graphics code found in most X windows system servers, but despite its origins, libxmi is completely decoupled from X11. It draws vector graphics onto a user-supplied matrix of pixels, not onto an on-screen window, and uses its own two-stage graphics pipeline.

Libxml++: This package provides a C++ wrapper for the XML parser library libxml2.

Libxml2: Libxml2 is the XML C parser and toolkit developed for the Gnome project, but it can be used outside of GNOME. It provides functions which allow reading data from XML files as well as changing data within the XML tree structure and saving the changing to be used later. Though the library is written in C a variety of language bindings make it available in other environments. This package (a.k.a. libxml or gnome-xml) implements a number of existing standards related to markup languages, including the XML standard, Namespaces in XML, XML Base, RFC 2396, XPath, XPointer, HTML4, XInclude, SGML Catalogs, and XML Catalogs. In most cases, libxml tries to implement the specifications in a relatively strict way. To some extent, it provides support for the following specifications, but doesn't claim to implement them: DOM, FTP client, HTTP client, SAX, and DocBook SGML. Support for W3C XML Schemas is in progress.

Libytnef: The library necessary for the running of ytnef, aka, Yerase's TNEF Stream Reader.

Libzip: 'libzip' is a library for reading, creating, and modifying zip archives. Users can add files from data buffers, files, or compressed data copied directly from other zip archives, and can revert changes made without closing the archive.

Free Software Foundation!

Semantic search

Query log

Main Features

apel

emu

Note

llibcurl

Main features

Features

Notes

Forks

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Interaction

Navigation

Creation

Print

Tools