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

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

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

JDEE: The Java Development Environment for Emacs (JDEE) is an add on software package for Emacs that assists in the development of software in the Java Programming Language. JDEE provides many Emacs commands that help with editing, compiling, running, debugging, and browsing large Java programs.

JQuery Autocompleter: I modeled this autocompleter to be as *simple* as possible. From a higher level, and autocompleter is nothing more than a submission of the contents of a single form field to a url, and then displaying the results.

JRuby: Ruby is the effort to recreate the Ruby interpreter in Java. JRuby is tightly integrated with Java to allow both to script any Java class and to embed the interpreter into any Java application. The package includes a Ruby 1.6.7 compatible interpreter (not all builtin classes are supported yet), support for scripting Java classes and interfaces in JRuby, and Bean Scripting Framework (BSF) support.

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

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

JSBundle: jsBundle is a python project that gathers and builds javascript libraries into single files, minified, documented, and even gathers test files. The built files can optionally include a hash in their filenames to ensure browsers don't continue to cache through versions.

JSONPath: JSONPath is an XPath-like tool for JSON.

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

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

JZlib: JZlib is a re-implementation of zlib in pure Java. The first and final aim for hacking this was to add packet compression support to pure Java SSH systems. It can inflate and deflate zlib data, but does not yet support gzip file handling supports. It does support all compression levels and flushing modes in zlib.

Jack: Jack is a console based cd-ripper. It supports cdparanoia and cdda2wav (amongst others) for extraction and various MP3 and OGG/Vorbis encoders; you can even rip from a cdrdao-generated CD image. Emphasis is on failure-safeness and ease of use. Jack can encode multiple tracks at once, good on SMP systems. It resumes its work if interrupted and keeps an eye on available HD space. It also supports freedb query at any time, even after encoding, and can try to query freedb for MP3s of which you do not know the CD anymore (provided you have a complete rip and know the track sequence).

Janet: Janet is a functional and imperative programming language. It runs on Windows, Linux, macOS, BSDs, and should run on other systems with some porting. The entire language (core library, interpreter, compiler, assembler, PEG) is less than 1MB. You can also add Janet scripting to an application by embedding a single C source file and a single header.

Java-gnome: Java-GNOME is a Java binding for GTK and GNOME. It is implemented as a JNI layer that delegates the Java calls to the underlying native libraries.

Jekyll: Jekyll is a simple, blog aware, static site generator. It takes a template directory (representing the raw form of a website), runs it through Textile or Markdown and Liquid converters, and spits out a complete, static website suitable for serving with Apache or your favorite web server. This is also the engine behind GitHub Pages, which you can use to host your project's page or blog right from GitHub.

Jeweler

Jeweler: Craft the perfect RubyGem Jeweler provides two things:

Rake tasks for managing gems and versioning of a GitHub project
A generator for creating/kickstarting a new project

Jimtcl: Jim is a small-footprint implementation of the Tcl programming language. It implements a large subset of Tcl and adds new features like references with garbage collection, closures, built-in Object Oriented Programming system, Functional Programming commands, first-class arrays and UTF-8 support. All this with a binary size of about 100-200kB (depending upon selected options). This package provides the Jim interactive shell.

Jinja: Jinja is a sandboxed template engine written in pure Python. It provides a Django like non-XML syntax and compiles templates into executable python code. It's basically a combination of Django templates and python code.

JobLib

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

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

Jquery Infinite Scroll: A basic infinite scrolling pattern for jQuery.

Jquery Livesearch: Adds some live search to your web page.

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

Jtw: Java Training wheels (J.T.W.) provides a less steep learning curve for learning to program in Java. The system is powered by a preprocessor that adds features to Java such as a superfor macro and a file inclusion system much like the C language's preprocessor.

Jug: Jug allows you to write code that is broken up into tasks and run different tasks on different processors. It has two storage backends: One uses the filesystem to communicate between processes and works correctly over NFS, so you can coordinate processes on different machines. The other uses a redis database and all it needs is for different processes to be able to communicate with a common redis server. Jug is a pure Python implementation and should work on any platform.

Kaffe: Kaffe is a clean room implementation of the Java virtual machine, plus the associated class libraries needed to provide a Java runtime environment. As an independent implementation, it was written from scratch and is free from all third party royalties and license restrictions. It comes with its own standard class libraries, including Beans and Abstract Window Toolkit (AWT), native libraries, and a highly configurable virtual machine with a just-in-time (JIT) compiler for enhanced performance.

Karrigell: 'Karrigell' is a Web programming application that includes a Web server and an SQL database (gadfly). It allows execution of Python scripts and of pages mixing Python and HTML, easy handling of authentication and sessions, building pages from components, and internationalization features. It comes with a complete documentation and several demos, including a wiki server, a forum, and a portal with personalization and news editing.

Kawa: Kawa is both a full-featured Scheme implementation, and a compiler toolkit for implementing other programming languages. It currently compiles the Scheme functional language to Java bytecodes. Included in Kawa is qexo, a partial implementation of XQuery in Java.

Kedama: A wrapper around ming. Create swf files in ruby using ming.

Keyword Search: Generic support for extracting GMail-style search keywords/values from strings.

Kite: Kite is a programming language designed to minimize as much of the programmer experience as possible — quick development, fast execution with low CPU and memory usage. Of course, there's more to kite than that, so lets get started on a real introduction. On being unique Kite's syntax is different from most languages, if you're used to your curly braces, indented blocks or end statements, you're in for a little surprise. But hey, cheer up, change is good!

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

Klisp: klisp is an interpreter for the Kernel Programming Language. It aims at being comprehensive and robust as specified in the "Revised(-1) Report on the Kernel Programming Language (revised 29 October 2009)". Kernel Programming Language is a Scheme-like dialect of Lisp in which everything is a first-class object. It features first class environments and statically scoped fexprs (called operatives). It was designed by John N. Shutt. You can read all about it at http://web.cs.wpi.edu/~jshutt/kernel.html klisp is developed by Andres Navarro, a Computer Science undergraduate at Buenos Aires University (UBA). You can reach him at canavarro82@gmail.com. Significant contributions are being made by Oto Havle in his fork over at https://bitbucket.org/havleoto/klisp

Kook: Kook is a very useful tool to control your task such as compile, install or clean. Kook is similar to Make, Rake, Ant, or Cook. Kookbook.py, is a task definition file for Kook.

Kwartz: Kwartz is a template system which realized the concept of 'Independence of Presentation Logic'(IoPL). It is available to separate the presentation layer from the main program with any template system. In addition, Kwartz enables you to separate the presentation logic (such as iteration or conditional branching) from the presentation data (HTML file).

Kxparse: KXParse is a PHP-based, lightweight, easy-to-use XML parser. It's an include file that's loaded on the fly, so it does not need to be installed.

LISA: 'LISA' is a platform for the development of Lisp-based Intelligent Software Agents. It is a production-rule system implemented in the Common Lisp Object System (CLOS), and is heavily influenced by CLIPS and the Java Expert System Shell (JESS). Its core is a reasoning engine based on an object-oriented implementation of the Rete algorithm solving the many-to-many matching problem. LISA can reason over CLOS objects without imposing special class hierarchy requirements, so users cans augment existing CLOS applications with reasoning capabilities. Also, the full power of Common Lisp is available for use within productions; there is no dichotomy between the programming language and its implementation. The project's goals include complete freedom of availability, ease of portbility, simplicity (so that new developers can easily understand code layout and behavior), familiarity (with roots in CLIPS and JESS, LISA will be familiar to those who've worked with these systems), and flexibility.

