Semantic search

Jump to: navigation, search
Search

Edit query Show embed code

The query [[Programming-language::C++]] was answered by the SMWSQLStore3 in 0.0098 seconds.


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


Aseprite
Aseprite is a pixel art editor. It was specifically designed for that task. ASEPRITE (aka ASE, Allegro Sprite Editor) is a free software program to create animated sprites & pixel art. Sprites are little images that can be used in your website or in a video game. You can draw characters with movement, intros, textures, patterns, backgrounds, logos, color palettes, isometric levels, etc." Download Categories
Aspell Heckert gnu.tiny.png
GNU Aspell is a spell checker that can be used either as a library or as an independent spell checker. It does a much better job of coming up with possible suggestions than other English language spell checkers. Other technical enhancements over Ispell include shared memory for dictionaries and intelligent handling of personal dictionaries when more than one Aspell process is open.
Astroid
Astroid is a lightweight and fast Mail User Agent that provides a graphical interface to searching, display and composing email, organized in thread and tags. Astorid uses the notmuch backend for blazingly fast searches through tons of email. Astroid searches, displays and compose emails - and rely on other programs for fetching, syncing and sending email. Check out Astroid in your general mail setup for a suggested complete mail solution. [1]
Audacious
Audacious is a free software audio player. A descendant of XMMS, Audacious plays your music how you want it, without stealing away your computer’s resources from other tasks. Drag and drop folders and individual song files, search for artists and albums in your entire music library, or create and edit your own custom playlists. Listen to CD’s or stream music from the Internet. Tweak the sound with the graphical equalizer or experiment with LADSPA effects. Enjoy the modern GTK-themed interface or change things up with Winamp Classic skins. Use the plugins included with Audacious to fetch lyrics for your music, to set an alarm in the morning, and more.
Audacity
Audacity is a cross-platform multitrack audio editor that lets you record sounds directly or import Ogg, WAV, AIFF, AU, IRCAM, or MP3 files. It features a few simple effects, all of the editing features you should need, and unlimited undo. The GUI is built with wxWidgets and the audio I/O currently uses PortAudio.
Avaneya: Viking Lander Remastered DVD
Whether you are a fan of science fiction, a space–science enthusiast, hobbyist, photographer, gamer or a patron of grass–roots libre arts and technology, you are sure to find the first successful images from the surface of Mars highly captivating. These mind blowing images were taken by NASA's Viking landers during the highly ambitious, billion–dollar mission first launched in 1975. However, many images were nearly lost to history due to magnetic tape deterioration and archaic proprietary technology. With NASA's blessing, our team developed the technology to recover many of these images. This research tool was part of the design phase of our parent project, Avaneya — our upcoming libre cerebral science fiction game for the GNU operating system set on Mars, described in the words of Richard Stallman as an exciting, pioneering project. Originally an internal research tool, overwhelming public interest compelled us to release the technology on this DVD for all. Now everyone can relive the original breathtaking experience that captured the world's attention and marked the first successful moment in history that humanity saw Mars — not as a distant, impersonal, celestial body, beheld through a telescope for centuries, but as a tangible and alien world well within its reach.
Avogadro
Avogadro is an advanced molecule editor and visualizer designed for cross-platform use in computational chemistry, molecular modeling, bioinformatics, materials science, and related areas. It offers flexible high quality rendering and a powerful plugin architecture.
  • International: Translations into Chinese, French, German, Italian, Russian, Spanish, and others, with more languages to come.
  • Intuitive: Built to work easily for students and advanced researchers both.
  • Fast: Supports multi-threaded rendering and computation.
  • Extensible: Plugin architecture for developers, including rendering, interactive tools, commands, and Python scripts.
  • Flexible: Features include Open Babel import of chemical files, input generation for multiple computational chemistry packages, crystallography, and biomolecules.
