Disclaimer: this is an automatic aggregator which pulls feeds and comments from many blogs of contributors that have contributed to the Mono project. The contents of these blog entries do not necessarily reflect Xamarin's position.

October 20

Xamarin.Forms Book Preview Edition Available Now

The Petzold engine has been churning through the Xamarin.Forms API, and we’re pleased to announce that the first preview edition of Creating Mobile Apps with Xamarin.Forms is now available. It was distributed in print to all Xamarin Evolve 2014 attendees last week and is now available as a free download in a number of formats:


The six chapters available in the preview edition cover the history of Xamarin.Forms, solution structure, the basics of the view system and building your first Xamarin.Forms app. The extensive samples are also available for download from GitHub.

Charles also presented two talks at Evolve: XAML for Xamarin.Forms and Xamarin.Forms is Cooler Than You Think, both of which will be available shortly as videos of the sessions are published at evolve.xamarin.com.


Work continues on both Xamarin.Forms and the book!

Traktor Pro .tsi file format reverse-engineered – docs on GitHub

I’ve reverse-engineered the .tsi binary file format specification, which Traktor Pro by Native Instruments uses to store its Controller Mappings. I am hoping this should open the gates to new power tooling for MIDI controller mapping power tools (Traktor’s own being rather sub-optimal).

The project, documentation and instructions are here: https://github.com/ivanz/TraktorMappingFileFormat/wiki

Can’t sing enough praises of 010 Editor by SweetScape which enabled me to write scripts and define data structures incrementally on top of a binary blob.


October 16

The Wait Is Over: MimeKit and MailKit Reach 1.0

After about a year in the making for MimeKit and nearly 8 months for MailKit, they've finally reached 1.0 status.

I started really working on MimeKit about a year ago wanting to give the .NET community a top-notch MIME parser that could handle anything the real world could throw at it. I wanted it to run on any platform that can run .NET (including mobile) and do it with remarkable speed and grace. I wanted to make it such that re-serializing the message would be a byte-for-byte copy of the original so that no data would ever be lost. This was also very important for my last goal, which was to support S/MIME and PGP out of the box.

All of these goals for MimeKit have been reached (partly thanks to the BouncyCastle project for the crypto support).

At the start of December last year, I began working on MailKit to aid in the adoption of MimeKit. It became clear that without a way to inter-operate with the various types of mail servers, .NET developers would be unlikely to adopt it.

I started off implementing an SmtpClient with support for SASL authentication, STARTTLS, and PIPELINING support.

Soon after, I began working on a Pop3Client that was designed such that I could use MimeKit to parse messages on the fly, directly from the socket, without needing to read the message data line-by-line looking for a ".\r\n" sequence, concatenating the lines into a massive memory buffer before I could start to parse the message. This fact, combined with the fact that MimeKit's message parser is orders of magnitude faster than any other .NET parser I could find, makes MailKit the fastest POP3 library the world has ever seen.

After a month or so of avoiding the inevitable, I finally began working on an ImapClient which took me roughly two weeks to produce the initial prototype (compared to a single weekend for each of the other protocols). After many months of implementing dozens of the more widely used IMAP4 extensions (including the GMail extensions) and tweaking the APIs (along with bug fixing) thanks to feedback from some of the early adopters, I believe that it is finally complete enough to call 1.0.

In July, at the request of someone involved with a number of the IETF email-related specifications, I also implemented support for the new Internationalized Email standards, making MimeKit and MailKit the first - and only - .NET email libraries to support these standards.

If you want to do anything at all related to email in .NET, take a look at MimeKit and MailKit. I guarantee that you will not be disappointed.

Xamarin Evolve 2014 Re-Cap and Videos

We had an incredible time at Xamarin Evolve 2014, and we hope that you did too!  It was amazing to have 1,200 mobile developers all in one place to learn and celebrate mobile development.  And we hope that those of you who joined from 99 countries to watch the live stream found the sessions educational and inspiring.

Miguel de Icaza on stage during the Xamarin Evolve 2014 Keynote

If you missed the Keynote, or if you just want to re-live the excitement of the incredible announcements made there, the Evolve 2014 Keynote video is now available.

Watch Evolve 2014 Keynote

The Big Announcements

