[[Software-development::programming-language]]

Acts as fu: When you need a dash of ActiveRecord and nothing more. Now you have no excuse for not test-driving your ActiveRecord extending plugins.

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

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

AdaDoc: AdaDoc is a tool for Ada 95 developers. It creates an HTML file from a package specification for documentation purposes.

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

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

AdacURL: AdacURL is an Ada95 binding to the popular curl library for fetching files over various protocols such as HTTP, FTP, or TELNET.

Algol 68 Genie: Algol68G (Algol 68 Genie) is an Algol 68 implementation. Its front-end parses an entire Algol 68 source program. If parsing is successful, the syntax tree (that serves as an intermediate program representation) is interpreted by Algol68G's back-end. The interpreter performs many runtime checks.

Amnesia: Hopefully with Amnesia you'll know exactly whats happening with memory when it comes to memcached. Its always nice to have some statistics to see how everything is performing within your stack. Memcached seems to be a mystery box that people don't really pay alot of attention to. Amnesia tells you how your application is performing, when it misses, when it is running sweet, when you're about to run out of memcached and (perhaps) fall down in a screaming heap.

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

Apl: GNU APL is an interpreter for APL as described in ISO standard 13751, aka. "Programming Language APL, Extended". This free version of the programming language APL has already implemented the latest and greatest features (nested arrays and related functions, complex numbers, shared variables) and is intended to be a full implementation of the standard. GNU APL has builtin support for Emacs (gnu-apl-mode). GNU APL has a predefined keyboard layout in order to produce APL characters when the "Alt" key is held down. The layout can be customized by the program xmodmap and a new keyboard mapping table like "apl.xmodmap" provided in source: xmodmap apl.xmodmap Text files beginning with #!apl run the interpreter as a shell with the subsequent lines as input.

Apydia: Apydia is an API reference documentation generator for Python. It's designed as an instantly serviceable replacement for Pudge's API-documentation generator. It won't generate complete websites from reST etc. like Pudge does, though - Apydia is only about the API.

AsmEdit: 'AsmEdit' is an editor and IDE written in assembler. It includes source highlighting and support for external helper programs for compiling and debugging. It contains word processing features such as paragraphing and spelling in a binary of less than 20,000 bytes.

AsmRef: 'AsmRef' includes a menu system and search function to display data on the Linux kernel and most topics associated with x86 assembler development on GNU/Linux systems.

Asset Trip: Asset Trip bundles JavaScript and CSS files at deploy time. The assets are then served from a Git-esque object store in the applicationÃ¢â¬â¢s public directory.

Association Freezer: Freeze an Active Record belongs_to association to ignore any future changes.

Atrack

Atrack is a ntrack / Bittorrent tracker designed from the ground up to run on Google's App Engine grid. Its main goals are:

As small codebase as possible.
As fast as possible.
As low bandwidth usage as possible.
As low memory usage as possible.
For this it relies heavily (and almost completely) on memcached, no data is stored anywhere, and it lets memcached do most of the lifecycle management. Atrack also aims to respect your privacy: other than what is needed for the most basic tracking (hashes/keys and ip/ports) atrack gathers no information whatsoever. Beyond that no aggregate statistics are kept of anything (at least once the testing/debugging phase is over), and nothing is stored permanently anywhere, not even hashes and ip/ports, they are kept in memory until they are expired by memcached and never written to disk or any other kind of permanent storage.

Avrotest: Arbitrary performance test between avro and thrift.

Awesome (node.js): A Redis implementation in node.js.

BFFFT: Using a simple array as input, a 2-dimensional Fast Fourier Transform consists of two one-dimensional FFTs performed (for instance) on each line first, and on each column next. An important limitation in FFT computer applications dealing with large arrays is the fact that the algorithm is not well suited to parallelization, due to the huge amount of data that has to be transfered between computers. Since the transfers are proportional to the number of operations, network time soon becomes prominent when the number of processors is high. This program uses vectorization as an alternative to parallelization methods.

BRL: BRL is a language designed for server-side WWW-based applications, particularly database applications as it is particularly good at constructing output that is a mix of static and dynamic content. It is based on Scheme, which makes the syntax extremely simple yet powerful. This implementation is a Java Servlet using the Kawa Scheme compiler.

BWidget Toolkit: The BWidget Toolkit is a high-level widget set for Tcl/Tk that uses native Tcl/Tk 8.x namespaces. They feature a professional look and feel and don't require a compiled extension library. Tools included are XLFDfont, assert, clonename, focus, get3dcolor, getname, grab, lreorder, parsetext, and place.

Babel

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

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

Bacon: Bacon is a small RSpec clone weighing less than 350 LoC but nevertheless providing all essential features.

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

Bakery: 'bakery' is a C++ Framework for creating GNOME applications using Gnome-- and Gtk--. It provides a Document/View architecture without forcing the user to use the whole architecture. It also makes it easy to start developing GNOME applications by inheriting and overriding.

Barista: Barista is very, very similar to bistro_car (infact, credit where credit is due - it shares similar code / is almost a fork). The main difference being, it lets you use coffee as you would javascript. Simply put, Write coffee and place it in app/coffeescripts and Barista will automatically serve it as if it was placed in public/javascripts.

Bas55: bas55 is an editor and interpreter for the Minimal BASIC programming language, as defined by the ECMA-55 standard.

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

Bff: bff is a relatively fast (due to slight optimizations) Brainf*ck language interpreter written in portable C.

Bfloop: bfloop is an interpreter for the BLooP and FLooP programming languages described in the book Gödel, Escher, Bach by Douglas Hofstadter. BLooP is a language that has only bounded loops, in other words before you enter a loop you have to give a fixed upper limit on the number of times to run the body, and you can’t change the limit while in the loop. It is impossible for a BLooP program to run forever; it always quits with an output in some finite time, an upper limit for which is predictable in advance. Functions that BLooP can compute are called primitive recursive functions, and it turns out that not all functions are primitive recursive. The FLooP language is the same as BLooP with the addition of an unbounded loop (MU-LOOP). FLooP can calculate anything your computer can calculate, but you cannot say in general whether a FLooP program will eventually terminate.

Biferno: Biferno is a new object-oriented, HTML embedded, scripting language for web development. Its high-level built-in classes, with their methods and properties, make the code very clean and easy to mantain. It has a plug-in architecture that makes the language completely extensible, allowing other developer to easily add functionality through internal and external classes.

BigFORTH: bigFORTH is a native code Forth for x86 processors. It is 32 bit and complies fully with ANS Forth. Tools include a multitasker; source-able decompiler; source level debugger (even using optimized macros) with single step and trace, and as many breakpoints as you want; post mortem dump and return stack trace; and a Pentium-MMX-assembler/disassembler. MINOS is a portable GUI library, written in object oriented Forth, and includes the GUI development editor Theseus. It is on a separate release schedule from bigFORTH; 0.9.8 beta of MINOS was released 2002-06-23.

Bigloo: Bigloo is an implementation of the Scheme programming language. It relies on an optimizing compiler from Scheme to C. Bigloo enables connections between Scheme code and C code. It proposes many extensions to Scheme such as a regular parser compiler, an lalr parser compiler, pattern matching, an object layer, etc.

Bisonc++: Bisonc++ is a parser generator like bison, but it generates C++ code Bisonc++ is a general-purpose parser generator that converts a grammar description for an LALR(1) context-free grammar into a C++ class to parse that grammar. Once you are proficient with bisonc++, you may use it to develop a wide range of language parsers, from those used in simple desk calculators to complex programming languages. Bisonc++ is highly comparable to the program bison++, written by Alain Coetmeur: all properly-written bison++ grammars ought to be convertible to bisonc++ grammars after very little or no change. Anyone familiar with bison++ or its precursor, bison, should be able to use bisonc++ with little trouble. You need to be fluent in using the C++ programming in order to use bisonc++. Bisonc++ expands the concepts initially implemented in bison and bison++, offering a cleaner setup of the generated parser class. The parser class is derived from a base-class, mainly containing the parser's token- and type-definitions as well as several member func- tions which should not be modified by the programmer. To create the program from its sources, either descend into the bisonc++ directory, or unpack a created archive, cd into its top-level directory and follow the instructions provided in the INSTALL file found there. Alternatively, binary ready-to-install versions of the Bisonc++ parser generator are available in verious GNU/Linux distributions, in particular Debian. See, e.g., https://packages.debian.org/search?keywords=bisonc%2B%2B&searchon=names&suite=all&section=all Gitlab's web-pages for Bisonc++ are here: https://fbb-git.gitlab.io/bisoncpp/

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

