Free objective modula 2 1.00 reference implementation software for linux

Hex-a-hop is a puzzle game based on hexagonal tiles. There is no time limit and no real-time elements.

The objective is simply to destroy all the green hexagonal tiles on each of the 100 levels. As you progress through the game, more types of tiles are introduced which make things more difficult and interesting (hopefully).

The project is built on top of SDL, which is an open-source layer for direct media access.

QiPan project consists of the reference implementation of the CXBoard communication protocol.
QiPan is the reference implementation of a cxboard compliant interface program.
CXBoard is a communication protocol, modeled after XBoard and UCI, used for communication between Chinese Chess engines and interfaces.
Enhancements:
- This release contains new pieces and additional features that make it nicer to use and able to connect to 3rd party engines.

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.

Template Numerical Toolkit (TNT) is a collection of interfaces and reference implementations of numerical objects useful for scientific computing in C++.
The toolkit defines interfaces for basic data structures, such as multidimensional arrays and sparse matrices, commonly used in numerical applications. Template Numerical Toolkits goal is to provide reusable software components that address many of the portability and maintennace problems with C++ codes.
TNT provides a distinction between interfaces and implementations of TNT components. For example, there is a TNT interface for two-dimensional arrays which describes how individual elements are accessed and how certain information, such as the array dimensions, can be used in algorithms; however, there can be several implementations of such an interface: one that uses expression templates, or one that uses BLAS kernels, or another that is instrumented to provide debugging information.
By specifying only the interface, applications codes may utilize such algorithms, while giving library developers the greatest flexibility in employing optimization or portability strategies.
TNT Data Structures
- C-style arrays
- Fortran-style arrays
- Sparse Matrices
- Vector/Matrix
TNT utilities
- array I/O
- math routines (hypot(), sign(), etc.)
- Stopwatch class for timing measurements
Libraries that utilize TNT
- JAMA: a linear algebra library with QR, SVD, Cholesky and Eigenvector solvers.
- old (pre 1.0) TNT routines for LU, QR, and Eigenvalue problems

JXTA platform is an open network computing platform designed for peer-to-peer (P2P) computing. The JXTA platform standardizes the manner in which peers:
- Discover other peers
- Advertise Peer resources (Peer, PeerGroup, Service and Pipe Advertisements)
- Communicate with each other (Pipes)
- Cooperate with each other to form secure peer groups (group membership)
The Platform project is a Java Standard Edition reference implementation of the JXTA protocols.
The Platform project was the original JXTA implementation and was built in Java, because Java enabled us to rapidly prototype and test new ideas and develop a more robust implementation.
Java is available on most client platforms (Unix, Windows, MacOS X, etc.) and allows us to reach the maximum number of potential users.

