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.

September 22

Branch differences

We’ve implemented a batch of improvements in the branch/cset/label diff window in the last months. Some of the improvements are pretty recent and some others have been around for months already. I’ll be walking through them and explaining how they help when running diffs on a daily basis.

Improved diff groups

Availability: (Sep 12th 2014) and (Sep 19th 2014).

The first feature is the ability to group together files and directories that only differ in file system permissions (typical scenario when some files get executable flag on Linux). Now the files that only differ in file system permissions are grouped together so you can better focus on what was actually modified.

The goal here is to let you focus on the real changes when diffing code for a review or when figuring out why a bug occurred, by grouping away potentially uninteresting changes.

The second feature is a slight modification since we released Item Merge Tracking last year. Now the files that were in changed/changed merge conflicts will show up in their own category:

And this is how the same info was grouped before:

As you can see now he highlight the “changed/changed” and put them at the very beginning of the list so you can focus first on the diffs of files which were modified by both contributors during a merge, and hence are potentially worth reviewing.

Analyze diffs

Availability: (March 3rd 2014) and (March 10th 2014).

There’s a story behind this feature: sometimes you find yourself reviewing a task where the developer modified a huge number of files, like 200 or so.

You launch the diff and then you see the counter with a big number on it: 100, 200, 250 files… whatever. Your feeling will be: “oh god! Let’s go and grab some coffee first”. Which, in short, means that huge reviews are extremely unproductive because you enter in this state of mood of “this will take a loooooong time”.

And sometimes that’s correct and you truly have to spend a long time.

But chances are that many of the files changed by your colleague only contain trivial changes. Like a rename on a method that affects a bunch of files, but all this files only have a trivial modification.

How can you figure out beforehand? Well, that’s why we’ve introduced “analyze changes”.

You click on the new “analyze differences” button and then Plastic will use cloc to calculate the lines of code being modified. You can see it running in my review with 284 files below:

And here goes the result once the changes were classified:

As you can see there’s a new SLOC column where you see a summary of the lines of code being added, changed and deleted (since it uses SLOC and not LOC, there will be cases where changes only affected comments or white lines and hence they’ll show up as zero changes!).

You can sort the column and then check how many files have really “big changes” and it will have a positive effect on your mood and willingness to go through the entire list, which at the end of the day means increased productivity :-)

In my screenshot you can see how the selected file just contains a namespace change… which is not a big deal to review and in fact in my example this refactor affected more than 180 files out of 280, not bad.

This is the first step towards true “semantic multi-file diff” :-)

Find in files

Available since: (Jun 6th 2014) and (July 1st 2014).

Sometimes you’re diffing a branch and then you would like to find something (a method call, a given text or comment) inside the files being diffed.

That’s why we added “find in files” to the diff window: click on the new “find in files” button or “CTRL+SHIFT+F” and the following panel will show up:

You can enter the pattern to find, then decide whether you want to search in both sides or only one of them, select the extension or whether you want to select the search to the filtered files in the diff window.

And the results are displayed as follows:

With the occurrences of the left and right sides separated to ease the navigation.

In my case I was looking for the word “comment” and it is clearly more common before the change, which means the word was deleted from the file.

Our plan is to implement another feature on top: “search only in diffs” to restrict the search to the text blocks which were really modified. This is useful, for instance, to see if a certain method call has been really used in the new code or not.

Annotate each contributor

Available since: (Jun 18th 2014) and (Jun 26th 2014).

We added the option to launch the annotate from within the diff view so you can instantly see the detailed information about each line of each of the two sides of a diff.

I find it especially useful when going through complex merges: look at the screenshot above. Do you see the “Yes” at the end of the annotate? It means this line was modified during a merge. Which means the two contributors to the merge don’t contain the line but it was actually edited during the merge (at least prior to the checkin). This information is very useful to figure out what was really changed manually and what simply comes directly from one of the merge contributors.

As it happens with some of the other features explained in this blog post, this is just a first step. We’re working on more improvements to item merge tracking to be able to display on files in the “changed-changed” group exactly which lines come from merges or were modified on the branch.

Info about binary files

Available since: (Aug 6th 2014) and (Aug 8th 2014).

Sometimes you’re diffing a branch and there are binary files that can’t be diffed. So far we were just displaying a message telling “diff not available” (although you can CTRL+D to launch the external diff, for images for instance). Now we display useful metadata to understand the change:

The date and size and author are especially useful to understand what is going on with the file.

For images our plan is to embed the Image Diff here (check the gallery to find out more about the tool).

September 20

Expanded Oculus Rift Support in Unity

More awesome news today as Brendan Iribe, during his Oculus Connect conference keynote, announced that our two companies have extended our partnership in order to ensure that Unity is available for all of our development community. That means whether you’re using the free version of Unity or Unity Pro, you’ll be able to create awesome VR experiences for the Oculus Rift and the Oculus VR Store for free!

We’re working with Oculus to create an official add-on supporting the Oculus Rift in Unity that everyone will have access to for free. We know a lot of you have interest in creating new experiences and experimenting with one of the most exciting platforms around so we’re very happy to make that as easy as possible.

The Oculus add-on will include stereo imaging optimizations, 3D audio support, deeper Unity editor integration, inclusion of the Oculus Rift in the Unity development and debugging workflow, integration of Oculus-specific APIs within Unity, and direct publishing to the Oculus platform.

We do want to make sure everyone can work on Oculus projects while the Unity for Oculus add-on is in development. To that end, we’re working with Oculus to make the current Oculus plug-in, one that has been available for free for Unity Pro users, also available for those making games with the free version of Unity. This new plugin version will be made available for free download on the Oculus developer site as soon as possible.

We’re already seeing some amazing things being made in Unity for the Oculus Rift. Projects like Lucky’s Tale, Game of Thrones: The Wall, The Gallery: Six Elements, DarkNet, Titans of Space, Blocked In, and our 2014 Unity Awards winner for Best Student Project, The Rift: U.R.I.D.I.S., demonstrate the great creative potential in virtual reality and the Oculus Rift. We can’t wait to see what you can do with dedicated tools!


September 19

Add Some Punch to Your Apps with iOS 8

