Mono 2.0 is out!

Today we released Mono 2.0 to the world. You can download sources and binaries from our download page. And our official release notes are up as well. This of course would not be possible without the open source contributors that worked tirelessly on Mono sending patches, fixing bugs, helping the community, answering questions, creating test cases and supporting us all these years.

Mono 2.0 is both a runtime for application and a kit for developers for writing applications with C# and other ECMA CLI languages for a wide spectrum of uses.

Big thanks go to the fantastic Mono team at Novell that has kept the excitement and the pace over all these years (we started in 2001), the large contributions from Mainsoft, Unity3D and our users that pushed us to fix bugs, implement new features and tune Mono. Also, we very much appreciate the work of the ECMA 334 and 335 committee members that worked on the CLI and C# specifications and everyone at Microsoft that answered our questions over the years and specially those that licensed code under open source licenses.

We originally started to work on Mono, because we wanted to make developers happier and more productive on Linux. We liked C#, we liked the CIL and we wanted to have those technologies available on our platform.

Since we have been active in the Linux Desktop world, it is not a surprise that the early use of Mono was mostly on Linux desktop applications, and Mono continues to shine there. Server-side use of Mono was a natural evolution and we soon were powering ASP.NET sites on Linux.

There is one area where we under-delivered in the past, and it has been a constant source of pain. Up until now, we did not have a working debugger. This has finally changed, and Mono 2.0 includes for the first time a debugger, the time for WriteLine() debugging is now behind us.

As the project matured, developers started taking advantage of Mono's open source nature: essentially .NET on their own terms. A platform that could be adapted, morphed, ported and modified to suit many different uses. Today Mono is embedded in portable mp3 players and powers Unity3D's game engine on the Apple iPhone, the Nintendo Wii, MacOS X and Windows (Some folks at Novell are working with Unity on bringing Unity3d to Linux!).

It has also been deployed to run code on large clusters of servers for SecondLife, powers our open source Silverlight implementation (Moonlight) and powers the popular DekiWiki: a Social Collaboration Tool.

Mono is a large project and it is hard to pick one feature to talk about as there are so many, so instead I put together a quick table of the major features that are part of this release:
Compiler Support .NET APIs Mono APIs
Mono's Open Source Compilers: Open Source Compilers: Commercial Compilers:
  • ISE's Eiffel.
  • Microsoft's C#.
  • Microsoft's F#.
  • Microsoft's VB.NET.
  • RemObject's Oxygene (Object Pascal).
And many more.
Core API:
  • 2.0 core APIs.
  • System, System.Xml.
  • 3.5 System.Core.
  • System.Drawing.
  • System.DirectoryServices.
  • System.Web.Services.
Windows.Forms 2.0:
  • Win32 driver.
  • Quartz/OSX driver.
  • Cairo/X11 Unix driver.
ASP.NET 2.0:
  • Core ASP.NET.
  • ASP.NET AJAX.
  • Apache and FastCGI integration.
ADO.NET 2.0 plus providers for:
  • Managed drivers: Postgresql, MS SQL Server, Sybase.
  • Semi-managed drivers: Firebird, IBM DB2, Oracle, Sqlite.
  • MySQL provides their own drivers.
GUI APIs:
  • Gtk# (Unix, Windows, MacOS X).
  • Cocoa# (MacOS X).
Mono Core:
  • Mono.Addins - Extensibility Framework.
  • Mono.Cairo - Cairo Graphics Binding.
  • Mono.Cecil - ECMA CIL Manipulation.
  • Xml.Relaxng.
  • Novell.Directory.Ldap
  • C5 - Generics Library.
Linux Specific: Other Ecosystem Libraries:
  • Bit# - Bittorrent client/server library.
  • Mono.Fuse - User-space file systems.
  • Mono.ZeroConf - Bonjour stack.
  • Mono.Nat - Network Address Translation.
  • Mono.Upnp - Universal Plug and Play.
  • Tao Framework - OpenGL, OpenAL, SDL and Cg bindings.

We have ported Mono to a wide variety of platforms and operating systems on this 1.0 to 2.0 cycle. These platforms include:

  • Linux (x86, x86-64, PowerPC32, Itanium, SPARC, ARM, s390, s390x.
  • Solaris (x86-64, SPARC).
  • MacOS X (x86, PowerPC32).
  • Windows (x86, support for x86-64 will come in Mono 2.2).
  • Nintendo's Wii.
  • iPhone/iPod Touch (ARM, limited functionality due to licensing requirements; I will blog later this week about this).
  • *BSD (x86, x86-64).

Developing with Mono

Long time Linux developers will probably continue to use Emacs and VI, but some new Linux developers might want to use an IDE. New developers can use our open source MonoDevelop IDE on Linux, or alternatively the commercial X-Develop IDE or SlickEdit.

If you are a Windows developer, you can continue using Visual Studio or your IDE of choice to write the code and compile it. Your binaries will run just fine on Linux.

To assist Windows developers in porting their applications to Unix, we have provided the Mono Migration Analysis tool.

Runtime Changes

The Mono Virtual Machine gained plenty of features since Mono 1.2 was released. We have added:

  • Generic Code Sharing and VTable Compression have been implemented: this significantly reduces the memory footprint of generic type instantiations, while still getting the speed benefits of using generics.
  • AOT support: in addition to x86, we now also support ARM and x86-64.
  • COM interop is now complete (works on Windows with "real COM" and can be used on Unix with Mainsoft's COM or Mozilla's XPCOM).
  • AOT code can now AOT parts of 2.0 assemblies (assemblies that contain generics).
  • Full AOT support (allows code to run JIT-less, this is limited to 1.0 code).
  • CIL Verifier: Now Mono has a CIL verifier.
  • CoreCLR Security: the security system used by Moonlight.
  • Many optimizations that improve execution performance: New intrinsics operations (Math.Min/Max for example); various operations are now inlined by the JIT; managed allocations (no transition to unmanaged code for allocating memory); multi-array access is now tuned by the JIT; constant and block initializations are now handled by the JIT; Faster initialization and access to multi-dimensional arrays (4x faster).
  • The runtime went on a diet, many runtime data structures are smaller making Mono lighter.

Tools

In addition the the Mono Debugger making its debut appearance on this release, we are very proud of our code analyzer Gendarme.

Gendarme is a extensible rule-based tool to find problems in .NET applications and libraries. Gendarme inspects programs and libraries that contain code in ECMA CIL format (Mono and .NET) and looks for common problems with the code, problems that compilers do not typically check or have not historically checked.

Feedback

Mono is not perfect, but we want to improve it. Like many other open source projects, we need your bug reports to improve Mono. If you have problems with Mono, help us by filing a bug report.

Special Thanks

Special thanks to Hacker Extraordinaire Aaron Bockover who not only brings us the best media player in the world, but created the new web site design and implemented and tuned it over very long extra hours up until 7am in the morning on his weekend.

And to our packaging and QA team that spent extra hours to get all the bits and pieces in place for the release.

Posted on 06 Oct 2008 by Miguel de Icaza
This is a personal web page. Things said here do not represent the position of my employer.