The last couple of years have been good to C# and .NET, in
particular in the mobile space.

While we started just with a runtime and some basic
bindings to Android and iOS back in 2009, we have now grown to
provide a comprehensive development stack: from the runtime,
to complete access to native APIs, to designers and IDEs and
to a process to continuously deliver polish to our users.

Our solution is based on a blend of C# and .NET as well as
bindings to the native platform, giving users a spectrum of
tools they can use to easily target multiple platforms without
sacrificing quality or performance.

As the industry matured, our users found themselves solving
the same kinds of problems over and over. In particular,
many problems related to targeting multiple platforms at once
(Android, iOS, Mac, WinPhone, WinRT and Windows).

By the end of last year we had identified five areas where
we could provide solutions for our users. We could deliver a
common framework for developers, and our users could focus on
the problem they are trying to solve.

These are the five themes that we identified.

Cross-platform UI programming.

2D gaming/retained graphics.

2D direct rendering graphics.

Offline storage, ideally using SQLite.

Data synchronization.

Almost a year later, we have now delivered four out of the
five pillars.

Each one of those pillars is delivered as a NuGet package
for all of the target platforms. Additionally, they are
Portable Class Libraries, which allows developers to create
their
own Portable
Class Libraries on top of these frameworks.

Cross Platform UI programming

With Xamarin 3.0 we
introduced Xamarin.Forms,
which is a cross-platform UI toolkit that allows developers to
use a single API to target Android, iOS and WinPhone.

Added bonus: you can host Xamarin.Forms inside an existing
native Android, iOS or WinPhone app, or you can extend a
Xamarin.Forms app with native Android, iOS or WinPhone APIs.

So you do not have to take sides on the debate over 100%
native vs 100% cross-platform.

Many developers also want to use HTML and Javascript for
parts of their application, but they do not want to do
everything manually. So we also launched support for the
Razor
view engine in our products.

2D Gaming/Retained Graphics

Gaming and 2D visualizations are an important part of
applications that are being built on mobile platforms.

We productized the Cocos2D API for C#. While it is a great
library for building 2D games -and many developers build their
entire experiences entirely with this API- we have also
extended
it to allow developers to spice up an existing native
application.

Offline Storage

While originally our goal was to bring Mono's System.Data
across multiple platforms (and we might still bring this as
well), Microsoft released a cross-platform SQLite binding with
the same requirements that we
had: NuGet
and PCL.

While Microsoft was focused on the Windows platforms, they
open sourced the
effort, and we contributed the Android and iOS ports.

This is what powers Azure's offline/sync APIs for C#.

In the meantime, there are a couple of other efforts that
have also gained traction: Eric
Sink's SQLite.Raw
and Frank
Krueger's sqlite-net
which provides a higher-level ORM interface.

All three SQLite libraries provide NuGet/PCL interfaces.

Data Synchronization

There is no question that developers love Couchbase. A
lightweight NoSQL database that supports data synchronization
via Sync gateways and Couchbase servers.

While Couchbase used to offer native Android and iOS APIs
and you could use those, the APIs were different, since each
API was modeled/designed for each platform.

Instead of writing an abstraction to isolate those APIs
(which would have been just too hard), we decided to port the
Java implementation entirely to C#.

Since we did the initial work to bootstrap the effort,
Couchbase has taken over the maintenance and future
development duties of the library and they are now keeping it
up-to-date.

While this is not yet a PCL/NuGet, work is in progress to
make this happen.

Work in Progress: 2D Direct Rendering

Developers want to have access to a rich API to draw.
Sometimes used to build custom controls, sometimes used to
draw charts or to build entire applications based on 2D
rendered API.

We are working on bringing the System.Drawing API to all of
the mobile platforms. We have completed an implementation of
System.Drawing for iOS using CoreGraphics, and we are now
working on both an Android and WinPhone implementations.

Once we complete this work, you can expect System.Drawing
to be available across the board as a NuGet/PCL library.

If you can not wait, you can get your hands today on the
Mac/iOS version
from Mono's
repository.

Next Steps

We are now working with our users to improve these APIs.
But we wont stop at the API work, we are also adding IDE
support to both Xamarin Studio and Visual Studio.