AwesomeBump
AwesomeBump is a normal/specular/parallax/ambient occlusion map generator.
BRL-CAD
BRL-CAD includes an interactive geometry editor, parallel ray-tracing support for rendering and geometric analysis, path-tracing for realistic image synthesis, network distributed framebuffer support, image-processing and signal-processing tools.
Ballandpaddle Heckert gnu.tiny.png
GNU Ball and Paddle is an old-fashioned ball and paddle game with a set amount of blocks to destroy on each level, while moving a paddle left and right at the bottom of the screen. Various powerups may make different things occur.
Bayonne Heckert gnu.tiny.png
Bayonne is the telephony server of the GNU project. Based on the ACS project, it offers a multi-line interactive voice response telephony server which may be scripted and telephony plug-ins for runtime driver configuration directly extended thru modular plugins. Bayonne also features "TGI" for making Perl applications "telephony aware". Support has been extended to include XML parsing and support has been started on VoIP integration to support next generation telephone networks. The project is not fully completed but is moving steadily towards producing a finished project that may be used to build telephony based system administration, home automation, automated attendant, v-commerce, and voice messaging systems.
BibleTime
BibleTime is a powerful cross platform Bible study tool. It uses the SWORD programming library to work with Bible texts, commentaries, dictionaries and books provided by the CrossWire Bible Society.
Boost
Boost is a repository of portable and peer-reviewed C++ libraries.
Accumulators 
Framework for incremental calculation, and collection of statistical accumulators. Math and numerics
Algorithm 
A collection of useful generic algorithms. Algorithms
Any 
Safe, generic container for single values of different value types. Data structures
Array 
STL compliant container wrapper for arrays of constant size. Containers
Asio 
Portable networking, including sockets, timers, hostname resolution and socket iostreams. Concurrent Programming
Assign 
Filling containers with constant or generated data has never been easier. Input/Output
Bimap 
Bidirectional maps library for C++. With Boost.Bimap you can create associative containers in which both types can be used as key. Containers
Bind 
boost::bind is a generalization of the standard functions std::bind1st and std::bind2nd. It supports arbitrary function objects, functions, function pointers, and member function pointers, and is able to bind any argument to a specific value or route input arguments into arbitrary positions. Function objects and higher-order programming
Call Traits 
Defines types for passing parameters. Generic Programming
Chrono 
Useful time utilities. Domain Specific
Circular Buffer 
A STL compliant container also known as ring or cyclic buffer. Containers
Compatibility 
Help for non-conforming standard libraries. Broken compiler workarounds
Compressed Pair 
Empty member optimization. Data structures
Concept Check 
Tools for generic programming. Generic Programming
Config 
Helps Boost library developers adapt to compiler idiosyncrasies; not intended for library users. Broken compiler workarounds
Container 
Standard library containers and extensions. Containers
Context 
Context switching library. Concurrent Programming
Conversion 
Polymorphic and lexical casts. String and text processing
CRC 
The Boost CRC Library provides two implementations of CRC (cyclic redundancy code) computation objects and two implementations of CRC computation functions. The implementations are template-based. Domain Specific
Date Time 
A set of date-time libraries based on generic programming concepts. Domain Specific
Dynamic Bitset 
The dynamic_bitset class represents a set of bits. It provides accesses to the value of individual bits via an operator[] and provides all of the bitwise operators that one can apply to builtin integers, such as operator& and operator<<. The number of bits in the set is specified at runtime via a parameter to the constructor of the dynamic_bitset. Containers
Enable If 
Selective inclusion of function template overloads. Generic Programming
Exception 
The Boost Exception library supports transporting of arbitrary data in exception objects, and transporting of exceptions between threads. Language Features Emulation
Filesystem 
The Boost Filesystem Library provides portable facilities to query and manipulate paths, files, and directories. System
Flyweight 
Design pattern to manage large quantities of highly redundant objects. Patterns and Idioms
Foreach 
In C++, writing a loop that iterates over a sequence is tedious. We can either use iterators, which requires a considerable amount of boiler-plate, or we can use the std::for_each() algorithm and move our loop body into a predicate, which requires no less boiler-plate and forces us to move our logic far from where it will be used. In contrast, some other languages, like Perl, provide a dedicated "foreach" construct that automates this process. BOOST_FOREACH is just such a construct for C++. It iterates over sequences for us, freeing us from having to deal directly with iterators or write predicates. Algorithms
Format 
The format library provides a class for formatting arguments according to a format-string, as does printf, but with two major differences: format sends the arguments to an internal stream, and so is entirely type-safe and naturally supports all user-defined types; the ellipsis (...) can not be used correctly in the strongly typed context of format, and thus the function call with arbitrary arguments is replaced by successive calls to an argument feeding operator%. String and text processing
Function 
Function object wrappers for deferred calls or callbacks. Function objects and higher-order programming
Function Types 
Boost.FunctionTypes provides functionality to classify, decompose and synthesize function, function pointer, function reference and pointer to member types. Generic Programming
Functional 
The Boost.Function library contains a family of class templates that are function object wrappers. Function objects and higher-order programming
Functional/Factory 
Function object templates for dynamic and static object creation Function objects and higher-order programming
Functional/Forward 
Adapters to allow generic function objects to accept arbitrary arguments Function objects and higher-order programming
Functional/Hash 
A TR1 hash function object that can be extended to hash user defined types. Function objects and higher-order programming
Functional/Overloaded Function 
Overload different functions into a single function object. Function objects and higher-order programming
Fusion 
Library for working with tuples, including various containers, algorithms, etc. Template Metaprogramming
Geometry 
Geometry Library. Algorithms
GIL 
Generic Image Library Containers
Graph 
The BGL graph interface and graph components are generic, in the same sense as the the Standard Template Library (STL). Containers
Heap 
Priority queue data structures. Data structures
ICL 
Interval Container Library, interval sets and maps and aggregation of associated values Containers
Identity Type 
Wrap types within round parenthesis so they can always be passed as macro parameters. Preprocessor Metaprogramming
In Place Factory, Typed In Place Factory 
Generic in-place construction of contained objects with a variadic argument-list. Generic Programming
Integer 
The organization of boost integer headers and classes is designed to take advantage of <stdint.h> types from the 1999 C standard without resorting to undefined behavior in terms of the 1998 C++ standard. The header <boost/cstdint.hpp> makes the standard integer types safely available in namespace boost without placing any names in namespace std. Math and numerics
Interprocess 
Shared memory, memory mapped files, process-shared mutexes, condition variables, containers and allocators. Concurrent Programming
Interval 
Extends the usual arithmetic functions to mathematical intervals. Math and numerics
Intrusive 
Intrusive containers and algorithms. Containers
IO State Savers 
The I/O sub-library of Boost helps segregate the large number of Boost headers. This sub-library should contain various items to use with/for the standard I/O library. Input/Output
Iostreams 
Boost.IOStreams provides a framework for defining streams, stream buffers and i/o filters. String and text processing
Iterators 
The Boost Iterator Library contains two parts. The first is a system of concepts which extend the C++ standard iterator requirements. The second is a framework of components for building iterators based on these extended concepts and includes several useful iterator adaptors. Iterators
Lambda 
Define small unnamed function objects at the actual call site, and more. Function objects and higher-order programming
Lexical Cast 
General literal text conversions, such as an int represented a string, or vice-versa, from Kevlin Henney. String and text processing
Local Function 
Program functions locally, within other functions, directly within the scope where they are needed. Function objects and higher-order programming
Locale 
Provide localization and Unicode handling tools for C++. String and text processing
Math 
Boost.Math includes several contributions in the domain of mathematics: The Greatest Common Divisor and Least Common Multiple library provides run-time and compile-time evaluation of the greatest common divisor (GCD) or least common multiple (LCM) of two integers. The Special Functions library currently provides eight templated special functions, in namespace boost. The Complex Number Inverse Trigonometric Functions are the inverses of trigonometric functions currently present in the C++ standard. Quaternions are a relative of complex numbers often used to parameterise rotations in three dimentional space. Octonions, like quaternions, are a relative of complex numbers. Math and numerics
Math Common Factor 
Greatest common divisor and least common multiple. Math and numerics
Math Octonion 
Octonions. Math and numerics
Math Quaternion 
Quaternions. Math and numerics
Math/Special Functions 
A wide selection of mathematical special functions. Math and numerics
Math/Statistical Distributions 
A wide selection of univariate statistical distributions and functions that operate on them. Math and numerics
Member Function 
Generalized binders for function/object/pointers and member functions. Function objects and higher-order programming
Meta State Machine 
A very high-performance library for expressive UML2 finite state machines. State Machines
Min-Max 
Standard library extensions for simultaneous min/max and min/max element computations. Algorithms
Move 
Portable move semantics for C++03 and C++11 compilers. Language Features Emulation
MPI 
Message Passing Interface library, for use in distributed-memory parallel application programming. Concurrent Programming
MPL 
The Boost.MPL library is a general-purpose, high-level C++ template metaprogramming framework of compile-time algorithms, sequences and metafunctions. It provides a conceptual foundation and an extensive set of powerful and coherent tools that make doing explict metaprogramming in C++ as easy and enjoyable as possible within the current language. Template Metaprogramming
Multi-Array 
Boost.MultiArray provides a generic N-dimensional array concept definition and common implementations of that interface. Containers
Multi-Index 
The Boost Multi-index Containers Library provides a class template named multi_index_container which enables the construction of containers maintaining one or more indices with different sorting and access semantics. Containers
Numeric Conversion 
Optimized Policy-based Numeric Conversions. Math and numerics
Operators 
Templates ease arithmetic classes and iterators. Iterators
Optional 
Discriminated-union wrapper for optional values. Miscellaneous
Parameter 
Boost.Parameter Library - Write functions that accept arguments by name. Programming Interfaces
Phoenix 
Define small unnamed function objects at the actual call site, and more. Function objects and higher-order programming
Pointer Container 
Containers for storing heap-allocated polymorphic objects to ease OO-programming. Containers
Polygon 
Booleans/clipping, resizing/offsetting and more for planar polygons with integral coordinates. Miscellaneous
Pool 
Memory pool management. Memory
Preprocessor 
Preprocessor metaprogramming tools including repetition and recursion. Preprocessor Metaprogramming
Program Options 
The program_options library allows program developers to obtain program options, that is (name, value) pairs from the user, via conventional methods such as command line and config file. Input/Output
Property Map 
Concepts defining interfaces which map key objects to value objects. Containers
Property Tree 
A tree data structure especially suited to storing configuration data. Containers
Proto 
Expression template library and compiler construction toolkit for domain-specific embedded languages. Template Metaprogramming
Python 
The Boost Python Library is a framework for interfacing Python and C++. It allows you to quickly and seamlessly expose C++ classes functions and objects to Python, and vice-versa, using no special tools -- just your C++ compiler. Inter-language support
Random 
A complete system for random number generation. Math and numerics
Range 
A new infrastructure for generic algorithms that builds on top of the new iterator concepts. Algorithms
Ratio 
Compile time rational arithmetic. Math and numerics
Rational 
A rational number class. Math and numerics
Ref 
A utility library for passing references to generic functions. Function objects and higher-order programming
Regex 
Regular expression library. String and text processing
Result Of 
Determines the type of a function call expression. Function objects and higher-order programming
Scope Exit 
Execute arbitrary code at scope exit. Language Features Emulation
Serialization 
Serialization for persistence and marshalling. Input/Output
Signals 
Managed signals & slots callback implementation. Function objects and higher-order programming
Signals2 
Managed signals & slots callback implementation (thread-safe version 2). Function objects and higher-order programming
Smart Ptr 
Smart pointer class templates. Memory
Spirit 
LL parser framework represents parsers directly as EBNF grammars in inlined C++. String and text processing
Statechart 
Boost.Statechart - Arbitrarily complex finite state machines can be implemented in easily readable and maintainable C++ code. State Machines
Static Assert 
Static assertions (compile time assertions). Generic Programming
String Algo 
String algorithms library. String and text processing
Swap 
Enhanced generic swap function. Miscellaneous
System 
Operating system support, including the diagnostics support that will be part of the C++0x standard library. System
Test 
Support for simple program testing, full unit testing, and for program execution monitoring. Correctness and testing
Thread 
Portable C++ multi-threading. Concurrent Programming
Timer 
Event timer, progress timer, and progress display classes. Miscellaneous
Tokenizer 
Break of a string or other character sequence into a series of tokens. String and text processing
TR1 
The TR1 library provides an implementation of the C++ Technical Report on Standard Library Extensions. This library does not itself implement the TR1 components, rather it's a thin wrapper that will include your standard library's TR1 implementation (if it has one), otherwise it will include the Boost Library equivalents, and import them into namespace std::tr1. Miscellaneous
Tribool 
3-state boolean type library. Miscellaneous
Tuple 
Ease definition of functions returning multiple values, and more. Data structures
Type Traits 
Templates for fundamental properties of types. Generic Programming
Typeof 
Typeof operator emulation. Language Features Emulation
uBLAS 
uBLAS provides matrix and vector classes as well as basic linear algebra routines. Several dense, packed and sparse storage schemes are supported. Math and numerics
Units 
Zero-overhead dimensional analysis and unit/quantity manipulation and conversion. Domain Specific
Unordered 
Unordered associative containers. Containers
Utility 
Class noncopyable plus checked_delete(), checked_array_delete(), next(), prior() function templates, plus base-from-member idiom. Algorithms
Uuid 
A universally unique identifier. Data structures
Value Initialized 
Wrapper for uniform-syntax value initialization, based on the original idea of David Abrahams. Miscellaneous
Variant 
Safe, generic, stack-based discriminated union container. Containers
Wave 
The Boost.Wave library is a Standards conformant, and highly configurable implementation of the mandated C99/C++ preprocessor functionality packed behind an easy to use iterator interface. String and text processing
Xpressive 
Regular expressions that can be written as strings or as expression templates, and which can refer to each other and themselves recursively with the power of context-free grammars. String and text processing
Bpel2owfn Heckert gnu.tiny.png
BPEL2oWFN translates a web service expressed in BPEL (Business Process Execution Language for Web Services) into an oWFN (open Workflow Net). This oWFN can be used to:
  • check for controllability or generate the operating guideline using Fiona (www.informatik.hu-berlin.de/top/tools4bpel/fiona)
  • check for deadlocks or any other Petri net property
  • check any temporal logic formula with a variety of model checking tools.
