Xammy BadgesWe are excited to announce the Xammy Awards, which will be awarded this year at Xamarin Evolve 2014. Xamarin developers represent the world’s top mobile developers and this is your chance to be recognized on our global stage.

Apps can be submitted in the following 4 categories:

  • Consumer: Tell us how your app changes the way we interact with the world and each other.
  • Gaming: Show us how you’ve created a breakthrough new game concept, or otherwise advanced the craft of game development.
  • Enterprise: Highlight how your app is transforming business processes and making BYOD work for employees and businesses.
  • Emerging Devices: Showcase how you’re taking C# to new form factors, and pioneering the next generation of mobile experiences.

There will be winners in each category, a Grand Prize winner, and a Developers’ Choice winner. Submissions are open from now until August 11th, and winners in the 4 categories will be announced at Xamarin Evolve 2014.

There is only one chance to claim a category for this inaugural year of the Xammy Awards — submit your app today!

Posted by Andrew Tierney Sunday, July 27, 2014 4:12:00 PM

WWDC Summary 

Apple Announces iOS 8 with Touch ID for Apps, QuickType, Third-Party Keyboards and More

Monday June 2, 2014 11:11 am PDT by Marianne Schultz

Apple announced iOS 8 at the keynote event of its annual Worldwide Developers Conference today. iOS 8 gets a multitude of new features for consumers, including revamped notification features, an upgrade to auto-correct called QuickType, support for third-party keyboards, improvements to Mail, and a new health tracking component called Health

Notification Center 

Interactive notifications let users pull down notifications and interact with them to respond to text messages or other notifications without leaving the current open app, or complete actions from notifications shown on the lock screen. In a demo, Craig Federighi was able to reply to an iMessage and like a Facebook post directly from the on-screen notification, which popped over a separate app he was using. 

Keyboard Enhancements 

A new feature in the iOS keyboard called QuickType, adds predictive typing suggestions that adapt to the current context. QuickType learns each users habits and language while protecting privacy. Along with QuickType enhancing the existing iOS keyboards, Apple is going to allow users to install third-party keyboards for the first time, which means keyboards like Swype can be used natively on the operating system. 

Messages Improvements 

Messages gets the ability to name conversation threads, add and remove people from group conversations, allow users to leave group conversations, a feature that has been much-requested by users. In addition to leaving a message thread, users also have the option to turn on "Do Not Disturb," which will mute message notifications from a noisy group message thread. 

With iOS 8, Messages allows users to share their locations right within the app. It also allows audio and video messages to be recorded directly in the Messages app and sent to friends. These messages can be viewed inline or via the lock screen. Craig Federighi showed off a neat trick with an audio message -- he held the phone up to his ear to reply, with the message automatically sending when he lowered the phone. 


HealthKit is a new developer API that will gather and consolidate users' health information from multiple sources and apps, such as those from Nike and Fitbit. A corresponding "Health" app will monitor fitness metrics, linking into third-party apps to gather data. 

Apple has been testing HealthKit with the Mayo Clinic, letting patients and doctors work together using HealthKit to get personalized thresholds for readings, notifying doctors automatically when something is wrong. HealthKit aims to bridge the gap between patients, doctors, and health-tracking devices. According to the Mayo Clinic, HealthKit has the potential to "revolutionize" how the health industry works. 


Siri gets several updates, with the ability to be invoked hands-free with the phrase "Hey, Siri" along with Shazam song recognition, 22 new dictation languages, streaming voice recognition to show users search results as they speak, and more. 


There are thousands of new APIs for developers, and one of the most exciting of those was Extensibility. This feature allows apps within iOS 8 to share information with each other and with the Notification Center. Demoed on stage, Extensibility allowed filters from third-party apps to be used directly on pictures within the Photos app and it also brought Bing translation to Safari. 

Extensibility also allows apps to install widgets within the Notification Center, which work similar to existing Apple widgets for the Calendar, Stocks, and more. This was demoed with an ESPN SportsCenter widget, which allowed sports scores to be displayed automatically within Notification Center. 

Touch ID 

Developers will also be able to access Touch ID for the first time to protect sensitive apps. Fingerprint data will be kept separate, but authentication will automatically unlock passwords stored in keychain to grant user access to apps. 

Family Sharing 

A Family Sharing feature will let families share photos, calendars, reminders, and more among up to six family members at once. Family Sharing also allows families (of up to 6 people) with Apple ID accounts using the same credit card to share apps and books. With Family Sharing enabled, when a child attempts to purchase an app, an adult will get a popup on their own device asking them to approve the purchase. 

