| Mono | |
|---|---|
 | |
 Diagram of Mono architecture | |
| Original author | Ximian |
| Developer | WineHQ |
| Initial release | June 30, 2004; 21 years ago (2004-06-30) |
| Stable release | |
| Repository | |
| Written in | C,C#,XML |
| Operating system | Windows,macOS,Linux,IBM AIX,IBM i[2] |
| Platform | IA-32,x64,IA-64,ARM,MIPS,RISC-V,PowerPC,SPARC,S390 |
| Type | Software framework |
| License | MIT License[3] |
| Website | www |
Mono is afree and open-sourcesoftware framework that aims to run software made for the.NET Framework onLinux and other OSes. Originally byXimian which was acquired byNovell, it was later developed byXamarin which was acquired byMicrosoft.[4] In August 2024, Microsoft transferred ownership of Mono toWineHQ.[5]
When Microsoft first announced their.NET Framework in June 2000 it was described as "a new platform based on Internet standards",[6] and in December of that year the underlyingCommon Language Infrastructure was published as an open standard, "ECMA-335",[7] opening up the potential for independent implementations.[8]Miguel de Icaza ofXimian believed that .NET had the potential to increase programmer productivity and began investigating whether a Linux version was feasible.[9] 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 theO'Reilly conference.
After three years of development, Mono 1.0 was released on June 30, 2004.[10] 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.[11]
Novell acquired Ximian in 2003. After Novell was acquired byAttachmate in April 2011, Attachmate announced hundreds of layoffs for the Novell workforce,[12] putting in question the future of Mono.[13][14]
On May 16, 2011, Miguel de Icaza announced in his blog that Mono would continue to be supported byXamarin, a company he founded after being laid off from Novell. The original Mono team had also moved to the new company. Xamarin planned to keep working on Mono and had planned to rewrite the proprietary .NET stacks foriOS andAndroid from scratch, because Novell still owned MonoTouch and Mono for Android at the time.[15] 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 byAttachmate, and considering that the Xamarin team would have difficulties proving that they did not use technologies they formerly developed when they were employed byNovell for the same work.[16] 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 officially took stewardship of the project.[17][18]
On February 24, 2016, Microsoft announced it had signed a definitive agreement toacquire Xamarin.[19]
On August 27, 2024, Microsoft transferred ownership of Mono to WineHQ, the developer team ofWine, a Windows compatibility layer.[5]
Mono's current version is 6.12.0 (as of June 2024[update]). This version provides the coreAPI of the.NET Framework and support for Visual Basic.NET and C# 7.0.LINQ to Objects, XML, andSQL are part of the distribution.Windows Forms 2.0 is also supported, but not actively developed, and as such its support on Mono is incomplete.[20] Version 4.0 was the first version that incorporates Microsoft original source code that was released by Microsoft as part of the.NET Core project.
As of January 14, 2021, Mono has full support for all the features in .NET 4.7 exceptWindows Presentation Foundation (WPF) (which the Mono team do not plan to support due to the amount of work it would need)[20] andWindows Workflow Foundation (WF), and with only limited support forWindows Communication Foundation (WCF) and the ASP.NET async stack. However, System.Web and WCF are candidates for 'almost immediate' porting from the .NET reference source back to Mono.[21] Some missing parts of the.NET Framework are under development in an experimental Mono subproject calledOlive.[22]
The Mono project has also created aVisual Basic .NET compiler and a runtime designed for running VB.NET applications. It is currently being developed by Rolf Bjarne Kvinge.
An open-source implementation ofMicrosoft Silverlight, calledMoonlight, has been included since Mono 1.9.[23] 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.[24] A preview release of Moonlight 3.0 was announced in February 2010 and contains updates to Silverlight 3 support.[25]
The Moonlight project was abandoned on May 29, 2012.[26] According to Miguel, two factors sealed the fate of the project: Microsoft added "artificial restrictions" that "made it useless for desktop programming", and the technology had not gained enough traction on the Web. In addition, Silverlight itself was deprecated by Microsoft by 2012.
Mono consists of three groups of components:
Thecore components include the C# compiler, the virtual machine for theCommon Language Infrastructure and the core class libraries. These components are based on theEcma-334 and Ecma-335 standards,[27] allowing Mono to provide a standards compliant, free and open-source CLIvirtual machine. Microsoft issued a statement that covers both standards under theirCommunity Promise license.[28]
TheMono/Linux/GNOME development stack provide tools for application development while using the existingGNOME andfree and open-source libraries. These include:Gtk# forgraphical user interface (GUI) development, Mozilla libraries for working with theGecko rendering engine, Unix integration libraries (Mono.Posix), database connectivity libraries, a security stack, and the XML schema languageRelaxNG. Gtk# allows Mono applications to integrate into the Gnome desktop as native applications. The database libraries provide connectivity to the object-relational databasedb4o,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.[29]
TheMicrosoft compatibility stack provides a pathway for porting Windows .NET applications toLinux. This group of components includeADO.NET,ASP.NET, andWindows Forms (and libgdiplus), among others. As these components are not covered byEcma standards, some of them remain subject topatent fears and concerns.
The major components of Mono include:
The Mono runtime contains a code execution engine that translates ECMACIL byte codes into native code and supports a number of processors:ARM,MIPS (in 32-bit mode only),SPARC,PowerPC,z/Architecture,IA-32,x86-64 andIA-64 for 64-bit modes.
The code generator is exposed in three modes:
Starting with Mono 2.6, it is possible to configure Mono to use theLLVM 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-starting Mono code generation engine.
Starting with Mono 5.18, support for LLVM is a default configuration option. Previous versions required a special LLVM fork, but now mono can fall back to its own code generator when it encounters something not handled by LLVM.[30]
As of Mono 2.8, the Mono runtime ships with twogarbage collectors: a generational collector and theBoehm–Demers–Weiser Conservative Garbage Collector. The Boehm garbage collector could exhibitmemory leaks on certain classes of applications, making it unsuitable for some long-running server applications.[31][32] Mono switched toSimple Generational GC (SGen-GC) as the default collector in version 3.1.1.
The SGen garbage collector has many advantages over a traditional conservative scanner. It usesgenerational 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 is 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.[31]
Theclass 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.[33]
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.
TheCommon Language Infrastructure (CLI) as implemented by theCommon Language Runtime (CLR), is implemented by the Mono executable. The runtime compiles and executes .NET applications. The common language infrastructure is defined by the ECMA standard.[27] To run an application, you must invoke the runtime with the relevant parameters.
TheCommon 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.
Within a native .NET/Mono application, all code ismanaged; 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 asGtk#.
Mono has innovated in some areas with new extensions to the core C# and CLI specifications:
In addition, Mono is available on a variety of operating systems and architectures.[40]
Windows 7, Windows 8, Windows 8.1, Windows 10, macOS or Linux
Several projects extend Mono and allow developers to use it in their development environment. These projects include:
Cross-platform:
macOS:
Mobile platforms:
Windows:
Microsoft has a version of .NET 2.0 now available only forWindows XP, called theShared Source CLI (Rotor). Microsoft'sshared source license may be insufficient for the needs of the community (it explicitly forbids commercial use).
Free Software Foundation's decommissionedPortable.NET project.[44]
MonoDevelop is a freeintegrated development environment primarily designed for C# and other .NET languages such asNemerle,Boo, andJava (viaIKVM), although it also supports languages such asC,C++,Python, andVala. MonoDevelop was originally a port ofSharpDevelop 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.
Xamarin.iOS and Xamarin.Android, both developed byXamarin, are implementations of Mono foriPhone andAndroid-based smartphones. Previously available only for commercial licensing,[45] after Microsoft's acquisition of Xamarin in 2016, the Mono runtime itself wasrelicensed underMIT license[46] and both Xamarin.iOS and Xamarin.Android are being made free and open-source.[47]
Xamarin.iOS (previously named MonoTouch) is a library that allows developers to create C# and .NET based applications that run on the iPhone, iPod and iPad devices. It is based on the Mono framework and developed in conjunction with Novell. Unlike Mono applications, Xamarin.iOS "Apps" are compiled down to machine code targeted specifically at theAppleiPhone andiPad.[48] This is necessary because the iOS kernel preventsjust-in-time compilers from executing on the device.
The Xamarin.iOS stack is made up of:
Xamarin Studio is used as the primary IDE, however additional links toXcode and the iOS 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++ andObjective-C, and the use of a middle layer between the iOS platform and iPhone applications. This made the future of MonoTouch, and other technologies such asUnity, uncertain.[49] 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.[50][51]
| Date | Version | Notes |
|---|---|---|
| September 14, 2009 | MonoTouch 1.0[52] | Initial release |
| April 5, 2010 | MonoTouch 2.0[53] | iPad support |
| April 16, 2010 | MonoTouch 3.0[54] | iPhone 4 support |
| April 6, 2011 | MonoTouch 4.0[55] | iOS 4 support |
| October 12, 2011 | MonoTouch 5.0[56] | iOS 5 support |
| September 19, 2012 | MonoTouch 6.0[57] | iOS 6 support |
| February 20, 2013 | Xamarin.iOS 6.2[58] | Visual Studio support |
| July 24, 2013 | Xamarin.iOS 6.4[59] | .NET 4.5 async/await support |
| June 19, 2013 | Xamarin.iOS 7.0[60] | XCode 5 and iOS 7 support |
| September 10, 2014 | Xamarin.iOS 8.0[61] | iOS 8 and Xcode 6 support |
| September 16, 2015 | Xamarin.iOS 9.0[62] | iOS 9 and Xcode 7 support |
| September 13, 2016 | Xamarin.iOS 10.0[63] | iOS 10 and Xcode 8 support |
| September 19, 2017 | Xamarin.iOS 11.0[64] | iOS 11 and Xcode 9 support |
| September 14, 2018 | Xamarin.iOS 12.0[65] | iOS 12 and Xcode 10 support |
| September 13, 2019 | Xamarin.iOS 13.0[66] | iOS 13 and Xcode 11 support |
| September 20, 2020 | Xamarin.iOS 14.0[67] | iOS 14 and Xcode 12 support |
Xamarin.Android (formerly known as Mono for Android), initially developed byNovell and continued byXamarin, is a proprietary[citation needed][68] implementation of Mono forAndroid-based smart-phones.[69][70][71] It was first released on April 6, 2011.[72] Mono for Android was developed to allow developers to more easily write cross-platform applications that will run on all mobile platforms.[73] 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."[74]
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 theMicrosoft Community Promise Agreement."[75][76]
The Xamarin.Android stack consists of the following components:
Cocoa# (also known as CocoaSharp) was a bridgeframework forMac OS X, which allowed applications developed with the Mono runtime to access theCocoa API. It was initially released on August 12, 2004,[78] and was included with the Mono distribution starting with version 1.0.6, released on February 18, 2005.[citation needed] It has not seen any development since 2008,[citation needed] and is now deprecated.[79]
Monobjc was CocoaSharp's replacement. It allows .NET developers to use most of the Mac OS X API, including Cocoa, with no native code, while still achieving a native UI.[citation needed]
Xamarin.Mac is a library that allows developers to run .NET and C# apps on theMac.[80]
Mono isdual licensed by Xamarin, similar to other products such asQt and theMozilla Application Suite. Mono's C# compiler and tools are released under theGNU General Public License (GPLv2 only) (starting with version 2.0 of Mono, the Mono C# compiler source code is also available under theMIT X11 License),[81] the runtime libraries under theGNU Lesser General Public License (LGPLv2 only) and the class libraries under theMIT License. These are allfree software andopen-source licenses and hence Mono isfree andopen-source software.
The license of the C# compiler was changed from the GPL to the MIT X11 license[82] to allow the compiler code to be reused in a few instances where the GPL would have prevented such:
On March 18, 2016, Microsoft's acquisition of Xamarin was officially closed.[83]On March 31, 2016, Microsoft announced atMicrosoft Build that they'll completelyre-license Mono under theMIT License even in scenarios where previously a commercial license was necessary,[84] and Microsoft stated that they won't assert any "applicable patents" against parties that are "using, selling, offering for sale, importing, or distributing Mono."[85][86] It was also announced that Xamarin had contributed the Mono Project to the .NET Foundation.[85]
On July 6, 2009, Microsoft announced that it was placing their ECMA 334 and ECMA 335 specifications under theirCommunity Promise pledging that they would not assert their patents against anyone implementing, distributing, or using alternative implementations of .NET.[87] Mono's implementation of those components of the .NET stack not submitted to theECMA for standardization has been the source of patent violation concerns for much of the life of the project.[88] In particular, discussion has taken place about whether Microsoft could destroy the Mono project through patent suits.[89]
The base technologies submitted to the ECMA, and therefore also the Unix/GNOME-specific parts, are claimed to be safe due to Microsoft's explicitly placing both ECMA 334 (C#) and ECMA 335 (CLI) standards under theMicrosoft Community Promise. The concerns primarily relate to technologies developed by Microsoft on top of the .NET Framework, such asASP.NET,ADO.NET andWindows Forms (seenon-standardized namespaces), i.e. parts composing Mono's Windows compatibility stack. These technologies are today[when?] 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.
In June 2009 the Ubuntu Technical Board stated that it saw "no reason to exclude Mono or applications based upon it from the archive, or from the default installation set."[90]
TheFree Software Foundation's Richard Stallman has stated on June 2, 2009, that "[...] we should discourage people from writing programs in C#. Therefore, we should not include C# implementations in the default installation of GNU/Linux distributions or in their principal ways of installing GNOME".[91] On July 1, 2009, Brett Smith (also from the FSF) stated that "Microsoft's patents are much more dangerous: it's the only major software company that has declared itself the enemy of GNU/Linux and stated its intention to attack our community with patents.", "C# represents a unique threat to us" and "The Community Promise does nothing to change any of this".[92]
Fedora Project Leader Paul Frields has stated, "We do have some serious concerns about Mono and we'll continue to look at it with our legal counsel to see what if any steps are needed on our part", yet "We haven't come to a legal conclusion that is pat enough for us to make the decision to take mono out".[93]
In November 2011 at anUbuntu Developer Summit, developers voted to have the Mono-basedBanshee media player removed from Ubuntu's default installation beginning onUbuntu 12.04; although reported reasonings included performance issues onARM architecture, blocking issues on its GTK+ 3 version, and it being, in their opinion, "not well maintained", speculation also surfaced that the decision was also influenced by a desire to remove Mono from the base distribution, as the remaining programs dependent on Mono,gbrainy andTomboy, were also to be removed. Mono developer Joseph Michael Shields defended the performance of Banshee on ARM, and also the claims that Banshee was not well-maintained as being a "directed personal insult" to one of its major contributors.[94]
Many programs covering a range of applications have been developed using the Monoapplication programming interface (API) and C#. Some programs written for the Linux Desktop includeBanshee,Beagle,F-Spot,Gbrainy,Docky/GNOME Do,MonoTorrent,Pinta, andTomboy. The program,Logos 5 Bible Study Software (OS X Version), was written for the MacOS.
A number of video games, such asThe Sims 3 andSecond Life (for theirscripting languages),OpenSimulator virtual world server, or games built with theUnity orMonoGamegame engines, also make use of Mono.[95]OpenRA bundles itsApple Disk Image and LinuxAppImages with Mono essentially removing almost all dependencies from the game.[96]
| Date | Version[98] | Notes |
|---|---|---|
| June 30, 2004 | 1.0[99] | C# 1.0 support |
| September 21, 2004 | 1.1[100] | |
| November 9, 2006 | 1.2[101] | C# 2.0 support |
| October 6, 2008 | 2.0[102] | Mono's APIs are now in par with .NET 2.0. Introduces theC# 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. |
| January 13, 2009 | 2.2[103] | Mono switches its JIT engine to a new internal representation[104] that gives it a performance boost and introducesSIMD support in the Mono.Simd[36] Mono.Simd namespace. Mono introducesFull Ahead of Time compilation that allows developers to create full static applications and debuts the C# Compiler as a Service[34] and the C# Interactive Shell[35] (C# REPL) |
| March 30, 2009 | 2.4[105] | 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. |
| December 15, 2009 | 2.6[106] | 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. |
| September 22, 2010 | 2.8[107] | Defaults to .NET 4.0 profile,C# 4.0 support, new generational garbage collector, includesParallel 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; incorporatesDynamic Language Runtime, MEF,ASP.NET MVC2, OData Client open-source code from Microsoft;. Will become release 3.0 |
| February 15, 2011 | 2.10[108] | |
| October 18, 2012 | 3.0[109] | C# 5.0 support, async support, Async Base Class Library Upgrade and MVC4 - Partial, no async features support. |
| July 24, 2013 | 3.2[110] | Default Garbage Collector is now the SGEN, instead of Boehm |
| March 31, 2014 | 3.4[111] | |
| August 12, 2014 | 3.6[112] | |
| September 4, 2014 | 3.8[113] | |
| October 4, 2014 | 3.10[114] | |
| January 13, 2015 | 3.12[115] | |
| April 29, 2015 | 4.0[116] | Defaults to .NET 4.5 profile and ships only .NET 4.5 assemblies, defaults to C# 6.0. First release to integrate Microsoft open-source .NET Core code |
| May 10, 2017 | 5.0[117] | Shipping Roslyn C# compiler to enable C#7 support; Shipping msbuild and deprecating xbuild for better compatibility; Enabling concurrent SGen garbage collector to reduce time spent in GC; Introducing the AppleTLS stack on macOS for HTTPS connections; Continued Progress on .NET Class Library convergence; Updated libjpeg in macOS package |
| July 14, 2017 | 5.2[118] | Support for .NET Standard 2.0, strong assembly names, and experimental default interface members. |
| October 5, 2017 | 5.4[119] | The JIT Runtime now supports concurrent method compilation and various other Performance Optimisations; Added .NET 4.7 reference assemblies |
| February 1, 2018 | 5.8[120] | InitialWebAssembly port; Modes for the SGen GC; Includes Roslyn's csi (C# interactive) REPL tool |
| February 26, 2018 | 5.10[121] | The Interpreter is now included in the default installation; runtime now supports Default Interface Methods; WebAssembly considered reliable now; Support for .NET 4.7.1 / C# 7.2 / F# 4.1 |
| May 8, 2018 | 5.12[122] | Port to IBM AIX/i; now includesVB.NET compiler; option to usejemalloc |
| August 7, 2018 | 5.14[123] | MajorWindows.Forms update to improve compatibility with .NET |
| October 8, 2018 | 5.16[124] | Hybrid suspend garbage collector; Client certificate support; C# 7.3 support |
| December 21, 2018 | 5.18[125] | .NET 4.7.2 support; moreCoreFX code is used |
| April 11, 2019 | 5.20[126] | SSPI (Security Support Provider Interface) in System.Data assembly; Various issues resolved |
| July 17, 2019 | 6.0[127] | C# compiler defaults to version C# 8.0 RC; Various stability improvement in debugger support; Mono Interpreter is feature complete and stable |
| September 23, 2019 | 6.4[128] | C# compiler support for C# 8 language version; .NET Standard 2.1 support |
| December 10, 2019 | 6.6[129] | Added .NET 4.8 reference assemblies |
| January 15, 2020 | 6.8[130] | Various Bugfixes |
| May 19, 2020 | 6.10[131] | Various Bugfixes |
| November 24, 2020 | 6.12[132] | Various Bugfixes |
| March 4, 2025 | 6.14[133] | First release after transfer toWineHQ |
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.
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.
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.
MonoTouch is a commercial product based on the open source Mono project and is licensed on a per-developer basis.
we are announcing today our commitment to open source the Xamarin SDKs for Android, iOS, and Mac under the MIT license in the coming months
Applications built with MonoTouch are native applications indistinguishable from other native applications.
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.
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.
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.
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.
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.
On May 14, Xamarin announced Mono for Android 4.2.
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.
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.
We haven't come to a legal conclusion that is pat enough for us to make the decision to take mono out
| People |  | ||||
|---|---|---|---|---|---|
| Products |
| ||||
| Related | |||||
| Implementations | |||||||
|---|---|---|---|---|---|---|---|
| Architecture | |||||||
| Components |
| ||||||
| Tools |
| ||||||
| IDEs | |||||||
| Organizations | |||||||