iOS 8 iconWith over 4,000 APIs, and 12 major new or upgraded frameworks and features, iOS 8 is one of Apple’s biggest OS releases yet. Now, Xamarin is here to get you started with the new goodies and 64 bit support with the iOS and Mac Unified API.

To get building apps that take advantage of the new iOS 8 frameworks and features today:

  1. Download and install the latest Xcode.
  2. Update Xamarin.
  3. Check out the Introduction to iOS 8 Guide.

While you’re downloading Xcode and installing the updates, watch the Get Ready for iOS 8 webinar for a curated overview of the new features, hosted by Xamarin Developer Evangelist Mike Bluestein.

If you want to see the new features in action for yourself, you can also download and play with our new iOS 8 Samples.

iOS 8 has a ton of new frameworks and features, so when you’re ready to continue your journey and dive deep, check out the Xamarin guides, which will help you utilize the new features and add some sparkle to your apps.

Provide Rich OS Integration with App Extensions

App Extensions iconApp Extensions allow for apps to deliver unprecedented functionality through deep OS integration. With Extensions, applications can now offer features like the Today Widgets that live on the notification screen, custom keyboards, and sharing extensions, to name just a few. To learn how to create your own, check out the Intro to App Extensions guide.

Access Secrets Biometrically with Touch ID

Touch Id iconThe new TouchID APIs allow app developers to integrate with Apple’s biometric touch sensor to authenticate users and restrict access to data and functionality within your apps. Additionally, with TouchID, access to the keychain and secure storage is available biometrically. For more information, check out the Introduction to TouchID guide.

Build Custom Photo Galleries and Create the Next Instagram with Photo Kit

Photo Kit iconPhoto Kit is a new framework that makes working with the image library a snap. With Photo Kit, you can more easily fetch photos, create custom galleries, and even apply filters and modify them en masse. For an example of using the Photo Kit framework in Xamarin, see Mike Bluestein’s Build Great Photo Experiences in iOS 8 with Photo Kit blog post.

Use Manual Camera Controls to Create Highly Stylized Photos

Camera API iconThe AVFoundation Framework got a big upgrade in iOS with the addition of the all new manual camera controls. With them, you can get low-level access to the camera hardware, enabling the iPhone’s camera to be controlled more like traditional cameras. Jump in and read the Intro to Manual Camera Controls guide for more information.

Take your iCloud Integration to the Next Level with Cloud Kit

Cloud Kit iconCloud Kit expands on the existing iCloud APIs to enable much more sophisticated integration with iCloud, and is targeted at developers who want to take advantage of iCloud to handle cloud-based data persistence and retrieval. It offers a much simpler integration story than previously, while offering a much more feature-rich experience. For more information, check out the Intro to Cloud Kit guide.

Share Documents with other apps with the Document Picker

Document Picker iconThe Document Picker allows applications to reach beyond the app sandbox to share and access documents with other applications. With the Document Picker, you can now create complex document workflows between more than one application. For more information on working with it, check out the Intro to the Document Picker guide.

Work with Calendars and Events in Event Kit

With iOS 8, Apple expanded on the Event Kit framework to allow easier access to, and manipulation of calendars and events. For more info, check out the Intro to Event Kit guide.

Simplify UI Creation Across All iOS Devices with Unified Storyboards

Unified Storyboards iconWith the introduction of the iPhone 6 and iPhone 6+, creating user interfaces that work well across all iOS devices got much more complicated. Fortunately, Apple introduce Unified Storyboards to simplify the process by allowing you to create single screens that scale for different devices. For more information, see the Intro to Unified Storyboards guide.

Integrate 3D Graphics into your App with Scene Kit

Scene Kit iconSceneKit is a 3D scene graph API that makes integrating 3D content into your application and causal 3D games a breeze. For an example of using the Scene Kit framework in Xamarin, see Mike Bluestein’s Lights, Camera, Action – 3D in iOS 8 with Scene Kit blog post.

Create 2D Games Quickly with Sprite Kit

Sprite Kit iconSprite Kit, the 2D game framework from Apple, has some interesting new features in iOS 8 and OS X Yosemite, including integration with Scene Kit, lighting, and physics enhancements. For an example of using the SpriteKit framework in Xamarin, see Mike Bluestein’s New Sprite Kit Physics Features in iOS 8 blog post.

Browse the Entire List of New APIs and Features

These are some, but not all, of the new features in iOS 8. For a comprehensive list, check out the API change log and release notes.

Xamarin Evolve 2014 Speaker Spotlight: Rachel Reese

This is the sixth post in our Xamarin Evolve 2014 “Speaker Spotlight” series, helping you get to know a little bit more about some of the amazing speakers who will be contributing at this year’s conference.

Photo of Rachel ReeseToday’s spotlight features Rachel Reese, a long-time software engineer and math geek who recently relocated to Nashville, TN to work with the fabulous folks at Firefly Logic, as well as to be a part of the Nashville functional programming scene. She currently helps run the Nashville Xamarin user group, @NashXam, and is an ASPInsider and an F# MVP. You can hear Rachel’s talk, “1) Write Cross-Platform Apps with F# & Xamarin. 2) ??? 3) Profit!: Mobile App Development in F#” in the Xamarin Platform track at Xamarin Evolve.

How long have you been doing mobile development?

Actually, not very long (around eight months). I’d been hearing about Xamarin and F# development for about two years, but it took my move to Nashville for me to get really involved in mobile development. In just under a year, I’ve jumped all in — what’s there to not love about using my F# and C# skills to build iOS and Android apps? This is awesome!

Why did you get into software development?

Oh, good question. I was a math/physics major in college. The summer after my freshman year, I started a research job with a high-energy physics lab. One of the grad students sat me down on my first day, handed me a book on C, and told me that I wouldn’t really be useful until I understood most of it. I spent the summer going through the book meticulously. I took a couple programming courses in school, as well, so when I graduated (after much, much hemming and hawing about whether or not to go to grad school) I opted for a job with a friend of mine that only required I know a bit about HTML. It was all downhill from there!

What is your favorite line of code that you have ever written?


What will attendees get out of your Xamarin Evolve talk?

A basic understanding of how and why using F# is a fabulous alternative to C# for mobile developers.

How much do you love curly braces and why?