LWebstring: * webstring replaces the standalone packages webstring, lwebstring, TurboWebstring, and LturboWebstring. lxml-based implementation of webstring, an XML template engine. An lxml-based implementation of webstring, an XML template engine where Python is the template language.

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

Latte: Latte is a true designer-friendly templating language for PHP. Latte compiles template down to the optimal PHP code at the same time as you work. It provides support for creating layouts, blocks, template inheritance, autoescaping, and other features. It is a particularly safe templating system that prevents threats of XSS with context-aware escaping. Latte protects your work from many security traps.

LavaPE: 'LavaPE' is a programming environment for the experimental object-oriented programming language Lava. It replaces text editing with structure editing, thereby preventing all syntactic and many semantic errors. The pure point-and-click nature of Lava programming and the concise representation of programs as declaration trees with small chunks of executable code simplify programming, and ease comprehension.

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

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

Liberty-eiffel: Liberty Eiffel is a compiler for the Eiffel programming language. It continues the development of SmartEiffel, the GNU Eiffel Compiler. It is a complete, small and fast, Eiffel compiler, including an Eiffel to C compiler, documentation tools, a pretty printer, a debugger and various other tools. It also includes a large library of classes distributed under the terms of the MIT/X Consortium License and a comprehensive set of wrappers/bindings for widespread Free-Software libraries. Eiffel is an advanced object-oriented programming language that emphasizes the design and construction of high-quality and reusable software.

Libixp

libixp is a stand-alone client/server 9P library including ixpc client. It consists of less than 2000 lines of code (including ixpc). libixp's server API is based heavily on that of Plan 9's lib9p, and the two libraries export virtually identical data structures. There are a few notable differences between the two, however:

libixp multiplexes connections internally, while on Plan 9, the kernel performs this task, and in plan9port, a separate process is spawned to do so. Despite this divergence, the user of the library will not notice any difference in behavior, except that there may be duplicate tag and fid numbers between different connections. This issue is of little relevance, however, as the library handles the task of mapping fids and tags to arbitrary pointers and P9Req structs.
libixp is released under a lenient MIT-style license, with the exception of the file intmap.c, which comes from Plan 9, and falls under the LPL. This file may be rewritten at some point, but the authors, as of yet, has been uncompelled to do so
.
libixp lacks lib9p's file trees.
Unlike plan9port's lib9p, libixp is POSIX based, and should compile without specialized libraries on nearly any POSIX system.

Lighttpdrecipe: Buildout recipe for generating Lighttpd configuration files This recipe for buildout generates Lighttpd configuration files. It's especially well suited for using with Django (djangorecipe) in FastCGI mode. Config file is generated from Jinja2 template. Recipe provides some custom Jinja tests, specifically tailored for Lighttpd configuration files. Very little logic is hard coded in the python code, most of the work happens in the template, so you can extend default template or even use your own.

Lightweight C++: 'lwc' is a programming language that looks like C++ and is directly translated to readable C code. It supports function overloading, member functions, inheritance, polymorphism (virtual functions), multiple inheritance, virtual inheritance and pure virtual functions, constructors/destructors, new/delete, and simplistic templates. By studying the generated C code it is easy to understand how OOP features are implemented and what is the cost of everything. Adding new features and extensions is also very easy (much easier than adding new C++ extensions to gcc at least).

LineProfiler: line_profiler will profile the time individual lines of code take to execute. The profiler is implemented in C via Cython in order to reduce the overhead of profiling. Also included is the script kernprof.py which can be used to conveniently profile Python applications and scripts either with line_profiler or with the function-level profiling tools in the Python standard library.

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

Lisp-cgi-utils: 'lisp-cgi-utils' is a package for developing CGI scripts with Common Lisp. It implements a very basic HTTP/CGI interface (sending headers, getting GET/POST and environment variables) and offers tools for easier HTML generation with special support for handling HTML forms.

