From E&E Students
Jump to: navigation, search


What is Mono?™

Mono is a comprehensive open source development platform based on the .NET framework that allows developers to build Linux and cross-platform applications with unprecedented productivity. Mono's .NET implementation is based on the ECMA standards for C# and the Common Language Infrastructure.

Sponsored by Novell and led by Miguel de Icaza, the Mono project has an active and enthusiastic contributing community. Mono includes both developer tools and the infrastructure needed to run .NET client and server applications.

Mono includes a compiler for the C# language, an ECMA-compatible runtime engine (the Common Language Runtime, or CLR),and class libraries. The libraries include Microsoft .NET compatibility libraries (including ADO.NET and ASP.NET), Mono's own and third party class libraries.Gtk#, a set of .NET bindings for the gtk+ toolkit and assorted GNOME libraries can be found in the later. This library allows you to build fully native Gnome application using Mono and includes support for user interfaces built with the Glade interface builder. Furthermore, Mono's runtime can be embedded into applications for simplified packaging and shipping. In addition, the Mono project offers an IDE, debugger, and documentation browser.


Mono™ Project Roadmap

Miguel de Icaza ( Last update: Jan 18th, 2004

  • Introduction
  • Background
  • Mono release strategy
  • Mono 1.0 goals
  • Microsoft's Whidbey
  • Mono 1.2
  • Mono 2.0
  • Peer projects
  • Unscheduled activities
  • Mono and WinFX: 2006
  • Unsupported technologies
  • Mono Developer Strategy
  • Comments


This document describes the high-level roadmap for Mono.

The Mono project started in 2001 as an effort to implement the .NET Framework to UNIX. To bring both the new programming model based on the Common Language Infrastructure and C# as well as helping people migrate their existing knowledge and applications to UNIX. Mono today supports a wide variety of operating systems, CPUs and debuting with Mono 1.0 establishes parity with the .NET Framework 1.1.

At the October 2003 PDC conference a number of new technologies were announced. From the Mono release schedule perspective, we should think about these technologies from their release time standpoint, and the features that must be supported.

This document outlines the roadmap for the Mono project from our perspective: what we can effectively deliver on the dates outlined. Since Mono is a large open source project, things might change and new features can be incorporated into the plan if external sources devote enough attention to those problems. Background

So far Microsoft has published two versions of the .NET Framework: 1.0 and 1.1, the later with incremental updates to the changes in 1.0

The Mono project has been tracking some of the improvements available in those two releases, some of the highlights of our work so far are:

  • Core: mscorlib, System, System.Security and System.XML assemblies.
  • ADO.NET: System.Data and various other database providers.
  • ASP.NET: WebForms and Web Services are supported. Work on WSE1/WSE2 has also started.
  • Compilers: C#, VB.NET and various command line tools that are part of the SDK.
  • Open Source, UNIX and Gnome specific libraries.

Other components like Windows.Forms, Directory.Services, Enterprise Services and JScript are being developed but are not as mature as the other components but are under development by various people.

Some other smaller and less used components do not have yet a Mono equivalent (System.Management, System.Drawing.Design). Mono release strategy

The levels of maturity of Mono fluctuate depending on the development effort we have put into it, and the use we have given to them. For example, the virtual machine and the C# compiler very mature, while less commonly used functionality in Mono like Windows.Forms or VB.NET are still under heavy development.

Our strategy is to release the mature components as Mono 1.0, and have upcoming versions of Mono add extra functionality. Mono 1.0 goals

The Mono 1.0 release includes the following components:

  • C# compiler.
  • VM, with JIT and pre-compiler.
  • IL assembler, disassembler.
  • Development and security tools.
  • Core libraries: mscorlib, System, System.XML.
  • System.Data and Mono database providers.
  • System.Web: Web applications platform and Apache integration module.
  • System.Web.Services: client and server support.
  • System.Drawing.
  • System.DirectoryServices
  • JIT support: x86, SPARC and PPC architectures (interpreter available for other architectures).
  • ECMA profiles: special build options to build Mono as an implementation of the various ECMA profiles will be available.
  • Java integration through IKVM.
  • Embedding interface for the runtime.
  • mono: will contain the above features implementing the .NET 1.1 API.
  • mono microsoft compatiblity stack: Will include a build of the libraries with the .NET 1.0 API, this is a compatibility build for people running .NET 1.0 applications.
  • mono preview packages : Will contain a snapshot of the other technologies under development for developer's convenience, but will be unsupported at this time. These include the Generics edition of the C# compiler.
  • mono-core: A build that only includes the ECMA components.

Release: June 30th, 2004.

Bug fix releases will be done on a monthly basis.

For a detailed list, see the mono-1.0 feature list.

Microsoft's Whidbey

To understand post 1.0 editions of Mono, it is important to put it into perspective with the Microsoft Whidbey product, to be released sometime in 2005.

The new features in the Whidbey release of the .NET Framework include:

  • Generic types - These introduce changes to the compiler, runtime and class libraries.
  • ASP.NET 2 - Many tools to simplify web application development: Master pages, new controls for common operations, personalization and themes.
  • Remoting - New security channels and version-resistant remoting (good news in the interop department).
  • XML - XQuery debuts on this release as well as an improved XmlDocument system based on XPath: XPathDocument.
  • Networking - FTP client, Ssl streams.
  • Console and Serial ports: Console terminal input/output is available as well as serial port handling.
  • Windows.Forms - Layout containers finally appeared on Windows.Forms as well as various new controls.
  • ObjectSpaces - An API for simpler data-base access.

Mono 1.2

The Mono team is developing in parallel some features that wont make it to the 1.0 release in stable form. These will be the foundation for the 1.2 release. The focus of this release is to track the core API for the .NET Framework 2.0, but again, only a subset of the total framework will be available.

Mostly, Mono 1.2 consists of components that were not stable enough for Mono 1.0, but that would be mature at this point, plus the incorporation of some new features from Whidbey. In addition to the Mono 1.0 components, this release will add:

  • Generic types support: C# compiler, execution system and core class libraries.
  • ASP.NET 2.0 improvements.
  • Remoting improvements from Whidbey.
  • System.XML: simpler improvements from Whidbey, lacking the large additions (XQuery for example).
  • Console and Serial ports support.
  • New compilers: VB.NET and JScript support.
  • WSE1/WSE2 implementations.
  • System.Windows.Forms officially debuts with .NET 1.0 API; 1.2 API available as an unstable addition.

This release will by default provide .NET 1.2 APIs, but compatibility libraries for 1.0 and 1.1 will be distributed in the mono-compat package. The unstable components of Mono will be distributed on the `mono-unstable' package, the libraries in this release will be unsupported.

Release target: Q4/2004.

Mono 2.0

A refresh update on the Mono 1.2 release containing the missing components from the previous release and complete any under performing pieces. Updates to System.Xml, ASP.NET and Windows.Forms to match the .NET 2.0 API.

Release target: Q2/2005.

Peer projects

Other projects like the debugger, the documentation browser, Java integration through IKVM and Gtk# will remain on their own schedules. This page will be updated to contain that information when it becomes available. Unscheduled activities

A missing component of Mono is the Code Access Security (CAS). This functionality is not needed in today's Mono as currently Mono is being used to run fully trusted applications, and we are not using it on embedded scenarios where assemblies would have different trust levels.

This is an important component, but requires three major pieces of work:

  • Runtime support for implementing the security demands.
  • A guidelines document outlining what and where must have security demands in place.
  • A full audit of our class libraries: method by method

All of these are major pieces of work, and we currently have no plans to implement any of those. A volunteer effort might be able to help with the runtime requirements and the document, but until those are done, we are unlikely to start doing any work on the actual class library audit and instrumentation.

Mono and WinFX: 2006

WinFX is the name given to the new set of libraries that makes up .NET in the Longhorn operating system: the existing .NET set of class libraries, plus the new functionality available in the OS.

WinFX adds things like storage facilities (WinFS), a new versatile communications stack (Indigo) and a new eye-candy packed GUI programming system (Avalon).

Although WinFS, Avalon and Indigo are very exciting components, at this time it is too early to tell when those components will be available for Mono. Open source developers will very likely start work on these, but since they are still far from being officially released, they are not in the radar at this point.

Unsupported technologies

Some technologies are of little interest for most developers or are being phased out by components in the Longhorn time frame. In some cases, we feel that they are not crucial to the future of the open source desktop.

System.EnterpriseServices and System.Management come to mind, and we are unlikely to put any resources into the task. We would gladly host the code if someone cares to implement it, but they would likely remain unsupported features of Mono. Mono Developer Strategy

Mono Developers should read the Mono Hacking Roadmap