DataDraw is an ultra-fast persistent database for high performance programs
written in C. It's so fast that many programs keep all their data in a
DataDraw database, even while being manipulated in inner loops of compute
intensive applications. Unlike slow SQL databases, DataDraw databases are
compiled, and directly link into your C programs. DataDraw databases are
resident in memory, making data manipulation even faster than if they were
stored in native C data structures (really). Further, they can automatically
support infinite undo/redo, greatly simplifying many applications.
DataDraw databases can be persistent. Modifications to persistent data are
written to disk as they are made, which of course dramatically slows write
times. However, DataDraw databases can also be volatile. Volatile databases
exist only in memory, and only for the duration that your program needs it.
Volatile databases can be directly manipulated faster than C structures,
since data is better organized in memory to optimize cache performance.
DataDraw supports modular design. An application can have one or more common
persistent databases, and multiple volatile databases to support various
tools' data structures. Classes in a tool's database can extend classes in
the common database. DataDraw is also 64-bit optimized, allowing programs to
run much faster and in less memory than standard C programs using 64-bit
pointers. This is because DataDraw databases support over 4 billion objects
of a given class with 32-bit object references.
Diffuse is a graphical tool for merging and comparing text files. Diffuse is
able to compare an arbitrary number of files side-by-side and gives users the
ability to manually adjust line matching and directly edit files. Diffuse can
also retrieve revisions of files from Bazaar, CVS, Darcs, Git, Mercurial,
Monotone, RCS, Subversion, and SVK repositories for comparison and merging.
Some key features of Diffuse:
- ability to compare and merge an arbitrary number of files side-by-side
(n-way merges)
- line matching can be manually corrected by the user
- ability to directly edit files
- syntax highlighting
- Bazaar, CVS, Darcs, Git, Mercurial, Monotone, RCS, Subversion, SVK support
- support for UTF-8 encoded unicode
- unlimited undo
- easy keyboard navigation
CLOCC Port provides a portable interface to various features absent
from the ANSI Common Lisp standard, such as sockets, multiprocessing,
calling external programs, Gray streams etc.
DirectFB is a graphics library which was designed with embedded systems
in mind. It offers maximum hardware accelerated performance at a
minimum of resource usage and overhead.
The debug memory allocation or dmalloc library has been designed as a
portable drop in replacement for the system's memory management
routines while providing powerful debugging facilities configurable at
runtime. These facilities include such things as memory-leak
tracking, fence-post write detection, file/line number reporting, and
general logging of statistics. Online documentation is available at:
DMUCS is a system that allows a group of users to share a compilation farm.
Each compilation request from each user will be sent to the fastest available
machine, every time. The system has these fine qualities:
* Supports multiple users compiling simultaneously, and scales well to handle
the new loads.
* Supports multiple operating systems in the compilation farm.
* Uses all processors of a multi-processor compilation host.
* Makes best use of compilation hosts with widely differing CPU speeds.
* Guarantees that a compilation host will not be overloaded by compilations.
* Takes into account the load on a host caused by non-compilation tasks.
* Supports the dynamic addition and removal of hosts to the compilation farm.
* Works with distcc, which need not be altered in any way.
The LLVM Project is a collection of modular and reusable compiler and
toolchain technologies.
This port includes Clang (a C/C++/Objective-C compiler), LLD (a linker),
LLDB (a debugger), an OpenMP runtime library, and the LLVM infrastructure
these are built on.
DParser is a simple but powerful tool for parsing. You can specify the form of
the text to be parsed using a combination of regular expressions and grammar
productions. Because of the parsing technique (technically a scannerless GLR
parser based on the Tomita algorithm) there are no restrictions. The grammar
can be ambiguous, right or left recursive, have any number of null productions,
and because there is no separate tokenizer, can include whitespace in terminals
and have terminals which are prefixes of other terminals. DParser handles not
just well formed computer languages and data files, but just about any wacky
situation that occurs in the real world.
The dyncall library encapsulates architecture-, OS- and compiler-specific
function call semantics in a virtual "bind parameters from left to right
and then call" interface allowing programmers to call C functions in a
completely dynamic manner. In other words, instead of calling a function
directly, the dyncall library provides a mechanism to push the function
parameters manually and to issue the call afterwards.
This means, that a program can determine at runtime what function to
call, and what parameters to pass to it. The library is written in C and
assembly and provides a very simple C interface to program against.
The library comes in very handy to power flexible message systems,
dynamic function call dispatch mechanisms, closure implementations or
even to bridge different programming languages.
When it comes to language bindings, the dyncall library provides a clean
and portable C interface to dynamically issue calls to foreign code using
small kernels written in assembly. Instead of providing code for every
bridged function call, which unnecessarily results in code bloat, only a
couple of instructions are used to invoke every possible call.