Littler: Littler provides hash-bang (i.e. script starting with #!/some/path) capability for GNU R, as well as simple command-line and piping use.

LoGS: 'LoGS' is a log analysis engine that addresses many of the issues with maintaining larger networks or cluster style machines. It has a dynamic ruleset, can look for messages before triggering an action, and has a powerful programming language used for configuration and extension. With proper rule226set construction, LoGS is a very efficient analysis engine.

Log4c++: 'log4cxx' is a port to C++ of the log4j project. It has the basically same functionaloty as log4j.

Lua: Lua is a programming language designed for extending applications. It is also frequently used as a general-purpose, stand-alone language. It combines simple procedural syntax with powerful data description constructs based on associative arrays and extensible semantics. Lua is dynamically typed, interpreted from bytecodes, and has automatic memory management with incremental garbage collection, making it ideal for configuration, scripting, and rapid prototyping.

Lua-gnome: Links and maintainer email broken. Redirected homepage to archive.org. Poppy-one (talk) 08:23, 1 September 2018 (EDT)

Lush: Lush is an object-oriented Lisp interpreter and compiler with a C interface, a vector, matrix, and tensor engine, a huge numerical library, a GUI toolkit, and bindings to GSL, SDL, OpenGL, V4l, and others. It is an alternative to Matlab, Python, and Scheme, and lets users mix Lisp and C within a single function for a unique combination of flexibility and efficiency. Lush is ideal for researchers in AI, computer vision, audio, image, and video processing, machine learning, statistics, bio-informatics, interactive graphics, and multimedia applications.

MANOOL

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

Makers Mark: Generate syntax highlighted HTML using Markdown/Lighthouse conventions.

ManyMailers: Multiple SMTP servers for ActionMailer.

Map Ready: A Rails plugin to convert models into map ready marker objects. Includes support for marker clustering and offsetting.

Maruku: Maruku is a Markdown interpreter written in Ruby.

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

Maxima: Maxima is a fairly complete computer algebra system written in lisp with an emphasis on symbolic computation. It is the Common Lisp implementation of MIT's Macsyma system for computer based algebra.

Memcache Client: A ruby library for accessing memcached.

Merb-cache: A plugin for the Merb framework that provides caching stores, strategies and helpers.

Mercury: Mercury is a modern logic/functional programming language. It includes a compiler, a debugger, a profiler, and numerous library packages and other tools. It is designed to be the successor to logic programming languages like Prolog. It combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. It allows modularity, separate compilation, and numerous optimization/time trade-offs.

Metric Fu: Metric_fu is a set of rake tasks that make it easy to generate metrics reports. It uses Saikuro, Flog, Flay, Rcov, Reek, Roodi, Churn, RailsBestPractices, Subversion, Git, and Rails built-in stats task to create a series of reports. It's designed to integrate easily with CruiseControl.rb by placing files in the Custom Build Artifacts folder.

Midica: A Music programming language - translates source code into MIDI. Includes a player. Supports MIDI-Karaoke. Includes a MIDI analyzer. Supports several import and export formats. Can also be used to develop in other music programming languages like ALDA or ABC.

MissingH: 'MissingH' is a library of all sorts of utility functions for Haskell programmers. It is written in pure Haskell and thus should be extremely portable and easy to use. It also has no prerequisites save those that are commonly included with Haskell compilers. In currently has 36 different modules, including a full logging infrastructure, printf() implementations, various string and I/O utilities, a FTP client library, and more.

Mit-scheme: Mit-scheme is an implementation of the Scheme programming language, providing an interpreter, compiler, source-code debugger, integrated Emacs-like editor, and a large runtime library. MIT/GNU Scheme is best suited to programming large applications with a rapid development cycle.

Mod python: Mod_python is an Apache module that embeds the Python language interpreter within the server. This lets Apache handlers be written in Python for faster and more powerful applications than plain CGI.

Mod ruby: mod_ruby' embeds the Ruby interpreter into the Apache Web server, allowing Ruby CGI scripts to be executed natively. These scripts will start up much faster than without mod_ruby.

Mogofeed: MogoFeed combines multiple news feeds (or feed topic searches) into a single web page view, much like a typical "Planet"-style feed aggregator. ItÃ¢â¬â¢s built in Ruby on top of Sinatra and DataMapper.

Mongo Metrics: Rack middleware to record web requests to MongoDB.

MongoMapper: Awesome gem for modeling your domain and storing it in mongo.

Mongoid: Mongoid is an ODM (Object-Document-Mapper) framework for MongoDB in Ruby.

Mono: Mono is a free implementation of the various ECMA and .NET framework technologies for Posix, MacOS X, and Windows. The project includes a compiler, a class library, and a CLI runtime engine.

Moonshine: Moonshine is Rails deployment and configuration management done right. By leveraging capistrano and puppet, moonshine allows you have a working application server in 15 minutes, and be able to sanely manage itÃ¢â¬â¢s configuration from the comfort of your version control of choice.

Moonshine Resque: A Moonshine plugin for installing and managing resque.

Morbid: A Twisted-based publish/subscribe messaging server that uses the STOMP protocol.

Mother: Mother is a python module that hides SQL syntax and gives you a set of intelligent classes and methods. With intelligent we mean the capability of self-adaption, understanding various situations. Mother could be considered as a Object Relational Mapper with a strong introspection. In fact, configuration files, tables, fields and keys declarations are not needed, because Mother knows the database structure herself. Mother works with PostgreSQL and SQlite.

Mozart Oz: Mozart is an advanced development platform for intelligent, distributed applications. It is based on the Oz language, which supports declarative programming, object-oriented programming, constraint programming, and concurrency as part of a coherent whole. For distribution, Mozart provides a true network transparent implementation with support for network awareness, openness, and fault tolerance. Security is upcoming. Mozart is an ideal platform for both general-purpose distributed applications as well as for hard problems requiring sophisticated optimization and inferencing abilities.

MultiShove: Stores objects in multiple storage backends simultaneously with dictionary-style access, caching, and object serialization and compression.

Multifileiter: An iterator over all lines of the given files. Like module fileinput in the standard library, but faster, and written in C. Unlike fileinput, input files are not completely read into memory; it can handle files of any size. In addition, a replacement for the standard fileinput.FileInput legacy class is provided. This package has no external dependencies. It has been tested in Python 2.6; support for Python 3.1 is still experimental.

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

My Knowledge Explorer: My Knowledge Explorer uses the mKR (my Knowledge Representation) language to create, query and update mKB (my Knowledge Base). mKR is a useful mixture of English (subject, verb, object, preposition phrase) and the KornShell (variables, procedures, control structures). mKB can be a local user KB or an internet KB such as OpenCyc. The Redland RDF Library commands can be used to translate mKR to/from standard W3C languages such as Turtle and SPARQL.

MySQL for Python (MySQLdb)

MySQLdb is an interface to the popular MySQL database server for Python. The design goals are:

Compliance with Python database API version 2.0 [PEP-0249]
Thread-safety
Thread-friendliness (threads will not block each other)
MySQL-3.23 through 5.0 and Python-2.3 through 2.6 are currently supported. Python-3.0 will be supported in a future release.

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

Nakatype: Prototype.js extensions.

Nasal: Nasal (Not another scripting language) is a small, simple, yet full-featured language designed for use as an extension language in cases where larger languages are too large or unwieldy. It supports OOP syntax and functional programming, works on the traditional data realm of strings, vectors, and hashes, and does it all in less than 100k of ANSI C. Please note that this is not the NASL extension language from the Nessus project.

Nb++: nb++ is a nuts-and-bolts C++ toolkit. It includes classes for basic operating system features such as sockets, threads and regular expressions, along with threading strategies, a framework for writing daemons and tools for reference counting and event dispatching. Special attention has been given to thread safety.

Ncc: 'ncc' is a C source code analyzer which generates program flow and variable usage information. Using it should be as easy as changing CC=gcc to CC=ncc in makefiles, and it supports most common gcc extensions. It has been tested with (among others) the sources of the Linux kernel, gtk, gcc, gdb, bind, mpg123, and ncftp.

Nested Form: A Rails plugin to conveniently manage multiple nested models in a single form. It does so in an unobtrusive way through jQuery.

Newrelic-api: Java client library for the New Relic REST APIs built using Jersey and Gson. The library implements over 110 operations across all of the available 35 New Relic services. It is primarily used by applications to automate the configuration of New Relic Monitoring, Alerting and Dashboards, but can also be used for extracting incident and metric data, executing Insights queries, or uploading plugin metrics.

Nice: Nice is an object-oriented programming language based on Java. It incorporates many advanced features from functional programming and academic research. This results in more expressivity, modularity and safety.

Nifty Generators: A collection of useful Rails generator scripts for scaffolding, layout files, authentication, and more.

Nim

Nim was created to be a language as fast as C, as expressive as Python, and as extensible as Lisp. Nim is statically typed. It supports compile-time metaprogramming features such as syntactic macros and term rewriting macros. Term rewriting macros enable library implementations of common data structures, such as bignums and matrices, to be implemented efficiently, as if they were built-in language facilities. Iterators are supported and can be used as first class entities, as can functions, allowing for the use of functional programming methods. Object-oriented programming is supported by inheritance and multiple dispatch. Functions can be generic, they can be overloaded, and generics are further enhanced by Nim's support for type classes. Operator overloading is also supported. Nim includes tunable automatic garbage collection based on deferred reference counting with cycle detection, which can also be turned off altogether.

Features

Intuitive and clean syntax (inspired by Python)
JavaScript compilation
Small core with a rich prospect for extensibility
Decentralised package management with Nimble, the Nim package manager
Helpful tracebacks (inspired by Python)

Nitpick: Nitpick is intended to be a customizable, programmable, static checker for Ruby. It currently consists of a script which scans requireÃ¢â¬â¢d code (via method_added) and outputs various warnings built atop a library which provides code-level access to warnings .

Nokogiri: Nokogiri (Ã©â¹Â¸) is an HTML, XML, SAX, and Reader parser. Among Nokogiri's many features is the ability to search documents via XPath or CSS3 selectors. XML is like violence - if it doesnÃ¢â¬â¢t solve your problems, you are not using enough of it.

Noor

Noor is a program written in Python for viewing Quran. These are the interfaces that come with noor: Interface Description

noorgtk Uses PyGtk library; it has many features like bookmarks, notes and automatically playing recitations using external players.
noorhtmls Outputs quran in html files in a directory
noorcgi Can be used as a CGI script in web servers
noortxt Outputs a sura to a plain text file
You can specify translation files; If specified, the translation of each aya is shown after it. Translations can be in two formats.

Nota Bene: Nota BeneÃ¢â¬âis a note-taking application with Emacs integration akin to Notational Velocity.

NumExp: 'NumExp' is a Gnome program that implements numeric methods and some mathematical solutions. It is implemented via a CORBA server and a text client.

NumPy

The fundamental package needed for scientific computing with Python is called NumPy. This package contains:

a powerful N-dimensional array object
sophisticated (broadcasting) functions
basic linear algebra functions
basic Fourier transforms
sophisticated random number capabilities
tools for integrating Fortran code
tools for integrating C/C++ code

Besides its obvious scientific uses, NumPy can also be used as an efficient multi-dimensional container of generic data. Arbitrary data-types can be defined. This allows NumPy to seamlessly and speedily integrate with a wide-variety of databases. NumPy derives from the old Numeric code base and can be used as a replacement for Numeric. It also adds the features introduced by Numarray and can also be used to replace Numarray.

Objective Caml: The Objective Caml system is the main implementation of the Caml language. It features a powerful module system and a full-fledged object-oriented layer. It comes with a native-code compiler that supports numerous architectures, for high performance; a bytecode compiler, for increased portability; and an interactive loop, for experimentation and rapid development.

Ocaml: An industrial-strength functional programming language with an emphasis on expressiveness and safety.

Ol: Otus Lisp (Ol in short) is a purely functional dialect of Lisp. It implements an extended subset of R5RS Scheme including, but not limited to, some of the SRFIs. It's tiny(42kb), embeddable and crossplatform; can run in own sandbox; provides a portable, highlevel way for calling the code written in another languages. You can use Otus Lisp on GNU/Linux, Windows, Unix, Android and lot of any other operation systems with various (x86, x86_64, mips, arm, aarch64, ppc, etc.) architectures.

Onyx: Onyx is a powerful stack-based, multi-threaded, interpreted, general purpose programming language similar to PostScript and Forth. It can be embedded as an extension language into other applications, and was designed to have a small memory footprint. It is among the smallest embeddable interpreters available.

Optcomplete: 'optcomplete' provides programmable shell completion support for Python scripts that use the 'optparse' module. It implements the Bash completion protocol, and a simple common shell function invokes the script to provide the completion suggestions. Since an optparse parser already has most of the useful information required to provide completions, only two lines of code are needed to provide basic support for completions to an existing script. It also lets the developer to provide per-option completion, etc.

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

Optimus Prime: An option parsing yak shave.

OrderedDict: Drop-in substitute for Py2.7's new collections.OrderedDict. The recipe has big-oh performance that matches regular dictionaries (amortized O(1) insertion/deletion/lookup and O(n) iteration/repr/copy/equality_testing).

Orderly: Orderly is a textual format for describing JSON. Orderly can be compiled into JSONSchema. It is designed to be easy to read and write.

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

Otp: Erlang is a functional programming language designed in the Computer Science lab at Ericsson in Sweden in the late 1980s. It is used to build massively scalable soft real-time systems with requirements on high availability. Some of its uses are in telecom, banking, e-commerce, computer telephony and instant messaging. Erlang's runtime system has built-in support for concurrency, distribution and fault tolerance. The Erlang distribution also includes OTP (Open Telecom Platform) which provides a rich set of libraries and applications providing middle-ware to develop these systems. It includes its own distributed database, applications to interface towards other languages, debugging and release handling tools. This package also contains code examples and the Erlang editing mode for Emacs.

Owl: 'owl' (Obfuscated Weird Language) is a Forth-like language based on characters, and is written in C for the gcc. It has been inspired by false (the ancestor of all obfuscated Forth-like languages, written by W.v.Oortmerssen in 1993).

Oxref: Oxref generates a cross reference listing of symbols defined in non-stripped object files and/or libraries. A cross reference listing shows the functions using certain symbols (functions, data). This is useful information during program develop- ment and debugging phases. E.g., assuming that the signature; the pre-conditions or the post-conditions of a function must be changed it is important to know from what function(s) the function-to-modify is called to verify that the changes to the modified function do not break its calling functions. The generated cross reference listing starts with a header showing information about the program, a time stamp and the arguments passed to oxref. E.g., To create the program from its sources, either descend into the oxref 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 oxref are available in verious GNU/Linux distributions, in particular Debian. See, e.g., https://packages.debian.org/search?keywords=oxref&searchon=names&suite=all&section=all Github's web-pages for oxref are here: https://fbb-git.gitlab.io/oxref/

PALB: palb is a HTTP benchmark tool. The command line interface resembles the Apache benchmark tool ab. It lacks the advanced features of ab, but it supports multiple URLs (from arguments, files, stdin, and Python code). palb uses pycurl for high-performance URL retrieval and is able to handle more than thousand requests per second with dozens of concurrent requests. If pycurl is not available palb will fall back to Pythons urllib2.

PHPGallue: PHPGallue is a multi-user, server-oriented image management system with a Web frontend. PHPGallue is suited for photographers to organize and publish their work. It allows the user to mark images, groups, categories, films, and series as private or as only visible to registered users. It is designed especially for large numbers of images. The Web frontend and backend libraries are completely separated, so it is easy to integrate PHPGallue as a management system into existing Web applications.

PHPKook: A software build tool such as Make, Ant, SCons or Cook. PHPKook is implemented in PHP5. Basic commands (copy, move, rename, mkdir, ...) are also implemented in PHP(Kook) and allow you to execute platform-depended command.

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

PTML: PTML is a Python module which lets you embed Python code in text documents. Its most common application is dynamic content generation on web servers, however it can be used anywhere you need to generate text files on-the-fly.

PY-postgresql: py-postgresql is a set of Python modules providing interfaces to various parts of PostgreSQL. Notably, it provides a pure-Python driver + C optimizations for querying a PostgreSQL database.

Packet: It allows the user to define a packet format, and to create a Python class to represent those packets with named attributes for each packet field.

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

Parkaby: Ruby is nice. I think that's something we all can agree on. When you suddenly need to output some HTML in the middle of your app, it's very convenient to continue writing Ruby, instead of switching to String and interpolation. That's where Markaby comes in.

ParseDateTime: Parse human-readable date/time expressions.

Pascal: GNU Pascal is the Pascal language compiler of Project GNU. It is a 32/64 bit compiler that is linked against the GCC backend and will be integrated in to GCC in the long run. It runs on all operating systems compatible with GCC, and can act as a native or a cross compiler between those systems. It implements ISO Pascal, Borland Pascal 7.0, and parts of other Pascal standards or de-facto standards.

Pasdoc: Pasdoc generates documentation for Pascal units. It takes descriptions from comments within the source code. Documentation output formats include HTML and LaTeX. Object Pascal, FreePascal and Delphi specific features are supported.

Pcynlitx: Pcynlitx is an alleged outcome of the scientific research study that is carried out by Erkam Murat Bozkurt about meta-programming. The software has been developed by Erkam Murat Bozkurt that lives in Istanbul / TURKEY. He has graduated from Istanbul Technical University ( ITU ) Control Systems Engineriing division with M.Sc degree. The main purpose of the research study is to develop an easy and efficient way to develop multi-threaded C++ programs. Pcynlitx is the name for a vaporware allegedly existing software project with unclear aims.

Pebl

Pebl is a python library and command line application for learning the structure of a Bayesian network given prior knowledge and observations. Pebl includes the following features:

Can learn with observational and interventional data
Handles missing values and hidden variables using exact and heuristic methods
Provides several learning algorithms; makes creating new ones simple
Supports hard and soft structural priors
Has facilities for transparent parallel execution
Calculates edge marginals and consensus networks
Presents results in a variety of formats

Pegboard: Pegboard is a toolkit for grouping related WSGI components together and dispatching WSGI events into the group of components. These components conform to the WSGI interface and can be either Pegboard-aware components or any WSGI compliant application.

Peggy: Peggy helps you to create GTK applications that run out-of-the-egg. It offers functions to load ressources (like .glade files, images, locales) from a (zipped or unzipped) egg. Peggy is a thin layer on top of setuptools and PyGtk. ItÃ¢â¬â¢s not doing much fancy stuff but can save you from reading some docs. ;-)