iOS 8 will support most recent Apple iOS devices with the notable exception of the iPhone 4. iOS 8 will be available to developers as a beta today and it will be released to the public in the fall. 


Apple Announces OS X Yosemite with Improved Cross-Device Connectivity and New User Interface

Monday June 2, 2014 10:52 am PDT by Husain Sumra

Apple today announced the latest version of its Mac operating system, OS X Yosemite. The sequel to last year's OS X Mavericks, Yosemite includes a user interface redesign, as well as major new features focusing on seamless integration between Mac and iOS devices, a new cloud storage system called iCloud Drive, as well as the ability to make phone calls and send text messages through an iPhone. 


Continuity is the biggest new feature of OS X Yosemite, improving the connection between Macs and iOS devices. With Continuity, it's possible to share files between Mac and iOS devices and it's also possible to make phone calls on a Mac via an iPhone. 

AirDrop finally allows users to share files, photos, and more between iOS devices and Macs. Previously, this feature only allowed files to be shared from Mac to Mac or from iPhone to iPhone, which means sharing files from an iOS device to a Mac will now be far easier. Apple also debuted Handoff, which is a feature that allows iOS devices and Macs to recognize one another, letting users seamlessly transition from one device to another. For example, if a webpage is opened on Safari on a Mac, a user can pick up an iPhone and continue browsing that same site on his iOS device. In a demo on stage, the function was used to show an email started on the Mac continued on an iPhone. 

Through Continuity, iPhone communications integration allows users to make and answer phone calls sent to their iPhones right on their Macs. "Green bubble" SMS messages from Android also now show up on Macs, and it's easier than ever for a Mac to connect to an iPhone hotspot. 

Design and Notification Center 

The new UI is very similar to the flat look of iOS 7 with translucent windows, a new dock and app icons and an all-new notification center with a Today pane and both first- and third-party widgets like Weather and SportsCenter. There's also a new dark mode, which lets users turn the overall interface into the more darkened tone of Notification Center. 


Spotlight has a brand new interface which looks somewhat like third-party Mac apps likeAlfred and Quicksilver and pops up in the center of the desktop. The new Spotlight allows users to not only search through their computer, but online through sources like Wikipedia, Yelp and for live movie times. In addition, Spotlight can do unit conversions, like converting miles to kilometers. 

iCloud Drive 

Another significant new feature is iCloud Drive, a Dropbox-like service that syncs documents across Macs, iOS devices and Windows. It offers an iCloud storage folder directly within Finder so users can see exactly which files they have in iCloud and it is accessible from both Macs and iOS devices. Apple has introduced new pricing for iCloud with the debut of iCloud Drive. The first 5GB of iCloud storage is free, while 20GB costs $0.99 per month and 200GB costs $3.99 per month. Tiers of up to 1TB are also available.


Improvements to the Mail app in Yosemite include Mail Drop and Markup. Mail Drop's intention is to solve the problem of sending attachments that are far too large and result in failed sendings. iCloud now encrypts the attachments and sends the recipient a link to the attachment if it's too large. Attachments are limited to 5 GB. Markup allows users to sketch and doodle on emails, much like Evernote's Skitch


Safari has also seen improvements with a new "bird's eye" tab view, improved Privacy windows, and support for advanced HTML5 video, allowing for a 2 hour increase in battery life when streaming Netflix. The new tab view, essentially designed to replace the existing bookmarks bar, allows users to see a bird's eye view of all open tabs and lets users to bunch tabs together. Smart suggestions, which display favorite sites directly under the search bar, also help to replace the bookmarks bar. 

As far as Privacy goes, users are now able to open a separate private window that does not affect existing windows or tabs, whereas previously, turning on privacy affected all open content. Safari includes 6.5x faster Javascript, with WebGL, SPDY, IndexedDB, Javascript Promises, CSS Shapes and more. 

OS X Yosemite is available today to registered developers and will be launched to the public this fall. There will also be an public open beta program launched later this summer. OS X Yosemite will be a free upgrade for all users. 



Posted by Andrew Tierney Friday, June 6, 2014 11:53:00 PM


By Miguel de Icaza

dotnet_logoIt has been an amazing day today. Not only did I have the opportunity to share the stage with the creator of C#, Anders Heljsberg, in the Microsoft Build 2014 day 2 keynote, but we also jointly announced with Microsoft the launch of the .NET Foundation, a newly created entity that will foster open innovation on .NET.