Bitten: Bitten is a Python-based framework for collecting various software metrics via continuous integration. It builds on Trac to provide an integrated web-based user interface.

Blade: Blade emphasizes algorithm over syntax, and for this reason it has a very small but powerful syntax set with a very natural feel. It is object-oriented, fast, dynamically typed, and features comprehensive built-in functions, exceptions, closures, custom iterable classes, garbage collection, stack-based VM, and REPL. Package management is built into the language module system.

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

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

Boost

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

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

Bottle: Bottle is a fast and simple WSGI web-framework for Python packed into a single file with no external dependencies.

Bundler: Bundler is a tool that manages gem dependencies for your ruby application. It takes a gem manifest file and is able to fetch, download, and install the gems and all child dependencies specified in this manifest. It can manage any update to the gem manifest file and update the bundled gems accordingly. It also lets you run any ruby code in context of the bundled gem environment.

Busted: Busted is a tool for gathering and reporting information about a broken gem.

C ElementTree: * " cElementTree is included with Python 2.5 and later, as xml.etree.cElementTree. " The cElementTree module is a C implementation of the ElementTree API, optimized for fast parsing and low memory use. On typical documents, cElementTree is 15-20 times faster than the Python version of ElementTree, and uses 2-5 times less memory. On modern hardware, that means that documents in the 50-100 megabyte range can be manipulated in memory, and that documents in the 0-1 megabyte range load in zero time (0.0 seconds). This allows you to drastically simplify many kinds of XML applications.

C to C++ converter: This packages is a set of Python scripts that perform each stage of code conversion from C to C++. First, header files are converted into classes and declarations become members. Then, references to variables and functions are transformed into references to attributes and methods of classes. Additional tools provided include a generator/updater of header files, and a trans-directory mover with update of include statements.

C++ Annotations: The C++ Annotations offer an extensive tutorial about the C++ programming language. It can be used as a textbook for C/C++ programming courses.

C2hs: 'c2hs' is an interface generator that simplifies the development of Haskell bindings to C libraries. It processes existing C header files that determine data layout and function signatures on the C side in conjunction with Haskell modules that specify Haskell-side type signatures and marshaling details. Hooks embedded in the Haskell code signal access to C structures and functions; they are expanded by the interfacing tool in dependence on information from the corresponding C header file.

CMDln: `cmdln.py` is an extension of Python's default `cmd.py` module that provides "a simple framework for writing line-oriented command interpreters". The idea (with both cmd.py and cmdln.py) is to be able to quickly build multi-sub-command tools (think cvs or svn) and/or simple interactive shells (think gdb or pdb). Cmdln's extensions make it more natural to write sub-commands, integrate optparse for simple option processing, and make having good command documentation easier.

CMUCL: CMUCL is a free, high performance implementation of the Common Lisp programming language which runs on most major Unix platforms. It mainly conforms to the ANSI Common Lisp standard. CMUCL provides a sophisticated native code compiler; a powerful foreign function interface; an implementation of CLOS, the Common Lisp Object System; which includes multimethods and a metaobject protocol; a source-level debugger and code profiler; and an Emacs-like editor implemented in Common Lisp.

CRCmod: Python module for creating functions computing the Cyclic Redundancy Check (CRC). Any generating polynomial producing 8, 16, 24, 32, or 64 bit CRCs is allowed. Generated functions can be used in Python or C/C++ source code can be generated.

CSS-parser: Load, parse and cascade CSS rule sets in Ruby.

CSSPool: CSSPool is a CSS parser. CSSPool provides a SAC interface for parsing CSS as well as a document oriented interface for parsing CSS.

Cache Money: A Write-Through Cacheing Library for ActiveRecord.

Cachet: Cachet is an HTTP Reverse Cache Proxy written in Scala. It is comparable to Varnish or Rack::Cache. It implements the RFC2616 specification (at this time, only the Expiration model, but the Validation model is forthcoming) obeying Cache-Control headers and the like. It is very configurable so that you can use custom databases (Ehcache and Memcached are supported by default), and custom expiry strategies, and so on. It is designed so that you can layer on things like authentication, authorization, rate limiting, and arbitrary service composition strategies (e.g., Edge-Side Includes)--which is is, I think, something novel in a free reverse proxy.

Cachy

Caching library to simplify and organize caching.

I18n (seperate caches by locale / expires all locales)
Generation based (your able expire all caches of one type)
Simultanouse caching (handle multiple processes trying to write same expensive cache at once)
Dependent caches (x caches result of cache z+y -> z changes -> x changes)
Hashed keys (optional -> short/unreadable)
Global cache_version (expire everything Cachy cached, but not e.g. sessions)
works out of the box with Rails
works with pure Memcache and Moneta(-> Tokyo Cabinet / CouchDB / S3 / Berkeley DB / DataMapper / Memory store)

Cajo: The framework allows Java objects to communicate transparently with each other over the network, without absolutely zero source impact. It similarly allows the transparent distribution of remote graphical user interfaces.

Calendar Maker: Rails plugin to build a simple calendar scaffold, with events signified by class names added to the day. Putting a calendar on a web page is easy now. Also, you can add events to a calendar, which are denoted by adding a custom class name to that day, allowing you to style it differently, or even define behavior for that day via unobtrusive Javascript.

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

Cancan: CanCan is an authorization solution for Ruby on Rails. This restricts what a given user is allowed to access throughout the application. It is completely decoupled from any role based implementation and focuses on keeping permission logic in a single location (the Ability class) so it is not duplicated across controllers, views, and database queries. This assumes you already have authentication (such as Authlogic or Devise) that provides a current_user method which CanCan relies on. See Changing Defaults if you need different behavior.

Candygram: Candygram is a Python implementation of Erlang concurrency primitives. This package emulates those facilities as closely as possible in Python. It lets developers send and receive messages between threads using semantics nearly identical to those in the Erlang language, which is widely respected for its elegant built-in facilities for concurrent programming.

Capybara: Capybara aims to simplify the process of integration testing Rack applications, such as Rails, Sinatra or Merb. It is inspired by and aims to replace Webrat as a DSL for interacting with a webapplication. It is agnostic about the driver running your tests and currently comes bundled with rack-test, Culerity, Celerity and Selenium support built in.

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

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

Challis: Challis is a lightweight markup language along the lines of Markdown and Textile. It focuses on a simple implementation while still being friendly to authors.

Chicago: Chicago is a collection of runtime and test extensions and helpers that makes some common tasks a little bit easier.

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

Choones: "Choones" is a jQuery plugin, with a little markup and some styles that mimics Growl's "Music video" theme (pop up, from the bottom.) Sending messages back to the user is often something that uses some strange design pattern of adding a box to the top of a page, that pushes down the content or, even worse, thrown into a 'lightbox'. Choones is something that I've implemented a number of times, finally recognising this pattern I thought it was worth sharing.

Cilk: Cilk is designed for general purpose parallel programming, but it is especially effective for exploiting dynamic asynchronous, parallelism. The current release runs on symmetric multiprocessor machines that support Posix threads, GNU make, and gcc. You can also run Cilk on uniprocessor machines, which is useful for development and debugging, although you won't get any parallel speedup. According to cilk, a programmer should structure a program to expose parallelism and exploit locality, leaving the runtime system to schedule the computation to run efficiently. Thus, the runtime system handles details like load balancing, paging, and communication protocols. Unlike other multithreaded languages, however, cilk is algorithmic in that the runtime system guarantees efficient and predictable performance.

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

Clearance: Rails authentication with email & password. Clearance is a Rails engine. It works with versions of Rails greater than 2.3.