Our mission is to make it fast, easy and fun to deliver incredible mobile apps, and with these Xamarin Evolve 2014 announcements, we are bringing to you the world’s best solution to build, test and monitor your mobile apps:

  • Xamarin Insights: In the Keynote, we announced the release of Xamarin Insights, a real-time monitoring service that helps
  • Xamarin CEO Nat Friedman on stage during the Xamarin Evolve 2014 Keynoteyou improve your apps by tracking crashes and exceptions, and by providing insights into what is happening with your live users.

  • Xamarin Platform Previews: We announced 3 very exciting platform previews that we are making available immediately.
    • Xamarin Android Player: We tackled the single greatest pain point in Android development - the outdated, clunky, slow experience provided by the standard Android emulator. Our new Xamarin Android Player gives your apps the shortest startup time and best possible performance through hardware-virtualization and hardware-accelerated graphics.
    • Xamarin CTO Miguel de Icaza on stage at the Xamarin Evolve 2014 Keynote

    • Sketches: Sketches is a lightweight environment to explore the immediate effects of the code you write. Sketches are ideal to learn new APIs, prototype ideas, and quickly iterate on designs. When you are happy with your code in a Sketch, you can easily copy it into your app. You can also take snippets from your open solution and study them in this isolated live coding environment, making Sketches an incredibly powerful tool for debugging.
    • Profiler: The Xamarin Profiler helps you dissect, analyze, and polish your C# mobile applications. The profiler collects information about the managed side of your Xamarin iOS and Android applications and helps you to figure out where to spend the most time making improvements. You can use it to find memory leaks, resolve performance bottlenecks, and add polish to your applications before getting them out the door.

    Xamarin CEO Nat Friedman on stage at Xamarin Evolve 2014

  • Xamarin Test Cloud Updates: We announced some exciting new features for Xamarin Test Cloud:
    • Xamarin.UITest: Our new automated UI testing framework that harnesses the power of the C# language to create beautiful, readable, first-class test code with all the power of the .NET framework.
    • Improved Capture Tools: Screen recording in Xamarin Test Cloud enables developers to see video playback of an app running through its test cases, capturing the full testing flow, including animations.
    • Test Execution Enhancements: One of the most exciting announcements for Xamarin Test Cloud is hyper-parallel test execution. Currently, when you submit a test run to 10 unique devices, those tests happen at the same time across the devices, but the individual tests run one after the other. Hyper-parallel test execution takes this to the next level by splitting a test suite into chunks and executing the chunks in parallel on equivalent devices. We have seen this drop execution time from around 2.5 hours to just 12 minutes for our own tests.
  • IBM and Xamarin Partnership: Enterprise apps must have a consumer-grade front-end, an enterprise-grade back-end, and a comprehensive mobile software development lifecycle. In order to support the developers in our community building enterprise apps, we’ve partnered with IBM on two initial integrations, available now:
    • IBM MobileFirst SDK for Xamarin: pre-built software library that Xamarin and IBM developers can embed in their mobile apps to connect, secure and manage the apps using IBM Worklight, a part of the IBM MobileFirst portfolio.
    • IBM MobileFirst Add-Ons for Xamarin Studio and Visual Studio: Extensions that enable developers to configure and access the IBM Worklight server from a single environment.
  • Xamarin.Forms Components Ecosystem: Six major .NET component vendors have transformed over 140 existing charts, graphs, gauges, and grids into Xamarin.Forms-compatible, cross-platform mobile controls. Our component vendor partners have created beautiful UI controls that enable mobile developers to create native user experiences that meet the increasing demands of mobile enterprise apps, while saving countless hours developing these views for multiple platforms.

The rest of the conference session videos will be rolled out over the next few weeks, so stay tuned for more great Xamarin Evolve 2014 content!

October 15

The student and the Asset Store extension

Not every publisher sets out with a clear plan to make an Asset Store product. If you have a half-finished extension lying around, or some code or models you think others could benefit from using, consider doing what Copenhagen student Lasse Knudsen did: Polish and publish to the Asset Store.

Programmer Lasse first became familiar with Unity four years ago as part of his Mediaology studies at Aalborg University. “It was the standard game engine they used out there, and, of course, back then, there wasn’t an Asset Store.”

Later, after transferring to IT University of Copenhagen, Lasse wanted to write a pathfinding extension for his own use, and just to challenge himself generally. At the time, Navmesh was a Unity Pro feature, and Lasse wanted the functionality for a commercial project (meaning he couldn’t take advantage of Unity’s discounted educational licenses). So he set out to write his own pathfinding system, initially just as a coursework project.

“It worked pretty well, but I wasn’t really satisfied. So, after the course, I extended it to make it better, and I got it to a state where I was actually pretty happy with it. So I thought: ‘Hey, maybe other people will like it too.’”

And so the Simply A* pathfinding Asset Store tool was born. Lasse’s original plan was to make the extension available free of charge, but, by this time he’d invested a lot of time and effort in it. So, he decided to charge a small amount. A week after it was submitted to the Asset Store, Simply A* was on sale.

“I didn’t really expect people to buy it, but they started to very quickly. What with support requests and added functionalities I suddenly found myself pretty busy. Soon I was making so much money that I didn’t need to take a job to support my studies.”

Fast forward to the present, and Lasse’s working on two games: Gunjitsu which he and five student colleagues are aiming to publish as an early access Steam release in December, and some contract work for a retail client. Plus, he still has his studies to keep him busy.

“Now I’m busy with school and other game projects, so a month ago I made Simply A* available free of charge, with a reduced commitment to support it. The source code is there, so, obviously, people can fix things themselves if they want to.”

“It was a great way to improve my skills, do something I liked and make money. It helped me when it came to making editor extensions for my own use, and it helped me understand other assets on the Asset Store. That’s important because I use a lot of assets!”

October 14

.NET Foundation: Forums and Advisory Council

Today, I want to share some news from the .NET Foundation.

Forums: We are launching the official .NET Foundation forums to engage with the larger .NET community and to start the flow of ideas on the future of .NET, the community of users of .NET, and the community of contributors to the .NET ecosystem.

Please join us at forums.dotnetfoundation.org. We are using the powerful Discourse platform. Come join us!

Advisory Council: We want to make the .NET Foundation open and transparent. To achieve that goal, we decided to create an advisory council. But we need your help in shaping the advisory council: its role, its reach, its obligations and its influence on the foundation itself.

To bootstrap the discussion, we have a baseline proposal that was contributed by Shaun Walker. We want to invite the larger .NET community to a conversation about this proposal and help us shape the advisory council.

Check out the Call for Public Comments which has a link to the baseline proposal and come join the discussion at the .NET Forums.

First Unity game in WebGL: Owlchemy Labs’ conversion of Aaaaa! to asm.js

Starting today, Aaaaa! for the Awesome is the first commercially available Unity WebGL game! It’s been a long ride for Unity WebGL tools and Owlchemy Labs have been along for a fairly sizable chunk of it. You can get the fruits of their collaboration with Dejobaan Games along with other exciting new WebGL games in the Humble Mozilla Bundle.

“Working with super early versions of the Unity WebGL exporter was a surprisingly smooth experience overall!,” writes Alex Schwartz, the CEO of Owlchemy Labs, on the Mozilla blog.

