[[Interface::library]]

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.

Lightning: GNU lightning is a library that generates assembly language code at run-time, it is very fast, making it ideal for Just-In-Time compilers, and it abstracts over the target CPU, as it exposes to the clients a standardized RISC instruction set inspired by the MIPS and SPARC chips.

Link Grammar: The Link Grammar Parser is a syntactic parser of English, based on link grammar, an original theory of English syntax. The system assigns to a sentence a syntactic structure, which consists of a set of labeled links connecting pairs of words. The parser also produces a "constituent" representation of a sentence (showing noun phrases, verb phrases, etc.). The parser has a dictionary of about 60000 word forms. It covers a range of syntactic constructions, including many rare and idiomatic ones. The parser skips over the portions of the sentence that it cannot understand, and assigns some structure to the rest of the sentence. It can handle unknown vocabulary, and makes intelligent guesses from context and spelling about the syntactic categories of unknown words. It understands capitalization, numerical expressions, and various punctuation symbols.

LinkGrammar-WN: LinkGrammar-WN is a lexicon expansion for the Link Grammar Parser. The Link Grammar Parser is a syntactic parser of the English language that is capable of handling a wide variety of syntactic constructions and is considered quite robust. The LinkGrammar-WN project aims to import lexical information from WordNet in an effort to increase the size of the LGP lexicon. This project is of interest to anyone interested in NLP (natural language parsing) of English text.

Lionet: This is a candidate for deletion: 1. No files sources found. A Django application for serving pickle-built Sphinx docs.

Litetrash: 'litetrash' is a shared library which, when preloaded, implements a trash can. Itworks in the same way as libtrash (by intercepting function calls which might lead to accidental data loss), however it has virtually no configuration options and will hopefully compile on any *NIX system.

Lm sensors: This is a candidate for deletion: Links broken. No archive.org entry. Email to maintainer broken. Poppy-one (talk) 15:51, 23 August 2018 (EDT) Available still at https://packages.debian.org/search?keywords=lm-sensors&searchon=names&suite=all&section=all lm_sensors provides essential drivers for monitoring the temperatures, voltages, and fans of systems with the Linux kernel, containing devices such as the LM78 and LM75. It contains drivers for sensor chips and I2C and SMBus masters. It also contains text-based tools for sensor reporting, and a library for sensors access called 'libsensors'. It also contains tools for sensor hardware identification and I2C bus probing. There is a list of supported drivers on the Web site.

Lobbyists: This package provides a reference parser and database importer for the United States Senate LD-1/LD-2 lobbying disclosure database. The Senate provides the database as a series of XML documents, downloadable here: http://www.senate.gov/legislative/Public_Disclosure/database_download.htm The SQL database schema used by the importer is a direct translation of the XML schema used in the Senate documents. This isn't a particularly useful format for analyzing lobbying data, but it is useful for analyzing the lobbying records themselves, which often contain errors or anomalies. In any case, it shouldn't be too difficult to adapt the importing code in this package to a more useful schema.

Lodepng: No dependency or linkage to zlib or libpng required.

Log4c: 'Log for C' is a library for flexible logging to files, syslog, and other destinations. It is modeled after the Log for Java library, staying as close to its API as is reasonable.

Loopess: All links broken. Redirected homepage to archive.org. Poppy-one (talk) 17:16, 29 August 2018 (EDT) Loopess is a small signal and select loop library for applications running on POSIX operating systems. It provides a convenient abstraction of signals, file descriptor events, and timeouts for single-threaded applications using a simple C++ class structure. Loopess properly handles the race condition introduced by mixing signals with the select system call. It uses sigsetjmp and siglongjmp to jump out of signals that occur just prior to entering the select call. Otherwise, these signals would not be processed until the next file descriptor event. Jumping out of these signals safely prevents entering into the blocking select system call. As of Feb 29, 2004, development on this project has been discontinued as per the maintainer.

Loudmouth: Loudmouth is a lightweight Jabber client library written in C/Glib.

LuaSocket: LuaSocket is a Lua extension library that is composed by two parts: a C core that provides support for the TCP and UDP transport layers, and a set of Lua modules that add support for functionality commonly needed by applications that deal with the Internet. The core support has been implemented so that it is both efficient and simple to use. It is available to any Lua application once it has been properly initialized by the interpreter in use.

Lzlib: The lzlib compression library provides in-memory LZMA compression and decompression functions, including integrity checking of the uncompressed data. The compressed data format used by the library is the lzip format. The functions and variables forming the interface of the compression library are declared in the file lzlib.h. An usage example of the library is given in the file main.cc. Compression/decompression is done by repeatedly calling a couple of read/write functions until all the data has been processed by the library. This interface is safer and less error prone than the traditional zlib interface.

M1QN3: The routine M1QN3 has been designed to minimize functions depending on a very large number of variables (several hundred million is sometimes possible) not subject to constraints. It implements a limited memory quasi-Newton technique (the L-BFGS method of J. Nocedal) with a dynamically updated scalar or diagonal preconditioner. It uses line-search to enforce global convergence; more precisely, the step-size is determined by the Fletcher-LemarÃÂ©chal algorithm and realizes the Wolfe conditions.

MARC Perl: MARC/Perl is a Perl library for reading, manipulating, outputting and converting bibliographic records in the MARC format. However, it is often advantageous for libraries to be able to create or massage pre-existing MARC data on the way into or out-of such systems. This is the niche that MARC/Perl was designed to fill. MARC.pm development began in the summer of 1999. After much experimentation, enhancement and discussion the MARC::Record framework was adopted which provides a scalable approach to processing MARC data with Perl. Users can still download and get documentation for MARC.pm, but it is recommended that new users download MARC::Record. Future development of the MARC namespace on CPAN will be through MARC::Record.

MCS Libre (Monte-Carlo simulation): MCS-libre is a free utility for Monte-Carlo simulation. It is a library of header files that can easily be inserted into a C++ program. A C++ compiler is required. This author recommends using the GNU compiler g++.

MD (md.py): A library of language-level features for Python. Features include transactional memory, a dynamic environment, and a simple testing framework.

MLton: MLton is a whole-program optimizing Standard ML compiler that supports the full SML 97 language. Features include a complete basis library (except for use) matching the 2002 specs, untagged native integers and reals, unboxed native arrays, fast C FFI, multiple garbage collection strategies (copying, mark contact, generational), source-level profiling of both time and allocation, and a fast IntInf based on GNUmp. It also includes libraries for continuations, finalization, heap save and restore, interval timers, random numbers, resource limits, resource usage, signal handlers, system logging, threads, weak pointers.

MN: MyNews perl module contains Perl object classes to manage the data of MyNews. It can handle PostgreSQL and MySQL backends. It has an API for CGI access to MyNews data.

MN-CMS: 'MN::CMS' provides a set of new classes to manage articles in MyNews. MyCMS is a Content Manager System based on MyNews that lets users write articles and publish them on the MyNews website. Articles can be moderated.

MODEL

MODEL is a C++ library to analyse and simulate various kinds of rate equations which describe Vertical Cavity Surface Emitting Lasers (VCSELs). It can also be used to simulate other physical systems. The main functions of the various classes of the library include:

Deterministic integration of any system of well-behaved differential equations.
Stochastic integration of these systems, with the possibility of specifying the correlations present in the noise
Nonlinear rootfinder, to find stationary solutions
Eigenvalue determination, for stability analysis
Easy time modulation of input parameters
Diverse data collecting classes for data analysis
Small signal analysis (first order)

MPFI: MPFI (Multiple Precision Floating-Point Interval Library) is a library for arbitrary precision interval arithmetic with intervals represented using MPFR reliable floating-point numbers. It is based on the GNU MP library and on the MPFR library. The purpose of an arbitrary precision interval arithmetic is on the one hand to get guaranteed results, thanks to interval computation, and on the other hand to obtain accurate results, thanks to multiple precision arithmetic. The MPFI library is built upon MPFR to benefit from the correct roundings provided by MPFR, it portability, and its compliance with the IEEE 754 standard for floating-point arithmetic.

MPK: MathParseKit is a C++ Library that allows an easy integration of a mathematical functions interpreter.

MQ4CPP: MQ4CPP (Message Queuing for C++) is an implementation of enterprise messaging system, aka "message-oriented middleware" (MOM). It lets C++ application threads communicate with one another through exchanging messages. A message is a request, report, and/or event that contains information needed to coordinate communication between different applications. It provides a level of abstraction, so you can separate the details about the destination system from the application code. MQ4CCP lets C++ applications that share a messaging system exchange messages, and simplifies application development by providing a standard interface for creating, sending, and receiving messages. It implements the following messaging paradigms: Direct/Indirect messaging (local), unsolicited messaging (remote), Request/Reply (remote), conversation (remote), and broadcast (local/remote).

MQS: MQS (Minimalist Queue Services) is a minimalist queueing system that provides basic methods for offering asynchronous messaging. It lets applications store and retrieve messages to a dedicated queue in the queue services. This avoids direct connections between applications and provides a simple asynchronous communication system. The MQS Daemon provides a simple set of XML-RPC methods for pushing and getting messages in a given queue (you can use the system with any application that can talk XML-RPC). The queue is stored in either a database (e.g. Mysql, Postgresql) or in dedicated file(s) (e.g. QDBM).

MUNTL: 'MUNTL' is a multiprecision unsigned number template library. It is intended for the organization of calculations with the big precision for unsigned numbers, ie cases where there are unsigned numbers whose length exceeds the ability of a current platform to handle them. These cases include storage of big numbers (ie factorials) and the operations associated with them, emulation of registers of large length, and indications of errors in position code.

Mailutils: Mailutils is a collection of programs for managing, viewing and processing electronic mail. It contains both utilities and server daemons and all operate in a protocol-agnostic way. The underlying libraries are also available, simplifying the addition of mail capabilities to new software. Several tools are built atop of these libraries and included in the package. Among them are pop3 and imap4 servers, the traditional mailx mail reader, the sieve mail filtering utility and a complete set of MH utilities that can be used with GNU Emacs MH-E mode.