Clisp: ANSI Common Lisp is a high-level, general-purpose programming language. GNU CLISP is a Common Lisp implementation by Bruno Haible of Karlsruhe University and Michael Stoll of Munich University, both in Germany. It mostly supports the Lisp described in the ANSI Common Lisp standard. It runs on most GNU and Unix systems (GNU/Linux, GNU/Hurd, FreeBSD, NetBSD, OpenBSD, Solaris, Tru64, HP-UX, BeOS, IRIX, AIX, Mac OS X and others) and on other systems and needs only 4 MB of RAM. The user interface comes in English, German, French, Spanish, Dutch, Russian and Danish, and can be changed during run time. GNU CLISP includes an interpreter, a compiler, a debugger, CLOS, MOP, a foreign language interface, a socket interface, i18n, fast bignums, arbitrary precision floats and more. An X11 interface is available through CLX, Garnet, CLUE/CLIO. GNU CLISP runs Maxima, ACL2 and many other Common Lisp packages.

Cloak: Cloak (from Comment Locator) is a source code comment extraction and archiving utility. It has many potential uses, but the initial intent was the indexing and searching of comments in code.

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

Clozure Common Lisp: Clozure Common Lisp (CCL) also known as OpenMCL, Macintosh Common Lisp (MCL), Macintosh Allegro Common Lisp (MACL), and Coral Common Lisp (CCL), features: • All major platforms • Fully compiled native code • Fast, precise, compacting, generational garbage collection • Native OS threads on all platforms • A complete mature foreign function interface • Full support for SLIME, ASDF, and QuickLisp • A native IDE on OS X with Objective C and Cocoa integration

CodePY

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

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

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

Coffee Script Lab: CoffeeScript Lab is a frivolous little environment for playing with CoffeeScript in the browser, providing both a REPL and a place to type out longer scripts.

CoffeeScript: CoffeeScript is a little language that compiles into JavaScript. Think of it as JavaScript's less ostentatious kid brother Ã¢â¬â the same genes, roughly the same height, but a different sense of style. Apart from a handful of bonus goodies, statements in CoffeeScript correspond one-to-one with their equivalent in JavaScript, it's just another way of saying it.

Colfm: Colfm is a new, lightweight file manager written in Ruby with FFI::Ncurses. It is based on ideas of NeXTSTEPÃ¢â¬â¢s File Viewer, the OS X Finder, Emacs dired, vifm, and Midnight Commander.

Colubrid: Colubrid is a WSGI request handler which simplifies python web development. If you've ever created a WSGI application without an framework or an request handler you know how stupid this can be.

Comma: The Axiom computer algebra system provides a compiler for the SPAD programming language which is particularly well suited for developing mathematical algorithms. Aldor is a non-free descendant of the SPAD language. The Comma project draws from the past experience of these systems to provide a new implementation and language definition.

Common Lisp SQL: 'CLSQL' is an SQL database interface for Common Lisp. It provides object-oriented and functional access methods to the underlying database, which can be one of MySQL, ODBC, PostgreSQL, or SQLite. It uses the Unified Foreign Function Interface (UFFI) and thus supports the CMU Common Lisp, Steel Bank Common Lisp, Allegro Common Lisp, OpenMCL, and Lispworks implementations.

Complex Form Examples: This master branch is a simple solution for the multi-model form problem using the latest accepts_nested_attributes_for available in Rails 2.3.

Condenser: Condenser is a tool for finding and removing duplicated Java code. Unlike tools that only locate duplicated code, Condenser is also able to automatically remove duplicated code where it is safe to do so.

ConfigObj: A python module for ultra simple handling of configuration files. Also useful for human readable data persistence. Flexible and simple. ConfigObj is a simple but powerful config file reader and writer: an ini file round tripper. Its main feature is that it is very easy to use, with a straightforward programmer's interface and a simple syntax for config files.

Configgy: Configgy was a library for handling config files and logging for a scala daemon. The idea was that it should be simple and straightforward, allowing you to plug it in and get started quickly.

CouchDBKit: CouchDB is a document oriented database. This is is a framework to allow your Python application to use CouchDB.

CouchQL: CouchQL speeds up the creation of CouchDB views by automatically generating them based on a simple SQL-like query.

Couchdb-python

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

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

Coverage: Coverage.py is a tool for measuring code coverage of Python programs. It monitors your program, noting which parts of the code have been executed, then analyzes the source to identify code that could have been executed but was not. Coverage measurement is typically used to gauge the effectiveness of tests. It can show which parts of your product code are being exercised by tests, and which are not.

Coveralls: A rails plugin to make sure all files are required and show up in the code coverage report. (Untouched files are excluded and can thus inflate the overall code coverage.) If you forget to test a new library or module, it may not show up on the report, and thus you won't see that the coverage for that file is low.

Cp-tools: Classpath tools is a collection of tools for GNU Classpath including a documentation generation system for java source files (gjdoc) and a "doclet" for converting comments into GNU Texinfo source (texidoclet), etc. This project has been integrated into the main GNU Classpath project.

Cpphs: 'cpphs' is a simplified Haskell re-implementation of cpp, the C pre-processor, in Haskell. The C pre-processor is widely used in Haskell source code, but a true cpp is not often available on some systems, and the common cpp provided by the gcc 3.x series is changing in ways that are incompatible with Haskell's syntax. This includes problems with, for instance, string gaps, and prime characters in identifiers. This project attempts to provide an alternative to cpp that is more compatible with Haskell and can be distributed with compilers.

CrackLib: A password checking library.

Crenshaw Compiler: A simple compiler based on Jack W. Crenshaw's "Let's make a compiler!" tutorial. His version was in Turbo Pascal and output 68k asm, mine is in Ruby and outputs x86 asm.

Cscope: Cscope is an interactive, screen-oriented tool that allows the user to browse through C source files (as well as other languages) for specified elements of code. You can search code for: all references to a symbol, global definitions, functions called by a function, functions calling a function, test string, regular expression pattern, a file, or files that include a file. The program generates an information database for faster searches and later reference. The fuzzy parser supports C, but is flexible enough to be useful for C++ and Java. 'cscope' supports a command line mode for inclusion in scripts or as a backend to a GUI/frontend.

Ctypes: 'ctypes' is a ffi (Foreign Function Interface) package for Python. It lets you call functions from dlls/shared libraries and has facilities to create, access and manipulate simple and complicated C data types transparently from Python - in other words: wrap libraries in pure Python.

Cxcl: 'cxcl' is an interpreter for the XCLE language. It is part of the XCL software suite, which aims to provide developers with tools for the programmatic handling of executable code, combining easy generation and manipulation with execution speed and memory efficiency at runtime.

CxxTest: CxxTest is a JUnit/CppUnit/xUnit-like framework for C++ that doesn't require RTTI, member template functions, exception handling, or any external libraries (including memory management, file/console I/O, or graphics libraries). It is distributed entirely as a set of header files which makes it extremely portable and usable.

Cython: The Cython compiler for writing C extensions for the Python language. The Cython language makes writing C extensions for the Python language as easy as Python itself. Cython is a source code translator based on the well-known Pyrex, but supports more cutting edge functionality and optimizations. The Cython language is very close to the Python language (and most Python code is also valid Cython code), but Cython additionally supports calling C functions and declaring C types on variables and class attributes. This allows the compiler to generate very efficient C code from Cython code.

DBG-Client: 'DBG-Client' is the client for the DBG debugger and profiler for the PHP programming language.

DBG-Server: 'DBG' is a PHP debugger and profiler. It's can backtrace errors. It shows local and global variables as well as parameters which have been passed to all nested function calls at any point of execution. It also lets you execute scripts in a step-by-step manner, set breakpoints (including conditional ones), evaluate expressions, and watch variables. The profiler lets you find bottlenecks in PHP code at the functions level, the modules level, and even the source lines level.

Dabo: Dabo is a framework for developing enterprise-grade 3-tier database applications. It is database- agnostic, and currently supports MySQL, PostgreSQL, Firebird and SQLite as backends, with MS SQL support in development. It currently wraps wxPython for its UI layer, although other UI toolkits may be supported in the future. Dabo's ui module is an excellent replacement for raw wxPython. It wraps wxPython controls, and provides a much more Pythonic API to them. Many people who aren't connecting to databases are using dabo.ui to develop their apps, as they are much more productive than with raw wxPython.

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