“Jonas Echterhoff, Ralph Hauwert and the rest of the team over at Unity did such an incredible job getting the core engine running with asm.js and playing Unity content in the browser at incredible speeds, it’s pretty staggering. When you look at the scope of the problem and what technical magic was needed to go all the way from C# scripting down to the final 1-million-plus-line js file, it’s mind boggling”.

But getting the game to compile in this new build target wasn’t as easy as hitting the big WebGL export button and sitting back. While Unity did they care of a lot of the heavy lifting under the hood, there were some significant challenges that we worked together with Owlchemy to overcome.

The porting process began in June 2014  when Owlchemy gained access to the WIP WebGL exporter available to the alpha group. Was a complex game like Aaaaa! for the Awesome going to be portable within the limited time frame and using such an early framework?

“After two days of mucking about with the exporter, we knew it would be doable (and had content actually running in-browser!) but as with all tech endeavors like this, we were walking in blind as to the scope of the entire port that was ahead of us. Would we hit one or two bugs? Hundreds? Could it be completed in the short timespan we were given? Thankfully we made it out alive and dozens of bug reports and fixes later, we have a working game!”

Thanks to all those bug reports, developers using the current and future version of the tools will get all of these fixes built in from the start and can benefit from a better pipeline from Unity to WebGL.

Alex sees the web as a very good place for ambitious Unity projects. “You can expect Owlchemy Labs to bring more of their games to the web in the near future, so keep an eye out for those! ;) With our content running at almost the same speed as native desktop builds, we definitely have a revolution on our hands when it comes to portability of content, empowering game developers with another outlet for their creative content, which is always a good thing.”

More than two years have passed since the initial WebGL experiments at our HackWeek in Copenhagen. We’re extremely happy about the journey so far, the collaboration with our alpha and beta groups and our partners including Mozilla. We’re having loads of fun playing Aaaaa! for the Awesome and everybody’s looking forward to other upcoming Unity WebGL games. But we absolutely can’t wait to see what you all make with our Unity WebGL tools once Unity 5 is out!

October 13

Ada Lovelace Day 2014

Today is Ada Lovelace day, a special occasion to recognize women in our community. I want to take this opportunity to also highlight someone exceptional I have known for a while.

Her name is Andrea Magnorsky.

Andrea Magnorsky

Andrea is an Irish .NET programmer. She’s currently following one of her passion – game development – and is closing production with her studio Digital Furnace (ex-BatCat) on their next title Onikira.

To say that Andrea is a community person is an understatement. In the span of a few years she has not only created popular event/group like Global Gamecraft (game jam contest) or Dublin ALT.NET but she is also continously looking for new ways to teach people through numerous talks and meetups like Functional Kats.

She is curious of everything and always avid to learn. These days you can see her sailing along with F# and functional programming for instance.

It’s no surprise that she was recognized several times in Ireland as a top person in her field. Microsoft also recently awarded her an MVP award.

It’s thanks to people like Andrea that I’m happy to be part of the community that is software development.


Muncho would have loved to conclude this but he had another emergency

The Players Journey

We all want to be heroes (or villains). To be the leading character in our own stories is an important aspect of playing the games we love, even if the story is abstract or apparently absent there is an inherent power in the sense of competence, esteem and autonomy we gain from play.

Most of the best games designers I know think this a lot although there are some inherent. For a start are we really playing the hero or in fact the side-kick. In Destiny we spend a lot of time waiting for our Ghost to do something obscure we don’t quite understand whilst we are fending off hordes of Vex or some such. Are we really the heroes?

More than that we usually lack some important knowledge that our hero should by rights already know. Then there is the trouble with choice; something The Stanley Parable explores brilliantly, what if we don’t want to do something the plot requires us to do? However. I’m not looking to restart the debate of Ludo-narrative dissonance. Instead I want us to consider something else.

Players are not the heroes of the game. Not just because of the issues I’ve mentioned already but because of something more obvious. They are real people. That means they have lives and they can’t spend every waking moment playing your game.

When we design a game, especially now in this Games-As-A-Service age, we can’t just invest in the story arch for the hero, or whatever abstract purpose our game has. We have to take into account the Player Journey too.