BPEL2oWFN uses static analysis to make the generated oWFN as compact as possible to analyze a chosen property. This is called flexible model generation.
BPEL2oWFN is the successor of BPEL2PN (www.informatik.hu-berlin.de/top/bpel2pn), a Java-based compiler generating low-level Petri nets. BPEL2oWFN is a re-implementation for extensibility and performance issues. Its functionality is a superset of the functionality of BPEL2PN.
GNU BPEL2oWFN was written by Niels Lohmann, Christian Gierds and Martin Znamirowski. It is part of the Tools4BPEL project funded by the Bundesministerium für Bildung und Forschung - BMBF.
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.
CVAssistant
Whether you're looking for a job or trying to help a friend to find one, CVAssistant is the number one tool for you. It helps you by preparing resumes and cover letters and organizing your job application process. It: Stores all your skills and experiences. Creates resumes tailored for each job you apply. Creates cover letters summarized to match each job advertisement. Keeps a history of job applications so you are ready when you receive a phone call. Write resumes in your language. All languages are supported! It's a free and open source software which you can easily download to your computer and start using it out of the box. CV Assistant helps you create specialized resumes in Word .docx format fast and easy. The idea is to have a master resume with all skills and experiences in it. Then based on skills mentioned in the job advertisement, export a clean but well formatted word .docx file as a summarized resume with only relevant skills in it. This increases your chance of getting a job interview as most companies are using Applicant Tracking Software (ATS) or at best hiring managers which may be unaware of similarity between phrases like skilled in MS Word, familiar with Microsoft Word and Fully experienced with office suites. So job seekers need to create specialized resumes for each and every job position with the same wordings used in the advertisement. Add all your skills to CV Assistant, pick only relevant ones. It also creates cover letters! Again, write all possible sentences, and select those relevant ones per job post. CVAssistant helps you free of charge and this software remains for free!
CYTHAR
CYTHAR is multi-platform, pattern-oriented, polyphonic MIDI step-sequencer, which makes its own path. 16 parallel patterns with six tracks and 16 bars -- equating to 256 bars and 96 tracks. The six pattern tracks imitate the strings of a guitar and will be tuned e.g. to “EAdgbe”. For example, you can set a guitar chord to a pattern tune and then by enabling a few events or triggers the sequencer will start a solo or plays with the chords. You can program drum sets, melodies, arpeggios and complete songs.
Calamares
Calamares is a distribution-independent system installer, with an advanced partitioning feature for both manual and automated partitioning operations. It is the first installer with an automated “Replace Partition” option, which makes it easy to reuse a partition over and over for distribution testing. Calamares is designed to be customized by distribution maintainers without need for cumbersome patching, thanks to third party branding and external modules support.
Ccaudio Heckert gnu.tiny.png
GNU ccAudio is a stand-alone C++ class library and newly designated GNU package for manipulating audio data, whether on disk or in memory. GNU ccAudio offers the ability to work with audio file formats on disk by treating audio data as sequenced arrays of sample data rather than as arbitrary octets as some audio file manipulation libraries do. In addition to being audio content aware, GNU ccAudio allows header manipulation for setting things like annotation fields. GNU ccAudio is also endian aware and highly portable to both posix and win32 based systems. GNU ccAudio also offers basic audio signal processing including tone data set generation and pluggable codec operations. In the future we will provide loadable free software audio codec modules for many common audio encoding formats where not patent encumbered.
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.
Ccrtp Heckert gnu.tiny.png
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.
Ccscript Heckert gnu.tiny.png
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.
Cgicc Heckert gnu.tiny.png
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.
Chess Heckert gnu.tiny.png
GNU Chess is a chess-playing program. It can be used to play chess against the computer on a terminal or, more commonly, as a chess engine for graphical chess frontends such as XBoard.
Classified-ads
"Classified ads" is messaging system for exchange of private and public messages between humans, and maybe other primates. Features of the program include, but are not limited to: * Sending and retrieving messages public and private, between humans or inside groups * No need for server-side support of any kind * Minimal hassle for the end-user * No need for contracts with any service-operators, not counting your ISP * Identification of message senders while allowing some withdrawal of personal details * Text-based search of public posting
Clementine
Clementine is a multi-platform music player focusing on a fast and easy-to-use interface for searching and playing your music. Summary of included features :
  • Search and play your local music library.
  • Listen to internet radio from Last.fm, SomaFM and Magnatune.
  • Tabbed playlists, import and export M3U, XSPF, PLS and ASX.
  • Visualisations from projectM.
  • Transcode music into MP3, Ogg Vorbis, Ogg Speex, FLAC or AAC
  • Edit tags on MP3 and OGG files, organise your music.
  • Download missing album cover art from Last.fm.
  • Native desktop notifications using libnotify.
  • Supports MPRIS, or remote control using the command-line.
  • Remote control using a Wii Remote, MPRIS or the command-line.
  • Copy music to your iPod, iPhone, MTP or mass-storage USB player.
  • Queue manager.