Xamarin contributed six projects to the foundation, and we are excited to be working with Microsoft as we take .NET in this new direction.

Miguel on stag with C# shirt

Microsoft contributed Roslyn to the Foundation, and on stage we demoed Roslyn working on a Mac with the iOS version of our new Xamarin Store App – a beautiful, native app that let’s C# lovers order their own limited edition C# t-shirt for free.  This demo was a great proof point for how open source will help get .NET everywhere.  We are very busy integrating the best bits of Roslyn into our technology stack.

Xamarin is contributing six projects to the .NET Foundation:

  • Xamarin Mobile: a library that exposes a single set of APIs for accessing common mobile device functionality across iOS, Android, and Windows platforms.
  • Xamarin.Auth: A cross-platform API for authenticating users and storing their accounts.
  • Couchbase for .NET: A lightweight, document-oriented (NoSQL), syncable database engine.
  • Xamarin’s System.Drawing:our cross-platform implementation of the familiar drawing API
  • MailKit and MimeKit: robust cross-platform email libraries optimized for mobile.

The .NET Foundation will help accelerate the adoption of .NET across every platform and computing form factor—servers, mobile devices and desktops, and we are very excited for Xamarin to be a part of it.

Check out the Build website to see the recordings of the Day 2 keynote. Tomorrow you should also be able to see a recording of my ”Go Mobile with Xamarin and C#” session.

Miguel and Anders on Stage at build

Posted by Andrew Tierney Friday, April 4, 2014 5:15:00 PM










We are excited to announce that we have just released our support for all of the new APIs introduced iOS 7.1, which Apple just released today. We have shipped same day support for iOS since iOS 5, enabling developers to add the latest features to their iOS apps immediately.

When you dive into the APIs of iOS 7.1 you will notice that there is new support for External Media Players, which introduces a few new classes such asMPPlayableContentManager to control interactions between your app and external media players. Additionally, you will find MPContentItem,MPRemoteCommand, and MPRemoteCommandEvent along with a few other classes to assist you in connecting to external media players. OpenGL ES has also been updated with added support for automatic multithreading by simply setting the IsMultiThreaded property to true after creating your EAGLContext.

You can browse our entire API change log and release notes to find out the latest features released today with Xamarin.iOS 7.2 and the new iOS 7.1 APIs. Also, be sure to update your version of XCode to 5.1 available from the App Store.

Posted by Andrew Tierney Tuesday, March 11, 2014 12:56:00 PM

New in Mono 3.2.8 

