[[Software-development::small-specific-development-task]]

Atomthreads: Atomthreads is a free, lightweight, portable, real-time scheduler for embedded systems. It is targeted at systems that need only a scheduler and the usual RTOS primitives. No file system, IP stack or device drivers are included, but developers can bolt on their own as required. Atomthreads will always be a small number of C files which are easy to port to any platforms that require threading by adding a simple architecture-specific file.

Authz-tools: 'authz-tools' is a set of tools to manipulate authz files (as used by mod_authz_svn). It currently contains two utilities:
authz-tool -- extracts and modifies information in a authz file from command line authz-admin -- a cgi when you have numerous repositories served with help of SVNParentPath directive (see mod_dav_svn module documentation)

Autoproject: Autoproject interviews the user, then creates a source package for a new program, following the GNU programming standards. The new package uses autoconf to configure itself, and automake to create the Makefile. Optionally, the new package will use argp (from glibc) or a command line parser generator (AutoOpts). The idea is that you execute autoproject just once when you start a new project. It will ask a few questions, then create a new directory and populate it with standard files, customized for the new project.

BEYE: A multiplatform portable viewer of binary files with built-in editor in binary, hexadecimal and disassembler modes. It uses native Intel syntax for disassemble. Highlight AVR/Java/Athlon64/Pentium 4/K7-Athlon disassembler, Russian codepages convertor, full preview of formats - MZ, NE, PE, NLM, coff32, elf partial - a.out, LE, LX, PharLap; code navigator and more over.

BIF: This is a candidate for deletion: lunix.com.ar domain gone, no new site found on google Mach-tb (talk) 17:17, 26 March 2017 (EDT) Build it Fast (BIF) is a PHP Framework. It contains several classes that help you develop complex Web applications in a short amount of time. It brings the concept of the 'widget' to Web development. It features Cascade Skins and transparent session management.

BYLD: 'Byld' helps you build a GNU/Linux distribution on a single floppy disk to use as you want (net client, rescue disk...). It is not a complete distribution: it was made only to build a mini distribution on a floppy. You can use it however you want as is (follow quick installation instruction below) but its best use is to configure and build your own floppy distribution.

bbe is a sed-like editor for binary files. bbe performs basic byte operations on blocks of input stream. bbe is command line tools developed in GNU/Linux environment.Features include:

Non-interactive command-line tool.
Reads input stream in arbitrary blocks, not as lines as sed.
Input blocks can be defined as offset and length, just length, or using start and stop strings.
Basic commands: insert, delete, change, replace and convert data.
Commands can be given in command line or read from script-file.
Blocks can be written either to standard output or file.

Binfind: 'binfind' searches files for a byte sequence. The pattern can be given on the command line in ASCII or hex, read from a file, or a combination of the above. It uses the Boyer-Moore algorithm and can search large files without using a lot of memory. For each occurrence of the pattern, 'binfind' prints a line containing the offset of the occurrence in the searched file. If the user specifies more than one file, binfind prints the filename and a colon before the offset.

Binutils: Binutils includes tools capable of creating and managing binary program files, including handling object files, libraries, profile data, and assembly source code. This is a GNU package.

Bison: Bison is a general-purpose parser generator that converts an annotated context-free grammar into an LALR(1) or GLR parser for that grammar. Once you are proficient with Bison, you can use it to develop a wide range of language parsers, from those used in simple desk calculators to complex programming languages. Bison is upward compatible with Yacc: all properly-written Yacc grammars ought to work with Bison with no change. Anyone familiar with Yacc should be able to use Bison with little trouble. You need to be fluent in C or C++ programming in order to use Bison.

Bochs-Tools: Bochs-Tools is a collection of scripts and programs to be used together with the Bochs emulator. The main goal is to provide a more Unix-like interface to the emulator and to enable access to Bochs disk images from outside of Bochs. This project makes it very simple to copy an existing OS installation to a Bochs image.

Buildutils: Buildutils provides several new commands for your package setup.py file to help make development easier. It integrates with distutils using --command-packages, or automatically will add commands to all your setuptools projects.

Busybox: BusyBox combines tiny versions of many common UNIX utilites into a single small executable. It provides minimalist replacements for most of the utlities you usually find in GNU coreutils. The utilites in BusyBox generally have fewer options than their full-featured GNU cousins. This package is widely used for rescue and embedded systems. It also provides more compact alternatives to other common utilities such as bzip2, dhcp, diffutils, e2fsprogs, file, findutils, gawk, grep, inetutils, less, modutils, net-tools, procps, sed, shadow, sysklogd, sysvinit, tar, util-linux, and vim.

CPG: CPG is an integrated development environment application for creating parsers for conventional compiler implementation, special application compilers, and data structure parsers for message and record set processing. It has both complete GUI and command line interfaces for performing automaton calculations and parser code generation including regular expression, SLR(1), LALR(1), LR(1), conflict resolution, essential error entry calculation and configuration, unit rule elimination optimization, grammar rule code and parser driver code editing, C++ parser driver and table interfaces, and graphical parser simulation displays.

CalcChecksum: 'CalcChecksum' is a simple utility for calculating various checksums easily with a graphical user interface. It can calculate checksums for MD5, MD4, CRC32, SHA1 (SHA160), SHA256, RIPE-MD-160, TIGER, HAVAL (128, 160, 192, 224, 256 with 3, 4 or 5 passes) of files or text-strings, and runs on all 32 and 64 bit platforms that KDE 3.1 and QT 3.1 run on.

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

Cereal: 'cereal' is an emulation framework able to emulate 8051-compatible CPUs and connected devices, designed to allow easy addition of other (application-specific) devices to emulate.

Cflow: Cflow' analyzes a collection of C source files and prints a graph charting control flow within the program. It can produce both direct and inverted flowgraphs for C sources, or optionally generate a cross-reference listing. It implements either POSIX or GNU (extended) output formats. Input files can optionally be preprocessed before analyzing. The package also provides an Emacs major mode, so users can examine the produced flowcharts in Emacs.

Cflow2vcg: Cflow2vcg convert the result of the cflow utility in a VCG format. So, it offers the ability to display graphically the call-graph of sources, and import it in documentation.

Chestnut Package Manager

Chestnut Package Manager is a utility to handle executables and resource files in a transparent, platform independent and relocatable way. Its concept is similar to Apple bundles and Java archives. It is implemented in Python. The application consists of a Python library and three executables:

a runner, cnrun, which runs executables identified by the package name, the version and the entry point
a path resolver, cnpath, which returns the absolute path of a resource given the same identification as above
a lister, cnls, which provides a list of the packages available, and detailed information about their contents

Chrpath: 'chrpath' allows you to modify the dynamic library load path (rpath and runpath) of compiled programs and libraries.

Class XPath: Class::XPath is a Perl module which adds XPath-style matching to your object trees. This means that you can find nodes using an XPath-esque query with match() from anywhere in the tree. Also, the xpath() method returns a unique path to a given node which can be used as an identifier.

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.

Code Striker: Codestriker lets users perform code reviews in a collaborative fashion, as opposed to using unstructured emails. Authors create code review topics; nominated reviewers are automatically notified by email. Reviewers then submit comments against the code on a per-line basis, and can view comments submitted by the other reviewers as they are created. The appropriate parties receive email as an alert mechanism when comments are created. The author can submit comments against the review comments. The author winds up with a scrutctured group of review comments, instead of a pile of unstructured emails. The program supports integration with a CVS repository, coloured diffs and ability to view original and new files in their entirety (and side-by-side). Codestriker can be optionally linked with a bug tracking system and a CVS web viewing system.

ColorDiff: ColorDiff is a wrapper for diff that produces the same output as diff, but with coloured syntax highlighting at the command line to improve readability. The output is similar to a diff-generated patch in Vim or Emacs with the appropriate syntax highlighting options enabled. The colour schemes can be read from a central configuration file or from a local user ~/.colordiffrc file. 'colordiff' makes use of ANSI colours and therefore will only work when ANSI colours can be used.

Colorifer: Colorifer is a set of utilities that colors output of other processes, e.g. command line utilites or compilers. They make output more readable by using different colors for the significant pieces of the text. These programs can work like colorgcc perl script, and also for other programs. You only need to create a new config - set of the patterns (regular expressions) and the colors you want. 'CSed' is a color stream editor. It works like sed, but doesn't edit the stream and makes color substitutions instead. It is a simple filter that can be used to colorize the output of any program. CSed commands looks like sed commands. 'Colorifer' is a wrapper that runs a program and colorizes its output.