It is largely a port of Amarok 1.4, with some features rewritten to take advantage of Qt4.
Code Blocks
Code::Blocks is a C++ IDE built specifically to meet the most demanding needs of its users. It was designed, right from the start, to be extensible and configurable.
CodeLite
CodeLite is a cross platform IDE for the C/C++ programming languages. Particular features are its excellent code-completion and refactoring. It has generic support for compilers, with built-in support for GCC and Clang. It supports debugging with both GDB and LLDB. It comes with many plugins, including ones for Git and Subversion, qmake, CMake, cscope and Cppcheck.
Commoncpp Heckert gnu.tiny.png
Common C++ is a C++ class library that abstracts various system services in a portable manner, thereby making the creation of portable applications much easier. It is portable code, with very low runtime overhead, that works well on a very wide range of target platforms and C++ compilers in everyday use. It includes the 'ape' project, which was formerly a separate package. Common C++ manages threads, synchronization, and network sockets by offering portable C++ classes that abstract these services, as well as supporting "serial" I/O, daemon specific event logging, object serialization (persistence), block/record/page/ oriented file I/O, and configuration file parsing. It also provides an inheritable class architecture for your application that exploits C++ as needed. There are two source trees: one for "POSIX" systems such as GNU/Linux and the Hurd, the other for the Windows API. This makes Common C++ portable at the source level, as the two trees implement a functionally similar class interface. Commoncpp also includes uCommon C++, a lightweight C++ library with features such as rtti and exception handling removed. It is intended for programs linking to C libraries and not the standard C++ library.
Coolkey
Linux Driver support for the CoolKey and Common Access Card (CAC) smart card security keys used in a Public Key Infrastructure (PKI). The libpkcs11 module allows use of Smart Cards in applications that use mozilla Network Security Services (NSS).
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.
Cssc Heckert gnu.tiny.png
CSSC is the GNU project's replacement for the traditional Unix SCCS suite. It aims for full compatibility (including precise nuances of behaviour, support for all command-line options, and in most cases bug-for-bug compatibility) and comes with an extensive automated test suite. If you currently use SCCS for version control, you should be able to just drop in CSSC, even if you have a large number of shell scripts which are layered on top of SCCS and depend on it. This will let you to develop on and for GNU/Linux if your source code exists only in an SCCS repository. CSSC also lets you migrate to a more modern version control system.
CubicSDR
CubicSDR "allows you to navigate the radio spectrum and demodulate any signals you might discover" utilizing a modular 'piping' architecture that simplifies real-time analysis of discovered signals. CubicSDR creates live "waterfall" visual graphs representing a spectrum bandwidth and associated signal intensity.
Cursynth Heckert gnu.tiny.png
Cursynth is a polyphonic music synthesizer that runs graphically inside your terminal. You can play Cursynth as a standalone soft-synth with your computer keyboard or MIDI keyboard.
CuteCom
Cutecom is a graphical serial terminal, like minicom. It is aimed mainly at hardware developers or other people who need a terminal to talk to their devices. It features lineoriented interface instead of character-oriented, xmodem, ymodem, zmodem support (requires the lrzsz package) and hexadecimal input and output among other things. It is written using the Qt library by Trolltech (www.trolltech.com).
DBG-Client
'DBG-Client' is the client for the DBG debugger and profiler for the PHP programming language.
DUNE-Common
DUNE, the Distributed and Unified Numerics Environment is a modular toolbox for solving partial differential equations (PDEs) with grid-based methods. It supports the easy implementation of methods like Finite Elements (FE), Finite Volumes (FV), and also Finite Differences (FD). DUNE is free software licensed under the GPL (version 2) with a so called "runtime exception" (see license). This licence is similar to the one under which the libstdc++ libraries are distributed. Thus it is possible to use DUNE even in proprietary software. The underlying idea of DUNE is to create slim interfaces allowing an efficient use of legacy and/or new libraries. Modern C++ programming techniques enable very different implementations of the same concept (i.e. grids, solvers, ...) using a common interface at a very low overhead. Thus DUNE ensures efficiency in scientific computations and supports high-performance computing applications. DUNE is based on the following main principles:
  • Separation of data structures and algorithms by abstract interfaces.- This provides more functionality with less code and also ensures maintainability and extendability of the framework.
  • Efficient implementation of these interfaces using generic programming techniques.
  • Static polymorphism allows the compiler to do more optimizations, in particular function inlining, which in turn allows the interface to have very small functions (implemented by one or few machine instructions) without a severe performance penalty. In essence the algorithms are parametrized with a particular data structure and the interface is removed at compile time. Thus the resulting code is as efficient as if it would have been written for the special case.
  • Reuse of existing finite element packages with a large body of functionality.- In particular the finite element codes UG, ALBERTA, and ALUGrid have been adapted to the DUNE framework. Thus, parallel and adaptive meshes with multiple element types and refinement rules are available. All these packages can be linked together in one executable.
  • The framework consists of a number of modules which are downloadable as separate packages. The current core modules are:
  • dune-common- contains the basic classes used by all DUNE-modules. It provides some infrastructural classes for debugging and exception handling as well as a library to handle dense matrices and vectors.
  • dune-grid- is the most mature module. It defines nonconforming, hierarchically nested, multi-element-type, parallel grids in arbitrary space dimensions. Graphical output with several packages is available, e.g. file output to IBM data explorer and VTK (parallel XML format for unstructured grids). The graphics package Grape has been integrated in interactive mode.
  • dune-istl (Iterative Solver Template Library)- provides generic sparse matrix/vector classes and a variety of solvers based on these classes. A special feature is the use of templates to exploit the recursive block structure of finite element matrices at compile time. Available solvers include Krylov methods, (block-) incomplete decompositions and aggregation-based algebraic multigrid.