Mono 3.2.8 is a bug fix only release based on 3.2.7. This is a Linux-focused release.

  • On armhf, VFP scratch registers are now properly preserved across method calls.
  • A potential codegen bug on armhf for methods with lots of arguments has been fixed.
  • We now emit shorter floating point load/store sequences on armhf when possible.
  • Bugs surrounding alignment and mono_gc_bzero () / mono_gc_memmove () have been fixed.
  • A typo in the BigInteger.Cosh () implementation has been fixed.
  • Tuple<...> classes now implement ITuple and have a correct ITuple.ToString () implementation.
  • Bug #17589 has been fixed.
  • Bug #17558 has been fixed.
  • A stack alignment change that broke debugging on Android/x86 has been reverted (#17410).
  • Bug #17201 has been fixed.
  • The AOT compiler now adds types for method headers for gshared methods.
  • Bug #17632 has been fixed.
  • The DISABLE_JIT build has been fixed.
  • Bug #4510 has been fixed.
  • A potential crash in mono_method_desc_full_match () has been fixed.
  • Various build system fixes so that make dist works again.

New in Mono 3.2.7

New in 3.2.7

This is a major feature release that accumulates about 5 months of development


5 months of work, 1235 commits by 65 contributors.

Initial support for the hardfp ABI on ARM. This enables mono to be used on more recent versions of linux and produce better code on those targets.

The ABCREM optimization received a lot of love, now it works much better on 64bits systems.

Two new optimizations were added, a Loop Invariant Code Motion pass and Alias Analysis are now available. Performance in some functions can improve as much as 20%.

Hardware fences and atomic operations got a large revamp together with support for dynamic feature detection.

64bits CAS instructions are now supported on 32bits systems. This resulted in a significant performance boost on PLINQ workloads with multiple core.

Our LLVM integration got some love. It can now generate fast TLS access, a more recent LLVM version is been used and the list of optimizations we let it perform has been updated.

Our GC received some micro-optimization love by some small optimization in internal data structures and the use of intrinsics to speed up some core loops.

System.Core now has an interpreter for LINQ expressions and dynamic statements that can be used by FullAOT runtimes.

Better support for custom task schedulers.

Significantly improved reachability and flow analysis in C# compiler.


New features


  • [jit] Fix the handling of OP_ISUB_IMM in abcrem.
  • [jit] Improve ABCREM on 64-bits architectures
  • [jit] Implement the delegate ctor optimization in AOT mode too.
  • [jit] Some work towards a win64 port.
  • [jit] Use vectorized exception handling on windows.
  • [jit] Initial support for the hardfp ABI on ARM.
  • [jit] Add beginnings of a mach image writer for use with xdebug.
  • [jit] Implement proper TLS offset translation on mach based kernels.
  • [jit] Add a simple loop invariant loop motion pass for use with LLVM, which moves loop invariant instructions out of loop headers into the preceeding bblock.
  • [jit] Avoid linking the try block with the EH block as this produces spurious BBs during inlining.
  • [jit] The AggressiveInlining hint now triggers class initialization so more stuff gets force-inlined.
  • [jit] Add an alias analysis pass to the JIT.
  • [jit] ARM can dynamically switch between modes.
  • [jit] Atomics and hardware fences revamped and improved.
  • [jit] Add 64bits atomics on 32bits systems , this makes PLINQ significantly faster on multicore systems.
  • [llvm] Implement support for OP_TLS_GET_REG on osx/amd64.
  • [llvm] Update list of optimizations passed to 'opt'.
  • [runtime] Scalability work: reduce usage of the loader lock
  • [runtime] Removed the old debugger from the runtime.
  • [runtime] socket-io: make it possible to specify an interface index as a MulticastInterface SocketOption on linux.
  • [runtime] Don't expand variant generic interfaces on arrays.
  • [runtime] Implemented g_win32_getlocale function to return correct locale.
  • [runtime] Revamped hardware caps detection.
  • [runtime] Add LLDB support to mono_gdb_render_native_backtraces () on POSIX.
  • [runtime] Promote the reference queue API to the public.
  • [runtime] Provide more public API to inspect MonoTypes, MonoClasses and MonoMethodSignatures.
  • [runtime] Improving the retrieval of the user's locale on Apple systems.
  • [runtime] Async stack walking with AOT
  • [sdb] Allow users to specify a suspension policy when enabling an event
  • [sdb] Add async variants to the InvokeMethod methods.
  • [sdb] Support a setpgid=y/n option to --debugger-agent.
  • [sdb] Emit better debugger attribute for stepping over state machine initialization
  • [sgen] Reverse the free-list after sweeping to be in address-order.
  • [sgen] Only enqueue LOS objects if they contain references.
  • [sgen] Use gcc bitcount intrinsics where appropriate.

Class libraries

  • [corlib] Implementation of System.Reflection.ParameterInfo.HasDefaultValue
  • [corlib] Implemented System.Threading.Monitor.IsEntered
  • [corlib] LogicalSet/GetData implementation in CallContext
  • [corlib] Implement CultureInfo.DefaultThreadCurrentUICulture.
  • [corlib] Implement CultureInfo.DefaultThreadCurrentCulture.
  • [corlib] Add 'System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken' stub.
  • [Mono.Options] Improve error message for badly bundled args.
  • [pcl] Add new 'System.Runtime.InteropServices.WindowsRuntime' Facade Assembly.
  • [rx] Updated Rx to 2.2 release.
  • [System] Add IsIPv6Teredo to System.Net.IpAddress
  • [System] Add more of System.ComponentModel to MOBILE profile.
  • [System.Core] Update MonoTouch System.Linq.Expression to be 4.5 compatible
  • [System.Core] Add dynamic interpreter
  • [System.Core] Support IReadOnlyList in System.Linq.Enumerable.ElementAt and ElementAtOrDefault
  • [classlib] Introduce the mobile_static build.
  • [classlib] Add OrderedDictionary to the mobile profile.


  • [mcs] Suport recursive references of non-FX assemblies
  • [mcs] Implements definite assignment of expressions
  • [linker] Allow overriding MarkCustomAttribute and expose the MarkDefaultConstructor feature to subclasses
  • [xbuild] Initial MSBuild 12.0 support.
  • [xbuild] Improved xbuild diagnostics.
  • [xbuild] implement "skip target due to previous success" feature.
  • [xbuild] Add xbuild support for BuildManager
Posted by Andrew Tierney Thursday, February 20, 2014 11:32:00 PM

New in Mono 3.2.6 

Mono 3.2.6 is a hotfix release.

Bug fixes.

  • Add System.Runtime.InteropServices.WindowsRuntime APIs and PCL Facade
  • Fix problem in MSBuild handling of "Returns" in <Target>. This affects multiple Microsoft.Bcl.Build NuGet packages
  • Implement task batching in MSBuild. Fixes BXC #16403
  • Add /Libraries to llvm search path on OSX, this makes --llvm work in more cases

Also Mono 3.2.5 is a hotfix release.

Bug fixes:

  • Miscompilation of PCL projects referencing System.Net.Http
  • Improper stack size detection on Mavericks lead F# and C# compilers to crash.
  • Includes the latest F# release, 3.0.31.
Posted by Andrew Tierney Tuesday, January 21, 2014 7:22:00 PM

A sneak peak at 2014..!!! 

CastleSoft Studios

More to come very very soon...

Posted by Andrew Tierney Wednesday, January 15, 2014 8:20:00 PM

New in Mono 3.2.4 

This is a bug fixing only release.

Fix some packaging issues.

Fix System.IO.Compression.CompressionLevel enum.

Include namespace-level summary and remarks elements [#14672]

Multiple fixes to the PCL Facade assemblies.

Click Here for the download page.

Posted by Andrew Tierney Friday, November 15, 2013 1:18:00 PM

Microsoft and Xamarin Partner Globally 

Microsoft and Xamarin Partner Globally to Enable Microsoft Developers to
Develop Native iOS and Android Apps With C# and Visual Studio

Companies Join Forces on Technical and Customer Programs to Help
Developers Build Native Mobile Apps for Multiple Platforms

SAN FRANCISCO - November 13, 2013 — Xamarin, the company that empowers developers to build fully native apps for iOS, Android, Windows and Mac from a single shared code base, today announced a global collaboration with Microsoft that makes it easy for mobile developers to build native mobile apps for all major platforms in Visual Studio. Xamarin is the only solution that unifies native iOS, Android and Windows app development in Visual Studio—bridging one of the largest developer bases in the world to the most successful mobile device platforms.

A highly competitive app marketplace and the consumerization of IT have put tremendous pressure on developers to deliver high quality mobile user experiences for both consumers and employees. A small bug or crash can lead to permanent app abandonment or poor reviews. Device fragmentation, with hundreds of devices on the market for iOS and Android alone, multiplies testing efforts resulting in a time-consuming and costly development process. This is further complicated by faster release cycles for mobile, necessitating more stringent and efficient regression testing.

The collaboration spans three areas:

  • A technical collaboration to better integrate Xamarin technology with Microsoft developer tools and services.
    Aligned with this goal, Xamarin is a SimShip partner for Visual Studio 2013, releasing same-day support for Microsoft’s latest Visual Studio release that launched today. In addition, Xamarin has released today full integration for Microsoft’s Portable Library projects in iOS and Android apps, making it easier than ever for developers to share code across devices.
  • Xamarin’s recently launched Xamarin University is now free to MSDN subscribers. The training course helps developers become successful with native iOS and Android development over the course of 30 days. Classes for the $1,995 program kick off in January 2014, with a limited number of seats available at no cost for MSDN subscribers.
  • MSDN subscribers have exclusive trial and pricing options to Xamarin subscriptions for individuals and teams.


The broad collaboration between Microsoft and Xamarin which we announced today is targeted at supporting developers interested in extending their applications across multiple devices, said S. Somasegar, Corporate Vice President, Microsoft Corporation. With Xamarin, developers combine all of the productivity benefits of C#, Visual Studio 2013 and Windows Azure with the flexibility to quickly build for multiple device targets.

According to Gartner, by 2016, 70 percent of the mobile workforce will have a smartphone, half of which will be purchased by the employee, and 90 percent of enterprises will have two or more platforms to support. Faced with high expectations for mobile user experiences and the pressures of BYOD, companies and developers alike are looking for scalable ways to migrate business practices and customer interactions to high-performance, native apps on multiple platforms.

To meet this need to support heterogeneous mobile environments, Microsoft and Xamarin are making it easy for developers to mobilize their existing skills and code. By standardizing mobile app development with Xamarin and C#, developers are able to share on average 75 percent of their source code across device platforms, while still delivering fully native apps. Xamarin supports 100 percent of both iOS and Android APIs—anything that can be done in Objective-C or Java can be done in C# with Xamarin.

In just two years, Xamarin has amassed a community of over 440,000 developers in 70 countries, more than 20,000 paying accounts and a network of over 120 consulting partners globally.

We live in a multi-platform world, and by embracing Xamarin, Microsoft is enabling its developer community to thrive as mobile developers, said Nat Friedman, CEO and cofounder, Xamarin. Our collaboration with Microsoft will accelerate enterprise mobility for millions of developers.

The groundbreaking partnership was announced as part of the Visual Studio Live 2013 launch event in New York City. In addition, Xamarin and Microsoft have teamed up with the popular podcast, .NET Rocks!, for a 20-city nationwide road show featuring live demos on how to use Visual Studio 2013, Xamarin and Windows Azure to build and scale mobile apps for iOS, Android and Windows. For a full list of cities and to sign up for an event, please visit:

About Xamarin
Xamarin is the new standard for enterprise mobile development. No other platform enables businesses to reach all major devices—iOS, Android, Mac and Windows—with 100 percent fully native apps from a single code base. With Xamarin, businesses standardize mobile app development in C#, share on average 75 percent source code across platforms, and leverage their existing skills, teams, tools and code to rapidly deliver great apps with broad reach. Xamarin is used by over 430,000 developers from more than 100 Fortune 500 companies and over 20,000 paying customers including Clear Channel, Bosch, McKesson, Halliburton, Cognizant, GitHub, Rdio and WebMD, to accelerate the creation of mission-critical consumer and enterprise apps. For more information, please visit:, read our blog, and follow us on Twitter @xamarinhq

Posted by Andrew Tierney Thursday, November 14, 2013 8:44:00 AM

Mono 3.2.3 

OSX, OpenSuSe and Windows released


This release features over 2 months of fixes a few nice features.

We're now back to do simultaneous releases to Windows, Linux and Mac.

The C# compiler has a lot of fixes for async related issues.

New static and dynamic hardware capabilities probing, mono can now exploit hardware caps in many more cases than before.

Blended v5/v7 mode for arm. Some ARM targets require binaries that support all the way from very old CPUs to the most modern ones. Previously we would fail to work on SMP machines when built for UP targets.

Added skeletons for both System.DirectoryServices and System.Windows.Forms.DataVisualization.Charting.

New server focused flag. Run mono with --server to tell the runtime to target performance. With this release, this means an aggressive threadpool scheduler that creates additional threads faster.

We put a lot of effort on windows for this release. Builds are now based on a recent mingw toolchain. We fixes a good number of build issues and bugs in the windows backed.

We have finally switched to use vectored exception handling on windows, which makes it possible, for those of us that like Inception, to debug mono's debugger.

And, finally, PCL has arrived. This means a few fixes in the runtime, class libraries and build tools. And, on Mac, we now ship PCL reference assemblies.


  • 1782 - Check generic constraints for duplicates.
  • 4141 - XmlSchemaImporter needs to consider attributeGroupRef in some case.
  • 4344 - xsl:stylesheet always ignored xsl template contents.
  • 4668 - C# compiler doesn't like decimal in custom attribute values, so use string.
  • 6327 - Correctly install xbuild
  • 7126 - Don't allow execution of dynamic assemblies without run access.
  • 8637 - omit xml declaration for ToString().
  • 8719 - Implements parsing of multi value User-Agent string.
  • 8934 - Add more implicit generic array interfaces.
  • 10001 - Do not use chunked encoding with CGI/FastCGI.
  • 10194 - SetElementValue(nonExistentElementName, null) caused NRE.
  • 11294 - Add more system assemblies remapping.
  • 11778 - Fix Syscall.readlink() for non-ascii targets.
  • 11910 - Implement character validation methods in XmlConvert.
  • 12035 - xsi:nil='true' was ignored in some scenario.
  • 12469 - Add more conversion methods to XmlAtomicValue.
  • 12995 - Avoid an assert in mono_save_seq_point_info () if no seq points are generated for a method.
  • 13050 - Properly null terminate strings in mono_dwarf_escape_path ().
  • 13065 - Continue single stepping if the same line reached in all cases. Factor out some code code.
  • 13191 - Avoid passing partially shared instances to the JIT.
  • 13233 - Fix an overflow if MONO_ZERO_LEN_ARRAY is not 0.
  • 13289 - Nested partial type inside generic class can have base type defined later than current type inflation happens.
  • 13316 - Add nested partial types inside nested partial types to AST.
  • 13318 - Schedule internal delay task on default scheduler only.
  • 13324 - Lazy initialization of type parameters expanded interfaces.
  • 13336 - Handle property with default values.
  • 13340 - Another attempt at fixing mono_atomic_load_acquire() on MSVC.
  • 13343 - Support FTP download where PWD starts with '\'.
  • 13362 - Adds async handling to binary:emitbranchable.
  • 13435 - Add some error checking to custom attr parsing and plug a memory leak.
  • 13443 - Add clone for error expression.
  • 13454 - Lift result of enum substraction when operation is lifted due to non-nullable enum type.
  • 13466 - Add *CachePolicy to mobile profile.
  • 13476 - Ignore space separators in nowarn arguments.
  • 13488 - Add AssemblyAction.Save to the linker.
  • 13497 - Check promoted value type binary equality operations against null too.
  • 13501 - Correctly parse pragma headers.
  • 13509 - Remove CultureInfo.CurrentCulture dependency from ordinal based string::EndsWith.
  • 13523 - Write only import section from global namespaces before global attribute sections.
  • 13544 - Fix overflow checking in newarray with 64 bit array lengths.
  • 13549 - Correctly import nested non-generic types inside generic containers used within same generic container.
  • 13552 - Grow underlying buffer only when necessary.
  • 13603 - Quote path arguments to opt/llc.
  • 13604 - STW handshake/thread shutdown race condition.
  • 13626 - Rewrites RuntimeReflectionExtensions to actually do something.
  • 13682 - Don't show internal error when default paramater expression cannot be converted to paramter type.
  • 13708 - ASP.NET routing constraints should be treated as 'convertible to string'
  • 13716 - use XmlSchemaSettings.XmlResolver to resolve schemas.
  • 13729 - Fix cross compilation to windows. "Windows.h" should be "windows.h".
  • 13731 - Handle partial class case when nested type of partial container depends on parent base type from another partial container.
  • 13734 - Disable LLVM for async methods.
  • 13736 - Create correct flow branching for single non-default switch section.
  • 13742 - Always release DeflateStream unmanaged resources.
  • 13767 - Handle custom attributes with nested array of enums.
  • 13786 - Update named params parameter converted result expression.
  • 13793 - Inflate default parameter expression without type checks
  • 13813 - Thread teardown race condition.
  • 13817 - Basic optional parameters support in binder.
  • 13879 - Verifier support for IReadOnlyList<T> and IReadOnlyCollection<T>.
  • 13890 - Relax the restriction on global methods visibility.
  • 13892 - Add argument modifiers to generated base proxy when needed.
  • 13951 - Avoid lookups in the AOT images during STW.
  • 13952 - Don't crash when reporting invalid case label value.
  • 13953 - Support OID names in RSACryptoServiceProvider.SignData().
  • 13969 - Fix recursive check for non dependent return types during type inference.
  • 13970 - Correct parsing of invalid 00000000-0000-0000-0000-000000000000 guid format.
  • 13977 - Use the invariant culture calendar if the requested one is not available.
  • 13996 - Type parameter inflated interfaces needs to be marked too.
  • 14032 - Fixes GZipStream dispose order.
  • 14053 - Report error for name collision between property and generic method.
  • 14069 - Avoid the managed->copy for ref vtypes with an [In] attribute in n2m wrappers.
  • 14077 - HashSet no longer grows in capacity on deserialize
  • 14126 - Bad compiler interaction between anonymous method and async
  • 14143 - xsl:import in included stylesheet caused compilation error.
  • 14168 - Use IReflectType interface instead of TypeDelegator.
  • 14185 - Fixes negative symbol definition for few locales to be simple -.
  • 14194 - Fix yet another DISABLE_JIT bug in wrapper generation.
  • 14217 - Fix an LLVM assertion on structs with unaligned size.
  • 14245 - Invalid syntax during attribute target parsing can crash parser.
  • 14289 - Probing of generic parameter needs to check both operands.
  • 14339 - Clear out the ref fields from MonoDomain before calling mono_gc_clear_domain.
  • 14347 - More thorough check for managed type parameters.
  • 14351 - Bad compiler interaction between captured this, lambdas and async.
  • 14384 - Don't resolve extension method expression when in probing mode.
  • 14426 - Perform alignment checks for CAS on 32bits systems.
  • 14503 - Add support for invoking interface methods.
  • 14505 - Set empty string to TraceListeners for empty assert message.
  • 14515 - Fixes parallel enumerable index counter.
  • 14544 - Add System.ServiceModel.Activation assembly.
  • 14555 - Make suspend work during thread cleanup.

New in Mono 3.2.2


This is a bugfix release.

Some edge cases in our garbage collector that were found in internal testing are now fixed. Multiple C# compiler issues fixed.


  • TPL- Fix scheduling of non-inlined synchronous continuations.
  • Weaken a race condition in object initialization
  • Fix race conditions in finalizer/weak link staging
  • Fixed System.Text.Decoder.GetChars(byte*,int,char*,int,bool) to copy output into the char* buffer
  • Fixed to fail the __thread check with clang
  • Fixed g_utf8_to_utf16_general() to handle invalid utf8
  • 8934 Add more implicit generic array interfaces.
  • 13050 Properly null terminate strings in mono_dwarf_escape_path ().
  • 13191 Avoid passing partially shared instances to the JIT.
  • 13362 Adds async handling to binary:emitbranchable.
  • 13443 Add clone for error expression.
  • 13454 Lift result of enum substraction when operation is lifted due to non-nullable enum type.
  • 13466 Add *CachePolicy to mobile profile.
  • 13476 Ignore space separators in nowarn arguments.
  • 13497 Check promoted value type binary equality operations against null too.
  • 13509 Remove CultureInfo.CurrentCulture dependency from ordinal based string::EndsWith.
  • 13603 Quote path arguments to opt/llc.
  • 13604 STW handshake/thread shutdown race condition.
  • 13734 Disable LLVM for async methods to work around.
  • 13951 Register the jit info for GC critical methods as soon as they are loaded
  • 13952 Don't crash when reporting invalid case label value.


New in Mono 3.2.1

Mono 3.2.1 is a hot-fix release.

It fixes bug 13509, which causes a crash when the current culture is set to zh_TW.

New in Mono 3.2.0

Major Highlights


LLVM updated to version 3.2, this brings better optimizations for mono.

Garbage Collector

Mono now defaults to the SGen Garbage Collector.

A lot of work went into making this the best performing and most stable release of our collector.

As part of making it broadly usable, two problematic workloads were addressed and make much faster.

One is the popular object workload, where a few pinned nursery objects are very popular with old generation objects, causing a lot of remembered sets to be created. To avoid that, popular objects are made immortal until the next major collection.

The other is the massive thread stacks workload, where a lot of threads with big stacks need to be conservatively scanned. This used to put a lot of pressure on the pinning stage since it would produce very big pin queues. To avoid that, we employ hash filtering on pin queues and that dramatically reduce their average size and we pin major blocks instead of individual objects.

In addition to that, we switched to lazy sweeping by default, which reduces major collection pause times and improves aggregate throughput.

Three new experimental modes for the garbage collection are now available.

Low pause mode

Under the low pause mode, SGen will execute major collections concurrently to your application and only briefly pause to finish it. To enable it pass major=marksweep-conc in the MONO_GC_PARAM environment variable.

Low promotion nursery

The low promotion nursery employs aging to reduce temporal effects on object promotion and reduce the pressure on the major heap. To enable it pass minor=split in the MONO_GC_PARAM environment variable.

Mostly precise stack scanning

Now it's possible to enable mostly precise stack scanning, that can speed up collections by reducing the volume of conservative scanning needed. This reduces pinning, leading to shorter minor collection pause times and increased space usage of the nursery.


Mono 3.2 Basic Class Libraries now can fully build Xamarin's mobile profile.

Size Reduction

Multiple features can now be disabled for the classlibs to reduce the footprint on mobile devices. FullAOT targets now enjoy much better fallbacks and much more linker friendly code.


The FullAOT compiler can now generate much faster code for icalls and has support for generic valuetype sharing, ending issues with missing methods at runtime once and for all.


Performance of primitive parsing was greatly enhanced.

LINQ is now much faster with arrays.

Large object cloning and boxing is up to two times faster.

Optimize Marshal.Read/Write methods to avoid a trip to unmanaged when possible.

Other platforms

Google contributed ports of NaCl for ARM and Amd64. SGen now works on FreeBSD.

Posted by Andrew Tierney Monday, October 7, 2013 4:45:00 PM
Page 1 of 3 1 2 3 > >>