Network Transparent Widgets short from NTW, is a protocol and application framework that allows a single server to serve thousands of remote GUI applications.
The client applications are nearly indistinguishable from local, native applications. The protocol is language and architecture neutral. Server language bindings for C and Java are in heavy development.
Main features:
Speed: Remote apps can run at a speed which is nearly indistinguishable from a locally running application. Since the client draws the widgets natively, its not necessary to transfer graphical data, only widget state data. This can be done asynchronously, so the responsiveness of the UI never suffers.
Persistence: Its just as easy to write the ntw protocol data to disk as it is to the network, so the state of the entire gui application can be easily saved. This also happens transparently, so the developer doesnt have to spend any time loading and saving data. Also, if a network connection dies or the client computer loses power, the application can be restarted from the point of failure at the next connection.
Portability: using the protocol, an ntw server application running on a Unix machine could talk to an ntw client for Windows, and vice versa. So a developer could write a program on Linux that could be run from any OS without any porting necessary. Any language or platform that can read and write data to a network can use the protocol to create gui apps.
Scalability: Since the ntw server does not store or draw widget graphics, the memory and computational overhead of running an ntw application is much less than a comparable X Window application. A low end machine could easily serve hundreds of remote clients.
Productivity: Users can run ntw apps without installing anything but the client. Developers can release new versions of their apps without the users having to do anything, much like a web page.
Reference Implementation:
The current reference implementation of the client implements most of the widgets in the Gtk toolkit, and is written in C using the GTK+ 2.0 toolkit for drawing the widgets and handling events. It compiles and runs on FreeBSD, Linux, and Windows, and likely other Unix variants also. Youll need the GTK+ toolkit installed to run the client, and the GTK+ development headers to compile it.
The source code also include a server reference implementation and a sample server application. The "server" is really a set of C language bindings to functions that create and send ntw widget data. The bindings can be used in much the same way as any other GUI toolkit. See the file "ntwtest.c" for the example application. Its been tested on FreeBSD, Linux, and Windows XP. The server library should compile and run on most systems with a C compiler and support for sockets, without the need for any additional libraries.
The protocol is defined by the two header files, ntw.h and ntw_signals.h. These are C header files that describe exactly the byte layout for each of the widgets and all of the opcodes and events that can be sent.
There are still some widgets missing, and some of the signals raised by GTK are not yet handled in the protocol. This will be fixed in the near future.
Note: Although the reference implementation is coded in GTK, the NTW protocol is designed to be independent of any particular widget toolkit. GTK was picked due to favorable design features and a favorable license.
Enhancements:
- 02JUL06 - Fixed bug in update.c where spin_button was switched with slider
- 02JUL06 - Removed status field from image_buffer widget protocol

LAPACK is a linear algebra library, based on LINPACK and EISPACK.
LAPACK is written in Fortran77 and provides routines for solving systems of simultaneous linear equations, least-squares solutions of linear systems of equations, eigenvalue problems, and singular value problems.
The associated matrix factorizations (LU, Cholesky, QR, SVD, Schur, generalized Schur) are also provided, as are related computations such as reordering of the Schur factorizations and estimating condition numbers. Dense and banded matrices are handled, but not general sparse matrices. In all areas, similar functionality is provided for real and complex matrices, in both single and double precision.
If youre uncertain of the LAPACK routine name to address your applications needs, check out the LAPACK Search Engine.
The original goal of the LAPACK project was to make the widely used EISPACK and LINPACK libraries run efficiently on shared-memory vector and parallel processors.
On these machines, LINPACK and EISPACK are inefficient because their memory access patterns disregard the multi-layered memory hierarchies of the machines, thereby spending too much time moving data instead of doing useful floating-point operations.
LAPACK addresses this problem by reorganizing the algorithms to use block matrix operations, such as matrix multiplication, in the innermost loops. These block operations can be optimized for each architecture to account for the memory hierarchy, and so provide a transportable way to achieve high efficiency on diverse modern machines. We use the term "transportable" instead of "portable" because, for fastest possible performance, LAPACK requires that highly optimized block matrix operations be already implemented on each machine.
LAPACK routines are written so that as much as possible of the computation is performed by calls to the Basic Linear Algebra Subprograms (BLAS). While LINPACK and EISPACK are based on the vector operation kernels of the Level 1 BLAS, LAPACK was designed at the outset to exploit the Level 3 BLAS -- a set of specifications for Fortran subprograms that do various types of matrix multiplication and the solution of triangular systems with multiple right-hand sides.
Because of the coarse granularity of the Level 3 BLAS operations, their use promotes high efficiency on many high-performance computers, particularly if specially coded implementations are provided by the manufacturer.
Highly efficient machine-specific implementations of the BLAS are available for many modern high-performance computers. For details of known vendor- or ISV-provided BLAS, consult the BLAS FAQ. Alternatively, the user can download ATLAS to automatically generate an optimized BLAS library for the architecture. A Fortran77 reference implementation of the BLAS in available from netlib; however, its use is discouraged as it will not perform as well as a specially tuned implementation.
Enhancements:
- The BLAS implementation was completed.
- The number of timers accessible was increased.
- Code cleanups and bugfixes were made.

