Mono (software)

This article is about the computing platform. For other uses, see Mono (disambiguation).

Mono

Developer(s)	Xamarin (formerly by Novell and originally by Ximian) and the Mono community
Initial release	June 30, 2004
Stable release	2.10.6[1] / October 14, 2011; 22 days ago (2011-10-14)
Operating system	Cross-platform
Type	Platform
License	MIT, LGPLv2 and GPLv2, or dual license[2]
Website	www.mono-project.com

Mono, pronounced /ˈmoʊ.noʊ/ moh-noh, is a free and open source project led by Xamarin (formerly by Novell and originally by Ximian) to create an Ecma standard compliant .NET-compatible set of tools including, among others, a C# compiler and a Common Language Runtime.

The stated purpose of Mono is not only to be able to run Microsoft .NET applications cross-platform, but also to bring better development tools to Linux developers.^[3] Mono can be run on Android, BSD, iOS, Linux, Mac OS X, Windows, Solaris, and Unix operating systems as well as some game console operating systems such as the ones for the PlayStation 3, Wii, and Xbox 360.

The logo of Mono is a stylized monkey's face, mono being Spanish for monkey.^[4][5]

History

Release History

Date	Version[6]	Notes
2004-06-30	1.0[7]	C# 1.0 support
2004-09-21	1.1[8]
2006-11-09	1.2[9]	C# 2.0 support
2008-10-06	2.0[10]	Mono's APIs are now in par with .NET 2.0. Introduces the C# 3.0 and Visual Basic 8 compilers. New Mono-specific APIs: Mono.Cecil, Mono.Cairo and Mono.Posix. Gtk# 2.12 is released. The Gendarme verification tool and Mono Linker are introduced.
2009-01-13	2.2[11]	Mono switches its JIT engine to a new internal representation [12] that gives it a performance boost and introduces SIMD support in the Mono.Simd [13] Mono.Simd namespace. Mono introduces Full Ahead of Time compilation that allows developers to create full static applications and debuts the C# Compiler as a Service [14] and the C# Interactive Shell [15] (C# REPL)
2009-03-30	2.4[16]	This release mostly polishes all the features that shipped in 2.2 and became the foundation for the Long-Term support of Mono in SUSE Linux.
2009-12-15	2.6[17]	The Mono runtime is now able to use LLVM as a code generation backend and this release introduces Mono co-routines, the Mono Soft Debugger and the CoreCLR security system required for Moonlight and other Web-based plugins. On the class library System.IO.Packaging, WCF client, WCF server, LINQ to SQL debut. The Interactive shell supports auto-completion and the LINQ to SQL supports multiple database backends. The xbuild build system is introduced.
2010-09-22	2.8[18]	Defaults to .NET 4.0 profile, C# 4.0 support, new generational Garbage Collector, includes Parallel Extensions, WCF Routing, CodeContracts, ASP.NET 4.0, drops the 1.0 profile support; the LLVM engine tuned to support 99.9% of all generated code, runtime selectable llvm and gc; incorporates Dynamic Language Runtime, MEF, ASP.NET MVC2, OData Client open source code from Microsoft;. Will become release 3.0
2011-02-15	2.10[19]

When Microsoft first announced their .NET Framework in June 2000 it was described as "a new platform based on Internet standards",^[20] and in December of that year the underlying Common Language Infrastructure was published as an open standard, "ECMA-335"^[21] - opening up the potential for independent implementations.^[22] Miguel de Icaza of Ximian believed that .NET had the potential to increase programmer productivity and began investigating whether a Linux version was feasible.^[23] Recognizing that their small team could not expect to build and support a full product, they launched the Mono open source project, on July 19, 2001 at the O'Reilly conference.

After three years development, Mono 1.0 was released on June 30, 2004.^[24] Mono evolved from its initial focus of a developer platform for Linux desktop applications to supporting a wide range of architectures and operating systems - including embedded systems.^[25]

After Novell was acquired by Attachmate in April 2011, Attachmate announced hundreds of layoffs for the Novell workforce,^[26] putting in question the future of Mono.^[27][28]

On May 16, Miguel de Icaza announced in his blog that Mono would continue to be supported by Xamarin, a company he founded after being laid off from Novell. The original Mono team had also moved to the new company. Xamarin plans to keep working on Mono and had planned to rewrite the commercial .NET stacks for iOS and Android from scratch because Novell still owned MonoTouch and Mono for Android at the time.^[29] After this announcement, the future of the project was questioned, MonoTouch and Mono for Android being in direct competition with the existing commercial offerings now owned by Attachmate, and considering that the Xamarin team would have difficulties proving that they did not use technologies they previously developed when they were employed by Novell for the same work.^[30] However, in July 2011, Novell, now a subsidiary of Attachmate, and Xamarin, announced that it granted a perpetual license to Xamarin for Mono, MonoTouch and Mono for Android, which took officially the stewardship of the project.^[31][32]

Current status and roadmap