Perl: Perl is an high-level programming and scripting language.

PerlPanel: PerlPanel is an attempt to build a useable, lean panel program (like Gnome's gnome-panel and KDE's Kicker) in Perl, using GTK 2. It has an object-oriented design for easy customisation and extension, and an applet architecture that means that you can create an applet in a matter of minutes.

Php-Brainfuck: PHP-Brainfuck is an interpreter for the Brainfuck language designed to help learning and developing BF without having to compile all the time. Also, it shouldn't crash when your brackets are unbalanced. It comes with a small tutorial, some examples, and useful links.

PhpCodeGenie: 'phpCodeGenie' is a code generator for PHP/MySQL applications. Once you design your database tables, phpCodeGenie writes the PHP scripts and programs for you. It will build data entry forms, insert scripts, database lister scripts, edit record forms, update record scripts, delete confirmation scripts, delete scripts, search forms, search scripts and other frontend/database interaction code.

PhpHtmlLib: phpHtmllib is a set of PHP classes and library functions that build, debug, and render XML, HTML, XHTML, and WAP/WML documents, as well as SVG (Scalable Vector Graphics) images and complex HTML 'widgets'. It also has a powerful Form Processing engine that helps build/maintain complex HTML/XHTML forms.

PhpMyLinks: phpMyLinks is a PHP script which manages HTTP URLs. You can quickly add, delete, or modify your HTTP links and follow any link in the alphabetical list to reach your destination.