Mastrave: Mastrave is a free software library written to perform vectorized scientific computing and to be as compatible as possible with both GNU Octave and Matlab computing frameworks, offering general purpose, portable and freely available features for the scientific community. Mastrave is mostly oriented to ease complex modeling tasks such as those typically needed within environmental models, even when involving irregular and heterogeneous data series. Semantic array programming The Mastrave project attempts to allow a more effective, quick interoperability between GNU Octave and Matlab users by using a reasonably well documented wrap around the main incompatibilities between those computing environments and by promoting a reasonably general idiom based on their common, stable syntagms. It also promotes the systematic adoption of data-transformation abstractions and lightweight semantic constraints to enable concise and reliable implementations of models following the paradigm of semantic array programming. There are a couple of underlying ideas: library design is language design and vice versa (Bell labs); language notation is definitely a "tool of thought" (version), in the sense that there is a feedback between programming/mathematical notation and the ability to think new scientific insights. And perhaps ethic ones. Science and society Mastrave is free software, which is software respecting your freedom. As many other free scientific software packages, it is offered to the scientific community to also promote the development of a free society more concerned about cooperation rather than competitiveness, heading toward knowledge and culture freedom. Such a vision implies the possibility for motivated individuals to freely access, review and contribute even to the cutting-edge academic culture. This possibility relies on the development of tools and methodologies helping to overcome economic, organizational and institutional barriers (i.e. knowledge oligopolies) while systematically promoting reproducible research. This is a long-term goal to which the free software paradigm can and has been able to actively cooperate.

Math MatrixReal: Math::MatrixReal lets you manipulate NxN real matrices. Features include eigenvalues, eigenvectors, solving linear systems by various methods, determinants, many flexible ways to create matrices, and operator overloading.

MathBench: Helps in developing small Python scripts quickly. MathBench is extensible by plugins that can provide facilities to easily access some external libraries (for instance pylab) and also provide documentation and code samples through MathBench's integrated documentation system (aka "LibraryDesk").

MathGL: MathGL library makes wide spectrum of scientific graphics (plots, surfaces, contours, isosurfaces and so on) in platform independent way. Graphics may be exported to EPS, PNG, JPEG or TIFF formats. Front-end for library is based on OpenGL and GLUT libraries. Also it is possible to draw plot in console regime directly to file (bitmap or vector PostScript) without using X-server. Output graphics (bitmap drawed in memory) is adapted for using with wxWidgets and FLTK libraries.

MathGene: MathGene is a comprehensive JavaScript mathematics engine that delivers the ability to perform advanced numerical and symbolic mathematics processing of LaTeX expressions and send the output to pure HTML for rendering on a conventional web browser or via web server. MathGene has two modules: •mg_translate.js, which translates between LaTeX, HTML, and native MG format. •mg_calculate.js, which performs the calculations. mg_translate.js can be used without mg_calculate.js to perform mathematics rendering only. Both modules are required to perform calculations.

Matjito: "Matjito' is a pluggable library for fast computation of mathematical expressions in C++ programs. Matjito's input can be either expression string with information about mapping of symbols to variables and functions - parser mode, or n-ary tree representing expression - evaluator mode. It is x86 JIT, so it can compute expressions in a really fast way (comparable to or even better than code generated by optimizing C compilers).

MatrixSSL: PeerSec Network's MatrixSSL is an embedded SSL implementation designed for small footprint devices and applications requiring low overhead per connection. The library is less than 50K on disk with full cipher suites. It includes SSL client and SSL server support, session resumption, and implementations of RSA, 3DES, ARC4, SHA1, and MD5. The source is well documented and contains portability layers for additional operating systems, cipher suites, and cryptography providers.

Maverik: Maverik is a development toolkit that supports 3D virtual environments and interaction with those environments. It sits on top of a low-level rendering engine that uses OpenGL or Mesa, and provides mechanisms to render different kinds of objects, to manage environments and to provide support for 3D interaction. The system is open-ended in how its representation of different models. It uses call back functions, rather than importing and converting data to its own formats; this means it can be adapted relatively easily to widely differing application data structures without forcing particular representations on the implementor. For example, if you have a sim in which different parts of your model are varying dynamically but in ways that cannot be represented using the normal affine transformations (eg deformable objects), then Maverik lets you use the dynamically changing data directly to generate images. It also contains support for a variety of 3D input designs, and various kinds of displays (including stereo).

Maximum Length Sequence (MLS) library: libmls is a system response measurement library that uses a Maximum Sequence Length signal for excellent noise immunity. It allows gated measurements to minimise effects of room reflections. It also allows measurement of electrical systems including impedence vs frequency plots in a single two channel measurement. libmls can also meassure a system response using a swept sine tone.

Meanwhile: The heart of the Meanwhile Project is the Meanwhile library, providing the basic Lotus Sametime session functionality along with the core services; Presence Awareness, Instant Messaging, Multi-user Conferencing, Preferences Storage, Identity Resolution, and File Transfer. This extensible client interface allows additional services to be added to a session at runtime, allowing for simple integration of future service handlers such as the user directory and whiteboard and screen-sharing.

Mediastreamer: Mediastreamer is library written in C that allows you to create and run audio and video streams. It is designed for any kind of voice over IP applications. It features RTP connectivity, audio codecs (Speex, iLBC, G711, GSM), video codecs (MPEG4, H263, Theora), I/O from soundcards, wav files, webcams, echo-cancelation, conferencing, and various other utilities. It has a modular design that makes it extensible through plugins. This is the media-streaming component of linphone, a GPL SIP video phone.

Mediatex: The Mediatex project intends to make easier as possible archives management by spreading and accessing "write once read many" supports (as compact disks) and dedicated metadata. It provides a server sharing perennial URLs on electronic records.

Memcache Client: A ruby library for accessing memcached.

Metahtml: MetaHTML is a server-side programming language designed for the World Wide Web. It has a syntax that is similar to HTML and Lisp. It provides a large function library, including support for sockets, image creation and connections to other programs.

Metakit: 'Metakit' fills the gap between flat-file, relational, object-oriented, and tree-structured databases, supporting relational joins, serialization, nested structures, and instant schema evolution. There is a C++ API, a Python binding (Mk4py), and a Tcl binding (Mk4tcl). Data files are portable, use auto-sizing ints and strings, and can efficiently store binary data from single bits to multi-Mb objects. MetaKit works well for moderate-size (a few dozen Mb) datasets, and offers excellent performance well beyond that size when its column-wise data model is fully taken advantage of.

MiLi- Minimalistic headers-only C++ Library

MiLi is a collection of useful C++ libraries, composed only by headers. No installation, no makefile, no complications: just KISS. Simple solutions for simple problems. MiLi includes the following libraries (one header file length each):

bitwise-enums: library for type-safe bitwise operations based on enums.
pre-pos caller: library for wrapping object methods calls.
promotion-disable: library for disabling undesired C++ type conversions.
delete-container: deletes the elements of an STL container filled with pointers.
factory: provides a simple machinery to create subclasses from a given key.
invariants: provides invariants for function arguments and classes.
type-mapper: simple type mapping declarations.
properties: simple properties implementation.
string-utils: UPDATED various string utilities, such as case-insensitive strings and number/text conversions.
find-utils: generic find/containment test utilities, optimized for specific containers.
stream-utils: NEW! i/o stream utilities for reading/writing formatted data (such as CSV).

Micro Window-Gadgets: UWG is a lightweight gadget/windowing toolkit for C and X11. Interfaces are described using XML and are turned into C code using the ubuildinit utility. Currently, only a small percentage of the planned gadgets are implemented.

Mifluz: The purpose of mifluz is to provide a C++ library to build and query a full text inverted index. It is dynamically updatable, scalable (up to 1Tb indexes), uses a controlled amount of memory, shares index files and memory cache among processes or threads and compresses index files to 50% of the raw data. The structure of the index is configurable at runtime and allows inclusion of relevance ranking information. The query functions do not require to load all the occurences of a searched term. They consume very few resources and many searches can be run in parallel.

Mimetic: 'mimetic' is a MIME library written in C++ designed to be easy to use and integrate but yet fast and efficient. It's standard compliant using the Standard Template Library for base C++ structures and supporting all relevant messaging RFCs. A powerful template encoding/decoding engine is also included to allow seamless extendibility (i.e. encryption codecs) and intuitive codec chains creation (using well-known Unix-style pipes syntax: a b c). Real world examples, documentation, and regression tests are included.

Ming: 'Ming' is a C library for generating SWF ("Flash") format movies, plus a set of wrappers for using the library from C++ and popular scripting languages like PHP, Perl, Python, and Ruby. The package also includes a command-line actionscript compiler.

