This was a very interesting year for Mono, and I wanted to capture some of the major milestones and news from the project as well as sharing a bit of what is coming up for Mono in 2012.
I used to be able to list all of the major applications and great projects built with Mono. The user base has grown so large that I am no longer able to do this. 2011 was a year that showed an explosion of applications built with Mono.
In this post I list a few of the high profile projects, but it is by no means an extensive list. There are too many great products and amazing technologies being built with Mono, but a comprehensive list would take too long to assemble.
The largest event for Mono this year was that the team working on Mono technologies at Novell was laid off after Novell was acquired.
We got back on our feet, and two weeks after the layoffs had taken place, the original Mono team incorporated as Xamarin.
Launching Xamarin was a huge effort for all of us.
Xamarin would not have been possible without our great customers and friends in the industry. Many people cared deeply about the technology and helped us get up and running.
In July, we announced an agreement with Attachmate that ensured a bright future for our young company.
A couple of days later, we were ready to sell the mobile products that had been previously developed at Novell, and we started to provide all existing Novell customers with ongoing support for their Mono-based products.
Half a year later, we grew the company and continued to do what we like the most: writing amazing software.
Meanwhile, our users have created amazing mobile applications. You can see some of those in our App Catalog.
On the Mobile Space: This year Sony jumped to C# in a big way with the introduction of PS Suite (see the section below) and Nokia adopted Windows Phone 7 as their new operating system.
And we got you covered on Android and iOS for all of your C# needs.
On the Browser: we worked with Google to bring you Mono to Native Client. In fact, every demo shown at the Google Native Client event on December 8th was powered by Mono.
On the Desktop: this year we added MacOS X as a first-class citizen in the world of supported Mono platforms. We did this by introducing MonoMac 1.0 and supporting Apple's MacStore with it.
Games: continue to take advantage of C# blend of performance and high-level features. Read more on my GDC 2011 post.
It is a wild new world for C# and .NET developers that were used to build their UI using ASP.NET or Winforms only. It has been fascinating to see developers evolve their thinking from a Microsoft-only view of the world to a world where they design libraries and applications that split the presentation layer from the business logic.
Developers that make this transition will be able to get great native experiences on each device and form factor.
Sony PSSuite - Powered by Mono
At GDC, Sony announced that PS Suite was built on top of Mono. PS Suite is a new development stack for cross-platform games and cross-platform applications to run on Android devices and Sony Vita.
The PS Suite presentation is available in this video.
In particular, watch the game in Video 2 to get a feeling for the speed of a 3D game purely written in managed code (no native code):
Some of the juicy details from the GDC announcement:
- PS Suite will have an open appstore model, different than the traditional game publishing business.
- Open SDK, available for everyone at launch time.
- PS Suite supports both game development with Sony's 3D libraries as well as regular app development.
- Cross-platform, cross-device, using the ECMA Common Intermediate Language.
- Code in C#, run using Mono.
- GUI Designer called "UI Composer" for non-game applications.
- The IDE is based on MonoDevelop.
- Windows-simulator is included to try things out quickly.
MonoDevelop on PSSuite:
PS Suite comes with a GUI Toolkit and this is what the UI composer looks like:
Google Native Client
Google Engineers ported Mono to run on the sandboxed environment of Native Client. Last year they had added support for Mono code generator to output code for Native Client using Mono's static compiler.
This year Google extended Native Client to support Just in Time Compilation, in particular, Mono's brand of JIT compilation. This was used by all three demos shown at the Google Native Client event a couple of days ago:
Unity Powered Builder
This is another game built with Unity's Native Client code generator:
To get the latest version of Mono with support for Native Client, download and build Mono from Google's branch on github.
This was the year of Mono 2.10. We went from a beta release for Mono 2.10 in January to making it our new stable release for Mono.
While the world is on Mono 2.10, we have started our work to get Mono 2.12 out in beta form in January.
Mono on Android
This year we launched Mono for Android, a product that consists of port of Mono to the Android OS, C# bindings to the native Java APIs and IDE support for both MonoDevelop and Visual Studio.
The first release came out in April, it was rough around the edges, but thanks to the amazing community of users that worked with us during the year, we solved the performance problems, the slow debugging, vastly improved the edit/debug/deploy cycle and managed to catch up to Google's latest APIs with the introduction of Mono for Android 4.0.
Mono on iOS
Just like Android, we have been on a roll with MonoTouch.
In short, this year:
- We kept up with Apple's newly introduced APIs (UIKit, iCloud, Airplay, Bluetooth, Newstand, CoreImage).
- Integrated XCode 4's UI designer with MonoDevelop< and added support for storyboards.
- Added the option of using LLVM for our builds, bringing thumb support and ARMv7 support along the way.
We started beta-testing a whole new set of features to be released early next year: a new unit testing framework, a heap profiler, integrating MonoTouch.Dialog in the product and improving the debug/deploy process.<
Mono for iOS has been on the market now for two years, and many products are coming to the market based on it.
Phalanger is a PHP compiler that runs on the .NET and Mono VMs and is powered by the Dynamic Language Runtime.
It is so complete that it can run both MediaWiki and WordPress out of the box. And does so by running faster than they would under PHP.
This year the Phalanger guys released Phalanger 3.0 which now runs on Mono (previously they required the C++/CLI compiler to run).
Phalanger's performance is impressive as it is just as fast as the newly announced Facebook HipHop VM for PHP. The major difference being that Phalanger is a complete PHP implementation and the HipHopVM is still not a complete implementation.
The other benefit of Phalanger is that it is able to participate and interop with code written in other .NET languages as well as benefitting from the existing .NET interop story (C, C++).
Our technology to bridge C# and C++ matured to the point that it can be used by regular users.
Compiler as a Service
This year our C# compiler was expanded in three directions:
- We completed async/await support
- We completed the two code output engines (System.Reflection.Emit and IKVM.Reflection).
- We improved the compiler-as-a-service features of the compiler.
Our async/await support is scheduled to go out with the first preview of Mono 2.11 in early January. We can not wait to get this functionality to our users and start building a new generation of async-friendly/ready desktop, mobile and server apps.
One major difference between our compiler-as-a-service and Microsoft's version of the C# compiler as a service is that we support two code generation engines, one generates complete assemblies (like Microsoft does) and the other one is able to be integrated with running code (this is possible because we use System.Reflection.Emit and we can reference static or dynamic code from the running process).
We have also been improving the error recovery components of the compiler as this is going to power our new intellisense/code completion engine in MonoDevelop. Mono's C# compiler is the engine that is powering the upcoming NRefactory2 library.
You can read more about our compiler as a service updates.
Unity is one of Mono's major users. At this point Unity no longer requires an introduction, they went from independent game engine a few years ago to be one of the major game engine platforms in the game industry this year.
The Unity engine runs on every platform under the sun. From the Consoles (PS3, Wii and XBox360) to iPhones and Androids and runs on your desktop either with the Unity3D plugin or using Google's Native Client technology. The list of games being built with Unity keeps growing every day and they are consistently among the top sellers on every app store.
Mono is the engine that powers the scripts and custom code in games and applications built with Unity3D and it also powers the actual tool that users use to build games, the Unity3D editor:
The editor itself it implemented in terms of Unity primitives, and users can extend the Unity3D editor with C#, UnityScript or Boo scripts dynamically.
One of my favorite games built with Unity3D is Rochard was demoed earlier this year on a PS3 at the GDC and is now also avaialble on Steam:
Just before the end of the year, Microsoft shipped Kinectimals for iOS systems.
Kinectimals is built using Unity and this marks the first time that Microsoft ships a software product built with Mono.
Then again, this year has been an interesting year for Microsoft, as they have embraced open source technologies for Azure, released SDKs for iOS and Android at the same time they ship SDKs for their own platforms and shipped various applications on Apple's AppStore for iOS.
We started the year with MonoDevelop 2.4 and we finished after two major releases with MonoDevelop 2.8.5.
In the course of the year, we added:
- Native Git support
- Added .NET 4.0 project support, upgraded where possible to XBuild/MSBuild
- MonoMac Projects
- XCode 4 support for MonoMac, MonoTouch and Storyboards
- Support for Android development
- Support for iOS5 style properties
- Major upgrade to the debugger engine
- Adopted native dialogs on OSX and Windows
Our Git support was based on a machine assisted translation of the Java jGit library using Sharpen. Sharpen has proved to be an incredibly useful tool to bring Java code to the .NET world.
Our precise collector has gotten a full year of testing now. With Mono 2.10 we made it very easy for developers to try it out. All users had to do was run their programs with the --sgen flag, or set MONO_ENV_OPTIONS to gc=sgen.
Some of the new features in our new Garbage Collector include:
- Windows, MacOS X and S390x ports of SGen (in addition to the existing x86, x86-64 and ARM ports).
- Lock-free allocation to improve scalability (we only take locks when we run out of memory).
- Work stealing parallel collector and a parallel nursery collector, to take advantage of extra CPUs on the system to help with the GC.
- Work on performance and scalability work, as our users tried things out in the field, we identified hot-spots in SGen which we have been addressing.
As we are spending so much time on ARM-land these days, SGen has also gained various ARM-specific optimizations.
SGen was designed primarly to be used by Mono and we are extending it beyond being a pure garbage collector for Mono, to support scenarios where our garbage collector has to be integrated with other object systems and garbage collectors. This is the case of Mono for Android where we now have a cooperative garbage collector that works hand-in-hand with Dalvik's GC. And we also introduce support for toggle references to better support Objective-C environments like MonoTouch and MonoMac.
XNA and Mono: MonoGame
Ever since Microsoft published the XNA APIs for .NET, developers have been interested in bringing XNA to Mono-based platforms.
There was a MonoXNA project, which was later reused by projects like SilverXNA (an XNA implementation for Silverlight) and later XNAtouch an implementation of XNA for the iPhone powered by MonoTouch. Both very narrow projects focused on single platforms.
This year, the community got together and turned the single platform XNATouch into a full cross-platform framework, the result is the MonoGame project:
Platform Support Matrix
Currently MonoGame's strength is on building 2D games. They already have an extensive list of games that have been published on the iOS AppStore and the Mac AppStore and they were recently featured in Channel 9's Coding For Fun: MonoGame Write Once Play Everywhere.
An early version of MonoGame/XnaTouch powers SuperGiantGame's Bastion game on Google's Native Client. Which allows users of Windows, Mac and Linux desktop systems to run the same executable on all systems. If you are running Chrome, you can install it in seconds.
The MonoGame team had been relatively quiet for the most part of 2011 as they were building their platform, but they got into a good release cadence with the MonoGame 2.0 release in October, when they launched as a cross-platform engine, followed up with a tasty 2.1 release only two weeks ago.
With the addition of OpenGL ES 2.0 support and 3D capabilities to MonoGame, 2012 looks like it will be a great year for the project.
Since MonoDevelop is built on top of the Gtk+ toolkit and since it was primarily a Unix toolkit there have been a few rough areas for our users in both Mac and Windows.
This year we started working with the amazing team at Lanedo to improve Gtk+ 2.x to work better on Mac and Windows.
The results are looking great and we want to encourage developers to try out our new Beta version of Mono, which features the updated Gtk+ stack.
This new Gtk+ stack solves many of the problems that our users have reported over the past few months.
I never tracked Mono downloads as I always felt that tracking download numbers for open source code that got repackaged and redistributed elsewhere pointless.
This summer we moved the code hosting from Novell to Xamarin and we were surprised by our hosting bills.
The major dominating force are binaries for Windows and MacOS which are communities that tend not to download source and package the software themselves. This is the breakdown for completed downloads (not partial downloads, or interrupted ones) for our first month of hosting of Mono:
- 39,646 - Mono for Windows (Runtime + SDK)
- 27,491 - Mono for Mac (Runtime)
- 9,803 - Mono for Windows (Runtime)
- 9,910 - Mono for Mac (Runtime + SDK)
- Total: 86,850 downloads for Windows and Mac
These numbers are only for the Mono runtime, not MonoDevelop, the MonoDevelop add-ins or any other third party software.
It is also worth pointing out that none of our Windows products (MonoDevelop for Windows, or Mono for Android on Windows) use the Mono runtime. So these downloads are for people doing some sort of embedding of Mono on their applications on Windows.
At this point, we got curious. We ran a survey for two days and collected 3,949 answers. These is the summary of the answers:
What type of application will you run with Mono?
This one was fascinating, many new users to the .NET world:
The best results came form the free-form answers in the form. I am still trying to figure out how to summarize these answers, they are all very interesting, but they are also all over the map.
Some Key Quotes
When I asked last week for stories of how you used Mono in 2011, some of you posted on the thread, and some of you emailed me.
Here are a couple of quotes from Mono users:
I can't do without Mono and I don't just mean the iOS or Android dev with C# but MonoMac and Mono for *nix too. Thanks for everything; from the extraordinary tools to making hell turn into heaven, and thank you for making what used to be a predicament to effortless development pleasure.
That's where Mono comes in.
Gratefulness and paying polite respects aside, the key tenets of Mono we use are:
- shared C# code base for all our enterprise solutions - achieving the write once, compile everywhere promise with modern language and VM features everyone demands and expects in this century
- logical, consistent and self-explanatory wrapper APIs for native services - allows us to write meta APIs of our own across platforms
- low latency, low overhead framework
- professional grade IDE and tools
- native integration with iOS tools and development workflow
- existence of satisfactory documentation and support
- legal clarity - favorable licensing options
- dedicated product vision via Xamarin - commercial backing
- community support
Koen Pijnenburg shared this story with me:
We've been in touch a few times before and would like to contribute my story. It's not really an interesting setup, but a real nice development for Mono(Touch). I've been developing app for iPhone since day 1, I was accepted in the early beta for the App Store. On launch day july 2008, 2 of the 500 apps in the App Store were mine, my share has decreased a lot in the past years ;)
I really, really, really like football(soccer), maybe you do also, I don't know. In september 2008 I created the first real soccer/football stats app for the iPhone called My Football. This was a huge succes, basically no competition at that time. In 2009 I released My Football Pro, an app with 800 leagues worldwide, including live data for more then 100 leagues. Since then I created lots of apps, all created with the iPhone SDK and with Objective-C.
Since the launch of MonoTouch, it merged the best of two worlds in my opinion. I've been a Mono/.NET developer for years before the iPhone apps, for me it was love at first line of code.
The last year I've increased my work with MonoTouch / Droid /MonoGame(Poppin' Frenzy etc ;)), and focused less on working with native SDK's only. Since our My Football apps are at the end of their lifecycle in this form, we are working on a new line of My Football apps. Our base framework supporting our data, is built with Mono, and the apps UI will be built with MonoTouch / MonoDroid / WP7 etc.
Included is the screenshot of our first app built with the framework, My Football Pro for iPad. It has a huge amount of data, stats / tables / matches / live data for more then 800 leagues worldwide. We think it's a great looking app!
Working with MonoTouch is fantastic and just wanted you to know this!
Mono on Mainframes
This year turned out to show a nice growh in the deployment of Mono for IBM zSeries computers.
Some are using ASP.NET, some are using Mono in headless mode. This was something that we were advocating a few years ago, and this year the deployments went live both in Brazil and Europe.
Neale Ferguson from Sinenomine has kept the zSeries port active and in shape.
Mono and ASP.NET
This year we delivered enough of ASP.NET 4.0 to run Microsoft's ASP.NET MVC 3.
Microsoft ASP.NET MVC 3 is a strange beast. It is licensed under a great open source license (MS-PL) but the distribution includes a number of binary blobs (the Razor engine).
I am inclined to think that the binaries are not under the MS-PL, but strictly speaking, since the binaries are part of the MS-PL distribution labeled as such, the entire download is MS-PL.
That being said, we played it safe in Mono-land and we did not bundle ASP.NET MVC3 with Mono. Instead, we provide instructions on how users can deploy ASP.NET MVC 3 applications using Razor as well as pure Razor apps (those with .cshtml extensions) with Mono.
2012, the year of Mono 2.12
2012 will be a year dominated by our upcoming Mono release: Mono 2.12. It packs a year worth of improvements to the runtime, to our build process and to the API profiles.
Mono 2.12 defaults to the .NET 4.x APIs and include support for .NET 4.5.
This is going to be the last time that we branch Mono for these extended periods of time. We are changing our development process and release policies to reduce the amount of code that is waiting on a warehouse to be rolled out to developers.
We wrapped up our work on updating the ECMA CLI standard this year. The resulting standard is now at ISO and going through the standard motions to become an official ISO standard.
The committee is getting ready for a juicy year ahead of us where we are shifting gears from polish/details to take on significant extensions to the spec.