Free machines software for linux

Earth allows you to find files across a large network of machines and track disk usage in real time. The project consists of a daemon that indexes filesystems in real time and reports all the changes back to a central database.
This can then be queried through a simple, yet powerful, web interface. Think of it like Spotlight or Beagle but operating system independent with a central database for multiple machines.
Earth is initially focused on managing the explosion of data that occurs in digital visual effects work.
Enhancements:
- Many small usability improvements, several significant performance improvements for the Web application, reduced database size, code improvements, and a much improved command line interface to the Earth daemon.

SML is a "toy" machine language intended to teach basic processor concepts. This website contains an explanation and definition of SML, as well as an interpreter and example SML programs. GPLd source code for the interpreter is available, as well as binaries for Windows and Linux.

A machine language defines a set of instructions that a CPU can execute to perform operations. In other words, a machine language defines what you can do with your computer. Modern processors have very complex instruction sets; however, the simple language described here can give you an understanding of what is happening "under the hood" with your computer.

Machine language is the actual data that is directly run by the processor. Writing a program in machine language can therefore be advantageous if you need to save space or highly optimize your code. However, machine language is also not portable and can be difficult to understand and maintain.

Therefore, almost all code is now written in a higher level language, such as C, C++, Java, or scripting languages such as shell or perl. These languages all have their advantages and disadvantages as well, such as varying levels of portability, maintainability, scalability, and execution speed.

One level higher than machine language is assembly language. Assembly language is basically readable machine language. Instead of writing out the code bit-by-bit, you write out the code as a sequence of human readable instructions, which are then compiled almost directly into machine language.

Assembly language is almost always used instead of machine language when such a direct level of control is needed. For example, some games implement part of their code in assembly in order to maximize execution speed. Assembly can be "inlined" into some higher level languages, like C. This means that the assembly is defined as a callable procedure from within the C code.

Omnitty is a curses-based program that allows one to log into several machines simultaneously and interact with them, selectively directing input to individual machines or groups of selected machines.

You can run both line-oriented and screen oriented in the target machines, because Omnitty has built-in terminal emulation capability. When the window is large enough, Omnitty also displays a "summary area" for each machine, in which it shows what the latest output from the machine was, so you can have an idea of what is going on in each machine.

Joeq is a virtual machine and compiler infrastructure designed to facilitate research in virtual machine technologies such as Just-In-Time and Ahead-Of-Time compilation, advanced garbage collection techniques, distributed computation, sophisticated scheduling algorithms, and advanced run time techniques.
Joeq is entirely implemented in Java, leading to reliability, portability, maintainability, and efficiency. It is also language-independent, so code from any supported language can be seamlessly compiled, linked, and executed -- all dynamically.
Each component of the virtual machine is written to be independent with a general but well-defined interface, making it easy to experiment with new ideas.
Joeq is released as open source software, and is being used as a framework by researchers on five continents on topics ranging from automatic distributed virtual machines to whole-program pointer analysis.
Joeq is a virtual machine and compiler infrastructure designed to be a platform for research in compilation and virtual machine technologies. We had three main goals in designing the system. First and foremost, we wanted the system to be flexible. We are interested in a variety of compiler and virtual machine research topics, and we wanted a system that would not be specific to researching a particular area.
For example, we have interest in both static and dynamic compilation techniques, and in both type-safe and unsafe languages. We wanted a system that would be as open and general as possible, without sacrificing usability or performance.
Second, we wanted the system to be easy to experiment with. As its primary focus is research, it should be straightforward to prototype new ideas in the framework. With this in mind, we tried to make the system as modular as possible, so that each component is easily replaceable. Learning from our experience with Jalapeno, another virtual machine written in Java, we decided to implement the entire system in Java.
This makes it easy to quickly implement and prototype new ideas, and features like garbage collection and exception tracebacks ease debugging and improve productivity. Java, being a dynamic language, is also a good consumer for many of our dynamic compilation techniques; the fact that our dynamic compiler can compile the code of the virtual machine itself means that it can dynamically optimize the virtual machine code with respect to the application that is running on it. Javas object-oriented nature also facilitates modularity of the design and implementation.
Third, we wanted the system to be useful to a wide audience. The fact that the system is written in Java means that much of the system can be used on any platform that has an implementation of a Java virtual machine. The fact that Joeq supports popular input languages like Java, C, C++, Fortran, and even x86 binary code increases the scope of input programs. We released the system on the SourceForge web site as open source under the Library GNU Public License.
It has been picked up by researchers on five continents for various purposes, among them: automatic extraction of component interfaces, static whole-program pointer analysis, context-sensitive call graph construction, automatic distributed computation, versioned type systems for operating systems, sophisticated profiling of applications, advanced dynamic compilation techniques, system checkpointing, anomaly detection, secure execution platforms and autonomous systems. In addition, Joeq is now used as the basis of the Advanced Compilation Techniques class taught at Stanford University.
Joeq supports two modes of operation: native execution and hosted execution. In native execution, the Joeq code runs directly on the hardware. It uses its own run-time routines, thread package, garbage collector, etc. In hosted execution, the Joeq code runs on top of another virtual machine. Operations to access objects are translated into calls into the reflection library of the host virtual machine.
The user code that executes is identical, and only a small amount of functionality involving unsafe operations is not available when running in hosted execution mode. Hosted execution is useful for debugging purposes and when the underlying machine architecture is not yet directly supported by Joeq. We also use hosted execution mode to bootstrap the system and perform checkpointing, a technique for optimizing application startup times.
Joeq system consists of seven major parts:
- Front-end: Handles the loading and parsing of input files, such as Java class files, SUIF files, and binary object files.
- Compiler: A framework for performing analyses and optimizations on code. This includes the intermediate representation (IR) of our compiler.
- Back-end: Converts the compilers intermediate representation into native, executable code. This code can be output to an object file or written into memory to be executed. In addition, it generates metadata about the generated code, such as garbage collection maps and exception handling information.
- Interpreter: Directly interprets the various forms of compiler intermediate representations.
- Memory Manager: Organizes and manages memory. Joeq supports both explicitly-managed and garbage-collected memory.
- Dynamic: Provides profile data to the code analysis and optimization component, makes compilation policy decisions, and drives the dynamic compiler.
- Run-time Support: Provides runtime support for introspection, thread scheduling, synchronization, exception handling, interfacing to external code, and language-specific features such as dynamic type checking.

