Free reference implementation software for linux

Objective Modula-2 programming language is a hybrid between Smalltalk and Modula-2 based on the object model and runtime of Objective-C.
The design is an example how native Cocoa/GNUstep support can be added to static imperative programming languages without implementing a bridge.
Objective Modula-2s scope encompasses the design of the Objective Modula-2 programming language and the implementation of a compiler to implement it. The initial compiler will generate Objective-C source code.
Enhancements:
- This code is used to verify ideas and concepts which come up in the course of defining the language.
- It is in an early stage, incomplete and subject to frequent changes.

ISC DHCP provides a freely redistributable reference implementation of all aspects of DHCP, through a suite of DHCP tools:
- A DHCP server
- A DHCP client
- A DHCP relay agent
These tools all use a modular API which is designed to be sufficiently general that it can easily be made to work on POSIX-compliant operating systems and also non-POSIX systems like Windows NT and MacOS.
The DHCP server, client and relay agent are provided both as reference implementations of the protocol and as working, fully-featured sample implementations.
Both the client and the server provide functionality that, while not strictly required by the protocol, is very useful in practice. DHCP server also makes allowances for non-compliant clients which one might still like to support.

The OpenSCADA project aims to create a full-featured and state-of-the-art SCADA (Supervisory Control and Data Acquisition) system to be used in industrial and civil engineering applications to control distributed systems from a master location.
The OpenSCADA project was started in order to create a common standard for SCADA applications. This includes specifications, interfaces and reference implementations.
Enhancements:
- This release has many new features and enhancements to existing functionality.
- The interfaces and the reference implementation were cleaned up a little bit.
- The new upstream version of Utgard was added.

Liboil is a library of simple functions that are optimized for various CPUs. These functions are generally loops implementing simple algorithms, such as converting an array of N integers to floating-point numbers or multiplying and summing an array of N numbers.
Such functions are candidates for significant optimization using various techniques, especially by using extended instructions provided by modern CPUs (Altivec, MMX, SSE, etc.).
Many multimedia applications and libraries already do similar things internally. The goal of this project is to consolidate some of the code used by various multimedia projects, and also make optimizations easier to use by a broader range of applications.
As of the liboil-0.3.0 release, Im actively encouraging other open-source projects to begin using liboil. Im happy to do much of work converting projects to use liboil, and especially, adding function classes and implementations to liboil that may be needed.
Liboil does not require GCC to build, but since it uses GCC-style inline assembly heavily, using GCC is strongly recommended. Versions of GCC prior to 3.2 are known to have problems compiling liboil correctly. GLib-2.0 is recommended to build a few of the examples, but is not required for anything that is installed.
Liboil may be modified and distributed in accordance with a very liberal license commonly referred to as "Two-Clause BSD". This license was chosen to make liboil useful to as many open-source projects as possible, and has the side effect of also allowing liboil to be used by proprietary applications.
Liboil has a number of function classes, which are primarily seen by a developer using the library as actual functions. One such function is:
void oil_tablelookup_u8 (uint8_t *dest, int dstr, uint8_t *src,
int sstr, uint8_t *table, int tablestride, int n);
This function performs a table lookup for each element in the src array, and puts the results in the dest array. In actuality, oil_tablelookup_u8 is a preprocessor macro that generates the correct code to call an indirect function.
Each function class has one or more function implementations, which are real functions that perform the exact same action as defined by the documentation for the function. Each class has one implementation that is the reference implementation. This reference implmentation is used to test the accuracy of other implementations.
Presumably, the non-reference implementations can perform the action faster than the reference implementation. Thus, the liboil initialization code (at runtime) checks each implementation in a class to determine the fastest implementation. Once this is done, the classs indirect function pointer points to the optimal implementation. After this, any calls to the function class (such as oil_tablelookup_u8() described above) will automatically be routed to the fastest implementation.
Implementations can be disabled either at compile time (e.g., assembly code for the wrong architecture) or at run time (e.g., implementation uses unsupported opcodes). This is done automatically. In addition, implementations may be disabled because they do not produce the same results as the reference implementation.
All of the function classes will be API and ABI stable through the lifetime of the 0.3 series. In addition, the 0.4 series will include a compatibility library that will provide the 0.3 ABI. This allows multiple liboil-using libraries to be linked into the same application without regard to using the same liboil ABI. New ABI versions (0.4, 0.5, etc.) are expected no less than 6 months apart. It is planned that all future versions of liboil will support at least two liboil ABI versions.
Enhancements:
- Support for the jpeg decoder was improved.
- C++ support was improved.
- Various speedups and smaller improvements were done.