The "Open Device Monitoring and Tracking Protocol", otherwise known as OpenDMTP, is a protocol and framework that allows bi-directional data communications between servers and devices (clients) over the Internet and similar networks.
OpenDMTP is a highly configurable and extensible protocol for communicating with mobile devices.
OpenDMTP is particularly geared towards Location-based information (LBS) such as GPS, as well as temperature and other data collected in remote-monitoring devices. OpenDMTP is small, and is especially suited for micro-devices such as PDAs, mobile phones, and custom OEM devices.
We saw a need for a communications protocol that allowed high-latency, low-bandwidth (HL/LB) devices to transmit location data to monitoring-systems. Because these devices often have limited network connectivity, the protocol needed to be small and efficient. Example devices include mobile phones, PDAs, OEM micro-devices (alarm systems, temperature monitors, etc.), and more.
There are many mobile GPS tracking devices on the market today with their own closed proprietary protocols. Searching the web for open protocols revealed only a few available for transferring data (including GPS information) between devices. However these solutions are generally designed for non-mobile applications and/or lack some of the low-bandwidth, configurable, and extensible features that mobile applications require.
Main features:
- Small Footprint: Mobile devices typically have limited resources on which to run client code (ie. memory, processor speed). An open protocol designed with this in mind should be optimized to allow efficient implementation and should easily support devices such as PDAs, mobile phones, GPS monitoring devices, and other OEM micro-devices.
- Network Efficient: Mobile devices typically have limited network connectivity, and in some cases data communication can be quite expensive (e.g. satellite). Because of this the protocol needs to be efficient in its dialog between the client and server. The communication needs to be optimized such that the necessary information can be conveyed with a minimum number of bytes in the least amount of time.
- Bi-directional: Some devices can support two-way communication (ie. GPRS, or other socket based connections), while others may only support one-way communication (ie. some satellite communication systems). With this in mind, a protocol should be designed to support both duplex (two-way) and simplex (one-way) communication.
- Transport Media: Differrent mobile applications will have their own unique way of communicating data back to the server. Some may use GPRS, or socket based communication, others may use satellite communication, while still others may use other forms of wireless communication, such as BlueTooth. The design of the protocol should be able to encompass all such transport media types, regardless of the type of transport in use.
- Flexible Data Encoding: Most types of transport media allow for the transmission of binary encoded data. However, there may be some forms of media for which an ASCII encoded data packet is much better suited. A protocol designed with this in mind should be able to support both types of data encoding.
- Configurable Messages: Due to the broad range of data types used in mobile applications, the protocol should be flexible enough to define standard messages, yet still allow custom messages within the framework.
- Extensible: Not every mobile application is the same. Some require special handling and may have various types of inputs and outputs. A protocol designed for mobile applications should insure that the framework can be easily extended to incapsulate the specific needs of the device.
- Industry Compatibility: Having an open protocol insures better compatibility between different client devices and service providers.
- Reference Implementation: Having a reference implementation that showcases the major features of the protocol provides an easy starting point on which developers can add their own features and platform specific implementation without having to worry about how data gets from the client to the server.
OpenDMTP was specifically designed to suit all these needs, especially "Small Footprint" and "Network Efficiency". The typical data plan for GPRS communication, for instance, is usually 1Mb per month. OpenDMTP was designed to optimize packet encoding to allow the collection of GPS information packets once every 3 minutes, 24 hours a day, 30 days a month, and still stay under the 1Mb data plan limit.
While XML is very extensible, it fails the "Small Footprint" and "Network Efficiency" requirements. Thus, it was discounted as a viable protocol solution. Many mobile devices do not have the resources necessary to be able to provide full XML parsing functionality. And an XML packet may need to be several hundred bytes in length just to send a few bytes of actual data. This alone would make the solution cost prohibitive for high-cost transport media such as satellite.
OpenDMTP also includes a full-featured commercial quality reference implementation to jump-start development.
Enhancements:
- NEW: Minor optimizations made to message logging.
- FIX: Log file now properly displays account/device on client connection.