Curly braces!?

*puts on shades*

Where I am, I don’t need no stinkin’ curly braces.

What are you doing when you’re not doing mobile development with Xamarin?

I’m confused. Life outside mobile development with Xamarin!? That… exists?

Traveling (both near and far)! Fun fact: my two dogs have been to more countries than I suspect most Americans have (5: France, Germany, Spain, Canada, US).

Also, cooking. I have an awful/amazing habit of buying spices, infused balsamics, and kitchen trinkets. Sometimes I concoct awesome things, sometimes not so much, but it’s all fun.

If you missed the earlier posts in this series, click through to read about Jesse Liberty, Jon Skeet, Jonathan Peppers, Laurent Bugnion, and Paul Betts.

Dropbox Joins Xamarin Evolve 2014

Dropbox LogoWe are very excited to welcome Dropbox as a Silver Sponsor for Xamarin Evolve 2014. Dropbox  joins an exciting list of industry leaders at Xamarin Evolve this year, including Google, Microsoft, IBM, Twilio, Amazon, and more.

Photo of Steve Marx Steve Marx, Developer Advocate at Dropbox, will present, “Cross-Platform Syncing with Dropbox,” in the Mobile Ecosystem track. In this demo-heavy talk, Steve will walk attendees through the challenges of cross-platform syncing and the tools that Dropbox provides for mobile developers.

Don’t miss your ticket to mobile expertise – register now for Xamarin Evolve 2014.

September 18

Top Mobile Security Experts Come to Xamarin Evolve 2014

The global mobile economy is growing at an incredible rate, and with that explosive growth come risks and responsibilities for app developers. We’re excited to bring together top mobile security experts at Xamarin Evolve 2014 for a special Panel on Mobile Security Best Practices.

AirWatch, MaaS360, Arxan, Good Technology, and Mobile Iron logosJoin moderator Steve Hall, Director of Mobile Enterprise Mobility at Xamarin, along with panelists Erich Stuntebeck, Director of Research at AirWatch by VMware, Anar Taori, Senior Director of Product Management at MaaS360 by Fiberlink, an IBM company, Vince Arneja, Vice President, Product Management at Arxan Technologies, John Britton, Director of the Office of the CTO at Good Technology, and Sean Ginevan, Director of Corporate Strategy at MobileIron, to discuss how to best secure sensitive data in your apps, on devices, and over the wire.

Don’t miss this opportunity to learn from industry experts – register now for your ticket to mobile expertise at Xamarin Evolve 2014.

Meme Generator Powered by MMS

If you haven't heard yet, Twilio annouced MMS support today on all US and Canada phone numbers. I'm so stoked about this new feature and I knew exactly what I wanted to build with it.

Introducing the MMS Meme Generator

It is my belief that a mechanism for sending pictures cannot survive in the market if it does not generate memes. The internet demands the ability to express itself with images containing words. So, I am excited to bring you the first Twilio powered MMS meme generator.

How it works

All you need to do is send a properly formatted text message to (443)746-3637 -- that's (443)74-MEMES -- and you'll get back an MMS with your meme. Here are the supported memes in v1:

  • One does not simply ______
  • What if I told you ______
  • Brace yourselves ______
  • ______ but that's none of my business
  • ______ all the ______
  • ______ ain't nobody got time for that
  • ______ we're dealing with a badass over here
  • ______ aaaaand it's gone  (note: any number of a's will work on this one!)


Have fun with this!

Hope you have some fun with this. Share your funniest memes with me on Twitter @brentschooley! Future additions will allow you to send these memes to your friends by sending their phone number in the text. Also, stay tuned to the Twilio blog where in a few weeks I'll show you how this was built.

If you want to get started with Twilio MMS, my team has put together a great Getting Started post that covers Node, Python, C#, PHP, Java and Ruby. Show me what you build!

Google Joins Xamarin Evolve 2014

Google LogoWe’re thrilled to announce that Google is joining Xamarin Evolve 2014 as a Gold sponsor. Google is the latest addition to the growing list of fantastic sponsors and speakers, including Microsoft, IBM, Github, Salesforce, and more, attending the cross-platform mobile development event of the year from October 6-10 in Atlanta, Georgia.

peter friese roundGoogle Developer Advocate Peter Friese will provide a rundown of the core services available via Google Play Services in his talk, “Google Play Services Rock.” Attendees will get an overview of the new APIs that come as a part of the latest version of Google Play Services, and dive into some of the lesser known features that enable developers to build apps that truly rock.

Register now to join Xamarin and Google for the mobile development event of the year.

Global Illumination in Unity 5

Unity 5 is receiving a major make-over in terms of graphical fidelity and lighting in particular. Unity has been limited to baked lightmaps since Unity 3.0, but since then a lot of progress has been made in the global illumination field. Now is the time to provide some of that goodness out-of-the box in Unity. One of the new graphics features in Unity 5 is real-time in-game global illumination combined with new and vastly improved lighting workflows and these are the focus of this post. But first some background.

Doll model rendered with path tracing in Unity. Courtesy of Paul Tham, Unity Singapore.

What is this global illumination all about?

Global illumination (GI) is the simulation of physically based light transport. It is a means to simulate how light is transferred between surfaces in your 3D scene and it will greatly increase the realism of your game. Not only that, it is also a means to convey mood and with clever use can be used to improve the gameplay. GI algorithms take into account not only the light which comes directly from a light source (the direct illumination), but also subsequent cases in which this light is reflected by surfaces in the scene using different materials (indirect illumination). Traditionally, indirect illumination has been too expensive to compute within the real-time constraint of a game.

It is all down to this innocent looking equation:

It is really rather simple. The lighting visible from some point in your scene is the sum of light emitted from that surface point (Le) and the incident lighting from the hemisphere above the point reflected into the viewing direction towards the viewer. Li describes incoming light from some direction w’ on the hemisphere towards the point x. The reflectance term p then describes how light is reflected towards the viewer and is dependent on the incident angle w’ and the exitant angle w.

As the observant reader might have spotted L(x,w) is on both sides of the equation and inside an integral to boot. Now if that hadn’t been the case we would have had global illumination in Elite. Since the laws of physics are hard to alter, the research community set about to come up with a solution.

