[[Interface::library]]

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.

Free Software Foundation!

Semantic search

Query log

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Interaction

Navigation

Creation

Print

Tools