Phpwebapp: 'phpWebApp' is an application framework which simplifies building PHP Web applications based on relational databases. It separates the task of designing and changing the layout of the application from the task of implementing the logic of the application, by using XML templates that are an extension of XHTML. It also simplifies the task of implementing the logic of the application by offering an event based programming model.

Phuby: Phuby wraps PHP in a loving embrace. Exposes a PHP runtime in Ruby.

Pickler: Synchronize user stories in Pivotal Tracker with Cucumber features. If you aren't using Cucumber, you can still use pickler as a Pivotal Tracker command line client, provided you humor it with a features/ directory containing a tracker.yml file.

Platinfo

A small library which determines and returns standardized names for platforms. The driving goal is to provide platform names that are:

relatively short
readable (as much as possible making matching the given name to an actually machine self-explanatory)
be capable enough to produce all names needed to distinguish all platform-specific application builds
generally safe for usage in filenames
not ugly (e.g. "MSWin32" is ugly)

Pliant: Pliant is the first efficient, truly extendable, customizable programming language. It is suited both for small scripts and for very large applications, and could be described as a combination of reflexive C, C++, typed Lisp, and clean syntax in a single language. Pliant is a newer, very tiny language with a very simple syntax, so advanced features can be written in the language itself, as modules. Its module model can extend the language itself. A true language, introduced in this Pliant documentation is the Pliant Default Extension Environment: PDEE. However, it is not the only possible Pliant language. Beginners can use Pliant as an interpreted language by writing small pieces of code and running them directly. Experienced programmers can run Pliant as a compiled language: you can write efficient programs while using most high level programming features of object oriented languages and the expression power of logical programming languages. Pliant is also an ideal linker: you can write different pieces of a project in different programming styles with all parts interacting.

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

Populator: Populate an Active Record database with mass insert.

Ppgplot: 'ppgplot' is a Python package (extension) providing Python bindings to the PGPLOT graphics library. It uses the numeric or numarray Python modules to efficiently represent and manipulate vectors and matrices.

PrettyException: 'PrettyException' is a library to generate pretty HTML output for a given Exception. It is useful for those who develop Web applications in Ruby and don't have access to a Web server's logs.

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

Profilehooks: Sometimes you want to profile just a single function in your Python program. The profilehooks module lets you do that very easily.

Progtools: Progtools is a simple command-line interface (CLI) library for Python.

Project-Mindfulness: Project Mindfulness is an initiative to improve societal understanding of mindfulness by way of data science and computer programming. This project is 100% free (as in freedom) and open source. Feel free to contribute! Mindfulness: observing (physical or mental, positive or negative) followed by describing (internally or externally). A person skilled in mindfulness will then fully bring the mind back to baseline through an act of awareness while simultaneously accepting the observation without judgment. Click on the supplied URL and check out the README.md!

Protoeditor: Protoeditor is a small KDE text editor developed for debugging scripts interactively. The goal is to provide a simple editor supporting a variety of debuggers for different languages.

Prototype: Prototype is a JavaScript framework that aims to ease development of dynamic web applications. It offers a familiar class-style OO framework, extensive Ajax support, higher-order programming constructs, and easy DOM manipulation.

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

Psutil: Psutil is a module providing convenience functions for managing processes in a portable way by using Python.

Psych: A libyaml wrapper for Ruby.

Psyco: 'Psyco' helps execute Python code at speeds approaching that of fully compiled languages by using a technique called "specialization". This extension module for the unmodified interpreter accelerates user programs with little or no change in their sources. An increase in speed of 2 to 10 times is common.

Pure: Pure is a modern-style functional programming language based on term rewriting. It offers equational definitions with pattern matching, full symbolic rewriting capabilities, dynamic typing, eager and lazy evaluation, lexical closures, built-in list and matrix support and an easy-to-use C interface. The interpreter uses LLVM as a backend to JIT-compile Pure programs to fast native code. Pure is closely related to the author's Q language and is slated to eventually become its successor, since it offers many new and powerful features and programs run much faster than their Q equivalents. (OTOH, Q still offers many more library modules right now. Most of these will eventually be ported to Pure, but this will take some time.)

Py-RADIUS: radius.py is a pure Python module implementing client side RADIUS authentication as defined by RFC2138.

Py9p: Py9p is a pure python implementation of the 9P (in particular 9p2000) distributed file system protocol. Includes both client and server APIs, and both client and server authentication (using the Python Cryptography Toolkit).

PyCUDA

PyCUDA lets you access Nvidia's CUDA parallel computation API from Python. Several wrappers of the CUDA API already exist-so what's so special about PyCUDA?