DUNE-Grid
DUNE, the Distributed and Unified Numerics Environment is a modular toolbox for solving partial differential equations (PDEs) with grid-based methods. It supports the easy implementation of methods like Finite Elements (FE), Finite Volumes (FV), and also Finite Differences (FD). DUNE is free software licensed under the GPL (version 2) with a so called "runtime exception" (see license). This licence is similar to the one under which the libstdc++ libraries are distributed. Thus it is possible to use DUNE even in proprietary software. The underlying idea of DUNE is to create slim interfaces allowing an efficient use of legacy and/or new libraries. Modern C++ programming techniques enable very different implementations of the same concept (i.e. grids, solvers, ...) using a common interface at a very low overhead. Thus DUNE ensures efficiency in scientific computations and supports high-performance computing applications. DUNE is based on the following main principles:
  • Separation of data structures and algorithms by abstract interfaces.- This provides more functionality with less code and also ensures maintainability and extendability of the framework.
  • Efficient implementation of these interfaces using generic programming techniques.
  • Static polymorphism allows the compiler to do more optimizations, in particular function inlining, which in turn allows the interface to have very small functions (implemented by one or few machine instructions) without a severe performance penalty. In essence the algorithms are parametrized with a particular data structure and the interface is removed at compile time. Thus the resulting code is as efficient as if it would have been written for the special case.
  • Reuse of existing finite element packages with a large body of functionality.- In particular the finite element codes UG, ALBERTA, and ALUGrid have been adapted to the DUNE framework. Thus, parallel and adaptive meshes with multiple element types and refinement rules are available. All these packages can be linked together in one executable.
  • The framework consists of a number of modules which are downloadable as separate packages. The current core modules are:
  • dune-common- contains the basic classes used by all DUNE-modules. It provides some infrastructural classes for debugging and exception handling as well as a library to handle dense matrices and vectors.
  • dune-grid- is the most mature module. It defines nonconforming, hierarchically nested, multi-element-type, parallel grids in arbitrary space dimensions. Graphical output with several packages is available, e.g. file output to IBM data explorer and VTK (parallel XML format for unstructured grids). The graphics package Grape has been integrated in interactive mode.
  • dune-istl (Iterative Solver Template Library)- provides generic sparse matrix/vector classes and a variety of solvers based on these classes. A special feature is the use of templates to exploit the recursive block structure of finite element matrices at compile time. Available solvers include Krylov methods, (block-) incomplete decompositions and aggregation-based algebraic multigrid.