One of the most popular (and oldest) algorithms is path tracing, which basically attacks this algorithm head on, with some tricks added to spend the most time on areas known to be difficult. Path tracing is used a lot in CGI for film and television. Even though a massive amount of research has been poured into this, an image takes in the order of seconds to render (even with a beefy GPU).

Path tracing is typically used in screen-space, so the image needs to be re-rendered from scratch in every frame. This means that it supports fully dynamic scenes: lighting, materials, geometry can be freely animated. This is also a drawback as a new image has to be rendered when the camera is moved, and, since it takes on the order of seconds for the image to fully converge, it will not be appropriate for games.

A not fully converged image has disturbing noise in it and it is also not temporally coherent either so the image will flicker badly as it reaches convergence. Filtering can help limit this effect, but it cannot be completely removed. Below are a few shots taken at various levels of convergence:

Path traced images at various stages of convergence.

Lately a number of hybrid approaches have been developed, many running on the GPU, such as voxel cone tracing. Most of them require a desktop GPU with a fair amount of memory and are appropriate for high-end desktop systems only. In order to provide global illumination that will work well on a wide swath of supported platforms (including mobile) some compromise has to be made.

Enter Enlighten

Enlighten provides an excellent solution to this problem. It very elegantly scales from mobile through consoles up to high-end systems because it constrains the problem it is solving. It has also been battle-tested as it was shipped in AAA titles such as Battlefield 4, MoH Warfighter, and others.

The basic idea is that if some of the visibility is precomputed (i.e. the integral on the right in the rendering equation above) it is possible to modify the lighting in real-time even on mobile platforms.

Enlighten allows dynamically changing:

  • Light sources.
  • Environment lighting.
  • Material properties (diffuse reflectivity and surface emission).

The geometry that is part of the GI simulation has to be static, but dynamic geometry can be relit using light probes that are updated in real-time with the GI generated from the static geometry. In order to do this Enlighten precomputes the data needed for simulating GI at run-time. This data is consumed by a run-time module which is available for many platforms: OSX, Windows, Linux, iOS, Android, PS Vita, PS3, PS4, Windows Phone, Xbox360 and XboxOne. WebGL is in the works, but no definite timeline for this.

Enlighten outputs the following data:

  • Real-time lightmaps.
  • Real-time lightprobes.
  • Real-time cubemaps.

Enlighten is limited to computing GI for diffuse transport. This is the most important mode of transport as it conveys the overall illumination of the scene. Since diffuse transport is generally low-frequency the real-time lightmaps can be quite low-res and updateable in real-time. Support for specular/glossy transport is added by providing dynamically updated cubemaps. In Heckbert notation Enlighten accounts for the following light path subset: L(D)*(S|G)?E. This means that most GI effects are covered. The main missing effect will be specular bounces via diffuse surfaces – commonly known as caustics. To get this effect you will need to cheat.

Below is an example of two lighting setups rendered with Enlighten. These lighting setups were fully dynamic and switching between them is instantaneous.


 Viking Village – dawn

 In this next shot a brighter blue sky was used the sun is higher and more intense:

 Viking Village – sunny day

Environment lighting is grey and desaturated and the sun intensity is lower. Mainly ambient lighting:

Viking Village - overcast day

Lastly a sunset shot with warm reds for a sunset mood:

Viking Village – sunset

Using this technique enables games with very realistic looking time-of-day cycles.

Enlighten precompute

The compromise is that most of the geometry has to be static, effectively all the large scale geometry that will participate in the GI solution. During the precomputation phase Enlighten will automatically break up the scene into systems. It is also possible to affect how these systems are generated. The systems serve to make the precompute a massively parallel pipeline. The pipeline is relatively deep and solves per system tasks. Here is an example of how the Viking Village level was automatically broken up into systems:


Editor visualization of the automatically generated Enlighten systems.

After the precompute has finished the relationship between the systems is known and this can be used in the run-time to partially alleviate the limitation of static geometry. At run-time the amount of indirect light transferred between systems can be controlled. This allows you to fade in bounce between systems and this can be used to achieve effects such as destruction or opening doors.

Enlighten run-time

The Enlighten run-time is efficient enough to run on higher end mobile devices. It runs asynchronously on a CPU thread (or more threads if the platform allows it). The most prominent issue for mobile platforms will be that the direct lighting and shadow maps for dynamic lights needs to be computed on the GPU. So on mobile platforms only a few dynamic lights will be feasible. However, the emissive properties of geometry can be adjusted in real-time almost for free. The emissive lighting computed by Enlighten encodes visibility too. This means that the emissive light is effectively shadow mapped for free, albeit at a low resolution.

Enlighten scales well onto desktop systems and next-gen consoles that could support games using exclusively dynamic lights since more GPU power is available for direct lighting and shadow mapping.

Here is an example of a mobile demo using Enlighten running on an ARM powered tablet:

What about baking

For some titles baking will be the appropriate choice, so this workflow will be supported and developed well into the future. In Unity 5 the lighting inputs: light sources, emissive materials and environment lighting can be tagged as using baked or real-time GI. Baked lighting inputs are baked into lightmaps in the same way as in previous versions of Unity and dynamic lights are handled by the Enlighten run-time. The baked and real-time GI merges seamlessly.

There are also new baking features already in Unity 5. One of those is that now the lightmaps are broken up into components. For each atlas there are five lightmaps containing direct lightingindirect lighting, direct directionality, indirect directionality and AO respectively. After a bake these will be composited into lightmaps used in the game. In the Editor there are controls that specify how these lightmaps are composited. You can tweak these settings to adjust the look of the final output. For example the indirect lighting can be boosted easily. This only requires a compositing job, which takes seconds whereas before a rebake would be needed to do this.

Lighting workflow

Enlighten doesn’t just provide in-game real-time GI. One of the most important improvements that Enlighten provides is a vastly improved lighting workflow for artists. It allows for faster iteration on lighting, which in turn yields better looking content. An iterative mode has been added, which removes the need for explicitly baking the scene. The scene will instead precompute and  bake in the background without any user intervention. The Editor will automatically track changes made to the scene and execute the tasks needed to fix up the lighting. In many cases when iterating on the lighting these tasks will be nearly instantaneous.