Mini-XML: Mini-XML is a small XML library that you can use to read and write XML and XML-like data files in your application without requiring large non-standard libraries. Mini-XML only requires an ANSI C compatible compiler (GCC works, as do most vendors' ANSI C compilers) and a 'make' program. Mini-XML supports reading of UTF-8 and UTF-16 and writing of UTF-8 encoded XML files and strings. Data is stored in a linked-list tree structure, preserving the XML data hierarchy, and arbitrary element names, attributes, and attribute values are supported with no preset limits, just available memory.

Mod tidy: mod_tidy works as a filter that hooks up to the (X)HTML output of an Apache 2 webserver. It passes the webservers' (X)HTML output to TidyLib which parses and optional cleans-up and pretty-prints that output. If TidyLib detects an error, the client receives a HTML page with a list of all found errors and warnings that prevent the input of being a valid (X)HTML document. If TidyLib doesn't complain, the client will get and display the (X)HTML data as without mod_tidy. Due to the fact that mod_tidy may affect little response delays of the webserver, its use should be reduced to a developer framework only. mod_tidy is not recommended to be used in a production environment, where response delays of the webserver are undesirable.

Monolith: Monolith is a framework for web applications. Instead of thinking of your web application as a series of pages and forms, Monolith gives you basic widgets like buttons, images, form fields, tables and so on, which you can use to build up your web application or construct reusable super-widgets. In this way, building a web application is rather like constructing a traditional GUI application using Gtk, Motif, Windows/MFC, Java/JFC, etc. Monolith applications are written in C or C++. Monolith applications compile down to standalone shared object scripts which can be run directly from the rws micro web server.

More-itertools: This package provides functions for grouping, lookahead and lookback, windowing, augmenting, combining, summarizing, selecting and many other operations based on the iterables provided by Python.

Mozjpeg

This library aims to speed up loading times of webpages by achieving a reduction in file size and therefore transmission time through improvement of coding efficiency while retaining image quality. To achieve this, it uses more processing power for the encoding (asymmetry) while retaining full compatibility with the JPEG standard and requiring no changes on the decoder side. The techniques MozJPEG uses to achieve high compression include optimising Huffman trees, using progressive coding to optimally split the spectrum of DCT coefficients into separate scans, and through the use of trellis quantisation. Additionally, the presets are aggressively tuned towards the minimisation of file sizes. MozJPEG is a fork of libjpeg-turbo. MozJPEG is compatible with the libjpeg API and ABI. It is intended to be a drop-in replacement for libjpeg. MozJPEG is a strict superset of libjpeg-turbo's functionality. All MozJPEG's improvements can be disabled at run time, and in that case it behaves exactly like libjpeg-turbo. Besides libjpeg-turbo, MozJPEG also builds upon jpegcrush, a Perl script by Loren Merritt. An internet application of this tool is available at https://mozjpeg.com/.

Features

Progressive encoding with "jpegrescan" optimization. It can be applied to any JPEG file (with jpegtran) to losslessly reduce file size.
Trellis quantization. When converting other formats to JPEG it maximizes quality/filesize ratio.
Comes with new quantization table presets, e.g. tuned for high-resolution displays.
Fully compatible with all web browsers.
Can be seamlessly integrated into any program that uses the industry-standard libjpeg API. There's no need to write any MozJPEG-specific integration code.

Mpatrol: 'mpatrol' is a link library that diagnoses run-time errors caused by the wrong use of dynamically allocated memory, including writing to free memory and memory leaks. It provides a configurable log of all dynamic memory operations (such as malloc(), operator new, etc.) that occurred during the lifetime of a program, checks to detect misuse of dynamically allocated memory, and has support for both memory allocation profiling and tracing. Users can change the library settings at run-time via an environment variable without recompiling or relinking.

Mpc: MPC is a complex floating-point library with exact rounding. It is based on the GNU MPFR floating-point library, which is itself based on the GNU MP library. This is a C library for the arithmetic of complex numbers with arbitrarily high precision and correct rounding of the result. It extends the principles of the IEEE-754 standard for fixed precision real floating point numbers to complex numbers, providing well-defined semantics for every operation. At the same time, speed of operation at high precision is a major design goal.

Mpdired: MPDired is an Emacs front-end (client) for the Music Player Daemon (mdp) with interactions inspired from Dired. It features two views packed into the same interactive buffer: the browser view and the queue view.

Mpfr: The MPFR library is a library for multiple-precision floating-point computation with exact rounding. The computation is both efficient and has a well-defined semantics. It copies the good ideas from the ANSI/IEEE-754 standard for double-precision floating-point arithmetic.

Mplib: C Library that lets programs access ID3 tags id3v1 and v2 in mp3 files. These tags are meta-informations such as the title, artist or comments that come with most MP3s. It is easy to use and fast.

Mpmath

Mpmath is a pure-Python library for multiprecision floating-point arithmetic. It provides an extensive set of transcendental functions, unlimited exponent sizes, complex numbers, interval arithmetic, numerical integration and differentiation, root-finding, linear algebra, and much more. Almost any calculation can be performed just as well at 10-digit or 1000-digit precision, and in many cases pmath implements asymptotically fast algorithms that scale well for extremely high precision work. If available, mpmath will (optionally) use gmpy to speed up high precision operations. If matplotlib is available, mpmath also provides a convenient plotting interface. Its features include:

Fair performance -- typically 10-100x faster than Python's decimal library
Transcendental functions -- all functions from Python's math and cmath modules, plus a few more like gamma, factorial, erf
Complex numbers -- with support for transcendental functions
Directed rounding -- floor, ceiling, down, up, half-down, half-up, half-even
Unlimited exponents -- no overflow or underflow

Msnlib: a Python MSN messenger protocol library and client.

Multidict: This provides a way to manage or deal with such structures which can have more than one occurrence of a given key.

Mw-template: 'mw-template' is the Ruby part of a template library. It includes both the library itself and tests for it.

MySql2: A modern, simple and very fast Mysql library for Ruby.

NML: The Numerical Methods Library is a C library that deals with numerical analysis. Unlike packages that implement integrals, differentiation, interpolation, etc using only one algorithm, NML implements them using many algorithms; one function for each this is because the NML tends to be a way for helping to study the differences between different algorithms.

NURBSS++: Non-Uniform Rational B-Splines (NURBS) curves and surface are parametric functions which can represent any type of curves or surfaces. This C++ library hides the basic mathematics of NURBS. This allows the user to focus on the more challenging parts of their projects. The NURBS++ package includes a matrix library, an image manipulation library, a numerical library and a NURBS library. They can all be used on their own but they are all developped to support NURBS needs.

NX: The NX project provides a suite of libraries and X11 proxying agents implementing efficient compression and optimized transport of X11, HTTP, SMB, and arbitrary protocols, like audio, over low-bandwidth links. By translating and embedding RFB and RDP in X protocol, it is also able to compress VNC and Windows Terminal Service sessions.

Natural Language Toolkit: The NL Toolkit simplifies the construction of programs that process natural language and defines standard interfaces between the different components of an NLP system. NLTK includes graphical demonstrations, sample data, tutorials, and API documentation.

Ncurses: The ncurses (new curses) library is a free software emulation of curses in System V Release 4.0 and more. It uses terminfo format, supports pads and color and multiple highlights and forms charcters and function-key mapping, and has all the other SYSV-curses enhancements over BSD curses. It should port easily to any ANSI/POSIX-conforming UNIX-like system. On systems supporting libiconv, the library can be built to support wide- and multibyte-character applications, e.g., UTF-8. The distribution includes the library and support utilities, including a terminfo compiler tic, a decompiler infocmp, clear, tput, tset, and a termcap conversion tool captoinfo.

Neon: 'Neon' is an HTTP and WebDAV client library with a C language API. It provides high-level interfaces to HTTP/1.1 and WebDAV methods, and a low-level interface to HTTP request/response handling, so users can easily implement new methods. Features include persistent connections, proxy support, SSL/TLS support (using OpenSSL), and XML parsing (using either expat or libxml). The packages includes autoconf macros so you can embed 'neon' directly inside an application source tree.

Net Telnet Cisco: Net::Telnet::Cisco adds additional functionality to Net::Telnet that helps you automate Cisco router management and statistic gathering.

Net6: 'net6' is a library which facilitates the development of network-based applications. It provides a TCP protocol abstraction for C++.

Nettle: Nettle is a cryptographic library designed to fit any context: in crypto toolkits for object-oriented languages, in applications like LSH or GnuPG, or even in kernel space. Users need to keep track of available algorithms and their properties and variants. The algorithm selection process is dictated by the protocol you want to implement. Also, requirements of applications differ, so an API that fits one application well may be useless for another (which is why so many different cryptographic libraries exist). Nettle avoids this problem by doing one thing, the low-level crypto stuff, and providing a simple but general interface to it. In particular, it doesn't do algorithm selection, memory allocation, or any I/O. However, users can build application- and context-specific interfaces on top of Nettle and share code, testcases, benchmarks, documentation, etc.

Netwib: Netwib is a network library for administrators and hackers. Its objective is to let programmers easily create network programs. This library provides features for Ethernet, IP, UDP, TCP, ICMP, ARP, and RARP protocols. It supports spoofing, sniffing, client, and server creation. Furthermore, netwib contains high level functions dealing with data handling. This packages was formerly known as 'lcrzo.'

NetworkX: NetworkX is a Python package for the creation, manipulation, and study of the structure, dynamics, and functions of complex networks.

NextTypes: NextTypes is a standards based information storage, processing and transmission system that integrates the characteristics of other systems such as databases, programming languages, communication protocols, file systems, document managers, operating systems, frameworks, file formats and hardware in a single tightly integrated system using a common data types system. NextTypes is a relational/network/objects/files hybrid database system with high level SQL interface, extensive primitive types list, JSON/JSON-LD/XML/Smile/WebDAV/CalDAV/iCalendar/RSS data access, REST interface, customizable MVC architecture, optimistic concurrency control, HTML5/CSS3/SVG/Javascript responsive graphical interface, multilanguage, UTF-8 encoding, syntax highlighting or WYSIWYG editors, robots.txt and sitemap management, text extraction/fulltext search, document management, virus scanning, DoS/SQL injection/CSRF/XSS protection, passwords/X.509 certificates authentication, logging and backup system.

Nini: 'Nini' is a abstraction layer over multiple types of configuration data, a thin API that abstracts the access of multiple configuration files. If you have your own configuration file you can write your own "driver" that implements the IConfigSource interface. Nini already has support for several configuration file types and will add more.

Nio: 'nio' is a framework to develop networking software for TCP/IP stack protocols. It provides fine control of all aspects of various ip stack protocols and can send/receive valid and invalid network packets, which makes it the preferred library for developing protocol test software.

NumberParser (Java): NumberParser simplifies the usage of numeric types and extends the default mathematical support in Java. It is the second part of FlexibleParser. This Java version is a conversion of the code which I originally developed in C#.

ODF-XSLT

The ODF-XSLT Document Generator is a library written in PHP 5 that brings the full power of XSLT to your OpenDocument files. It enables you to use ODF files as if they were plain XSLT templates. It also includes a few extra parsing options that allow you to edit the XSLT parts of these ODF from within your favourite office suite. Features

Based on the industry standard (ISO/IEC 26300) OpenDocument format.
Multiple document types supported (text, spreadsheet, etcetera).
Full XSLT support. Since XSLT is Turing-complete, anything is possible (in theory).
Templates can be edited from within your office suite, such as OpenOffice.org or KOffice 2.
Easily extensible by hooking in pre- and postprocessors. Requirements

PHP 5.2 or later
PHP CLI for the commandline utility
libxslt and the PHP XSL extension
zlib and the PHP Zip extension

OFELI: OFELI (Object Finite Element LIbrary) is a library of finite element C++ classes for multipurpose development of finite element software. It is intended for teaching, research and industrial developments as well.

OFXparse: Tools for working with the OFX (Open Financial Exchange) file format. ofxparse: ofx utilities for python

OGDF: OGDF is a self-contained C++ class library for the automatic layout of diagrams. OGDF offers sophisticated algorithms and data structures to use within your own applications or scientific projects. The library is available under the GNU General Public License.

OSKit: The OSKit is a framework and a set of 34 component libraries oriented to operating systems. It provides in a modular way most of the infrastructure "grunge" needed by an OS, as well as many higher-level components. Its goal is to lower both the barrier to entry, and the cost, of OS R&D. The OSKit makes it easier to create a new OS, port an existing OS to architectures supported by the OSkit), or enhance an OS to support a wider range of devices, file system formats, executable formats, or network services. It can also build OS-related programs, such as boot loaders or OS-level servers atop a microkernel. The OSKit lets language researchers concentrate on issues raised by using advanced languages inside operating systems instead of spending time on ugly code and hardware. With the addition of extensive multithreading and sophisticated scheduling support, the OSKit also provides a modular platform for embedded applications and a component-based approach to constructing entire operating systems.

