Semantic search

Jump to: navigation, search
Search

Edit query Show embed code

The query [[Software-development::small-specific-development-task]] was answered by the SMWSQLStore3 in 0.0467 seconds.


Results 11 – 110    (Previous 100 | Next 100)   (20 | 50 | 100 | 250 | 500)   (JSON | CSV | RSS | RDF)


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 which follows the GNU programming standards. The new package uses autoconf to configure itself, and automake to create the Makefile. `make distcheck' succeeds. . 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. . Optionally, the new package will use a command line parser generator. Currently, autoproject supports two parser generators: clig by Harald Kirsch (kirschh@lionbioscience.com) (see http://wsd.iitb.fhg.de/~kir/clighome/), and autogen by Bruce Korb (korbb@datadesign.com) (see ftp://autogen.sourceforge.net/autoopts).
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
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 Heckert gnu.tiny.png
Binutils includes tools capable of creating and managing binary program files, including handling object files, libraries, profile data, and assembly source code.
Bison Heckert gnu.tiny.png
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 Heckert gnu.tiny.png
'GNU 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 Heckert gnu.tiny.png
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.
Coreutils Heckert gnu.tiny.png
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 Heckert gnu.tiny.png
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 Heckert gnu.tiny.png
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 Heckert gnu.tiny.png
'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 Heckert gnu.tiny.png
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 Heckert gnu.tiny.png
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 Heckert gnu.tiny.png
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 Heckert gnu.tiny.png
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 Heckert gnu.tiny.png
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.


Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the page “GNU Free Documentation License”.

The copyright and license notices on this page only apply to the text on this page. Any software or copyright-licenses or other similar notices described in this text has its own copyright notice and license, which can usually be found in the distribution or license text itself.