The following video shows a live session using the new lighting workflow:

What types of games will work with Enlighten?

As already discussed the limitation of real-time GI is that the large scale scene setup must be known in advance. We had to choose either to pursue a fully dynamic solution that would only work on high-end systems or a solution that covers many use-cases but also works on mobile hardware, thus reaching a wider part of the market. And we chose the latter for 5.0. Below is a list of types of games that may prove difficult with real-time GI:

  • Q: Can I do opening of doors and gates?
    A: As discussed above authoring systems and scripting the exchange of bounce between systems depending on the door or gate will solve this in some cases. (The scripting extensions needed for this are expected to arrive in 5.x.)
  • Q: Can I support destruction?
    A: Support for making objects transparent dynamically exists in Enlighten. This means that objects that may be destroyed in the game must be marked as such in advance. While this is not ideal it should support many use-cases. ( This feature should arrive in 5.x.)
  • Q: Can I download (stream) chunks of level additively?
    A: Yes, systems can be streamed in additively. The systems can be made so that they do not straddle your streaming chunks. This can be done manually or with scripting. (This feature should be available in 5.0.)
  • Q: Can I create a game world semi-procedurally with premade chunks (endless runner type)?
    A: Yes, bounce between consecutive chunks would be possible if the various combinations that premade chunks are arranged in are precomputed separately. This is similar to how you would bake lightmaps (without seams) for an endless runner. (The precompute API needed for this should be available in 5.x.)
  • Q: Can I create game world fully procedurally, Minecraft style?
    A: Short answer, no. However, we are doing multiple projects with Imagination Technologies using their PowerVR Ray Tracing technology for GI previews and hybrid rendering. This could potentially yield a solution to procedural or user generated scenes. The PowerVR Ray Tracing technology supports interactive GI for fully dynamic scenes. It is not yet fully real-time and the first few frames will have visible noise as the solution converges, but it is a very promising direction. It will certainly be able to light user generated scenes assuming some delay is acceptable. (There is no ETA for this as it is still an R&D project.)

What will be in Free what will be in Pro?

The feature split between Unity Free and Unity Pro has not yet been decided. We will announce this in a future blog post.

What is in 5.0

These are the main features shipping in Unity 5.0:

  • Enlighten run-time for in game real-time GI.
  • Iterative workflow (for both real-time GI and baking).
  • Reflection probes.

Beyond 5.0

As we are doing a lot of changes to the lighting workflows and lighting in general some features will slip 5.0 as they need more polish. These are some of the features that will surface during the Unity 5 cycle:

  • PowerVR path traced previews for real-time and baked lightmaps (details here).
  • API for controlling the real-time GI contribution between systems.
  • Enlighten real-time cubemaps.
  • Support for real-time GI transparency.
  • Cloud/cluster precompute/bake.

Some more material is available on this subject: slides for the Unite 2014 talk on GIvideo of the Unite 2014 talk on GI, Unite 2014 keynote (graphics part).

Let us know what you think!

The Graphics Team.

September 17

Update progress

The update operation is the responsible of downloading files and directories from the repository into your workspace. It can be a time consuming action if there’s a high number of files to be downloaded (or updated) or if the overall size is big. The equivalent to “update” in Plastic is “checkout” in SVN and Git jargon.

We added a new “update progress” so that when there’s a lot to be downloaded you get more precise feedback:

The progress is updated in 4Mb blocks which is the transfer unit we use. It can be a chunk of a big file or a group of small files summing up to 4Mb.


This feature is only available in version 5.4 ( - Jun 26th 2014 and higher). 5.0 won’t get this one merged since the code is built on top of some other changes and improvements developed for 5.4 only.

Webinar Recording: Android L and So Much More

The Android L Developer Preview introduced a plethora of new APIs for developers to take advantage of, including Material Design, notifications, and new animations, to name a few. Xamarin developers can access these APIs right now with our preliminary support in Xamarin.Android.

In this webinar, Xamarin Developer Evangelist James Montemagno walks viewers through the top new and updated APIs in the release. In addition to everything new in the Android L Developer Preview, he also covers new features in Google Play Services, Support Libraries, Android Wear, and Android TV SDKs.

Access the slides for this webinar here.

Additional Resources

If you’d like further information on getting started with Android L and Xamarin, follow the steps outlined in this blog post.

Xamarin Evolve 2014 attendees, be sure to check out our Android track for even more information. If you are not already attending the conference, you can register here.

Great News for PlayStation Developers!

(Edit: There have been a few questions about the Pro nature of these tools. To clarify, it is not necessary to own Unity Pro to take advantage of Unity Pro for PlayStation. As a licensed PlayStation developer, this version will allow you to use Pro features and target SCE platforms at no cost. If wish to publish with Unity Pro on additional platforms outside of the PlayStation family, you will need to have a regular Unity Pro license along with any necessary platform add-on licenses to do so.)

As many of you are aware, we’ve been working closely with Sony Computer Entertainment for a long time now. In March of 2013, we entered a strategic partnership that resulted in Unity for PlayStation® tools that make it possible for Unity developers to create games for SCE’s amazing devices.

Now, we’re extending that partnership and making it even better! Not only does this mean a deeper collaboration on support for features and optimizations for all of you experienced PlayStation developers, but also that ALL licensed PlayStation developers will have access to these tools for free!

All you have to do is contact your PlayStation representative to discuss becoming an approved PlayStation developer to get the PlayStation ready versions of Unity Pro.

This is another amazing display by SCE of how much they welcome developers, no matter their size and pedigree! Some of the most exciting games are coming from smaller teams who in the past would have been hard pressed to get on so many awesome platforms.

We’ve already seen some awesome games released using the tools like Oddworld: New ‘N’ Tasty, Stick it to the Man!, and CounterSpy and there are a ton more on the way like Galak-Z, Assault Android Cactus, Night in the Woods, Shiftlings, Starwhal: Just the Tip, and BroForce. You can see a sample list of games for the PlayStation platforms by visiting our showcase gallery and searching by platform.

Now that the tools are out and it’s easier than ever to get and use the tools, we’re expecting great things from all of you!

Happy developing,


September 16

