After more than a year of development, we are happy to
announce Mono 2.11, the first in a series of beta releases
that will lead to the next 2.12 stable release.
To assist those helping us with testing the release, we
have setup a new continuous build system that builds packages
for Mac, OpenSUSE and Windows
To test drive Mono 2.11 head to our
page and select the "Alpha" section of the page to get the
packages for Mac, Windows or Linux.
The Linux version is split up in multiple packages.
The Windows version ships with Gtk+ and Gtk#
The Mac version ships with Gtk+, Gtk#, F#, IronPython and
IronRuby and comes in two versions: Mono Runtime Environment
(MRE) and the more complete Mono Development Kit (MDK).
At this stage, we recommend that users get the complete
Runtime Improvements in Mono 2.11
There are hundreds of new features available in this
release as we have accumulated them over a very long time.
Every fix that has gone into the Mono 2.10.xx series has been
integrated into this release.
In addition, here are some of the highlights of this release.
Garbage Collector: Our SGen garbage collector is now
considered production quality and is in use by Xamarin's own
The collector on multi-CPU systems will also distribute
various tasks across the CPUs, it is no longer limited to the
with SGen will help developers tune the collector for
their needs and discusses tricks that developers can take
ThreadLocal<T> is now inlined by the runtime
engine, speeding up many threaded applications.
Full Unicode Surrogate Support this was a long
standing feature and has now been implemented.
C# 5.0 -- Async Support
Mono 2.11 implements the C# 5.0 language with complete
The Mono's class libraries have been updated to better
support async programming. See the section "4.5 API" for
C# Backend Rewrite
The compiler code generation backend was rewritten entirely
to support both IKVM.Reflection and System.Reflection which
allowed us to unify all the old compilers (
smcs) into a single compiler:
For more information
The new IKVM.Reflection backend allows the compiler to
consume any mscorlib.dll library, instead of being limited to
the ones that were custom built/crafted for Mono.
In addition, the compiler is no longer a big set of static
classes, instead the entire compiler is instance based,
allowing multiple instances of the compiler to co-exist at the
Compiler as a Service
Mono's Compiler as a Service has been extended
significantly and reuses the compiler's fully instance based
API for more details).
Mono's compiler as a service is still a low-level API to
the C# compiler. The NRefactory2 framework --shared by SharpDevelop and
MonoDevelop-- provides a higher level abstraction that can be --
used by IDEs and other high-level tools.
Our C# interactive shell and our C# API to compile C# code
can in addition to compiling expressions and statements can
now compile class definitions.
4.5 Profile Mono now defaults to the 4.5 profile
which is a strict superset of the 4.0 profile and reuses the
same version number for the assemblies.
Although .NET 4.5 has not yet been officially released, the
compiler now defaults to the 4.5 API, if you want to use
different profile API you must use the -sdk:XXX switch to the
command line compiler.
Because 4.5 API is a strict superset of 4.0 API they both
share the same assembly version number, so we actually install
the 4.5 library into the GAC.
Some of the changes in the 4.5 API family include:
- New Async methods
- WinRT compatibility API
- Newly introduced assemblies: System.Net.Http,
The new System.Net.Http stack is ideal for developers using
the C# 5.0 async framework.
The GDB support has been extended and can pretty print more
internal variables of Mono as well as understanding SGen
The soft debugger has seen a large set of improvements:
- Single stepping is now implemented using breakpoints in
most cases, speeding it up considerably.
- Calls to System.Diagnostics.Debugger:Log()/Break () are
now routed to the debugger using new UserLog/UserBreak event
- S390x is now supported (Neale Ferguson).
- MIPS is now supported.
- Added new methods to Mono.Debugger.Soft and the runtime to
decrease the amount of packets transmitted between the
debugger and the debuggee. This significantly improves
performance over high latency connections like USB.
Mac support has been vastly extended, from faster GC by
using native Mach primitives to improves many features that
previously only worked on Linux to extending the asynchronous
socket support in Mono to use MacOS X specific primitives.
We have completed the Mono MIPS port.
As a general theme, Mono 2.11 has hundreds of performance
improvements in many small places which add up.