CompactPath: The package provides means to handle compacting of filepaths. Compacting of filepaths may be useful in gui programming for example where filepaths of arbitrary length have to be displayed in widgets with limited visual space. The package is designed so you can use it as from everywhere. No need to install it to site-packages, in case you want to include it in a project. It comes equipped with a wrapper for labels to handle filepaths of arbitrary length in qt4.

Complete: This is a candidate for deletion: 1. No files sources found. Complete helps you start a new project the right way. Its template creates a clean structure with hooks for common testing (via setuptools/distribute's test_suite) and documentation (via Sphinx) needs. Once complete is installed, simply call paster: $ paster create -t ``complete`` MyProject The template only asks you about the project version, leaving you to fill in the rest of the package metadata at your leisure. When you're ready, see lib/MyProject/__init__.py.

Complexity: Complexity may be used to analyze the degree of complexity of functions in a C program. It estimates the difficulty that a human might have in understanding or testing the code. This software attempts to integrate more information than other, similar programs, in order to derive a more accurate estimate of complexity.

Context menu: This library lets you edit the entries on the right click menu for Windows and GNU/Linux using pure Python. It also allows you to make cascading context menus! context_menu was created as due to the lack of an intuitive and easy to use cross-platform context menu library. The library allows you to create your own context menu entries and control their behavior seamlessly in native Python. The library has the following features: - Written in pure python with no other dependencies - Extremely intuitive design inspired by Keras Tensorflow - Swift installation from Python's Package Manager (pip) - Painless context menu creation - Cascading context menu support - The ability to natively integrate python functions from a context entry call - Detailed documentation

Coreutils: Coreutils includes all of the basic command-line tools that are expected in a POSIX system. These provide the basic file, shell and text manipulation functions of the GNU system. Most of these tools offer extended functionality beyond that which is outlined in the POSIX standard.

Cppi: GNU cppi is a cpp directive indenter. It indents C preprocessor directives to reflect their nesting, among other regularizations.

Crow Designer: Crow is a modern GUI builder for the GTK+ toolkit. It is an advanced IDE-embeddable RAD tool designed to fulfill the needs of desktop programmers who want to create multi-platform GTK+ based applications with minimal GUI coding. Crow is full-featured yet elegant: its tree-based Property Explorer solves many GUI constructing tasks in a versatile manner without additional popup dialogs. The project is aimed at developing a tool that is coherent and highly productive for experienced GTK+ users as well as simple and accessible for newcomers.

Crun: How to Use Usage: crun < No of Times > < Time Interval > < Program Namge > [Program Parameters] crun would come handy when you need to execute certain command over and over again with several time intervals in between those executions. For example, let's say you want to run netstat -na command 20 times with a time interval of 1 second. Then you can use crun with following arguments: crun 20 1 netstat -na crun won't return until final process is executed and returned.

Ctags: Exuberant Ctags is a multilanguage reimplementation of the *nix ctags program. It generates an index of source code object definitions which editors and tools use to instantly locate the definitions. Exuberant Ctags currently supports 41 different computer languages.

Ctools: ctools is a set of useful tools for C programs including a resource database, a tiny interpreter, a set of utilities that extend clib, powersets of integers and chars, long-period random numbers, and Wirth's P4 compiler. It also contains Tinker, a Tcl-like interpreter that is small, easy to embed into a program, but not particularly fast (two out of three ain't bad!) If you want an extension or scripting language for your program, and don't want the whole Tcl package, Tinker will be a welcome tool.

Cw: 'cw' is a non-intrusive real-time ANSI color wrapper for common commands. It simulates the environment of the commands being executed, so that if a person types 'du', 'df', 'ping', etc. in their shell, it will automatically color the output in real-time according to a definition file containing the color format desired. It supports wildcard match coloring, tokenized coloring, headers/footers, case scenario coloring, command-line- dependent definition coloring, and includes over 50 pre- made definition files.

Cxmon: 'cxmon' is an interactive command-driven file manipulation. It has commands and features similar to a machine code monitor/debugger, but cannot run or trace code. There are, however, built-in PowerPC, 680x0, 80x86, 6502 and Z80 disassemblers. 'cxmon' is primarily intended for emulation development but it can be used as a generic tool for manipulating and analyzing binary data and machine code, or just as a hex calculator.

DMBCS Embedded C++ HTTP Server: At DMBCS we like to do things in certain ways: all our code takes the form of C++17 (or, lately, C++20) libraries built with GNU autotools, providing user interaction through HTTP/HTML5/CSS3/EcmaScript web interfaces. It is thus a common requirement that our code links against a library of classes which implement the HTML paradigm and provide the TCP/IP plumbing to allow applications to easily take the form of self-contained web servers. At DMBCS we use NGINX at top-level to coordinate the set of such micro-servers which make up a complete web site. The library has been under constant development for over twenty years (yes, really), and in heavy production use. The code-base hasnʼt quite been brought up to our expectations of full production-quality code yet (it has always been a project on the side of other things), and so we still regard it as beta-quality software. We expect this situation to change in the near future.

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

DebLib: deblib is a simple module for Python that allows you to look at the debian packages database. For example, it allows you to ask if a specific version of a package exist on the tested system. deblib has been created to facilitate the development of the dsacheck project.

Deroff: deroff strips off roff constructs and macros. The preprocessor (eqn, tbl, pic, grap, and vgrind) sections are removed entirely. The resulting outptu is suitable fo rspelling with (eg) spell

Distcc: 'distcc' distributes compilation of C or C++ code across several machines on a network. It should always generate the same results as a local compile, is simple to install and use, and is often significantly faster than a local compile. 'distcc' does not require all machines to share a filesystem, have synchronized clocks, or to have the same libraries or header files installed. Machines can be running different operating systems, as long as they have compatible binary formats or cross-compilers. 'distcc' sends the complete preprocessed source code across the network for each job, so all it requires of the volunteer machines is that they be running the distccd daemon, and that they have an appropriate compiler installed.

Dmidecode: 'Dmidecode' reports information about your system's hardware as described in your system BIOS according to the SMBIOS/DMI standard. This information typically includes system manufacturer, model name, serial number, BIOS version, asset tag as well as other details of varying level of interest and reliability. This other information often includes usage status for the CPU sockets, expansion slots (e.g. AGP, PCI, ISA) and memory module slots, and the list of I/O ports (e.g. serial, parallel, USB).

DoIt

DoIt comes from the idea of bringing the power of build-tools to execute any kind of task. It will keep track of dependencies between "tasks" and execute them only when necessary. It was designed to be easy to use and "get out of your way". DoIt can be used as:

a build tool (generic and flexible)
home of your management scripts (it helps you organize and combine shell scripts and python scripts)
a functional tests runner (combine together different tools)

Drbd: 'drbd' is a block device for building high-availability clusters. DRBD takes over the data, writes it to the local disk and sends it to the other host. On the other host, it takes it to the disk there. The other components needed are a cluster membership service, which is supposed to be heartbeat, and an application that works on top of a block device (ie, a filesystem and fsck). Each device has either a 'primary' or 'secondary' state. The application should run and access the device on the node with the primary device. Every write is sent to the local 'lower level block device' and to the node with the device in 'secondary' state. The secondary device then writes the data to its lower level block device. If the primary node fails, heartbeat is switching the secondary device into primary state and starts the application there. If the failed node comes up again, it is a new secondary node and will synchronise its content to the primary node whithout interruption of service in the background. Only those parts of the device that actually have been changed will resync.

ELF statifier: Executable files may be linked statically or dynamically. Dynamically linked executables use less disk space and memory, but require appropriative dynamic libraries present in order to run. ELF statifier make one executable file with no run-time dependencies from a dynamically linked executable and all its libraries. This file can be copied and run on another machine with no need for all of the libraries.

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

ETS- Enthought Tool Suite Project Tools: ETSProjectTools provides commands to make it easier for developers to work on projects that have a large number of dependencies, such as the ETS project itself. These commands are all predicated on a concept we call a "checkout", which is the coherent set of projects and versions that are required to satisfy all documented dependencies for the user-requested project(s).