A highly responsive Turing machine simulator written in Tcl/Tk. Contains many examples (unary and binary addition, subtraction, multiplication, a 5-state busy beaver, 2 string parsing examples, divisibility test, primality test), a theoretical introduction to Turing machines, a proof of the undecidability of the halting problem and pointers to further literature.

GladeNetSend is a GTK- based NetSend GUI for linux for sending and recieving net send from linux/windows machines.
Uses Samba to send and recieve messages. It can be minimized into the system tray and a popup window will appear as soon as a message is recieved.
Enhancements:
- if the icon file is not found, "NetSend" appears in the system Tray

The Kernel-Machine Library is a freely available (released under the GPL) C++ library to promote the use and progress of kernel machines. It is both for academic use and for developing real world applications.
The Kernel-Machine Library draws heavily from features of modern C++ such as template meta-programming to achieve high performance while at the same time offering a comfortable interface.
It enables compile-time selection of specialised algorithms on the basis of data types: for example, the specific case of a SVM in combination with a linear kernel can be computed by a specialised efficient algorithm.
The Kernel-Machine Library has implementations for the following kernel machines and their cited algorithms:
- Support Vector Machine [1, 2, 3]
- Relevance Vector Machine [4]
- Kernel Recursive Least Squares [5]
- Adaptive Sparseness using Jeffreys Prior [6]
- Smooth Relevance Vector Machine [7]
Up till now, the focus has been on regression. The handling of classification and ranking problems is being added.

Visual Automata Simulator is a tool for simulating, visualizing and transforming finite state automata and Turing Machines.
Visual Automata Simulator is a DFA, NFA and TM simulator.
Main features:
- Creates, simulates and transforms DFA and NFA machines
- Creates and simulates TM
- Batch tests for TM: useful features to test a bunch of files quickly!
- Easy-to-use GUI interface (multi-documents)
- Smart links between objects
- Machines can be drawn using the mouse - and resized at any time
- Multiple machines can be created in a single document
- Multiple documents can be opened at the same time
- Documents can be saved and reloaded from disk
- Debug mode to see exactly how the machine is working (each step has a different color)
- MacOS X GUI compliant.
Enhancements:
- FA and TM machine can be exported to EPS file
- integrated update manager
- preferences: can specify the character used to define an epsilon transition
- fixed a bug where epsilon transition were not considered when starting directly from a state instead of following a non-epsilon transition.