Object cleanup tied to lifetime of objects. This idiom, often called RAII in C++, makes it much easier to write correct, leak- and crash-free code. PyCUDA knows about dependencies, too, so (for example) it won't detach from a context before all memory allocated in it is also freed.
Convenience. Abstractions like pycuda.driver.SourceModule and pycuda.gpuarray.GPUArray make CUDA programming even more convenient than with Nvidia's C-based runtime.
Completeness. PyCUDA puts the full power of CUDA's driver API at your disposal, if you wish. It also includes code for interoperability with OpenGL.
Automatic Error Checking. All CUDA errors are automatically translated into Python exceptions.
Speed. PyCUDA's base layer is written in C++, so all the niceties above are virtually free.

PyColors: Works fine on any Operating System running BaSH or compatibles. If the shell's not color compatible, you'll get the raw string. The module have predefined some basic colors, but you can use any color, if you know the color code.

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

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

PyGTK: PyGTK is a set of bindings for the GTK widget set. It provides an object oriented interface that is slightly higher level than the C one. It automatically does all the type casting and reference counting that you would have to do normally with the C API. GTK+ 2 with Python 2 is supported, for GTK+ 3 or Python 3 use PyGObject instead.

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

PyKDE: PyKDE is a set of Python bindings for the KDE desktop environment that is used primarily as a GUI toolkit. Bindings are implemented as a set of Python modules that correspond to libraries in the kdelibs package. PyKDE supports nearly all classes and methods in these libraries. It also supports all of the enhancements to the Qt widget set developed by the KDE team as well as the 'standard' KDE dialog boxes, and features that greatly simplify the construction of menu/toolbar based GUIs. Additionally, you can mix PyKDE widgets and other classes with PyQt widgets and classes, just as you would in C++. Included modules are: dcop, kdecore, kdesu, kdefx, kdeui, kio, kfile, kparts, khtml, kspell, kdeprint and kmdi (with optional kjs). PyKDE supports KDE versions 3.0.0 to 3.2.3 and Qt versions 3.0.0 and later (as supported by PyQt). KDE 2 is no longer supported.

PyKE: Both forward-chaining and backward-chaining rules (which may include python code) are compiled into python. Can also automatically assemble python programs out of python functions which are attached to backward-chaining rules.

PyMonitor: PyMonitor module is used to add support for enable runtime monitoring/inspecting of a running Python application.

PyORBit: PyORBit is a Python binding for the ORBit2 CORBA ORB. It was developped to suit the needs of the bonobo bindings in GNOME-Python, but is usable for other purposes as well.

PyORQ: PyORQ (Python Object Relational binding with Queries) implements persistence for Python objects using a relational database (PostgreSQL, MySQL, SQLite) for storage. PyORQ uses native Python expressions to denote queries which can be automatically translated into SQL and then be executed by the backend. This leverages the search capabilities of a relational database in an object-oriented programming environment.

PyOpenCL

PyOpenCL lets you access GPUs and other massively parallel compute devices from Python. It tries to offer computing goodness in the spirit of its sister project PyCUDA:

Object cleanup tied to lifetime of objects. This idiom, often called RAII in C++, makes it much easier to write correct, leak- and crash-free code.
Completeness. PyOpenCL puts the full power of OpenCL's API at your disposal, if you wish. Every obscure get_info() query and all CL calls are accessible.
Automatic Error Checking. All CL errors are automatically translated into Python exceptions.
Speed. PyOpenCL's base layer is written in C++, so all the niceties above are virtually free.
Helpful and complete Documentation as well as a Wiki.
Liberal license. PyOpenCL is under the MIT license and free for commercial, academic, and private use.

PyOpenGL: PyOpenGL is the cross platform Python binding to OpenGL and related APIs. The binding is created using the standard (in Python 2.5 and above) ctypes library. PyOpenGL includes support for OpenGL v1.1 through 3.0, GLU, GLUT v3.7 (and FreeGLUT), and GLE 3. It also includes support for hundreds of OpenGL extensions. PyOpenGL is interoperable with a large number of external GUI libraries for Python including (wxPython, FxPy, PyGame, and Qt). It can be used with the Tkinter GUI library if you have installed the Togl widget for Tk.

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

PyQT: PyQt is a comprehensive set of Python bindings for the Qt GUI toolkit. The bindings are implemented as a set of Python modules: qt, qtcanvas, qtgl, qtnetwork, qtsql, qttable and qtxml, and contains 300 classes and over 5,750 functions and methods. PyQt also implements the qtext Python module. This contains bindings for QScintilla, the Qt port of the Scintilla programmer's editor class.

PyQwt: 'PyQwt' is a set of Python bindings for the Qwt class library which contains widgets for scientific and engineering applications. It allows you to integrate PyQt, Qt, Qwt, the Numerical Python extensions, and optionally SciPy in a GUI Python application or in an interactive Python session.

PyRESTclient: A simple REST client for Python, inspired by the microframework (Camping, Sinatra) style of specifying actions: get, put, post, delete.

PySendmail: PySendmail is a package to invoke the POSIX "sendmail" program to queue e-mail, with an smtplib compatible API.

PySolr: Lightweight python wrapper for Apache Solr.

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

PyWavelets

PyWavelets is a Python wavelet transforms module that includes:

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

PyX: PyX is a Python package for the creation of encapsulated PostScript figures. It provides both an abstraction of PostScript and a TeX/LaTeX interface. Complex tasks like 2D and 3D plots in publication-ready quality are built out of these primitives.

PyYAML

PyYAML features

a complete YAML 1.1 parser. In particular, PyYAML can parse all examples from the specification. The parsing algorithm is simple enough to be a reference for YAML parser implementors.
Unicode support including UTF-8/UTF-16 input/output and \u escape sequences.
low-level event-based parser and emitter API (like SAX).
high-level API for serializing and deserializing native Python objects (like DOM or pickle).
support for all types from the YAML types repository. A simple extension API is provided.
both pure-Python and fast LibYAML-based parsers and emitters.
relatively sensible error messages.

Pyao: 'pyao' is a set of Python bindings for Xiph.org's libao, a cross-platform audio output library.

Pyc: 'pyc' compiles Python source code to Python bytecode. Since it is written entirely in Python, it is easy to modify and add new features to the Python programming language.

Pydspam: 'Pydspam' is a Python wrapper for the 'dspam' project that provides support for sophisticated bayesian message filtering. It provides full access to the features of 'libdspam', and a high level API to handle message tagging and signature database.

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

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

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

Pymad: 'pymad' is a Python module that allows Python programs to use the MPEG Audio Decoder library. It provides a high-level API which makes reading from MPEG audio streams a piece of cake.

Pyrepl

This is pyrepl, a readline-a-like in Python. It requires python 2.2 (or newer) with the curses and termios modules built and features:

sane multi-line editing
history, with incremental search
completion, including displaying of available options
a fairly large subset of the readline emacs-mode keybindings (adding more is mostly just a matter of typing)
a new python top-level
no global variables, so you can run two or more independent readers without having their histories interfering.
no hogging of control -- it should be easy to integrate pyrepl into YOUR application's event loop.
generally speaking, a much more interactive experience than readline (it's a bit like a cross between readline and emacs's mini-buffer)
unicode support (given terminal support)

Pyres: Resque is a great implementation of a job queue by the people at github. It's written in ruby, which is great, but I primarily work in python. So I took on the task of porting over the code to python and PyRes was the result.