Eboxy: eboxy is an application for building simple user interfaces for entertainment PCs, suitable for use with a remote on a TV screen. It uses SDL for graphics and XML-based interface description files, supports TrueType fonts and PNG alpha transparency, and has a plugin extension system.

Editline: Editline is an autotool- and libtoolized port of the NetBSD Editline library (libedit). This command line editor library provides generic line editing, history, and tokenization functions, similar to those found in GNU Readline.

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

FASM: The Flat Assembler is efficient; supports 16/32/64-bit (both AMD64 and EM64T) instructions; MMX, SSE, SSE2, SSE3, and 3DNow! extensions; and generates binary/MZ/PE/COFF/ELF output formats.

FOSSology: http://sourceforge.net/projects/fossology/ Scan files for licenses and copyrights, perhaps more analysis in the future.

FileTools: This is a candidate for deletion: Links broken. No links to page. Email to maintainer broken. Poppy-one (talk) 11:31, 31 July 2018 (EDT) 'FileTools' can be used to split and join files with automatic checksum, to compare two files byte-by-byte and to calculate Adler-32 and Fletcher-32 checksum of a file. It doesn't require installation (on some environments you should run it from /home/(your user name)/ path or the equivalent for your system).

Filepp: filepp is a generic file preprocessor that lets C preprocessor functionality be used with any file type. It supports the full set of C preprocessor keywords (#include, #define, #if, etc.). filepp is also highly customizable and allows users to easily add their own keywords or modify the behaviour of existing keywords, and is more user friendly than cpp. Common uses include as an HTML preprocessor, to maintain consistency between software and documentation, and as a simple 'sed' replacement.

Fileutils: Included tools duplicate files, list files, display disk usage, change file permissions, change group and owner ownership, rename, delete and creates file nodes including technology to delete files securely (indefinitely). This program has been folded into GNU core utilities.

Fltk: The Fast Light Tool Kit ("FLTK", pronounced "fulltick") is a C++ graphical user interface toolkit. FLTK also includes FLUID, the Fast Light User Interface Designer, which allows you to graphically design applications, widgets, or classes for your GUI. The program was designed to be small and modular enough to be statically linked. It also works well as a shared library. 'fltk' does not use macros, templates, multiple inheritance, or exceptions. It is written directly atop Xlib for maximum speed.

Freedce: 'freedce' is a free implementation of DCE RPC, with development aimed at implementing DCOM for GNU/Linux (and other *NIX systems).

FunctionCheck: FunctionCheck is a profile generator for C/C++ programs. It uses the gcc '-finstrument-functions' feature to track each function entry and exit. It computes local and total times in functions, the number of calls, the average time per call, and function calls. It can also count time spent in sub-functions not compiled with '-finstrument-functions'. The time balance between functions is always respected. It also can trace memory allocations and report on memory leaks, showing the call stack leading up to the allocation of the leaked blocks.

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

GAA Argument Analyzer: The GAA Argument Analyser helps programmers to analyze the arguments given to their program from the command line or from a configuration file. You will only have to write a text file in GAA language, and GAA will provide you .c and .h files to manage arguments.

GENDIST: GENDIST (the Distribution Generator) lets you easily create your own distribution. It is particularly intended for special-purpose mini-distributions, which typically consist of a kernel and a root-filesystem, both packed together on one or a few floppies or CD-ROMs. It creates a makefile-based build system for your distribution, and helps you to automate the following three tasks: maintaining your root filesystem, maintaining your "CD filesystem" (in case you create a bootable CD), and packaging everything on media.

GIT-Goggles: A series of GIT utilities to streamline working with remote branches and reviewing code. You can think of git-goggles as 'git branch -a' on steroids. Just install and run 'git goggles' git-goggles is a git management utilities that allows you to manage your source code as it evolves through its development lifecycle.

GK Log: This is a candidate for deletion: can't find software anywhere, not on archive.org, my email to maintainer was returned to sender. Danm (talk) 12:30, 18 November 2017 (EST)

GatO: 'gatO' (GTK At Operation) is an interface to the UNIX command 'at.'

Gazpacho: Gazpacho is a GUI builder for the GTK+ toolkit designed to be ultra easy to use. It is strongly inspired by the Glade project but it is written from scratch in Python. As a result there are few lines of code to read, understand and maintain. One of the project's goals is that the .glade files that Gazpacho generates be fully compatible with libglade so you can use Gazpacho regardless of the language in which your application is written.

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

GeSHi: GeSHi is a generic syntax highlighter for PHP that takes any source code and highlights it in XHTML and CSS. It features case-sensitive or insensitive highlighting, auto-caps/non-caps of any keyword, an unlimited scope for styling, the use of CSS in which almost any aspect of the source can be highlighted, the use of CSS classes to massively reduce the amount of output code, function-to-URL capabilities, line numbering, and much more. Over 50 languages are supported, including Java, C, PHP, HTML, CSS, SQL, Pascal, C++, XML, ASP, and ASM.

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

Generic Coloriser: Inspired by logcolorizer, colorlog, acl, colorgcc, colortail, and others, Generic Colouriser can be used to colourise any files or outputs of commands. It's written in python and configurable via regular expressions.

Gengen: Gengen (GENerator GENerator) is a tool that, starting from a parameterized text, called template, generates a text generator that can substitute parameters with values. At the moment Gengen can generate C++ or C code, other target languages are under development (e.g., Java).

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.

Genroms: 'genroms' is a utility meant to aid in generating ROM files for arcade machines or emulators. You pass it in a standard Intel Hex File (.IHX) along with a description of the ROM layout in memory (.ROMS), and it will generate the ROM files as specified in the ROM layout file. It is meant for programers who are developing for arcade machines, or for circumstances where the ROM layout may be strange or non-contiguous.

GetAbsPath: 'getAbsPath' is a C header (getAbsPath.h) or an ANSI C tool (getAbsPath) which converts relative path to absolute ones. It uses the current working directory (CWD) as its basis. It can be used (for example) to find out the current path of a shell script.

GetOpts

This is yet another C++ version of the getopt function, that is, for parsing command line options and environment variables. However, unlike other versions, the design goals of this one are:

EASY to use
EASY to learn
mimc STL's streams
minimum code to type
smooth integration with STL types
Platform independant (ANSI C++)
EASY to extend for your own types

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.

Ginsu: Chop up/Stitch together large files.

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

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

Glibbind: This is a candidate for deletion: Links broken. Email to maintainer broken. Poppy-one (talk) 15:24, 2 August 2018 (EDT) Glib Binding Properties binds properties in GLib and GTK+ objects. This lets you synchronize the properties of several objects; when one property changes the others automatically change accordingly, so you don't need to write callbacks watching for property change notifications. It supports one-way and mutual bindings and bindings with transformation by transformation functions.

Global

GLOBAL is a source code tagging system that functions in the same way across a wide array of environments, such as different text editors, shells and web browsers. The resulting tags are useful for quickly moving around in a large, deeply nested project. GNU GLOBAL has the following features:

supports C, C++, Yacc, Java, PHP4 and assembly.
works the same way across diverse environments including vi, emacs, less, bash…
finds locations of specified symbol quickly.
locates not only definitions but also references.
allows duplicate tags.
locates paths which matches to the specified pattern.
hierarchical searches by default.
searches not only in a source project but also in library projects.
generates completion list for completing input method.
supports various output formats.
allows customizing of a set of candidate files to be tagged.
understands POSIX 1003.2 regular expression.
supports idutils as an external search engine.
tag files are independent of machine architecture.
supports incremental updating of tag files.
plug-in parser is available to treat new language.
supports customizing using ‘gtags.conf’.
generates a hypertext of source code.
compact format to save disk space.
supports client/server environment (TRAMP ready).
ignores binary files, dot files and specified files.
includes cscope-compatible program (gtags-cscope).
includes grep-like command (-g command).
supports grep-like symbol highlighting.

Gnomedb: GNOME-DB is a complete framework for developing database-oriented applications. It allows access to PostgreSQL, MySQL, Oracle and ODBC data sources. It also includes several applications and utilities which make it suitable for many database-related tasks.

Gnostic: gnostic is a program which executes shell scripts according to certain criteria. It is aimed at applications where there is a need to codify some types of "recipes" for doing things. It is a rule-based task execution system.

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

Gnumach: GNU Mach is the microkernel of the GNU system. A microkernel provides only a limited functionality, just enough abstraction on top of the hardware to run the rest of the operating system in user space. The GNU Hurd servers and the GNU C library implement the POSIX compatible base of the GNU system on top of the microkernel architecture provided by Mach. Currently, GNU Mach runs on IA32 machines. GNU Mach should, and probably will, be ported to other hardware architectures in the future. Mach was ported to many operating systems in the past.

Google Mock: Google Mock is an object mocking framework for C++ unit testing. One of its important features is its collection of matcher predicates which ease unit testing. It can be used with most unit testing frameworks.

Google Test: Google Test is a unit testing framework for C++.

Gorm: Gorm (Graphic Object Relationship Modeller) is a GNUstep application for building user interfaces and application objects relationships. Its major features include drag-and-drop creation of GUI elements from palettes, run-time loading of additional palettes, direct on-screen manipulation of GUI elements, manipulation and examination of objects via inspectors, and creation of connections between objects using mouse. It is a clone of the former Interface Builder application.

Grammatica: Grammatica is a parser generator (or compiler compiler) for C# and Java. It reads a grammar file and creates source code for a parser. The grammar file format describes the language in EBNF, with tokens described as regular expressions. Currently only LL(k) grammars are supported, but future versions will probably contain support for other grammar types.

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.

GtkExtra: 'GtkExtra' is a set of widgets for creating GUIs for the X windows system using GTK+. Widgets included are GtkSheet, GtkPlot, GtkPlotCanvas, GtkItemEntry, GtkComboBox, GtkColorCombo, GtkBorderCombo, GtkFontCombo, GtkDirTree, GtkIconList, GtkFileList, GtkIconFileSelection, GtkCheckItem

Gwydion-dylan: Dylan is an advanced, object-oriented, dynamic language which supports the rapid development of programs. It is based on Scheme, but with a block-style syntax similar to Pascal. It includes a Dylan-to-C compiler.

HTTPdrun: The httpdrun project is intended to automate development and testing of projects with apache. It supports full apache configuration abstraction using only python, autogenerate httpd.conf and autodetect apache installation and available modules.

Hachoir project- hachoir parser

hachoir-parser is a package of the most common file format parsers written for the Hachoir framework. Not all parsers are complete, some are very good and other less so: for example some only parser the first level of the tree. A perfect parser has no "raw" field: with a perfect parser you are able to know *each* bit meaning. Some good (but not perfect ;-)) parsers are:

