Free implementations software for linux

Cyfer is a portable low-level cryptographic library with support for several programming languages. Cyfer provides implementations of many message digest (hash), block and stream cipher, and public-key algorithms.
The library is extremely modular, providing easy way to add or modify algorithm implementations, or even separating the particular algorithm from the library physically (suitable for embedded environments).
The generic API provides a consistent way to use the library algorithms, and allows for algorithm selection at either the compile time or at runtime, so the application which uses Cyfer can be completely unaware of the algorithm specifics.
Cyfer is a low-level library. It deals only with various algorithms, and completely avoids the problems of data representation.
This is most evident in public-key sections; cyfer completely avoids the existing Public Key Infrastructure (PKI) standards. If you need this functionality, use the excellent and free OpenSSL, or some similar library.
The library design concept emphasises on simplicity and elegance (of both the algorithm implementations (if possible:) and the support library code), not maximizing performance or minimizing memory footprint.
The algorithm implementations are straightforward, so they can be used for educational purposes.
Cyfer is portable to any platform with sane C development environment, the only requirement being the availability of the GMP (GNU Multiple Precision arithmetic) library.
As the GMP is used only for public-key cryptography, hash or symmetric cipher components should work everywhere.
Enhancements:
- moved wrappers to separate packages
- unbundled win32 support gmp library
- polished the documentation
- polished the build process and package creation

Fid Core Library is the core library for the Frigand Imperial Desktop, a genuine Unix desktop environment based around multiprocessing, text-stream IPC, and the "everything is a file" concept.
It supports Emacs-like extensibility, customizability, and built-in multi-buffer support.
Enhancements:
- This release adds testing support for the axioms over buffer implementations and user interfaces, a better implementation of interactive, and a new cursor movement mechanism that allows the user interface to manage point itself (and, hence, keep it always on a widget).

libcontain library provides a large and growing number of fast and thread-safe containter objects written in C and C++.
The libcontain library now provides the following container types:
- a series of hash tables libcontain includes the hash table implementation from GNU glib and a hash implementation in C++ it inherited from the libhash library it originates from. This latter has been rendered thread-safe in the 0.2 release and implements a linear hashing algorithm. A single hash table implementation that will replace them both is on the drawing boards and is intended to be thread-safe and non-blocking.
- an array (vector) implementation
libcontain currently includes a non-blocking array implementation. However, this implementation presents a race-condition in concurrent calls to any of its writing functions if the array is in the process of being resized. There is currently no known non-blocking way to solve this race condition. Help is welcome in this area.
- a binomial tree
The binomial tree provided by libcontain does not provide any algorithmic logic in its implementation: it is a generic container that can be used as the basis for other container implementations, such as a heap or a map (as a matter of fact, the heap and the map are both based on this binomial tree)
- a heap
libcontain provides an automatically sorting heap implementation that (obviously) uses a heap sort to sort the elements it contains. Unfortunately, the heap implementation is not non-blocking (although bases on a non-blocking binomial tree implementation). It contains four levels of locks: a reader count and a write lock at the level of the nodes, and a reader count and a write lock at the level of the container. The locks are posed on the container for as short a time as possible so at to prevent the progress of the algorithm to block too long. If anyone knows of a non-blocking heap algorithm, input is more than welcome.
- a list
libcontain provides a non-blocking list implementation based on an algorithm by M.M. Micheal (also the inventor of Safe Memory Reclamation on which libmemory is based).
a map
The map implementation included in libcontain is based on the binomial tree implementation. Unlike some implementations based on binary trees, this implementation stores values in each node of the tree (not just the leaf nodes) and therefore allows a more memory-efficient way to store information than hashes and other map implementations. Also, the map implementation does not use a "less" function but uses a three-way comparison to compare keys (much like the helper function used by qsort). The implementation is almost (but not quite) non-blocking: for most intents and purposes, there are no real locks: read and write operations may be re-directed along a branch of the binomial tree if a node that they traverse is being deleted, but will not block for that. However, a remove operation will wait for another remove operation to finish if it traverses a node being removed.
- a queue
a non-blocking queue implementation is provided
- a stack
a non-blocking stack implementation is also provided
In future versions, the hash implementation will be replaced by a non-blocking one and the remaining problems with the existing containers will (hopefully) be solved. Help is also needed to write the architecture-dependant code for non-IA32 platforms such as Sparc.
Enhancements:
- The 0.2 release introduces number of important new features including a heap and a map, both based on a lock-free binomial tree. It also includes the required memory management to make the containters impervious to the ABA problem and thus truly thread-safe.

Fast MD5 Implementation in Java is a heavily optimized implementation of the MD5 hashing algorithm written in Java.
Fast MD5 Implementation in Java includes an optional native method for even greater speed improvements.
How Fast Is It?
Short answer:Much faster than any other Java implementation that I have tested and (surprisingly) even faster than the native, non-Java MD5 implementation on some systems.
Long answer:First of all, it is important to note that the term "fast" is used here in relative terms. The implementation of the MD5 message digest algorithm available on this page is written in Java and is fast compared with other implementations written in Java, both because it is heavily optimized by itself and because there is an optional native method that makes it even faster when the platform supports it. How it compares to a sensible implementation written in a language, such as C, that is compiled directly to machine code, is heavily dependent upon how good of a job the JIT compiler in your JVM does in compiling the code or whether you are able to use the optional native method.
Enhancements:
- Martin West contributed a bug fix and some code refactoring to make all targets work out of the box in the Ant build file. Previously, the "dist" target did not work if the "docs" directory was not present.

JThread project provides some classes to make use of threads easy on different platforms.
The classes are actually rather simple wrappers around existing thread implementations.
The package contains two classes: JThread and JMutex, which (obviously) represent a thread and a mutex. For unix-like platforms, the class implementations use the pthread library. On an MS-Windows platform, native Win32 threads are used.
The library is totally FREE!
Enhancements:
- The JMutexAutoLock class was added.
- In Win32 and WinCE, it is now possible to use a critical section object instead of a mutex handle.

hfloat (for huge floats) is a library package for doing calculations with floating point numbers of extreme precision. hfloat library is optimised for computations with 1000 to several million digits.

The computations can be done in (almost) arbitrary radix. The library contains routines for addition, subtraction, multiplication, division, n-th power, square root, n-th root, logarithm, exponentiation and more.

There are implementations of several superlinear converging algorithms for the computation of pi. The computation of 1 million decimal digits of pi takes about 15 seconds on an AMD64/2.2GHz.

GMediaRender is a UPnP media renderer for POSIX-compliant systems, such as GNU/Linux or UNIX. It implements the server component that provides UPnP controllers a means to render media content (audio, video and images) from a UPnP media server.

MediaServer / AV

UPnP A/V is a three-tier system, consisting of Servers, Renderers and Controllers. With an A/V UPnP controller you can instruct a UPnP A/V Renderer (such as GMediaRender) to play multimedia content (pictures, music tracks, radio broadcasts, movies, ..) available from a UPnP A/V Server.

UPnP A/V components are available both as stand-alone consumer electronics devices, as well as are software-only implementations. Listed below are some software implementations which run on GNU/Linux.