Xamarin Evolve 2014 Speaker Spotlight: Paul Betts

This is the fifth post in our Xamarin Evolve 2014 “Speaker Spotlight” series, helping you get to know a little bit more about some of the amazing speakers who will be contributing at this year’s conference.

Photo of Paul BettsPaul Betts is a C# Hacker at GitHub, and the author of several open source .NET projects, including Refit, Splat! and Akavache. Paul graduated from The Ohio State University, and likes to spend his spare time hacking on open source software, playing guitar and bass, and in general is within ε of really awesome. Don’t miss Paul’s talk at Xamarin Evolve, “Writing Mobile Apps the Github Way,” in the Mobile Best Practices track.

How long have you been doing mobile development?

My interest in mobile development started when iPhone first released their non-web SDK, but I really got started in mobile development when I added Xamarin support to ReactiveUI, which was about two years ago.

What are your favorite mobile apps and why?

My favorite app these days is Dropbox’s Mailbox. The usability designers who created that app are absolutely brilliant; while I don’t find it to be a particularly visually beautiful application (so much white everywhere!), using it is an absolute joy. If you’re building any kind of content-management/TODO app, study this thing like a graduate student.

What is your favorite platform to develop for and why?



What devices are you carrying around with you right now?

The devices I carry around with me are usually:

  • An HTC One (M7) – It’s getting a little long in the tooth, but getting the Developer Edition meant that it was super hackable and easy to flash with the latest software, given a bit of adb and fastboot work. It’s a great device except for the camera.
  • LG G Watch – I couldn’t wait until the Moto 360 came out – I’m excited to see if I can come up with a cool watch app!
  • nVidia Shield – It’s an Android phone with a super-powered graphics chip and an HDMI out, bolted to a game controller. I use it to play old SNES games and write software for it.

What are your favorite open source libraries, and why?

My favorite libraries? The Xamarin ones I write, of course! I’ve got a lot of them:

The common theme around most of these libraries is that they let you write cross-platform code in a Portable Library, and the library handles the platform details. For example, ModernHttpClient brings the best platform-specific networking libraries to your app, but wraps them in a familiar HttpClient interface that works everywhere.

Separate from that, I love all of the great work that Jake Wharton does; he’s a great Android developer and a lot of my library ideas come from him.

What is your favorite line of code that you have ever written?

My favorite line of code I’ve ever written is here.

To explain it though, I need to back up. The goal of this class is to provide a mapped operation queue – i.e. you schedule a Task with a specific Key – Tasks with different keys run in parallel, and Tasks with the same key run sequentially.

The entire behavior of this class, this complex notion that would take pages and pages of buggy, unverifiable threading/locking code, is reduced to a single (relatively) beautiful statement in C# with Rx. What’s even cooler, is that the notion of scheduling priority (i.e. important operations should go to the head of the line), was added simply by changing a data structure, from using a normal Queue in a SemaphoreSubject, to using a PriorityQueue.

If you missed the earlier posts in this series, click through to read about Jesse Liberty, Jon Skeet, Jonathan Peppers, and Laurent Bugnion.

Getting Started as a Contributor to our Open-Source Projects

Unity and Open-Source

Last month at Unite, we announced our Open-Source initiative, where we will be opening the source to various components of Unity (along with other helpful tools and samples) in the future.  We announced the presence of the Unity Test Tools project at our new home on BitBucket and since then we’ve watched as our community has cloned, made forks, and submitted pull requests (you can see the development of the Test Tools happening in the repository itself and the project’s issue tracker being used as well).  Since then we’ve released our Xcode Manipulation API (allowing you to modify and adjust a generated Xcode project) and iOS Native Code samples (giving examples for things like how to integrate Unity with native UI and how to do native video rendering).  We’re also gearing up to ship you the source for our new UI shipping in 4.6 (which is currently in open beta) and we’re making plans to open the source to other components as well.

We also announced our Contributor’s Guide that is now part of our user manual.  Today, I’d like to go through those steps with you.

The Steps to Contributing

Our repositories are hosted on BitBucket under either Mercurial or Git.  If you’ve already contributed to a project on GitHub, the process is the same here.  If you’re coming from Perforce or SVN (or some other centralized version control system) and these concepts of ‘forks’ and ‘clones’ and ‘pushing’ and ‘pulling’ are all new to you, we encourage you to follow the steps in the contributor’s guide very closely (since they will guide you along with screenshots every step of the way) and also take advantage of the ‘Further Reading‘ section.

The first thing you need to do is get an account on BitBucket, which is where we are hosting our repositories.  This is a very straightforward process (f you’re completely new to BitBucket, but have a GitHub account, feel free to use that same account over at BitBucket, (EDIT: You need to create a BitBucket account first and connect your GitHub (or Google) account to it.  From then on, you will be able to login to BitBucket with your GitHub (or Google) account) and if you’re wondering why we are on BitBucket instead of GitHub, please see our FAQ.).

Next, you’ll want to make your way over to our home on BitBucket and find the repository you want to contribute to.  Once you’ve done that, you’ll want to fork the repository to your own space.  A fork of a a repository is simply a clone of a repository, that lives under your own space where you are free to push your own changes to.

Clone your fork and apply your changes.  Unless you love getting down and dirty on the command-line, we recommend SourceTree from Atlassian for interacting with both Mercurial and Git.  It will work for you whether you are on Mac or Windows, and whether you are using Mercurial or Git.

Finally, open a pull request from your fork and wait.  A Unity Developer will look at your pull request and process it, and if it’s approved, it will be merged into our repository.

In the end, the process looks like this:
DVCS Overview

What Happens to Pull Requests

When you submit a pull request, generally one of four things can happen:

  1. The pull request is accepted as-is and is merged in its entirety.
  2. The pull request is closed as rejected.
  3. The pull request is not closed as rejected, but the Unity Developer will require that you do some extra work before the change can be merged.
  4. The pull request is rejected, but the Unity Developer still applies some of the changes from the pull request.

Cases 1 and 2 are straightforward.  Case 3 usually means you need to do some cleanup or handle some extra cases.  Case 4 will usually happen if the Unity Developer doesn’t think all of the changes apply, but wants to take some of them, or if the history of the changes needs to be cleaned up before they can be applied.  In our Unity Test Tools project, we’ve already seen cases of 1, 2, and 4.