Data.Gov Importer for the National Data Catalog: The National Data Catalog aims to be a complete catalog of all data sets and APIs that are either put out by the government or are derived from the government. Scoped to all government levels (federal, state, and local), and all branches (executive, legislative, judicial), NDC will be the one-stop shop for developers, researchers, and investigative journalists interested in government data. NDC will tap into the social benefits of having users come together around common interests. More than just a catalog, it will be a place for community-supported documentation about government data. This Ruby application moves data.gov datasets to the National Data Catalog.

Decorator

Python decorators are an interesting example of why syntactic sugar matters. In principle, their introduction in Python 2.4 changed nothing, since they do not provide any new functionality which was not already present in the language. In practice, their introduction has significantly changed the way we structure our programs in Python. I believe the change is for the best, and that decorators are a great idea since:

decorators help reducing boilerplate code;
decorators help separation of concerns;
decorators enhance readability and maintenability;
decorators are explicit.
Still, as of now, writing custom decorators correctly requires some experience and it is not as easy as it could be. For instance, typical implementations of decorators involve nested functions, and we all know that flat is better than nested. The aim of the decorator module it to simplify the usage of decorators for the average programmer, and to popularize decorators by showing various non-trivial examples. Of course, as all techniques, decorators can be abused (I have seen that) and you should not try to solve every problem with a decorator, just because you can.

Delayed Job

Delated_job (or DJ) encapsulates the common pattern of asynchronously executing longer tasks in the background. It is a direct extraction from Shopify where the job table is responsible for a multitude of core tasks. Amongst those tasks are:

sending massive newsletters
image resizing
http downloads
updating smart collections
updating solr, our search server, after product changes
batch imports
spam checks

Deltared: Constraint solvers, generally, are good for solving problems which fit the description of "when this value changes, update these other values." Think Rake, but for your program's data instead of files. Rake is actually a constraint solver itself: when a file is updated, it knows which other files to update and the how to update them. Similarly, when a DeltaRed "variable" changes, DeltaRed knows which other variables to update and how to update them.

Dezyne: The Dezyne language has formal semantics expressed in mCRL2 developed at the department of Mathematics and Computer Science of the Eindhoven University of Technology (TUE). Dezyne requires that every model is finite, deterministic and free of deadlocks, livelocks, and contract violations. This achieved by means of the language itself as well as by builtin verification through model checking. This allows the construction of complex systems by assembling independently verified components.

Dia2code-ruby: dia2code-ruby generates Ruby source code from an UML Dia Diagram