OSSP uuid: OSSP uuid is an application programming interface (API) and corresponding command line interface (CLI) for generating DCE 1.1 and ISO/IEC 11578:1996 compliant Universally Unique Identifiers (UUID). It supports DCE 1.1 variant UUIDs of version 1 (time and node based), version 3 (name based, MD5), version 4 (random number based) and version 5 (name based, SHA-1). UUIDs are 128 bit numbers which are intended to have a high likelihood of uniqueness over space and time and are computationally difficult to guess. They are globally unique identifiers which can be locally generated without contacting a global registration authority. UUIDs are intended as unique identifiers for both mass tagging objects with an extremely short lifetime and to reliably identify very persistent objects across a network.

Obby: Libobby is a library which provides synced document buffers. It supports multiple documents in one session and is portable to other computer environments. it is used by Gobby the collaborative editor.

Ocrad: Ocrad is an OCR (Optical Character Recognition) program and library based on a feature extraction method. It reads images in png or pnm formats and produces text in byte (8-bit) or UTF-8 formats. Ocrad includes a layout analyser able to separate the columns and blocks of text normally found on printed pages. it can be used as a stand-alone console application, or as a backend to other programs.

Octave-engine: An external interface library for Octave.

Octave-interval: The interval package for real-valued interval arithmetic allows one to evaluate functions over subsets of their domain. All results are verified, because interval computations automatically keep track of any errors. These concepts can be used to handle uncertainties, estimate arithmetic errors and produce reliable results. Also it can be applied to computer-assisted proofs, constraint programming, and verified computing. The implementation is based on interval boundaries represented by binary64 numbers and is conforming to IEEE Std 1788-2015, IEEE standard for interval arithmetic.

OfficeFloor: OfficeFloor provides true inversion of control for building simple static to complex real-time Web applications that are "build once, run anywhere" - even with cloud computing. It allows you to wire together a working prototype in minutes, extend the prototype to a working Web site in hours, and deploy and run anywhere. The code is self documenting to make support easier. It aims to be "The Java Web Answer" for rapid application development for Web applications.

Ogg Vorbis: Ogg vorbis is a fully open, non-proprietary, patent and royalty free compressed audio format for high quality (44.1-48.0kHz, 16+ bit, polyphonic) audio and music and fixed and variable bitrates from 16 to 128 kbps/channel. This puts Vorbis in the same class as audio representations including MPEG-1, audio layer 3, MPEG-s audio (AAC and TwinVQ) and PAC. Vorbis can both encode and decode as a single pass, real-time stream, and requires roughly the same encoding and decoding power as mp3. We anticipate that it will get faster as time goes on. Ogg vorbis uses the Ogg bitstream format; the correct extension is .ogg. Ogg vorbis was created because mp3 is not truly free: MPEG consortium members claim you cannot create an mp3 encoder without infringing on their patents.

Ogle: Ogle is a DVD player that supports DVD menus and navigation. It can access CSS-protected DVDs if you have libdvdcss installed, take screen shots, and view movies in fullscreen mode. It handles angles correctly and automatically uses the correct aspect. You can also switch subtitles and audio tracks.

OmegaT: OmegaT is a free multiplatform (Java-SWING) Computer Aided Translation tool. OmegaT keeps a memory of the way you translate your text and can use memories of previous translations for reference. OmegaT is based on translation industry standards (TMX 1.4 etc) and supports a number of common formats including ODF (ISO/IEC 26300), legacy OpenOffice.org formats, HTML/XHTML, DocBook, plain text, Java bundle properties, PO files etc. OmegaT is developed by translators for translators. Support and documentation are available in a number of languages.

OmniORB: 'OmniORB' is an Object Request Broker (ORB) which implements version 2.3 of the Common Object Request Broker Architecture (CORBA). It supports the C++ and Python language bindings, is fully multithreaded, uses IIOP as the native transport, and comes complete with a COS Naming Service. omniORB is possibly the fastest available C++ ORB. As of version 3.0.5, this project is no longer sponsored by ATT Labs.