In all cases, you’ll be notified of activity on your pull request by mail, so be sure you are set up to receive email notifications from BitBucket.

There You Have It

So, in just a few relatively simple and straightforward steps, you can be helping to improve Unity and its ecosystem, both for yourself and the rest of the community!  As I’ve said before, we’re excited to see what you create.

September 15

Web Series: Better Know a Xamarin

You may have met a Xamarin or two at Evolve, developer group, or at one of our other awesome events. However, there are many Xamarins working hard behind the scenes and out in the field around the world to bring you this amazing development platform. Better Know a Xamarin is a new web series that you can find on our YouTube Channel, where we sit down with our fellow Xamarins to see what they do here at Xamarin and what their passions are.


To kick things off, we have four episodes for your enjoyment. So sit back and get ready to Better Know a Xamarin.

Morgan Forsythe - Marketing Operations Manager

Jon Goldberger – Customer Support Engineer

Aaron Bockover - Mac Team Lead

Alex Soto - Software Engineer (Components)

The web series will continue to roll out new videos each week, so be sure to follow our Twitter account or subscribe to our YouTube channel for updates. If you’re interested in joining our growing global team, check out our available positions here.

Want to better know a Xamarin in person? Meet us in Atlanta, Georgia for Xamarin Evolve, October 6th-10th. Register for your ticket to mobile expertise here.

Improved checkin progress

We’ve improved the way in which the checkin progress is handled in the GUI so that it shows more details when the data is transferred through a slow network.

The default checkin scale uses megabytes, but if the network is too slow (sometimes checking in data through the VPN) it is equivalent to not having progress at all.

What we’ve done is to add a secondary progress bar that shows up only when the transfer is too slow. The secondary bar shows the progress of each 4Mb block being transferred. Remember Plastic splits the checkins in 4Mb chunks. The chunks can be just parts of a large file or groups of small files.

The following screencast shows how it works on a network with changing speed (we use WAMEm to modify the network bandwidth and hence overall speed). The example is not realistic but it is helpful to explain the new feature:


The improved checkin progress has been available for a while, since:

  • - Jun 18th 2014
  • - May 19th 2014

September 13

SyncView revisited – improved performance

We’ve improved the performance and usability of the SyncView: it is now able to exclude branches making the sync process much faster.

As you know, the SyncView is the view in the GUI that you can use to preview what needs to be replicated between different servers and then run the replicas.

Excluded branches have been added to improve sync performance

We have added “excluded branches”: branches that you don’t want to sync between your repo and the remote one.

In my case I run a Plastic server on my laptop (using a SQLite backend handling about 18Gb) but I don’t have full replicas of the central repositories. I just pull the branches I need (to develop, code review or manually test tasks before getting them released). It means there are a few thousand branches on the remote server that I’ll never pull. Some of them are already years old.

Since the SyncView calculates all the changesets that need to be pushed or pulled in order to let you preview them, it started to get slow with thousands of branches.

That’s why we added the “excluded branches” feature.

You can select the branches you won’t be syncing and just “exclude them”. The result is that the sync view will be much, much faster, saving precious time on each loop.

We also added an option to show the “excluded branches” so that you can include them again in the calculation in case you need them later on (expanding the excluded branches is way much faster in 5.4 than in 5.0 since we implemented a new server API call in 5.4 to speed up the calculation, while 5.0 API is frozen and can’t take advantage of it).

New behavior in the “refresh” button

Previously the refresh button in the “sync view details” lower panel just affected the expanded repositories. While it wasn’t an issue when you worked with small lists, it wasn’t effective dealing whith long lists like this:

So from now on the “refresh” will trigger the calculation of the entire list of syncs instead of just the expanded ones, while you can still refresh them individually using the context menu.

New “push visible” and “pull visible” buttons

Especially when you’re using Xlinks it is very useful to use the filter to push (or pull) all the branches with a given name, in different repositories.

We’ve added two new buttons: “push visible” and “pull visible” to launch the pull or push of all the branches selected by the filter.

Underlying format change

All the SyncView configuration is stored on a file named syncviews.conf. We’ve modified the file format to make it human readable and better structured than it was before. It will be automatically upgraded by the new 5.0 and 5.4 releases so no user action is required.


This feature has been available since:

  • (August 6th 2014) and later.
  • (Aug 8th 2014) and later.

September 12

Webinar Recording: Get Ready for iOS 8

On September 17th, iOS 8 will launch with over 4,000 new APIs, making it one of the largest iOS releases ever. Xamarin developers can start building for iOS 8 now, with support currently in the alpha channel for App Extensions, TouchID Authentication, PhotoKit, HealthKit, HomeKit, Apple Pay, and more.

In this webinar, Xamarin Developer Evangelist Mike Bluestein provides an overview of the top new and updated APIs, and how to incorporate all of the great new features into your app.

Download the slides for the Get Ready for iOS 8 Webinar here.

Additional Resources

To ensure you get the most out of the exciting changes in iOS 8 using Xamarin and C#, we’ve created an extensive set of resources to help you get started that are outlined in this blog post.

If you’re already registered for Xamarin University, we’ll be debuting a new class on September 17, 2014, that will help you update your apps for iOS 8. If you’re not already registered for Xamarin University, you can learn more about our unlimited, live mobile app development training here.

Lastly, if you are coming to Xamarin Evolve 2014, we will be covering iOS extensively, including iOS 8. If you are not already attending the conference, you can register here.

September 11

Xamarin Evolve 2014 Speaker Spotlight: Laurent Bugnion

This is the fourth post in our Xamarin Evolve 2014 “Speaker Spotlight” series, helping you get to know a little bit more about some of the amazing speakers who will be contributing at this year’s conference.

Photo of Laurent BugnionToday we’re getting to know Laurent Bugnion, the Senior Director of IdentityMine in Zurich, Switzerland. This year will mark his 8th year as a Microsoft Client Development MVP and his second year as a Microsoft Regional Director. He is also the author of the well-known open-source framework MVVMLight for Windows Phone, Windows 8, WPF, and Silverlight. In his free time, Laurent writes for MSDN Magazine and various other publications, as well as on GalaSoft, his blog. Be sure to see Laurent at Xamarin Evolve giving the talk, “Building Cross-Platform Applications with Xamarin, Xamarin.Forms and MVVM Light.”

