Free virtual machines software for linux

vlock project can lock one or more sessions on the Linux console. This is especially useful for Linux machines which have multiple users with access to the console.

One user may lock his or her session(s) while still allowing other users to use the system on other virtual consoles. If desired, the entire console may be locked and virtual console switching disabled.

endlos project is a fractal generator.
Main features:
- Platform independend: runs on any Java virtual machine (1.5 or later; 1.6 up to twice as fast!)
- Multithreaded: uses any amount of threads for faster calculation on computers with multiple cores/CPUs.
- Unlimited precision: high precision modes for 32, 64, 128 bit and unlimited calculations.
- Smooth coloring: days of boring low color stripes are gone.
- Random coloring: see color maps that nobody else has seen before!
- Color maps: support of color maps (*.map) - separat package with over 1600 color maps available.
- Draw modes: choose between draw modes to see pixel, line, block or only full image result.
- Fast zooming: get an instant preview of the location youre zooming into.
- File formats: any file format supported by the Java virtual machine (PNG, JPG, BMP, etc.).
- Multi Fractals: calculate as many fractals as you like at the same time.
- Automatic saving of settings: keep your sophisticated settings.

Ragel State Machine Compiler compiles finite state machines from regular languages into executable C/C++/Objective-C code. Ragel state machines can not only recognize byte sequences as regular expression machines do, but can also execute code at arbitrary points in the recognition of a regular language.
Ragel can also be thought of as a finite state transducer compiler where output symbols represent blocks of code that get executed instead of written to the output stream.
When you wish to write down a regular language you start with some simple regular language and build a bigger one using the regular language operators union, concatenation, kleene star, intersection and subtraction.
This is precisely the way you describe to Ragel how to compile your finite state machines. Ragel also understands operators that embed actions into machines and operators that control any non-determinism in machines.
Ragel FSMs are closed under all of Ragels regular language, action specification and priority assignment operators. This property allows arbitrary regular languages to be described. Complexity is limited only by available processing resources.
For example, you can make one machine that picks out specially formatted comments in C code, another machine that builds a list all function declarations and a third that identifies string constants then "or" them all together to make a single machine that performs all of these tasks concurrently and independently on one pass of the input.
Main features:
- Describe arbitrary state machines using regular language operators and/or state tables.
- NFA to DFA conversion.
- Hopcrofts state minimization.
- Embed any number of actions into machines at arbitrary places.
- Control non-determinism using priorities on transitions.
- Visualize output with Graphviz.
- Use byte, double byte or word sized alphabets.
- Generate C/C++/Objective-C code with no dependencies.
- Choose from table or control flow driven output.
Enhancements:
- The documentation and the Ruby code generator were improved.

LLVM is a compiler infrastructure designed for compile-time, link-time, runtime, and "idle-time" optimization of programs from arbitrary programming languages. LLVM currently supports compilation of C++ and C programs, using front-ends derived from gcc 3.4.
There is a demonstration front end, Stacker, which provides a simple forth-like language. Work is currently under way to provide a Java class file front-end, as well as other significant improvements.
- A compilation strategy designed to enable effective program optimization across the entire lifetime of a program. LLVM supports effective optimization at compile time, link-time (particularly interprocedural), run-time and offline (i.e., after software is installed), while remaining transparent to developers and maintaining compatibility with existing build scripts.
- A virtual instruction set - LLVM is a low-level object code representation that uses simple RISC-like instructions, but provides rich, language-independent, type information and dataflow (SSA) information about operands. This combination enables sophisticated transformations on object code, while remaining light-weight enough to be attached to the executable. This combination is key to allowing link-time, run-time, and offline transformations.
- A compiler infrastructure - LLVM is also a collection of source code that implements the language and compilation strategy. The primary components of the LLVM infrastructure are a GCC-based C & C++ front-end, a link-time optimization framework with a growing set of global and interprocedural analyses and transformations, static back-ends for the X86, PowerPC, IA-64, Alpha, & SPARC V9 architectures, a back-end which emits portable C code, and a Just-In-Time compiler for X86, PowerPC, and SPARC V9 processors.
LLVM does not imply things that you would expect from a high-level virtual machine. It does not require garbage collection or run-time code generation (In fact, LLVM makes a great static compiler!). Note that optional LLVM components can be used to build high-level virtual machines and other systems that need these services.
LLVM is a robust system, particularly well suited for developing new mid-level language-independent analyses and optimizations of all sorts, including those that require extensive interprocedural analysis.
LLVM is also a great target for front-end development for conventional or research programming languages, including those which require compile-time, link-time, or run-time optimization for effective implementation, proper tail calls or garbage collection.
We have an incomplete list of projects which have used LLVM for various purposes, showing that you can get up-and-running quickly with LLVM, giving time to do interesting things, even if you only have a semester in a University course. We also have a list of ideas for projects in LLVM.
Enhancements:
- In this version, the ARM backend is stable and fully supported, x86 backend supports MMX and PIC, and an MSIL (.NET) backend was added.
- A new loop rotation pass was added, and PassManager and loop strength reduction pass were improved.
- Integer types are now signless and can support arbitrary bitwidths.
- Support for software floating point was added, and inline assembly support is improved.
- Improved DWARF debug information and support for zero-cost DWARF exception handling are now available.
- There are major changes in the API and the bytecode format.

Scintilla is a free source code editing component. Scintilla comes with complete source code and a license that permits use in any free project or commercial product.

As well as features found in standard text editing components, Scintilla includes features especially useful when editing and debugging source code. These include support for syntax styling, error indicators, code completion and call tips.

The selection margin can contain markers like those used in debuggers to indicate breakpoints and the current line. Styling choices are more open than with many editors, allowing the use of proportional fonts, bold and italics, multiple foreground and background colours and multiple fonts.

The SinkWorld project investigates possible future directions for Scintilla to make it more flexible, robust, perform better and run on the .NET and Java virtual machines.

Development of Scintilla started as an effort to improve the text editor in PythonWin. After being frustrated by problems in the Richedit control used by PythonWin, it looked like the best way forward was to write a new edit control.

The biggest problem with Richedit and other similar controls is that they treat styling changes as important persistent changes to the document so they are saved into the undo stack and set the documents dirty flag. For source code, styling should not be persisted as it can be mechanically recreated.

Scintilla and SciTE are currently available for Intel Win32 and Linux compatible operating systems with GTK+.

VTD-XML is a "non-extractive" XML processing software API implementing Virtual Token Descriptor. Currently, VTD-XML only supports built-in entity references (" &s ><<less