Newbies What Next ? News Forums Calendar
Home | Register | News | Forums | Portal Pages | MyLinks | New | Hot | Link Us


 Category Gateway
More Options

LinuxLinks News
 · CD Audio Grabbers
 · fitlet is a tiny fanless PC full of openness
 · MintBox Mini gives Linux users a pocket-sized PC
 · 6 Invaluable Assembly Books
 · Why Mac users don’t switch to Linux
 · MIPS Creator CI20 review
 · Getting a Time Without NTP
 · CES 2015: Intel announces $149 Compute Stick which runs Windows and Linux
 · Firefox OS-Powered Smart TVs Coming Soon, Says Panasonic
 · ‘Linux Advocates’ Throws in the Towel


Latest Links


Top : Software : Programming : Development : Tools : Miscellaneous

CD Audio Grabbers
CD audio grabbers are designed to extract ("rip") the raw digital audio (in a format commonly called CDDA) from a compact disc to a file or other output. This type of software enables a user to encode the digital audio into a variety of formats, and download and upload disc info from freedb, an internet compact disc database.

(Read more)
Eloquent JavaScript
Eloquent JavaScript is a book providing an introduction to the JavaScript programming language and programming in general.


  • 0release
    0release is a program to generate source and binary releases automatically. With minimal configuration, 0release will generate a source tarball release candidate, build it to create a binary archive, upload them to your Web server, check the uploads, and tag the release in GIT and update the version number.
  • 6502dis
    a disassembler for 6502 binaries
  • ACR
    ACR is an autoconf like tool that allows you to create configure scripts for your programs. The main aim of this tool is to teach developers how to create portable builds of their tools, just using generic functions wrapped by acr to generate portable shellscript.
  • AdaControl
    AdaControl is a tool that detects the use of various kinds of constructs in Ada programs. Its first goal is to control proper usage of style or programming rules, but it can also be used as a powerful tool to search for the use (or non-use) of various forms of programming styles or design patterns. Searched elements range from very simple, like the occurrence of certain entities, declarations, or statements, to very sophisticated, like verifying that certain programming patterns are being obeyed. Which elements or constructs are searched is defined by a set of user-definable rules.
  • AnyDBM
    AnyDBM is a generic interface to DBM-like databases for Haskell. It lets you store String-to-String mappings in various formats, from a simple in-memory Map to a high-performance DBM database or even a SQL database.
  • Application Version Management
    designed to enable multiple versions of the same application (i.e. Mozilla) to be accessible to a user or developer on the same machine
  • apvsys
    a general open-source wrapper designed for engineering Unix/Linux environments. It provides a way to use and to manage simultaneously different versions of applications ( engineering tools, compilers, debuggers simulators, ... )
  • Apydia
    Apydia is an API reference documentation generator for Python. It's designed as an instantly serviceable replacement for Pudge's API documentation generator. However, it won't generate complete Web sites from reST like Pudge does. Apydia is only about the API.
  • ASM Workbench
    ASM Workbench is a tool environment for supporting the design and validation of abstract state machine (ASM) specifications.
  • AsmSrc
    AsmSrc generates assembler assembler source files from Linux executables. Library calls are detected along with symbols and other information found in ELF executable files. Generated source file is in nasm format.
  • Astroconst
    Astroconst is a set of header files in various languages (currently C, Fortran, Perl, Java, IDL and Gnuplot) that provide a variety of useful astrophysical constants without constantly needing to look them up.
  • at51programmer
    a universal, intelligent programmer for Atmel's 8051 devices, parallel flash, and e2prom memories
  • Atlantis Installer
    Atlantis Installer is an installation wizard built to simplify installing PHP-GTK2 applications on multiple platforms as an alternate solution to using PEAR. This allows you to build your application with the structure you want and drop it nicely as one package.
  • Autoconf Macro Archive
    provides documented and tested macros that are useful to many software writers using the autoconf tool, but too specific to be included into autoconf itself
  • AutoGen
    designed to simplify the creation and maintenance of programs that contain large amounts of repetitious text. It is especially valuable in programs that have several blocks of text that must be kept synchronized
  • Autoglade
    autoglade is a tool that automagically creates a fully working application from a GUI Glade definition plus some declarative information with no programming.
  • AutoLink
    a tool designed to transfer dynamic data-types (like graphs) using MPI
  • autorevision
    autorevision extracts metadata about the head version of your repository. It is meant to be used by project build systems to extract properties which can be used in software version strings.
  • AVR-Ada
    AVR-Ada aims to make the Ada part of gcc usable on AVR microcontrollers. This includes the three elements: the Ada compiler, the Ada run time system, and the AVR support library Some sample programs will be provided as well.
  • Bare Bones
    BareBones is an interpreter for the "Bare Bones" programming language defined in Chapter 11 of "Computer Science: An Overview", 9th Edition, by J. Glenn Brookshear.
  • binfmtc
    binfmtc implements handlers for C and other languages, which are usually compiled.
  • binutils
    a collection of binary utilities including gas (the assembler), ld (the linker), nm, ranlib, objdump, objcopy, readelf, etc. Most of these programs use the Binary File Descriptor (BFD) library to do low-level manipulation. The binutils have been ported to most major Unix variants as well as Wintel systems
  • Bisect
    Bisect is a code coverage tool for the Objective Caml language. It is a camlp4-based tool that allows to instrument your application before running tests.
  • BitRock InstallBuilder
    (commercial) allows you to create easy-to-use installers for Linux applications. The generated installer for an application can be run in GUI, text, and unattended modes
  • BlueSense SDK
    BlueSense SDK is a software development kit for communicating with BlueSense equipment. It allows you to read out sensors or control actuators. A user-space USB driver for all platforms is included.
  • BNM
    BNM is a build system that uses Maven pom.xml files and implements replacements for the core Maven system and its most important plugins.
  • Bolt
    Bolt is a logging tool for the Objective Caml language.
  • bpython
    bpython is an enhanced Python interactive interpreter that uses curses and provides the following main features: in-line syntax highlighting; readline-like autocompletion with suggestions displayed as you type;
  • brace
    brace is a dialect of C that looks a bit like python. It is compatible with C. It has coroutines, hygenic macros, automatic prototypes and headers, data structures, graphics and sound, etc.
  • brainwash
    brainwash is an optimizing interpreter for the Brainf*ck programming language written in C. It is developed with speed, low memory footprint, functionality and portability in mind.
  • bsdiff
    bsdiff and bspatch are tools for building and applying patches to binary files. By using suffix sorting (specifically, Larsson and Sadakane's qsufsort) and taking advantage of how executable files change, bsdiff routinely produces binary patches 50-80% smaller than those produced by Xdelta, and 15% smaller than those produced by .RTPatch (a $2750/seat commercial patch tool).
  • BuildNumber
    BuildNumber is a utility to add auto-incrementing build numbers to C/C++ projects. It is written in pure C for maximum portability but can also be used with C++ projects, and should compile on any platform. Every time you rebuild your project, BuildNumber will automatically update its build number for you: set it up once, and it just works. You can compile individual files without incrementing the build number, because it only updates when you actually build or make your project.
  • Buildroot
    Buildroot is a set of Makefiles and patches that makes it easy generate a cross-compilation toolchain and root filesystem for your target Linux system using the uClibc C library.
  • C++ XML Objects
    C++ XML Objects is a framework for persisting hierarchies of C++ objects to and from XML. Boost, the STL, and patterns are used extensively.
  • C-Pluff
    C-Pluff is a plug-in framework for C programs. It has been strongly inspired by the Java plug-in framework in Eclipse. C-Pluff focuses on providing core services for plug-in interaction and plug-in management. It aims to be platform neutral and supports dynamic changes to plug-in configuration without stopping the whole application or framework. It does not yet provide special facilities for distribution such as signed plug-in packages or remote plug-in repositories, but it is possible to build such features on top of the current framework.
  • C99-snprintf
    C99-snprintf is a free, portable, and C99 compliant implementation of the snprintf(3), vsnprintf(3), asprintf(3), and vasprintf(3) functions. It can be included with software packages as replacement code for systems which don't provide (C99 compliant versions of) these functions.
  • c_count
    c_count counts lines, statements, other simple measures of C/C++ source programs. It isn't lex/yacc based, and is easily portable to a variety of systems.
  • Candygram
    a Python implementation of Erlang concurrency primitives. Erlang is widely respected for its elegant built-in facilities for concurrent programming. This package attempts to emulate those facilities as closely as possible in Python
  • Capstone
    Capstone is a lightweight multi-platform, multi-architecture disassembly framework. Our target is to make Capstone the ultimate disassembly engine for binary analysis and reversing in the security community. It supports hardware architectures: ARM, ARM64 (ARMv8), Mips, PowerPC, Sparc, SystemZ and Intel.
  • CCFE
    CCFE is a simple tool to quickly supply an interactive screen-oriented interface to command line scripts and commands.
  • CCView
    CCView is a C++ project and class viewer for GNOME. The program can integrate with any editor that has a remote control mechanism (Emacs, for example) view member functions of C++ classes, and add new member functions.
  • cencode
    cencode encodes a stream or a file into quoted c-string escape sequences, suitable for use directly in C code. It is a universal alternative to dedicated export formats like XPM, unportable resource forks, linker flags, and Windows resources where dynamic loading of external data is not possible or undesired.
  • Cflow2Cflow
    Cflow2Cflow is a small utility to quickly manipulate the output of a large cflow output file. The cflow utility is a tool which take one or more C sources files and produce a calltree file.
  • cflow2vcg
    converts the result of the cflow utility to a VCG format
  • cfunge
    cfunge is a fast interpreter for the Befunge98 esoteric language. It is standard conforming.
  • chmc
    chmc is a free CHM compiler command targeted to *nix chm viewers.
  • Chump
    Chump is a table-driven assembler and dissembler with a very fast new architecture input format. Both the assembler and disassembler are created using a single description.
  • chunkit
    chunkit is a console client interfacing a file hosting service aka 'File upload for hackers'.
  • CIL
    CIL (C Intermediate Language) is a front-end for the C programming language that facilitates program analysis and transformation. CIL will parse and typecheck a program, and compile it into a simplified subset of C.
  • cinfo
    to provide users with more information on the contents of the various caches of their kernel
  • clig
    clig is a Command Line Interpreter Generator.
  • Cloc
    Cloc counts blank lines, comment lines, and physical lines of source code in many programming languages. It is written entirely in Perl, using only modules from the standard distribution of Perl 5.6 and higher, and so is quite portable.
  • CMT++
    an easy-to-use code metrics tool for C and C++ languages. Also assembly code can be measured. CMT++ is intended for mature software development organizations striving for productive development process resulting in high quality products
  • Coco
    Coco is a code coverage utility for Ruby. It can be used from RSpec or unit/test with a simple "require 'coco'".
  • Code Browser
    a folding and outlining editor for Linux and Windows. The editor is between a traditional text editor, a smalltalk class browser and a web browser like mozilla. It displays a structured text file (marker-based folding) hierarchically using multiple panes
  • CodeViz
    a call graph generation utility for C/C++
  • CodeWrestler
    CodeWrestler is a tool to massage a code base in different ways. Its main function is to traverse a source tree, identify the file types (e.g. source code, scripts, xml files, properties files) and run different processing classes on them.
  • Coil
    an MVC framework for Python. It is based on the design of Struts, and supports many of the same API's
  • ColorDiff
    a wrapper for 'diff' and produces the same output but with pretty 'syntax' highlighting. Colours schemes can be customized
  • Commando
    Commando was inspired by both Python's built-in optparse module and the JewelCli Java library. It eases the pain usually involved in trying to define and parse command line arguments to your Python application.
  • comparator
    a pair of tools for rapidly finding common code segments in large source trees. They can be useful as tools for detecting copyright infringement
  • compilercache
    a wrapperscript around your C and C++ compilers. Eachtime you compile something, the wrapperscript puts the result of the compilation into a cache
  • Config Maker
    Config Maker is a tool to automatically create C++ classes that parse configuration files. Only a few lines of text that describe the possible entries in the configuration file are needed, and the complete class will be generated ready for use.
  • constraint
    a constraint satisfaction problem solver written in python
  • Controlled Variables
    Controlled Variables implements secure basic types in C++. It provides C++ templates that give you the ability to control the initialization of your basic C types (i.e. char, int, long long, etc.).
  • cpdetector
    a framework for configurable code page-detection of documents. It may be used to detect the code page of documents retrieved from remote hosts
  • cproto
    generates function prototypes for functions defined in the specified C source files to the standard output. The function definitions may be in K&R or ANSI C style, or in lint-library form. cproto can also convert function definitions in the specified files from the K&R style to the ANSI C style
  • Cross Module Inliner
    an optimizing frontend for gcc which allows gcc to inline across module boundaries without requiring you to put inline functions in header files or even mark inline functions for inlining
  • crosstool
    crosstool is a set of scripts that make it easy to build cross-development toolchains based on gcc, glibc, and Linux. The goal is to make it easy to build and test cross-toolchains for all architectures supported by glibc.
  • crosstool-NG
    crosstool-NG is a versatile toolchain generator. It supports multiple target architectures, different components such as compilers and C libraries. It aims at being highly configurable.
  • crpcut
    crpcut (pronounced "crap cut") is the Compartmented Robust Posix C++ Unit Tester. With crpcut it is easy to write tests that other unit-test frame works cannot manage.
  • crucible
    A system for testing open source applications. Allows uploading or scheduling retrieval of software and its dependencies, and running different kinds of tests on it.
  • CSpec
    CSpec is a behavior-driven development framework for C. It provides a spec framework for describing the behavior of the functions of your system. The syntax is inspired from RSpec to be as legible as possible. The source code is as portable and as light as possible to make it easy to run the library on embedded devices.
  • cstrings
    cstrings is a lightweight internationalization tool for C code. It is useful for those who find gettext too bulky and intrusive.
  • CTC++
    CTC++ is a powerful instrumentation-based test coverage and dynamic analysis tool for C and C++ code. As a coverage tool, CTC++ shows the coverage all the way to the Modified Condition/Decision Coverage (MC/DC) level as required by DO-178B projects. As a dynamic analysis tool, CTC++ shows the execution counters in the code, i.e. more than plain boolean coverage information.You can also use CTC++ to measure function execution costs (normally time) and to enable function entry/exit tracing at test time.
  • Ctcompare
    Ctcompare allows you to compare several sets of C code trees on a token basis, rather than on a line by line basis. These programs help to identify code copying and similarities between snippets of code in both trees.
  • ctopy
    ctopy automates the parts of translating C source code to Python source code that are difficult for a human but easy for a machine.
  • Cuiterm
    CUI (Composite User Interface) is a compound type of user interface which incorporates the features of the GUI (Graphical User Interface) and the CLI (Command Line Interface) by realizing both interface in one area at the same time. It is absolutely substantial that the CUI contains GUI elements and control language in the same area of the screen at the same time, so the incorporation is complete. CUI is not an optional, alternatively selectable combination of the two communication method but a truly new approach.
  • CUnit
    a Unit Test framework for 'C'. This is not intended for C++, there are other frameworks that specifically support C++.
  • cupl
    cupl is an interpreter for the archaic CUPL and CORC programming languages. It includes full documentation and several programs.
  • cxmon
    cxmon is an interactive command-driven file manipulation tool that is inspired by the "Amiga Monitor" by Timo Rossi. It has commands and features similar to a machine code monitor/debugger, but it lacks any functions for running/tracing code. There are, however, built-in PowerPC, 680x0, 80x86 (including x86-64), 6502 and Z80 disassemblers, and special support for disassembling MacOS code.
  • DACS
    DACS is a general-purpose, distributed system that combines Single Sign-On capability and role-based access control for web services, which are any static and computational resources provided by a web server through HTTP. The DACS design is open and built from industry-standard protocols and APIs, making porting to new environments straightforward.
  • Daikon
    Daikon is an implementation of dynamic detection of likely invariants; that is, the Daikon invariant detector reports likely program invariants. An invariant is a property that holds at a certain point or points in a program; these are often seen in assert statements, documentation, and formal specifications. Invariants can be useful in program understanding and a host of other applications
  • dc3dd
    dc3dd is a patched version of GNU dd to include a number of features useful for computer forensics.
  • Delphi Yacc & Lex
    a parser generator toolset for Delphi and Kylix, based on Turbo Pascal Lex and Yacc
  • DePlo
    DePlo (DEpendency PLOtter) creates a graph (in the DOT format) showing the dependencies between Ada packages.
  • Devel::Profiler
    a Perl profiler designed as a drop-in replacement for Devel::DProf. It outputs data in the same format as Devel::DProf and supports the dprofpp frontend.
  • Dia2Code
    a small utility used to generate code from a Dia diagram
  • Discrete Event Calculus Reasoner
    The Discrete Event Calculus Reasoner allows a programmer to add common-sense reasoning capabilities to programs. It supports deduction/temporal projection, abduction/planning, postdiction, and model finding. It allows default reasoning about action, change, space, and mental states.
  • Dissy
    Dissy is a disassembler (graphical frontend to objdump) for multiple architectures. It allows fast navigation through the disassembled code and easy searching for addresses and symbols. Dissy is written in Python and available under the GNU GPL.
  • Distance Disassembler
    Distance Disassembler allows you to specify labels for addresses in the program being disassembled or for memory-mapped I/O registers and and ROM routines.
  • distcc
    distributes compilation of C code across several machines on a network. distcc 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
  • Distel
    Distel extends Emacs Lisp with Erlang-style processes and message passing, and the Erlang distribution protocol. With this you can write Emacs Lisp processes and have them communicate with normal Erlang processes in real nodes.
  • DndSkan
    a helper for developers that want to add drag and drop or clipboard support to their applications
  • dwarf-ng
    dwarf-ng is a powerful object file manipulation tools in the spirit of gdb. with dwarf-ng you can read and edit all the file's section headers as well as the raw data.
  • eAccelerator
    eAccelerator is a further development from mmcache PHP Accelerator & Encoder. It increases performance of PHP scripts by caching them in compiled state, so that the overhead of compiling is almost completely eliminated.
  • Ecere SDK
    The Ecere SDK is a cross-platform toolkit for building software applications. It currently runs on Windows and Linux. With the Ecere SDK, you can develop applications once and deploy them on all supported platforms alongside a lightweight runtime environment. It introduces eC, an object oriented language derived from and fully compatible with C, compromising neither runtime performance nor ease of use. A built-in 3D engine supporting both Direct3D and OpenGL is fully integrated.
  • ECLI
    an Eiffel wrapper around the X/Open ISO/CLI (Call Level Interface). This interfaces defines an API to RDBMS drivers, and uses SQL92
  • ECMerge Pro
    (commercial) ECMerge compares and merges files and folders, side-by-side or 3-way. It provides syntax coloring for C/C++, Java, HTML, ASP, PHP, and many other programming languages. It can save your work at an intermediate state and restart it later. It can generate Unix patches between files. A shell extension is provided under Windows.
  • EDelta
    EDelta is a fast XDelta-style binary differ, but optimized for executables which have a very systematic way of changing between versions. It has not been thoroughly evaluated so far, but on one example (two versions of Vim) it produces a 30kB delta where XDelta needs 250kB.
  • eglade
    eglade is an Eiffel code generator that parses XML files produced by Glade.
  • Eiffel Wrapper Generator
    a tool that generates Eiffel wrapper classes for C libraries. It can be used to create libraries that bridge the gap between Eiffel and C. It aims to work for arbitrary ANSI C and with all common Eiffel compilers
  • elf
    a comfortable command-line ELF object file header analyzer. Unlike many other similar projects, this project is aimed at the analysis of the ELF header, so as a large feature-set as possible is planned
  • 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 makes 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.
  • ELF Tool Chain
    ELF Tool Chain is a set of program development tools for working with files in the ELF executable file format.
  • elfvector
    a package for generating and using a transfer vector for subroutine linkage between an ELF executable and an ELF shared library under Linux on x86, in order to save space and application startup time
  • Ember
    replaces the Lite / W3-mSQL scripting package previously distributed with mSQL
  • EmilPRO
    EmilPRO is a graphical disassembler for a large number of instruction sets. It is a reimplementation and replacement for the Dissy disassembler.
  • encdec
    encodes and decode a wide range of C objects. This module may be used to encode and decode C objects such as integers, floats, doubles, times, and internationalized strings to and from a wide variety of binary formats as they might appear in portable file formats or network messages
  • ePerl
    allows you to expand perl statements inside of text files. It was originally written in C by Ralf S. Engelschall
  • EPP Interpreter
    a tool which supports the authoring and execution of EPP scripts using any BSF supported scripting language
  • Error Class Converter
    takes a text file that defines the error types, constant names and messages, levels and responses associated with it and generates classes in the supported languages that can be used to consistently handle the errors
  • EtTcl
    EtTcl is an extended Tcl interpreter based on Tcl-7.6 (chosen because it is smaller in memory footprint than newer versions).
  • Expect-lite
    Expect-lite is a wrapper for expect, created to make expect programming even easier. The wrapper permits the creation of expect script command files by using special character(s) at the beginning of each line to indicate the expect-lite action. Basic expect-lite scripts can be created by simply cutting and pasting text from a terminal window into a script, and adding '>' '
  • eXtensible Programming System
    XPS is a programming system based on the LLVM compiler infrastructure that aims to support extensible programming. Its main purpose is to aid in the definition of domain specific languages which will allow programs to be constructed at higher levels of abstraction than is the current practice.
  • fcmm
    Fast Concurrent Memoization Map (fcmm) is an almost-lock-free concurrent hashmap to be used for memoization in concurrent environments.
  • filterunit
    filterunit is a unit test facility for command line programs working as a filter. You can define input files and files with expected output. filterunit runs the program under test with the input files and compares the actual results with the expected results.
  • FlexMock
    FlexMock provides a mock/stub/spy library for Python. It is inspired by Ruby's FlexMock, however full feature parity with the Ruby version is not a goal.
  • Fluxcapacitor
    Fluxcapacitor is a tool for making your program run without blocking on timeouts, on functions like poll and select, by spoofing POSIX time functions.
  • fpgatools
    fpgatools is a toolchain to program field-programmable gate arrays (FPGAs). The only supported chip at this time is the xc6slx9, a 7 USD 45nm-generation fpga with 5720 6-input LUTs, block ram and multiply-accumulate devices.
  • Frama-C
    Frama-C is a suite of tools dedicated to the analysis of the source code of software written in C. Frama-C gathers several static analysis techniques in a single collaborative framework.
  • froofyJIT
    froofyJIT is a C++ 'syntactic sugar' front-end for Paolo Bonzini's GNU lightning library for dynamic native code generation. It uses C++'s powerful language facilities to allow GNU lightning instructions to be expressed in a more concise way that approximates a 'real' assembly language.
  • Frosted
    Frosted is a passive Python syntax checker.
  • FunnelWeb
    a literate-programming tool with a number of advanced features, including parametrized scraps, and fine control over the generated data
  • G-Inspector
    G-Inspector is a GLib(GTK+) object/class inspector.
  • G-Wrap
    tool (and Guile library) for generating function wrappers for inter-language calls. It currently only supports generating Guile wrappers for C functions
  • gaa
    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
  • gc-utils
    gc-utils is a small set of scripts that let you import and update CVS repositories into git very easy and let you export patches back into a CVS working copy. To makes the exchange easy, gc-utils stores the CVS working copy into a subdirectory and receives all information from there whenever necessary.
  • GCC Introspector
    consists of a patch to the gcc compiler to output the internal compiler tree nodes in RDF/XML and programs to process that RDF/XML
  • gDSPsim
    Gnu Digital Signal Processor Simulator: a DSP Simulator for Linux
  • geanyvc
    geanyvc is a plugin that provides a uniform way of accessing different version control systems from inside the Geany IDE. Only small subset of vc is implemented (diff, log, status, revert, and commit).
  • gengetopt
    generates a C main function that uses getopt_long function to parse the options, validate them and do certain tasks in response
  • ggcov
    ggcov is a GTK+ GUI for exploring test coverage data produced by C programs compiled with gcc -fprofile-arcs -ftest-coverage. So it's basically a GUI replacement for the gcov program that comes with gcc.
  • Gh-issues
    Gh-issues is a command line tool to display issues from a GitHub repository in a colorized console window.
  • git-annex
    git-annex allows managing files with git, without checking the file contents into git. While that may seem paradoxical, it is useful when dealing with files larger than git can currently easily handle, whether due to limitations in memory, checksumming time, or disk space.
  • glade--
    a C++ frontend for glade, the GUI designer for Gtk
  • gldd
    gldd visualizes dynamic library dependencies of Linux *.so and executable files.
  • glrParser
    glrParser is for the creation of syntactical analysers which work with the GLR(0) algorithm. The library can handle wide ambiguous grammars containing the epsilon-rules.
  • Gnasher
    Gnasher creates SHA1 hash files for local repository Maven2 dependencies. It also produces the missing pom metadata files for the same dependencies if they are missing, as well as producing SHA1 hash files for those poms.
  • Gnocchi
    Gnocchi is a complexity analyzer for C++ code. It calculates cyclomatic and the NPATH complexity measures. It reads the coverage information produced by GCC and determines the complexity of all functions. If code is compiled with -fprofile-arcs or -ftest-coverage (depending on compiler version), GCC creates a .gcno file for every object file.
  • Go-HotSwap
    (commercial) Go-HotSwap is a PICMG 2.1 R2.0 compliant, cross platform, Hot Swap software infrastructure. Using the Go-HotSwap architecture reduces time-to-market, enabling developers to focus on core technologies instead of going through all the effort involved in developing in-house hot swap software.
  • GPAC
    GPAC is a multimedia framework based on the MPEG-4 Systems standard (ISO/IEC 14496-1) developed from scratch in ANSI C. GPAC also features MPEG-4 Systems encoders/multiplexers, publishing tools for content distribution for MP4 and 3GPP(2) files and many tools for scene descriptions (MPEG4<->VRML<->X3D converters, SWF->MPEG-4, etc...).
  • gperf
    a perfect hash function generator. For a given list of strings, it produces a hash function and hash table, in form of C or C++ code, for looking up a value depending on the input string. The hash function is perfect, which means that the hash table has no collisions, and the hash table lookup needs a single string comparison only
  • GPIB-Tcl
    an extension to the Tcl programming language to allow communication with measurement equipment through the industry-standard IEEE-488 (GPIB) bus
  • GPLify
    a Perl script that adds notice of the GPL to a collection of source files
  • gquilt
    gquilt is a PyGTK GUI wrapper for quilt and mq. quilt and the mq extension to Mercurial (hg) are tools for managing a series of patches by keeping track of the changes each patch makes.
  • Greensocs
    Greensocs is a development kit for producing systems on a chip using SystemC (a C++ derivative) as opposed to Verilog or VHDL.
  • Grouch
    Grouch is a system for describing and enforcing a Python object schema.
  • GSLgen
    GSLgen is a general-purpose file generator. It generates source code, data, or other files from an XML file and a schema file. The XML file defines a particular set of data. The schema file tells GSLgen what to do with that data.
  • GtkJentchina
    a simplified GTK front-end library for Jentchina. It has a filter selection dialog and uses LibIGen to display forms
  • gtksourceviewmm
    gtksourceviewmm is a C++ wrapper for the gtksourceview text widget. It supports undo/redo, syntax highlighting, and other features typical of a source editor.
  • gtranslator
    gtranslator is an enhanced gettext po file editor for the GNOME desktop environment. It handles all forms of gettext po files like compiled gettext po files (gmo/mo files), compressed po files (po.gz/po.bz2 etc.) and features many comfortable everyday usage features likeFind/Replace, Auto Translation, Message Translation Learning, Messages Table (for having an overview of the translations/messages in the po file), Easy Navigation and Editing of translation messages & comments of the translation where accurate.
  • Guglhupf XML Transformation Engine
    A set of tools for transforming XML files. It is meant to be a simpler way of transforming xml than XSLT is. You can use XTE either as a command line tool, or as a Java framework to extend the functionality of your Java application.
  • Gumba
    Gumba allows you to use coffeescript and underscore.string inside your commandline.
  • HDLLint
    (commercial) a powerful Lint program for Verilog and VHDL
  • Heap Layers
    provides a flexible infrastructure for composing high-performance memory allocators out of C++ "layers". Heap Layers makes it easy to write high-quality custom and general-purpose memory allocators
  • histofile
    displays a histogram of the used byte-values in a given file. In other words, how many As, how many Bs, how many Cs, etc., for the entire range from 0 to 255. It includes a graphic view and a table view
  • Hogmem
    Hogmem is a program for managing memory status in development or test environments. It will reserve a specific amount of system memory and prevent the VMM from swapping the reserved memory to disk. This can be beneficial in various test cases where resource limits are not a meaningfull method for memory status management.
  • HOL
    a programming environment in which theorems can be proved and proof tools implemented. Built-in decision procedures and theorem provers can automatically establish many simple theorems
  • HOL-TestGen
    HOL-TestGen allows one to write test specifications in Higher-order logics (HOL). It can (semi-) automatically partition the input space, resulting in abstract test cases, and automatically select concrete test data. Automatic generation of test harnesses (in SML) is supported, and using a foreign language interface, implementations in arbitrary languages (e.g. C) can be tested.
  • HTML Document Object
    allows a programmer to quickly and easily generate dynamic HTML documents without having to deal with all the HTML overhead at every step of the way
  • HTML::Merge
    HTML::Merge is a scripting tool for Embedded HTML/SQL/Perl.
  • Hypy
    Hypy is a full-text search interface for Python applications. It can be used to index and search your documents from Python code.
  • I'm Cross!
    I'm Cross! is a script that installs a C/C++ cross-compiler toolchain that targets Microsoft Windows on a developer's Linux workstation.
  • i18nspector
    i18nspector is a tool for checking translation templates (POT), message catalogues (PO) and compiled message catalogues (MO) files for common problems.
  • i2py
    i2py provides tools for converting programs and scripts written in Research System Inc.'s IDL programming language to Python. It is not an IDL-compatible front end for the Python interpreter, nor does it make any attempt to replicate the functionality of the IDL standard library. Rather, its only purpose is to perform source-to-source conversion of legacy IDL code to Python. Currently, it supports only procedural IDL, although support for object-oriented code may be added in the future.
  • IBM Grid Toolbox
    an integrated set of tools and software that facilitate the creation of grids and applications that can exploit the advanced capabilities of the grid using a combination of this toolbox and other technologies
  • iCCsh
    iCCsh is an interactive C compiler shell. It allows C code to be quickly and easily evaluated, without the need for manually constructing and compiling an entire C source file.
  • IGCC
    IGCC is a real-eval-print loop (REPL) simulator for C/C++ programmers. It allows you to type C++ statements which are immediately compiled and executed.
  • IMSettings
    IMSettings is a framework that delivers Input Method settings and applies the changes immediately, so it will take effect without restarting applications and the desktop.
  • Intel2GAS
    a converter that will convert assembler source files written for NASM to files that can be assembled using the GNU Assembler (GAS), on the i386 platform. It provides support for basic MMX instructions as well
  • Inti-GConf
    an Inti binding for GConf (the GNOME Configuration System). It makes accessing the GConf database from your Inti applications easy and intuitive. Its API and documentation are complete and it comes with several examples
  • Intland Source Explorer
    (commercial) a Source Code Engineering tool suited for C, C++ and Java developer, project manager, and quality assurance enginee
  • Intlize
    Intlize allows the developer to use catgets without its normally bulky syntax and without having to mind the details of correct indices. Catgets is the built-in internationalization suite of C compilers. Alternatively, Intlize can produce a compact file format optimized for fast access. Intermediate files are in gettext po format, so there are many comfortable tools available to do the translations. Runtime files are provided for C and C++ and for both catgets and intlize native support.
  • ironout
    Ironout is a C refactoring tool. It tries to be simple and fast.
  • irrXML
    irrXML is a simple and fast open source xml parser for C++. The strenghts of irrXML are its speed and its simplicity. It ideally fits into realtime projects which need to read xml data without overhead, like games. irrXML was originally written as part of the Irrlicht Engine but after it has become quite mature it now has become a separate project.
  • isymchoose
    isymchoose can automatically determine which symbols (functions, types, enumerators, etc.) are available in a given C language source file and present you with a list of completion possibilities, including return types and argument lists.
  • Jail Chroot
    Jail Chroot is an attempt of write a tool that builds a chrooted environment. The main goal of Jail is to be as simple as possible, and highly portable.
  • JetPAG
    JetPAG is a flexible full-LL(k) parser and lexical analyzer generator focused on high performance, efficiency, usability, and readability of generated code. It generates powerful recursive-descent recognizers, and supplies a small library that can be used to do minimal parsing needs. Generated code is nicely structured and distributed over several files for easier management and integration into larger projects. JetPAG offers a wide range of customizations for the supplied grammars, allowing a great deal of control over the generated source code, and preventing many of the possible modifications on the generated code.
  • JiTI86
    a just-in-time instrumentation tool for Intel binaries. The tool allows you to create a dynamic loadable library that can be attached to a dynamic linkable program running under Linux
  • Jpass
    a password generator to add passwords to the signup form of a php/mysql based admin system
  • jPrintf
    (shareware) a port of printf to Java. It features precompiled format strings and an object-oriented design, and has helped hundreds of programmers port legacy C applications to Java
  • Kamaelia
    Kamaelia is designed as a testbed for network experimentation using a component architecture designed to simplify creation and testing of new protocols for large scale media delivery systems.
  • KBabel
    KBabel is an advanced and easy to use PO-file (gnu gettext message catalogs) editor. It has many features, that makes editing and managing your PO-files easy. This includes full navigation capatibilities, extensive editing functionality, search functions, syntax checking and statistics function.
  • Kcov
    Kcov is a code coverage tester based on bcov, which uses DWARF debugging information to collect coverage information from binaries without special compiler options
  • Kexi KFormDesigner
    an integrated environment for managing data. It helps creating database schemas, inserting, querying and processing data
  • KitCreator
    KitCreator is a simple build system for creating a Tclkit. It was created to ease creation of Tclkits.
  • kodepaster
    a command line tool to post code(c++ etc) to websites and use the link to share it with others, very helpful in IRC channels. so no need to open the browser, copy the text from the file, hit 'paste' etc. everything is done in one step
  • kparalleleport
    kparalleleport is a program for programmers who wish to use the parallel port. It makes it possible to view the values registered or read on the parallel port.
  • KProf
    KProf is a visual tool for developers that displays the execution profiling output generated by gprof.
  • Kunjika
    Kunjika is a Stackoverflow clone.
  • Kylix Libs Packaging
    tries to package the required Kylix libs for the most popular Linux distributions so that you have to distribute only your application any care about the required kylix libraries
  • Kyra
    a simple, fully featured, industrial strength Sprite engine written in C++. It is built on top of SDL and has been tested on Windows and Linux. It is provided free for non commercial use
  • ldapdiff
    ldapdiff combines "diff" and "patch" functionality in one application. The difference is, that ldapdiff is not designed for use on flat ascii files, it is designed for "patching" ldap directories using ldif files.
  • LibSysCTr
    a utility library that can be used to intercept system call functions on a Linux system. Process monitoring and sandboxing are just two of the potential usages of LibSysCTr
  • Likwid
    Likwid is a lightweight tool collection for multi threaded high performance programming. It contains command line tools for printing various topology information, pinning a threaded application (OpenMP and pthreads). Using the Linux msr module it allows to easily measure Performance counters from the command line. With likwid-bench a framework for rapid prototyping of assembly loop kernels is included.
  • linoleum_linux32
    linoleum_linux32 is a run-time module for the universal low-level programming language. This module allows compilation of Linoleum programs to run in the 32-bit versions of the GNU/Linux operating system.
  • Linux Trace Toolkit
    catalogs system events in minute detail, and allows a user to determine exactly what is happening
  • lisp-network-server
    lisp-network-server is a simple framework for writing Common Lisp network applications. It takes care of listening on the network, accepting the connection, and starting a new thread with handler functions of your network-aware application.
  • LoginServer
    a multi-client TCP server class with username/password access control
  • Lokalize
    Lokalize is a computer-aided translation system that focuses on productivity and performance. It implies paragraph-by-paragraph translation approach (when translating documentation) and message-by-message approach (when translating GUI). Lokalize is a replacement for KDE4 of KBabel.
  • lrc
    lrc (The Linux Resource Compiler) is a system for packing many files into a single file for installation and use in a program as its resources (such as the graphics and sounds used by a game).
    for the POSIX.1 coverage for the Linux Standard Base. LSB-VSX is built using the VSXgen (the generic VSX test framework), with the VSX-PCTS90 4.4.4 test set merged into it. The test coverage corresponds to the core "classic" POSIX.1
  • LuaRocks
    LuaRocks is a deployment and management system for modules in the Lua programming language. It aims to provide facilities for Lua such as those from module systems of other scripting languages, such as Ruby's RubyGems or Perl's CPAN.
  • m4
    GNU m4 is an implementation of the traditional Unix macro processor. It is mostly SVR4 compatible, although it has some extensions (for example, handling more than 9 positional parameters to macros). GNU m4 also has built-in functions for including files, running shell commands, doing arithmetic, etc.
  • Magick++
    the object-oriented C++ API to the ImageMagick image-processing library.
  • Maniac
    Maniac is a tool designed to automate the comparison and the validation of multiple variants of a same program. This is achieved by compiling each variant in a distinct shared object and generating a loader program that will successively load and execute them.
    an Algol-to-C translator. It automatically translates programs written on the algorithmic language Algol 60 to the C programming language
  • Matwrap
    a tool for interfacing C++ code into matrix-oriented scripting languages such as Matlab 5, Octave, and tela. It generates all the code to convert from the scripting language's internal types into the types that your C++ code understands
  • mawk
    mawk is an interpreter for the AWK Programming Language.
  • MCML2
    will compile CML2 (rulebase) to C or Java. It is mainly developed for configuring Linux kernel
  • Melon MailServer
    Melon MailServer is a simple mail server emulator for developers. It can emulate POP3 and SMTP services. The SMTP facility receives and stores all the messages sent to it rather than sending them.
  • Memory Pool System
    a very general, adaptable, flexible, reliable, and efficient memory management system. It permits the flexible combination of memory management techniques, supporting manual and automatic memory management, in-line allocation, finalization, weakness, and multiple concurrent co-operating incremental generational garbage collections
  • MemProf
    a tool for profiling memory usage and detecting memory leaks. It can be used with existing binaries without need for recompilation
  • Method Support
    Method Support is a program for supporting procedures by defining online forms. In other words, it provides the equivalent of a set of paper forms. This can be used to support defined procedures or processes, such as required for methods, methodologies, and processes such as SDLCs, the CMMI, or for SOX. The emphasis of this approach is to make it easy to set up a set of forms and to modify the forms over time.
  • MfGames.Node
    MfGames.Node is an I/O abstraction layer that creates a consistent interface for DotNET filesystem interfaces along with the internal contents of zip files.
  • MIB Smithy SDK
    a dynamic Tcl/Tk extension for developing your own SNMP management scripts and SMI conversion tools (with or without a GUI). MIB Smithy SDK is based on the core library that MIB Smithy Professional and Standard are built upon, providing the user an API with all of the internal capabilities of MIB Smithy (and benefits thereof) without the GUI
  • MindMap and Knowledgemanager
    a knowledge visualisation and archiving tool. MindMapping is displaying the knowledge in a tree structure so that the associations and links between knowledge
  • MiniCppUnit
    MiniCppUnit another C++ port of the famous JUnit framework for unit testing. Unlike CppUnit, MiniCppUnit follows a minimalistic aproach: The basic features are the same but in only bout 500 lines of code! No library instalation is needed, etc.
  • Minimac
    Minimac is a minimalist general purpose text macro processor, its simplicity should make it particularly well suited as a front end preprocessor for little language compilers.
  • mixal
    an assembler and interpreter for Donald Knuth's mythical MIX computer
  • mktclapp
    a tool for combining C/C++ code with Tcl/Tk to build a standalone executable that will run on machines without Tcl/Tk installed
  • MRPC
    Modular Remote Procedure Call is an open source remote procedure call system. It consists of a code generator and a transport interface. Sample transport code is provided and new transports are easy to define.
  • multitask
    multitask allows Python programs to use generators (a.k.a. coroutines) to perform cooperative multitasking and asynchronous I/O. Applications written using multitask consist of a set of cooperating tasks that yield to a shared task manager whenever they perform a (potentially) blocking operation, such as I/O on a socket or getting data from a queue. The task manager temporarily suspends the task (allowing other tasks to run in the meantime) and then restarts it when the blocking operation is complete. Such an approach is suitable for applications that would otherwise have to use select() and/or multiple threads to achieve concurrency.
  • naken430asm
    naken430asm provides a development kit for the Texas Instruments MSP430 line of microcontrollers.
  • ncursesxx
    provides a set of widgets for text user interface like menubars, popup menus, various dialog boxes, and controls (push buttons, check buttons etc.). Using this library you can easy create a powerfull console program with compicated interface
  • NoodleInstaller
    NoodleInstaller is a free, easy to use, configurable install program for use in distributing your programs. It it available for both DOS and Linux.
  • NUnit
    a simple framework to write repeatable tests in any .Net language. NUnit has only been tested with the Beta 2 .Net SDK, build 2914. C#, VB and JScript examples are supplied
  • nwbintools
    nwbintools is a machine code tool-chain containing an assembler and various related development tools. It will thus be similar to GNU's binutils, but no attempts are made to duplicate its functionality, organization, or interfaces. The assembler works on x86 ELF-based Linux and FreeBSD systems.
  • ObjecTrieve
    (commercial) an advanced ISAM file manager, in the form of a library of C function that efficiently manage ISAM files. ObjecTrieve allows a developer to build robust database management applications that allow direct and fast access to records. Using ObjecTrieve, applications can be built with C or C++ to handle non-conventional, unstructured and large data, in addition to conventional and structured data that fits a record-and-file metaphor. As it is available under multiple platforms, a developer can build applications that can easily be ported across different environments.
  • odirect
    When reading a lot of data from a disk or network filesystem, e.g. during a backup, buffer cache pollution can be a substantial performance problem for other processes on the machines involved. odirect is intended to provide a convenient way of avoiding that on systems that offer an O_DIRECT value for open(). The project provides a C library, a C++ wrapper, and SWIG code to make it easy to use from your favorite scripting language.
  • Open Track
    a flexible issue tracking tool originally developed at the Open Software Foundation for tracking issues on OSF/1, DCE, Motif, DME, ODE, and a slew of other projects
  • OpenCCG
    a collection of natural language processing components and tools which provide support for parsing and realization with Combinatory Categorial Grammar (CCG)
  • p4delta
    summarizes the difference between a Perforce depot/repository project and its local version. It detects files that have been added and removed, and of existing files it counts the number of lines that have been added, deleted, and changed
  • parallel
    Build and execute command lines from standard input in parallel.
  • Patch Maker
    Patch Maker helps you manage multiple in-progress source code patches to software. It remembers which files are part of which patch, and keeps them disentangled during the development process. It speeds up common operations and housekeeping tasks, allowing you to focus on writing code. It is a command-line tool written in Perl, and so is usable on (at least) Windows, Linux and Mac OS X.
  • patchutils
    a small collection of programs that operate on patch files. Currently it contains interdiff and filterdiff
  • Pedeto
    Pedeto is a plugin for Eclipse that provides a fully featured IDE for Perl. It features full Eclipse integration, content assist, background syntax checking, code folding, syntax highlighting, a debugger, and much more.
  • Peludo
    Peludo is a system that provides a toolchain and a runtime to create and launch self-contained, platform independent, injectable, network transportable, non-static applications that can be dynamically extended on-demand.
  • pENC
    (commercial) a source code encryptor for Perl. It generates a license file, which must be present for the encrypted code to run
  • pepper
    pepper is a flexible command-line tool for retrieving statistics and generating reports from source code repositories. It ships with several graphical and textual reports, and is easily extendable using the Lua scripting language. pepper includes support for multiple version control systems, including Git and Subversion.
  • Perl Console
    Perl Console is a small program that lets you evaluate Perl code interactively. It uses Readline to grab input, and provides completion with all the namespaces loaded during your session. It allows you to load a module in your session and test a function exported by it.
  • pgtcl
    This is a project to evolve and upgrade libpgtcl, the Tcl client interface to PostgreSQL. Enhancements will include converting all commands to use Tcl 8-style objects, an interface to asynchronous query processing, more rigorous checking of command arguments, and more standardized processing of numeric arguments and error reporting.
  • PHP AnyXML
    AnyXML is an XML read-only class that offers PHP 5 SimpleXML's capabilities on any host, even those with PHP 4 or lacking the expat extension. It will automatically and transparently fail back to the fastest available solution, always offering a consistent API.
  • Pies
    Pies is a Python 2 & 3 compatibility layer with the philosophy that all code should be Python 3 code. Starting from this viewpoint means that when running on Python 3 pies adds virtually no overhead.
  • Pin Dynamic Instrumentation Tool
    Pin Dynamic Instrumentation Tool is a tool for the instrumentation of programs. It supports Linux executables for Intel (R) Xscale (R), IA-32, IA-32E (64 bit x86), and Itanium (R) processors.
  • Plow
    Plow is a workflow execution engine inspired by Makeflow. It features deps-aware execution, multi-process execution, incremental transition from imperative workflow execution with, and remote execution (with execnet gateway specification syntax).
  • PonyProg
    a serial device programmer software with a user friendly GUI framework available for Windows95, 98, 2000 & NT and Intel Linux. Its purpose is reading and writing every serial device
  • Poseidon for UML
    a UML-CASE-tool. It is an extension of the Open-Source-Project ArgoUML, that is available with source code and free of charge
  • PredictionIO
    PredictionIO is an open source machine learning server for software developers to create predictive features, such as personalization, recommendation and content discovery.
  • Pride
    Pride combines bash scripts, zenity, ant, ImageMagick, and the Android SDK tools to create a fast and simple POSIX alternative to Eclipse for Android development.
  • ProcessVisualizationBrowser
    a system for industrial process visualization. ProcessViewBrowser is based on Qt. It is capable of displaying most Qt widgets and some more
  • prtpacker
    a tool for creating C or C++ source code from external program resources such as images, text, or data. These resources can be arranged in a tree structure much like a typical file system. After compiling and linking the resulting source code you can access the resource tree from within your software through a simple API
  • PTK4L
    PIC ToolKit for Linux is an assembler, disassembler and programmer for the PIC16C84 and PIC16F84 microcontrolers.
  • Py-Lepton
    Py-Lepton is a high-performance, pluggable particle engine and API for Python. The engine is designed to be very flexible and does not rely on any other libraries directly. You can use it either with OpenGL (via pyglet or PyOpenGL), or with pygame by selecting the appropriate renderer. Examples are provided using pyglet and pygame.
  • PyCant
    PyCant helps Python developers manipulate test records from Cantata++, which provides unit and integration testing for software projects.
  • pycdep
    pycdep is a tool for analyzing and visualizing C/C++ header file dependencies. A script extracts information about your code and dumps it in a Prolog database, which is used to query the dependency graph.
  • PyDSM
    PyDSM is a Python Delta Sigma Modulator toolbox. It contains tools for experimenting with ?? modulators.
  • Pyfort
    a tool for creating extensions to the Python language using Fortran routines
  • pyfuscate
    pyfuscate is a tool to obfuscate Python source code. It is a tool for stripping contextual information from the programmer assigned names in your code.
  • pygccxml
    The purpose of the GCC-XML extension is to generate an XML description of a C++ program from GCC's internal representation. Since XML is easy to parse, other development tools will be able to work with C++ programs without the burden of a complicated C++ parser.
  • pyhtmlhelp
    pyhtmlhelp is a cross-platform tool written in Python for converting among CHM, HTB, and DevHelp formats. Hopefully, more formats will follow.
  • Pylon Application Platform
    Pylon Application Platform is a lightweight platform for embedded applications. It is scriptable using Forth, and applications based on it are also scriptable. Non-preemptive multitasking is provided.
  • Pymacs
    Pymacs is a powerful tool which, once started from Emacs, allows both-way communication between Emacs Lisp and Python. Pymacs in intended for using Python as an extension language for Emacs rather than the other way around, and this asymmetry is reflected in some design choices. Within Emacs Lisp code, one may load and use Python modules. Python functions may themselves use Emacs services and handle Emacs Lisp objects kept in Emacs Lisp space.
  • PyObjC
    aims to provide a bridge between the Python and Objective-C programming languages. The bridge is intended to be fully bidirectional, allowing the Python programmer to take full advantage of the power provided by various Objective-C based toolkits and the Objective-C programmer transparent access to Python based functionality
  • pyPEG
    pyPEG is a quick and easy solution for creating a parser in Python programs. pyPEG uses a PEG language in Python data structures to parse, so it can be used dynamically to parse nearly every context free language.
  • PyReverse
    a set of tools for reverse engineering Python code. So far, it features dependency analysis tools, documentation generation, and XMI generation for importation in a UML modeling tool
  • pyrobase
    pyrobase assembles general Python helper functions and classes that can be applied to any project. That includes some additional tasks for the Paver build tool, an improved xmlrpc2scgi module, unit test helpers, and generic base modules for various domains.
  • PySL
    PySL is a package that makes S-Lang functions and variables accessible via Python. It allows any S-Lang data type to move from S-Lang to Python scope and back (using numarray to provide the Python-side equivalent of S-Lang arrays). It also lets the user call any intrinsic or user-defined S-Lang function (including those defined by imported modules) from Python.
  • Python-AD
    Python-AD is an AD client for the Python programming language. It is built with Python-LDAP and provides some enhanced features such as credential management, domain controller location, and transparent multi-domain functionality.
  • PythonCard
    a project to build a HyperCard like tool in, and using, the Python language. PythonCard is a software construction kit
  • pyvm
    pyvm is an experimental Python virtual machine with a compiler written in Python. It is not 100% compatible with C-python, but well written Python programs without gross hacks should work.
  • pyXSD
    pyXSD is a free, open source python program that maps xml and xsd(XML Schema) files into python, allowing for easy schema-based validation and transformation of xml files.
  • qpybrowser
    a path- and classbrowser for Python code. It is based upon the path- and classbrowser that's included in Idle, the Python IDE that comes with the Python distribution
  • Quellcode Bahn
    QB (Quellcode Bahn) is a software that manage the operations on the source of the programs you develop, with a versioned repository. QB manage the deploy of your program, taking it from the repository and putting it wherever you want with test phase.
  • Quilt
    Quilt is a set of scripts to manage a series of patches by keeping track of the changes each patch makes. Patches can be applied, un-applied, refreshed, etc.
  • QUnitTest
    QUnitTest is a GUI front end for running C++ Unit Tests.
  • qwebcam
    qwebcam is a widget to display a webcam image in a Qt application.
  • RaTM
    RaTM is a testing utility that provides numerous abilities for testers such as report generation (in different formats), statistics gathering, flexible running of test scripts, and others.
  • ReadyExec
    ReadyExec is a client-server system designed to alleviate the problem of high-startup-costing applications which are run repeatedly.
  • Reblok
    Reblok is a utility to build back an Abstract Syntax Tree (AST) from Python bytecode.
  • REDLisp
    REDLisp is currently only an interpreter of a new dialect of Lisp. It already has GTK and SDL_mixer support. Functions partially work. Macros will be added very soon, as will classes, multiplatform sockets, and threads. REDLisp isn't meant to replace any current Common Lisp implementation, but is just a pet project of a college student.
  • RegExplorer
    RegExplorer is a visual regular expression explorer, it allows for writing regular expressions and visually see the matches, thus making regular expression much easier to write and maintain.
  • repcached
    repached is a patch set which adds a data replication feature to memcached 1.2.x. Its main purpose is to provide redundancy and safe fail over to the memcached system.
  • RepTool
    Reptool is a reporting/printing tool. It is made up of two components: libreptool, which manages source files that are the report's definition, and produces the report/printout; and greptool, which visually creates source files. It is based on glib, libxml, GTK+, cairo, pango, and libgda.
  • revdump
    Revdump is a tool that can dump values of various types (integers, floats, little/big endian) from raw data files, which is useful for reverse engineering data file formats.
  • rmtoo
    rmtoo is an open source requirement management tool.
  • RPM Builder for Anjuta
    a dynamic library plugin for Anjuta v1.1.1. and later This is a free software under GNU LGPL. You can make RPM spec file and RPM package(s) easily for your project. It makes RPM spec file from project. The plugin use the project settings (user name, configure parameters, etc.). The plugin saves all settings to a rbc file (and works with it next time). You can make RPM packages too (then you need the rpmbuild, otherwise not)
  • rtldi
    an ELF program interpreter that enables each main executable program to use its own runtime loader and shared libraries, independent of the default versions installed in /lib, and independent of any other main executable program
  • Ruby-GConf
    allows Ruby developers to write applications that store their configuration data using GConf
  • runawk
    runawk is a small wrapper for the AWK interpreter that helps one write standalone AWK scripts.
  • S-Lang Interface Package
    SLIRP is a vectorizing code generator aimed primarily at simplifying the process of creating modules for the S-Lang scripting language. It supports making C, C++, and Fortran code callable directly from the S-Lang interpreter and can automatically vectorize functions to take advantage of the abilities of S-Lang. SLIRP can also generate parallelizable wrappers for OpenMP-aware compilers.
  • SBuild
    SBuild is a very fast, powerful and flexible build tool. It can be used to build anything you want and does not force any style, but its main target are all Java VM targeted projects.
  • scit
    Simple Continuous Integration Tools (scit) is an automated build and or test system consisting of a set of Perl and expect scripts utilizing common tools that are available for most Unix-like operating systems
  • ScitePM
    ScitePM is a lightweight, GTK-based project manager for use with the SciTE editor. It allows the user to organize a set of files as a project, like most IDEs, and then open them within SciTE.
  • Scmbug
    Scmbug is a system that integrates software configuration management (SCM) with bug-tracking. It aims to be a universal tool that will glue any source code version control system (such as CVS, Subversion, and Arch) with any bug-tracking system (such as Bugzilla and Mantis).
  • scspell
    scspell is an interactive spell checker for source code. When applied to code written in most popular programming languages while using typical naming conventions, scspell will usually catch many errors without an annoying false positive rate.
  • Sdbsiod
    Sdbsiod is a version of the Siod Scheme interpreter with database support through libsdb, the simple database library.
  • sdelta
    sdelta analyzes two files and outputs the difference. It applies the difference or delta file to the first of the original files to construct a bit for bit clone of the second file. It is optimized for use with source tarballs, and also contains sdreq, the client for the sdelta Public Patch Repository.
    a set of object-oriented CLS-compliant .NET bindings for the SDL gaming library - a cross-platform multimedia library designed to provide level access to audio, keyboard, mouse, joystick, TrueType fonts, various image formats, sound mixing, 3D hardware via OpenGL, and 2D video framebuffer
  • SDLperl
    SDLperl is a multimedia programming extension to perl. Through use of the Simple DirectMedia Layer SDLperl provides support for graphics (2D and 3D), sound effects, music, cdrom playback, fonts, and game devices.
  • sedsed
    a Python script that masters sed scripts. It generates sed debug files in sed, which lets you debug scripts with your own version of sed
  • SEW
    SEW is a distributed real-time analysis tool intended toassist the real-time community in analysis algorithm development and distributed system analysis.
  • SharpBox
    SharpBox implements a .NET driven application programming interface for existing cloud storage services developed in C#.
  • shellcheck
    ShellCheck is a shell script static analysis tool. It's mainly focused on handling typical beginner and intermediate level syntax errors and pitfalls where the shell just gives a cryptic error message or strange behavior.
  • Sidebrain
    Sidebrain is a working-memory tool for programmers: it maintains a stack of your current tasks, a queue or pool of pending tasks, and a set of observations, to help to remind you of what you're doing.
  • Simple Settings Dialog
    Simple Settings Dialog (ssd) enables a script author to easily construct a simple dialog (e.g. for configuration purposes) that can be be presented to the user during script execution. It is build on QT4 and implements the most commonly used widgets from QT. It is intended for sysadmins for scripting purposes.
  • snescom
    snescom reads symbolic 65816 or 65c816 machine code and compiles (assembles) it into a relocatable object file.
  • Soap for Tcl
    provides a mechanism to bind Tcl command procedures to remote procedure calls using the Simple Object Access Protocol (SOAP) over HTTP
  • Source auditor
    a system for maintaining machine-parsable audit records for a tree of sourcecode
  • Source-Navigator
    Source-Navigator is a source code analysis tool. With it, you can edit your source code, display relationships between classes and functions and members, and display call trees.
  • splintGUI
    splintGUI is an graphical frontend for the syntax checker splint.
  • Spring IDE for Eclipse
    Spring IDE for Eclipse provides plugins for the Eclipse platform to ease working with Bean Factory configuration files for the Spring Framework. It contains a Spring project nature (with an incremental builder for validating Spring bean config files), an image decorator (which decorates Spring projects and all Spring bean config files), a Spring view (which allows one to browse Spring projects and their Spring bean config files, including bean properties), and an editor showing a graph from the beans of a single config file or a set of config files.
  • spuug
    spuug is a little tool that generates the boilerplate code for GObjects.
  • SSDDiff
    a diff application similar to GNU diffutils that generates "patch" files for semistructured data such as XML files. It differs from other XML diff applications
  • Struct::Compare
    compares two values of any type and structure and returns true if they are the same. It does a deep comparison of the structures, so a hash of a hash of a whatever will be compared correctly
  • Stubby
    a tool that enables programmers and packagers to add transparent support for optional run-time dynamic linking of shared libraries. This allows for the creation of applications that can gain additional functionality if a library is present, but that does not fail to load if the library is not installed
    The STUBS Toolchain and Utility Build Suite is a set of scripts which, together with a set of pre-written configuration files, builds one or more software packages in sequence.
  • SWIG
    Simplified Wrapper and Interface Generator: most commonly used to create high-level interpreted programming environments, systems integration, and as a tool for building user interfaces
  • Swig Starter Kit
    Swig Starter Kit provides a simple set of examples for integrating C++ and various scripting languages using SWIG. Currently, Lua is the only target language supported.
  • TAHI Test Suite
    The TAHI Test Suite provides a mechanism for validating an IPv6 implementation against a standardized test for conformance to the IPv6 specification, extensions and directly related protocols.
  • Talend Open Studio
    Talend Open Studio is an ETL (Extract, Transform, and Load) tool. Talend Open Studio can perform jobs that range from datawarehouse feeding to database synchronization, as well as file format transformations. Its graphical interface is made with Eclipse RCP, and data related scripts are generated in Perl. The application was designed to be extended with components written by users. Read more
  • tclreadline
    makes the GNU Readline library available for interactive tcl shells. This includes history expansion and file/command completion. Command completion for all tcl/tk commands is provided and commmand completers for user defined commands can be easily added
  • Tclshout
    extends tcl to include the commands based on libshout. It's an open source product released under the GPL. It's intention is to make it easy to connect to an icecast server and create an mp3 stream
  • tclxosd
    tclxosd is a Tcl binding for the libxosd on screen display library.
  • teamtrac
    Teamtrac is a tool to correlate different sources of information regarding the software engineering process. It is used by companies to monitor their own software development process, and by outsourcing companies to provide on-the-fly information to their customers. It can provide the glue between tools like a source repository (like CVS or Subversion), a ticketing system like Trac or Bugzilla, and a time tracking tool like Tutos, Kimai or, if you're unlucky, some simple spreadsheets. It can be used to provide statistics and evaluations across the boundaries of each of these tools.
  • TeaX
    a KDE style which provides a fast, elegant and usable theme engines for KDE widgets which allows translucent menu and panel (kicker), all of that using a C++ based engine, instead of using pixmaps, which increase performance
  • Template based B+ Tree
    Template based B+ Tree is a simple and yet very efficient template based B+ Tree implementation which supports different types of storage.
  • Texplore
    Texplore is a type explorer for GObject based libraries. You can see what signals, properties, and other things are present in each type, its parents, and its children.
  • The Examiner
    utilizes the objdump command to disassemble and comment foreign executable binaries. This app was designed to analyze static compiled binaries but works ok with others. The intention is for forensic research but could also be used in general reverse engineering
  • TinyUML
    TinyUML is a UML 2 diagram editor. It creates attractive UML diagrams and has a focus on ease of use.
  • tk_msg
    tk_msg is a small application which helps a programmer create message cataloges for localizing Tcl/Tk programs.
  • Tpl
    Tpl makes it easy to serialize your C data using just a handful of API functions.
  • trfcrypt
    an add-on package to the tcl-extension trf that provides encryption functionality
  • tsprof
    direct measurement subroutine profile for Linux on i586+
  • tuitest
    tuitest is a tool to create and run automated tests of text user interfaces. It is meant as a complement to the widespread use of unit tests, and uses concepts known from GUI testing tools with the difference that it applies them specifically to text- and terminal-based user interfaces.
  • ubuildinit
    ubuildinit is a utility for use with micro window-gadgets (UWG) that generates C source and header files from XML descriptions of visual interfaces.
  • Udis86
    Udis86 is an easy-to-use minimalistic disassembler library (libudis86) for the x86 and AMD64 (x86-64) range of instruction set architectures. The primary intent of the design and development of udis86 is to aid software development projects that entail binary code analysis.
  • Umple
    Umple is a modeling tool and programming language family to enable what we call Model-Oriented Programming. It adds abstractions such as Associations, Attributes and State Machines derived from UML to object-oriented programming languages such as Java, PHP and Ruby. Umple can also be used to create UML class diagrams textually.
  • Unacorn
    a couple of utilities to help port RISC OS C programs to Unix
  • Unique
    Unique finds patterns in source code. It helps you build better software by finding pieces of code that could benefit from a refactoring.
  • uthash
    uthash is a hash for C structures, allowing any C structure having a unique key field to be hashed. Structures can be added, deleted, or removed from the hash in constant time. The key field can have any data type.
  • vAVRdisasm
    vAVRdisasm is an Atmel AVR firmware disassembler. It supports all AVR instructions defined by the Atmel AVR Instruction Set, revision 0856E-AVR-11/05. This single-pass disassembler can handle Atmel Generic, Intel HEX8, and Motorola S-Record formatted files containing valid AVR firmware. vAVRdisasm is capable of a variety of formatting options, including representing data constants in different bases, and can output assemble-able code.
  • ViewBer
    ViewBer is a free utility that displays the ASN.1 structure of a BER-encoded file. ViewBer can be used to view the contents of X.509 certificates (PEM and DER encoded), PKCS#12, PKCS#10, CSR files, PKCS#7, etc.
  • vimplugin
    Vimplugin is an attempt to use the Vim text editor inside the Eclipse IDE. Vim offers powerful features such as macros, regular expressions, syntax highlighting for 1001 languages, and much more.
  • VisLib
    a Gtk application for visualizing, editing and searching hierarchically organized couples of visual and textual information
  • Visual REGEXP
    will let you design your regexps by letting you type the expression and visualize its effect on a sample of your choice
  • Voyager Application Server
    (commercial) offers Voyager(TM) users the means to build scalable, secure, distributed, transaction-oriented applications.
  • VSTHlite
    a lite version of The Open Group's Threads verification suite VSTH. VSTHlite is a test package for use with VSXgen (the generic VSX test framework), and contains 700 tests for a subset of the POSIX96 threads interfaces and headers
  • vu8
    vu8 is a system for wrapping C++ classes and functions within javascript modules and classes.
  • Web+
    (commercial) a tool for creating dynamic Web sites
  • wiggle
    wiggle is a utility that applies conflicted patches intelligently.
  • X-Tract
    an XML Script processor. XML Script is a fully XML compliant language, specifically designed for handling XML data. XML Script is more powerful than XSL, and can perform many XSL functions more efficiently. X-Tract can be used on the command line, or can be run from a web server to handle CGI queries
  • x2svg
    x2svg is software to graphically lay out files like DTDs and Java property files as scalable vector graphics (SVG).
    an example of a visual programming tool built using IPAD-Pro
  • Xfdiff
    Xfdiff is a graphic interface to the GNU diff and patch commands. It allows you to view differences side by side for files or directories. You can also view differences that applying a patch file would imply, without having to apply the patch. You can also apply patches to the hard disc or create patch files for differences between files or directories.
    an Extensible Interpreter Development Kit: provides technical guidance and source code so that you can readily design and implement an interpreter according to your own requirements. You may need, for example, to create a special interpreter for a domain specific language, script language, or other "little language".
  • XLObject
    XLObject is a clone of basic services offered by the Qt object model, redesigned around modern features of the C++ language. It provides signal and slots functionality, the ability to manage Objects using object trees, and useful Qt-like classes such as multi-threaded network sockets, timers, and easy to use threads.
  • xmlgen
    xmlgen allows users to write Tcl code which translates itself into XML. Every tag is made into a markup command which takes attributes and the element's content as parameters and then prints the XML tagged content.
  • XParam
    a general-purpose tool for parameter handling in C++. It allows object serialization and deserialization in a format that is human-readable and -writeable, and is unaffected by issues of word-size and endianity
  • xParse
    xParse is a light-weight XML Parser written in C++. It aims to simplify the creation of XML tree objects.
  • XPLC
    a component framework, similar to what Microsoft has done with COM or has done with XPCOM, but with slightly differing goals
  • XPTracker
    XPTracker is a radical alternative agile planning tool aimed at keeping out of your way and making sure you can see the stuff you care about at a glance.
  • xRecurseDiff
    xRecurseDiff is a small sotware, useful for all those programmers working with a own code repository (class library or similar). It helps to rapidly verify differences between different copies of the same file.
  • ydSLitProg
    a prototype for an SGML-based litterate-programming tool
  • Zenity
    Zenity is a tool that allows you to display Gtk+ dialog boxes from the command line and through shell scripts. It is similar to gdialog, but is intended to be saner. It comes from the same family as dialog, Xdialog, and cdialog, but it surpasses those projects by having a cooler name.
  • zmakebas
    zmakebas converts text files containing Sinclair Spectrum Basic programs (as plain old ASCII) into tokenised Basic saved in .TAP format.
  • ZMech
    Interative state machine development tool: IPAD-Pro derived

Share this Page
Bookmark and Share
Submit this page to popular social networks such as Digg, Twitter, StumbleUpon and more.

My LinuxLinks
  • Bookmarked links
  • Emailed Newsletter
  • Your own profile

  • Top Applications
    Top Free Software
    6 Lean Desktops
    14 File Managers
    21 Backup Tools
    21 Window Managers
    21 Productivity Tools
    21 Text Editors
    21 Video Emulators
    21 Home Emulators
    42 Graphics Apps
    42 Scientific Apps
    42 Email Apps
    12 Instant Messaging
    42 Games
    42 More Games
    21 More Games
    42 Audio Apps
    42 Video Apps
    80 Security Apps
    Free Console Apps
    14 Multimedia
    'Free' Proprietary
    21 Closed-Source Apps
    Top Commercial Apps
    42 Games
    Free Web Software
    21 Web CMS
    14 Wiki Engines
    8 Blog Apps
    6 eCommerce Apps
    Other Articles
    Migrating from Windows
    Distribution Guide
    Distro Portal Pages

    Migrate to Linux
    Thinking of switching to Linux? Check out our Linux Equivalents to Windows Software section, highlighting popular Linux equivalents to Windows software.

    This feature also includes over 150 individual software portal pages including Blender, Scribus,, Evolution, Eclipse, K3b, and MythTV, providing a wealth of essential information.


    Distribution Guides
    Distro Guide


    Linux Mint
    64 Studio

    Berry Linux

    Entire List


    Web Calendar
    Linux Licenses

    Advertise at


    Latest Portal Pages


    Add Link | Modify Link | About | FAQ | Guide | Privacy | Awards | Contact |
    Portal Version 0.7. Intel Blade.
    Comments to the webmaster are welcome.
    Copyright 2009 All rights reserved.