Campbell’s Heroes Journey is a well-trodden path and I’m going to help illustrate The Players Journey, of course it’s not the only Storytelling form, but it’s still quite a useful one. I’m also going to take a few very slight liberties with the specific stages, but all within the principles of the original.

  1. The Ordinary World – Players often already have games they are playing, and even if they are between games they are being bombarded on all sides with messages. Why should they play your game?
  2. The Call To Adventure – Discovery is not a passive act. You have to create the conditions for players to find and desire your within your design through art, narrative, social interactions as well as through the other media and of course partners including the platform holders.
  3. The Refusal of the Call – don’t assume downloading a game means it will be played. The reality of a game before we learn the controls is always poorer than our imagination. Get your players playing fast and feeling good about their competence fast. Additionally, we have to consider the physical devices and the moments in time they choose to play this game. Are they interruptible? How much time can they spare? What is their mode of use? This is particularly noticeable on mobile where Games with a shorter incidence of play seem to attract more frequent play, even if playing sessions end up longer.
  4. The Threshold – After the first play we need to think about why our players would want to come back and play again, and again. We want to create a sense of anticipation for their return to play. We can afford to be generous after all we want them to learn the value of continuing to play and if this is a free2play game to create a desire to spend money later.
  5. The Belly Of The Whale – There always comes a point where players fail, but this is a necessary step for us to be able to commit to playing, otherwise where is the challenge? How does your game make me want to get back up and play again? Longevity in games is linked to an innate sense of ‘unfinished business’ after play not just the rewards of success. There is some evidence that Whale players don’t start spending till after 8-12 days. That requires us to sustain their interest a long time.
  6. The Road Of Trials – Once we have passed the danger zone of the Learning Stage and they are still playing then we know they now properly engaged. It’s here that the repeatability of the core mechanic becomes essential; and has to remain fun. Why would we want to play again, and again? There has to be a sustainable delight!
  7. The Temptation – Engaged players don’t just keep playing without an expectation of reward for their effort. Games needs to have a sense of purpose and progression to retain the players’ interest but we need a trigger if we are to get a player to spend money on DLC or In-App items. Players (according to research by Park & Lee) don’t spend money because they are happy. They do so in anticipation of future value. We need to create reasons to want to spend money in the game. That even more the case if we have a F2P game which is hoping to attract Whales (big spenders). These spenders aren’t born, they only emerge from deep engagement with your game.
  8. The Epic Battle – Having a sense of purpose is all well and good, but without an attainable goal or ‘sense of impending doom’ to drive us forward we can easily lose momentum. The Boss Battle isn’t just about a bigger fight; it’s as much about creating a target to aim for which is within reach. If it seems too far away, or we can’t relate to the goals we quickly get bored. There is danger here however, if we create ways for the player to pay their way past the Epic Battle (indeed to pay to avoid playing any aspect of the game) we break the game. That’s what ‘Pay To Win’ means – a broken experience!
  9. The Ultimate Boon – The lure of short term goals and ultimate conflicts is all very good, but in the end we eventually seek something more meaningful. A long term payoff we can anticipate and predict, but where the conditions of that reward can’t quite be pinned down – leaving scope for anticipation and ideally with enough unfinished business that will keep our attention for a long time to come. In the end we need to be able to look back on our playing (and paying) experience and see the utility we gained from this investment.
  10. Rescue From Without – Social factors are essential for long term engagement. Just as the Hero often needs an external helping hand we, as social creatures, need some contact with other players to sustain our interest in the games over time. There is great power in shared experiences and the power to discuss our own magical moments. It’s the heart of storytelling. One of the keys to success in service-based based is the realisation that we need interaction with the Free-Players in order to create the conditions to keep the paying players playing (and paying). Social experiences aren’t binary, we can have shared moments with strangers as well as deep connections exemplified by guilds where the social interaction becomes more important than the game itself.
  11. The Return? – Whilst we can work hard to create ongoing experiences we have to acknowledge that in the end players will churn, they will return to their Ordinary World and perhaps even seek out other adventures. If we have done our work well they will have been changed by their experience and their expectations from other games will be permanently affected.
  12. Master of Two Worlds – Players who leave a game feeling that their investment in terms of money and time was worthwhile will continue to be positive influences for other potential players and may even be ripe to return for the sequel or an extension of the original game. This has to be treated as a new journey, but one with new dangers to face and new treasures to uncover.

These 12 Steps aren’t a fool-proof formula, but they hopefully will help you set your sights further than just the first playing session. We have to consider our players as real people with real lives who want what you have to offer them in terms of entertainment and perhaps, just perhaps this will help us create more sustainable experiences and dare I say… better games?

If you’d like to know more, Oscar will be discussing this topic at the IGDA Webinar on Wednesday 15th October – if you want to join that register at https://www2.gotomeeting.com/register/158293626

p.s. You don’t have to be an IGDA member to join in.

October 12

A Tale of Connected Dots

This past week, we organized Evolve 2014 in Atlanta to talk about all things mobile with Xamarin.

Being a mobile conference, we of course made our own app so that attendees could track out the sessions and the geography of the event.

We also launched something a bit different in the form of a treasure hunt app. Thanks to Estimote, we used a combination of iBeacon and QR codes spread throughout the conference intertwined with challenges along the way until you reach the end of the quest and a special prize.

The main interface of that quest app is a serie of connected dots:

Evolve Quest screenshot

As you progress through the game, the content scrolls naturally to reveal more odd-shaped arrangement of those dots.

Originally, this screen was just a big tall image containing everything. This is suboptimal on Android for a couple of reason like some graphic chip not supporting big “texture” or simply the need to rescale at runtime on most screen.

Ultimately it’s also not fun because there is really nothing you can do with a big image.

Hint: this is NOT what we shipped (on Android at least).

Rather, what attendees could see on their Android phone at the conference was this:

A much more satisfying, softly animated, connected system of dots. The current game position is also highlighted with a discrete pulse.

We will open-source the entire Quest application at some point but I wanted to share how we did that specific bit that is entirely exclusive to Android.

View Source Code

Since this is a really custom animation, it’s a bit different than the other type of animation samples I have already shown.

For this type of thing, I usually rely on a very simple animator that gives me a floating value between 0 and 1 so that I can do my own tweening in code. I also manage to pass this value by hijacking one of the standard view animatable property so that I don’t need to expose more information to the Java bridge:

// Interpolator instantiation
shiverAnimator = ObjectAnimator.OfFloat (this, "scaleX", 0, 1);
shiverAnimator.RepeatCount = ValueAnimator.Infinite;
shiverAnimator.AnimationRepeat += (sender, e) => shiverIndex++;

