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

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.

Free Software Foundation!

Semantic search

Query log

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Interaction

Navigation

Creation

Print

Tools