Mono's current version is 2.10 (as of February 2011^[update]). This version provides the core API of the .NET Framework as well as support for Visual Basic.NET and C# versions 2.0, 3.0, and 4.0. LINQ to Objects, XML, and SQL are part of the distribution. C# 4.0 is now the default mode of operation for the C# compiler. Windows Forms 2.0 is also supported, but not actively developed, and as such its support on Mono is incomplete.^[33]

Mono's aim is to achieve full support for the features in .NET 4.0 except WPF (which the Mono team do not plan to support due to the amount of work it would need),^[33] Entity Framework and WF, limited WCF.^[34] Some missing parts of the .NET Framework are under development in an experimental Mono subproject called Olive.^[35]

The Mono project has also created a VB.NET compiler as well as a runtime designed for running VB.NET applications. It is currently being developed by Rolf Bjarne Kvinge.

Moonlight

Main article: Moonlight (runtime)

An open source implementation of Silverlight, called Moonlight, has been included since Mono 1.9.^[36] Moonlight 1.0, which supports the Silverlight 1.0 APIs, was released January 20, 2009. Moonlight 2.0 supports Silverlight 2.0 and some features of Silverlight 3.0.^[37] A preview release of Moonlight 3.0 was announced in February 2010 and contains updates to Silverlight 3 support.^[38]

Mono components

Mono consists of three groups of components:

1. Core components
2. Mono/Linux/GNOME development stack
3. Microsoft compatibility stack

The core components include the C# compiler, the virtual machine for the Common Language Infrastructure and the core class libraries. These components are based on the Ecma-334 and Ecma-335 standards,^[39] allowing Mono to provide a standards compliant, free and open source CLI virtual machine. Microsoft issued a statement that covers both standards under their Community Promise license.^[40]

The Mono/Linux/GNOME development stack provide tools for application development while using the existing GNOME and Free and Open Source libraries. These include: Gtk# for GUI development, Mozilla libraries for working with the Gecko rendering engine, Unix integration libraries (Mono.Posix), database connectivity libraries, a security stack, and the XML schema language RelaxNG. Gtk# allows Mono applications to integrate into the Gnome desktop as native applications. The database libraries provide connectivity to the object-relational database db4o, Firebird, Microsoft SQL Server (MSSQL), MySQL, Open Database Connectivity (ODBC), Oracle, PostgreSQL, SQLite, and many others. The Mono project tracks developing database components at its website.^[41]

The Microsoft compatibility stack provides a pathway for porting Windows .NET applications to GNU/Linux. This group of components include ADO.NET, ASP.NET, and Windows.Forms, among others. As these components are not covered by Ecma standards, some of them remain subject to patent fears and concerns.

Framework architecture

Simplified Mono architecture

The major components of Mono include:

• Code Execution Engine
• Class Libraries
  • Base Class Library
  • .NET Compatibility Class Libraries
  • Mono specific class libraries:
    • Cross platform class libraries for both Mono and .NET (Gtk#, Mono.Cecil, Mono.CSharp, Text.Templating)
    • Unix-specific class libraries (Posix, FUSE, curses)
    • Platform-specific class libraries (Mac bindings, iPhone bindings, Android bindings, MeeGo bindings)
• ECMA Assemblies
• ECMA Metadata
• Mono's Common Language Runtime
  • Compatible with the ECMA Common Language Infrastructure/.NET Common Language Runtime
  • Mono-specific enhancements:
    • Mono.SIMD support
    • Mono co-routines and continuations.
• Mono-specific enhancements
• Native interop services and COM interop
• Security - Transparent Code Framework

Code Execution Engine

The Mono runtime contains a code execution engine that translates ECMA CIL byte codes into native code and supports a number of processors: ARM, MIPS (in 32-bit mode only), SPARC, PowerPC, S390 (in 64-bit mode), x86, x86-64 and IA-64 for 64-bit modes.

The code generator is exposed in three modes:

• Just in time (JIT) compilation: The runtime will turn ECMA CIL byte codes into native code as the code runs.
• Ahead-of-Time (AOT) compilation: this code turns the ECMA CIL byte codes (typically found on a .exe or .dll file) and generates native code stored in an operating system, architecture and CPU specific file (for a foo.exe file, it would produce foo.exe.so on Linux). This mode of operation compiles most of the code that is typically done at runtime. There are some exceptions like trampolines and other administrative code that still require the JIT to function, so AOT images are not fully standalone.
• Full Static Compilation: this mode is only supported on a handful of platforms and takes the Ahead-of-Time compilation process one step further and generates all the trampolines, wrappers and proxies that are required into a static file that can be statically linked into a program and completely eliminates the need for a JIT at runtime. This is used on Apple's iOS, Sony's PlayStation 3 and Microsoft's XBox 360 operating systems^{[citation needed]}.

Starting with Mono 2.6, it is possible to configure Mono to use the Low Level Virtual Machine (LLVM) as the code generation engine instead of Mono's own code generation engine. This is useful for high performance computing loads and other situations where the execution performance is more important than the startup performance.

Starting with the Mono 2.7 preview, it is no longer necessary to pick one engine over the other at configuration time. The code generation engine can be selected at startup by using the --llvm or --nollvm command line arguments, and it defaults to the fast Mono code generation engine.

Garbage collector

As of Mono 2.8, the Mono runtime ships with two garbage collectors, a generational collector^[42] and the Boehm conservative collector.

The current default garbage collector (the "Boehm-Demers-Weiser Conservative Garbage Collector")^[42][43] has significant limitations compared to commercial garbage-collected runtimes like the Java Virtual Machine or the .NET framework's runtime, such as a conservative garbage collection can exhibit memory leaks on certain class of applications, this can make it unsuitable for long-running server applications.

As of October 2010^[update], a new generational collector called the "Simple Generational GC" (SGen-GC) is part of Mono. Just like the LLVM code generation engine is now selectable at startup, users can elect to use the new SGen garbage collector by passing the --gc=sgen switch to the Mono runtime at startup.^[42] This new garbage collector has many advantages over a traditional conservative scanner. It uses generational garbage collection where new objects are allocated from a nursery, during the garbage collection cycle, all objects that survived are migrated to an older generation memory pool. The idea being that many objects are transient and can quickly be collected and only a handful of objects are long-term objects that live for the entire life of the application. To improve performance this collector assigns memory pools to each thread to let threads allocate new memory blocks without having to coordinate with other threads. Migration of objects from the nursery to the old generation is done by copying the data from the nursery to the old generation pool and updating any live pointers that point to the data to point to the new location. This can be expensive for large objects, so Mono's SGen uses a separate pool of memory for large objects (Large Object Section) and uses a mark-and-sweep algorithm for those objects.

Currently SGen treats the stack and registers conservatively and pins any objects that could be referenced by any of these roots. The upcoming version of Mono scans the managed stack precisely reducing the number of pinned objects.

Class library

The class library provides a comprehensive set of facilities for application development. They are primarily written in C#, but due to the Common Language Specification they can be used by any .NET language. The class library is structured into namespaces, and deployed in shared libraries known as assemblies. Speaking of the .NET framework is primarily referring to this class library.^[44]

Namespaces and assemblies

Namespaces are a mechanism for logically grouping similar classes into a hierarchical structure. This prevents naming conflicts. The structure is implemented using dot-separated words, where the most common top-level namespace is System, such as System.IO and System.Net. There are other top-level namespaces as well, such as Accessibility and Windows. A user can define a namespace by placing elements inside a namespace block.

Assemblies are the physical packaging of the class libraries. These are .dll files, just like (but not to be confused with) Win32 shared libraries. Examples of assemblies are mscorlib.dll, System.dll, System.Data.dll and Accessibility.dll. Namespaces are often distributed among several assemblies and one assembly can be composed of several files.

Common Language Infrastructure and Common Language Specification

The Common Language Infrastructure (CLI), or more commonly known as the Common Language Runtime, is implemented by the Mono executable. The runtime is used to execute compiled .NET applications. The common language infrastructure is defined by the ECMA standard.^[45] To run an application, you must invoke the runtime with the relevant parameters.

The Common Language Specification (CLS) is specified in chapter 6 of ECMA-335 and defines the interface to the CLI, such as conventions like the underlying types for Enum. The Mono compiler generates an image that conforms to the CLS. This is the Common Intermediate Language. The Mono runtime takes this image and runs it. The ECMA standard formally defines a library that conforms to the CLS as a framework.

Managed and unmanaged code

Within a native .NET/Mono application, all code is managed; that is, it is governed by the CLI's style of memory management and thread safety. Other .NET or Mono applications can use legacy code, which is referred to as unmanaged, by using the System.Runtime.InteropServices libraries to create C# bindings. Many libraries which ship with Mono use this feature of the CLI, such as Gtk#.

Mono-specific innovations

Mono has innovated in some areas with new extensions to the core C# and CLI specifications:

• C# Compiler as a Service (Use the C# compiler as a library).^[14]
• C# Interactive Shell.^[15]
• SIMD support^[13] as part of the Mono.SIMD namespace, where method calls to special vector types are directly mapped to the underlying processor CPU SIMD instructions.
• Full Static Compilation of .NET code^[46] (used on Mono/iPhone, Mono/PS3).
• Mono coroutines (used to implement micro-threading code and continuations, mostly for game developers).^[47]
• 64-bit "large arrays", although present on the ECMA specification, Mono is the only implementation that supports them.
• Assembly injection to live processes.^[48]
• Use of LLVM as JIT backend.

In addition, Mono is available on a variety of operating systems and architectures.^[49]

Related projects

Several projects extend Mono and allow developers to use it in their development environment. These projects include:

Cross-Platform:

• Banshee Media Player a cross-platform music media player built with Mono and Gtk# and also a driver of dozens of C#-based libraries and projects for media handling.
• Beagle a search system for Unix systems.
• Gecko#, bindings for embedding the layout engine used in Mozilla (Gecko).
• Gtk#, C# wrappers around the underlying GTK+ and GNOME libraries, written in C and available on Linux, MacOS and Windows.
• Mono Migration Analyzer (MoMA), a tool which aids Windows .NET developers in finding areas in their code that might not be cross-platform and therefore not work in Mono on Linux and other Unixes.
• MonoCross, a cross-platform Model–view–controller design pattern where the Model and Controller are shared across platforms and the Views are unique for each platform for an optimized User Interface.
• MonoDevelop an open source and cross platform Integrated Development Environment that supports building applications for ASP.NET, Gtk#, Meego, MonoTouch and Silverlight/Moonlight.
• Moonlight, an implementation of Silverlight that uses Mono.
• OpenTK, a managed binding for OpenGL, OpenCL and OpenAL.
• Qyoto, C# bindings for the Qt framework.
• Resco MobileBusiness, a cross-platform developer solution for mobile clients.
• Resco MobileCRM, a cross-platform developer solution for mobile clients synchronized with Microsoft Dynamics CRM.
• ServiceStack a high-performance Open source .NET REST web services framework that simplifies the development of XML, JSON and SOAP Web Services.
• Tao, a collection of graphics and gaming bindings (OpenGL, SDL, Glut, Cg).

MacOS:

• Cocoa# wrappers around the native Mac OS X toolkit (Cocoa) (deprecated).
• Monobjc a set of bindings for Mac OS X programming.
• MonoMac the new bindings for Mac OS X programming, based on the MonoTouch API design.

Mobile Platforms:

• MonoDroid Mono for the Android operating system. With bindings for the Android APIs.
• MonoTouch Mono for the iPhone, iPad and iPod Touches. With bindings to the iOS APIs.

Windows:

• MonoTools for Visual Studio A Visual Studio plugin that allows Windows developers to target Linux, MacOS right from Visual Studio and integrates with SUSE Studio.

Other Implementations

Microsoft has a version of .NET 2.0 now available only for Windows XP, called the Shared Source CLI (Rotor). Microsoft's shared source license may be insufficient for the needs of the community (it explicitly forbids commercial use).

Free Software Foundation's abandoned Portable.NET project^{[citation needed]}.

MonoDevelop

Main article: MonoDevelop

MonoDevelop is a free GNOME integrated development environment primarily designed for C# and other .NET languages such as Nemerle, Boo, and Java (via IKVM.NET), although it also supports languages such as C, C++, Python, Java, and Vala. MonoDevelop was originally a port of SharpDevelop to Gtk#, but it has since evolved to meet the needs of Mono developers. The IDE includes class management, built-in help, code completion, Stetic (a GUI designer), project support, and an integrated debugger.

The MonoDoc browser provides access to API documentation and code samples. The documentation browser uses wiki-style content management, allowing developers to edit and improve the documentation.

MonoTouch and Mono for Android

MonoTouch and Mono for Android, both developed by Xamarin, are implementations of Mono for iPhone and Android-based smart-phones. Contrary to Mono itself, they are released under a commercial license only.^[50]

MonoTouch

Release History

Date	Version	Notes
2009-09-14	MonoTouch 1.0[51]	Initial release
2010-04-05	MonoTouch 2.0[52]	iPad support
2010-04-16	MonoTouch 3.0[53]	iPhone 4 support
2010-07-31	MonoTouch 3.0.8[54]	Latest version

MonoTouch allows developers to create C# and .NET based applications that run on the iPhone. It is based on the Mono framework and developed in conjunction with Novell. Unlike Mono applications MonoTouch "Apps" are compiled down to machine code targeted specifically at the Apple iPhone.^[55] This is necessary because the iPhone kernel prevents just-in-time compilers from executing on the device.

The MonoTouch stack is made up of:

• Compilers
  • C# from the Mono Project
  • Third party compilers like RemObject's Oxygene can target MonoTouch as well
• Core .NET libraries
• Development SDK:
  • Linker: used to bundle only the code used in the final application.
  • mtouch: the Native compiler and tool used to deploy to the target device.
  • Interface Builder integration tools.
• Libraries that bind the native CocoaTouch APIs.
• MonoDevelop IDE

MonoDevelop is used as the primary IDE however additional links to Xcode and the iPhone simulator have been written.

From April to early September 2010, the future of MonoTouch was put in doubt as Apple introduced new terms for iPhone developers that apparently prohibits them from developing in languages other than C, C++ and Objective-C, and the use of a middle layer between the iPhone OS platform and iPhone applications. This made the future of MonoTouch, as well as other technologies such as UNITY, uncertain.^[56] Then, in September 2010, Apple rescinded this restriction, stating that they were relaxing the language restrictions that they had put in place earlier that year.^[57][58]

Mono for Android

Mono for Android, developed by Xamarin, is an implementation of Mono for Android-based smart-phones.^[59][60][61] It was first released on April 6, 2011.^[62] Mono for Android was developed to allow developers to more easily write cross-platform applications that will run on all mobile platforms.^[63] In an interview with H-Online, Miguel de Icaza stated, "Our vision is to allow developers to reuse their engine and business logic code across all mobile platforms and swapping out the user interface code for a platform-specific API."^[64]

In August 2010, a Microsoft spokesman, Tom Hanrahan of Microsoft’s Open Source Technology Centre, stated, in reference to the lawsuit filed by Oracle against Google over Android's use of Java, that "The type of action Oracle is taking against Google over Java is not going to happen. If a .NET port to Android was through Mono it would fall under the Microsoft Community Promise Agreement."^[65][66]

The Mono for Android stack consists of the following components:

• Mono runtime
• Libraries:
  • Core .NET class libraries
  • Libraries that bind the native Android/Java APIs
• SDK tools to package, deploy and debug
• Visual Studio 2010 integration to remotely debug and deploy.

License

Mono is dual licensed by Xamarin, similar to other products such as Qt and the Mozilla Application Suite. Mono's C# compiler and tools are released under the GNU General Public License (GPLv2 only) (starting with version 2.0 of Mono, the Mono C# compiler source code will also be available under the MIT X11 License),^[67] the runtime libraries under the GNU Lesser General Public License (LGPLv2 only) and the class libraries under the MIT License. These are all free software and open-source licenses and hence Mono is free and open-source software.

The license of the C# compiler was changed from the GPL to the MIT X11 license^[68] to allow the compiler code to be reused in a few instances where the GPL would have prevented it from being used:

• Mono's Compiler as a Service
  • The Mono interactive Shell
  • The Mono embeddable C# compiler
• Mono's implementation of the C# 4.0 dynamic binder.
• MonoDevelop's built-in parser and AST graph

Mono and Microsoft's patents

For more details on this topic, see Software patents and free software and Novell#Agreement with Microsoft.

Mono’s implementation of those components of the .NET stack not submitted to the ECMA for standardization has been the source of patent violation concerns for much of the life of the project.^[69] In particular, discussion has taken place about whether Microsoft could destroy the Mono project through patent suits.^[70] So far these concerns have proven to be unfounded.^[71]

The base technologies submitted to the ECMA, and therefore also the Unix/GNOME-specific parts, are not problematic due to Microsoft's explicitly placing both ECMA 334 and ECMA 335 standards under the Microsoft Community Promise. The concerns primarily relate to technologies developed by Microsoft on top of the .NET Framework, such as ASP.NET, ADO.NET and Windows Forms (see non-standardized namespaces), i.e. parts composing Mono’s Windows compatibility stack. These technologies are today not fully implemented in Mono and not required for developing Mono-applications, they are simply there for developers and users who need full compatibility with the Windows system.

Should patent issues ever arise, the Mono project's stated strategy for dealing with them is as follows:^[72]

• Work around the patent by using a different implementation technique that retains the API, but changes the mechanism; if that is not possible, they would
• Remove the pieces of code that were covered by those patents, and also
• Find prior art that would render the patent useless.

In addition, Mono is also included in the list of software that the Open Invention Network has sworn to protect.^[73]

On July 6, 2009, Microsoft announced that it was placing their ECMA 334 and ECMA 335 specifications under their Community Promise pledging that they would not assert their patents against anyone implementing, distributing, or using alternative implementations of .NET.^[74] However, their position regarding the non-ECMA components like ASP.NET, ADO.NET, and Windows Forms (which are the bone of contention) remains unclarified.

Following criticism from the Free Software Foundation's Richard Stallman, Canonical Ltd., makers of the Ubuntu Linux distribution, came out with a Mono Position Statement^[75] which states that "It is common practice in the software industry to register patents as protection against litigation, rather than as an intent to litigate. Thus mere existence of a patent, without a claim of infringement, is not sufficient reason to warrant exclusion from the Ubuntu Project." The statement then goes on to say that they would therefore continue to ship Mono in Ubuntu until the patents actually become a real threat rather than simply a perceived threat.

Fedora Project Leader, Paul Frields, has stated "We haven't come to a legal conclusion that is pat enough for us to make the decision to take mono out." ^[76]

Software developed with Mono

Banshee (media player)

GNOME Do

A range of programs have been developed that use the Mono API and C#. Some programs written for the Linux Desktop include Banshee, Beagle, Docky, F-Spot, Gbrainy, GNOME Do, MonoTorrent, Pinta, and Tomboy. A number of video games such as The Sims 3 and Second Life's scripting language, LSL (although not an official .NET language itself), along with many games based on the Unity game engine also make use of Mono.

See also

Free software portal

• Common Language Runtime
• Comparison of application virtual machines
• DotGNU – A free software umbrella project which includes Portable.NET
• MonoDevelop – An open source IDE targeting both Mono and Microsoft .NET framework platforms
• Moonlight (runtime), an open-source implementation of Microsoft's Silverlight developed by the Mono Project
• Portable.NET – Another free software implementation of ECMA 334 and 335
• Shared Source Common Language Infrastructure – Microsoft's shared source implementation of .NET, previously codenamed Rotor
• mod_mono – A module for the Apache HTTP Server that allows for hosting of ASP.NET pages and other assemblies on multiple platforms by use of Mono

Notes

1. ^ http://www.mono-project.com/Release_Notes_Mono_2.10.6
2. ^ "FAQ: Licensing – Mono". http://www.mono-project.com/FAQ:_Licensing. Retrieved 2009-11-26. 
3. ^ "Mono Project aims to bring .Net apps to Linux". ZDNet. 2001-10-29. http://www.zdnet.com/news/mono-project-aims-to-bring-net-apps-to-linux/298857. ""Called the Mono Project, this effort encompasses creating a development environment that will allow applications developed for .Net to run on Linux-based as well as Windows-based systems. Mono originated out of a need for improved development tools for the GNOME community and for Ximian specifically, according to Miguel de Icaza, Ximian's chief technical officer."" 
4. ^ "FAQ: General". Mono Projects. http://www.mono-project.com/FAQ:_General. Retrieved December 4, 2009. 
5. ^ "Ximian's Mono project: .NET for monkeys, penguins, and gnomes". TechRepublic. http://articles.techrepublic.com.com/5100-10878_11-1044968.html. 
6. ^ http://www.mono-project.com/OldReleases
7. ^ http://go-mono.com/archive/1.0/
8. ^ http://www.go-mono.com/archive/1.1.1/
9. ^ http://go-mono.com/archive/1.2/
10. ^ http://www.mono-project.com/Release_Notes_Mono_2.0
11. ^ http://www.mono-project.com/Release_Notes_Mono_2.2
12. ^ http://www.mono-project.com/Linear_IL
13. ^ ^{a b} http://tirania.org/blog/archive/2008/Nov-03.html
14. ^ ^{a b} http://tirania.org/blog/archive/2010/Apr-27.html
15. ^ ^{a b} http://www.mono-project.com/CsharpRepl
16. ^ http://www.mono-project.com/Release_Notes_Mono_2.4
17. ^ http://www.mono-project.com/Release_Notes_Mono_2.6
18. ^ http://www.mono-project.com/Release_Notes_Mono_2.8
19. ^ http://www.mono-project.com/Release_Notes_Mono_2.10
20. ^ "Microsoft sees nothing but .NET ahead", Steven Bonisteel, ZDNet, June 23, 2000
21. ^ http://www.ecma-international.org/publications/files/ECMA-ST-WITHDRAWN/ECMA-335,%201st%20edition,%20December%202001.pdf
22. ^ "Microsoft edges into sharing code", Joe Wilcox and Stephen Shankland, ZDNet on June 28, 2001
23. ^ "[Mono-list Mono early history."]. 2003-10-13. http://lists.ximian.com/archives/public/mono-list/2003-October/016345.html. 
24. ^ "OSS .NET implementation Mono 1.0 released - Ars Technica". ArsTechnica. http://arstechnica.com/old/content/2004/06/3949.ars. Retrieved 2009-10-23. 
25. ^ "Supported Platforms", Mono website
26. ^ Koep, Paul (2011-05-02). "Employees say hundreds laid off at Novell's Provo office". KSL-TV. http://www.ksl.com/?nid=148&sid=15382738. Retrieved 2011-05-07. 
27. ^ J. Vaughan-Nichols, Steven (2011-05-04). "Is Mono dead? Is Novell dying?". ZDNet. http://www.zdnet.com/blog/open-source/is-mono-dead-is-novell-dying/8821. Retrieved 2011-05-07. 
28. ^ Clarke, Gavin (2011-05-03). [.http://www.theregister.co.uk/2011/05/03/novell_mono_layoffs/ ".NET Android and iOS clones stripped by Attachmate"]. The Register. .http://www.theregister.co.uk/2011/05/03/novell_mono_layoffs/. Retrieved 2011-05-07. 
29. ^ http://tirania.org/blog/archive/2011/May-16.html
30. ^ "The Death and Rebirth of Mono". infoq.com. 2011-05-17. http://www.infoq.com/news/2011/05/Mono-II. Retrieved 2011-05-29. "Even if they aren't supporting it, they do own a product that is in direct competition with Xamarin's future offerings. Without some sort of legal arrangement between Attachmate and Xamarin, the latter would face the daunting prospect of proving that their new development doesn't use any the technology that the old one did. Considering that this is really just a wrapper around the native API, it would be hard to prove you had a clean-room implementation even for a team that wasn't intimately familiar with Attachmate's code." 
31. ^ "SUSE and Xamarin Partner to Accelerate Innovation and Support Mono Customers and Community". Novell. 2011-07-18. http://www.c.com/news/press/2011/7/suse-and-xamarin-partner-to-accelerate-innovation-and-support-mono-customers-and-community.html?utm_source=twitterfeed&utm_medium=twitter. Retrieved 2011-07-18. "The agreement grants Xamarin a broad, perpetual license to all intellectual property covering Mono, MonoTouch, Mono for Android and Mono Tools for Visual Studio. Xamarin will also provide technical support to SUSE customers using Mono-based products, and assume stewardship of the Mono open source community project." 
32. ^ De Icaza, Miguel (2011-07-18). "Novell/Xamarin Partnership around Mono". http://tirania.org/blog/archive/2011/Jul-18.html. Retrieved 2011-07-18. 
33. ^ ^{a b} Miguel de Icaza (2011-03-07). "GDC 2011". http://tirania.org/blog/archive/2011/Mar-07.html. Retrieved 2011-03-11. "We have no plans on building WPF. We just do not have the man power to build an implementation in any reasonable time-frame(...)For tools that are mostly OpenGL/DirectX based, use Windows.Forms, keeping in mind that some bug fixing or work around on their part might be needed as our Windows.Forms is not actively developed." 
34. ^ Mono compatibility list
35. ^ [1]
36. ^ "MoonlightRoadmap". Mono Team. http://www.mono-project.com/MoonlightRoadmap. Retrieved 2008-11-08. 
37. ^ http://tirania.org/blog/archive/2009/Dec-17.html
38. ^ http://tirania.org/blog/archive/2010/Feb-03.html
39. ^ Ecma-335
40. ^ Technet.com
41. ^ http://www.mono-project.com/Database_Access
42. ^ ^{a b c} "Compacting GC". mono-project.com. http://www.mono-project.com/Compacting_GC. Retrieved 2008-12-16. 
43. ^ Boehm, Hans-J.. "Advantages and Disadvantages of Conservative Garbage Collection". Xerox Parc. http://www.hpl.hp.com/personal/Hans_Boehm/gc/issues.html. Retrieved 2008-12-16. 
44. ^ .NET Framework Architecture on the official Mono documentation
45. ^ ECMA-335
46. ^ http://tirania.org/blog/archive/2008/Nov-05.html
47. ^ http://www.mono-project.com/Continuations
48. ^ http://tirania.org/blog/archive/2008/Sep-29.html
49. ^ http://www.mono-project.com/Supported_Platforms
50. ^ "FAQ". os.xamarin.com. 2011-08-01. http://ios.xamarin.com/FAQ#How_is_MonoTouch_Licensed.3f. "MonoTouch is a commercial product based on the open source Mono project and is licensed on a per-developer basis." 
51. ^ http://tirania.org/blog/archive/2009/Sep-14.html
52. ^ http://monotouch.net/Releases/MonoTouch_2/MonoTouch_2.0.0
53. ^ http://monotouch.net/Releases/MonoTouch_3/MonoTouch_3.0.0
54. ^ http://monotouch.net/Releases/MonoTouch_3/MonoTouch_3.0.12
55. ^ "MonoTouch and iPhone 4". http://www.mono-project.com/newstouch/archive/2010/Apr-09.html. ""Applications built with MonoTouch are native applications indistinguishable from other native applications."" 
56. ^ http://arstechnica.com/apple/news/2010/04/apple-takes-aim-at-adobe-or-android.ars
57. ^ "Statement by Apple on App Store Review Guidelines". http://www.apple.com/pr/library/2010/09/09statement.html. ""Based on their input, today we are making some important changes to our iOS Developer Program license in sections 3.3.1, 3.3.2 and 3.3.9 to relax some restrictions we put in place earlier this year. In particular, we are relaxing all restrictions on the development tools used to create iOS apps, as long as the resulting apps do not download any code. This should give developers the flexibility they want, while preserving the security we need."" 
58. ^ "Great News for MonoTouch Users". http://tirania.org/blog/archive/2010/Sep-09.html. ""With these new terms, the ambiguity is gone and C# lovers and enthusiasts can go back to using MonoTouch. Developers that like garbage collection and their strongly typed languages can resume their work."" 
59. ^ "Novell's Mono project bringing .Net development to Android". NtworkWorld. http://www.networkworld.com/news/2010/031610-novells-mono-project-bringing-net.html. 
60. ^ "Novell's Mono project bringing .Net development to Android". InfoWorld. http://www.infoworld.com/d/developer-world/novells-mono-project-bringing-net-development-android-778. 
61. ^ "MonoDroid: .NET Support Coming to Android". TechieBuzz. http://techie-buzz.com/mobile-news/monodroid-net-support-android.html. 
62. ^ "Mono for Android brings C# to Android". Heise Online. 2011-04-07. http://www.h-online.com/open/news/item/Mono-for-Android-brings-C-to-Android-1223483.html. Retrieved 2011-04-07. 
63. ^ "Novell (Mono/C#) is developing MonoDroid". Android Community. http://androidcommunity.com/novel-monoc-is-developing-monodroid-20100217/. ""This will make it easier for developers to make cross platform apps as well as bring some of the existing apps that are made using MonoTouch to Android."" 
64. ^ "Mono for Android". H-Online. http://www.h-online.com/open/news/item/Mono-for-Android-957628.html. ""Our vision is to allow developers to reuse their engine and business logic code across all mobile platforms and swapping out the user interface code for a platform-specific API."" 
65. ^ "Microsoft won't stop (Mono) .NET on Android". TechWorld. http://www.techworld.com.au/article/358564/microsoft_won_t_stop_net_android. ""The type of action Oracle is taking against Google over Java is not going to happen. If a .NET port to Android was through Mono it would fall under the Microsoft Community Promise Agreement."" 
66. ^ "Microsoft says .NET on Android is safe, no litigation like Oracle". Developer Fusion. http://www.developerfusion.com/news/85355/microsoft-says-net-on-android-is-safe-no-litigation-like-oracle/. 
67. ^ "Mono C# Compiler Under MIT X11 License". Novell Inc. 2008-04-08. http://www.mono-project.com/news/archive/2008/Apr-08.html. 
68. ^ http://tirania.org/blog/archive/2008/Apr-16-2.html
69. ^ "Will open source get snagged in .Net?", Charles Babcock, ZDNet Asia on August 7, 2001
70. ^ "Microsoft's Empty Promise", Brett Smith, fsf.org, July 16, 2009
71. ^ "Mono Position Statement". Canonical Ltd.. https://lists.ubuntu.com/archives/ubuntu-devel-announce/2009-June/000584.html. "It is common practice in the software industry to register patents as protection against litigation, rather than as an intent to litigate. Thus mere existence of a patent, without a claim of infringement, is not sufficient reason to warrant exclusion from the Ubuntu Project." 
72. ^ Mono FAQ: Licensing | Patents
73. ^ "How Mono got into Fedora". Linux Weekly News. http://lwn.net/Articles/179597/. "The list of "certain Linux-related applications" is said to exist, though it has not, yet, been posted publicly. But Mono is apparently on that list. So anybody who files patent infringement suits against Mono users, and who is, in turn, making use of technology covered by OIN's patents is setting himself up for a countersuit. Depending on the value of the patents held by OIN, that threat could raise the risk of attacking Mono considerably." 
74. ^ "The ECMA C# and CLI Standards". Port 25. 2009-07-06. http://port25.technet.com/archive/2009/07/06/the-ecma-c-and-cli-standards.aspx. ""Under the Community Promise, Microsoft provides assurance that it will not assert its Necessary Claims against anyone who makes, uses, sells, offers for sale, imports, or distributes any Covered Implementation under any type of development or distribution model, including open-source licensing models such as the LGPL or GPL."" 
75. ^ "Mono Position Statement". Canonical Ltd.. 2009-06-30. https://lists.ubuntu.com/archives/ubuntu-devel-announce/2009-June/000584.html. Retrieved 2010-05-12. "Given the above, the Ubuntu Technical Board sees no reason to exclude Mono or applications based upon it from the archive, or from the default installation set." 
76. ^ "Fedora is concerned about Mono". internetnews.com. 2009-06-12. http://blog.internetnews.com/skerner/2009/06/fedora-is-concerned-about-mono.html. Retrieved 2010-07-04. "We haven't come to a legal conclusion that is pat enough for us to make the decision to take mono out" 

References

• This article incorporates text from Mono's homepage, which was then under the GNU Free Documentation License.
• Miguel de Icaza (October 13, 2003). "[Mono-list] Mono early history." (mailing list). http://lists.ximian.com/archives/public/mono-list/2003-October/016345.html. Retrieved December 6, 2005. 
• Edd Dumbill (March 11, 2004). "Will Mono Become the Preferred Platform for Linux Development?". ONLamp. http://www.onlamp.com/pub/a/onlamp/2004/03/11/mono.html. Retrieved October 14, 2006. 
• Eugenia Loli-Queru (February 22, 2005). "Mono Applications? Aplenty!". OSNews. http://www.osnews.com/story.php?news_id=9780. Retrieved December 6, 2005. 
• Sean Michael Kerner (November 18, 2005). "Mono Project Goes Virtual". Internet News. http://www.internetnews.com/dev-news/article.php/3565496. Retrieved October 14, 2006. 
• Kerner, Sean Michael (November 9, 2006). "Months Late, Novell Ships Mono 1.2". internetnews.com. http://www.internetnews.com/dev-news/article.php/3643026. 
• Corey Northcutt (October 12, 2006). "In the World of mod_mono". Ubiquity. http://blog.ubiquityhosting.com/?p=34. Retrieved October 14, 2006. 
• Sean Campbell (October 8, 2008). "Interview with Joseph Hill - Product Manager - Mono - Novell". HSIB. http://howsoftwareisbuilt.com/2008/10/08/interview-with-joseph-hill-mono/. Retrieved October 8, 2008. 
• Tim Smith (September 9, 2010). "A Brief Introduction to the Java and .NET Patent Issues". InfoQ. http://www.infoq.com/articles/java-dotnet-patents. Retrieved September 13, 2010. 

External links

• Mono Project Main Page
• MonoTouch Main Page for the port to Apple Inc.'s hand-held products