Dialtone: A minimalist Ruby web application framework used to demonstrate Rack (http://rack.rubyforge.org). Use the Rackup script to launch the sample application.

Diapergluforth: 'diapergluforth' lets you access functions in shared object libraries without having to recompile against the library's header files. It also tracks buffer allocations and automatically frees them when you exit, so you can check for memory leaks immediately after calling a function. In addition, diaperglu traps various error conditions such as attempts to access memory that the process doesn't own, and reporting an error on it's error stack instead of just exiting.

Directory Watcher: The directory watcher operates by scanning a directory at some interval and generating a list of files based on a user supplied glob pattern. As the file list changes from one interval to the next, events are generated and dispatched to registered observers. Three types of events are supported Ã¢â¬â added, modified, and removed.

Discodactyl: Discodactyl is an experimental toolkit for XRD service discovery documents and related protocols. It includes implementations of XRD URITemplate Link-Patterns, basic site-meta support, HTTP Link header parsing, acct: URIs and a webfinger poking stick.

Djalog: A simple logging module for Django applications.

Django: Django is a high-level Python Web framework that encourages rapid development and clean, pragmatic design.

Djblets: A collection of useful classes and functions for Django.

DocTestTools: These are a small set of tools to make it easier to run doctest on your source files and text files. There is a tool to run doctest on an individual file, and another tool to run doctest on all files within a directory (recursively). The individual doctest runs are done in separate processes so that the tests don't contaminate each other. Finally, there is a small module to set the python path of the program calling it to make it easier to run the program from multiple clones of the same project where it is impossible to set the python path to a single location. These tools are written in Python so that they will run on all platforms.

Dotgnu-pnet: DotGNU Portable.NET is part of the DotGNU project, whose goal of is to build a suite of tools to build and execute .NET applications, including a C# compiler, assembler, disassembler, and runtime engine. The initial target platform is GNU/Linux. DotGNU Portable.NET includes a runtime engine, a C# compiler, and various tools. The other parts of the package are currently treecc, pnetlib, pnetC, mlpnet, pnetmark, pnetcurses, and mahjongg.

Downlow: Why is downloading and extracting files such a pain in Ruby? Downlow to the rescue.

Doxymacs: 'doxymacs' is an elisp package designed to make using and creating Doxygen easier for Emacs users. It can look up documentation for classes, functions, members, etc in the browser of your choice, fontify Doxygen keywords, and automagically insert Doxygen comments in JavaDoc, Qt, or C++ style. You can also create your own style via templates.

DrPython: DrPython is a highly customizable, simple, and clean editing environment for developing Python programs. It is intended primarily for use in schools, and is a tribute to DrScheme.

DrScheme: * "PLT Scheme is now Racket." 'DrScheme' is a graphical environment for developing programs using the Scheme, MzScheme, and MrEd programming languages. Features include source text highlighting of syntax and run-time errors, support for multiple levels of Scheme from beginner to advanced, an algebraic stepper for the beginner language, interactive and graphical static analysis, a graphical user interface (GUI) library, objects, threads, modules, exceptions, TCP/IP, regular expressions, and filesystem support.

DrlFT: 'DrIFT' is a type sensitive preprocessor for Haskell. It extracts type declarations and directives from modules and applies rules to them which generate code. The user can add new rules as required. 'DrIFT' automates instance derivation for classes that aren't supported by the standard compilers. In addition, instances can be produced in separate modules to that containing the type declaration. This lets instances be derived for a type after the original module has been compiled. Simple utility functions can also be produced from a type.

Dtach: dtach is a program that emulates the detach feature of screen. It is designed to be transparent and un-intrusive; it avoids interpreting the input and output between attached terminals and the program under its control.

Dvorky: fussing around with trying to make an android keyboard layout.

Dynamic Asset Helper: Rails plugin providing helpers to dynamically include JS/CSS assets based on routes.

ECB: 'ECB' is a source code browser for Emacs. It displays windows that can be used to browse directories, files, and file contents like methods and variables. It supports source code parsing for languages like Java, C, C++, Elisp, Scheme, Perl, TeX, LaTeX, etc. It also offers an (optional) permanent "compile window" at the bottom of the emacs frame, which displays all help and compile output. The rest of the frame is called the "edit area", which can be divided into several edit windows that are used for editing the sources. Deleting some of the edit windows neither destroys the compile window nor the browsing windows.

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

Easylzma: An easy to use, tiny, public domain, C wrapper library around Igor Pavlov's work that can be used to compress and extract lzma files.

Eclipse: A Java-based integrated development environment (IDE) and platform for rich client applications originally created by IBM.

Eev: Eev is an Emacs mode providing an e-script environment that consists of text files holding commands (shell or not) and Emacs Lisp commands. It can be used for replaying recorded shell “sessions”, referring to other documents (other text files, info, man, URL, mail, whatever), demoing… Or for automating almost everything with Emacs.

Elib

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

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

EmPy: EmPy embeds Python expressions and statements in template text. It takes an EmPy source file, processes it, and produces output. This is done via expansions, which are special signals to the EmPy system and are set off by a special prefix. It can expand arbitrary Python expressions and statements in this way, as well as a variety of special forms. Textual data not explicitly delimited in this way is sent unaffected to the output, so Python can be used as a markup language. Also supported are callbacks via hooks, recording and playback via diversions, and dynamic, chainable filters.

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

Encoder Tools: Some tools to make encoding from DVDs easier, written in Ruby.

Enotes: 'enotes' is a small GNU Emacs script to handle appointments. It stores a list of notes, each with a title, a date, a warning date, and optionally a long description and a reference file. A window pops up when a warning time is reached. It is simple (more than calendar and others), yet reliable and very practical

Enstaller

The Enstaller project is a replacement for setuptools that builds on top of it and adds significant features. It is based on setuptools 0.6c9. It starts from the setuptools source and adds the enstaller entry point as well as specific improvements such as:

added support for removing a package
added support for post-install and pre-uninstall scripts
improved dependency resolution with enpkg.
easy_install can now work through a proxy for both http and https urls.
setup.py develop also runs post-install scripts and --uninstall runs pre-uninstall scripts
easy_install and enpkg now prefer final releases of distributions over dev builds.

EphemPy: Python tools for working with the JPL ephemeris files.

Epsilon

'GNU epsilon' is a purely-functional strongly-typed omega-order language, moving towards Lisp in that it allows dynamic management of source code at runtime. It is oriented to ease of development and readability. The static scoping rule and the type checkings at compile-time should make the language "safe". Its features include:

static scoping
first-class functions
Hindley-Milner type system with type inference
modules
synonym, concrete and abstract types, with polymorphism
a scanner generator
a purely functional I/O system, inspired by Haskell
can generate C code, Scheme code, and bytecode for a virual machine

The package currently includes a compiler, interpreter, runtime system, and garbage collector. Planned or not yet finished: parser generator, classes, an extensive library, optimizer, partial evaluator, pretty-printer, an Emacs mode, parellel implementation for SMPs and clusters, interoperability with other languages via CORBA.

Epydoc: Epydoc is a tool for generating API documentation for Python modules, based on their inline documentation strings (docstrings). It produces HTML output (similar to the output produced by javadoc) and PDF output. Epydoc supports four markup languages for documentation strings: Epytext, Javadoc, ReStructuredText, and plaintext.

Eric: Eric is a full featured Python and Ruby editor and IDE, written in python. It is based on the cross platform Qt gui toolkit, integrating the highly flexible Scintilla editor control. It is designed to be usable as everdays' quick and dirty editor as well as being usable as a professional project management tool integrating many advanced features Python offers the professional coder.

Erlectricity: Erlectricity allows a Ruby program to receive and respond to Erlang messages sent over the Erlang binary protocol.

Escape Utils: Being as though we're all html escaping everything these days, why not make it faster? At the moment escape_utils supports escaping and unescaping of HTML, and Javascript but I wanna add URL encoding soon. For character encoding in 1.9, we'll return strings in whatever Encoding.default_internal is set to or utf-8 otherwise. It has monkey-patches for Rack::Utils, CGI, ERB::Util and Haml and ActionView so you can drop this in and have your app start escaping fast as balls in no time.

Euphoria: Euphoria is a simple, flexible, and easy-to-learn programming language. It lets you quickly and easily develop programs for lots of different platforms. Euphoria was first released in 1993.

Eventdns: An EventMachine based DNS server

ExtraDix: The sorting algorithm ExtraDix is an extension of the well-known RadixSort (hence its name Extended raDix). It is not based on comparing key values, it is stable and sorts indirectly by first calculating the correct sorting order and only then moving the data records. The algorithm is very fast, there is no best case nor worst case as regards timing, the time necessary for sorting increases directly and in linear fashion with the number of records and the algorithm can be used for all basic data types.

FLVlib: It includes three example scripts, debug-flv, index-flv and retimestamp-flv which demonstrate the possible applications of the library. Provides an easy and extensible way of writing applications that parse and transforming FLV files. Can be used as a drop-in replacement for FLVTool2, from which it is typically much faster. Unlike FLVTool2 it works on audio-only files and does not overwrite any previous metadata the file might have.

FOX: FOX is a C++-based toolkit for GUI development. It includes a rich set of widgets and includes layout managers, MDI widgets, and mega-widgets. FOX incorporates support for XDND for drag and drop, X clipboard and X Selection, watching other I/O channels and sockets, timers and idle processing, object serialization and deserialization, a registry to save persistent settings, and 3D widgets using Mesa or OpenGL. FOX emphasizes speed, and minimizes memory use by letting programmers create and destroy GUI elements on the fly. Widgets can connect to each other and pass certain commands between them, which also reduces the amount of code needed. Finally, GUI elements automatically update themselves by interrogating the application's state, so it is easy to maintain the state of the GUI in an application.

FXRuby: 'FXRuby' is a Ruby extension module that provides an interface to the FOX GUI toolkit.

Factory C: Factory C is Factory C because it uses a factory table that uses a strategic factory method(s) thats the singleton class factory method to the class interface heap for a factory table class. There are 3 levels of OOP in Factory C and thats Virtual, Factory, and Complex. The Complex object uses a runtime object for its interface inside of its own builder table and heap containers for its class interface heap and class information heaps, and runtime objects for its interface registrations. This (Factory C) is for fully dynamic-at-runtime Object-Oriented Programming with no limitations on things like datatypes or multiple inheritance or coupling. As a presentation of hash tables or data structures Factory C uses a Virtual Table, Factory Table, and an Adapter Table. there is a single linked list template you can typename, also a vector and binary search tree (heap). but only the datastructures needed to implement Factory C are included. Also, part or the Object-Orientation of Factory C is that every primitive type has a constructor plus interface as a virtual table object and factory method plus interface heap as a factory table class. The Complex object is created using a small class builder that is implemented in C.

FactoryGirl: FactoryGirl is a fixtures replacement with a straightforward definition syntax, support for multiple build strategies (saved instances, unsaved instances, attribute hashes, and stubbed objects), and support for multiple factories for the same class (user, admin_user, and so on), including factory inheritance.

FakeFS: Mocha is great. But when your library is all about manipulating the filesystem, you really want to test the behavior and not the implementation. If you're mocking and stubbing every call to FileUtils or File, you're tightly coupling your tests with the implementation. With FakeFS:
def test_creates_directory
Library.add "directory" assert File.directory?("directory") end
Woot.

Fifty States App: This is a candidate for deletion: Links broken. No links to page. Email to maintainer broken.Poppy-one (talk) 01:56, 29 July 2018 (EDT) A Django App for viewing Fifty State Project data.

Fiscal Year Calculations: Some helper methods for the Time object for fiscal year calculation.

Flatland

Flatland manages the mapping between structured Python application data and the flat key/value namespace of forms. Features include:

Declarative form specification
Conversion to and from native Python types and Unicode
Structured data: lists, dicts, lists of dicts, etc.
JavaScript-safe name flattening by default
Schema-driven, directed expansion of incoming key/value pairs- only expected request data is examined and parsed
Compound fields
Validation
Strong value defaulting, pre-populating re-populating and roundtripping
Namespacing: easily manage multiple forms in a single page
Works on form and JSON data

FlexSURVEY: flexSURVEY is a small-in-size but powerful tool for creating flexible PHP-driven online surveys and questionnaires. With flexSURVEY, surveys are created by writing PHP source code using flexSURVEY's functions and lightweight markup language.

Flexable: `flexable` is template engine with simple data structure. It is made up of str, unicode, dict, tuple, list and Element.

Flexc++: Flexc++ was designed after `flex'. Flexc++ offers as compared to flex's C++ option a cleaner class-design. Flexc++ generates a scanner class that is ready for use, as well as a member function producing the lexical scanner tokens (lex()). The class can easily be provided with additional members without the need for polymorphic functions. Consequently, classes generated by flexc++ have no virtual members and actually have but one public member: lex(), replacing the old-style flex and flex++ yylex() function. Flexc++ offers many options, among which an option to define classes generated by flexc++ in a separate namespace. This allows developers to define additional symbols, even outside of the class generated by flexc++, without encountering name-collision problems. With flexc++, artificial means to prevent name-collisions, like the yy-conventions used by flex and flex++ are no longer required. Flexc++ generates C++ code. If C code is required, flex should be used. Flexc++'s grammar requirements are highly compatible with flex's requirements, so converting a flex grammar into a flexc++ grammar should be fairly simple. In addition to the flexc++ scanner generator itself and several skeleton files, the package contains an extensive man-page, as well as a full manual rewritten after the original flex manual, and several examples. To create the program from its sources, either descend into the flexc++ directory, or unpack a created archive, cd into its top-level directory and follow the instructions provided in the INSTALL file found there. Alternatively, binary ready-to-install versions of flexc++ are available in verious GNU/Linux distributions, in particular Debian. See, e.g., https://packages.debian.org/search?keywords=flexc%2B%2B&searchon=names&suite=all&section=all Gitlab's web-pages for flexc++ are here: https://fbb-git.gitlab.io/flexcpp/

Follow: Follow class implements "tail -f" functionality to incrementally read text and binary files as they grow.

Forban: Forban is a kind of p2p (peer2peer) filesharing application for link-local and local area network. Forban works independently from Internet and use only the local area capabilities to announce, discover, search or share files. Forban relies on HTTP and he is opportunistic (meaning replicating any files seen in his proximity or interest).

Forgery: The Problem: Making meaningful development data for your application. The Solution: A fake data generator that does more than just lorem ipsum and random text (well, it does those too, but also does much more). Forgery generates fake data from dictionaries, formats, and recipes. The plugin includes a generator providing directories to make your own forgeries.

Fortune: Fortune is a stripped-down implementation of the classic BSD Unix fortune command. It combines the capabilities of the strfile command (which produces the fortune index file) and the fortune command (which displays a random fortune). It reads the traditional fortune program's text file format.

Foursquare: A ruby interface for Foursquare's JSON API. Sign up for a Foursquare account at http://playfoursquare.com.

Freckle API: A basic API client for the Freckle API.

Free Oberon: Free Oberon is a cross-platform IDE for development in Oberon programming language made in the classical FreePascal-like pseudo-graphic style. Compilation of user-written programs is performed using the Vishap Oberon Compiler and then GCC. The compiled console programs can be run in the built-in terminal emulator.

Freepascal: FreePascal , aka Free Pascal Compiler (FPC), is a 32 and 64 bit bit Pascal compiler with extensions for different processors and operating systems. It tries to stay compatible with the dialects of well known proprietary Pascal-based compilers, so you don't have to learn much to switch to free software and/or systems. The language syntax is semantically compatible with TP 7.0 as well as most versions of Delphi (classes, rtti, exceptions, ansistrings). FPC supports function overloading, operator overloading and other such features. It also comes with several command-line tools to help your programming, including a source formatter, a makefile generator, a C header translator, a unit dependency lister and even TP lex and yacc. FreePascal comes with its own development environment (not for all platforms yet).

Fscript: 'FScript' is an extremely simple scripting language whose intended use is as an embedded language in other Java programs. It is simple to embed; it can be as simple as sub-classing one class to add your own functionality. However, it is not a complete programming language, as it has no library of standard functions (such as IO and string processing). FScript supplies base functionality (such as flow control, variable handling, and basic math operations) that can extended by the host application.

Ftwalk: Ftwalk is a high level script programming language, very similar to awk, but greatly extended to include a richer type system, object-oriented features, 300+ built-in functions, extensibility through dynamic libraries, etc. It does file tree searches, and can be run interactively as a calculator. It is particularly useful for interactively testing logic, system calls, and prototyping; writing software test scripts; for running redundant copy backups, software installation, and verification scripts; and as a 'find' replacement.

Funk: A mocking framework for Python, influenced by JMock.

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

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

GNADE: The GNADE (GNat Ada Database Environment) project has been initiated through the Ada for GNU/Linux Team. Its primary goal is to provide all tools and packages necessary to create an Ada 95 development environment providing a seamless integration of SQL based databases into Ada 95. To reach this goal, the approach of embedding SQL into Ada 95 has been selected to allow the reuse of old legacy code. The ODBC interface has been chosen as the primarily supported interface to the underlying data base.

GNU SETL: GNU SETL is a modest extension and implementation of SETL, the World's Most Wonderful Programming Language.

GTKpas: GTKpas is based on the gtk.h header translations and external declarations included with FreePascal and builds an objective model around these functions. The package includes a binding for GtkGLArea, which lets users embed an OpenGL drawing area in a GTK window.

Gambas: Gambas is a full-featured object language and development environment built on a BASIC interpreter. It is split between a compiler, an interpreter, an archiver, a scripter, a graphical development environment, and extension components.

Gambit: Gambit is a set of tools for doing game theory on finite games. It features a graphical interface as well as a (currently experimental) Python API for doing repetitive or econometric tasks on games.

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

Garnet: Garnet is an environment for creating interfaces to Common Lisp software. It was originally developed by the User Interface Software Group in the Human Computer Interaction Institute in the School of Computer Science at Carnegie Mellon University in the early to mid 1990s. In 1995, active support for Garnet at CMU was dropped; there is currently no active development on the project. The toolkit itself, however, remains feature complete and stable.

Gash

* Gash lets you access a Git-repo as a Hash.

Gash doesnÃ¢â¬â¢t touch your working directory
Gash only cares about the data, not the commits.
Gash only cares about the latest data.
Gash can commit.
Gash will automatically create branches if they donÃ¢â¬â¢t exist.
Gash only loads what it needs, so it handles large repos well.

Gauche: 'Gauche' is an R7RS Scheme implementation that ia meant to be a handy tool for daily work. Its goals include quick startup, a built-in system interface, and native multilingual support. It has an object-oriented system similar to STklos and Guile. It natively supports UTF-8, EUC-JP, and Shift-JIS multibyte encodings.

Gcjwebplugin: 'gcjwebplugin' is a plugin for Mozilla and other web browsers for the execution of Java applets. It uses the JVM provided by GCJ. The package is now quite flexible with its build and runtime dependencies now. It builds with every Java compiler that supports the GNU EmbeddedWindow extensions (which should be all that depend on/are derived from GNU classpath). The Mozilla build dependency is gone too as the needed header files of Mozilla are now included in gcjwebplugin. This package has been folded into classpath, please see that entry for the latest information.

Gcl: GCL is a Compiler and interpreter for Common Lisp. It compiles to C and then uses the native optimizing C compiler (e.g., GCC), giving great portability. It is highly efficient: a function call is basically the same speed as a C function call, in fact identical to a C function call via a pointer. The program has a source level Lisp debugger (dbl) for interpreted code, letting you step a line at a time, while displaying your position in an Emacs window. It has pioneered conservative Garbage Collection schemes, but also has the stratified garbage collection (SGC) scheme, for only recent allocations, that is based on native page fault handling. There is also a built in interface to Tk widget system. Allows a mixture of tcl and common lisp to be used in a user interface--your choice which you use.

Geany: Geany is a lightweight editor and IDE with basic features of an integrated development environment. It features syntax highlighting in dozens of languages, code completion, call tips, many supported filetypes (including C, Java, PHP, HTML, DocBook, Perl, LateX, and Bash), and symbol lists. It can be extended with the help of plugins, to add features like window splitting.

Gembox: Gembox is a very simple web based application for browsing your local ruby gems. It uses Sinatra to provide a pretty layer on your gem repository, so you can browse, find, and learn about your installed ruby gems.

Gemifest: Like Heroku's gem manifests, but for your own computer.

Gengetopt: 'gengetopt' takes an easy-to-do description of options and generates a C function that uses the GNU getopt_long(3) function to parse and validate the options. gengetopt is perfect if you don't want to write all the stuff required to call GNU getopt_long(3), or if you have a program and wish it took many options. The generated code works if you use autoconf or automake.

Getargs: 'getargs' is a Python module that implements a command line parser that Python scripts can use to parse their command line arguments in sys.argv. It is designed as a more powerful and flexible alternative to 'getopt'. 'getargs' supports all features provided by getopt. It also allows a command line option to take an arbitrary number of arguments, permits switches (options without arguments) and options with arguments to be interleaved on the command line, and allows the developer specify the maximum and minimum number of arguments an option can take.

Gforth: Gforth is a fast and portable implementation of the ANS Forth language. It works nicely with the Emacs editor, offers some nice features such as input completion and history, backtraces, a decompiler and a powerful locals facility, and it has a comprehensive manual. Gforth combines traditional implementation techniques with newer techniques for portability and performance: its inner interpreter is direct threaded with several optimizations, but you can also use a traditional-style indirect threaded interpreter. Gforth runs under GNU, BSD, and similar systems, MS Windows and MacOS and should not be hard to port to other systems supported by GCC.

Ghc: The Glasgow Haskell Compiler is a robust, fully-featured, optimising compiler and interactive environment for Haskell 98, GHC compiles Haskell to either native code or C. It implements numerous experimental language extensions to Haskell 98; for example: concurrency, a foreign language interface, multi-parameter type classes, scoped type variables, existential and universal quantification, unboxed types, exceptions, weak pointers, and so on. GHC comes with a generational garbage collector, and a space and time profiler.

Git Commit Notifier: Sends HTML email commit messages splitting commits that were pushed in one step.

Glade--: Glade-- is a backend for glade (the GUI builder for GTK and Gnome) and glade-2 to create C++ sources (gtk-- and gtkmm2, any combination). It is usable for both Gnome and Gnome2.

Glame: The GNU/Linux Audio Mechanics project will be a complete sound editor for GNU/Linux systems. GLAME so far has a graphical frontend to set up filter networks and perform basic audio editing tasks. A Scheme-based command line editor offers low-level access for scripting purposes.

Gnocl: 'Gnocl' is a GTK/Gnome extension for the programming language Tcl. It provides easy to use commands to quickly build Gnome compliant user interfaces including the Gnome canvas widget and drag and drop support. It is loosely modeled after Tk.

Gnome-python: 'gnome-python' is a set of interfaces to gnome-libs. It also contains a copy of PyGTK, so you don't have to worry about gnome-python getting out of sync with your copy of PyGTK. The bindings cover almost all of the APIs in gnome-libs.

Gnomemm: 'Gnomemm' is a set of C++ binding for the GNOME libraries. It is intended for use with gtkmm, and was previously known as Gnome--.

Gnu-c-manual: The GNU C Reference Manual is strictly a reference, not a tutorial. Its aim is to cover every linguistic construct in GNU C, but not the library functions which are documented in The GNU C Library Reference Manual.

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

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.

God: God is an easy to configure, easy to extend monitoring framework written in Ruby. Keeping your server processes and tasks running should be a simple part of your deployment process. God aims to be the simplest, most powerful monitoring application available.

Goops: GOOPS is the object-oriented extension to Guile. It is very close in spirit to CLOS (the Common Lisp Object System) but is adapted for the Scheme language. The GOOPS extension gives the user a full object oriented system with multiple inheritance and generic functions with multi-method dispatch. Furthermore, the implementation relies on a true meta object protocol, in the spirit of the one defined for CLOS. This package has been folded into Guile please see that entry for the latest information.

Gphpedit: 'gPHPEdit' is a GNOME2 editor that is dedicated to editing PHP files and other supporting files, like HTML/CSS. It has support for drop-down function lists, hints showing parameters, and syntax highlighting.

Grack: This project aims to replace the builtin git-http-backend CGI handler distributed with C Git with a Rack application. This reason for doing this is to allow far more webservers to be able to handle Git smart http requests. The default git-http-backend only runs as a CGI script, and specifically is only targeted for Apache 2.x usage (it requires PATH_INFO to be set and specifically formatted). So, instead of trying to get it to work with other CGI capable webservers (Lighttpd, etc), we can get it running on nearly every major and minor webserver out there by making it Rack capable.

Grancher: Grancher, easily copy folders and files to other Git branches.

Graticule: Graticule is a geocoding API for looking up address coordinates. It supports many popular APIs, including Yahoo, Google, Geocoder.ca and Geocoder.us.

GreenCloth: GreenCloth is derived from RedCloth, the defacto text to html converter for ruby. The purpose of GreenCloth is to add a bunch of new features to RedCloth that make it more suited for wiki markup. GreenCloth requires that RedCloth version > 4.0 is installed and that prior versions are NOT installed.

Grendel: Grendel is a RESTful web service which allows for the secure storage of users' documents. When a Grendel user is created, an OpenPGP keyset (a master key for signing/verifying and a sub key for encrypting/decrypting) is generated. When the user stores a document, the document is signed with the user's master key and encrypted with their sub key. Other users can be granted read-only access to these documents. For instance, if a web service stores documents securely for users, a user might grant the service administrators temporary shared access to their documents for support purposes, or may grant permanent access to another user for sharing purposes.

Grun

Grun is a python module helper to help you to build out some simple gtk apps, by providing nice things to improve your scripts with GUI "bling bling". It's clearly the easiest way to put some GUI things in your scripts/commands. It's a kind of gui framework. It provides :

An easy way to turn your methods into GUI winforms, in one line of code.
some simple dialogs (messagebox/prompt/progressbar)
a pynotify wrapper
a iconapp/tray backend to let your application stay in tray
a popup generator
a simple config backend to store configs in a xdg way
a simple clipboard getter/setter (text only!)

Gst-python: 'gst-python' is a wrapper for the GStreamer library for use in Python programs. This library helps users construct graphs of media-handling components, ranging from simple mp3 playback to complex audio (mixing) and video (non-linear editing) processing. It handles boring details such as managing memory and type casting.

Gtk2-Perl: GTK-Perl allows Perl developers to write GTK+ 2.x applications. The bindings use an object oriented syntax that attempts to remain close to the C API, but take a more Perl-like approach where appropriate. The Perl bindings to the 3.x series of the gtk+ toolkit is under development.

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.

GtkAda: GtkAda is a portable Ada 95 graphical toolkit based on Gtk+ and Gnome widgets. It provides a complete object oriented and safe toolkit for developing Gtk+ and Gnome applications. It tries to map almost all the functions found in gtk and gdk.

GtkExtra--: GtkExtra-- provides C++ wrappers for GtkExtra, for use with Gtk--. This includes the GtkPlot and GtkSheet widgets, among others.

GuiLoader: GuiLoader is a high-performance and compact GuiXml loader library. This library allows GTK+ applications to create GUI widgets and objects at run-time from GuiXml resource files. GuiLoader is written in the C language as a GObject subclass and has a trivial language-independent API. GuiLoader was designed to be easily wrapped for any language that has GTK+ bindings.

GuiLoader C++: GuiLoader/C++ is a C++ binding to GuiLoader library. It is a convenience layer that simplifies development of GuiLoader based applications written in C++ language by introducing exception safety, binding GTK+ objects defined in GuiXml to C++ variables and type-safe dynamic connection to signals.

Guile: Guile is an implementation of the Scheme programming language, packaged for use in a wide variety of environments. In addition to implementing the R5RS, R6RS, and R7RS Scheme standards, Guile includes full access to POSIX system calls, networking support, multiple threads, dynamic linking, a foreign function call interface, powerful string processing, and HTTP client and server implementations. Guile can run interactively, as a script interpreter, and as a Scheme compiler to VM bytecode. It is also packaged as a library so that applications can easily incorporate a complete Scheme interpreter/VM. An application can use Guile as an extension language, a clean and powerful configuration language, or as multi-purpose "glue" to connect primitives provided by the application. It is easy to call Scheme code from C code and vice versa. Applications can add new functions, data types, control structures, and even syntax to Guile, to create a domain-specific language tailored to the task at hand.
Guile's VM

Guile contains an efficient compiler and virtual machine. It can be used out of the box to write programs in Scheme, or can easily be integrated with C and C++ programs.
Guile is the GNU Ubiquitous Intelligent Language for Extensions, and the official extension language of the GNU project.

Guile-cv ,: Guile-CV
Image Processing and Analysis in Guile
a Computer Vision functional programming library
Guile-CV is based on Vigra (Vision with Generic Algorithms), enhanced with additional algorithms (Image Textures, Delineate, Reconstruction and many more), all accessible through a nice, clean and easy to use high level API.
Guile-CV is natively multi-threaded, and takes advantage of multiple cores, using high-level and fine grained application-level parallelism constructs available in Guile, based on its support to POSIX threads.

Guile-dbi: 'guile'-dbi is a generic database interface for Guile that provides a way to use database drivers that are linked at run-time.

Guile-gnome: Guile-Gnome is a Guile wrapper collection for some of the GNOME core libraries. This package tries to build the following wrappers: Gobject, Glib, Atk, Pango, Pangocairo, Gdk, Gdk-Pixbuf, Gtk, Libglade, Libgnome, Libgnomeui, Libgnomecanvas. Guile-Gnome makes GNOME accesible from Guile, so it provides a convenient interface for Scheme programmers to develop visual applications.

Guile-gtk: Guile-Gtk makes the Gtk+ 1.2, Gdk Pixbuf, Glade and Gtk GL graphical user interface libraries available to Guile Scheme programmers. Complete GUI applications can be written using Guile Gtk, using both the high level Gtk widgets and the low level Gdk drawing.

Guile-sdl ,: GNU Guile-SDL is a set of bindings to the Simple DirectMedia Layer (SDL). With them, Guile programmers can have easy access to graphics, sound and device input (keyboards, joysticks, mice, etc.). Most of the SDL functions are wrapped, with the exception of a few functions that are too C-centric. The SDL threads and audio functions are not included. However audio programming can be done with the module SDL_mixer… Also included is SDL_gfx 2.0.22 and bindings for it.

Guile-sdl2: Guile-sdl2 provides Guile Scheme bindings for the SDL2 C shared library. The bindings are written in pure Scheme by using Guile's foreign function interface.

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.

HTTP Switchboard: An http switchboard implementation that can use rev, eventmachine or regular threaded "panels".

HX: A miniature web site generator.

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 metadata

hachoir-metadata extracts metadata from multimedia files: music, picture, video, but also archives. It supports most common file formats:

Archives: bzip2, gzip, zip, tar
Audio: MPEG audio ("MP3"), WAV, Sun/NeXT audio, Ogg/Vorbis (OGG), MIDI, AIFF, AIFC, Real audio (RA)
Image: BMP, CUR, EMF, ICO, GIF, JPEG, PCX, PNG, TGA, TIFF, WMF, XCF
Misc: Torrent
Program: EXE
Video: ASF format (WMV video), AVI, Matroska (MKV), Quicktime (MOV), Ogg/Theora, Real media (RM)
It tries to give as much information as possible. For some file formats, it gives more information than libextractor for example, such as the RIFF parser, which can extract creation date, software used to generate the file, etc. But hachoir-metadata cannot guess informations. The most complex operation is just to compute duration of a music using frame size and file size. hachoir-metadata has three modes:
classic mode: extract metadata, you can use --level=LEVEL to limit quantity of information to display (and not to extract)
--type: show on one line the file format and most important informations
--mime: just display file MIME type

Hare: Hare is a new programming language made by Drew DeVault that is similar to C but designed to be more simple. It is based on the QBE compiler backend, which provides good performance in a small footprint. Hare uses a static type system, manual memory management, and a minimal runtime. It is well-suited to writing operating systems, system tools, compilers, networking software, and other low-level, high performance tasks.

High Level Assembly Language: The High Level Assembly Language (HLA) was designed to allow advanced assembly language programmers to write more readable and powerful assembly language code. It makes it possible to write code by leveraging knowledge of high level languages like C, C++, Pascal, and Delphi. HLA compiles into 80x86 assembly language, which is assembled by MASM, TASM, or Gas.

HighLine: 'HighLine' eases and simplifies the tasks of doing console input and output with low-level methods like gets() and puts(). It provides a system for requesting data from a user, without needing to code all the error checking and validation rules and without needing to convert the typed Strings into what your program really needs.

Hobbit: This program is currently part of the SCM Scheme implementation. Hobbit is a small optimizing scheme-to-C compiler written in R4RS Scheme and intended for use together with SCM scheme. It compiles full R4RS (with the exception of mutual tail recursion and hygienic macros) and supports defmacros. Hobbit treats SCM files as a C library and provides integration of compiled procedures and variables with the SCM interpreter as new primitives. It compiles scheme files to C files and does not provide anything else by itself (eg. calling the C compiler, dynamic loading). Hobbit (derived from hobbit5x) is included in SCM since 2007. Hobbit4d has also been ported to an old version of Guile.

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.

ICTFax: ICTFax is free software white lable internet fax software that support email to fax , web to fax as well as fax to web and fax to email also it support integration with existing fax machines. ICTFax features both outbound faxing and inbound fax over internet through DID numbers

IDLEfork: The IDLEfork project is an official experimental development fork of Python's small, light, 'bundled' integrated development environment, IDLE. Its objective is to develop a version of IDLE which had an execution environment which could be initialized prior to each run of user code.

IMDbPY: 'IMDbPY' provides easy access to IMDB using a Python package. It is theoretically independent from the data source (since IMDB already provides different interfaces to their database). It is mainly intended for programmers and developers, but some example scripts are included.

IMDbPyKit: A web interface to the IMDb data. This is a web interface to all information accessible through IMDbPY; the output is not suitable for old browsers or mobile phone, so you can also take a look at imdbgw.

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.

IPython

IPython: an interactive computing environment. The goal of IPython is to create a comprehensive environment for interactive and exploratory computing. To support, this goal, IPython has two main components:

An enhanced interactive Python shell.
An architecture for interactive parallel computing.

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.

Ide.php: 'Ide.php' is a Web-based editor for quick development of server side code. It has a rapid prototyping environment so you can test and save snippets of code with minimal overhead. You can use it to develop PHP, ASP, JSP, SSI, HTML, or CGI.

Importex: This Ruby gem helps import an Excel document into a database or some other format. Just create a class defining the columns and pass in a path to an "xls" file. It will automatically format the columns into specified Ruby objects and raise errors on bad data.

Incf cl

The package (incf cl) is a collection of convenience functions and macros to aid in the development of software written in Common Lisp. Some of the available features are:

List manipulation functions similar to those in Haskell's prelude.
List comprehensions.
Doctest suite for automatic verification of examples in docstrings.
Nesting functions similar to those available in Mathematica.

IndexedCatalog

IndexedCatalog provides indexing and allows queries for objects based on attributes. Which is accomplished by indexing all fields by type (string/integer/float) and by a simple query language. The IndexedCatalog does not require any additional extensions apart from the ZODB, and it made for applications that use StandaloneZODB and not Zope. It is completely untested with Zope at this time. Features:

Provides a Shelf, which aggregates queries and is a front-end to all IC features.
Provides a Catalog class that stores objects and offers a query interface.
Provides Indexes for Strings, Floats, Integers, Dates and Instances.
Requires very little change to objects for catalogs and indexes to work: basically inherit from IndexedCatalog.IndexedObject, add some special attributes to the Classes, and use catalog.insert() to add the instances to the catalogs.
Supports composite objects, initializing and indexing sub-objects automatically.
Supports queries by type, and allows querying sub-object or referenced object attribute values.
Allows ordering query results by field, both ascending and descending.
Using Distutils means miminal effort to install.

Integrity: Integrity is your friendly automated Continuous Integration server. As soon as you push your commits, Integrity builds your code, run your tests and makes sure everything works fine. It then reports the build status using various notifiers back to you and your team so everyone is on the same page and problems can be fixed right away.

Integrity Twitter: Integrity is your friendly automated Continuous Integration server. This lets Integrity send a tweet after each build is made.

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

Io

Io is a small prototype-based programming language. The ideas in Io are mostly inspired by ANSI Smalltalk (all values are objects) and Act1, Self, and NewtonScript (actors and futures, differential protos, inheritance by delegation). Features:

small (~12K lines)
pure object language
reasonably fast (comparable to Python, Perl, Ruby)
differential prototype-based object model
untyped
incremental garbage collection
exceptions
ANSI C implementation (except for inline directive)
embeddable
multi-state (multiple independent VMs can run in the same application)
coroutines (light wieght threads)

Isounidecode: Conversion and transliteration of unicode into ascii or iso-8859-1.

Free Software Foundation!

Semantic search

Query log

Guile's VM

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Interaction

Navigation

Creation

Print

Tools