[[Interface::command-line]]

BlueZ

The Bluetooth wireless technology is a worldwide specification for a small-form factor, low-cost radio solution that provides links between mobile computers, mobile phones, other portable handheld devices, and connectivity to the Internet. The specification is developed, published and promoted by the Bluetooth Special Interest Group. BlueZ provides support for the core Bluetooth layers and protocols. It is flexible, efficient and uses a modular implementation. It has many interesting features:

Complete modular implementation
Symmetric multi processing safe
Multithreaded data processing
Support for multiple Bluetooth devices
Real hardware abstraction
Standard socket interface to all layers
Device and service level security support

Currently BlueZ consists of many separate modules:

Bluetooth kernel subsystem core
L2CAP and SCO audio kernel layers
RFCOMM, BNEP, CMTP and HIDP kernel implementations
HCI UART, USB, PCMCIA and virtual device drivers
General Bluetooth and SDP libraries and daemons
Configuration and testing utilities
Protocol decoding and analysis tools

Boa: A high-performance Web server for UNIX-like computers

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.

Bogofilter: Bogofilter is a Bayesian spam filter. It takes an email message or other text on standard input, does a statistical check against lists of "good" and "bad" words, and returns a status code indicating whether or not the message is spam. It is designed with fast algorithms (including Berkeley DB system), and tuned for speed, so it can be used for production by sites that process a lot of mail.

Bonddb: 'bonddb' is an object orientated wrapper for PostgreSQL. It's a fast data abstraction layer C/C++ applications, to allow easy access to class objects. You can use existing PostgreSQL databases without any modification or additional tables needed in the backend. "bonddb' easily modifies rows in database fields without you having to construct sql statements or worry about refreshing existing datasets. It also lets you easily map your tables together in object to object relationships. Method calls aren't supported yet but they are being worked on.

Bonsai Ruby: Bonsai builds dynamic web sites that run anywhere. Perfect for portfolios, catalogues and other image-heavy sites. ThereÃ¢â¬â¢s no database or admin interface - just templates for the HTML, YML files for the content, and the file system defines the hierarchy. Upload the results and youÃ¢â¬â¢re away. ItÃ¢â¬â¢s not aimed at blogs or text-heavy sites, but those where simple, well-defined hierarchies are the focus. Bonsai is designed to keep a clear separation between content and templates, following best web practices. It has been built with an emphasis on simplicity of use.

Booh: It takes one or several series of photos and videos, and automatically builds static Web pages to browse them, creating thumbnails, etc. It features automatic rotation of portrait images, support for videos, preloading, sub-albums support, themability, a powerful GUI for editing, and more.

Bookland.py: Bookland is a Python program that generates ISBN bar code symbols (Bookland EAN-13 + 5-digit add-on) in EPS format. Includes UPC-A and EAN-13 classes, so it may be useful in a broader context. You can create a bar code even withou the full ISBN number as bookland will calculate the check digit for you. The program also creates the EAN13 number and check digit and determines the parity patterns and bit encodings.

Bool: Bool is a utility for finding files that match a boolean expression. It supports AND, OR and NOT as well as the NEAR operator for locating two expressions within a short distance from each other. The program has separate text processing and HTML processing algorithms; the former separates patterns separated by newlines or words separated by hyphens. The latter understands many features of the HTML 4.01 standard.

Bootstrapper: The bootstrapper program creates a customized bootstrap script by scanning the autoconf macros in a project's configure.in file and using them to determine which programs need to be used to create a usable configure script. It then creates a bootstrap script which is custom tailored to your project's configuration. The resulting bootstrap script is useful for rebuilding the configure script and Makefile.in files, particularly for a project which may be downloaded off of a cvs server. By including a bootstrap script in a cvs repository, all auto generated files related to configure can be excluded from the cvs repository. It is also useful for a developer importing a new project onto a cvs repository. Running `make distclean' then `./bootstrap --clean' removes all auto-generated files, instead of removing them by hand.

Bosh: bosh takes the output of the specified command and displays it using a simple ncurses interface. Actions can be configured and run using the currently selected line of the output as part of the action. An example is to use ps as the main command and kill as an action. Then, using bosh, the ps output can be browsed to find a particular process, which is then killed.

Botec: BOTEC is a simple astrophysical and orbital mechanics calculator, including a database of all named Solar System objects. BOTEC is intended as a simple but useful calculator to assist with making astrophysical, orbital mechanics, and space navigation calculations. As the origin of the acronym applies, BOTEC is more of a "back-of-the-envelope calculator" rather than an industrial-strength calculator, although this may change in the future.

Bots

Bots EDI-connects your company with your EDI trading partners. EDI is the exchange of electronic business data between companies. Bots takes care of all the needed communications, translations, protocols and standards.
Examples of EDI:

Retail: a buyer orders every day by EDI. The supplier send invoices to this retailer by EDI.
Automotive: just-in-time deliveries are send to the suppliers.

Bottle: Bottle is a fast and simple WSGI web-framework for Python packed into a single file with no external dependencies.

Brag: Brag collects and assembles multipart binary attachements from newsgroups. It is best suited to run as a cron job. It supports for uuencode, MIME base64, and yenc encodings, NNTP authentication, non-default NNTP ports, and message filtering with accept/reject patterns. It can combine parts from different newsgroups or even different servers, and optionally saves message subjects.

Bras: Bras is a rules-based command execution system, a la 'make'. It helps to keep targets (usually, but not neccessarily, files) , up-to-date with respect to a set of dependencies. For every target, a (freely definable) rule describes what it means for the target to be out-of-date and what has to be done to refresh it. Bras can follow targets into other directories. It acts there according to the local brasfile to update the target and then reports the result back. Because no recursive execution of bras is necessary, the result of the reasoning for that other directory is not lost. Bras is implemented in Tcl. Rules can be mixed with procedural parts. In particular control structures can be used to automatically collect lists of targets, find out platform specifics or selectively activate rules. 'Bras' normally runs from the command line, but its rule eveluation functionality is available as a TCL module and can be used in a GUI application implemented in Tcl/tk.

Braze: Braze is a program for managing ALSA MIDI connections. It evaluates a Lua script and reconfigures the ALSA MIDI connections based on actions taken by the script. It can also listen for changes to the ALSA MIDI ports and reconfigure the connections accordingly.

Breeze: 'breeze' aims to be a fast and powerful CD Digital-Audio Player. It may run as either a console app or as a daemon. It can control a cdrom that is playing live, can change track to the next or previous one, jcan jump backward or forward, and set a playlist and your information about cdda.

Brinance: 'Brinance' is a financial planning and tracking program, hoping to be a functional replacement for something more complicated like GnuCash for those who prefer the command line. It has a few advanced features, such as scheduling transactions in the future and having as many accounts as one might want.

Broadband-usage: This software meters the traffic on an SNMP-enabled broadband modem/router and then lets you find out your usage by calendar month. It's main purpose is to let you know what your usage is without having to resort to your ISP's website and without having to trust their accounting. If they get their accounting wrong (which can happen), this software gives you data that you might be able to use when contesting the invoice.

Brother ql: brother_ql is a software package to facilitate printing labels on Brother’s QL-Series label printers. It was designed to be used from the command line but also supports usage from other software packages (via its command line interface or via its Python API).

Bugs

BUGS is the Big and Useful Great Security key encryption algorithm and applications. It is easy to use, and includes sample applications and documentation. The cryptography library can also be used with your own programs. Features include:

Private key algorithm
Dynamic cryptography algorithm
Source code can be made public without making the algorithm weak
Infinite key lengths
Bilateral bits swwapping with various windows
Bilateral Pseudo randomly binary operations
Random number added to key
Random number generator using the ISAAC algorithm
Possibility of generating your own RNG seed
Five different cryptography levels, for the best possible
combination of efficiency and speed
Seed and shuffle functions
A clear text can be crypted using its own data
Two methods of execution: direct disk access or memory cache
Strong key generator

Buildtool: Buildtool is a set of integrated utilities which make programs more portable and easier to build on any kind of *nix-like system. It simplifies the build process of a program from user's point of view, by automatically configuring the source code with specific details of the host system; it also makes developer's work easier because all Makefile complexity is hidden and behavior is homogenized.

Buku: buku is a powerful bookmark management utility written in Python3 and SQLite3. It is a cmdline solution with a private, portable, merge-able database and browser integration. buku fetches the title of a bookmarked web page and stores it along with any additional comments and tags. With multiple options to search bookmarks, including regex and a deep scan mode (particularly for URLs), finding a bookmark is very easy. Multiple search results can be opened in the browser at once. Though a terminal utility, it's possible to add bookmarks to buku without touching the terminal! Refer to the documentation on GUI integration. If you prefer the terminal, thanks to the shell completion scripts, you don't need to memorize any of the options. There's an Easter egg to revisit random forgotten bookmarks too. buku is too busy to track you - no history, obsolete records, usage analytics or homing.

Bulldog Firewall: This is a candidate for deletion: URLs on this page do not work. I could not find "Bulldog Firewall" anywhere online. Drw (talk) 09:00, 18 July 2018 (EDT) 'Bulldog' is a powerful but lightweight firewall for heavy use systems. It allows dynamic and static rules sets for maximum protection and has several advanced features. Be prepared to spend some time setting this up. If you are looking for a "quick fix", then you are on the wrong site. BullDog is NOT a quick fix, but rather one step in a complete security policy.

Bundler: Bundler is a tool that manages gem dependencies for your ruby application. It takes a gem manifest file and is able to fetch, download, and install the gems and all child dependencies specified in this manifest. It can manage any update to the gem manifest file and update the bundled gems accordingly. It also lets you run any ruby code in context of the bundled gem environment.

Bunny the Fuzzer: * " IMPORTANT: This project (Bunny the Fuzzer) is superseded by American Fuzzy Lop " A closed loop, high-performance, general purpose protocol-blind fuzzer for C programs. Uses compiler-level integration to seamlessly inject precise and reliable instrumentation hooks into the traced program. These hooks enable the fuzzer to receive real-time feedback on changes to the function call path, call parameters, and return values in response to variations in input data. This architecture makes it possible to significantly improve the coverage of the testing process without a noticeable performance impact usually associated with other attempts to peek into run-time internals. Bunny is currently known to support GNU/Linux, FreeBSD, OpenBSD, and Cygwin on IA32 and IA64 systems.

Bup: 'bup' is a patch for bash that modifies the shell to send all user keystrokes via UDP over the network for collection by a sniffer or a syslogd server. It does not depend on syslogd to send the packets.