OneModel: Today: You can take notes with it. Rearrange them easily, up and down in a list, or up/down in the hierarchy. Link them to each other. Navigate across links with simple keypresses. Make deeply nested lists. Link lists to lists. Compose long paragraphs and attach them. Or do more complicated things if desired, by creating relationship types and using those. Import txt or export txt or html. It's better than the alternatives for some people, because the navigation takes fewer keystrokes, you don't have to read a manual (it's all on the screen, or so I like to think), you can have the same thing in as many places as you want, it is Free (some alternatives are, others are not), and it has immense future potential for becoming a better-structured, much more powerful and flexible wikipedia-like tool, if we work together. Vision: The idea is to have the most efficient personal knowledge organizer (now available in a usable text-based interface), then support mobile access, easy internal automation, and effective sharing and collaboration. Then, to combine efforts and learn as we go until we integrate humankind's knowledge over time. The key differentiators are that it is to be Free, and based on an object model (easily created on the fly as a side-effect of using the system), rather than on massive amounts of words. The knowledge is the same, even if the words can change. One can think of that as "using building blocks of knowledge, starting at an atomic level (i.e. numbers, relationships...), free and efficient." Or, taking the best experiences of online organizer tools and wikis, but more structured, efficient, Free, open, and collaborative; and allowing full individual or organizational control.

OpenBabel: Openbabel is a program and library designed to interconvert between many file formats used in molecular modeling and computational chemistry. The command-line utility that comes with OpenBabel is meant to be a replacement for the original 'babel' program, to translate between various chemical file formats. The library includes the file-translation code as well as utilities to help develop other free software chemistry software.

OpenCL: Botan (previously OpenCL) is a library of cryptographic algorithms. It currently 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. As of Sept 2002, this project has been renamed Botan; please see the entry for that package (http://directory.fsf.org/botan.html) for the most recent information about the package.

OpenDBX: OpenDBX is an extremely lightweight but extensible C library for accessing databases with a single API. It provides a clean and simple interface across all supported databases that leads to an elegant code design automatically. Currently, Firebird/Interbase, MySQL, PostgreSQL, SQLite, and SQL Server (MS and Sybase) are supported, and backends for more native database APIs can be written easily.

OpenEXR: OpenEXR is a high dynamic-range (HDR) image file format developed by Industrial Light & Magic. It is used on all motion pictures currently in production, and is now ILM's main image file format. The package includes the following libraries and tools: IlmImf, Half, Imath, exrdisplay, exrdisplay, exrheader, exrstdattr, exrmaketiled, exrenvmap, and exrmakepreview. OpenEXR's has a higher dynamic range and color precision than existing 8- and 10-bit image file formats. It supports 16-bit floating-point, 32-bit floating-point, and 32-bit integer pixels. It includes multiple lossless image compression algorithms, some of which can achieve 2:1 lossless compression ratios on images with film grain. New compression codecs and image types can be added by extending its C++ classes. New image attributes can be added to OpenEXR image headers without affecting backward compatibility.

OpenGLUT: OpenGLUT is a project to evolve the GLUT (OpenGL Utility Toolkit) C/C++ API. OpenGLUT uses the freeglut code base (from which it split in February 2004) as a foundation for extending, enhancing and refining the API.

OpenGui: OpenGUI (formerly FastGL) is a high-level C/C++ graphics & windowing library built upon a fast, low-level x86 ASM graphics kernel. It provides 2D drawing primitives and an event-driven windowing API for easy application development, and it supports the BMP image file format. You can write apps in the old Borland BGI style or in a windowed style like QT. OpenGUI supports the keyboard and mouse as event sources, the Linux framebuffer, SVGAlib, and XFree86-DGA2 (HW accelerated) as drawing backends, Mesa3D under Linux, and 8, 15, 16, and 32-bpp color modes.

OpenLB: OpenLB is a C++ library for the implementation of lattice Boltzmann simulations which addresses a vast range of problems in computational fluid dynamics. The package is mainly intended as a programming support for researchers and engineers who simulate fluid flows by means of a lattice Boltzmann method. The source code is written in a modular way, which make is easily extensible to include new physical content. The overall structure of the library enables for a fast implementation of both simple applications and advanced CFD problems.

OpenOBEX: The OpenOBEX library provides a free software implementation of the Object Exchange (OBEX) protocol. OBEX is a session protocol and can best be described as a binary HTTP protocol. OBEX is optimised for ad-hoc wireless links and can be used to exchange all kind of objects like files, pictures, calendar entries (vCal) and business cards (vCard).

OpenVRML: OpenVRML is a VRML/X3D browser and C++ runtime library. +The library includes parsers for VRML97 and VRML-encoded X3D as well as a +full runtime system for playing VRML/X3D content. An XEmbed control is +included along with frontends for use both as a stand-alone player and as a +Mozilla Gecko Web browser plug-in

Openjpeg: OpenJPEG is an implementation of JPEG 2000 codec written in C language. It has been developed in order to promote the use of JPEG 2000, a still-image compression standard from the Joint Photographic Experts Group (JPEG). Since April 2015, it is officially recognized by ISO/IEC and ITU-T as a JPEG 2000 Reference Software.

Openssl: The OpenSSL Project is a collaborative effort to develop a robust, professional-grade, fully featured, free toolkit implementing the Secure Sockets Layer (SSL v2/v3) and Transport Layer Security (TLS v1) as well as a full-strength general-purpose cryptography library.

Optik: Optik is a powerful, flexible, extensible, easy-to-use command line parsing library for Python. Using Optik, you can add intelligent, sophisticated handling of command line options to your scripts with very little overhead. Optik implements the conventional GNU/Unix commandline syntax. Features include typed options (if you say you want an integer, you'll get an integer) and automatic help generation.

Osip: The GNU oSIP library is an implementation of SIP (as defined by RFC 3261). This is the oSIP library (for Omnibus SIP), which consists of a parser and a transaction manager. It gives multimedia and telecom software developers an easy and powerful interface to initiate and control Session Initiation Protocol (SIP) based sessions in their applications. SIP is described in the RFC2543. The oSIP home page includes links to various useful SIP sites. 'oSIP' is little in size and code and thus could be use to implement IP soft-phone as well as embedded SIP software. oSIP is not limited to endpoint agents, and can also be used to implement "SIP proxy". It does not intend to provide a high layer API for controlling "SIP Session" at this step. Instead, it currently provides an API for the SIP message parser, SDP message parser, and library to handle "SIP transactions" as defined by the SIP document.

Ostrich: Ostrich is a small library for collecting and reporting runtime statistics from a scala server. It can collect counters, gauges, and timings, and it can report them via JMX, a simple web interface, a plain-text socket, or a "W3C" log file. A server can also be asked to shutdown or reload its config files using these interfaces.

PCI Utilities: The PCI Utilities package contains various utilities dealing with the PCI bus. It includes `lspci' for listing all PCI devices (very useful for debugging of both kernel and device drivers) and `setpci' for manual configuration of PCI devices. The library (and therefore all the utilities) can access PCI registers either via the /proc/bus/pci interface present since Linux kernel 2.1.82 or via direct hardware access (for use with older kernels and for hardware diagnostics). It can also read and interpret register dumps printed by `lspci -x'.

PDFMap: PDFMap is a command line tool and Python library which helps you create of high quality maps in PDF format. Objects of any type (either shapes or images) can be placed on a map and scaled and rotated to reflect their original dimensions and orientation. You can make each object clickable in Adobe Acrobat Reader (e.g., to access a Web-enabled application from which you've extracted the data used to create the map).

PDO: Python Database Objects: PDO: Python Database Objects, is a collection of objects for use with Phase or with the Python Programing Language. PDO is designed to be robust and simple at the same time, allowing access to multiple styles of databases, with one set of instructions. This means never having to worry again about your syntax when changing Database Platforms on your next project.

PG8000: pg8000 is a Pure-Python interface to the PostgreSQL database engine. It is one of many PostgreSQL interfaces for the Python programming language. pg8000 is somewhat distinctive in that it is written entirely in Python and does not rely on any external libraries (such as a compiled python module, or PostgreSQL's libpq library). pg8000 supports the standard Python DB-API version 2.0.

PHP Code Snippet Library: PHP Code Snippet Library. PHP-CSL is designed to let you store all your favourite code snippets, functions and classes. It is an online application written in PHP which enables authorised users to store and categorise code snippets. Visit www.php-csl.com for the latest info.

PIL: The Python Imaging Library (PIL) adds image processing capabilities to your Python interpreter. This library supports many file formats, and provides powerful image processing and graphics capabilities.

PNGwriter: 'PNGwriter' is an easy to use graphics library that uses PNG as its output format. It supports plotting and reading in the RGB (red, green, blue), HSV (hue, saturation, value/brightness) and CMYK (cyan, magenta, yellow, black) colour spaces, basic shapes, scaling, bilinear interpolation, full TrueType antialiased and rotated text support, bezier curves, opening existing PNG images and more.

POT: POT (Persisted Object Tree) is a persistency layer that lets you persist almost any thinkable object tree. It logs all the changes made to objects in your tree while they are happening. It supports transactions so that in case of a crash the reloaded data will be in a sane state.

PTypes: The C++ Portable Types Library (PTypes) is a simple alternative to the STL that includes multithreading and networking. It defines dynamic strings, character sets, variants, lists and other basic data types along with threads, synchronization primitives, and IP sockets. It includes a sample HTTP daemon showing the full power of the library.

Packet assembly library (libpal)

Libpal is an easy-to-use, straightforward packet assembly library that allows programmers to forge any kind of IP, TCP, UDP, ICMP and application layer packages. It provides an interface consisting of several functions which can be found in packet.h. A list of features includes fully configurable:

ethernet header, type and payload (CVS only)
(R)ARP packets (CVS only)
IP header, options and payload
ICMP messages
TCP header, options and payload
UDP header and payload

Panda3D: A fault-tolerant game engine for 3D games of any genre. The underlying software library is written in C++, but games can be written in C++ or Python.

Pantheios: Pantheios is a C/C++ logging API library. It offers an optimal combination of complete type-safety, very high efficiency, genericity, and extensibility. It is simple to use and extend, highly portable (platform and compiler independent), and it upholds the C tradition of only paying for what you use. Pantheios supports logging of message statements of arbitrary complexity, consisting of heterogenous types. Pantheios supports filtering of log messages based on severity level.

Pantomime: Pantomime provides a set of Objective-C classes that model a mail system. It is fully written in Objective-C (some very small parts in C where performance is critical), and is part of GNUMail.

Papyros: Papyros is a small platform independent parallel processing package. It provides a simple uniform interface for executing tasks concurrently in multiple threads or processes, local or on remote hosts.

Paramiko: "paramiko" is a combination of the esperanto words for "paranoid" and "friend". it's a module for python 2.2+ that implements the SSH2 protocol for secure (encrypted and authenticated) connections to remote machines. unlike SSL (aka TLS), SSH2 protocol does not require hierarchical certificates signed by a powerful central authority. you may know SSH2 as the protocol that replaced telnet and rsh for secure access to remote shells, but the protocol also includes the ability to open arbitrary channels to remote services across the encrypted tunnel (this is how sftp works, for example). it is written entirely in python (no C or platform-dependent code)

ParseDateTime: Parse human-readable date/time expressions.

Parted: Parted is a program that allows you to create, destroy, resize, move, and copy hard disk partitions. This is useful for creating space for new operating systems, reorganizing disk usage, and copying data to new hard disks. The program currently supports ext2, ext3, and FAT (FAT16 and FAT32) filesystems and Linux swap devices, and MS-DOS disk labels. GNU Parted contains a library, libparted, and a command-line frontend, parted, which also serves as a sample implementation and script backend.

Pascha: Pascha (Easter) Computation Utility Library. Algorithms for both Western and Eastern Christian traditions.

Pass: pass is a simple, command-line password manager that stores each password in a separate text file, encrypted with a GPG key. Passwords can be generated, managed and modified. They can also be temporarily copied to the clipboard from the command line. Finally, `pass` can be accessed by more complex interfaces, or integrated into other applications.

PasswdGen: PasswdGen is a utility for system administrators who, for security reasons, want to generate random passwords based on their own criteria. passwdGen has many run-time options that allow you to customize the criteria the generated password. 'passwdGen' is designed in a modular way and currently has three main front-ends: a console based front-end (fe-text), a GTK+ based front-end (fe-gtk), and a KDE2 front-end (fe-kde2). The building of each of these can be disabled at runtime using --disable-gtk, --disable-text, and --disable-kde2.

Path: Object for working with files and directories path.py provides a class (path) for working with files and directories. Less typing than os.path, more fun, a few new tricks.

Pdp: PDP is an extension library for PureData, aimed at providing video and other media processing fuctionality. Its focus is on images and video. There is limited support for matrix processing included in the main library, an extension library for 1D and 2D binary cellular automata, OpenGL rendering (like Gem), and a library that lets you connect a scheme interpreter (guile) to PD/PDP. Future plans include audio buffers (like Vasp), ascii packets, and text buffers.

Perl-cvs: perl-cvs has an object oriented interface to the CVS command. It uses the system cvs command under the hood.

Perl-gstreamer: This module provides a Perl interface to version 0.10.x of the GStreamer library.

Pesto: Pesto is a library for Python web applications. Its aim is to make writing WSGI web applications easy and fun. Pesto doesn't constrain you -- how you integrate with databases, what templating system you use or how you prefer to lay out your source files is up to you. Above all, pesto is small, well documented and well tested.

Phpprintipp: Can print both files and strings, cancel jobs, get printer's infos.

PiDiP: 'PiDiP' is a group of additional video objects for Pure Data Packet. These include:
pdp_ascii -ASCII art renderer pdp_canvas -video canvas pdp_cmap -color mapper pdp_compose -video compositor pdp_capture -screen capture to video utility pdp_ctrack -color tracker pdp_ffmpeg -video streamer towards a ffserver pdp_form -geometric forms adder pdp_i/pdp_o -PD to PD streaming objects pdp_imgloader -loads an image and blends it with a video source pdp_live -video stream decoder (at least from ffserver) pdp_mgrid -grid-based motion detector pdp_pen -free hand drawing object pdp_rec -quicktime file recorder pdp_shape -shape detection object pdp_spigot -video signal router pdp_text -text addition object pdp_transition -transition between two video sources pdp_yq -quicktime movie reader pdp_erode -erosion morphology operator pdp_dilate -dilation morphology operator pdp_hitand miss -hit and miss morphology operator pdp_binary -transforms an image to a binary image pdp_disintegration -effect based on piksels summing and averaging There is also a collection of objects that lets you apply effecTV filters to your video.

Pixman: Pixman is a library that provides low-level pixel manipulation features such as image compositing and trapezoid rasterization. Important users of pixman are the cairo graphics library and the X server.

Playmidi: Playmidi is a midi file player that will playback to FM, GUS, and external MIDI. It also supports Creative Music Files (CMF) and Microsoft RIFF (RMI) files and large midi archives from games such as Ultima 7.

Plib: PLIB is a set of libraries to write games and other realtime interactive applications that are 100% portable across a wide range of hardware and operating systems. It's used by Majik3D, FlightGear, and others, and includes libraries for GUI widgets, sound replay, geometry, scene graph, joystick, and fonts/text. The package also includes a scripting language and networking code, both focused towards games.

Plotutils: Plotutils is a package for plotting and working with 2D graphics. It includes a library, "libplot", for C and C++ for exporting 2D vector graphics in many file formats. It also has support for 2D vector graphics animations. The package also contains command-line programs for plotting scientific data.

Plplot: PLplot is a software package for creating scientific plots whose plot symbols and text are limited in practice only by what Unicode-aware system fonts are installed on a user's computer. The package includes a core C library, separate language bindings for that library, and separate dynamically loaded device drivers which control how the plots are presented in non interactive and interactive plotting contexts. The PLplot core library can be used to create standard x-y plots, semi-log plots, log-log plots, contour plots, 3D surface plots, mesh plots, bar charts and pie charts. Multiple graphs (of the same or different sizes) may be placed on a single page, and multiple pages are allowed for those device formats that support them. PLplot bindings exist for many compiled and interpreted languages, including C, C++, Lisp, Lua, OCaml, Octave, Perl or Python.

Poker-engine: 'poker-engine' implements poker rules according to variants and betting structures specified in configuration files. It can be used by a multiplayer poker server, a poker AI, or a poker client.

PoliPoly: PoliPoly is a python library for dealing with political boundaries and political boundary polygons such as those obtained from census shapefiles. Enables programmatic conversion of latitudes/longitudes to political districts.

PonG: PonG is a library and a GUI tool for creating configuration dialogs. An XML file which describes the configuration dialog and the gconf keys that should be used. Adding a configuration dialog to an application is then just adding a couple of lines of code.

Poppler: A PDF rendering library.

Poppler Encoding Data: File encoding data for the Poppler PDF library.

Popt: The popt library exists essentially for parsing command line options. Some specific advantages of popt are no global variables (allowing multiple passes in parsing argv), parsing an arbitrary array of argv-style elements (allowing parsing of command-line-strings from any source), a standard method of option aliasing, ability to exec external option filters, and automatic generation of help and usage messages.

Portable Media Player library (PMPlib): Portable Media Player library (PMPlib) is a FOSS project for the development of management software and libraries for various portable media players.

Prettytable: PrettyTable is a simple Python library designed to make it quick and easy to represent tabular data in visually appealing ASCII tables. It allows for selection of which columns are to be printed, independent alignment of columns (left or right justified or centred) and printing of "sub-tables" by specifying a row range. It also lets you control many aspects of the table, like the width of the column padding, the alignment of text within columns, which characters are used to draw the table border, whether you even want a border, and much more. It was inspired by the ASCII tables used in the PostgreSQL shell psql.

Prover 9: Prover9 is an automated theorem prover for first-order and equational logic, and Mace4 searches for finite models and counterexamples. Prover9 is the successor of the Otter prover.

Psilib: psilib is a library allowing applications to process Portable Site Information (PSI). PSI is an XML-standard for enabling entire websites to be exchanged between website management tools without feature loss.

Pspell: The goal of the Portable Spell Checker Interface Library (Pspell) is to provide a generic interface to Spell checker libraries installed on the system.

Pthrlib: 'pthrlib' is a library and toolkit for easily and quickly writing small, fast, HTTP/1.1-compliant Web servers. The distribution includes a lightweight cooperative threading library, a buffered I/O library, a library for writing HTTP/1.1 RFC-compliant servers, a library for writing CGI scripts that run inside the server, and an ftp client library. Examples, full manual pages documenting every function, and a production quality micro-webserver called rws are also included.

Py

The Codespeak py lib aims at supporting a decent Python development process addressing deployment, versioning and documentation perspectives. It includes:

py.path: path abstractions over local and Subversion files *

py.code: dynamic code compile and traceback printing support This package provides the Python 2 modules.

PyAuthTicket: PyAuthTicket uses HMAC to generate a one time ticket based on a secret key, message (optional) and timestamp (defaults to the current time). If both sides know a secret key (ie, an API key), a receiver can verify the identity of a sender by requiring a ticket digest and the timestamp used to create it along with the actual request. To verify the sender, the receiver would create a ticket with the same credentials (key, request, timestamp) and verify it against the provided digest. This does not prevent replay attacks but as the timestamp is provided, a lower threshold can be set to reduce the time window in which replays can run.

PyCerberus

pycerberus is a framework to check user data thoroughly so that you can protect your application from malicious (or just garbled) input data.

Remove stupid code which converts input values: After values are validated, you can work with real Python types instead of strings - e.g. 42 instead of '42', convert database IDs to model objects transparently.
Implement custom validation rules: Writing custom validators is straightforward, everything is well documented and pycerberus only uses very little Python magic.
Focus on your value-adding application code: Save time by implementing every input validation rule only once, but 100% right instead of implementing a dozen different half-baked solutions.
Ready for global business: i18n support (based on GNU gettext) is built in, adding custom translations is easy.
Tune it for your needs: You can implement custom behavior in your validators, e.g. fetch translations from a database instead of using gettext or define custom translations for built-in validators.
Use it wherever you like: pycerberus does not depend on specific contexts (e.g. web development) so you can also use it in every Python application.

PyCurry: Facilities to spec, test and run concurrent programs.

PyDO: PyDO is a ORM (Object-Relational Mapper) database access library for Python that facilitates writing a Python database access layer. PyDO attempts to be simple, flexible, extensible, and unconstraining.

PyIFBabel: pyifbabel is a pure-Python implementation of the Treaty of Babel, a standard for identifying and handling the metadata of interactive fiction files.

PyIniconfig: This module parses INI files, while maintaining section and entry order, supporting comments and multi-line values.

PyJaw: A Python implementation of the Rejaw API. This is a port of the Ruby API developed by the Rejaw team.

PyMarkdown: This is a Python implementation of John Gruber's Markdown. It is almost completely compliant with the reference implementation. See Features for information on what exactly supported and what is not. Additional features are supported by the Available_Extensions.

PyPLE: PyPLE is a framework for composing, evaluating, and storing logical expressions. With PyPLE, you can compose complex chains of simple logical operators and store them in a database. You can then apply those chains of logic to any data you like.

PyPdf

A pure Python library built as a PDF toolkit. It is capable of:

extracting document information (title, author, ...),
splitting documents page by page,
merging documents page by page,
cropping pages,
merging multiple pages into a single page,
encrypting and decrypting PDF files.
By being Pure-Python, it should run on any Python platform without any dependencies on external libraries. It can also work entirely on StringIO objects rather than file streams, allowing for PDF manipulation in memory. It is therefore a useful tool for websites that manage or manipulate PDFs.

PyPluggy: Core of Pytest's plugins.

PyPump: PyPump provides an interface to the pump.io APIs. The aim is to provide very natural pythonic representations of Notes, Images, People, …, allowing you to painlessly interact with them.

PyScript: Pyscript is a Python module for producing high quality PostScript graphics. Rather than using a GUI to draw a picture, the picture is programmed using Python and the pyscript objects.

PyStemmer: PyStemmer provides access to efficient algorithms for calculating a "stemmed" form of a word. This is a form with most of the common morphological endings removed; hopefully representing a common linguistic base form. This is most useful in building search engines and information retrieval software; for example, a search with stemming enabled should be able to find a document containing "cycling" given the query "cycles". PyStemmer provides algorithms for several (mainly european) languages, by wrapping the libstemmer library from the Snowball project in a Python module. It also provides access to the classic Porter stemming algorithm for english: although this has been superceded by an improved algorithm, the original algorithm may be of interest to information retrieval researchers wishing to reproduce results of earlier experiments.

PyTOML: Parses and creates TOML configuration files.

PyWavelets

PyWavelets is a Python wavelet transforms module that includes:

1D and 2D Forward and Inverse Discrete Wavelet Transform (DWT and IDWT)
1D and 2D Stationary Wavelet Transform (Undecimated Wavelet Transform)
1D and 2D Wavelet Packet decomposition and reconstruction
Computing Approximations of wavelet and scaling functions
Over seventy built-in wavelet filters and support for custom wavelets
Single and double precision calculations
Results compatibility with Matlab Wavelet Toolbox (tm)

Pyasn1: This is an implementation of ASN.1 types and codecs in Python programming language. It has been first written to support particular protocol (SNMP) but then generalized to be suitable for a wide range of protocols based on ASN.1 specification.

Pyasn1-modules: Using the features of pyasn1, this package provides classes to ease some common operations in which ASN.1 is used.

Pycares: Through this one can use c-ares in Python.

Pycrypto: The Python Cryptography Toolkit is a collection of cryptographic algorithms and protocols, implemented for use from Python.

Pygame: Pygame is a set of Python extension modules designed for writing games. The core of pygame is wrapped on top of the SDL library.

Pyglet

pyglet provides an object-oriented programming interface for developing games and other visually-rich applications for GNU/Linux and other platforms. Some of the features of pyglet are:

No external dependencies or installation requirements. For most application and game requirements, pyglet needs nothing else besides Python, simplifying distribution and installation.
Take advantage of multiple windows and multi-monitor desktops. pyglet allows you to use as many windows as you need, and is fully aware of multi-monitor setups for use with fullscreen games.
Load images, sound, music and video in almost any format. pyglet can optionally use AVbin to play back audio formats such as MP3, OGG/Vorbis and WMA, and video formats such as DivX, MPEG-2, H.264, WMV and Xvid.

Pygpx: A module for parsing GPS Exchange Format (GPX) files. This module allows you to parse and extract data from GPX files.

Pyjamas: Pyjamas is a toolkit and library designed to enable writing AJAX applications in Python. It is based on Google's GWT, which does the same thing for Java.

Pymacs: Pymacs is a powerful tool which, once started from Emacs, allows both-way communication between Emacs Lisp and Python. Pymacs aims Python as an extension language for Emacs rather than the other way around, and this asymmetry is reflected in some design choices. Within Emacs Lisp code, one may load and use Python modules. Python functions may themselves use Emacs services, and handle Emacs Lisp objects kept in Emacs Lisp space.

Pymunk: pymunk is a easy-to-use pythonic 2d physics library that can be used whenever you need 2d rigid body physics from Python. It is built on top of the very nice 2d physics library Chipmunk.

Pynumwords: pynumwords is a Python library for converting numbers into words. The library currently supports N-base systems, Roman numbers, Morse code, English, Chinese, Hebrew, and Lithuanian.

Python-CapitolWords: Capitol Words provides access to the most commonly used words in Congressional Record each day. (http://www.capitolwords.org/api/). Python-CapitolWords is a project of Sunlight Labs.

Python-Musicbrainz2: python-musicbrainz2 provides simple, object oriented access to the MusicBrainz web service. It is useful for applications like CD rippers, taggers, media players, and other tools that need music metadata.

Python-Serpente: Roman numeral conversion module.

Python-SunlightAPI: Python library for interacting with the Sunlight Labs API. The Sunlight Labs API provides basic legislator information, district lookups, and experimental information on lobbyists. (http://services.sunlightlabs.com/api/)

Python-VoteSmart: Python library for interacting with the Project Vote Smart API. The Project Vote Smart API provides detailed information on politicians, including bios, votes, and NPAT responses. (http://votesmart.org/services_api.php)

Python-idna: Also supports Unicode Technical Standard 46 (UTS 46).

Python-six: Compatibility library from Python 2 to 3.

Pytz: Pytz brings the Olson tz database into Python. This library allows accurate and cross platform timezone calculations using Python 2.3 or higher. It also solves the issue of ambiguous times at the end of daylight savings, which you can read more about in the Python Library Reference (datetime.tzinfo).

QDBM: 'QDBM' is an embedded database library compatible with GDBM and NDBM. It features hash database and B+ tree database and is developed referring to GDBM for the purpose of the following three points: higher processing speed, smaller size of a database file, and simpler API.

QDecoder: qDecoder is a Web Application Interface for C/C++ use. The Query Fetch algorithm of qDecoder based on the linked-list provides transparency with low layers by the simple library interface regardless of COOKIE/GET/POST(including File Upload), so the web based software can be more intuitively designed and implemented.

QRtools: QRTools is a library for decoding QR Codes. It relies on libdecodeqr for decoding.

Qanava: Qanava is a C++ library designed to display graphs on a Qt canvas. Qanava provide classes to generate various layouts of directed graphs and visualize their nodes with custom styles on a graphic canvas. Qanava is designed for applications with basic graph visualization needs such as Gantt charts, social networks, and document or network modelling applications. It is not meant for a complex interactive visualization of very large data sets.

Qt: Qt is a cross-platform application and UI framework for developers using C++ or QML, a CSS & JavaScript like language. Currently developed by The Qt Company and the Qt Project, it simplifies the task of writing and maintaining GUI (graphical user interface), cross-platform applications. It is written in C++ and is fully object-oriented. Qt/X11 does not require any additional graphical layer above X11. It is highly optimized native code that runs directly on top of the lowest graphical layer Xlib. An integrated development environment called Qt Creator is packaged separately.

QtLua: The QtLua library aims to make Qt4 applications scriptable using the Lua scripting language. It is an alternative to the QtScript module. QtLua does not generate or use generated binding code for Qt. Instead it provides useful C++ wrapper classes to make C++ and lua objects accessible from both lua and C++. It takes advantages of the Qt meta object system to expose QObject members to lua scripts.

QuantLib: QuantLib is a library for detailed and advanced quantative finance calculations for such things as exact pricing of bonds and derivatives, and hedging and risk assessment under various financial models. It's intended for use both by working quantative analysts (quants) and by researchers. The library is written in C++ and has bindings for several other languages, including Perl, Python, GNU R, Ruby, and Scheme (via SWIG).

RARfile: This is a Python module for Rar archive reading. The interface is made as zipfile like as possible. The archive structure parsing and uncompressed files are handled in pure python, for compressed files it calls the 'unrar' command line utility.

RIGEL: A lightweight evolutionary algorithms engine, capable of handling any user-defined genome, with both genetic-algorithm and evolutionary-strategy optimisation paradigms.

RKelly: The RKelly library will parse JavaScript and return a parse tree.

RLog: 'RLog' is a flexible message logging facility for C++ programs and libraries. It is subscription based, meaning you can subscribe to messages of your choice in various ways: by hierarchical channel name (e.g. "debug", "debug/ special", "error", etc.), or filename, component name, etc. Log messages are individually enabled. It is meant to be fast enough for production code where it may be called many times, as both the GCC and Intel compilers reduce the logging overhead a few clock cycles if they are dormant (with no subscribers). Other add-on components extend subscriptions to external programs, so you can enable and collect debugging messages remotely.

ROHC: The ROHC library implements the RObust Header Compression (ROHC) protocol as defined by the IETF. The ROHC protocol define a standardized method for compressing IPv4, IPv6, UDP, UDP-Lite and RTP network packet headers. It performs well over links where the packet loss rate is high, such as wireless links.

RSL - Remote Service Library: This module provides a collection of interfaces and a "plugin" mechanism to access remote services with different protocols and technology in a unified way. The library has been developed as part of a "command line shell service integration". It has been separated into its own package to allow a modular installation and if may be useful for other projects too. RSL is a pure client side library which allows easy access to web services. It provides a full abstraction of service protocol and technology and tries to map each remote service to Python methods. Hence, from a programmers point of view, there should be almost no difference (except some minimal boilerplate) between a local method call and a remote call. Even the fact, whether SOAP, JSON or whatever protocol in use, should be completely hidden (but not inaccessible). One of the main goals of the library is, to make it easily possible to add more web service and transport protocols, without changing all the other parts. This allows to extend the library bit by bit and makes each package much more maintainable. It also allows to keep the installation foot print at a minimum (just install only required modules).

Rabbitmq-c: RabbitMQ-C is a C client library for RabbitMQ. This package includes command line utilities.

Railsmachine: RailsMachine is a collection of libraries for automating deployment and hosting configuration for Ruby on Rails applications using Capistrano and Rake. Ready to deploy your Rails application to Rails Machine? Follow these steps and youÃ¢â¬â¢ll have it running in no time! Feel free to utilize Rails MachineÃ¢â¬â¢s Ask Us Anything Support and contact us with any questions you have along the way.

Raptor RDF Parser Toolkit: 'Raptor' is a library for parsing RDF syntaxes into RDF triples. It supports the latest W3C recommendation for RDF/XML including collections and datatypes, N-Triples, Turtle, and some XML RSS via a tag soup parser. It handles RDF/XML as used by RDF applications such as RSS 1.0, FOAF, Dublin Core, and OWL. It can use either expat or libxml2 for XML parsing, libcurl when available for URI retrieval, and is portable to many POSIX systems.

Rasqual: Rasqal is a C library for RDF (Resource Description Framework) query syntaxes, query construction and query execution returning result bindings. It supports the query languages RDQL and SPARQL. 'Rasqual' provides APIs for creating a query and parsing query synta. It includes pluggable triple-store source and matching interfaces, an engine for executing the queries and an API for manipulating results as bindings. It uses the Raptor RDF parser to return triples from RDF content and can also work with the Redland RDF library's persistent triple stores.

ReMarkable Connection Utility (RCU): All-in-one offline/local management software for reMarkable e-paper tablets (RM1 and RM2). RCU ensures the user's data is never out of their control, completely unshackled from the manufacturer's proprietary cloud.

Readline: The GNU readline library allows users to edit command lines as they are typed in. It can maintain a searchable history of previously entered commands, letting you easily recall, edit and re-enter past commands. It features both Emacs-like and vi-like keybindings, making its usage comfortable for anyone.

Really Easy Video Encoding Library: Revel is a C/C++ library designed to be the shortest, simplest path between your application and high-quality well-compressed video output. Any program that generates a series of successive images can use Revel to output a compressed AVI video, without having to know hardly anything about the overwhelming esoterica of video encoding.

RemoteD: remoteD is a python module that make multiprocess programming and IPC extremely simple. Each process has access to a shared datastore maintained by a remoteD server. remoteD servers are auto created for you when your first process creates a share stub.

Rep-gtk: rep-gtk is a binding of the GTK, GDK, GNOME, and libglade libraries for the librep Lisp environment. It's currently targeted at GTK 1.2 and is based on the guile-gtk binding by Marius Vollmer.

Repology.el: This package is an emacs library to access and query Repology.org for information about packages. It also provides various user-facing tools.
Emacs Lisp Package Archive

To install this package, run in Emacs:
M-x package-install RET repology RET

ReportLab: ReportLab is a PDF library suitable for web publishers, developers or creative design professionals who need to create or automate complex (even data-driven) documents. It was developed to fill the reporting needs of large financial institutions. ReportLab uses the 'Platypus' layout engine, which builds documents from components like headlines, paragraphs, fonts, tables, bitmap images, vector graphics, etc. It places these flowable elements in a document "story" following a set of templates for frames, pages and the entire document itself. It supports the standard 14 PostScript fonts, custom embedded Type-1 fonts, and Asian fonts. The included graphics subpackage provides a set of primitive shapes as well as reusable widgets building on them. Sample collections include bar charts, line charts and pie charts. Different renderers can be used to create vector graphics (in fact, even full document pages) as individual components in PDF, EPS, and bitmap formats including JPEG, PNG, GIF, BMP and PICT.

Rest suite: Server-side Javascript library that wraps parts of the Netsuite SuiteScript API (v2010.1). This interface should be more performant than the SOAP based interface as it allows 50 simultaneous connections per set of login credentials. Note that NetSuite's point system is seemingly arbitrary and we've tried to provide better error handling wherever possible. Designed as a replacement for netsuite-rest-client

Retrograph: Retrograph is a Ruby library which emulates the video display unit from a hypothetical late-80s 8-bit game console. It is similar in capability to the Sega Master System's VDP, with some additional features and direct support for text modes.

RobOptim: RobOptim is a C++ generic non-linear optimization library for robotics. The core level allows user to define problem optimization in a generic way in order to use different back-ends.

Ruby Amazon: Ruby/Amazon is a simple Ruby library that allows one to retrieve information from the popular Amazon.com Website via Amazon Web Services. It aims to wrap the grunt work of interacting with the Amazon API behind a high-level layer of Ruby and, in so doing, make it easier to use.

Ruby DICT: Ruby/DICT is an RFC 2229-compliant client-side library implementation of the DICT protocol, written in the Ruby programming language. It can be used to write clients that access dictionary definitions from a set of natural language dictionary databases. rdict, a powerful CLI dictionary client built on Ruby/DICT, is included.

Ruby LinkParser: A high-level Ruby interface to Link Grammar. This binding wraps the link-grammar shared library provided by the AbiWord project for their grammar-checker, with a few additional patches.

Ruby Mechanize: The Mechanize library is used for automating interaction with websites. Mechanize automatically stores and sends cookies, follows redirects, can follow links, and submit forms. Form fields can be populated and submitted. Mechanize also keeps track of the sites that you have visited as a history.

Ruby RSS: - cant find source nor license Ruby/RSS is an object oriented Ruby library for parsing, creating, downloading, and caching RSSs.

Ruby-mkmf: A library to be called from Ruby to aid in the process of creating Makefiles needed by builds of other Ruby codes.

Ruby-tar: Read and write tar files with Ruby.

Ruli: RULI (Resolver User LayerInterface) is a library built on top of an asynchronous DNS stub resolver. It provides an easy-to-use interface for querying DNS SRV resource records; its goal is to promote wide deployment of SRV-cognizant software. RULI aims to fully support SRV-related standards. There are currently bindings for Guile/Scheme, PHP and Perl, and it supports IPv6.

RunFunc: An alternative syntax for optparse. I liked optfunc but I went ahead and rewrote it to use a different syntax to be able to include option help and input validators.

Runwig: 'runwig' is an Apache module based runtime system for advanced Web services. It supports resident session processes, smart reply pages, and automatic garbage collection. It is designed to be used both when the services are to be written directly in C, and when C is the target language in a compilation from a high-level Web-service domain specific language such as bigwig (see http://www.brics.dk/bigwig/).

Ruport: Ruport (Ruby Reports) is a software library that aims to make the task of reporting less tedious and painful. It provides tools for data acquisition, database interaction, formatting, and parsing/munging. Designed to be extensible, it is possible to use Ruport for quick specific tasks as well as to build robust reporting applications.

Rx: Replacement for the GNU regex library.

Rygel: Rygel is a home media solution (UPnP AV MediaServer and MediaRenderer) for GNOME that allows you to easily share audio, video, and pictures, and to control a media player on your home network. Rygel achieves interoperability with other devices by trying to conform to the strict requirements of DLNA and by converting media on-the-fly to formats that client devices can handle.

S-lang: S-lang is a C-like programming language, designed to be embedded in programs. It provides standard screen handling functions, similar to curses. It also provides access to program internals, which lets users create customized procedures.

SCA: SCA (Smart Class Archive) contains PHP classes which can be used to accelerate the development process of large PHP projects. It includes classes for database handling, value conversion, template processing, internationalization, rights management and many other useful classes.

SDL: SDL is a library that allows you portable low-level access to a video framebuffer, audio output, mouse, and keyboard. With SDL, it is easy to write portable games for various operating systems.

SDL2 gfx

SDL_gfx is a library that contains graphics primitives and surface functions for SDL2. Current components of the library are:

Graphic Primitives
Surface Rotozoomer
Framerate control
MMX image filters
Build-in 8x8 Font

They are wrapped up in an addon library which is also under the Zlib license.

SILC Toolkit: SILC (Secure Internet Live Conferencing) is a protocol which provides secure conferencing services in the Internet over insecure channels. SILC superficially resembles IRC, although they are very different internally. The purpose of SILC is to provide secure conferencing services. SILC uses strong cryptographic methods to secure all traffic; it encrypts and authenticates all messages. It also supports secure file transferring. The SILC is delivered as SILC Client for end users, SILC Server for system administrators, and SILC Toolkit for application developers.

SImg: SImg is a software for astronomical image processing. It contains a tool for visualization of highly dynamic images. The package consists of a library and applications which use it. Some of the features are deconvolution (various methods), Video4Linux support, PSF computation, approximation by linear combination of images and polynoms, various color transforms, automatic shifting of image sets (for addition and color composition), and more.

SPIPAT: SPIPAT is a package that adds SNOBOL4/SPITBOL style patterns to Python as composable objects. Patterns can be composed with other Patterns and strings using the '+' and ' ' operators. Based on a C-language translation of the GNU Ada (GNAT) package by the original creator of SPITBOL.

SQLite: SQLite is a lightweight and embeddable database. It's fully ACID and SQL92 compliant with 100% test coverage. As storage a single cross-platform disk file format is used, which may be up to terrabytes in size. It requires no setup and little administrative work. SQLite itself has a simple yet expandable API. Bindings for most programming languages exist on all major plattforms.

STLport: The ANSI/ISO C++ spec includes a standard C++ library, also known as the STL. GCC comes with an implementation that does not comply with this standard, but instead partly implements an older version. STLport is a freely available version, based on the SGI STL implementation. It is fully-compliant, supported, very fast and includes special debugging facilities, and interesting and useful extensions to the standard.

STklos: 'STklos' is a Scheme system that conforms to R5RS. The implementation is based on an ad-hoc Virtual Machine. It can also be compiled as a library, so that one can easily embed it in an application. Its features include an efficient and powerful object system based on CLOS, a simple-to-use module system, implementation of the full tower of numbers defined in R5RS, and easy connection to the GTK+ toolkit. 'STklos' is the successor to 'STk', a Scheme interpreter tightly connected to the Tk toolkit.

Sane-backends: SANE is an application programming interface (API) and communication protocol that regulate communication between software and digital imaging devices, such as image scanners and digital cameras. It's also a scanner server which allows you share your stand-alone scanner or your printer-combo scanner over the network. SANE stands for Scanner Access Now Easy and is an API providing access to any raster image scanner hardware (flatbed scanner, hand-held scanner, video- and still-cameras, frame-grabbers, etc.). The package contains the library, drivers, the command line frontend scanimage, the sane-find-scanner utility and the saned server.

Scala Stats: Scala library for tracking runtime metrics. Use it to keep track of latency, events, exception counts, etc.

SciMath

The SciMath project includes packages to support scientific and mathematical calculations, beyond the capabilities offered by SciPy.

enthought.interpolate
enthought.mathematics
enthought.units

SciPy: SciPy is package of tools for science and engineering for Python. It includes modules for statistics, optimization, integration, linear algebra, Fourier transforms, signal and image processing, ODE solvers, and more.

Script.aculo.us: script.aculo.us provides you with easy-to-use, cross-browser user interface JavaScript libraries to make your web sites and web applications fly.

Scriptorium: Scriptorium is a Web-based code library. It's designed for programmers who need to organize, share, and archive the code they've written, regardless of what language or format the code is in.

Sctplib: The SCTPLIB library is a prototype implementation of the Stream Control Transmission Protocol (SCTP), a message-oriented reliable transport protocol that supports multi-homing, and multiple message streams multiplexed within an SCTP connection (also named association). SCTP is described in RFC 4960. See https://www.uni-due.de/~be0001/sctplib/ for details. The API of the library is modeled after Section 10 of RFC 4960, and most parameters and functions should be self-explanatory to the user familiar with this document. In addition to these interface functions between an Upper Layer Protocol (ULP) and an SCTP instance, the library also provides a number of helper functions that can be used to manage callbacks and timers, as well as UDP sockets for simple IPC. Furthermore, SCTPLIB provides support for UDP encapsulation, making it possible to co-exist with kernel SCTP implementations.

Secret Rabbit Code: Secret Rabbit Code (aka libsamplerate) is a Sample Rate Converter for audio. One example of where such a thing would be useful is converting audio from the CD sample rate of 44.1kHz to the 48kHz sample rate used by DAT players. SRC is capable of arbitrary and time varying conversions; from downsampling by a factor of 256 to upsampling by the same factor. Arbitrary in this case means that the ratio of input and output sample rates can be an irrational number. The conversion ratio can also vary with time for speeding up and slowing down effects.

SeeR: SeeR compiles to bytecode and executes scripts written in the C/C++ languages. This is for things you cannot (or don't want to) have compiled (hard-coded) inside your program. It supports many instances of the script, multitasking and more. It is multiplatform, and easily integrates with anything (can access your program variables, functions and classes). It contains a SeeRC script compiler/interpreter, and can be used easly in shell scripts (like Perl).

Sendmail: Sendmail is a mail transfer agent (MTA) originally developed by Eric Allman. It is highly configurable and supports many delivery methods and many transfer protocols.

Serlvers: Serlvers is a set of Erlang modules designed to help in the implementation of IP services (i.e. TCP/IP or Internet servers). Serlvers consists of a set of behaviours to abstract the internals of each protocol, and other modules to help with the infrastructure. The goal is that when making a server, you only need worry about how to store, handle, process, etc. the information instead of the internals of each protocol (to save countless hours of RFC reading). This package is outdated and no longer maintained.

Setuptools scm: This provides series of hooks for easing the task of preparing a source release package based on the tracked files of your current project.

Sglib: 'Sglib' is a generic library for C that was inspired by the Standard Template Library from C++. It has a single header file and no binary code. It defines macros for sorting arrays and manipulating lists, sorted lists, double linked lists, hashed containers, and red-black trees. Macros are parametrized by the type of the data structure. The library does not enforce its own data representation, but acts on user-defined types. Nor does it enforce any particular memory management system.

Shell-haskell: 'shell-haskell' is a library for communicating with other processes via Haskell code. It can be used for both simple tasks like getting the output of another program or more complex tasks like interacting with an interpreter.

Shishi: Shishi is a free implementation of the Kerberos 5 network security system. It is used to allow non-secure network nodes to communicate in a secure manner through client-server mutual authentication via tickets. It includes a library ('libshishi') that developers can use to add support for RFC 1510, and a command line utility ('shishi') that lets users interface with the library, acquire and manage tickets, and more. Included are also a TELNET client and server (based on GNU InetUtils) for remote network login, and a PAM module for host security. Shishi is still alpha quality. Basic support for acquiring and managing tickets are working. The KDC server side can only serve initial authentication requests. DES, 3DES and AES cipher suites are supported.

SiMath: SiMath is Silicos' free library and C++ API to train and evaluate predictive and classification models from data matrices. SiMath is built on top of several free libraries which all have their own interface and internal format. The idea of SiMath is to have a flexible and consistent interface to all tools needed in a typical data modeling procedure. These tools include preprocessing, feature selection, model training and evaluation. Since SiMath originated from within a chemoinformatics environment, most tools included in SiMath are related to this field. Currently, SiMath includes some basic classes to manipulate real-valued data matrices and vectors. There are several clustering algorithms available and also support vector machines for classification and regression are provided.

Sigscheme: SigScheme is a R5RS Scheme interpreter for embedded use. It features a small footprint (64KB in library form on the "small" configuration) like SIOD and TinyScheme, low memory consumption (2-words per cons cell), handling of multibyte characters (UTF-8, EUCs, and Shift_JIS), and more. It is mainly developed to replace the Scheme interpreter of uim.

Silly Translation library (Silt): Silly Translation library (Silt) is a library for doing some funny translations of given texts. The library can be used in any application such as mail or instant messaging clients to add some fun to communication. It can also be used to provide a trivial encryption (VERY INSECURE) that can be used to render communication hard to read for someone who is not familiar with Silt (this applies only to some modes). Be warned that the usage of some modes may offend your buddies.

Simple XML Configuration Library: An xml library for parsing a simple configuration file format. Actively developed for *nix, *bsd, and os x. The goal of the project is to provide a library that can be easily wrapped into other languages such as python.

Simple and Effective Ajax Library: Simple and Effective Ajax Library tries to avoid compatibility and cross-platform problems using very simple javascript code.

Sketch Library

This package provides implementations of various sketching techniques (a.k.a. summarization and synopsis data structures). In particular it contains the following:

Bloom filter
Multistage Bloom filter
Lossy Counting
FM sketch
Count-Min sketch
Quantile Digest
Count-Min FM sketch
Quantile Digest FM sketch
AMS
Fast AMS
Reservoir Sampling
Counting Sampling
Max-Stable Sketch
Range-Efficient F0 (F_0) Sketch

Slib: SLIB is a portable Scheme library providing compatibiliy and utility functions for all standard Scheme implementations. SLIB supports Bigloo, Elk-3.0, Gambit-4.0, Gauche-0.9, GNU Guile, JScheme, Kawa, MIT/GNU Scheme , RScheme, Scheme 48, SCM, Scsh and SISC, offering them a framework for using packages of Scheme procedures and syntax. Its catalog can be transparently extended to accomodate packages specific to a site, implementation, user, or directory.

Slibtool: slibtool is an independent reimplementation of the widely used libtool, written in C. slibtool is designed to be a clean, fast, easy-to-use libtool drop-in replacement, and is accordingly aimed at package authors, distro developers, and system integrators. slibtool maintains compatibility with libtool in nearly every aspect of the tool's functionality as well as semantics, leaving out (or turning into a no-op) only a small number of features that are no longer needed on modern systems.

Free Software Foundation!

Semantic search

Query log

Forks

Features

Emacs Lisp Package Archive

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Interaction

Navigation

Creation

Print

Tools