DUNE-ISTL
DUNE, the Distributed and Unified Numerics Environment is a modular toolbox for solving partial differential equations (PDEs) with grid-based methods. It supports the easy implementation of methods like Finite Elements (FE), Finite Volumes (FV), and also Finite Differences (FD). DUNE is free software licensed under the GPL (version 2) with a so called "runtime exception" (see license). This licence is similar to the one under which the libstdc++ libraries are distributed. Thus it is possible to use DUNE even in proprietary software. The underlying idea of DUNE is to create slim interfaces allowing an efficient use of legacy and/or new libraries. Modern C++ programming techniques enable very different implementations of the same concept (i.e. grids, solvers, ...) using a common interface at a very low overhead. Thus DUNE ensures efficiency in scientific computations and supports high-performance computing applications. DUNE is based on the following main principles:
  • Separation of data structures and algorithms by abstract interfaces.- This provides more functionality with less code and also ensures maintainability and extendability of the framework.
  • Efficient implementation of these interfaces using generic programming techniques.
  • Static polymorphism allows the compiler to do more optimizations, in particular function inlining, which in turn allows the interface to have very small functions (implemented by one or few machine instructions) without a severe performance penalty. In essence the algorithms are parametrized with a particular data structure and the interface is removed at compile time. Thus the resulting code is as efficient as if it would have been written for the special case.
  • Reuse of existing finite element packages with a large body of functionality.- In particular the finite element codes UG, ALBERTA, and ALUGrid have been adapted to the DUNE framework. Thus, parallel and adaptive meshes with multiple element types and refinement rules are available. All these packages can be linked together in one executable.
  • The framework consists of a number of modules which are downloadable as separate packages. The current core modules are:
  • dune-common- contains the basic classes used by all DUNE-modules. It provides some infrastructural classes for debugging and exception handling as well as a library to handle dense matrices and vectors.
  • dune-grid- is the most mature module. It defines nonconforming, hierarchically nested, multi-element-type, parallel grids in arbitrary space dimensions. Graphical output with several packages is available, e.g. file output to IBM data explorer and VTK (parallel XML format for unstructured grids). The graphics package Grape has been integrated in interactive mode.
  • dune-istl (Iterative Solver Template Library)- provides generic sparse matrix/vector classes and a variety of solvers based on these classes. A special feature is the use of templates to exploit the recursive block structure of finite element matrices at compile time. Available solvers include Krylov methods, (block-) incomplete decompositions and aggregation-based algebraic multigrid.
