[Mono-announce-list] Mono Roadmap.
Miguel de Icaza
31 Dec 2001 15:58:04 -0500
Various people have been asking me privately how the different
pieces of the JIT engine, the compiler and the class libraries fit
together, and how these relate to the recent announcements I have been
posting every day on the status of Mono.
* A Self Hosting Environment
A Self Hosting environment means that it will be possible to
develop and contribute to Mono on non-Windows platforms with
the Mircrosoft .NET SDK.
Given that our compiler is written in C# and that you will
most likely want to use C# to build your applications, this
means that the following things must happen:
* The C# compiler is complete and robust enough to
allow the ongoing development of the compiler itself
and the Mono class libraries.
* The JIT engine is available and mature enough to run
and execute the C# compiler and the class libraries.
* The class libraries on which the C# compiler depends
have enough functionality and are robust enough to
host the compiler.
* The C# compiler status
The C# compiler has to go through a number of phases:
* The compiler parses itself (April 2001)
* The compiler can compile itself (December 2001)
* The compiler generates correct CIL output (work in
progress, 146 out of 150 errors have been fixed,
only 4 more errors remain).
* The compiler generates correct code for itself.
Note that there is a difference between correct CIL output and
correct code. Correct CIL output means that the code is
"syntactically" ok to be executed by a JIT engine. But that
does not mean that the code generated is correct. That is the
* The JIT status
The JIT engine on Intel x86 is mature enough to run pretty
much anything we throw at it. It is lacking a GC engine, but
we are going to be deploying it in January.
After the JIT engine becomes feature complete we will be
working on optimization of the code generated, for now we will
focus on making the VM complete (For example, there are still
various issues that need to be addressed, like the stack
waking to enable the security system, enable the GC, etc).
For systems where the JIT has not been ported, we do provide
an interpreter which has also been pretty robust since October
this year. The interpreter is obviously slower than the JIT
engine, and it is only intended to be used as a quick way of
running your applications on platforms where the JIT engine
does not exist.
The major reason why an application would not run on Mono
right now is because the class libraries that they require are
either not present or are incomplete.
Dietmar has a number of pending patches to go into CVS, but he
could not get them into CVS before he went into vacation to
give us a window to fix last minute problems, so those patches
have not made it into CVS. They add full unicode support
through Glib/libiconv to Mono.
* The Class Libraries
From the compiler perspective, the major block requires is the
System.Reflection.Emit API. We have assembled enough
information by constructing the compiler to know all the
quirks that need to be implemented.
The current implementation can be used to generate small
application, but some bits are still missing. Paolo has been
working on this and has done a great job, but everytime I
improved the compiler, I added a new dependency (not related
to Reflection necessarly ;-).
So that will be taken care of in January.
Anyways, there are still a lot of other classes, more simple
that need to be worked on. As usual, we welcome your
Nick has a few ideas on how we can move along.
There are many classes that have still missing pieces or miss
a test suite. And you have no idea how important is a test
suite. That is what has allowed us to produce a C# compiler
in such a short time. Without the test suite, we would have
Anyways, I am looking forward to write my next generation set of GUI
applications using Mono ;-)
Best wishes and Happy New Year!