Pyro: Pyro is short for PYthon Remote Objects. It is an advanced and powerful Distributed Object Technology system written entirely in Python, that is designed to be very easy to use. Never worry about writing network communication code again, when using Pyro you just write your Python objects like you would normally. With only a few lines of extra code, Pyro takes care of the network communication between your objects once you split them over different machines on the network. All the gory socket programming details are taken care of, you just call a method on a remote object as if it were a local object!

Pysync: 'pysync' has both a demonstration implementation of the rsync and related algorithms in pure Python, and a high speed librsync Python extension. The pure Python is not fast and is not optimized, however it does work and provides a simple implementation of the algorithm for reference and experimentation. It includes a combination of ideas taken from librsync, xdelta, and rsync. The librsync Python extension is less flexible and harder to understand, but is very fast.

Python: Python is an high-level programming and scripting language. Some of its key distinguishing features include: clear, readable syntax; strong introspection capabilities; intuitive object orientation; natural expression of procedural code; full modularity, supporting hierarchical packages; exception-based error handling; and very high-level dynamic data types.

Python rope: Rope is a python refactoring library. Its main goal is to provide IDE features such as auto-completion, refactorings, content assistance, and outlines. The best implementations are done for Emacs and Vim.

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

Python-SIP: 'SIP' creates Python bindings for C and C++ libraries. It was originally developed to create PyQt, the Python bindings for the Qt toolkit, but can be used to create bindings for any C or C++ library. SIP makes it easy to exploit existing C or C++ libraries in a productive interpretive programming environment and to take a Python application and selectively implement parts of it. SIP consists of a code generator and a Python module. The code generator processes a set of specification files and generates C or C++ code which is then compiled to create the bindings extension module. The Python module provides support functions to the automatically generated code.

Python-stablesort: 'python-stablesort' is an adaptive, stable, natural mergesort. It is a back-port of the new Python CVS (i.e., the upcoming version 2.3) stable listsort algorithm to all Python versions (tested with all versions from 1.5.2 to 2.2.3). It can also be regarded as some sort of forward-port in case the default Python list sort() method will change to a non-stable algorithm in the future again.

PythonCAD: The goal of the PythonCAD project is to create a fully scriptable drafting program that will match and eventually exceed features found in commercial CAD software. The program, currently under active development, is in its early stages but can do simple drawing.

Q: * " Q is no longer supported, see Pure instead. Please note that Q has been superseded by the Pure programming language, so please head over to the new website and download the latest version of the Q successor today! " Q (which stands for 'equational') is a functional programming language based on the term rewriting calculus. You specify a system of equations which the interpreter uses as rewrite rules to reduce expressions to normal form. Q lets you formulate programs in a high-level, declarative style. It is useful for scientific programming and other advanced applications, and also as a sophisticated kind of desktop calculator. Features include advanced symbolic expression manipulation, a fast bytecode interpreter, a collection of built-in types, support for lazy evaluation, exception handling, and multithreading, a libtool-based C interface, a standard library with various list processing functions, and add-on modules for interfacing with other programs.

QDot 8086: QDot 8086 is a mid-level programming language targeting the original IBM-PC architecture written as a set of macros for NASM — the Netwide Assembler. The idea behind it is to make it easy to write small, fast, correct and maintainable code in a language almost as expressive as C but without giving up all control Assembly language grants to programmers. It features support to functions of an arbitrary number of parameters and multiple return values, global and function-local variables, loop and conditional flow-control constructs, evaluation of arbitrarily complex stack-based expressions, symbol importing and primitive debugging. In order to accomplish this, NASM’s powerful preprocessing and assembling capabilities are used to achieve a machinery that very closely resembles a compiler. QDot has also a companion standard library that is fully BIOS-based, thus OS-independent, which provides array processing, keyboard, video, disk and speaker I/O, timing, low-level debugging, math functions, user interface procedures and last but not least a versatile metamorphic boot-loader, that makes it simple to build a binary that is simultaneously a valid DOS executable and a bootable image — a property known as run-within-OS-or-bootstrap-itself-without-OS. There are already a couple of programs implemented in QDot as a proof of concept: Terminal Matrix 8086 and DeciMatrix 8086. QDot currently supports only the tiny memory model (.COM binaries — whose code, data and stack fit all within 64kb segment boundaries).