Matroska video
Microsoft RIFF (AVI video, WAV audio, CDA file)
PNG picture
TAR and ZIP archive
GnomeKeyring parser requires Python Crypto module.

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

Hachoir project- hachoir urwid: hachoir-urwid is a binary file explorer based on Hachoir library for parsing files. Using this tool you can exactly know the meaning of each bit/byte of your files. With direction keys, you can navigate in the field tree. The key 'h' will disable 'human display' and switch to 'raw display'. It's sometime useful when you would like to compare hexadecimal data and Hachoir representation.

Hakmatak: Hakmatak implements the w10n specification. It is used to create WSGI applications that RESTfully expose complex data stores.

Halloc: Hierarchical alloc (halloc) is an extension to a standard malloc/free interface that simplifies memory disposal tasks when allocated structures exhibit hierarchical properties. It can be used for various tasks including memory pooling, limited garbage collection, and simplified dynamic structure management.

Hello: The GNU Hello package serves as an example of GNU package distribution and code. It also prints a nice greeting in a variety of languages. The "Hello, world!" program is the classic beginner's programming task. The GNU version takes this a step further by processing its argument list to modify its behavior, by supporting internationalization, and by including a mail reader; it's a true demonstration of how to write programs that do these things.

Hhmalloc: This is a candidate for deletion: 1. Is the same as: http://directory.fsf.org/wiki/Halloc 2. Proof of redirect: http://web.archive.org/web/20060912210521/http://www.cipherica.com/hhmalloc/ 3. New HP: http://swapped.cc/#!/halloc Hierarchical heap is an extension of the standard C malloc/free interface, which organizes memory blocks into naturally occurring hierarchies. HH can be used for a number of tasks including memory pooling, limited garbage collection, and simplified dynamic structure management.

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.

Hilite: 'hilite' is a utility which executes whatever command you specify, highlighting anything it prints to stderr. It's most useful when compiling, since warnings are printed in bright red and are therefore very hard to miss.

Hitch: Hitch allows developers to be properly credited when Pair Programming and using Git.

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

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

Honeycomb: Honeycomb is an object-oriented hover intent library. A lot of hover intent libraries give you a single in-point for invoking hover functionality, assuming you will always want action to take place on hover in and hover out. This can allow for fairly light weight libraries but can be very difficult to work with if you need any customization. If you have use cases for hover intent that aren't always straight forward, Honeycomb may be a good fit for you.

Hugs

Hugs 98 is a functional programming system based on Haskell 98, the de facto standard for non-strict functional programming languages. Hugs 98 provides an almost complete implementation of Haskell 98, including:

Lazy evaluation, higher order functions, and pattern matching.
A wide range of built-in types, from characters to bignums, and lists to functions, with comprehensive facilities for defining new datatypes and type synonyms.
An advanced polymorphic type system with type and constructor class overloading.
All of the features of the Haskell 98 expression and pattern syntax including lambda, case, conditional and let expressions, list comprehensions, do-notation, operator sections, and wildcard, irrefutable and `as' patterns.
An implementation of the Haskell 98 primitives for monadic I/O, with support for simple interactive programs, access to text files, handle-based I/O, and exception handling.
An almost complete implementation of the Haskell module system. Hugs 98 also supports a number of advanced and experimental extensions including multi-parameter classes, extensible records, rank-2 polymorphism, existentials, scoped type variables, and restricted type synonyms.

Icarus Verilog: Icarus Verilog is a Verilog simulation and synthesis tool. It operates as a compiler, compiling source code writen in Verilog (IEEE-1364) into some target format. For batch simulation, the compiler can generate an intermediate form called vvp assembly. This intermediate form is executed by the ``vvp command. For synthesis, the compiler generates netlists in the desired format. The compiler proper is intended to parse and elaborate design descriptions written to the IEEE standard IEEE Std 1364-2001. The standard proper was released towards the middle of the year 2001, though in a rather pricey electronic form. This is a fairly large and complex standard, so it will take some time for it to get there, but that's the goal. NOTE: Under the Version information please browse the Installation link to find the proper download link.

Idutils

Idutils includes tools to create an index of textual tokens used in a list of file names and then to query that index. Thus, it allows the user to, for example, find all the uses of a particular function in a large programming project. In addition to handling textual tokens, it can also handle numeric constants and the contents of character strings. Database queries can be issued from the command-line, or from within Emacs, serving as an augmented tags facility. Programs included are:

mkid: (id-utils)mkid invocation. Creating an ID database.
lid: (id-utils)lid invocation. Matching words and patterns.
fid: (id-utils)fid invocation. Listing a file's tokens.
fnid: (id-utils)fnid invocation. Looking up file names.
xtokid: (id-utils)xtokid invocation. Testing mkid scanners.

Inferno: Inferno is a compact operating system for building cross-platform distributed systems with advanced networking facilities and a safe concurrent programming environment. It runs as a full OS or an application with an architecture-independent virtual machine (Dis). A full development toolkit is included. It is mainly programmed in the Limbo language.

IniParser: iniparser is a free stand-alone ini file parsing library. It is written in portable ANSI C and should compile anywhere.

IzPack: IzPack is a powerful Java installer builder. It is able to create lightweight and modular installers. You can choose which installer and installer panels to use (some can do the same job, so that you can select the one you prefer). IzPack does not use native code; it is designed to be fully independent from the operating system that runs it. The end user with a properly installed JVM can easily use an installer made with IzPack, since a single "java -jar installer.jar" will launch it.

Jacksum: Jacksum is a free checksum utility written entirely in Java. It can be used for computing and verifying checksums, CRCs and hashes as well as timestamps of files. It supports most common checksum algorithms (Adler32, BSD sum, POSIX cksum, CRC-16, CRC-32 (FCS-32), CRC-64, ELF-32, eMule/eDonkey, FCS-16, HAVAL (3/4/5 passes, 128/160/192/224/256 bits), MD2, MD4, MD5, MPEG-2's CRC-32, RIPEMD-128, RIPEMD-160, SHA-1, SHA-256, SHA-384, SHA-512, TIGER, Unix System V sum, sum8, sum16, sum24, sum32, Whirlpool and xor8).

Job Scheduler: The Job Scheduler runs executable files, shell scripts, and database procedures automatically (MySQL, PostgreSQL, Firebird, SQL Server, Oracle, and DB2). It processes sequential and parallel tasks and job chains, provides an API for job implementation with Javascript and Perl, and exposes jobs as Web services.

Jpnevulator: What once started as a Jackpot Navigator emulator (hence the strange name) is now a nice serial sniffer and you can use it to send data on a serial line too. It's sort of like a very simple terminal emulator, like picocom. But jpnevulator uses hexadecimal byte values to display and send along the line. Very handy indeed if you are working a lot with serial protocols.

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.

KCachegrind: Profiling, i.e. determinating the most time consuming execution parts, is an important last step when developing applications. KCachegrind visualizes this data, generated by a profiling tool, in various ways.

Kanban

Personal Kanban automatically manages 3 permanent lists of things to do, using the Kanban method for organizing your work. This method is meant for software development and secondarily for other important formal tasks. In the kanban method, each list is called "bucket" and has a maximum number of elements. In this kanban, the lists are:

Tasks performed -- called the "Completed" list;
Tasks to be performed -- called the "Todo" list;
Potential tasks -- called the "Options" list.

Personal Kanban can be punitive enough to prevent a project from being neglected. More information on Azure DevOps.

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

Kcd: kcd is a directory change utility similar to NCD. It helps you navigate the directory tree. You can also supply part of the desired directory name in the command line and let kcd find it for you. It rescans directories quickly because it saves timestamps so it won't rescan unchanged directories. You can tell the program to skip certain directories, or chose if you want just part of the tree. kcd supports the bash, ash, pdksh, zsh, and tcsh shells.

LazyBat: Data parser for non-recursive processing. It's not meant to write programming languages, but it's designed to be easier, faster and better for the rest of it. I call it 'application parser' because it makes life easier for all the common parsing jobs application developers do, such as parsing date/time, command shell interface parsing, XML data, CSV, nested lists, complex choice selections, Web URLs, odd parsing jobs in data communication etc.

Ldcheck: ldcheck (Library Dependancy Checker) was a tool to check for bad or missing dependencies in GNU/Linux. Its purpose was to check for broken library dependencies and recommend which distribution package to re-compile or re-install to resolve the problem(s). It is not maintained anymore.

Libconfini: libconfini is a simple INI parsing library with the ability to read disabled entries (i.e., valid entries nested in comments). libconfini does not store the data read from an INI file, but rather dispatches it, formatted, to a custom listener. The code is written in C (C99) and does not depend on any particular library, except for the C standard libraries stdio.h, stdlib.h and stdint.h.

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

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

Libngrs 2: Links broken. Email to maintainer broken. Homepage changed to archive.org Poppy-one (talk) 15:14, 6 August 2018 (EDT) NGRS stands for Nattisoft Graphic RAD System. Its goal is to provide a toolkit which offers an easy way to write WHYSWG editors. All the components are movable. Its second aim is to provide a libary for small statical compilations against X.

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

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

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

MCPP: MCPP is a high quality C/C++ preprocessor. It implements almost all of C90, C99 and C++98 specifications. It's source code is portable and has been ported to several compiler-systems on UNIX-like systems and DOS/Windouws, including GNU C and Visual C++. This package contains also Validation Suite to test C/C++ preprocessor comprehensively. When this validation suite is applied to various preprocessors, MCPP achieved a prominent result.

MICO: MICO is a free CORBA implementation whose features currently include:
-IDL to C++ mapping -Dynamic Invocation Interface (DII) -Dynamic Skeleton Interface (DSI) -graphical Interface Repository browser that allows you to invoke arbitrary methods on arbitrary interfaces -Interface Repository (IR) -IIOP as native protocol (ORB prepared for multiprotocol support) -Portable Object Adapter (POA) -Objects by Value (OBV) -CORBA Components (CCM) -Support for using MICO from within X11 applications and Tcl/Tk -Portable Interceptors (PI) -Support for secure communication and authentication using SSL -Support for nested method invocations -Support for thread-pool and thread-per-connection concurrency models -CORBA Services including Interoperable Naming service, Trading service, Event service, Relationship service, Property service, Time service, and Security service

Mangle: Mangle is a source de-formatter/de-commentor. It will remove all comments and/or formatting from from both ANSI and non-ANSI C/C++ source code leaving only what is required.

Mariabasic: BASIC (short for Beginner's All-purpose Symbolic Instruction Code) is one of the most accessible programming languages to date. mariaBasic Interpreter is a simplistic and command-line-based programming piece of software designed to make it easier for you to help you write code and perform complex calculations, as well as execute string or file procedures on PDAs, short for Personal Digital Assistants.

Maude: Maude is a high-performance multiparadigm language based on rewriting logic, and contains a functional sublanguage based on equational logic. It can be used for both programming and executable system specification in a variety of areas such as distributed and mobile systems and communication protocols, and functional applications. Thanks to its reflective features it can be used as a metalanguage and is easily extensible with powerful module composition operations as those supported in its Full Maude extension. It can also be used as a semantic framework to specify and prototype different languages, concurrency calculi, and SOS specifications; and as a logical framework to represent and mechanize different logics and proving tools.

Mensa

Mensa is a generic, flexible, enhanced, and efficient free software Java implementation of a pattern matching state machine as described by the 1975 paper by Alfred V. Aho and Margaret J. Corasick: _Efficient string matching: An aid to bibliographic search_. This implementation is

generic in that it can be used to match any type of symbols as defined by the Java template type S — e.g., it is possible to create a machine to match bytes, characters, integers, gene sequences, bit sequences, etc.;
flexible in that the architecture allows for granular extension, customization, or replacement of framework components;
enhanced in that it supports a number of useful extension not addressed in the original paper, such as whole-word matching, case-sensitivity controls, fuzzy whitespace matching, fuzzy punctuation matching, incremental matching (i.e., iterators), matching event listeners, etc.; and
efficient in that it performs well in terms of both time and resource usages on very large (~million term) keyword sets.

Misctools: The 'misctools' package includes the following:
basecvt- A simple program for converting numeric values from one base to another. bat- A binary dump program; similar to the UNIX od command, but produces output in a much more useful format. cpmod- A program to copy file permissions. dirstack- A curses-based directory browser/selector. dirtree- A program that generates a hierarchical list of filenames for a given directory tree. djinn- A wrapper program that allows a Java program to run as a true UNIX daemon. ftrunc- A program that truncates files to specified lengths. man2pdf- A script that converts manpages into PDF files. man2ps- A script that converts manpages into PostScript files. pascii- A program that reads characters from the keyboard and displays their ASCII codes in various formats. pfortune- A program that prints out random fortunes. pkgenv- A simple shell environment manager for software packages. psprint- A script that formats and prints various types of files to a PostScript printer. ps2pdf- A script that converts PostScript files into PDF files. ranline- A program that reads a line at random from standard input or a file. stat- A program that prints out information about a file. texi2pdf- A script that converts Texinfo files into PDF files. texi2ps- A script that converts Texinfo files into PostScript files. textlock- A password-protection program like xlock for use on text terminals. watcherd- A program that watches the size of a file and invokes another program when the file size increases. wrap- A program that reformats text, wrapping words as necessary, to fit within a specified number of columns. This package was formerly known as 'pingtools.'

Mod cplusplus: 'mod_cplusplus' does for C++ something similar to what mod_perl does for Perl. It cleans up the interface to Apache by wrapping common structures and functionality with objects and methods, and lets you implement any type of handler simply by subclassing, instead of hooking functions.

Mold: mold is a faster drop-in replacement for existing Unix linkers. It is several times faster than the LLVM lld linker, the second-fastest open-source linker which I originally created a few years ago. mold is designed to increase developer productivity by reducing build time, especially in rapid debug-edit-rebuild cycles.

MonitorGrowth: A simple perl script that lets you monitor a file's growth in k/s, kib/s and mib/s.

Motor: Motor is a text mode based programming environment for GNU/Linux. It consists of a powerful editor with syntax highlight feature, project manager, makefile generator, gcc and gdb front-end, etc. Deep CVS integration is also provided. You can organize your project files (sources, headers, libraries), edit, compile and debug your programs without need to leave the IDE and run any other programs, automatically check in/out updated project files from/to your CVS repositories and import projects into them. Also it can generate distribution packages (tar,gz and RPM) of projects.

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

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

OSCAR: OSCAR (Open Source Cluster Application Resource) is a snapshot of the best known methods for building, programming, and using clusters. It consists of a fully integrated and easy-to-install software bundle designed for high performance cluster computing.

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

OmniEvents: 'omniEvents' is a cross-platform server that enables CORBA applications to communicate through asynchronous broadcast channels (rather than direct method calls). It is a small, efficient implementation of the Object Management Group's Event Service specification designed to work with omniORB.

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

Opag: Opag (Option Parser Generator) generates C or C++ code that parses command line options. Input is a description of the command line options you want your program to support. Output is a C or C++ function which finds these options in an array of strings (typically "argv", the second parameter of the "main" function) and sets variables accordingly. The package supports both short (single character) and long (GNU style) options. Users can also associate a help string with each option. Opag uses these to create a macro which expands to a string containing a nicely formatted description of the options.

Openbios: Openbios aims to create an IEEE 1275-1994 compliant firmware (referred to as OpenFirmware). OpenFirmware (IEEE-1275-1994) is used by SUN, Apple and others. OpenBIOS is also a chance to implement functions missing in the standard PC-BIOSe, e.g. support for serial terminals etc.

Opy: Configurable Multi-Module Python Source Code Obfuscator. This program will take your multi-module Python 2.7 or 3.x source code and replace all identifiers by numered tags. Identifiers of 3rd party or standard modules as well as identifiers used in getattr, setattr, exec and eval can be exempted.

Otak: Otak provides a visual interface to command line programs that don't have one by letting users to select arguments from a menu. For example, it can be used as an address book program with Mutt (the default), or as a phone book with SMS sending software, or even as a list of hosts for SSH or FTP.

Overflow: Overflow is a "data flow oriented" development environment which lets users build complex programs by visually connecting small, reusable building blocks. It is primarily designed as a research tool, but can also be used for real-time data processing. The package includes a visual debugger. It currently includes toolboxes for signal, speech, and image processing, vector quantization, fuzzy logic, real-time audio effect processing, and neural networks.

PJ

Etymon PJ/PJX is a developer toolkit for parsing, modifying, and creating PDF documents. The main part of the toolkit is a Java class library that provides software developers with an object representation of a PDF document that can read, parse, modify, or extract data from exisiting PDF files, as well as creating new ones. PDF is normally used in the final stage of document preparation, but it is also useful in the following situations:

Use an existing document as a starting point for PDF generation
Extract information about documents for a catalog
Stamp a header or other text onto pages of a document
Combine pages from various sources into a single document
Overlay text onto a form based on user input
Extract graphical elements from a document

POlib: polib allows you to manipulate, create, modify gettext files (pot, po and mo files). You can load existing files, iterate through it's entries, add, modify entries, comments or metadata, etc... or create new po files from scratch. polib provides a simple and pythonic API, exporting only three convenience functions 'pofile', 'mofile' and 'detect_encoding', and the 4 core classes: POFile, MOFile, POEntry and MOEntry for creating new files/entries.

Patch: GNU version of Larry Wall's program that takes "diff's" output and applies it to an original file to generate a modified version of that file. Normally, the patched versions are put in place of the originals. Backups can be made.

Patchutils

Patchutils contains the following tools for manipulating patch files: interdiff, combinediff, filterdiff, fixcvsdiff, rediff, lsdiff, and splitdiff. You can use

interdiff- creates an incremental patch from two patches against a common source
combinediff- creates a single patch from two incremental patches
filterdiff- selects patches based on files matching shell wildcards
lsdiff- lists modified files in a patch
rediff- corrects hand-edited patches
fixcvsdiff- corrects the output of 'cvs diff'
splitdiff- separates patches so that each new file alters a given file only once

Patchwork: GNU Patchwork automates patch authoring and submitting. It keeps track of which files have been modified, added, and removed. It tracks multiple, overlapping patches against a source tree and allows the patch author to pop them off and push them on the patch stack. It can automatically generate a diff and mail it to the appropriate address. You can configure, by directory, which addresses patches get mailed to. It neither uses nor requires CVS. This project has been decommissioned and is no longer developed.

Pdc: PDC is a desktop calculator in the 'bc' style with features designed for programmers. It does not support floating point math, but does provide all the C operators (logical, bitwise, shifts, etc.) and implements ISO C operator precedence. Additionally, functions are available to assist with 'bit bashing' tasks such as byte swapping and bit scanning.

Perltidy: Perltidy is a Perl script indenter and beautifier. By default it approximately follows the suggestions in perlstyle(1), but the style can be adjusted with command line parameters. Perltidy can also write syntax-colored HTML output, and is useful in tracking down errors based on missing or extra braces, parentheses, and square brackets.

Picocom: 'picocom' is a minimal dumb-terminal emulation program designed to serve as a simple, manual, modem configuration, testing, and debugging tool. It has also served as a low-tech "terminal-window" to allow operator intervention in PPP connection scripts. 'picocom' is ideal for embedded systems since its memory footprint is less than 20K when stripped. The source distribution includes an easy to use and thoroughly documented terminal-management library, which could serve other projects alao. This library hides the termios calls, and provides a less complex and safer (though less feature-rich) interface.

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

Preprocess: There are millions of templating systems out there (most of them developed for the web). This isn't one of those, though it does share some basics: a markup syntax for templates that are processed to give resultant text output. The main difference with preprocess.py is that its syntax is hidden in comments (whatever the syntax for comments maybe in the target filetype) so that the file can still have valid syntax. A comparison with the C preprocessor is more apt. preprocess.py is targetted at build systems that deal with many types of files. Languages for which it works include: C++, Python, Perl, Tcl, XML, JavaScript, CSS, IDL, TeX, Fortran, PHP, Java, Shell scripts (Bash, CSH, etc.) and C#. Preprocess is usable both as a command line app and as a Python module.

Prima: Prima is an extensible Perl toolkit for multi-platform GUI development. Supported platforms include GNU/Linux, Windows NT/9x/2K, OS/2, and UNIX/X11 workstations (FreeBSD, IRIX, SunOS, Solaris, and others). The toolkit contains a rich set of standard widgets and has emphasis on 2D image processing tasks. A Perl program using Prima looks and behaves identically on X, Win32, and OS/2 PM.

Proto: ANSI C and C++ need function prototypes, but often a programmer will write a program only to find that he's left out a system header file and is missing a prototype for an important function. These tools are designed to find function prototypes.

Ptmalloc2: * " Note: nedmalloc supersedes ptmalloc2 and is a better memory allocator in almost all scenarios " 'ptmalloc2' is one of the fastest dynamic memory allocators known. It is forked directly from GNU glibc 2.3.3. Extensively tested, it gives an average of six times speed improvement in heavily multi-threaded applications.

Pvswitch: 'pvswitch' is a tiny program which makes it possible to use different program installations on one machine flawlessly. It is most useful for developers of interpreter based programs which are started via a hash-bang line (#!) (Perl, Tcl, etc and who need to run programs sagainst different interpreter version of those languages.

Py

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

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

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

PyFind: PyFind is a "find file" utility for GNOME written in python.

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

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

PyPluggy: Core of Pytest's plugins.

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.

PyTOML: Parses and creates TOML configuration files.

Pyconfigure: GNU pyconfigure makes it easy for Python developers to offer their users the familiar and standard GNU process for configuring and installing their software: $ ./configure $ make install GNU pyconfigure can wrap the functionality of an existing Python distutils setup.py script, making it easy to integrate with existing packages. It also offers a set of robust Autoconf macros for building powerful and flexible configure scripts.

Pycrc: pycrc implements a reference model in Python and a source code generator for C. The used CRC variant can be chosen from a fast but space-consuming implementation to slower but smaller implementations suitable especially for embedded applications.

Pyglet

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

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

Python Bytecode Verifier: Python Bytecode Verifier's purpose is similar to that of Java or .NET bytecode verifiers; to ensure that an externally compiled bytecode is safe to be executed in the runtime environment. Using a verifier in the Python interpreter could securely allow loading compiled bytecode to be loaded into isolated Python environments. Closed source code written in Python as well as external compilers for other languages targeting the Python runtime could safely be used in bytecode form. This Python Bytecode Verifier is implemented in Python and is written with C portability in mind because the long-term goal is to convince the Python community to accept a bytecode verifier into the CPython interpreter that would increase security of internally compiled Python code and would securely enable the use of externally constructed Python bytecode.

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

Q-Graph: Q-Graph is an add-on library to deal with combinatorial graphs (data structures consisting of nodes and edges connecting the nodes). It is a collection of Q scripts that provide a graph data structure and a full-featured Tk-based graph editor. It can be used to implement and test graph algorithms using the Q language.

Quotatool: quotatool is a tool for manipulating filesystem quotas. Depending on the options given, it can set hard or soft limits on block and inode usage, set andreset grace periods, for both users and (if your system supports this) groups. The filesystem to set the quota on is given as the first (and only) non-option element, and it is either the block special file (i.e /dev/sda3) or the mount point (i.e. /home) for the filesystem.

RHIDE

RHIDE is an integrated development environment for DJGPP. It is NOT a compiler; it is a program that gives you a friendlier user interface to the compilers (mostly gcc) which come with DJGPP. Features include:

Ability to compile programs without knowing the exact command line syntax of gcc
Highlighted syntax for C/C++ source files and headers, for Pascal source files and customizable highlighting for any other files
an integrated debugger which lets you debug your program without leaving RHIDE or running an external debugger
ability to customize (among other) colors, screen mode, compilers and compiler options, and language

RPM Wizard: RPM Wizard is an installation program for RPM packages. Using a wizard interface, it makes installing easy even for beginners. With features such as automatic dependency handling, it aims to become the most easy-to-use RPM installation program.

Regex-markup: Regex-markup performs regular expression-based text markup according to used-defined rules. It can color syslog files as well as the output of programs such as ping, traceroute, gcc, etc. The hierarchal rules-format is simple to understand, yet very powerful. Regex-markup and uses POSIX regular expressions to do much of its work.

Regular Expression Graphing Program: This program is designed to take a regular expression and produce a graph of the state machine that is used to parse the regular expression. It is useful for teaching regular expressions and state machines. The program comes with a built-in tutorial and sample set of regular expressions.

SPOPS: SPOPS (Simple Perl Object Persistence w/ Security) is a robust and powerful Perl module that allows you to serialize objects. It is unique in that it also allows you to apply security to these objects using a fairly simple but powerful scheme of users and groups. It's also unique in that for most objects, you will not need to write any code. All you need is a fairly simple configuration file, and you can have a class for your object ready to go, right out of thin air.

Safeheap: Run time utility to detect buffer overrun and underrun in a C/C++ programs. Aborts the program as soon as a memory corruption is detected and saves the backtrace information in a log file for later debugging. Useful tool to fix hard and frustrating memory corruption bugs.

Salmon: Salmon is a pure Python SMTP server designed to create robust and complex mail applications in the style of modern web frameworks such as Django. Unlike traditional SMTP servers like Postfix or Sendmail, Salmon has all the features of a web application stack (ORM, templates, routing, handlers, state machines, Python) without needing to configure alias files, run newaliases, or juggle tons of tiny fragile processes. Salmon also plays well with other web frameworks and Python libraries.

Sanity.pl: 'sanity.pl' renames all files in a directory to a sane name; it replaces spaces with underscores, removes semicolons, and replaces German umlauts. It also lowercases .MP3 to .mp3 which works much better with some players.

Savane: 'Savane' is a Web-based Free Software hosting system, originally based on SourceForge 2.0. It currently includes bug tracking, project and member management, mailing lists, and individual account maintenance.

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

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

Sfind: 'sfind' is a portable and POSIX.1-2001 compliant implementation of the "find" utility. It implements features like "-ls" and "-exec program [argument ...] {} +" (the latter is the POSIX built in "xargs"). There are no limitations on path length. Directory loops caused by hard-linked directories are handled gracefully.

Shuffle: 'shuffle' randomly rearranges its arguments. The number of rearranged arguments to be printed is user-specifiable, so shuffle may be used to choose one element of a list at random, for instance.

Sloccount: SLOCCount is a set of the programs for counting source lines of code (SLOC) in large software systems. It can automatically identify and measure a wide range of programming languages. It automatically estimates the effort, time, and money it would take to develop the software, using the COCOMO model or user-provided parameters.

Sloth: Sloth allows you to slow down an application by specifying (in milliseconds) the delay on the process. It slows the process down by very rapidly sending it SIGSTOP and SIGCONT, giving the appearance of a slower application.

Sos: 'sos' is a user interface for a simple string to integer encoding function. The function and the user interface are useful for a crude implementation of "switching on strings" (SOS) in standard C. SOS means using strings in the case labels of a switch statement. This feature is useful, for example, in parsing configuration files of the form "name=value", with "value" having several options.

Source-Navigator: Source-Navigator is a source code analysis tool. It lets you edit source code, display relationships between classes and functions and members, and display call trees. You can also build your projects with your own makefile or by using Source-Navigator's build system to automatically generate a makefile. It works with the Insight GUI interface for GDB, and supports C, C++, Java, Tcl, [incr Tcl], FORTRAN, and COBOL, and provides an SDK to write your own parsers.

SourceWell: SourceWell is a software announcement and retrieval system that includes user authentication and authorization system (anonymous/user/editor/admin), sessions with and without cookies, high configurability, multilangual support, ease of administration, RDF-type document backend, advanced statistics, announcing mailing lists, application indexing by sections, and many other features. It is browser and database independent.

SqueakGtk: SqueakGtk is an attempt to port the Gtk+ GUI to Smalltalk Squeak.

Stream: Streams are iterables with a pipelining mechanism to enable data-flow programming and easy parallelization.

Subterfugue: A framework for observing and playing with the reality of software via system call tracing and rewriting. It's a foundation for building tools to do tracing, sandboxing, and many other things. You could think of it as "strace meets expect."

SweepOver: 'SweepOver' makes the exploration of a model by numerical simulations easier and faster. For example, take a system that has 4 parameters A,B,C,D and that produces a figure of some quantity against A. In code, this corresponds to a loop. If you need to see what happens when B is varied, and you modify the loop slightly. However, doing this repeatedly becomes tedious very quickly. 'SweepOver' gives you a black box, that is, an executable called PROG that simulates a system for a given set of parameters and prints out the relevant quantities. Then SweepOver sweeps over any parameter magically.

TNT: The Template Numerical Toolkit (TNT) is a collection of interfaces and reference implementations of numerical objects for scientific computing in C++. It defines interfaces for basic data structures, such as multidimensional arrays and sparse matrices, commonly used in numerical applications. Kits goal is to provide reusable software components that address many of the portability and maintenance problems with C++ code.

Tag Manager

Tag Manager is a library and a set of utility programs to help IDE developers implement features such as code completion, calltips, source browsing, etc. It is based on ctags but overcomes a few of its limitations, such as availability as a clean set of library function calls, ability to show argument list for functions and macros, etc. It is GUI independent.

This project is currently undergoing a complete rewrite as per the developer. The new project will be called 'SourceBase.'

Tclap: Templatized C++ Command Line Parser is a simple library for parsing command line arguments. It provides a simple, flexible, object-oriented interface to the command line that automates the parsing, USAGE creation, and type casting common with command line handling. However, this library is templatized so the argument class is type independent which avoids identical-except-for-type objects like IntArg, FloatArg, StringArg, etc.

Tpipe: 'tpipe' is a Unix command pipeline plumbing tool. It duplicates standard input and/or standard ouput.

Trueprint

Trueprint translates C source code files as PostScript files. In addition to the basic source code output, it can also perform diff-marking, indentation counting, function and file indices and more. The following programming languages are supported:

C
C++
Java
Pascal
Perl
Pike
Sh (Shell)
Verilog

Turck MMCache: Turck MMCache is a opcode cache for PHP. It increases performance of PHP scripts by caching them in a compiled state, so that the overhead of compiling is almost completely eliminated. It also uses some optimizations for speeding up PHP scripts' execution. It typically reduces server load and increases the speed of PHP code by 1-10 times. PLEASE NOTE: The package is not updated frequently, and for this reason it is recommended to first try alternatives.

UI Dialog: UI::Dialog is an OOPerl wrapper for various dialog applications. It supports the dialog backends Zenity, XDialog, GDialog, KDialog, CDialog, and Whiptail; there is also an ASCII backend for console-based dialog variants. UI::Dialog is a class that provides a strict interface to these various backend modules. By using UI:Dialog (with its imposed limitations on the widgets), you can ensure that your Perl program will function with any available interface. UI::Dialog is the result of a complete rewrite of the UDPM CPAN module.

UPX: UPX (Ultimate Executable Packer) is a portable, extendable, high-performance executable packer for several different executable formats. It achieves an excellent compression ratio and offers very fast decompression. Your executables suffer no memory overhead or other drawbacks. UPX supports 32-bit and 64-bit GNU/Linux binaries, 32-bit Windows binaries and much more. Experimental support for 64-bit Windows binaries is also available.

UnixODBC: 'unixODBC' is an specification that gives application developers a predictable API with which to access data sources (defined as SQL Servers and any data source with an ODBC driver). Its single biggest advantage is dynamic data binding, which lets a user or sysadmin pick one data source and configure an application to use it without having to recompile.

Upad: Upad is a programmer (aka "chipflasher") and low level debugger for micro-controllers which feature a background debug mode (BDM) interface. BDM is an electronic interface enabling debugging of embedded systems. Specifically, it provides in-circuit debugging in a non-intrusive manner. The interface appears in many Freescale and NXP products, such as the S12Z, HCS08, and 68HC12. Upad may be used to upload programs to such products and to debug those programs. Its software is exclusively free software. It requires a dedicated hardware device, but this is inexpensive and can be easily constructed by a moderately skilled technician.

Vc-dwim: vc-dwim contains two tools, vc-dwim and vc-chlog. vc-dwim is a tool that simplifies the task of maintaining a ChangeLog and using version control at the same time, for example by printing a reminder when a file change has been described in the ChangeLog but the file has not been added to the VC. vc-chlog scans changed files and generates The GNU coding standards-compliant ChangeLog entries based on the changes that it detects.

VirtualBox: Virtual Machine Software creation entity

Wcd: WCD is a directory changer. It jumps to a (sub)directory anywhere in the directory-tree. The directory to jump to can be given by only the first characters or an expression with wildcards.

Wget Script generator: This is a candidate for deletion: 1. No source found WGSGen is a shell download-script generator for wget. It repeats wget commands and flags for each URL you want to download (you can set different options for each URL) which saves time and repetition. You can generate scripts either locally or remotely (ie telnet, ssh, etc) and leave them running. This is particularly valuable in machines with limited permissions and no wget frontend. As of January 22, 2003, the links and emails addresses for this entry are not working. An Internet search has turned up no further information. If anyone has additional information about this package, please contact <bug-directory@gnu.org>.

Whitespace: Whitespace detects and can clean up the following types of whitespaces in the given files: leading space, trailing space, indentation space, space followed by TABs, and end-of-line space.

Wildcard 2: Wildcard is a program for renaming files that supports recursion, Perl regular expressions, and multiple levels of undo. Transposition maps can be defined and used as well.

Working Directory: Working Directory (wd) lets you store a handful of commonly used directories in short, easy-to-type slots. It supports varyious schemes of working directories, and is intended for terminal users who deal with deep or scattered directory structures.

XCLE: 'XCLE' is a software suite aims that gives developers tools for the programmatic handling of executable code, combining easy generation and manipulation with execution speed and memory efficiency at runtime.

XML Boiler

I wrote a specification (congratulate me with great work) for automatic transformation of XML documents based on namespaces, written a software (XML Boiler) to implement these transformations. Written a short tutorial for XML Boiler. There was no automatic way to transform between XML files of different formats previously. This new way is a technological revolution. Most of the specification was implemented in Python programming language, resulting in this free software. The most important current project goal (as of Apr 2019) is to rewrite the entire project in D programming language (because Python was found too slow and also not enough reliable). Additional project purpose: Develop some general purpose libraries for D programming language. The benefits of the project include:

freely intermix tag sets of different sets of tag semantics (using XML namespaces), without disturbing each other (such as by name clash) in the global world
add your new tags to HTML (and other XML-based formats)
get rid of using HTML in future Web, switch it to proper semantic XML formats
make XSL-format based browsers with automatic generation of XSL from other XML formats
make automatic coloring of source listings (for example)
add macroses and include (such as by XInclude) other files in XML
intermix different XML formats, with intelligent automatic processing of the mix
embed one XML format in another one
automatically choose the order of different XML converters applied to your mixed XML file
make browsers to show your XML in arbitrary format
make processing XML intelligent (with your custom scripts)
integrating together XML conversion and validation scripts written in multiple programming languages
associating semantics (such as relations with other namespaces and validation rules) to a namespace
semantics can be described as an RDF resource at a namespace URL (or a related URL)
many more opportunities
integrate all of the above in single command

XRoar: XRoar is a cross-platform emulator for the Dragon 32, Dragon 64, and Tandy CoCo computers all originally released in the early '80s. The emulator runs under Unix-like operating systems (including Mac OS X), Windows32, and the GP32 handheld.

Xbae: Xbae is a set of widgets that extend Motif. Most powerful of the three widgets is XbaeMatrix, which presents an editable array of string data to the user in a scrollable table similar to a spreadsheet. The rows and columns of the Matrix may optionally be labeled. It can be used as a table, a matrix, or a powerful list. XbaeCaption associates an XmLabel (caption) with it's single child. The label may be either an XmString or Pixmap and can be displayed in any one of twelve positions around the perimeter of the child. XbaeInput is a subclassed from the XmText widget. It lets keystrokes be validated as well as the final string, and is handy for restricting user input.

Xbasic: XBasic is a comprehensive program development environment that integrates a powerful editor, compiler, debugger, function libraries and GuiDesigner into a seamless working environment that encompasses the whole process of creating fast, efficient, reliable, portable 32-bit programs.

Xev: XEv is a stand alone X client that prints all the events received by a window, to aid in the debugging and understanding of X11 event messages. It is useful for seeing what causes events to occur and to display the information that they contain; it is essentially a debugging and development tool, and should not be needed in normal usage. It is a part of the X.Org project.

Xlrd: Xlrd is a Python module for extracting data from Excel spreadsheet files. It can be used to extract data from new and old Excel spreadsheets on any platform. The package itself is pure Python with no dependencies on modules or packages outside the standard Python distribution. It has strong support for Excel dates and is Unicode-aware.

Xvcg: Xvcg is an X-windows tool for displaying call-graphs, flow diagrams, and the like, specified in a .vcg file and written in GDL (graph description language). Some of the source files (five of them) contain obfuscated code which contradicts section 3 of the GNU GPL.

Xxdiff: 'xxdiff' is a graphical browser for viewing the differences between two or three files, or between two directories, and can be used to produce a merged version.

YASM: The Yasm Modular Assembler accepts both NASM and GAS syntax; supports x86 and AMD64 instructions; and outputs binary, ELF32, ELF64, 32 and 64-bit Mach-O, RDOFF2, COFF, Win32, and Win64 object formats.

YAZ: YAZ (Yet Another Z39.50 toolkit) is a portable C/C++ programmer's toolkit which supports the development of Z39.50v3 clients and servers. Sample clients and a server are included with the distribution.

Yaccviso: Yaccviso visualizes yacc and bison grammars. It will generate a .dot or .vcg file that you can play around with in graphviz (from AT&T research labs fame) or VCG. The graphics above shows a very simple version of the very same yacc grammar which was used to write Yaccviso. Is is especially helpful when you have a large grammar file. Yaccviso will show you the dependencies between the grammar's left hand side (LHS) and its corresponding RHS non terminals and terminal symbols. It just helps to visualize! This is especially true when you have to keep in mind the first- and follow-sets.

Yasper: 'Yasper' (Yet Another Smart Pointer) is a and simple single-header smart pointer for C++. It is a simpler alternative to boost::shared_ptr and loki::smart_ptr that uses no policy templates and requires no external dependencies.

Zfuncs: A package of various utility programs useful to programmers.

Free Software Foundation!

Semantic search

Query log

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Interaction

Navigation

Creation

Print

Tools