// Property hijack
public override float ScaleX {
	get { return currentShiverInterpolation; }
	set {
		currentShiverInterpolation = value;
		Invalidate ();

In our case, I then use this value to compute for each drawing pass an offset that is added to the base position of every dots:

// Expressed in dp units
int[] shiverOffsets = new[] { 9, 3, -8, 4, -7, 6 };

// Extra applied offset code
int ApplyShivering (int dotIndex, int value)
	var off = shiverOffsets [(dotIndex + shiverIndex) % shiverOffsets.Length]
		* currentShiverInterpolation;
	value += (int)Math.Round (off);
	return value;

The wave that you see on the highlighted pin comes from a GradientDrawable that I create from a shape drawable XML definition as follow:

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
	<solid android:color="#99ffffff" />

The reason for using a drawable like this is to avoid redoing common drawing code and also taking advantage of the ring shape type automatic radius scaling (notice the innerRadiusRatio attribute) to create a nice spreading effect as the ring grows larger.

The ring size and color is dynamically computed from a slightly interpolated (quadratic or accelerated) value coming from our shared shiver interpolator:

var dur = shiverAnimator.Duration / 4;
var fraction = (float)(shiverAnimator.CurrentPlayTime % dur) / dur;
// Cheap interpolation
fraction *= fraction;

var rippleRad = (int)(radius * (5 * fraction + 1)) - 8;
ripple.SetBounds (x - rippleRad, y - rippleRad, x + rippleRad, y + rippleRad);

var color = Color.Argb ((int)Math.Round (0x99 * (1 - fraction)),
                        0xFF, 0xFF, 0xFF);
((GradientDrawable)ripple).SetColor (color.ToArgb ());

If you have been to my Mastering Time and Space session, you’ll likely also have detected the presence of a custom interpolator in there that is set on the shared shivering animator. The code is following:

class TriangleWave : Java.Lang.Object, ITimeInterpolator
	public float GetInterpolation (float input)
		var t = input * 2;
		return (float)(2 * Math.Abs (t - Math.Floor (t + 0.5)) * (1 - 2 * Math.Floor (t)));

This interpolator generates a triangle pattern that is repeatable (i.e. it both starts and ends at the same position for the dot) so that the animation can run continuously:

Triangle curve

October 9

Universal Fighting Engine: Building a business on the Asset Store

Daniel Esteves is an Asset Store publisher who is all in. His assets are not a byproduct of his game development process. He actually enjoys building tools more than building games, just as we do. And he’s got some advice for people who are itching to make it their living as well.

He used to create Flash games and built an independent game studio that had some success with an MMO card game on Kongregate. After a few years of updates, however, the revenue dried up.

When searching for a new camera system for yet another update on the game, Daniel came across Unity and the Asset Store. He immediately fell for the possibilities of rapid prototyping: “Suddenly, I could see how to do so many small things really, really fast. I was like a kid in a candy store. I just thought “This is sooooo cool!” And I bought all these assets.”

Then it hit him. If there are other enthusiasts like him around, it must be possible to make a living out of this. Around the same time, he sold his share of the game studio, so he could afford to spend some time developing an asset idea. “Since I already had a passion for fighting games and there was nothing like it available in the paid market, I decided to invest my next 8 months working on a 2.5D fighting game toolkit called Universal Fighting Engine (UFE).”


UFE launched on the Asset Store in December 2013, but Daniel started pitching the idea to potential customers a long time before that. And he’s advising others to do the same: “Before going too deep into development, pitch the idea in the Asset Store forum as a WIP (Work In Progress) thread. Introduce yourself and your qualifications before introducing an idea. As you progress in development, post news, screenshots and videos.” This is a way to get some true fans, people who will provide feedback, open your eyes to new ideas and spread the word about your asset.

Since the release, Daniel has been working on updates and customer support, eventually hiring two freelancers to help him with development. He’s still getting lots of support queries, but it helps that he makes sure the documentation is up to date.

“If you are a coder, document EVERYTHING. It will save you countless hours of support. Of course, you will always have the occasional “TL;DR” customer, but trust me, you are mostly dealing with highly intelligent, adult people. If you have it well written somewhere, most customers won’t bother you. If you are a modeler, organize your files the best way you can. And of course, always give them something to look at (a video or a web demo).”

That said, he knows that customer support pays off. Daniel uses the Asset Store section of the forum as a public QA and a website, which saves him a lot of the hassle of answering similar questions multiple times through email. And he knows that people reporting bugs and asking for specific functionalities have helped to mold his product into something better.

One of his most prominent customers is the guy behind Kings of Kung Fu. With a very small budget, professional 3D modeller and animator Jay Lee was been able to put together an alpha build of his dream game, recreating Kung Fu scenes from classic movies.

What does the future hold for UFE? Daniel plans to release a separate engine for purely 2D games and dreams of creating a comprehensive Beat ‘em up engine. So far, it’s been possible for him to make a living doing what he loves. His assets have grossed over twenty thousand dollars since the beginning of June. The future of his projects depends on the Unity community’s love for the genre though, so he hopes that fighting games continue to be in vogue.

October 8

Introducing Xamarin Insights: Real-time Monitoring for Your Apps

Crash reporting and analytics are a vital component to any application’s success. An ideal solution has a few key requirements:

  • Insight into how users are interacting with your apps with events
  • Comprehensive error reporting, including stack traces for both native and managed exceptions
  • Tools to prioritize key issues that customers are experiencing
  • Full cross-platform support with portable class library support
  • Integration of analytics and crash reporting

Last year, at Xamarin Evolve 2013, we announced Xamarin Test Cloud, allowing you to test your app on thousands of devices to ensure the best possible experience for your users. This year is no different.

Xamarin Insights logo

Today, we are pleased to announce the preview for Xamarin Insights, a real-time monitoring system that will enable you to identify, report, and track issues that are impacting users with a simple and effective API.


You can add Insights into your application with just a single line of code. Insights will gather and report any uncaught native or managed exceptions. In addition, you will be able to track both past and active sessions, with full access to device statistics such as operating system and screen resolution. If you want a deeper level of control, you can simply “report” any caught exception, along with any additional data that will help you diagnose the issue, using Insights’ simple API.

Xamarin Insights - Reports


In addition to crash reporting, Insights enables you to easily track any event that occurs in your application with a single method call. From page views to button clicks, Insights’ event tracking can handle the job. You can even track performance by reporting how long operations take to complete. Insights’ tracking is great for seeing which features of your app are being utilized or neglected.

Xamarin Insights Stacktrace


Reproducing bugs is hard. At some point, you’re sure to have experienced a tester or customer report an issue that they had in an app, but you have no information about their device, or any way to determine the steps necessary to reproduce the issue. Insights can combine event tracking with user identification to dive into any specific details you wish, and even make a customer happy by sending them an email when their issue has been resolved.

Xamarin Insights Identify


All of this information is easily browsable from the Insights dashboard. However, as developers we need real-time feedback. To help, Insights easily integrates with services such as GitHub, HipChat, Visual Studio Online, Campfire, and many more, allowing you instant notifications on information that matters to you.

Xamarin Insights Integrate

Get Insights Today

Xamarin Insights is available today for all active Xamarin subscribers at no additional charge for the next few months as a preview. Pricing will be announced at the end of the preview, but a generous plan will be included for Xamarin subscribers at no additional charge.

New Xamarin Test Cloud Features

Today, we are very excited to announce some major improvements and enhancements to Xamarin Test Cloud.


Xamarin.UITest is our new automated UI testing framework capable of testing any mobile app. Xamarin.UITest enables you to harness the power of the C# language to create beautiful, readable, first-class test code with all the power of the .NET framework and IDE at your disposal. Local tests with Xamarin.UITest run against your simulator or device and can report results of test runs directly into Xamarin Studio or Visual Studio.

UI Tests in C#

Xamarin.UITest is based on Calabash, one of the world’s most popular automated testing frameworks for mobile apps. This framework presents a uniform interface to cross-platform testing for any iOS or Android app, including non-Xamarin applications and even hybrid apps that leverage HTML and CSS in WebViews.

While exceptionally powerful in a local environment, the true power of Xamarin.UITest lies in the fact that you can take a working local test case and push it to Xamarin Test Cloud with no modifications, scaling out your testing efforts across a pool of more than 1,000 real, non-jailbroken Android and iOS devices in a cloud environment built for performance and stability.

We encourage you to check out Xamarin.UITest from NuGet and start writing your local tests today. Here’s the docs to help get you started.

Improved Capture Tools

Xamarin Test Cloud generates screenshots of the app as your test progresses through its steps. This way, you can ensure that your app still looks great even on resolutions you’re not familiar with. However, some user experiences aren’t fully captured by screenshots alone.

For this reason, we are announcing a preview of screen recording in Xamarin Test Cloud. With screen recording, you will be able to see video playback of your app running through its test cases. It captures the full testing flow, including animations. It will be available as a preview for Android 4.0 and above at first, and it fully integrated inside the Xamarin Test Cloud web portal.

Screenshot of a Test Cloud failure report

Test Execution Enhancements

One of the most exciting announcements for Xamarin Test Cloud is hyper-parallel test execution. Currently, when you submit a test run to 10 unique devices, those tests already happen at the same time across all those devices, but the individual tests run one after the other. Hyper-parallel test execution takes this to the next level.

Our lab contains many copies of the same device, so we can split a test suite into chunks and execute the chunks in parallel on equivalent devices. In the end, the results are stitched together to form a test result as if the test had been executed serially on a single device – and your test results will come back much, much faster.

We use Xamarin Test Cloud ourselves to ensure the quality of our products. The Xamarin.Forms team, for example, has one of the largest test suites that we service. When run with Xamarin Test Cloud’s default serial configuration, the suite takes around 2.5 hours to execute. When run with hyper-parallelization, the execution time drops to just 12 minutes.
We are delighted to preview these great features, and we’re confident that they will help your team achieve its mobile quality goals, such as: moving to faster release cycles, gaining the ability to release at any time, protection against regressions, and most importantly, achieving the peace of mind and confidence that your developers need to create the best mobile app possible.

Xamarin Platform Previews

We just announced previews for three exciting Xamarin platform features we’re introducing to make your development experience more enjoyable.

We’re making these previews available immediately to get feedback from our community and to help us focus our efforts.

Xamarin Android Player

We decided to tackle the single greatest pain point all Android developers face every day — the outdated, slow and clunky experience provided by the Android emulator. Our new Xamarin Android Player runs with hardware-virtualization on your Windows or Mac desktop to give your apps the shortest startup time and best possible performance through hardware-virtualization and hardware-accelerated graphics.

Xamarin Android Player

The Android Player is built using Xamarin.Mac on OSX and WPF on Windows, and sports native user interfaces that have been customized for each platform following the idioms of Mac and Windows respectively. We have provided a great user interface to help you simulate battery state condition as well as the GPS location as well as integrating directly into ADB, allowing any existing Android tool to work directly with our high performance emulator.

We have made it very simple for developers to install Android APKs and to add Google Play Services. Merely drag and drop the APK into your Xamarin Android Player and have it run.

This current preview ships with Android KitKat 4.4.2, API Level 19 and a single form factor, and is free Free for current Xamarin subscribers. By launch, we will be distributing Android images for all the major API levels and form factors as well as a few nice surprises.


Sketches make C# and F# more accessible than ever.

We wanted to improve upon the standard write, build, deploy, test cycle, and Sketches does just that. Start writing code and watch it run; you can see both the intermediate results for the code that you are writing, as well as the effect that they have on the user interface.

Sketches in C#

Sketches are ideal to learn new APIs, prototype ideas, and quickly iterate on designs. When you find code that works for you, it’s easy to copy it into your app. Or, you can take snippets from your open solution and study them in an isolated live coding environment. This is an incredibly powerful tool for debugging.

Sketches are available today for iOS, Android, and Mac as a preview in the Xamarin Studio Beta Channel, and are coming soon to Visual Studio for Android, iOS and Windows.

To learn more, check out our Sketches documentation.


Profiling is detective work. It’s like solving a mystery or diagnosing a patient – developers have to use their skills to piece together the whole picture, but a good diagnostics tool, like a good magnifying glass or a stethoscope, can help the developer by gathering the clues required to solve the puzzle. That’s why we’re extremely excited to introduce the Xamarin Profiler for your Xamarin mobile apps.

Profiler in Xamarin Studio on Mac

The Xamarin Profiler is a tool that helps you dissect, analyze, and polish your C# mobile applications. The profiler collects information about the managed side of your Xamarin iOS and Android applications and helps you to figure out where to spend the most time making improvements. You can it to find memory leaks, resolve performance bottlenecks, and add polish to your applications before getting them out the door.

The Xamarin Profiler comes in two native versions – Mac and Windows – that integrate seamlessly with your existing Xamarin toolchain. It is available for a public preview download here.

Enterprise Component Vendors Join Xamarin.Forms Ecosystem

On stage at Xamarin Evolve 2014 just now, Miguel shared the amazing work that has been done by six major component vendors in order to ship support for Xamarin.Forms.


A major feature of our Xamarin 3 release earlier this year, Xamarin.Forms gives mobile developers the ability to build native UIs for iOS, Android and Windows Phone from a single, shared C# codebase. Xamarin.Forms is incredibly extensible, enabling developers to share code while always maintaining access to the power of underlying native platform.


Today, we are announcing a major expansion of the Xamarin.Forms ecosystem: Six major .NET component vendors have transformed over 140 existing charts, graphs, gauges, and grids into cross-platform mobile controls, giving Xamarin developers powerful and expressive controls for advanced data visualization.

Our component vendor partners have created beautiful UI controls that enable mobile developers to create native user experiences that meet the increasing demands of mobile enterprise apps, while saving countless hours developing these views for multiple platforms.

More details of Xamarin.Forms support availability can be found on each vendors’ product page:

All components will be available in the Xamarin Component store this year. SyncFusion and Telerik components are available today.

IBM and Xamarin Partner to Accelerate Enterprise Mobility

We are proud to announce a partnership today with IBM to help developers build great native mobile apps for iOS, Android and Windows Phones that easily connect to enterprise data and systems.

IBM and Xamarin Logos

Enterprise apps must have a consumer-grade front-end, an enterprise-grade back-end, and a comprehensive mobile software development lifecycle.

IBM has built a portfolio of enterprise mobility solutions, called IBM MobileFirst, to connect, secure and manage mobile apps. One of IBM’s flagship offerings of their portfolio is IBM Worklight, which is a middleware platform to secure mobile apps, manage their lifecycle, and integrate them into the enterprise.

Our first integration includes:

  • IBM MobileFirst SDK for Xamarin: A pre-built software library that Xamarin and IBM developers can embed in their mobile apps to connect, secure and manage the apps using IBM Worklight, a part of the IBM MobileFirst portfolio.
  • IBM MobileFirst Add-Ons for Xamarin Studio and Visual Studio: Extensions that enable developers to configure and access the IBM Worklight server from a single environment.

The IBM MobileFirst Platform SDK and IBM MobileFirst Platform studio add-ons are available immediately at http://xamarin.com/ibm.

Join the Xamarin Evolve 2014 Live Stream

We’re live streaming the main stage of Xamarin Evolve 2014 from now through the Closing Session on Friday, October 10th. The schedule is as follows, in EDT:

Wednesday, October 8th

  • 9:00 AM – Xamarin Evolve 2014 Keynote, Nat Friedman & Miguel de Icaza, Xamarin
  • 11:30 AM – Find Bugs Before Your Users Do with Xamarin Test Cloud and C#, Rasmus Kromann-Larsen & Karl Krukow, Xamarin
  • 1:45 PM – UX Patterns for Cross Platform Mobile, David, Ortinau, Shutterfly
  • 2:45 PM – Rx and the TPL: Cats and Dogs Living Together??, Paul Betts, Github
  • 4:00 PM – Getting Your Testing Process in Place, Karl Krukow, Xamarin & Niels Frydenholm, eBay
  • 5:00 PM – The Future of C#, Mads Torgensen, Microsoft

Thursday, October 9th

  • 9:00 AM – A Canon in C#, Jon Skeet, Google
  • 10:00 AM – Sketches: A Rich and Interactive Way to Explore Xamarin
  • 11:15 AM – iBeacons and Contextual Location Awareness in iOS and Android Apps, James Montemagno & Mike Bluestein, Xamarin
  • 1:00 PM – Building Cross-Platform Business Apps with Azure Mobile Services, Paul Batum, Microsoft
  • 2:00 PM – If You Can Ship Your app in China, You Can Ship it Anywhere, Jonathan Peppers, Hitcents
  • 3:15 PM – Programming Augmented Reality, Frank A. Krueger, Krueger Systems Inc.
  • 4:15 PM – 1) Write Cross-Platform Apps with F# & Xamarin. 2) ??? 3) Profit!, Rachel Reese, Firefly Logic

Friday, October 10th

  • 9:00 AM – Xamarin.Forms is Even Cooler than You Think, Charles Petzold, Xamarin
  • 10:00 AM – Evolving From Web to Mobile App with Xamarin, Jesse Liberty, Falafel
  • 11:15 AM – Finish the Mac App You Didn’t Know You Started, Mike James, Xamarin
  • 1:00 PM – Closing Session, Nat Friedman & Miguel de Icaza, Xamarin
    Don’t miss any of the great talks from the conference – join the live stream now!

Announcing Xammy Finalists: Vote for Your Favorite now!

Xamarin developers represent the world’s top mobile developers, and the Xammy Awards recognize top apps on our global stage. After combing through hundreds of submissions, we’ve selected our top finalists below. We’re excited for our finalists and blown away by all of the innovation happening on the Xamarin platform.

Xamarin is picking the winners for each category, but we need your help to select the overall “Developer’s Choice” award!

Each person can vote only once, so watch the videos of each finalist and vote for you favorite app. Voting closes at 12pm EDT on October 10th, and you can watch the awards ceremony via live stream at the closing Xamarin Evolve 2014 session that starts at 1 pm.

Xamarin Xammy badgesConsumer

  • The Cinemark App by Cinemark
  • Hanx Writer by Hitcents
  • Storyo by Nativo Labs


  • Apex by Kimberly-Clark
  • Doune FT by Dutch Tax Office
  • TS4 by Gate Gourmet

Emerging Devices

  • PCR Essentials by Thermo Fisher Scientific
  • Skylight by APX Labs
  • Total Comfort Connect by Honeywell


  • Skulls of the Shogun by 17-BIT
  • Snap Attack by Microsoft Studios

Voting for the Xammy Awards is now closed.

Join Us for the Xamarin Evolve 2014 Keynote

Xamarin co-founders Nat Friedman and Miguel de Icaza are presenting the keynote at Xamarin Evolve 2014 in Atlanta, Georgia at 9 am ET. Since we want the entire Xamarin community to be able to join us for this event, we’ve set up two ways for you to follow along today.

We invite those of you who can to join us via live stream to get the full effect of this exciting event. We’ll start sharing as soon as the keynote starts at 9 am ET, and will continue to stream the main stage throughout the rest of the conference.

We know that some of you can’t join the live stream, so we are also bringing you coverage via live blog here. The liveblog is a real-time feed of text updates and photos posted from the event, ideal for those of you who prefer text or want to follow along while multi-tasking at work or on a slower connection.

The opening keynote begins at 9 AM ET. Stay tuned!

Live Blog Evolve 2014 Keynote

October 7

Benchmarking Unity performance in WebGL

When we port Unity to new platforms, it is always an important question to find out how well it performs on that platform – and to see what we can do to make it perform as fast as possible.

One exciting new platform we are currently working to support is WebGL. WebGL is unique when it comes to performance: all code needs to be cross-compiled to JavaScript; some common performance-enhancing techniques, like multi-threading and SIMD, are not available yet; and we are relying on a completely new scripting runtime, IL2Cpp, to run user script code. So we need to find out: Will it be fast enough to play games? How will different browsers and hardware compare? What build settings will produce the fastest results?

These are the questions we have asked ourselves, and we have frequently been asked by our users as well as by suppliers of WebGL implementations. The most obvious approach is to run existing Unity content in WebGL and measure the frame rates. We found that, for most of the content we’ve tried, frame rates are at least 50% of native builds (depending on many factors, such as the browser being used). You can try two demos of games exported to WebGL here. However, we would like to get precise and reliable numbers. Which areas are particularly slow in WebGL? Which are fast? How do different implementations compare, exactly?

To find out, we have created Unity Benchmarks, a suite of benchmark tests written in Unity. The benchmarks stress different areas of the engine and produce easily-comparable numbers on performance. Click here to try Unity Benchmarks in WebGL in your browser! (Note that some WebGL implementations on windows may get incorrectly high results for the Mandelbrot GPU benchmark, as they won’t render the shader correctly. We are investigating the issue and looking for a fix.)


The Physics Benchmark test

Unity Benchmarks has different tests stressing 3D physics, 2D physics, particles, navigation, animation & skinning, object instantiation, scripting, draw calls and GPU pixel throughput. Each benchmark will count how many iterations of a given task Unity can perform in a fixed amount of time. For the reported numbers, higher is always better.

If you run all of the benchmarks, it will also show an Overall Score value. This score is calculated as a weighted sum of all the individual test results. Since the different benchmarks have very different result scales, they each carry different weights in the overall score.  The weights are calibrated to produce similar result scales on my development machine running in WebGL. But that is somewhat arbitrary, so, when comparing results, the individual scores are much more meaningful than the Overall Score!

So, after all the explanations, here are some results (all benchmarks are run on a 15” Retina MacBook Pro 2.6 GHz i7 running OS X 10.10):



The scores have been scaled so that Firefox = 1.0, to fit onto a single chart. Higher is better.

Some observations:

  • In almost all benchmarks, Firefox with asm.js is faster than both Chrome and Safari in almost all benchmarks, and is currently the best browser to run Unity WebGL content. We hope to see asm.js support showing up in other browsers in the future as well, however – see here for some interesting comments on this subject.

  • When you are mostly GPU-bound, you can expect WebGL to perform very similar to native code.

  • In some areas, WebGL will actually outperform native code significantly. This is the case for tests which rely a lot on script performance (Mandelbrot and CryptoHash, which both implement their algorithms in C#), as IL2Cpp can produce more optimized code (expect to read more about this in another blog post soon).

  • Native code can still be several times faster than WebGL for areas heavily optimized to use multi-threading and/or SIMD, such as the 3D physics tests (PhysX 3.3 in Unity 5.0 is now fully multi-threaded). Compared to that, 2D physics is very close to parity when comparing Firefox to Native (Box2D is not multi-threaded). We hope that the future will bring SIMD and multi-threading extensions to JavaScript, at which point this may change.

The most important takeaway is, while there are still areas where WebGL is significantly slower than native code, overall you can get expect very decent performance already, and this can only get better in the future. I hope that these benchmarks may help anyone looking to optimize performance of their JS engines and WebGL implementations to run Unity content as fast as possible.


Monologue is a window into the world, work, and lives of the community members and developers that make up the Mono Project, which is a free cross-platform development environment used primarily on Linux.

If you would rather follow Monologue using a newsreader, we provide the following feed:

RSS 2.0 Feed

Monologue is powered by Mono and the Monologue software.