Burn: ‘burn’ is a command-line tool to create audio discs from MP3, Ogg Vorbis, or WAV files, to backup data files, to create discs from ISO-9660 images, and to copy discs on-the-fly. It performs any of its functions in a single command, without requiring preparatory filesystem creation, etc. The program can compute if there is necessary free space for temporary files (images and audio files), warn if size is bigger than disc capacity, and manage multisession discs.

BurnCDDA: 'burnCDDA' is a console frontend to cdrdao, cdrecord, mpg123, oggdec, mppdec, normalize, and mp3_check. It can be used to create audio CDs from an M3U playlist (the playlist format of XMMS). It supports MP3, OGG Vorbis, Musepack, and WAV files, and it might be the easiest way to copy an audio CD.

Burncenter: This is a candidate for deletion: Unclear licensing, potentially non-free. Source code files do not mention GPL in their headers, just state "Copyright(c) 2000-2005 Alexandre Janon". A copy of the GPLv2 is included with the program. Majority of links on the project's website return 404. Drw (talk) 09:26, 18 July 2018 (EDT) 'burncenter' is a very easy-to-use text-based interface to the standard CD-burning tools for UNIX (cdrecord, cdda2wav, and mkisofs). It features an easy-to-use text interface, multi-session support, audio CD support, and CDRW support with fast and complete blanking.

Business Integration Engine: BIE is an free software integration system that makes it easy for organizations to exchange data with external trading partners regardless of their native applications. It is truly cross-platform since it written in Java.

Bustd

* Features

Insignificant memory usage!

bustd seems to use less memory than some other lean daemons such as earlyoom.

Also quite insignificant CPU usage

Much like earlyoom and nohang, bustd uses adaptive sleep times during its memory polling. Unlike these two, however, bustd does not read from /proc/meminfo, instead opting for the sysinfo syscall. This approach has its up- and downsides. The amount of free RAM that sysinfo reads does not account for cached memory, while MemAvailable in /proc/meminfo does. The sysinfo syscall is one order of magnitude faster, at least according to this kernel patch: https://sourceware.org/legacy-ml/libc-alpha/2015-08/msg00512.html (granted, from 2015). As bustd can't solely rely on the free RAM readings of sysinfo, we check for memory stress through Pressure Stall Information.

bustd locks all pages mapped into its address space

Much like earlyoom, bustd uses mlockall to avoid being sent to swap, which allows the daemon to remain responsive even when the system memory is under heavy load and susceptible to thrashing.

Checks for Pressure Stall Information

The Linux kernel, since version 4.20 (and built with CONFIG_PSI=y), presents canonical new pressure metrics for memory, CPU, and IO. In the words of Facebook Incubator:

PSI stats are like barometers that provide fair warning of impending resource

shortages, enabling you to take more proactive, granular, and nuanced steps

when resources start becoming scarce.

More specifically, bustd checks for how long, in microseconds, processes have stalled in the last 10 seconds. By default, bustd will kill a process when processes have stalled for 25 microseconds in the last ten seconds.

Busted: Busted is a tool for gathering and reporting information about a broken gem.

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.

Busynode: This is a candidate for deletion: Marked as decommissioned. Drw (talk) 09:01, 18 July 2018 (EDT) 'busynode' is a simple host reservation system, primarily designed for cluster installations. It lets users communicate with others on what hosts they currently use, or plan to use in the near future. Reservation information is stored as text files on a shared filesystem (such as an NFS mount). When executed without any options, busynode behaves as an enhanced ruptime tool.

ByteName: For each byte of the input ByteName prints a line consisting of the byte offset, the byte in hex, octal, binary, and decimal, and its description in a selected single-byte encoding. A command line flag suppresses printing of lines corresponding to ASCII characters, which is useful for locating stray non-ASCII codes. It can also generate a chart for a specified encoding or, for a specified codepoint, generate descriptions in all known encodings. More than 50 encodings are supported.

C ElementTree: * " cElementTree is included with Python 2.5 and later, as xml.etree.cElementTree. " The cElementTree module is a C implementation of the ElementTree API, optimized for fast parsing and low memory use. On typical documents, cElementTree is 15-20 times faster than the Python version of ElementTree, and uses 2-5 times less memory. On modern hardware, that means that documents in the 50-100 megabyte range can be manipulated in memory, and that documents in the 0-1 megabyte range load in zero time (0.0 seconds). This allows you to drastically simplify many kinds of XML applications.

C to C++ converter: This packages is a set of Python scripts that perform each stage of code conversion from C to C++. First, header files are converted into classes and declarations become members. Then, references to variables and functions are transformed into references to attributes and methods of classes. Additional tools provided include a generator/updater of header files, and a trans-directory mover with update of include statements.

C2hs: 'c2hs' is an interface generator that simplifies the development of Haskell bindings to C libraries. It processes existing C header files that determine data layout and function signatures on the C side in conjunction with Haskell modules that specify Haskell-side type signatures and marshaling details. Hooks embedded in the Haskell code signal access to C structures and functions; they are expanded by the interfacing tool in dependence on information from the corresponding C header file.

C2html: 'C2html' is a program which converts C source files to highlighted html files. The produced file can be used for creating technical manuals. A highlighted source code listing is usually much easier to read.

CAGE: A generic and fairly complete cellular automata simulation engine. CAGE is a fairy generic and complete cellular automaton simulation engine in Python. It supports both 1D and 2D automata, a variety of prepackaged rules, and the concept of "agents" which can move about independently on the map for implementing agent behavior. CAGE comes with numerous examples of fully-functional CA systems, including Conway's Game of Life, Langton's self-reproducing automaton, Langton's "vants," and 1D automata rule explorers. It also comes with simple displayers (including a curses interface for 2D automata). Also included is a unique implementation of a finite state machine (ant.py).

CDimgtools: CDimg tools is a set of command line tools to manipulate CD/DVD images of certain formats.

CGI UTILS: CGI_UTILS is a set of three C++ classes: CGI, Template, and Session. CGI wraps the CGI protocol. Template provides an easy way to use templates in your CGI applications. It knows about variables and datasets (tables). Session provides the ability to pass data between your programs through shared memory.