Why did you get into software development?

I was an electric engineer and started doing low level coding for embedded controllers twenty years ago.


How long have you been doing mobile development?

I started doing programming about 20 years ago and worked on all kind of systems, from embedded controllers to full blown PCs. I am still coding for multiple systems and mobile is, of course, an important part of it. I did some code for the Palm line of devices, but it was more of a hobby. I really started coding professionally for mobile devices when Microsoft released the first Windows Phones.

What is your favorite platform to develop for and why?

After working on many different platforms, I would say that my favorite remains the various XAML/C#. I am able to create UI in XAML that I cannot easily create with other platforms, and XAML/C# is available for many devices, from TVs (XBOX) and phones to computers and tablets. Also the tooling (especially Blend) is just fantastic, especially when you work closely with designers (which I do). Of course, on Android and iOS without XAML, working with C# is nice, too, but I do find the UI on these platforms quite complicated to build for compared to the simple beauty of XAML.

What devices are you carrying around with you right now?

I carry the Nokia Lumia 1020, which is my most trusted companion, all the time. I love this device, especially the amazing pictures it takes, and the large screen.

I also usually carry my Kindle Paperwhite. I love to read and the reading comfort is just fantastic on this device, though I also read on my Lumia when I don’t have my Kindle with me.

I recently fell in love with a Dell Venue Pro 8, on which I installed Windows Pro 8.1. It’s an awesome little device where I can run any Windows application, including legacy ones, and has great battery life.

Finally most of my work is done on my Surface, and I cannot wait to get my new Surface Pro 3 at the end of August!!

What are your favorite mobile apps and why?

I love geolocation, and it still feels somehow magical when an app knows where I am. This can be a huge help, especially when traveling. Also, anything related to photography.

What will attendees get out of your talk?

Users of MVVM Light on Microsoft platforms love it because it isn’t overly complicated and “does the job”. Now, with the possibility to use MVVM Light on Xamarin, too, I want to build a knowledge base for new users. Some of them have never heard of MVVM, some of them know of it but have heard contradictory statements. There is a need for information, and this will help people to switch platforms more easily, as well.

If you missed the earlier posts in this series, click through to read about Jesse LibertyJon Skeet, and Jonathan Peppers.

September 9

Unite 2014 Wrap Up

Another Unite has come and gone and it was amazing! It’s always a great time for us to get out and meet so many of you and have you meet each other. As David Helgason said in the keynote, it’s a great place to make new friends, nurture exciting ideas, and even form new partnerships. It’s an ever evolving industry that we find ourselves in and having friends along for the ride makes it all the better!

Change is constant in such a fast-paced industry and we’re working hard to keep up to meet your needs (hopefully in some cases, even predicting needs). While Unity will be moving in new directions and trying new things as a technology provider, all of our decisions stem from the same mission: democratize game development. To us, it’s summarized as two questions: How will I create my game? How will I connect with an audience? We’re endeavoring to answer those questions and while it’s nearly impossible to fill every need a developer might have, we’re aiming to build the most stable and impressive environment we can for you guys to find success, however you might define it.

In that spirit, David, Joachim, Lucas, Todd, and Jussi kicked the show with a keynote giving the rundown on the industry, Unity and the Unity community’s place in it, and how we’re building Unity as an end to end development platform to address the massive new challenges faced every day by developers.

Check out the full keynote here:

The big takeaways from this year’s Unite keynote were:

  • Unity Cloud Build was announced! It’s a powerful continuous integration service helps you build, test, and share new game projects more quickly. We acquired Austin-based Tsugi to make this happen and created Unity Austin at the same time (they’re hiring)! Better yet, the beta is up and available! Sign up at https://build.cloud.unity3d.com.
  • Unity 4.6 entered public beta! You can now go test out the new UI system for yourself (download here). Tutorials for the Unity 4.6 beta can be found here.
  • Select Unity components will be open source giving you more control to customize components and extend Unity under an unrestrictive MIT/x11 license. The first open source components are the Unity Test Tools and will be followed soon by the new UI system.
  • Unity Everyplay is now integrated in over 700 games with 15M registered users and 6M shared replays. Additionally, new community features are on their way, including social hubs for individual games where developers can take a more active role in discussions.
  • We entered a strategic collaboration with Intel to ensure that mobile developers will be able to bring their games and apps to the new crop of Intel-based Android devices with total ease.
  • We’re collaborating with Google to provide full support in Unity for Google’s Android TV set top box, which is available in the Unity 4.5.3p2 update as part of the Unity Android build.

After the keynote, the event kicked into full gear with an incredible complement of sessions dedicated to helping you all learn about upcoming features in Unity 4.6 and Unity 5 like those talked about in the keynote, best practices from your peers in the development scene that are using Unity, and even more about what we have in store for you down the line. All of the 60 sessions from Unite have been posted online at this point and you can find them here!

We also saw an incredible line-up of games and projects honored at the 2014 Unity Awards.

Each year the bar of quality raises and we couldn’t be in more awe of your abilities and creativity. These amazing finalists and winners along with the hundreds of excellent (and there were many excellent projects not in the finals) projects submitted for the awards this year are what keep us inspired to create the best possible tools for you guys to bend to your creative will.

While Unite 2014 in Seattle was something of a headliner for us as a company this year, Unite isn’t a singular event. We’ve already seen incredible events in China, Japan, Korea, and Taiwan attended by thousands more of our awesome community in Asia. And we’re not done yet! There are two more Unite events taking place this year in October in São Paulo, Brazil and Melbourne, Australia.

brazilaustralia 2014 has, so far, been an amazing year for developers and the games industry in general. Unity is growing and evolving and we hope you’ll all play a big part in what’s ahead! dh2 crowdexhibit roadmap motionleap

awardwinnerslucasscriptingJoachim Ante3Orange Tshirt Guytwo mountains

How to handle big files with Plastic

So it's basically done like any other file!

Plastic is not affected by the file size like other systems out there.

Keep coding while we take care of your files.


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.