* The Mono runtime The Mono runtime implements a JIT engine for the CIL virtual machine (as well as a byte code interpreter, this is to quickly port it to new systems), the class loader, the garbage collector, threading system and metadata access libraries. We currently have two runtimes: Currently both runtimes are missing garbage collection. We are planning on using the ORP GC engine and deploy it by middle January. * COM and XPCOM We plan on adding support for XPCOM on Unix and COM on Microsoft Windows later in our development process. ** Executing MSIL/CIL images The code will load an executable and map the references to external assemblies to our own version of the assemblies on Linux. Our roadmap looks like this, this has been updated as of Dec 18, 2001: A setup similar to the Kaffe JIT engine will be used to layout the code to support non-IA32 architectures. Our work will be focused on getting a IA32 version running first. The JIT engine should work on Linux and Win32, although you will need to install the CygWin32 development tools to get a Unix-like compilation environment (mostly we use GNU make in a few of the makefiles). ** JIT Engine (updated, Dec 18th, 2001) The JIT engine uses a code-generator generator approach for compilation. Given the properties of CIL byte codes, we can take full advantage of a real instruction selector for our code generator. There are a couple of books that deal with this technique: "A Retargetable C Compiler" and "Advanced Compiler Design and Implementation" are good references. You can also get a technical description of lbrug. A few papers that describe the instruction selector: ** Garbage Collection We will be using the Intel ORP GC engine as it provides a precise garbage collector engine, similar to what is available on the .NET environment. Although using a conservative garbage collector like Bohem's would work, all the type information is available at runtime, so we can actually implement a better collector than a conservative collector. ** IO and threading The ECMA runtime and the .NET runtime assume an IO model and a threading model that is very similar to the Win32 API. Dick Porter has been working on the Mono abstraction layer that allows our runtime to execute code that depend on this behaviour. ** Useful links Paolo Molaro found a few interesting links: ** PInvoke PInvoke is the mechanism we are using to wrap Unix API calls as well as talking to system libraries. Initially we used libffi, but it was fairly slow, so we have reused parts of the JIT work to create efficient PInvoke trampolines.