Daily Pictures
Features
  • receive a notification every day to take a picture
  • save the picture right inside the app (you can delete it from your Camera Roll)
  • share pictures from the app, or save it back to Camera Roll
  • add a title or note to each picture
  • keep track of interesting statistics (how many pictures you’ve taken, how many are left to take this year, how much space you’re using)
  • works on iOS 5 and iOS 6 (and iOS 7 of course)
Ddd Heckert gnu.tiny.png
GNU DDD, the Data Display Debugger, is a graphical front-end for command-line debuggers. Many back-end debuggers are supported, notably the GNU debugger, GDB. In addition to usual debugging features such as viewing the source files, DDD has additional graphical, interactive features to aid in debugging.
Ddrescue Heckert gnu.tiny.png
Ddrescue is a data recovery tool. It copies data from one file or block device (hard disc, cdrom, etc) to another, trying hard to rescue data in case of read errors. The basic operation of ddrescue is fully automatic. That is, you don't have to wait for an error, stop the program, read the log, run it in reverse mode, etc. If you use the logfile feature of ddrescue, the data is rescued very efficiently (only the needed blocks are read). Also you can interrupt the rescue at any time and resume it later at the same point.
Debea Database Library
Debea is an Object Relational Mapping library (ORM) for C++. It allows you to map C++ objects to relations in various SQL and file databases.
Decibel
Decibel is a realtime communication framework based on Telepathy. It is meant to integrate VoIP, text chat, CTI (computer telephone integration), and similar applications into the user's desktop. Decibel consists of a desktop neutral policy daemon called Houston and desktop specific components for user interaction.
Dimnum
The dimnum library contains templated C++ classes for storage and manipulation of dimensionful numbers, as encountered in physics and engineering. Since it uses templates, there is no size or speed penalty with respect to normal variables (depending on compiler optimisations).
Dinrhiw2
Primary aim of the dinrhiw is to be linear algebra library and machine learning library. For this reason dinrhiw implements PCA and neural network codes. Currently, the neural network code only supports:
  • hamiltonian monte carlo sampling (HMC) and simple bayesian neural network
  • second order L-BFGS search
  • gradient descent (backpropagation)