CGKit (Python Computer Graphics Kit): The Python Computer Graphics Kit is a collection of Python modules that contain the basic types and functions to be able to create 3D computer graphics images (focusing on Pixar's RenderMan interface).

CI Joe: CI Joe is a Continuous Integration server that'll run your tests on demand and report their pass/fail status. Because knowing is half the battle.

CLHep: 'CLHelp' is a set of HEP (High Energy Physics)-specific foundation and utility classes such as random generators, physics vectors, geometry, and linear algebra.

CMUCL: CMUCL is a free, high performance implementation of the Common Lisp programming language which runs on most major Unix platforms. It mainly conforms to the ANSI Common Lisp standard. CMUCL provides a sophisticated native code compiler; a powerful foreign function interface; an implementation of CLOS, the Common Lisp Object System; which includes multimethods and a metaobject protocol; a source-level debugger and code profiler; and an Emacs-like editor implemented in Common Lisp.

CMUSphinx- PocketSphinx: Sphinx is a speaker-independent large vocabulary continuous speech recognizer. It is also a collection of free software tools and resources that allows researchers and developers to build speech recognition systems. The packages that the CMU Sphinx Group is releasing are a set of reasonably mature, world-class speech components that provide a basic level of technology to anyone interested in creating speech-using applications without the once-prohibitive initial investment cost in research and development; the same components are open to peer review by all researchers in the field, and are used for linguistic research as well. PocketSphinx is CMU's fastest speech recognition system. It uses Hidden Markov Models (HMM) with semi-continuous output probability density functions (PDF). Even though it is not as accurate as Sphinx-3 or Sphinx-4, it runs at real time, and therefore it is a good choice for live applications. You can find further documentation about PocketSphinx in the release documentation, or at the online documentation.

CMUSphinx- Training: Sphinx is a speaker-independent large vocabulary continuous speech recognizer. It is also a collection of free software tools and resources that allows researchers and developers to build speech recognition systems. The packages that the CMU Sphinx Group is releasing are a set of reasonably mature, world-class speech components that provide a basic level of technology to anyone interested in creating speech-using applications without the once-prohibitive initial investment cost in research and development; the same components are open to peer review by all researchers in the field, and are used for linguistic research as well. SphinxTrain is CMU Sphinx's training package. It trains models in Sphinx-3 format, which is also used by PocketSphinx. The Sphinx-2 format can also be converted to Sphinx-2 format under some conditions related to Sphinx-2's limitations. At this point, Sphinx-4 uses Sphinx-3 models.

CMUSphinx2: Sphinx is a speaker-independent large vocabulary continuous speech recognizer. It is also a collection of free software tools and resources that allows researchers and developers to build speech recognition systems. The packages that the CMU Sphinx Group is releasing are a set of reasonably mature, world-class speech components that provide a basic level of technology to anyone interested in creating speech-using applications without the once-prohibitive initial investment cost in research and development; the same components are open to peer review by all researchers in the field, and are used for linguistic research as well. Sphinx-2 is a fast speech recognition system, the predecessor of PocketSphinx. It is not being actively developed at this time, but is still widely used in interactive applications. It uses Hidden Markov Models (HMM) with semi-continuous output probability density functions (PDF). Even though it is not as accurate as Sphinx-3 or Sphinx-4, it runs at real time, and therefore it is a good choice for live applications. You can find further documentation about Sphinx-2 in the release documentation, or at the online documentation.

CMUSphinx3: Sphinx is a speaker-independent large vocabulary continuous speech recognizer. It is also a collection of free software tools and resources that allows researchers and developers to build speech recognition systems. The packages that the CMU Sphinx Group is releasing are a set of reasonably mature, world-class speech components that provide a basic level of technology to anyone interested in creating speech-using applications without the once-prohibitive initial investment cost in research and development; the same components are open to peer review by all researchers in the field, and are used for linguistic research as well. Sphinx-3 is CMU's state-of-the-art large vocabulary speech recognition system. It uses Hidden Markov Models (HMM) with continuous output probability density functions (PDF). It supports several modes of operation. The more accurate mode, known as the "flat decoder", is descended from the original Sphinx-3 release (still available for reference purposes at https://cmusphinx.svn.sourceforge.net/svnroot/cmusphinx/trunk/archive_s3/s3). The faster mode, known as the "tree decoder", was developed separately. The two decoders were merged in Sphinx 3.5, though the flat decoder was not fully functional until Sphinx 3.7. Further documentation can be found in the release documentation, or at the online documentation.

CMake: CMake is a cross-platform build system. It is used to control the software compilation process using simple platform and compiler independent configuration files. It generates native Makefiles and workspaces that can be used in the compiler environment of your choice. CMake is quite sophisticated: it is possible to support complex environments requiring system configuration, pre-processor generation, and code generation.

CP: Cerebral Procreation: CP (Cerebral Procreation) is a BF (BrainF***) interpreter and compiler. It is different from other compilers in that instead of trying to understand the BF code, it simply transfers it to Perl code, which it then evaluates using the handy eval() function. It can also translate to C code, for easy compilation into a stand-alone binary.

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.

CRM114: 'CRM114' is a Controllable Regex Mutilator and Smart Filter, designed for easy creation of filters for things like incoming email redirection, spam filtering, system logs, or monitoring processes. Filtering rules can be either hard-coded (such as regexes), soft-coded (calculated at runtime or read from an external file or process), or learned dynamically by phrase matching (by SBPH hashing). This makes it possible to create very accurate filters over (99.9%) with very little actual work.

CSS-parser: Load, parse and cascade CSS rule sets in Ruby.

CSSPool: CSSPool is a CSS parser. CSSPool provides a SAC interface for parsing CSS as well as a document oriented interface for parsing CSS.

CT Sim: Computed Tomography is the technique of estimating the interior of objects from the measurements of radiation projected through the object. That radiation can be transmitted through the object such as in X-ray computed tomography or emitted from internal radiation sources as in nuclear medicine scans. CTSim simulates the transmission of X-rays through phantom objects. These X-ray data are called projections; CTSim reconstructs the original phantom image from the projections using a variety of algorithms. The program also has a wide array of image analysis and image processing functions.

CUPS: CUPS is a printing system that uses the Internet Printing Protocol (IPP). It provides System V and BSD command-line interfaces, as well as a Web interface and a C programming interface to manage printers and print jobs. It supports printing to both local (parallel, serial, USB) and networked printers, and printers can be shared from one computer to another. Internally, CUPS uses PostScript Printer Description (PPD) files to describe printer capabilities and features and a wide variety of generic and device-specific programs to convert and print many types of files.

CVSGraph: CvsGraph is a utility to make a graphical representation of all revisions and branches of a file in a CVS/RCS repository.

CVSTrac: CVSTrac implements a low-ceremony Web-based bug and patch-set tracking system for use with CVS. Features include automatic changelog generation, repository change history browsing, user-defined bug database queries, Wiki pages, and Web-based administration of the CVSROOT/passwd file. CVSTrac operates either as CGI or as its own Web server. It automatically generates a patch-set log from CVS check-in comments, and includes a built-in repository browser. It is simple to setup and has minimal memory, disk and CPU requirements, so it runs effectively on old hardware. Access permissions are separately configurable for each user, and anonymous users are allowed. Since the program uses a built-in SQL database engine (SQLite), no external RDBMS is required.

CVSps: CVSps is a program for generating 'patchset' information from a CVS repository. A patchset is defined as a set of changes made to a collection of files, and all committed at the same time (using a single 'cvs commit' command). This helps you see the big picture of the evolution of a cvs project. You can see the history of committed patchsets, restrict by author, date range, files affected, branches affected. The program can also generate a diff of a given patchset. It essentially gives you the equivalent of tagging before and after each commit.

CaSchd: a Ruby network manager.

Cache Money: A Write-Through Cacheing Library for ActiveRecord.

CacheIt: This is a candidate for deletion: I cannot confirm any facts about this project. The URLs on this page link to web pages which do not work without running JavaScript which does not have any licence notice. I have been unable to download the program, suggesting it might be dead. Drw (talk) 09:37, 18 July 2018 (EDT) CacheIt is a PHP class to facilitate caching. You subclass Cachable and implement the get method of Cachable, and you instantiate it as well as instantiate CacheIt with arguments of the instance of your subclass of Cachable. Then both the path (ending in a trailing slash) to the directory that cached data will be kept, and the number of seconds that a cached entry can be kept before expiring. Then, just call the get method of the instance of CacheIt and caching happens automatically. CacheIt doesn't do LRU--if you're concerned about the cache directory getting too large, have a cron job scan it occasionally and delete the oldest files.

Cachet: Cachet is an HTTP Reverse Cache Proxy written in Scala. It is comparable to Varnish or Rack::Cache. It implements the RFC2616 specification (at this time, only the Expiration model, but the Validation model is forthcoming) obeying Cache-Control headers and the like. It is very configurable so that you can use custom databases (Ehcache and Memcached are supported by default), and custom expiry strategies, and so on. It is designed so that you can layer on things like authentication, authorization, rate limiting, and arbitrary service composition strategies (e.g., Edge-Side Includes)--which is is, I think, something novel in a free reverse proxy.

Cachy

Caching library to simplify and organize caching.

I18n (seperate caches by locale / expires all locales)
Generation based (your able expire all caches of one type)
Simultanouse caching (handle multiple processes trying to write same expensive cache at once)
Dependent caches (x caches result of cache z+y -> z changes -> x changes)
Hashed keys (optional -> short/unreadable)
Global cache_version (expire everything Cachy cached, but not e.g. sessions)
works out of the box with Rails
works with pure Memcache and Moneta(-> Tokyo Cabinet / CouchDB / S3 / Berkeley DB / DataMapper / Memory store)

Cadaver: 'cadaver' is a command-line WebDAV client. It supports resource upload/download/display, namespace operations (copy/move), collection deletion/creation, property manipulation, and locking operations.

Cage: cage is a replacement for the chroot(8) utility. Like chroot, cage changes its root directory to the one specified and then executes your application. Before execing, however, cage drops all privileges that would let the program escape its jail.

Calamaris: Calamaris parses the logfiles of a variety of Web proxy servers (see the program's home page for a list of supported servers) and generates reports about peak-usage, request-methods, status-report of incoming and outgoing requests, second and top-level destinations, content-types, and performance.

Calcurse: Calcurse is a text-based personal organizer which helps keep track of events and everyday tasks. It has a calendar and a "todo" list, and puts your appointments in order. The user interface is configurable, and you can choose between different color schemes and layouts. All of the commands are documented within an online help system.

Calendar Maker: Rails plugin to build a simple calendar scaffold, with events signified by class names added to the day. Putting a calendar on a web page is easy now. Also, you can add events to a calendar, which are denoted by adding a custom class name to that day, allowing you to style it differently, or even define behavior for that day via unobtrusive Javascript.

Calibre: Calibre is an e-book manager that can view, convert, edit and catalog e-books in all of the major e-book formats. It's a complete e-library solution that includes library management, e-book format conversion, newsfeed to e-book conversion, integrated e-book viewer, and synchronization with e-reader devices.

Callgraph: A tool for printing call graphs.

Calltree: 'calltree' is a static call tree generator for C programs. It parses a collection of input files and builds a graph that represents the static call structure of the files.

Cals2tiff: This is a candidate for deletion: URLs both lead to 404. sollers.ca does exist, but no mention of cals2tiff on that site. Drw (talk) 09:02, 18 July 2018 (EDT) This program is used to convert .cal files (US NAVY CALS raster file Type 1) into .tiff files (baseline TIFF bilevel images). All it really does is change the header. CALS only support compressed data, and only through CCITT group 4 algorithm (T6). Tiff revision 6.0 can support this same compression schem (among others), and therefore there is no need to change the data to convert from one format to the other.

Camorama: Camorama is a small utility to view and save images from a webcam or any other Video4Linux device. It can apply a number of image filters and make remote captures.

Cancan: CanCan is an authorization solution for Ruby on Rails. This restricts what a given user is allowed to access throughout the application. It is completely decoupled from any role based implementation and focuses on keeping permission logic in a single location (the Ability class) so it is not duplicated across controllers, views, and database queries. This assumes you already have authentication (such as Authlogic or Devise) that provides a current_user method which CanCan relies on. See Changing Defaults if you need different behavior.

Candela: Candela is a simple shell-building system that uses python and curses to help developers create customized command line interfaces. It has a simple interface, is well documented, and allows developers to take command-based tools to the next level of complexity and usability. Features Commands are 100% python and can run aribtrary code Commands can run code in secondary threads for asynchronous operation Customizable tab completion hooks for command arguments Customizable key event callbacks for reacting to each keypress event Responsive layout for smaller terminals Numerous built-in command templates Simple command syntax and help system "stickers" allow persistent information display Automatically generated command validation Up/Down arrows cycle through history Copy/Paste, insert text mode Easy transitions between menus Supports both named and positional command arguments

Candygram: Candygram is a Python implementation of Erlang concurrency primitives. This package emulates those facilities as closely as possible in Python. It lets developers send and receive messages between threads using semantics nearly identical to those in the Erlang language, which is widely respected for its elegant built-in facilities for concurrent programming.

Capybara: Capybara aims to simplify the process of integration testing Rack applications, such as Rails, Sinatra or Merb. It is inspired by and aims to replace Webrat as a DSL for interacting with a webapplication. It is agnostic about the driver running your tests and currently comes bundled with rack-test, Culerity, Celerity and Selenium support built in.

Carp-Clan: 'Carp::Clan' reports errors from the perspective of the caller of a "clan" of modules, similar to "Carp.pm" itself. But instead of giving it a number of levels to skip on the calling stack, you give it a pattern to characterize the package names of the "clan" of modules which will never be blamed for any error. So these modules stick together like a "clan"; any error will be blamed on the "outsider" script or modules not belonging to the "clan".

Carrot: carrot is an AMQP messaging queue framework. AMQP is the Advanced Message Queuing Protocol, an open standard protocol for message orientation, queuing, routing, reliability and security. The aim of carrot is to make messaging in Python as easy as possible by providing a high-level interface for producing and consuming messages. At the same time it is a goal to re-use what is already available as much as possible. carrot has pluggable messaging back-ends, so it is possible to support several messaging systems. At the time of release, the py-amqplib based backend is considered suitable for production use. Several AMQP message broker implementations exists, including RabbitMQ, ZeroMQ and Apache ActiveMQ. You'll need to have one of these installed, personally we've been using RabbitMQ. Before you start playing with carrot, you should probably read up on AMQP, and you could start with the excellent article about using RabbitMQ under Python, Rabbits and warrens. For more detailed information, you can refer to the Wikipedia article about AMQP.

Caspar: 'Caspar' offers Makefile snippets for tasks like installing files maintained using a version control system, or typesetting documents in certain markup languages. If you need to maintain and distribute lots of files, you will probably find 'Caspar' useful. It can also automate typesetting if you write documents in a markup language like LaTeX, DocBook XML, DocBook SGML or POD.

Castget: castget is a simple, command line-based RSS enclosure downloader. It is primarily intended for automatic, unattended downloading of podcasts.

Castle Game Engine: Castle Game Engine is a cross-platform 3D and 2D game engine for Object Pascal (FPC and Lazarus). - It supports many formats for game assets, including X3D, VRML, Collada, Spine JSON, MD3 and others. - Many graphic effects are possible, including bump mapping, shadows, shaders, mirrors, screen effects. - Animation, collision detection, 3D sound and more features are available. - An extensible system of 3D objects can be used, with out-of-the-box levels, items, intelligent creatures and more. - The engine is portable -- for desktop, mobile, web plugin. The engine is also used to develop view3dscene - a full-featured X3D / VRML browser and a viewer for many other 3D and 2D game formats.

Cat IMproved: Cat IMproved is an improved version of the UNIX program cat.

Catase: Catase is a catalog server which serves documents in response to queries. The queries can contain thematic, temporal, and spatial (geometry) constraints. It uses OGC standards. The documents are currently ISO 19115 in XML and the query language is CQL.

Catdoc: The program extracts text from Word files while preserving as many special characters as possible. It does not try to preserve Word formatting, but does extract readable text. A Tcl/Tk graphical viewer is included as well, and versions 0.91.2 and above include an Excel file converter.

CbMySQL: 'cbMySQL' is a PHP class for creating, modifying MySQL databases and tables. For backup issues, you can export CSV data directly with only one class method. The MySQL object is easier to handle than PHP's built in functions, and you need not install anything like PEAR.

Ccache: Ccache is a compiler cache. It speeds up recompilation by caching previous compilations and detecting when the same compilation is being done again.

Ccbuild: 'ccbuild' is like a dynamic Makefile: it finds all programs in the current directory (containing "int main") and compiles them. To do this, it reads the C++ sources and looks at all local and global includes. All C++ files around local includes are considered objects for the main program. The global includes lead to extra compiler arguments using a configuration file. ccbuild splits these arguments for compilation and linking, keeping the linking arguments back for later use. It should allow development without any scripting and only simple reusable configuration. 'ccbuild' can also create simple Makefiles and graph dependencies using DOT (graphviz) graphs.

Ccd2cue: The program ccd2cue is a CCD sheet to CUE sheet converter for the GNU Operating System. It supports the full extent of CUE sheet format expressiveness, including mixed-mode discs and CD-Text meta-data. It plays an important role for those who need to use optical disc data which is only available in the proprietary sheet format CCD, but don’t want to surrender their freedom. It fills an important gap in the free software world because before its conception it was impossible to use complex forms of optical disc data laid out by CCD sheets in a whole/holy free operating system.

Ccollect: ccollect does (pseudo) incremental full backups with different exclude lists, using hard links and rsync.

Ccrtp: GNU ccRTP is a high performance threadsafe C++ RTP (Real-Time Transport Protocol) stack. It can be used to build both client and server applications for audio and visual conferencing over the Internet, for streaming of realtime data, and for next generation IP based telephony systems.

Ccrypt: 'ccrypt' is a utility for encrypting and decrypting files and streams. It was designed to replace the standard Unix 'crypt' utility, which is notorious for using a very weak encryption algorithm. 'ccrypt' is based on the Rijndael cipher, which is the U.S. government's chosen candidate for the Advanced Encryption Standard (AES). This cipher is believed to provide very strong security. Unlike unix crypt, the algorithm provided by ccrypt is not symmetric (one must specify whether to encrypt or decrypt). Encryption and decryption depend on a user-supplied keyword (key phrase). Keywords can be any number of characters; all characters are significant (although ccrypt internally hashes the key to 256 bits). Longer keywords provide better security, since they are less likely to be discovered by exhaustive search.

Ccscript: GNU ccScript is a C++ class framework for creating a virtual machine execution system for use with and as a scripting/assembler language for state-transition driven realtime systems. It is the core of the scripting engine found in GNU Bayonne. It is meant to be used where step execution is important, and where each step is in response to a callback event or a state machine transition. It offers deterministic execution and low overhead so that many concurrent instances can run together. However, in addition to offering step machine execution, GNU ccScript loads all scripts into an active image at once. This is for performance, as all operations in the script system, to assure deterministic execution, are in memory. GNU ccScript also offers the ability to load new scripts en masse. Existing active sessions operate on the currently loaded scripts, and new sessions are offered the new script. When the last active session on an old script set completes, the entire script set is flushed from memory, so you can operate scripted servers without downtime for rebuilding script images in memory.

Ccvssh: 'ccvssh' is an external program called by cvs (via the :ext: method) which connects to remote CVS pservers through an SSL connection to a stunnel daemon. It is a reimplementation of 'cvssh' in C, and is fast and easy to use.

Cdargs: 'cdargs' adds a bookmark feature and a simple filebrowser to the builtin shell command `cd'. This lets you jump to various places throughout the filesystem with just a few keystrokes. It is intended for heavy shell users.

Cdcd: cdcd is a CLI CD player designed to incorporate all the features of the X and curses based CD players without having to use a clunky push button interface or having a console hogged with a curses-based CD player. cdcd can accept commands directly from the command line, or in a query mode similar to telnet or ftp. CDDBP and HTTP mode CDDB support is inlcuded, and now CD Index support as well. cdcd also supports CD-ROM changers on GNU/Linux 2.1 or 2.2 systems. You can run cdcd with a command as the argument (eg cdcd play), which is a great way to use cdcd and cron together to make a CD alarm clock. If you run cdcd without arguments you will be given the cdcd command prompt.

Cdecl: Composing and deciphering C (or C++) declarations or casts, aka ‘‘gibberish.’’

Cdparanoia: Cdparanoia is a Compact Disc Digital Audio (CDDA) extraction tool, commonly known as a 'ripper'. It is built on top of the Paranoia library (included in the cdparanoia source distribution). The cdparanoia package reads audio from the CDROM directly as data, with no analog step between, and writes the data to a file or pipe in WAV, AIFC or raw 16 bit linear PCM. 'cdparanoia' contains few-to-no 'extra' features; it concentrates on the ripping process and knowing as much as possible about the hardware performing it. Cdparanoia will read correct audio data from inexpensive drives prone to misalignment, frame jitter and loss of streaming during atomic reads, and can read and repair data from damaged CDs. It has no compile time configuration, and will autodetect the CDROM, its type, its interface and other aspects of the ripping process at runtime.

Cdrdao: 'cdrdao' creates audio or mixed mode CD-Rs in disk-at-once (DAO) mode driven by a description file. In DAO mode, users can create non standard track pre-gaps with lengths other than 2 seconds and contain nonzero audio data. This lets users divide live recordings into tracks where 2 second gaps would be irritating and create hidden tracks or track intros as found on commercial CDs.

Cdrom: Cdrom is a small/lightweight CD-ROM/DVD-ROM drive controlling utility. It supports several features like automatic mounting/unmounting (if needed), speed control, drive capability, CD status, and more. The author notes that cdrom was programmed under Linux 2.4, and has not been tested with newer kernel versions, including the 2.6 branch.

Cdrtools: !!!WARNING!!!! This download probably has serious licence issues. For saver options look at the details tab. cdrtools (formerly cdrecord) creates home-burned CDs with a CDR/CDRW recorder. It works as a burn engine for several applications. It supports CD recorders from many different vendors; all SCSI-3/mmc- and ATAPI/mmc-compliant drives should also work. Supported features include IDE/ATAPI, parallel port, and SCSI drives, audio CDs, data CDs, and mixed CDs, full multi-session support, CDRWs (rewritable), TAO, DAO, RAW, and human-readable error messages. cdrtools includes remote SCSI support and can access local or remote CD writers.

Cdrtools DVD Extensions: DVD extensions for cdrtools 2.0 is a free software extension to add DVD support to JÃÂ¶rg Schilling's cdrtools package. A patch for cdrtools-2.0 is created and is actually a translation of a patch which can be found on abcpages.com. That patch is based upon cdrtools 1.11. The patch given here is based upon cdrtools-2.00.tar.gz. The objective is to give cdrtools dvd extensions without imposed limits, and also to have a free software solution to burn dvd's. Currently DVD-R(W) support is added.DVD functionality has been expanded with DVD+RW and DVD+R DL burning, with the release of cdrtools-2.01.01a01-ossdvd.patch.bz2.

Cedar Backup: 'Cedar Backup' supports backups of files on local and remote hosts to CD-R or CD-RW media over a secure network connection. It also includes extensions that understand how to back up MySQL databases and Subversion repositories, and can be easily extended to support other data sources. It is focused around weekly backups to a single disc, with the expectation that the disc will be changed or overwritten at the beginning of each week. With appropriate hardware, Cedar Backup can also write multisession discs.

Celebrat: Celebrat is a very easy-to-use, non-interactive, text-mode calendar application. It reads a data file in ASCII format, and prints on stdout a human-language summary of what events will take place up to ten days from now. It also includes a small daemon which announces events that are due by putting a message on every registered terminal, or by integrating the announcement in the bottom line of GNU screen sessions.

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.

Certi: CERTI is an HLA RTI. HLA (High-Level Architecture) is a general purpose architecture for distributed computer simulation systems. In HLA systems, the RTI (RunTime Infrastructure) manages data exchange between simulations. CERTI focuses on HLA 1.3 specification and its C++ API (IEEE 1516 will be supported too).

Cf4ocl

The C Framework for OpenCL, cf4ocl, is a cross-platform pure C object-oriented framework for developing and benchmarking OpenCL projects. It aims to:

Promote the rapid development of OpenCL host programs in C (with support for C++) and avoid the tedious and error-prone boilerplate code usually required.
Assist in the benchmarking of OpenCL events, such as kernel execution and data transfers. Profiling comes for free with cf4ocl.
Simplify the analysis of the OpenCL environment and of kernel requirements.
Allow for all levels of integration with existing OpenCL code: use as much or as few of cf4ocl required for your project, with full access to the underlying OpenCL objects and functions at all times.

Features:

Object-oriented interface to the OpenCL API

* New/destroy functions, no direct memory alloc/free * Easy (and extensible) device selection * Simple event dependency mechanism * User-friendly error management

OpenCL version and platform independent
Integrated profiling
Advanced device query utility
Offline kernel compiler and linker

Cfengine: Intended for sys admins, CFEngine is a tool for setting up and maintaining BSD and System 5-like operating systems optionally attached to a TCP/IP network. The program focuses on a few key areas that scripts tend to mishandle. From a single configuration files (or set of files) you specify, using classes, your network configuration; cfengine then parses the file and carries out the instructions, warning you about errors (or fixing them) as it goes. You can think of cfengine as a very high level language, higher than Perl or shell. A single command can result in many hundreds of operations being performed on multiple hosts. You can also use it as a net-wide front end for 'cron.'

Cfengine (non-GNU): Intended for sys admins, CFEngine is a tool for setting up and maintaining BSD and System 5-like operating systems optionally attached to a TCP/IP network. The program focuses on a few key areas that scripts tend to mishandle. From a single configuration files (or set of files) you specify, using classes, your network configuration; cfengine then parses the file and carries out the instructions, warning you about errors (or fixing them) as it goes. You can think of cfengine as a very high level language, higher than Perl or shell. A single command can result in many hundreds of operations being performed on multiple hosts. You can also use it as a net-wide front end for 'cron.'

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

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

Cfs-el: GNU cfs-el is a frontend for using CFS (Cryptographic File System - wrote by Matt Blaze) from GNU Emacs.

Cfv: 'cfv' both tests and creates .sfv (Simple File Verify), .csv, .crc, .md5(sfv style), md5sum, and BSD md5 checksum verification files. It also includes test-only support for .par and .par2 files. These files are commonly used to ensure the correct retrieval or storage of data.

Cgicc

GNU cgicc is an ANSI C++ compliant class library that greatly simplifies the creation of CGI applications for the World Wide Web by doing the following:

Parses GET and POST form data transparently.
Provides string, integer, floating-point and single- and multiple-choice retrieval methods for form data.
Provides methods for saving and restoring CGI environments to aid in application debugging.
Provides full on-the-fly web-authoring generation capabilities, with support for cookies.
Supports web-authoring file upload.

Chaco: Chaco is a software for partitioning graphs mainly intended for parallel computing and scientific simulations. It implements a set of algorithms for this task ranging from a generalization of KL/FM with weighted graphs support to the premiere multilevel algorithms which combine high quality partitioning schemes and low computational costs.

Chafa: Chafa is a command-line utility that converts all kinds of images, including animated GIFs, into ANSI/Unicode character output that can be displayed in a terminal. It is highly configurable, with support for alpha transparency and multiple color modes and color spaces, combining selectable ranges of Unicode characters to produce the desired output. The core functionality is provided by a C library with a public, well-documented API.

Challis: Challis is a lightweight markup language along the lines of Markdown and Textile. It focuses on a simple implementation while still being friendly to authors.

Change: 'Change' is a non-interactive text editor that is similar to 'sed' but easier to use. It substitutes a specified target pattern in the source text with another specified text pattern. It can operate on multiple files specified on the command line, or on stdin/stdout in filter mode.

Change Suffix: 'chsuf' changes the suffix of file and/or directory names. It also can be used to add or remove a suffix to/from a list of files. chsuf can be useful for changing DOS-style three character extensions to more readable variations (e.g. from .htm to .html), or for adding an extension to filenames for use on platforms which depend on filename extensions.

Changedfiles: 'changedfiles' is a framework for filesystem replication, security monitoring, and/or automatic file transformations--anything where you'd poll files or directories and then do something to them or send them somewhere else (or both). The difference is, the kernel tells you when they change, instead of you having to poll. It is also an easy real time FTP push mirror to one or multiple sites. 'changedfiles' has a kernel module (works with Linux kernel version 2.4) which reports to a device whenever a file on the filesystem changes, and a daemon which runs in user space and can be configured to do almost anything when a change to a file matching one of the patterns it looks for is reported.

Changetrack: Changetrack is a program to monitor changes to system files. If files are modified one day, and the system starts working incorrectly a few days later, changetrack can provide information on which files were modified and help locate the problem. Changetrack will also allow recovery of the files at any stage. Changes to each file can be mailed to a list of email addresses or presented in a Web-based form or as a text file. The program makes human-readable output, and uses RCS to allow recovery of the files from any stage.

Charities.cron: charities.cron is a cron script in the gawk language to visit the charity sites affiliated with thehungersite.com. These sites let Web users donate food, health care, and other goods simply by clicking on a link. The sites generally count one click per IP address per day; by making this a daily cron job, thousands of dollars will be donated to charity each year.

Charlemagne: Charlemagne is a genetic programming application that includes both a commandline client and an interactive console mode. It is written in Python and Lisp, and is user extensible to some degree in both languages. It features built-in input-output mapping support and provides the ability to define complex fitness calculations in Lisp or Python.

Chart: Chart is stock market charting program. It downloads and displays market daily data and current price quotes in various styles and with many standard technical analysis indicators and averages. Data is obtained from several sources, including Barchart and Yahoo Finance (which covers most major world exchanges). Alert levels, notes, and free-form trend lines can be added to charts. Chart is at "personal project" level, which means the features are those things which interest the author, but the aims are serious. Chart is written in GNU Guile and perl, and customizations and extensions can be added using Scheme code. The main interface is the Guile Gtk GUI. An Emacs interface is included too, for viewing price quotes within Emacs, including importing into the Simple Emacs Spreadsheet (and other uses).

Check: Check is a unit test framework for C. It features a simple interface for defining unit tests, putting little in the way of the developer. Tests are run in a separate address space, so Check can catch both assertion failures and code errors that cause segmentation faults or other signals. The output from unit tests can be used within source code editors and IDEs.

Check Postgres: check_postgres is a script for monitoring various attributes of your database. It is designed to work with Nagios, MRTG, or in standalone scripts.

Check modbus: This is Nagios plugin for Modbus TCP and RTU. This checker has many useful features: - support of IPv6 / IPv4 - support of DNS names - serial port connections (RS232 and RS485) with Modbus RTU (when compiled with libmodbus >= 3.0.0) - support of many data formats (unsigned/signed int16_t, int32_t, float, double) - support of several data orders (LSB, MSB and some others) - retries can be sent to get reliable answer - supports performance data - supports creation dump of the registers in different formats (binary, hexadecimal, decimal) - support binary dump as an input source for data (useful for off-line data) - separate lock files for input and output

Check-license: check-license is a license checker application and checks source code files against a database of known licenses. The program can also generate HTML reports of its scans.

CheckInstall: 'CheckInstall' keeps track of all files installed by a "make install" or equivalent, creates a Slackware, RPM, or Debian package with those files, and adds it to the installed packages database, allowing for easy package removal or distribution.

CheckUPS: CheckUPS checks United Parcel Service's Web site (via crontab) for the status of a shipped package. If a package status changes, CheckUPS notifies any email addresses the user supplies (email, ICQ, pager, phone, etc). It logs all status check attempts, results, and the last notice sent out.

Checkaliases: Reads a sendmail aliases file and reports problems in it, such as syntax errors, pipes to missing programs, local users who don't exist, include files that can't be read, files with wrong permissions, duplicate alias names, etc. newaliases.el is GNU Emacs Lisp code to make editing and checking an aliases file easier. It can automatically run checkaliases and newaliases after saving the aliases file.

Checker: Checker is a debugging tool suite which is used to find memory errors at runtime. 'Checker' can help find bugs that standard tools cannot always find. The best example is memory leaks. A memory leak is a zone of memory, allocated with malloc that is not used anymore. So the memory allocated is lost. This means you program needs more memory and runs slower, since your OS might have to start swapping. It detects bad memory accesses such as: reading uninitialized memory, writing in a freed zone, writing or reading outside of a memory block, and using NULL pointers. This is particularly useful for big programs with many functions. Checker maintains bitmaps to keep track of the status of each byte of memory. The status can be writable, readable, both, or none. When memory is allocated, the new memory becomes write-only: you are not allowed to read it because it has not been initialized. But when you you write to this new block, those bytes become readable and writable. When the block is freed, the bytes become unreadable and unwritable. Red zones are unreadable and unwritable memory, so that each access to a red zone produces a warning.

Checkmate: Checkmate checks mp3s. It scans the file to see if the frames are where they are supposed to be, if the frame headers are correct and if the headers are consistent throughout the file. It gives some statistics on the file like bitrate and length, and a conclusion whether the file is good or bad.

Checkstyle: Checkstyle is a development tool to help programmers write Java code that adheres to a coding standard. It automates the process of checking Java code to spare humans this boring (but important) task. This makes it ideal for projects that want to enforce a coding standard. Checkstyle is highly configurable and can be made to support almost any coding standard. An example configuration file is supplied supporting the Sun Code Conventions. As well, other sample configuration files are supplied for other well known conventions. Checkstyle can check many aspects of your source code. Historically it's main functionality has been to check code layout issues, but since the internal architecture was changed in version 3, more and more checks for other purposes have been added. Now Checkstyle provides checks that find class design problems, duplicate code, or bug patterns like double checked locking.

Checksuite: 'checksuite' is a suite of programs that provide notification and assistance with day-to-day system administration tasks. These programs monitor system resources as well as some security aspects on a system. There are several options that can be passed to the command line, and a full listing can be shown by passing a -h to each program.

Checkurls: 'checkurls' is a program to help people who are interested in multiple files on Internet and want to spend less time checking for updates. It takes a list of URLs, downloads the files at these URLs, compares these with the old files, and if something has changed it sends an email to the user with a patch.

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

Chgrep: 'chgrep' searches the input files (or standard input if no files are named) for oldpattern and changes them to newpattern (grep doesn't support this). You can use .lock files (or another extend). It is useful in (but not limited to) mail servers.

Chicago: Chicago is a collection of runtime and test extensions and helpers that makes some common tasks a little bit easier.

Chicken: CHICKEN is a simple Scheme-to-C compiler supporting the language features as defined in the 'Revised^5 Report on Scheme'. It supports full tail-recursion and first-class continuations. The code it generates is quite portable; compiled files generated by it (including itself) should work with either no or minor changes on other systems. Linking to C modules and C library functions is straightforward, and compiled programs can easily be embedded into existing C code. The package includes many extra libraries.

ChkTeX: ChkTeX checks for various syntactic, semantic and typographical errors in LaTeX documents, and helps the writer stay focused on the content rather than presentation or syntax of commands.

Chkrootkit: chkrootkit is a tool to locally check for signs of a rootkit. It contains programs to check for modified system binaries, signs of LKM trojans and more. It currently detects 60 rootkits, worms and LKMs.

Choones: "Choones" is a jQuery plugin, with a little markup and some styles that mimics Growl's "Music video" theme (pop up, from the bottom.) Sending messages back to the user is often something that uses some strange design pattern of adding a box to the top of a page, that pushes down the content or, even worse, thrown into a 'lightbox'. Choones is something that I've implemented a number of times, finally recognising this pattern I thought it was worth sharing.

Choose: Choose is a program that computes permutations and choose functions. It does so quickly and effectively. Choose falls into the category of programs that are simple but are useful and for some reason do not exist.

Chpox: 'chpox' provides transparent checkpointing and restarting of processes on GNU/Linux clusters. It was originally designed for recovery of jobs with a long execution time in case of system crashes, power failures, etc. It works with openMosix, is SMP safe, works as a kernel module, does not require kernel patches or program recompiling/relinking, and supports virtual memory, regular open files, pipes, *nix domain sockets, current directory, termios, and child processes.

Chrootbin: Chrootbin is a tool which will help you make basic a chroot environment. It lets you skip the boring parts of making a chroot from scratch. It also helps you to install any other classic executables like strace or find.

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

Church: This module allows simple experimentation with the lambda calculus, first developed by Church. It understands the different types of lambda expressions, can extract lists of variables (both free and bound) and subterms, and can simplify complicated by expression by means of application.

Cilk: Cilk is designed for general purpose parallel programming, but it is especially effective for exploiting dynamic asynchronous, parallelism. The current release runs on symmetric multiprocessor machines that support Posix threads, GNU make, and gcc. You can also run Cilk on uniprocessor machines, which is useful for development and debugging, although you won't get any parallel speedup. According to cilk, a programmer should structure a program to expose parallelism and exploit locality, leaving the runtime system to schedule the computation to run efficiently. Thus, the runtime system handles details like load balancing, paging, and communication protocols. Unlike other multithreaded languages, however, cilk is algorithmic in that the runtime system guarantees efficient and predictable performance.

Cinelerra: For years some people have wanted a way to edit their audio and video in one place as fluidly as writing text. Cinelerra tries to be a single location for all audio and video editing needs: it can capture composite, and edit audio and video. All the recording, editing, and playback are handled here. It can be used as an audio player. It can be used to record audio or video. It can even be used as a photo retoucher.

Cish: CISH is a configuration shell for GNU/Linux machines that are used as network routers. It provides configuration commands that handle network devices, access control, and routing. The command syntax and CLI closely mimic the behaviour of Cisco network devices.

Citadel: Citadel is an advanced client/server BBS program for operating highly interactive sites, both on the Internet and over dialup. Users can connect to Citadel/UX by telnet, WWW, or client software. Features supported include public and private message rooms, e-mail, real-time chat, message forums,and paging. The server is multithreaded and can easily support a large number of concurrent users without arbitrary limits of messages per room, rooms per system, etc limited by the size of data structures. Both POP3 and SMTP servers are built in for easy connection to Internet mail. Citadel/UX is both robust and mature, as it has been developed over the past twelve years.

Cjukebox: Cjukebox is a management system for audio files and play lists which relies solely on directory structures instead of a database. When available, freedb.org database records can be used to improve the presentation. Playback is handled by the Musicus tool, which directly uses xmms plug-ins, so Cjukebox can play all music formats supported by xmms (wav, ogg, mp3, mpc, etc.). It works with the remote controls suppported by lirc, and provides hotkeys for immediate playback of up to 10 playlists. It also supports an external info script hook for conveying information about the song currently playing, a "badlist" (suppresses songs you don't want played), and a "goodlist" (adds the current song to this list with one keystroke so the user can come back to it later).

Cko: 'cko' (Colored Kernel Output) is a Linux 2.4 and 2.6 kernel patch that colors kernel messages in the BSD style. If you don't like the default color (brown), you can change the value of the "color" variable and set it to whatever color you like.

Cksfv: 'ksfv' (Check SFV) creates simple file verification (.sfv) listings and tests existing .sfv files. It uses the crc32 checksum.

Cl2html: 'cl2html' converts a CVS log into chronological HTML output to give an overview of the CVS activities in a project. HTML output can include links to sources and patches, using viewcvs.cgi.

Class Date: Class::Date provides a date datatype for Perl. You can create new Class::Date objects with a constructor from different scalar formats, array refs, and hash refs, and then you can easily manipulate it by the builtin "+" and "-" operators (e.g., $date=date([2001,03,15])+'3Y 1s'). Relative date types also available.

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.

Cleanlinks: The cleanlinks program searches the directory tree descended from the current directory for symbolic links whose targets do not exist, and removes them. It then removes all empty directories in that directory tree. It is useful for cleaning up a shadow link tree created with 'lndir' after files have been removed from the real directory.

Cleansweep: cleansweep is a set of scripts that help you clean duplicated files from your system. md5dir.sh gathers information on files in a directory. md5dirs.sh gathers information on files in multiple directories. samefiles.sh processes the data and generates information on file duplicates, filename duplicates, and unique files. clean_samefiles.sh cleans the files.

Clearance: Rails authentication with email & password. Clearance is a Rails engine. It works with versions of Rails greater than 2.3.

Clee: A library of common command-line options and some quick tools to make extensible command-line interfaces using sprinkles.

ClientTable: ClientTable is a Python module for generic HTML table parsing. It is most useful when used in conjunction with other parsers (htmllib or HTMLParser, regular expressions, etc.), to divide up the parsing work between your own code and ClientTable.

Clisp: ANSI Common Lisp is a high-level, general-purpose programming language. GNU CLISP is a Common Lisp implementation by Bruno Haible of Karlsruhe University and Michael Stoll of Munich University, both in Germany. It mostly supports the Lisp described in the ANSI Common Lisp standard. It runs on most GNU and Unix systems (GNU/Linux, GNU/Hurd, FreeBSD, NetBSD, OpenBSD, Solaris, Tru64, HP-UX, BeOS, IRIX, AIX, Mac OS X and others) and on other systems and needs only 4 MB of RAM. The user interface comes in English, German, French, Spanish, Dutch, Russian and Danish, and can be changed during run time. GNU CLISP includes an interpreter, a compiler, a debugger, CLOS, MOP, a foreign language interface, a socket interface, i18n, fast bignums, arbitrary precision floats and more. An X11 interface is available through CLX, Garnet, CLUE/CLIO. GNU CLISP runs Maxima, ACL2 and many other Common Lisp packages.

Cloudgizer: Cloudgizer is a tool for building web applications as Apache modules in C language enhanced with simple markup, with emphasis on performance, small-footprint, and more productive and safer programming in C. It combines the ease of scripting with the power of C, improving the resource utilization for cloud applications. The programmer writes simple markup language mixed with C code, which is then translated entirely into C code and compiled natively as Apache module. The resulting application is fast and takes less memory, as there are no interpreters or virtual machines. Features include easy markups to use MariaDB database, HTML input parameters, cookies, simpler outputting of web pages, files storage and manipulation, encryption, encoding, program execution, web calls, safer and easier string manipulation etc. - the list is too long to place in one sentence. Overall Cloudgizer does a lot of stuff for you that you'd otherwise need to do yourself. A memory garbage collection system and memory overwrite/underwrite detection comes in handy for program stability. The same goes for string and memory handling markups to help write applications that won't crash. Also included is an application packaging system and an automated application installer. This makes rollout of products and release cycle more manageable. Cloudgizer source files have extension .v. Cloudgizer pre-compiler (cld program) will turn your .v files into .c files, ready for compilation as pure C programs. Then, your program will be compiled and linked with Apache web server on RH/Centos systems. It links with Apache as an Apache module in a "prefork" configuration. It does the work of communicating with Apache, and it makes it easier to write high-performance/small-footprint web programs in C. Cloudgizer is not designed to be thread-safe as it works in a "prefork" configuration of Apache. You can also build command-line programs. The same program can serve as both command-line utility and a web program linked with Apache. Cloudgizer works with RedHat/Centos 7 operating system, Apache web server and mariaDB database.

Clozure Common Lisp: Clozure Common Lisp (CCL) also known as OpenMCL, Macintosh Common Lisp (MCL), Macintosh Allegro Common Lisp (MACL), and Coral Common Lisp (CCL), features: • All major platforms • Fully compiled native code • Fast, precise, compacting, generational garbage collection • Native OS threads on all platforms • A complete mature foreign function interface • Full support for SLIME, ASDF, and QuickLisp • A native IDE on OS X with Objective C and Cocoa integration

ClusterIt: 'ClusterIt' is a suite of software to allow easy maintenance of large groups of machines. It does not provide a parallel programing environment, but is used to managing one, or to manage massive server farms. Its features include parallel rsh, parallel copy, parallel virtual xterminals (xterms), and job scheduling facilities for performing parallel compiling. It also has programs to allow barrier syncing in shell scripts.

ClusterSSH: Cluster SSH opens xterm windows with connections to specified hosts and an administration console. Any text typed into the administration console is replicated to all other connected and active windows. It is intended for, but not limited to, cluster administration where the same configuration or commands must be run on each node within the cluster. Performing these commands all at once with ClusterSSH keeps all nodes in sync.

Cmdftp: 'cmdftp' is a command line FTP client with shell-like functions which uses passive mode only, works in local and remote mode transparently, tries to keep the connection alive, and supports multiple and recursive file transfers.

Cn: 'cn' is a counterpart for rm, which moves files into the trashcan. It is meant to be used instead of rm, such that one's fingers get into "good habits", and thus avoid accidentally rm-ing the wrong thing. 'cn' will confirm once, by default (even for directories), but can be made silent. It attempts to autodetect the location of the trash if KDE/GNOME are running. It can also handles perverse cases, such as trashing a file which is already in the trash, or deleting multiple files with the same name.

CoaSim: 'CoaSim' is a tool for simulating the coalescent process with recombination and gene conversion under the assumption of exponential population growth. It constructs the ancestral recombination graph for a given number of individuals and uses this to simulate samples of SNP and micro-satellite haplotypes/genotypes. The generated sample can afterwards be separated in cases and controls, depending on states of selected individual markers. The tool can accordingly also be used to construct cases and control data sets for association studies.

Coas: The Caldera Open Administration System project is designed to improve the way users administer their GNU/Linux systems. It will be a collection of tools, each of which will include multiple user interfaces. The system will also let users choose the tools they want to use.

Code-fu: This is a candidate for deletion: 1. No files/source found code-fu is a flatfile pastebin written in PHP and HTML. By using GeSHi (Generic Syntax Highlighter), you can color your output to suit pretty much any kind of code.

Code2html: 'code2html' converts source code to syntax highlighted HTML. It may be called from the command line or as a CGI script. It can also handle include commands in HTML files. Currently supports: Ada 95, C, C++, diff files, gpasm, HTML, Java, JavaScript, Lisp, Makefile, Pascal, Perl, Python, shell, SQL, AWK, M4, and Groff.

CodeWorker: CodeWorker is a scripting language designed to produce reusable, tailor-made, evolving, and reliable IT systems with a high level of automation. An extended BNF syntax lets users define new domain-specific languages or parse existing formats, and a template-based syntax lets users write patterns for generating code. The code generation knows how to preserve protected areas with hand-typed code and offers code expansion, source-to-source translation, and program transformation. These tasks are executed in a straightforward process, with no binding to an external programming language and with no translation of requirements specification in a constraining format.

Coffee Script Lab: CoffeeScript Lab is a frivolous little environment for playing with CoffeeScript in the browser, providing both a REPL and a place to type out longer scripts.

CoffeeScript: CoffeeScript is a little language that compiles into JavaScript. Think of it as JavaScript's less ostentatious kid brother Ã¢â¬â the same genes, roughly the same height, but a different sense of style. Apart from a handful of bonus goodies, statements in CoffeeScript correspond one-to-one with their equivalent in JavaScript, it's just another way of saying it.

Coldstore: ColdStore is a gigabyte-scale persistent object store which maps objects into a file (for persistence), can allocate objects in a minimal working-set of pages (for speed), permits library versions to change without a rebuild of the store, and permits application checkpoint/restart. Coldstore might be used to replace a database, cache highly structured objects, act as an OODB, make STL persistent, act as a Document Store for XML/SGML/HTML, create a MUD. Future projects include a virtual machine toolkit, ports of several languages, VW and byte-interpretive language workbench.

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.

Comanche Server: Comanche is an extremely simple HTTP (web) server written entirely in Python. It does not use any of the many Python standard library modules related to HTTP serving, as it was initially written as a learning exercise. At present it does not support CGI or SSL and uses a simple fork-on-demand architecture, but is being actively improved.

Combine: Pronounced COMbine, like the farm implement, combine matches any number of files to a file, set of files, or input stream. When built on a system with Guile available, it uses Guile to provide extensibility for filtering and data transformation. Additional features include hierarchy handling, a Guile module adapted from the Emacs calendar for performing date arithmetic, and outer joins on either or both sides of a match.

Comfigure: 'comfigure' simplifies the './configure'ing of packages. It remembers the 'configure' options for each one, and uses them automatically if called without options. 'comfigure' automatically recognizes the package name and version from the directory from which it was called. If the stored version is not equal to the current one, 'comfigure' calculates an MD5 digest sum over the output of './configure --help' to see if the available options have changed. If they have, the program asks the user what to do.

Command Line Progress Bar: Command Line Progress Bar is a simple command line tool to display information about a data transfer stream. It will display the number of bytes transfered, the speed of the transfer, and if the size of the data stream is known it will display the ETA, percent complete, and a progress bar.

Command Line Trash

Features

Command line interface compatible with the rm command. You can alias rm with trash.
Remembers original path, deletion time and file permissions of each trashed file.
Compatible with the KDE trash.
Implements the FreeDesktop.org Trash Specification
Works with volume other than the home volume (e.g. USB pen or another partition).

Common Lisp SQL: 'CLSQL' is an SQL database interface for Common Lisp. It provides object-oriented and functional access methods to the underlying database, which can be one of MySQL, ODBC, PostgreSQL, or SQLite. It uses the Unified Foreign Function Interface (UFFI) and thus supports the CMU Common Lisp, Steel Bank Common Lisp, Allegro Common Lisp, OpenMCL, and Lispworks implementations.

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.

Compare: 'Compare' is similar to cmp (in the 'diffutils' package) but faster and with better readable output. It examines one file and standard in (or two files on a byte by byte basis) and prints the file position of the first difference it finds, first in decimal and then in hexadecimal, followed by the differing byte content in hexadecimal and a quoted character.

Compilercache: 'Compilercache' is a wrapperscript around your C and C++ compilers. Each time you compile something, it puts the result into a cache. If you compile the same thing again, the result will be picked from the cache instead of being recompiled. The same applies if you change your compiler options: the old compilation is picked up from the cache, which speeds things up considerably. No Makefiles, no cleaning up dependencies, and no recompilation if you switch compiler options. Additionally, if you download an updated version of a package already on your system and compile it using compilercache, only the changed sources will be recompiled.

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.

Complex Form Examples: This master branch is a simple solution for the multi-model form problem using the latest accepts_nested_attributes_for available in Rails 2.3.

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

Composer: Composer is a tool for dependency management in PHP. It allows you to declare the libraries your project depends on and it will manage (install/update) them for you. Composer is not a package manager in the same sense as Yum or Apt are. Yes, it deals with "packages" or libraries, but it manages them on a per-project basis, installing them in a directory (e.g. vendor) inside your project. By default it does not install anything globally. Thus, it is a dependency manager. It does however support a "global" project for convenience via the global command. This idea is not new and Composer is strongly inspired by node's npm and ruby's bundler.

Conc: Conc is a serial console concentrator package. It features remote maintenance of systems over IP, and concurrent connections to consoles. It can pool serial lines on multiple machines into one system, which lets you manage a virtually unlimited number of consoles- ideal for large server farms, clusters or off-site server rooms.

Condenser: Condenser is a tool for finding and removing duplicated Java code. Unlike tools that only locate duplicated code, Condenser is also able to automatically remove duplicated code where it is safe to do so.

Cone: Cone (COnsole Newsreader And Emailer) is a text-based mail client based, in part, on Courier libraries. It seamlessly handles multiple POP3 and IMAP accounts and local mail folders. It is also a simple newsreader. It is designed to be foolproof enough to be used by inexperienced users, but also offers advanced features for power users.

Config General: With Config::General you can read and write config files and access the parsed contents from a hash structure. The format of config files supported by Config::General is inspired by the Apache config format (and is 100% compatible with Apache configs). It also supports some enhancements such as here-documents, C-style comments, and multiline options.

ConfigObj: A python module for ultra simple handling of configuration files. Also useful for human readable data persistence. Flexible and simple. ConfigObj is a simple but powerful config file reader and writer: an ini file round tripper. Its main feature is that it is very easy to use, with a straightforward programmer's interface and a simple syntax for config files.

Configgy: Configgy was a library for handling config files and logging for a scala daemon. The idea was that it should be simple and straightforward, allowing you to plug it in and get started quickly.

Confix: Confix is a build tool for source code packages, on top of GNU Automake. It inspects the package's source code, tracks inter package dependencies, propagates checks across package boundaries, and finally writes Automake input files for the maintainer.

Confstore: 'confstore' is a configuration backup utility. It scans a system for all recognised configuration files and then stores them in a simple archive. It knows what to scan for by reading a definitions file. Confstore can also restore configuration from backup archives it has previously created, upload them to a FTP server, and mail them to an email account.

Conjuguer: Conjuguer is a French verb conjugation program which can be used from the command line to output some or all tenses of some or all french verbs. It can also generate a website containing all conjugations of all french verbs, and it is also the CGI program that drives the website.

ConnMon: Connection Monitor is a connection and bandwidth monitoring program with console (ncurses) and X (GTK) based user interfaces. It displays a list of open TCP and UDP connections with transfer rate (in bytes per second) for each connection. ConnMon uses the GNU adns library to make asynchronous DNS lookups.

Conntrack-tools: The conntrack-tools are a set of free software userspace tools for Linux that allow system administrators interact with the Connection Tracking System, which is the module that provides stateful packet inspection for iptables. Modern firewalls implement state tracking (a.k.a. connection tracking) in order to keep some state about the currently active sessions. The conntrack-tools are the userspace daemon conntrackd and the command line interface conntrack. The userspace daemon conntrackd can be used to enable high availability of cluster-based stateful firewalls and to collect statistics of the stateful firewall use. conntrack is a userspace command line program targeted at system administrators. It enables them to view and manage the in-kernel connection tracking state table. Since 1.2.0, the conntrack-tools includes the nfct command line utility.

Cons

CONS is a replacement for GNU Make. It is not compatible with make, but it offers features not found in make or other build tools including:

integrated dependency analysis (no more "make depend" to generate static lists of .h files)
complete, non-recursive dependency analysis across multiple directories;
multiple side-by-side variant builds;
compilation from MD5 signatures instead of time stamps for determining whether a file is up-to-date
extensibility via Perl.

CONS is implemented in Perl. You don't need to know Perl to use CONS, although you can use it more powerfully if you do.

Conserver: 'Conserver' provides remote access to serial port consoles and logs all data to a central host. It supports both local and network serial connections, and can replay the server console history from the console app even if the server is down. Multiple users can connect to a single serial connection.

Convert From SSI: Server-Side Includes (SSIs) can rapidly speed up the development of dynamic websites. Overall stylistic changes can be made in minutes, without manually updating each page. However, SSIs can dramatically slow down a webserver, and some hosts do not support SSI funtionality. The 'Convert From SSI' script reads in .shtml files (files with SSI statements in them) that the user specifies (by putting them into one directory) and converts #include SSI statements into regular HTML that does not require a webserver that supports SSI.

ConvertFS: 'ConvertFS' is a very simple but extremely powerful toolset which allows users to convert one file system to another. It creates a sparse image of a block device, mkfs a secondary filesystem on it, mounts it, moves files from the primary filesystem to the mounted image and then maps the image to the device. It works for converting virtually any filesystem type to virtually any one as long as they are both block-oriented and supported by GNU/Linux for read/write, and as long as primary filesystem supports sparse files.

Convmv: 'convmv' converts filenames (not file content), directories, and even whole filesystems to a different encoding. This comes in very handy if, for example, one switches from an 8-bit locale to an UTF-8 locale. It has some smart features: it automagically recognises if a file is already UTF-8 encoded (thus partly converted filesystems can be fully moved to UTF-8) and it also takes care of symlinks. It can also convert from normalization form C (UTF-8 NFC) to NFD and vice-versa.

Cook: Cook is a tool for constructing files. It is given a set of files to create, and recipes of how to create them. In any non-trivial program there will be prerequisites to performing the actions necessary to creating any file, such as include files. Cook provides a mechanism to define these. When a program is being developed or maintained, the programmer will typically change one file of several which comprise the program. Ccok examines the last-modified times of the files to see when the prerquisites of a file have changed, implying that the file needs to be recreated as it is logically out of date.

Cool3s: 'cool3s' is a smart snippet system designed to make a snippet library available in cooledit, a snippet being a reusable, or a generated on the spot piece of text. Written in Bash shell script command language it is multi functional and can be used for other applications or in the shell. It presents you with a menu of your snippets which it then enters in the application that called it or echos it to your screen. There are also configuration options that can bypass the selection menu and retrieve the snippet of your choice at once. 'cool3s' runs on any system that runs bash as a shell.

CopyQ

CopyQ is a rich, graphical clipboard manager.

Store text, HTML, images and any other custom format.
Customize tray menu.
Save items in tabs or tree.
Quickly browse through items (fast navigation, filtering with matched text highlighting).
Sort items, create new, edit, remove, copy/paste to different tab.
Variety of system-wide shortcuts (e.g. show main window or tray, edit clipboard, copy next/previous, paste as plain text).
Immediately paste to focused window from tray or main window.
Fully customizable appearance (colors, fonts, transparency).
Advanced command-line interface and scripting.
Ignore clipboard copied from some windows or containing some text.
Apply custom commands on selected items or automatically when new matching clipboard content is available.

Coq

A proof done with Coq is mechanically checked by the machine. In particular, Coq allows:

to define functions or predicates,
to state mathematical theorems and software specifications,
to develop interactively formal proofs of these theorems,
to check these proofs by a relatively small certification "kernel".

Core-restart: 'core-restart' is a process checkpointing and restarting system. It does not require the executables to be linked with a library, so processes can be checkpointed without being changed. Also, the restarted process and the restoration code are in independent address spaces which simplifies the mechanism of restoring the stack and register state of the checkpointed process. The system runs only on user-level code and requires no modifications to the kernel.

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

Corkscrew: 'corkscrew' is a small program for tunneling SSH through HTTP proxies. It features easy configuration and support for several Unix variants. It has been tested with the following HTTP proxies: Gauntlet, CacheFlow, JunkBuster, Squid , Apache's mod_proxy

CouchDB-FUSE

This is a Python FUSE module for CouchDB. It allows CouchDB document attachments to be mounted on a virtual filesystem and edited directly. Use Cases

This is a great time-saver if you want to edit HTML, JavaScript, CSS or even image files directly using your favourite editor.
Uploading large numbers of files repetitively through Futon or even via a Python prompt becomes tedious very quickly: drag'n'drop or cp * is the way forward!

CouchDBKit: CouchDB is a document oriented database. This is is a framework to allow your Python application to use CouchDB.

CouchQL: CouchQL speeds up the creation of CouchDB views by automatically generating them based on a simple SQL-like query.

Couchdb-python

This is a Python library for CouchDB. It provides a convenient high level interface for the CouchDB server. This package currently encompasses four primary modules:

couchdb.client: the basic client library
couchdb.design: management of design documents
couchdb.schema: a higher-lever API for mapping between CouchDB documents and Python objects
couchdb.view: a CouchDB view server that allows writing view functions in Python

Count: 'Count' is a fast replacement for the standard 'wc' utility. It has the additional features of counting the visible line length and a fast -stat option to quickly determine file sizes.

Coveralls: A rails plugin to make sure all files are required and show up in the code coverage report. (Untouched files are excluded and can thus inflate the overall code coverage.) If you forget to test a new library or module, it may not show up on the report, and thus you won't see that the coverage for that file is low.

Cowbell: Cowbell is tightly integrated with Amazon.com using its free SOAP service. Cowbell employs this service not only to fetch album cover images, as most tag editors do, but also in combination with intelligent algorithms to "guess" the appropriate song information from song titles. It can also cache these cover images in the same directory where that album resides. Going above and beyond the call of tagging, Cowbell also can rename your files based upon a user-configurable pattern (More detail on how to use this feature is covered in the Advanced Guide) and also export a M3U/PLS playlist of your songs in album-order. For you console junkies, Cowbell also offers a command-line based batch tagger which can tag and "guess" a whole collection of music with just a few keystrokes. And, to top it all off, Cowbell is fully internationalized and has been translated into German, French, Portuguese, Spanish, Norwegian and Swedish.

Cowloop: The cowloop-driver is a copy-on-write loop driver (block device) which can be used on top of any other block driver. It shields the lower driver from any write access and diverts all write-accesses to an arbitrary regular file, called the cowfile. When a modified block is read again later on, the cowloop-driver gets the block from the cowfile, while non-modified blocks are obtained from the original read-only device. This lets block-devices be used in a read-write fashion without modifying the underlying block-device itself.

Cp-tools: Classpath tools is a collection of tools for GNU Classpath including a documentation generation system for java source files (gjdoc) and a "doclet" for converting comments into GNU Texinfo source (texidoclet), etc. This project has been integrated into the main GNU Classpath project.

Cpio: Cpio copies files into or out of a cpio or tar archive. The archive can be another file on the disk, a magnetic tape, or a pipe. GNU cpio supports the following archive formats: binary, old ASCII, new ASCII, crc, HPUX binary, HPUX old ASCII, old tar, and POSIX.1 tar. The tar format is provided for compatibility with the tar program. By default, cpio creates binary format archives for compatibility with older cpio programs. When extracting from archives, cpio automatically recognizes which kind of archive it is reading and can read archives created on machines with a different byte-order.

Cplay: 'cplay' is a curses frontend for various audio players. It aims to provide a power-user-friendly interface with simple filelist and playlist control. Since cplay' is written in Python, it can use either pyncurses or the standard curses module. The program currently supports ogg123, mpg123, mpg321, splay, madplay, and mikmod, xmp, and sox.

Cpp2latex: 'cpp2latex' converts C++ into LaTeX either for including into existing LaTeX documents or as standalone documents. The current version (2.0) supports syntax highlighting.

Cpphs: 'cpphs' is a simplified Haskell re-implementation of cpp, the C pre-processor, in Haskell. The C pre-processor is widely used in Haskell source code, but a true cpp is not often available on some systems, and the common cpp provided by the gcc 3.x series is changing in ways that are incompatible with Haskell's syntax. This includes problems with, for instance, string gaps, and prime characters in identifiers. This project attempts to provide an alternative to cpp that is more compatible with Haskell and can be distributed with compilers.

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

Cpre: 'cpre' is a supplement to the normal cp. It takes a list of file names and a regular expression substitution pattern, performs the substitution on the file names, and then copies each file to the new name that resulted from the substitution.

Cproto: Cproto is a program that generates function prototypes and variable declarations from C source code. It can also convert function definitions between the old style and the ANSI C style. This conversion overwrites the original files, so make a backup copy of your files in case something goes wrong.

Cpulimit: cpulimit is a simple program that attempts to limit the CPU usage of a process (expressed in percentage, not in CPU time). This is useful to control batch jobs when you don't want they eat too much CPU. It does not act on the nice value or other scheduling priority details, but on the real CPU usage. Also, it is able to adapt itself to the overall system load, dynamically and quickly.

CrackLib: A password checking library.

Createusers: Createusers adds users in bulk. It also sets up new users' home directories for personal Web space with Apache. The companion program, removeusers, eliminates users from the system. The latest release includes a graphical user interface, based on Tcl/tk.

Crenshaw Compiler: A simple compiler based on Jack W. Crenshaw's "Let's make a compiler!" tutorial. His version was in Turbo Pascal and output 68k asm, mine is in Ruby and outputs x86 asm.

Crip: 'crip' is a terminal-based ripper/encoder/tagger tool for creating Ogg Vorbis/FLAC/MP3 files under UNIX or GNU/Linux. It is well-suited for someone seeking to make a lot of files from CDs and have them all properly labeled and professional-quality with a minimum of hassle and yet still have flexibility and full control over everything. Current versions of crip support only Ogg Vorbis and FLAC; if you want to make MP3 files you must use crip-1.0.

CrocoPat: 'CrocoPat' is a tool for querying and manipulating relations. It is easy to use because of its simple query and manipulation language based on predicate calculus and its simple file format for relations. It is efficient because it internally represents relations as binary decision diagrams, a data structure that is well-known as a compact representation of large relations. CrocoPat is general, because it manipulates not only graphs (i.e. binary relations), but n-ary relations.

Cron: Background-only application which launches and runs other applications, or opens documents, at specified dates and times.

Cronolog: 'cronolog' is a filter program that reads log file entries from standard input and writes each entry to the output file specified by a filename template and the current date and time. When the expanded filename changes, the current file closes and a new one opens. 'cronolog' is meant to be used in conjunction with a Web server, such as Apache, to split the access log into daily or monthly logs.

Cronwrap: 'cronwrap' is a utility that offers more control over the execution of a cron job than the standard cron daemon allows. It can ensure and report that the job completes within a specified time period. It can email and/or log any output produced from the job. It reports on the exit status of the job.

Crossroads Load Balancer: Crossroads is a load balance and failover utility for TCP-based services. It is a daemon program running in userspace and features extensive configurability, polling of backends using "wakeup calls", detailed status reporting, "hooks" for special actions when backend calls fail, and more. It is service-independent; it is usable for HTTP(S), SSH, SMTP, DNS, etc.

Crowdsec: Crowdsec is a firewall and behaviour detection system that uses a shared IP address reputation database in order to identify potential threats. User can instruct Crowdsec to watch certain logs, including both operating system logs and logs for specific applications. These are analysed for potential security threats, and the source IP address of any suspicious activity may be uploaded to a shared reputation database. Likewise, the user can download this shared database to benefit from lists of known suspicious hosts. Crowdsec includes so-called 'bouncers' to block certain IP addresses from accessing services, thus forming a reputation-based firewall. As the bouncer and detection components are separate programs and can remotely communicate, Crowdsec may be appropriate for embedded applications where the host to be protected is not powerful enough to detect potential threats itself; the log analysis can be done on another, more powerful system.

Crucible: Crucible provides a powerful, flexible backend for building automated testing systems. It allows for conducting tests on multiple machines (via NFS), including patching, rebuilding, and booting new kernels, libraries, and services. Configuration and customization can be done through simple config files and bash scripts. It is suitable for performing tests of GUI applications, services, libraries, and kernel patches.

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.

Free Software Foundation!

Semantic search

Query log

Insignificant memory usage!

Also quite insignificant CPU usage

bustd locks all pages mapped into its address space

Checks for Pressure Stall Information

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Interaction

Navigation

Creation

Print

Tools