Requirements:

• Python

Restlet is a framework that brings the simplicity and efficiency of the REST architectural style to Java developers.
Restlet project is composed of two parts, a neutral API and a reference implementation (Noelios Restlet Engine). It supports all REST concepts (resource, representation, data, connector, components, etc.) and is suitable for both client and server REST applications.
The server connectors provided are HTTP (via Mortbays Jetty or an adapter Servlet) and the client connectors are HTTP, JDBC, and SMTP (via JavaMail).
Mission
- Bring the simplicity and efficiency of the REST architectural style to Java developers
Restlet API
- Supports all REST concepts (resource, representation, data, connector, components, etc.)
- Suitable for both client and server Web applications
- Maplets support the concept of URIs as UI with advanced pattern matching features
- Chainlets filter calls to implement features such as logging and authentication
- Complete alternative to Servlet API with no external dependency (JAR < 60kb)
- Supports blocking and non-blocking NIO modes
Noelios Restlet Engine (NRE)
- Reference implementation of the Restlet API provided by Noelios Consulting (core JAR < 110kb)
- Server connector provided: HTTP (via Jetty connectors or Servlet connector)
- Client connectors provided: HTTP, JDBC, SMTP (via JavaMail)
- Supports logging (LogChainlet), authentication (GuardChainlet) and cool URIs rewriting (RedirectRestlet)
- Static files serving (DirectoryRestlet) with metadata association based on file extensions
- FreeMarker template representations as an alternative to JSP pages
- Automatic server-side content negotiation based on media type and language

nss_ldap is an RFC 2307-compliant set of C library extensions.
The resolution of the entities defined in RFC 2307 is generally performed by a set of UNIX C library calls (such as getpwnam() to return the attributes of a user).
The nss_ldap module provides the means for Solaris and Linux workstations to this information (such as users, hosts, and groups) from LDAP directories.
The module is the reference implementation of RFC 2307, and has been studied by vendors such as Sun (who developed the original Name Service Switch interface).
Main features:
- Support for the RFC 2307/RFC 2307bis (including netgroups) as well as user-defined schema
- Common implementation across platforms
- Support for Kerberos and SSL authentication, integrity and privacy
- Configuration file compatibility with pam_ldap
- Bootstraps from the DNS using SRV records
- Support for AIX, glibc, IRS and ONC+ name service switches
- Support for RFC 2307bis groups (including nested groups)
- Specific Active Directory support including incremental retrieval of multi-valued attributes
- Directory-based authentication for platforms that lack PAM (AIX 4.3.3)

JPOX is a free and fully compliant implementation of the JDO 1.0 and 2.0 specifications, providing transparent persistence of Java objects.
JPOX supports persistence to all of the major RDBMS on the market today, supporting all of the main Object-Relational Mapping (ORM) patterns demanded by todays applications, allows querying using either JDOQL or SQL, and comes with its own byte-code enhancer.
JPOX is available under an Open Source Apache 2 license, allowing access to not just a top quality Java persistence implementation but also to the source code, allowing you to contribute to the success story of the principal Open Source JDO implementation in the world today.
JPOX 1.0 implements the JDO 1 specification and passes the JDO 1 TCK. JPOX 1.1 (currently under development) extends the JPOX 1.0 capabilities to implement the JDO 2 specification.
JPOX 1.1 will become the JDO 2 Reference Implementation with its 1.1-final release. JPOX will be updated in future to also implement any EJB3 specification of Java persistence.
Whats New in 1.1.8 Stable Release:
- A bug has been fixed for attaching a CompoundIdentity 1-N relation.
- A bug has been fixed in the deletion of an embedded Collection.
- Improvements were made to the available SQL types for a datastore.
- Handling was added for read-only datastores and the action to perform if an update was attempted.
- Support was added for collections of interfaces where there is more than 1 implementation and discriminators are used.
- This is likely to be the final release in the 1.1 series.
Whats New in 1.2.0 Beta 3 Development Release:
- Full support was added for "ordered" Lists (JPA1).
- Support for many JPQL functions was added.
- Support for sequences was added in HSQLDB.
- More complete support was added for named sequences (JDO2).
- Full support for JPA1 lifecycle events was added.
- Support for JDO 2.1 XSDs was added.
- Support for optimistic transactions was rewritten, giving full support for all common scenarios.
- Support for mapping Strings to BLOB in Oracle was added.
- Support for cascade-persist=false (JPA1) was improved.
- Persistence-by-reachability was upgraded to handle the majority of cases at runtime rather than in metadata.
- Several bugs were fixed.