As well as mathematical routines for arbitrary precision mathematics, hermite curve interpolation and many other things.
DirectFB
'DirectFB' is a thin library that provides developers with hardware graphics acceleration, input device handling and abstraction, an integrated windowing system with support for translucent windows and multiple display layers on top of the framebuffer device. It is a complete hardware abstraction layer with software fallbacks for every graphics operation that is not supported by the underlying hardware.
Dmbcs-kraken-api
Kraken is a virtual currency exchange, which also handles fiat (real) currency amounts. Subscribers to the service have an account with associated funds attached. The web site (www.kraken.com) provides the user with an account overview (i.e. current balance), currency-pair exchange market status (history of prices and current order book), and the means to place entries on the order book; bids for a currency which can be immediately met with orders to sell the currency are automatically transacted, with the Kraken site taking a small and variable cut of the deal. Kraken also provide a stateless, web-based API by which all of the above actions can be undertaken programmatically. This is fully open, and described at the Kraken exchange web site. The DMBCS client-side C++ library implements all features of the API in a fully encapsulated C++ class, allowing users to implement algorithmic or robotic trading and dynamic exchange modelling.
DnDD
I named this program DNDD. Abbreviation for discussion & democratic decision making. DNDD is a Mysql client program. DNDD is also a bulletin board program focused on decision making procedure. You can use DNDD as a normal bulletin board or as a platform for some group of people to discuss some serious matters and decide what to do. Because DNDD have innate ability to vote and calculate votes, you can use it for class chief election or board meeting.
Dolphin
Dolphin is the default file manager in the KDE Plasma Workspaces, intended to be both powerful and easy to use.


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

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