QR: **QR** helps you create and work with **deque, queue, and stack** data structures for **Redis**. Redis is well-suited for implementations of these abstract data structures, and QR makes it even easier to work with the structures in Python. QR works best for (and simplifies) the creation of **bounded** deques, queues, and stacks (herein, DQS's), with a defined size of elements.

QRencoder: This Gem is a wrapper around a useful library for creating QR Codes, a two-dimensional bar code format popular in Japan (and readable by cell phones even) created by the Denso-Wave Corporation in 1994. These bar codes look like the following: http://www.denso-wave.com/qrcode/images/qrcode.gif

Qexo: Qexo (Query Expressions for XML Objects aka Kawa-XQuery) is an implementation of W3C's draft XML query language XQuery. XQuery is a high-level expression language whose values are sequences of nodes (as in DOM) and simple values. It includes syntax for embedding XML or HTML results, and a 'for' statement comparable to SQL's 'select'. This implementation uses the Kawa tools to compile XQuery programs to Java bytecodes that can run on any JVM. XQuery programs can run as servlets, as standalone applications, or from the command-line.

Qscheme: Qscheme is a fast and small implementation of Scheme written in C. It is easy to interface with dynamic libraries (since most of the external functions and variables can be declared directly in Scheme, without any special C coding) and should be easy to use as an extension language. Qscheme supports foreign function call and dynamic library. A Perl-like regular expression module is provided as an example. Benchmarks show that it is generally between 2 and 70 times faster than other scheme interpreters. It now intergrates GTK/libglade bindings. other features include efficient error and exception handling with catch/throw, support for UNIX scripting, native multithreading support, modular programming support, and a new socket interface so you can build a simple client/server on TCP/IP.

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

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

Quadtree: Spatial index for Python GIS.

Quasi: Quasi is a Python shell which supports pluggable "contexts" for non-Python commands, such as OS commands, MySQLdb queries and external programs, where a "context" is a different way of interpreting what you type in. All the contexts support variable sustitution, which means you can drop the value of a Python variable right into a command.

Querulous: An agreeable way to talk to your database.

R: R is a system for statistical computation and graphics. It consists of a language plus a run-time environment with graphics, a debugger, access to certain system functions, and the ability to run programs stored in script files. The core of R is an interpreted computer language which allows branching and looping as well as modular programming using functions. Most of the user-visible functions in R are written in R. It is possible for the user to interface to procedures written in the C, C++, or FORTRAN languages for efficiency. The R distribution contains functionality for a large number of statistical procedures. Among these are: linear and generalized linear models, nonlinear regression models, time series analysis, classical parametric and nonparametric tests, clustering and smoothing. There is also a large set of functions which provide a flexible graphical environment for creating various kinds of data presentations. Additional modules ("add-on packages") are available for a variety of specific purposes.

RDF: The packages is intended to provide the core RDF types and interfaces that other packages can build on. The package defines a plugin interface for parsers, stores, and serializers that other packages can use to implement parsers, stores, and serializers that will plug into the rdf package. The rdf package does not itself contain any plugin implementation. So, you will want to install a library that builds upon rdf and defines some plugin implementations.

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

RPyC: A symmetric library for transparent RPC, clustering and distributed computing for python, built around the concept of remote services and object proxying.

RSpec: RSpec is the original Behaviour Driven Development framework for Ruby.

RSpec Expectations: RSpec-Expectations adds should and should_not to every object and includes RSpec::Matchers, a library of standard matchers.

Rack: Rack provides a minimal, modular and adaptable interface for developing web applications in Ruby. By wrapping HTTP requests and responses in the simplest way possible, it unifies and distills the API for web servers, web frameworks, and software in between (the so-called middleware) into a single method call. The exact details of this are described in the Rack specification, which all Rack applications should conform to.

Rack Cache: Real HTTP Caching for Ruby Web Apps.

Rack Client: A client wrapper around a rack app or Net::HTTP.

Rack Contrib: This package includes a variety of add-on components for Rack, a Ruby web server interface.

Rack Test: Rack::Test is a small, simple testing API for Rack apps. It can be used on its own or as a reusable starting point for Web frameworks and testing libraries to build on. Most of its initial functionality is an extraction of Merb 1.0Ã¢â¬â¢s request helpers feature.

Racket: Racket is a general-purpose programming language in the Scheme family, with a large set of libraries and a compiler based on Chez Scheme. Racket is also a platform for language-oriented programming, from small domain-specific languages to complete language implementations. The main Racket distribution comes with many bundled packages, including the DrRacket IDE, libraries for GUI and web programming, and implementations of languages such as Typed Racket, R5RS and R6RS Scheme, Algol 60, and Datalog. The minimal Racket distribution includes just enough of Racket for you to use raco pkg to install more. Bundled packages, such as the DrRacket IDE, are not included.

Rails Templates: Template scripts for creating new rails applications.

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

Rb.log: 'rb.log' is a full-featured weblogger written in Ruby. It features file uploads, comments, blog-rolling, side-bar editing, bookmarklets, the Blogger API, searching, RSS syndication, and archives. It also performs well on slower machines by regenerating static pages after posts are made.

RedBottle: RedBottle is a small, pluggable application skeleton that's designed to neatly integrate Bottle with Redis. Bottle is a simple, cool, fairly powerful Python micro-framework, with built-in routing and templating. Redis is a fast, powerful, persistent key-value store. Combined, they make a great combination! RedBottle uses a straight-forward, REST-like style to add, remove, and show simple string key-values.

RedFoot: A hypercode program loader and runner.

RedWeb: Redweb is a web interface to the Redis key-value store and server. It is written in Python, and is built on the Bottle micro-framework. With Redweb, you can easily interact with Redis through your web browser, utilizing POST functionality. But Redweb is more than that, too. The Redweb source can be reused to create neat web applications that utilize Bottle and Redis. So Redweb is sort of like a reversible jacket -- you get two nice features for the price of one.

Redis: Redis is an advanced key-value database. It is similar to memcached but the dataset is not volatile, and values can be strings, exactly like in memcached, but also lists, sets, and ordered sets. All this data types can be manipulated with atomic operations to push/pop elements, add/remove elements, perform server side union, intersection, difference between sets, and so forth. Redis supports different kind of sorting abilities.

Redis-Lua: A Lua client library for the redis key value storage system.

Redis-objective: Redis-objective allows you to store objects in Redis.

RedisRB: A ruby client library for the redis key value storage engine. Redis is a key value store with some interesting features: 1. It's fast. 2. Keys are strings but values can have types of "NONE", "STRING", "LIST", or "SET". List's can be atomically push'd, pop'd, lpush'd, lpop'd and indexed. This allows you to store things like lists of comments under one key while retaining the ability to append comments without reading and putting back the whole list.

Redisk: Redisk is a set of Ruby classes that mimic's Ruby's built in IO classes to allow drop in replacement for logging and other fun things.

Redispy: This is the Python interface to the Redis key-value store.

Registry: registry is used to mix into a super class that has many or multiple implementations via subclasses. This has been described to me as a factory pattern, John Barton describes 'registry' as a "metaprogrammed method factory". A good example of this is a parser, you might have a parser for json and another for yml. Register your sub classes to handle certain labels or descriptions, then let the super class decide weather the message you send it can be handled or not.

Remix Stash: A new way to deal with memcached. New API that doesn't actually suck! I've rethought a lot of the API and this comes with a lot of new capabilities. More work is being done on making it as expressive as possible without terrible overhead. This includes vectorized keys which allow emulation of partial cache clearing as well as nice shortcuts like eval and gate for expressions. Options, clusters, and implicit scope are easy to manage on a stash-by-stash basis. Keys are also easy to pass in as it will create composite keys from whatever you pass in (as long as it has to_s) so no more ugly string interpolation all over the place. It's fast (faster than memcache-client). It's simple (pure ruby and only a few hundred lines). It's tested (shoulda). Of course, because it's pure ruby it will run almost anywhere as well unlike many other clients.

Remote GUD: Remote GUD mode for Emacs is an Emacs Lisp rsh-gud.el that lets you debug a program running on a remote host, with sources on the local host. It works via rsh.

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

Remotehash: Provides a simple interface to OpenDHT servers.

Render Caching: Cache render calls in Rails controllers. This gem adds the render_with_cache method to all controllers. Call this inside of an action to cache the view.

Resque: A Ruby library for creating background jobs, placing those jobs on multiple queues, and processing them later.

Resque-mailer: A gem plugin which allows messages prepared by ActionMailer to be delivered asynchronously. Assumes that youÃ¢â¬â¢re using Resque for your background jobs.

Resque-status: Resque-status provides a set of simple classes that extend resqueÃ¢â¬â¢s default functionality (with 0% monkey patching) to give apps a way to track specific job instances and their status. It achieves this by giving job instances UUIDÃ¢â¬â¢s and allowing the job instances to report their status from within their iterations.

RetroForth: RetroForth is a compact, free software Forth development system. It can be used under FreeBSD, GNU/Linux, BeOS, or as an operating system. It is easy very easy to learn, use, and extend with standard libraries like SDL, and it can also be used to create tight, stand-alone applications.

RetroWeb: RetroWeb is an extension for RetroForth intended to help users create Web pages. It is still close to HTML, but offers a more compact syntax. Most importantly, it allows you to work with the full power of Forth to generate HTML code. It can be used to create both static HTML files and simple dynamic CGI responses.

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

Retrograph Easy: Retrograph/EASY is a simple API for creating games based on Retrograph. Currently, it is based atop Ruby/SDL, but support for other backends may be possible in the future.

Retweet: A base application template for building simple Twitter web apps with Sinatra and DataMapper. If you just want to build a simple keyword-based aggregator (such as tweetdreams.org), all you need to do is edit environment.rb to set the name of your app and the API search keyword(s), edit the CSS, and go.

Reverse Polish Lisp 2: RPL/2 is a special language, and could be the strange child of forbidden love between Lisp and Forth. The reversed polish notation and the definitional working come from Forth, only keeping an anonymous stack; the control structures come from Lisp. What a brilliant genealogy!

Free Software Foundation!

Semantic search

Query log

Features

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Interaction

Navigation

Creation

Print

Tools