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.

July 29

Asset Previewer

Mobile developers are working with all kinds of graphics assets and until now, to preview them, we would use an external tool to browse them.

We have developed a plug-in for both Visual Studio and Xamarin Studio that will provide live previews of various assets right into the IDE. It works particularly well for UrhoSharp projects.

The previewer can display in the IDE previews of the following asset types.

  • Static Models (*.mdl files)
  • Materials, Skyboxes, Textures (*.dds)
  • Animations (*.ani)
  • 2D and 3D Particles (*.pex)
  • Urho Prefabs (*.xml if the XML is an Urho Prefab)
  • Scenes (*.xml if the XML is an Urho Scene)
  • SDF Fonts (*.sdf)
  • Post-process effects (*.xml if the XML is an Urho RenderPath)
  • Urho UI layouts (*.xml if the XML is an Urho UI).

For Visual Studio, just download the previwer from the Visual Studio Gallery.

For Xamarin Studio, go to Xamarin Studio > Add-ins go to the "Gallery" tab, and search for "Graphics asset previewer" and install.

July 28

Live Webinar | Continuous Everything: Why You Need Mobile DevOps

Join Xamarin VP of Product Keith Ballinger on Thursday, August 11 at 11 am PT / 2 pm ET / 6 pm GMT for his webinar on why you need to implement Mobile DevOps.

Whether you’re a mobile-only startup looking to turn early adopters into evangelists or a multi-million dollar enterprise mobilizing your workforce, you need to ship the right apps, to the right customer, at the right time. You need users to use your apps, turning downloaders into engaged users. To win mobile users’ loyalty, you have to continuously ship high quality software and continuously listen and learn from your users, giving them features before they know they want them. Mobile isn’t just build, release, and done; it’s a continuous cycle of designing, coding, testing, releasing, monitoring, fixing, and improvement. With the right mobile DevOps processes and the right technology, this “continuous everything” is within reach for any organization and all developers.

In this webinar, you will:

  • Hear what Keith learned from his failed startup experience and how you can sidestep common pitfalls to beat your competition
  • Understand how to balance shipping high quality software with speed to market
  • Find out why agile isn’t enough and how mobile DevOps allows you to release faster
  • Learn how to listen to your users, collect feedback, and prioritize new features to ship better apps
  • See how Xamarin Test Cloud and HockeyApp can help any organization get started with mobile DevOps and continuous everything
    Sign up below to join us on Thursday, August 11 at 11 am PT / 2 pm ET / 6 pm GMT.



    The post Live Webinar | Continuous Everything: Why You Need Mobile DevOps appeared first on Xamarin Blog.

    Unity 5.4 is out – here’s what’s in it

    The wait is over, and Unity 5.4 has been released! You can download it here.

    As we announced in March, we’ve put extra resources into beta testing Unity 5.4 so we can deliver the highest level of quality and stability. We couldn’t have done it without the help of our beta users: thank you for your feedback and bug reports! We’d like to show our appreciation and reward for your efforts; for more details, see further down the post.

    As well as spending recent months polishing Unity 5.4, we’ve been hard at work improving Unity 5.3.x to make it a rock-solid platform for the projects you have in production.

    If you’re in a hurry, here’s a quick overview of Unity 5.4:

    • Graphics & rendering performance improvements:
      • Better multithreaded rendering
      • Fewer draw calls with GPU Instancing – available on Windows, OSX, Linux, PlayStation 4, and Xbox One
      • Improved low level graphics features: texture arrays, compute shaders, and more
    • For Artists:
      • Thanks to sizing controls, a new trigger module, and better lighting with Light Probe Proxy Volumes (LPPV) particles are now more customizable.
      • In-engine support for motion vector rendering
    • VR Improvements: more built-in multiplatform VR support and better performance
    • IL2CPP for Android is now an officially supported platform (previously it was labelled ‘experimental’)
    • The editor now supports Mac Retina displays (Windows HiDPI support is in the pipeline) and we’ve added a zoomable game view function (OSX & Windows)
    • Cloud Build setup is now available from the within the editor.  
    • Performance Reporting is now fully integrated in the editor, 1-click activation without plugins or code
    • A major Analytics feature update with Raw Data Export, Heatmaps, Livestream, and Ads data in the dashboard
    • In-App Purchasing now supports the Amazon Appstore
    • Web Player and PS3 Build target options have been removed along with iOS 6 support (we now support iOS 7.x and above)

    Now read on for the details:

    Graphics & rendering performance improvements

    Improved multithreaded rendering

    Unity 5.4 takes our multithreaded rendering support to the next level. Depending on your project and the platform you’re building to, it can significantly improve your frame rate.

    Building on the work we did to take particles, sprites, flares, halos, lines and trails off the main thread in Unity 5.3, we’ve introduced parallel command list generation. Instead of building one graphics command list on the main CPU core scripts used by physics and scripts, work is reallocated to multiple CPU cores, removing potential bottlenecks and enabling complex scenes to run faster.

    Fewer draw calls with GPU instancing

    Fewer draw calls means better performance. By implementing GPU instancing support, we’re allowing you to render vast numbers of identical geometries that share the same materials with very few draw calls.

    GPU instancing support is available on Windows (DX11/12 with Shader Model 4.0 and up), OSX, and Linux (OpenGL 4.1 and up) as well as on PlayStation 4 and Xbox One.More platforms are in the pipeline, so stay tuned.

    The scene contains 3 types of rock mesh. Each rock is tinted with a different gray scale color using a material property block. The first scene uses an instanced version of the standard shader, the second scene uses the built-in standard shader. The data is captured with 5.4 beta on Windows / D3D11, with an Intel Core i7-4980HQ@2.8GHz CPU & an nVidia GeForce GT 750M GPU.

    Improved low level graphics features: texture arrays, compute shaders and more

    If you’re a graphics programmer building your own shaders, 2D Texture Arrays can help you when you’re optimizing large scenes and implementing rendering systems. They work by allowing the GPU to treat 2D textures that share the same size and format as a single object.

    We’ve also improved a series of low-level graphics features. Compute shaders can now be chained together via DispatchIndirect, compute buffer counters have been improved, and debug information can be used for compute shader debugging. You can perform fast texture copies with a new CopyTexture function, and support for uniform arrays as shader parameters has been added. On Metal, OpenGL, and D3D9 platforms we’ve implemented Alpha-to-coverage, and on iOS we now support multithreaded  rendering for Metal graphics. Finally, image effects can be applied on a scene view camera with a new ImageEffectAllowedInSceneView attribute.

    For Artists: Better particle lighting and motion vectors illustrated with improved cinematic image effects

    New particle controls

    Unity 5.4 includes new sizing controls for particles, allowing you to control their width and height independently and to control mesh particles’ full 3D form.

    We’re also rolling out a new trigger module, which allows you to modify particle properties inside a list of colliders. In its simplest form, you can destroy particles when they touch the colliders, but, by using a custom scripting callback, it’s now also possible to modify all particle properties. You can see this in action in the viscous volume effect below.

    Large particle systems can now be lit more realistically with Light Probe Proxy Volumes (“LPPV”).  It’s a way of getting baked lighting information into large dynamic objects that can’t use baked lightmaps.

    LPPV works by generating a 3D grid of interpolated light probes inside a bounding volume and allows you to specify the grid resolution. By doing so, you can add a spatial gradient to probe-lit objects. LPPV isn’t just useful for particles; you can also use it on large dynamic objects.

    Cinematic Image Effects and Motion Vector Support

    Finally let’s not forget about the Cinematic Image Effects (like Screenspace Raytraced Reflections, Depth of Field, Tonemapping and Colour Grading and more) available as an open source package from the Asset Store (and open for contribution on our repo). Cinematic Image Effects were put to good use in our Adam demo.


    In 5.4, we’ve also added motion vector support. Motion vectors track frame-to-frame motion at pixel level, and can be utilized to great effect when creating your own post-processing effects such as motion blur and temporal anti-aliasing. As an example, the current beta of our Cinematic Image Effects package makes good use of this feature to create a convincing motion blur effect:

    More multiplatform VR support and better performance

    Unity 5.4 now includes built-in and optimized rendering support for OpenVR (SteamVR/HTC Vive), Oculus Rift, Gear VR, and Playstation VR platforms. Through a single API you can easily build for multiple platforms with device-specific tweaking kept to a minimum.

    To enable this, we’ve refactored the VR subsystem to eliminate redundant code that duplicated functionalities across VR devices. On the performance side, we’ve added the Optimized Single-Pass Stereo Rendering feature (previously called Double Wide Rendering), so now both viewports are rendered in a single pass, to help sustain high frame rates.

    If you’re looking to get started with VR, these handy tutorials and the associated free assets will help you get up to speed quickly.

    Finally, as announced at Google IO, Unity will be natively supporting the new Daydream platform. If you can’t wait for the native integration, go to the Google developer portal and get the Google Daydream VR Dev Kit for Unity.

    IL2CPP available for Android

    In case you are new to Unity, IL2CPP is our scripting backend that converts IL (Intermediate Language) code from scripts and assemblies in a Unity project to C++ code which is then compiled using platform native compilers. The obvious benefit is a performance gain when Unity runs your scripts (game logic). Introduced with Unity 5.0 and initially implemented for use with WebGL, today IL2CPP is also fully supported on iOS, PS4, and PS Vita, with experimental support available for Windows Store/UWP and Xbox One.

    Furthermore, today we’re excited to announce that we removed the experimental tag from IL2CPP for Android and fully support it!   

    WebGL build times shorter and WebGL 2.0 experimental available

    In 5.4 we’ve focused our energy on reducing build time for WebGL, by caching IL2CPP artifacts and offering an option for using a pre-built runtime components in Development builds, so only user code will need to be rebuilt. Your first build will still take as much time, but subsequent ones will be incremental, hence much faster (and remember that you can easily offload the build to Cloud Build – see below).

    WebGL is fully supported and a viable build target you can use to make web games right now. We’re thrilled to see developers adopting WebGL as a deployment option for their games, for example check out Nordeus’ story about Bringing Top Eleven to WebGL presented at Unite Europe 2016. They provide useful tips to get to WebGL and … [*Spoiler Alert*] announced a +30% increase in revenue!

    We’re also excited also to announce that WebGL 2.0 is available in Unity as an experimental target. While the WebGL 2.0 spec is still a draft and not yet in current releases of the web browsers, you can get a head start with Firefox or Chrome, by enabling it in Unity. Simply uncheck the “Auto Graphics API” property and add “WebGL 2.0” at the top of the list:


    Retina editor support and zoomable game view

    If you’re developing on a Mac with a Retina display, the Unity editor will now look great on your monitor. HiDPI support is also in the pipeline for Windows users.

    Additionally, if you’re developing for a high-resolution target device, the editor game view now allows you to zoom in and out to fit the entire resolution on-screen. It works on both the OSX and Windows versions of the editor.

    Cloud Build setup is now done right from the editor

    With Cloud Build you offload the process of compiling and creating builds across platforms, speeding up iteration time within your team. With Unity 5.4, we’ve simplified setup by enabling Cloud Build config right from the editor. Additionally, you can now view the status of Cloud Build right from the Services tab saving you a roundtrip to the dashboard. Convenient!


    Have a couple more minutes?  Check out this Getting Started video.

    Performance Reporting fully integrated in the editor, 1-click activation

    Unity Performance Reporting automatically collects application errors, across devices and platforms, so you can find and address issues in real time. With Unity 5.4, Performance Reporting come fully integrated in the editor with a 1-click activation. It takes seconds. Watch:

    Error logs will then appear in your developer dashboard:

    This is just the beginning. Performance Reporting aims to be a suite of tools to help you better understand the inner workings of your games. Exception reporting is the first feature we’ve built, but there’s more to come (check our recent blog post for more information).

    Analytics major feature updates: revenue reports, real time events, new heatmaps, raw data export

    We’re rolling out major Unity Analytics feature updates with the release of Unity 5.4. You can view ads revenue and ARPDAU (Average Revenue Per Daily Active User) through the new Analytics Dashboard, track real time game events using the Livestream feature (Unity Plus and Unity Pro only), map critical game metrics of your choice using the new Heatmaps feature, and conveniently download all the data to build customized insights with the Raw Data Export feature (Unity Pro only).

    In-App Purchasing now supports Amazon Appstore

    We’ve added Amazon Appstore support to Unity IAP, our cross-platform in-app purchasing technology. Use Unity IAP to integrate support for multiple stores through one API.

    A fond farewell to the Web Player, PS3 deployment, and iOS 6 support

    As announced previously, and as a consequence of browser vendors’ move to the plug-in-free Web, Unity 5.3 was the final Unity release to support Web Player deployment. You can, of course, continue to use Unity 5.3.x to ship Web Player games should you wish to. But for now, it’s time to look at WebGL!

    Given how quickly iPhone users update to the latest version of iOS (“Games by the Numbers” Q2 2016 report showed 99.2% of iOS game installs on iOS 7.x or above), it makes abundant sense for us to remove iOS 6 from the list of build targets for this release of Unity.

    We’re also moving on with a tear in our eye from supporting PS3 deployment, allowing us to concentrate on helping you build even more great PS4 games.

    Beta users, thank you for testing and submitting bug reports!

    Thank you to everyone participating in the beta program. We want to recognize your effort and thank people who took the time to upgrade their existing projects and report issues. You are using Unity in so many different ways, so regression bugs are the hardest ones for us to catch.

    So, everybody who submitted a valid bug will receive an email to claim their Unity 5.4 beta t-shirt. On top of that, we still have the draw for 100 vouchers for $100 on the Asset Store.
    Watch your inbox!



    Unity 5.5 beta coming soon

    If you’re looking for the Unity 5.5 Beta, never fear, it’s coming soon. While we’re getting it ready, why not take a look at our guide to being an effective Beta tester or check out what’s coming in Unity 5.5 on our Roadmap Page.

    For the full low down on Unity 5.4, check out the release notes.

    New blog launched


    I have set up a new blog in french for growth hacking and maketing. I talked about marketing and hacking and how it can leverage growth of startups and big companies.

    Here is the new blog address:



    J’ai lancé il y a un an déjà mon nouveau blog autour du growth hacking et du marketing. J’y parle de marketing et de hacking et comment en mélangeant les deux, on peut faire croitre les startups et les grosses boites.

    Voila l’adresse:


    July 27

    Power Up Visual Studio Using XAML Power Toys

    Xamarin.Forms makes it fast, easy, and fun to create cross-platform mobile apps for iOS, Android, and Windows. When combined with Visual Studio 2015, the most powerful development environment, developers can be massively productive. From a single IDE, developers can build apps that run on any device, from mobile to IoT devices to the cloud. Apart from being the most powerful development environment, it’s also extremely extensible. There are thousands of extensions available for you to customize Visual Studio to help make you a productive developer. In this blog post, you’ll learn about XAML Power Toys for Visual Studio 2015, which combines the power of Visual Studio and Xamarin.Forms to make building cross-platform mobile apps even easier.

    Getting Started with XAML Power Toys

    The XAML Power Toys for Visual Studio 2015 extension allows developers to rapidly create cross-platform, data-bound, data-entry forms from a view model or entity class. This extension supports all editions of Visual Studio, from Community to Enterprise. To install XAML Power Toys, go to Tools > Extensions & Updates in Visual Studio. From this window, you can search for and install the extension.

    XAML Power Toys

    Generating a Data Entry Form

    XAML Power Toys generates entry data form user interfaces from your models and view models. For simplicity, here is a FriendViewModel that represents an abstraction of the entry form I wish to create:

    public class FriendViewModel : INotifyPropertyChanged
       private string _fullName;
       private string _twitterHandle;
       public String FullName
          get { return _fullName; }
             _fullName = value;
       public String TwitterHandle
          get { return _twitterHandle; }
             _twitterHandle = value;
       public FriendViewModel()
          FullName = "Mayur Tendulkar";
          TwitterHandle = "@mayur_tendulkar";
       public event PropertyChangedEventHandler PropertyChanged;
       protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
          PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));

    Next, before we begin creating our user interface, we need to build our solution. This extension uses reflection to fetch metadata from our view models and models and uses this metadata to give options to generate our user interface. If you don’t build your solution before attempting to use XAML Power Toys, you’ll receive an error like this:

    XAML Power Toys - Build Project

    After building the solution, we can begin using XAML Power Toys by right-clicking inside an empty XAML page.

    XAML Power Toys - Click in XAML

    On the next screen, we can select the view model from which our data entry form user interface will be created.

    XAML Power Toys - Select View Model

    This view model will then be used to help generate the user interface. As highlighted, this allows developers to select controls (e.g. Entry,Image,Switch) and their properties (e.g. Text, PlaceHolder, BindingMode, Source, etc.).

    XAML Power Toys - UI

    Once the basic user interface options are selected, it’s time to select the “root object” for our form. For example, if we’re creating a large form, it makes sense to have our form added to a ScrollView so a user can scroll through them.

    XAML Power Toys - Outer Control.jpg

    Once you click on “Generate UI” button, the required XAML will be generated and automatically added to your page.

    XAML Power Toys - Generated UI

    That’s it! Using XAML Power Toys, we generated a data entry form that runs on iOS, Android, and Windows 10 without having to write any user interface code—just our view model or model. This extension helps to make developers even more productive, especially when building data-driven, CRUD applications.

    Wrapping Up

    Using this extension, it’s easy and fast to generate a user interface using models in Xamarin.Forms applications. Karl Shifflett, the author of this extension, has made this extension open source and has published video tutorials, which can be found here.

    The post Power Up Visual Studio Using XAML Power Toys appeared first on Xamarin Blog.

    July 26

    Learn How Xamarin Customers Ship Five-Star Apps

    Today, we’re happy to announce our new Xamarin Customers website, which highlights our global customers across verticals, use cases, and geographies. From indie developers building their first app to multi-million dollar organizations with hundreds of apps in the pipeline, our customers are creating amazing mobile experiences. To recognize their success, we’ve captured more than 25 customer stories across 12 verticals.

    Xamarin Customer logo wall

    It’s easier than ever to deliver amazing Xamarin apps for any scenario:

    • Pinterest uses Xamarin Test Cloud to delight Pinners everywhere, guaranteeing its apps look amazing and work without issue on any device for over 100 million users.
    • Coca-Cola Bottling Co. Consolidated is transforming their business with anywhere, anytime accessible field sales apps powered by Xamarin for Visual Studio, Azure, and Visual Studio Team Services.

    Our partners play a big role in our customers’ mobile strategy:

    • Info Support took home the 2016 Enterprise Xammy Award for their work with Dutch Railways, creating apps that equip Dutch Railways’ staff to better serve its over 1.1 million daily passengers.
    • Escher Group paired their Xamarin development skills with JudoPayments’ Xamarin SDK to rewrite Ireland’s largest coffee chain’s loyalty apps in C#, resulting in a better customer experience, incorporating technologies like Apple Pay to drive more revenue.

    Visit xamarin.com/customers to explore our customer stories, and contact us to share your own.

    The post Learn How Xamarin Customers Ship Five-Star Apps appeared first on Xamarin Blog.

    IL2CPP Optimizations: Devirtualization

    The scripting virtual machine team at Unity is always looking for ways to make your code run faster. This is the first post in a three part miniseries about a few micro-optimizations performed by the IL2CPP AOT compiler, and how you can take advantage of them. While nothing here will make code run two or three times as fast, these small optimizations can help in important parts of a game, and we hope they give you some insight into how your code is executing.

    Modern compilers are excellent at performing many optimizations to improve run time code performance. As developers, we can often help our compilers by making information we know about the code explicit to the compiler. Today we’ll explore one micro-optimization for IL2CPP in some detail, and see how it might improve the performance of your existing code.


    There is no other way to say it, virtual method calls are always more expensive than direct method calls. We’ve been working on some performance improvements in the libil2cpp runtime library to cut back the overhead of virtual method calls (more on this in the next post), but they still require a runtime lookup of some sort. The compiler cannot know which method will be called at run time – or can it?

    Devirtualization is a common compiler optimization tactic which changes a virtual method call into a direct method call. A compiler might apply this tactic when it can prove exactly which actual method will be called at compile time. Unfortunately, this fact can often be difficult to prove, as the compiler does not always see the entire code base. But when it is possible, it can make virtual method calls much faster.

    The canonical example

    As a young developer, I learned about virtual methods with a rather contrived animal example. This code might be familiar to you as well:

    public abstract class Animal {
      public abstract string Speak();
    public class Cow : Animal {
       public override string Speak() {
           return "Moo";
    public class Pig : Animal {
        public override string Speak() {
            return "Oink";

    Then in Unity (version 5.3.5) we can use these classes to make a small farm:

    public class Farm: MonoBehaviour {
       void Start () {
           Animal[] animals = new Animal[] {new Cow(), new Pig()};
           foreach (var animal in animals)
               Debug.LogFormat("Some animal says '{0}'", animal.Speak());
           var cow = new Cow();
           Debug.LogFormat("The cow says '{0}'", cow.Speak());

    Here each call to Speak is a virtual method call. Let’s see if we can convince IL2CPP to devirtualize any of these method calls to improve their performance.

    Generated C++ code isn’t too bad

    One of the features of IL2CPP I like is that it generates C++ code instead of assembly code. Sure, this code doesn’t look like C++ code you would write by hand, but it is much easier to understand than assembly. Let’s see the generated code for the body of that foreach loop:

    // Set up a local variable to point to the animal array
    AnimalU5BU5D_t2837741914* L_5 = V_2;
    int32_t L_6 = V_3;
    int32_t L_7 = L_6;
    // Get the current animal from the array
    V_1 = ((L_5)->GetAt(static_cast<il2cpp_array_size_t>(L_7)));
    Animal_t3277885659 * L_9 = V_1;
    // Call the Speak method
    String_t* L_10 = VirtFuncInvoker0< String_t* >::Invoke(4 /* System.String AssemblyCSharp.Animal::Speak() */, L_9);

    I’ve removed a bit of the generated code to simplify things. See that ugly call to Invoke? It is going to lookup the proper virtual method in the vtable and then call it. This vtable lookup will be slower than a direct function call, but that is understandable. The Animal could be a Cow or a Pig, or some other derived type.

    Let’s look at the generated code for the second call to Debug.LogFormat, which is more like a direct method call:

    // Create a new cow
    Cow_t1312235562 * L_14 = (Cow_t1312235562 *)il2cpp_codegen_object_new(Cow_t1312235562_il2cpp_TypeInfo_var);
    Cow__ctor_m2285919473(L_14, /*hidden argument*/NULL);
    V_4 = L_14;
    Cow_t1312235562 * L_16 = V_4;
    // Call the Speak method
    String_t* L_17 = VirtFuncInvoker0< String_t* >::Invoke(4 /* System.String AssemblyCSharp.Cow::Speak() */, L_16);

    Even in this case we are still making the virtual method call! IL2CPP is pretty conservative with optimizations, preferring to ensure correctness in most cases. Since it does not do enough whole-program analysis to be sure that this can be a direct call, it opts for the safer (and slower) virtual method call.

    Suppose we know that there are no other types of cows on our farm, so no type will ever derive from Cow. If we make this knowledge explicit to the compiler, we can get a better result. Let’s change the class to be defined like this:

    public sealed class Cow : Animal {
       public override string Speak() {
           return "Moo";

    The sealed keyword tells the compiler that no one can derive from Cow (sealed could also be used directly on the Speak method). Now IL2CPP will have the confidence to make a direct method call:

    // Create a new cow
    Cow_t1312235562 * L_14 = (Cow_t1312235562 *)il2cpp_codegen_object_new(Cow_t1312235562_il2cpp_TypeInfo_var);
    Cow__ctor_m2285919473(L_14, /*hidden argument*/NULL);
    V_4 = L_14;
    Cow_t1312235562 * L_16 = V_4;
    // Look ma, no virtual call!
    String_t* L_17 = Cow_Speak_m1607867742(L_16, /*hidden argument*/NULL);

    The call to Speak here will not be unnecessarily slow, since we’ve been very explicit with the compiler and allowed it to optimize with confidence.

    This kind of optimization won’t make your game incredibly faster, but it is a good practice to express any assumptions you have about the code in the code, both for future human readers of that code and for compilers. If you are compiling with IL2CPP, I encourage you to peruse the generated C++ code in your project and see what else you might find!

    Next time we’ll discuss why virtual method calls are expensive, and what we are doing to make them faster.

    July 25

    Preview: Android Nougat is on the Way

    Today, we’re excited to release a new version of our Android N Developer Preview, which features bindings to the final APIs of the Android N SDK. The new version includes several exciting features including multi-window UI, direct reply notifications, advanced memory and power optimizations, and more for developers to integrate into their applications.

    Android N Hero

    Get Started

    Start the Android SDK Manager:

    • Xamarin Studio, use Tools > Open Android SDK Manager
    • Visual Studio, use Tools > Android > Android SDK Manager

    Install the latest Android SDK tools; these are listed under Tools:


    Install Android Nougat (API 24) SDKs and Device Images:

    You must install Android SDK Tools revision 25.1.7 or later, SDK Platform-tools 24 or later, and SDK Build-tools 24.0.1. For more information about using the Android SDK Manager to install the Android SDK, see SDK Manager.

    Finally, download the latest preview Xamarin.Android packages for Visual Studio or Xamarin Studio.

    When is Nougat coming out?

    As of this posting, the final release of Android N Developer preview has been released and developers can start publishing apps to devices running Android N at the official API level if your users have opted into the Android Beta program. This will have your app ready for Android N when it is officially released later this year in Q3. Head over to Google’s preview overview page for more details.

    Google’s Android N Timeline
    Android N Updates

    Important Behavior Changes

    Android N introduces several behavior changes that could impact your application. These include new Doze optimizations for battery and memory improvements, background optimizations (including the deprecation of the CONNECTIVITY_ACTION broadcast), permissions changes, and several others that you can read about on the Android N preview portal. One of the more substantial changes to the platform is a new restriction of applications using non-public APIs such as SQLite, libcrypto, and many more. Be sure to test your application and libraries on Android N to ensure compatibility.

    Learn More

    Head over to our Xamarin Android N Developer Preview guide to read up on all of the latest features and for the latest downloads of our Android N Preview for Xamarin developers. Then be sure to check out our Android N samples on GitHub.

    The post Preview: Android Nougat is on the Way appeared first on Xamarin Blog.

    July 22

    New Xamarin Dev Days Cities Announced!

    Last year, hundreds of developers joined us at Xamarin Dev Days in dozens of cities around the US to learn cross-platform mobile development. The events were such a success that we’re bringing it back this year and taking it global! The first Xamarin Dev Days of 2016 in Milan and Mexico City were great, with a full house at both locations, where every developer went home with a goodie bag and tangible knowledge of how to build, test, and monitor native iOS, Android, and Windows apps with Xamarin.

    XDD Milan 2016

    What are Dev Days?

    Screen Shot 2016-07-22 at 13.19.22Xamarin Dev Days are community run, hands-on learning experiences. More than just your average hackathon, they are free, day-long events focused around learning how to build native iOS, Android, and Windows apps with C#, Xamarin, and partner technology through valuable sessions from Xamarin, our partners, or your local developer community leaders.

    After a morning of learning how to build beautiful, cloud-connected mobile apps with Xamarin, you’ll get a chance to put your new knowledge into practice with a hands-on workshop that walks you through the process of building your first cloud-connected, cross-platform mobile app. Xamarin experts will be there to help you get up and running, debug code, and answer any questions you may have.


    Announcing More Cities!

    8/06: Gurgaon, India
    8/09: Ho Chi Minh City, Vietnam
    8/20: Washington, DC
    8/20: Kuala Lumpar, Malaysia
    8/20: San Francisco, California
    8/20: Bangalore, India
    8/27: New York, NY
    8/27: Kochi, India
    9/03: Kolkata, India
    9/03: Brisbane, Australia
    9/10: Sevilla, Spain
    9/16: Pisa, Italy
    9/17: Hyderabad, India
    9/17: Kitchener, Canada
    9/24: Thiruvananthapuram, India
    9/24: Curitiba, Brazil
    9/24: Montreal, Canada
    9/30: Bristol, UK
    10/15: Houston, TX
    10/29: Strasbourg, France

    Use the map below to find an event near you, or head on over to our Xamarin Dev Days website for a full list of current Xamarin Dev Days cities around the world.


    Get a Xamarin Dev Days in Your City

    If you didn’t see a city near you on the map but are interested in organizing an event locally, apply as a Xamarin Dev Days host! We’ll provide you with everything you need for a fantastic Dev Days event in your town, including all of the speaker content and lab walkthrough, a hosting checklist, and swag goodies to give away to all of your attendees.

    Sponsoring Xamarin Dev Days

    We’re working with tons of Xamarin Partners and community members’ companies around the world to help facilitate Xamarin Dev Days. If your company is interested in participating, apply to be a sponsor and get global recognition as a Xamarin Dev Days contributor, as well as access to our worldwide developer community.

    The post New Xamarin Dev Days Cities Announced! appeared first on Xamarin Blog.

    In Development – Unity Splash Screen tools

    As you saw in our recent pricing announcements, part of our new structure allows you as a Plus or Pro subscriber to disable the Splash Screen feature of Unity. In addition to this we wanted to provide a set of simple tools to let you display a co-branded splash screen with animation, for those of you that do wish to use them.

    As we still require Personal Edition users to show a Unity splash screen for now, these tools will also be available and become the default method of showing the Made with Unity splash. The tools are still in development, and are currently aimed to be part of Unity 5.5. Check out the video above for what they look like in practice, and please provide us with feedback in the comments below.

    Pre-emptive Questions and Answers

    Q. Why not offer the shiny cube animation video we’ve seen from Unity recently?

    A. This is a pre-rendered video clip that we may consider including for platforms it would make sense to include in (Desktop and Console) in future versions of the splash screen, but for now we wanted a light-weight simple system that everyone could use – or if on Plus/Pro – opt out of.

    Q. Aliasing looks funky on the MWU logo in the video?

    A. Yes, a little – because we are yet to implement AA for the splash – its in development, and we’ll work on the quality up til release.

    Q. What’s to stop me as a Personal edition user from having a dark background with a dark unity logo?

    A. We include the Overlay opacity as a mandatory feature on Personal edition, plus you’d be rendering at least 2 seconds of needless blank screen to try and circumvent the splash screen.

    Q. This is cool, but why no nested prefabs?

    A. Actually completely unrelated teams are working on features like this, and nested prefabs. We actually have solid ideas on how to achieve what is necessary for nested prefabs now and our core team are migrating from improving asset bundles to working full-time on this feature.

    Q. Are there any Pokémon here? I heard there were Pokémon here.

    A. Probably.

    July 21

    Introducing Stack Overflow Documentation

    Xamarin and Microsoft are excited to be a part of the launch of Stack Overflow Documentation. This new feature brings the same collaborative approach from Stack Overflow’s question-and-answer system to developer documentation.
    stackoverflow documentation

    Stack Overflow Documentation provides a set of edit and review tools that lets the community write example-focused documentation to complement our existing developer portal and samples at developer.xamarin.com. Stack Overflow badges and reputation are supported, so every contribution you make is recognized; the more docs you contribute, the more rep you earn!

    How does it work?

    The new site will be organized by Stack Overflow tags (such as Xamarin.iOS and Xamarin.Android) which will contain documentation topics with many examples.

    Browsing the documentation is as easy as using Stack Overflow: you can navigate by tag, topic, or search. If you can’t find the documentation you’re looking for, suggest someone write it (or if you know about a particular subject, write it yourself).

    How to Contribute

    Stack Overflow users can:

    • Suggest topics that they would like to see documented, for others to write.
    • Create a topic they are knowledgeable on, and immediately add examples.
    • Add examples to existing topics.

    Each topic can have a number of examples to demonstrate how to accomplish different tasks. Examples can have the following four elements:

    • Examples: Topics should always include working code examples.
    • Syntax: Add method signatures if they aren’t obvious.
    • Parameters: Explain what parameters are for and any constraints they must adhere to.
    • Remarks: Describe any additional rules or pitfalls that aren’t covered in the code examples.

    Submissions will be peer-reviewed; the site includes the ability to share drafts and chat with other contributors before an example is published.

    Get Started

    Xamarin tags are set up and ready for contributions, as this screenshot demonstrates:

    Xamarin.iOS on Stack Overflow Documentation

    We’re excited to see what great examples our developer community create and share!

    Visit stackoverflow.com/documentation to get started today.

    The post Introducing Stack Overflow Documentation appeared first on Xamarin Blog.

    July 20

    Build C# and F# Apps on Your iPad with Continuous Mobile Development Environment

    It doesn’t matter if you’re on a Windows or a macOS machine, you have access to amazing IDEs to build iOS, Android, Mac, and Windows apps and libraries with Visual Studio and Xamarin Studio. But, what if you could take all of your code on the go and with you everywhere you go? What if you could open up a code file, library, or Xamarin.Forms project on your iPad and start coding with a full professional mobile development environment with IntelliSense powered by Roslyn? That’s the experience that Frank Krueger, Xamarin MVP, delivers with his new app, Continuous Mobile Development Environment, a professional C# and F# IDE for your iOS devices.


    Built with Xamarin

    Frank Krueger has been developing apps with Xamarin since it first came out. He’s seen great success as an independent developer with apps including iCircuit and Calca. Continuous demonstrates the full potential that’s unlocked for .NET developers through Xamarin, with full API access across all platforms and the power of .NET.

    Powered by Open Source

    Powered by the open source .NET compiler platform as a service Roslyn, Continuous offers full syntax highlighting and code completion as well as documentation for over 60,000 symbols. Krueger was able to deliver rich F# support with the open source FSharp Compiler, and to bring Continuous full circle and deliver support for .NET’s standard library, all iOS APIs, and support for Xamarin.Forms, it leverages Mono and the now open sourced Xamarin.iOS and Xamarin.Forms. It’s amazing to see what can be built with these open source technologies!


    Professional Development Environment

    As a professional development environment, Continuous is lightning fast, has an interactive output window to see your app running live, automatic and constant debugging, and works completely offline. If that wasn’t enough, Continuous deeply integrates into iOS features and has a custom keyboard accessory for quick access to much needed keys for C# and F# development. Continuous doesn’t stop there, though—it also enables developers to carry on development in your favor desktop IDEs, Visual Studio and Xamarin Studio. You can share a single file, zip an entire solution, or collaborate with other iOS apps to synchronize with Git.

    Try Continuous Yourself

    You can learn more about Continuous at continuous.code and learn more about its development and release on Krueger’s blog. We want to congratulate Frank on his release of Continuous; we can’t wait to see what he and all developers building apps with Xamarin come up with next. To learn more about all of the open source projects at Xamarin, visit open.xamarin.com

    The post Build C# and F# Apps on Your iPad with Continuous Mobile Development Environment appeared first on Xamarin Blog.

    Games by the Numbers (2016 Q2): BRIC Countries Dominate Global Mobile Game Installs

    The Q2 2016 edition of the “Games by the Numbers” report is now available! This quarterly report reveals global game install trends across different platforms, devices and regions.

    Unity by the Numbers - 2016 - Infographic1-Final

    Key highlights from this report include:

    • The BRIC countries, Brazil, Russia, India and China, accounted for four of the top five global game install leaders with 41% of the total and 42% of Android. Four of the top five Android mobile device manufacturers for BRIC countries are from China.
    • Android achieved near total dominance in Indonesia, with 96% of total game installs, surpassing the Republic of Korea and Brazil (Q1 2016 leaders, each with 92%).
    • Marshmallow (6.0 or later), released in October 2015, gained significant traction over the last quarter, jumping over 4.5X to 7.5% of installs globally, likely a result of all the major device manufacturers kicking off rollouts of Marshmallow on their devices.  
    • iOS showed more consolidation with 78% (vs 72% in Q1) of installs occurring on devices running iOS 9.0 (released September 2015) or later.

    This marks the third data report developed in conjunction with the Unity Analytics team and is based on the anonymized data of the 238K Made with Unity games which generated 4.4B installs from 1.7B unique devices in Q2 2016. To see all the insights and trends, download the full report:


    More Information:


    Report version history

    April 2016, Second edition covers Q1 2016 

    Sept 2015, First edition covers April-July 2015


    July 19

    Explore iOS 10, tvOS 10, watchOS 3, and macOS Sierra Previews Today

    Apple announced major updates to all of their operating systems and a smattering of new APIs for developers to explore at this year’s WWDC conference. sdk-icon-90x90_2xWe are excited for Xamarin developers to get their hands on these new APIs to start building beautiful native apps in C#, so today, we’re releasing our first set of previews for developers to start exploring iOS 10, tvOS 10, watchOS 3, and macOS Sierra along with supporting Xamarin-specific documentation to get you started.

    iOS 10

    iOS 10 has something for everyone. SiriKit unleashes the power of Siri for developers to integrate unique experiences into their mobile applications to enhance a slew of services. Notifications have been completely overhauled to schedule notifications based on geo-fencing or time and a new UI framework to allow enhanced customization has been added. This is just that start, as there are new APIs unlocked in HealthKit, HomeKit, Core motion, Foundation, Core Data, and many more as well. To get started, browse through our Introduction to iOS 10 documentation.


    tvOS 10

    Bring your apps to life on the big screen with the latest additions to tvOS including ReplayKit to live broadcast game play, PhotoKit to share photos with iCloud Photo Library and your apps, and easily integrate multipeer connectivity to your iOS apps. To get started, check out our Introduction to tvOS 10 documentation.

    watchOS 3

    Take advantage of the latest watchOS release, which dramatically speeds up performance and navigation of all apps. Performance is one thing, but there are also several new APIs to play with, including Fitness and Motion with access to real-time heart rate data, gyroscope, and accelerator. Enhance your existing apps with direct access to the Digital Crown, speaker audio, in-line video, SpriteKit, SceneKit, Apple Pay, and camera data from HomeKit-enabled accessories! You can get started today with our Introduction to watchOS 3 documentation.

    *This initial release of watchOS 3 has a subset of the final APIs that will be available in the future.

    macOS Sierra

    hero-macos_medium_2xThese Apple previews aren’t just about mobile devices, as you can also start integrating the latest APIs in macOS Sierra (10.12) into your Xamarin.Mac applications. Our Introduction to macOS Sierra documentation is a great place to start.

    Installing the Previews

    You can download the Previews for Xamarin Studio on macOS directly from the Xamarin Developer site for each OS: iOS 10, tvOS 10, watchOS 3, and macOS Sierra. You will need to ensure that you have the latest Xcode 8 Beta installed, which can be run on macOS 10.11.5 (El Capitan) or newer for iOS, tvOS, and watchOS, and macOS Sierra for macOS Sierra development. Upcoming previews will add even more support for these platforms, including support for Visual Studio.

    The post Explore iOS 10, tvOS 10, watchOS 3, and macOS Sierra Previews Today appeared first on Xamarin Blog.

    Made with Unity Showcase at Unite 16 & The Revamped Madewith.unity.com!

    Made with Unity has been a really bright spot for us for many reasons this past year. It’s invigorating for all of us to really see just how many incredible games are being made with Unity! A big part of that visibility has been due to madewith.unity.com which we launched last year. We’re very happy to announce that we’ve launched the next iteration of the site today, but before we get into more detail about that…

    One of the newest (and super bestest, by our calculations) additions to the global Unite line-up has been the Made with Unity Showcases. We’re very happy with how positively they’ve been received both by show attendees and the participants and they’ve quickly become an integral part of the events.


    Made with Unity Showcase @ Unite Europe ’16

    So, to go along with the unveiling of the madewith.unity.com site redesign, we’re also announcing that open submissions have begun for the Unite Los Angeles Made with Unity Showcase! Once again, we’ll be looking to include a variety of games and other projects that show off the breadth of awesome experiences being made by the community.

    All you need to do is fill out the submission form and sign up for a profile on madewith.unity.com if you haven’t already done that. If you haven’t announced your game yet and can’t sign up for a profile, feel free to submit anyway, we can take care of signing up later.

    Open submissions will close on August 14th at midnight PDT, so make sure to get your submissions in by then.




    The New Madewith.unity.com

    After you’ve signed up, you’ll hopefully have noticed some sweeping changes to the layout, design, and how we’re showcasing your content on madewith.unity.com.  We hope you like the new look!  Here’s a quick rundown of the highlighted changes to the site and how you can get started to create your profile and publish your own story.  

    Front Page1


    Overall Improvements and Bug Fixes

    Our primary goal was to take in the overall feedback over the past year and make this an easier experience to share stories and create profiles.  To accomplish this, we rewrote the codebase and focused a lot of attention on making the CMS easier to work with and the process to create a profile a bit easier to digest.  

    The good news is, this code rewrite makes it easier for us to update the site and make fast changes if common issues rear their ugly heads.  We’ll continue to listen to you to make this a reliable experience for you.  If you run into any issues as an existing profile owner or new user, please let us know in the forum!

    Games Gallery and Stories Library

    We also  wanted to improve the way you browse and find new games developed by Unity devs everywhere.  The new layout allows us the opportunity to showcase many of your games by category, themes, or any way we want really.  In turn, that gives us the ability to show off more of your content to everyone.  

    We’ve added the much needed search option throughout the site so you can find a story or game based on a specific tag, keyword, or platform.  Slowly but surely, we’re growing the site to make it easier to find your interests, discover new ideas, and keep track of dev updates and announcements.  


    Updated Game Profiles

    Another area of focus was to improve the ability for devs to showcase their work on the site.  Your game profile pages are updated to show off more of what you’re working on, including an option for release dates and an updated tagging system to allow for more relevant related games.  We invite you to use this as a resource for you to show all your story announcements, blog updates, and media with everyone should you need it.  

    In addition to that, you may have observed the new Weekly Top 10 on the front page.  We’re using this to highlight the most active game profiles of the week.  You may be asking how you get on this prestigious list. It’s a mixture of how many stories related to the game you’re posting, how much the article is shared, and how many people have read those stories and viewed your profile within the given period.  Put simply:  post awesome updates, share your awesome stories, and actively promote each other.


    Share Your Story!

    Over the past several months, we’ve seen some amazing stories and insights from Unity developers around the world.  We’re well over 300 crowd-sourced articles from the community in under a year!  It’s been awesome to see the site take shape with such varied perspectives and creatives ideas.  

    Our goal remains the same as when we originally launched the site.  To make this a place for every Unity developer to express their ideas to a global audience, inspire and educate others, and be a central resource for what’s going on in the community so press and media to see what’s going on.  

    Whether those stories are about experimentation with new concepts in VRa director’s commentary inside look on your upcoming game, tips and tricks, or even failures encountered that taught you important lessons you feel are valuable to the community, we want this to be a place can read about all the hard work that goes into game development. When you’re ready to write a story yourself, check out our quick guidelines to help get you started.

    Do you already have a profile?

    All stories and profiles have been migrated to the new site.  We’ve done a lot to make sure we haven’t negatively impacted your content but some edge cases may have slipped through.  To combat that we’ve created an Update FAQ for you madewith.unity.com veterans and some tips to help make sure your migrated profile looks great.  If you encounter any issues or something isn’t looking quite right, let us know in the forum.  The easiest solution is to log in, edit your profile, and walk through the new steps to make sure everything is 100%.

    What’s Next?

    Now that the overall redesign is in the wild, we can continue our focus on more functional additions for you.  Comments, statistical data, and more ways for readers to interact and provide feedback are definitely on our mind.  We’ll be listening to your feedback closely as always.  

    So go ahead and apply for the Unite 16 showcase, create a profile, share what you’re working on.  With your continued support and participation we can’t wait to continue to grow Made with Unity as a developer resource and to aid discovery.

    July 18

    Podcast: Tools for Creating & Designing Five Star Apps

    This week on the Xamarin Podcast, Mike James and I share the tools and processes we use to create and design beautiful, five-star cross-platform apps, including Sketch, Zeplin, Paintcode, and Bitrise.

    Subscribe or Download Today

    Knowing the latest in .NET, C#, and Xamarin is easier than ever with the Xamarin Podcast! The Xamarin Podcast is available from iTunes, Google Play Music, and SoundCloud. Do you have an interesting story, project, or advice for other .NET mobile developers? If so, we’d love to share it with the Xamarin community! Tweet @pierceboggan or @MikeCodesDotNet to share your blog posts, projects, and anything else you think other mobile developers would find interesting. Be sure to download today’s episode tools for creating and designing five star apps, and don’t forget to subscribe!

    The post Podcast: Tools for Creating & Designing Five Star Apps appeared first on Xamarin Blog.

    July 15

    Contest: Add an Azure Backend to Your Mobile App

    All apps need a backend, and Azure Mobile Apps makes it simple to add a backend to your mobile application. From no-code backends with Azure Easy Tables to full .NET backends with ASP.NET Web API, Azure has a backend for any kind of mobile app. Once you’ve built your backend, it’s time to consume it from a mobile app, and thanks to the App Service Helpers library, adding a backend to your mobile app can be done in as little as four lines of code.

    In this contest, we invite you to add an Azure Mobile Apps backend to your app to win a Xamarin t-shirt!

    How to Enter

    1. Create a new Azure Mobile App:

    2. Connect your mobile app to the cloud.

    3. Tweet a short video clip of your Xamarin app connected to an Azure Mobile Apps backend with the hashtags:

    • #Xamarin AND #AzureMobile

    Xamarin T-Shirts

    Pro Tip: Easily add a no-code backend to your mobile app with just four lines of code in five to ten minutes with App Service Helpers, or follow our guides on adding a backend with Azure Easy Table.


    All submissions must be made by Monday, July 25 at 12 pm EST. A valid entry consists of a tweet containing the hashtags #Xamarin AND #AzureMobile, along with a short video clip of your app connecting to an Azure Mobile Apps backend. A valid entry will win one Xamarin t-shirt. Limit one entry per person. To be eligible, you must follow @XamarinHQ to enable us to DM you for private follow up. Please allow up to three weeks for us to verify entries and collect shipping information to send your Xamarin t-shirt. There is no purchase necessary to enter the “Add an Azure Backend To Your Mobile App” contest.

    The post Contest: Add an Azure Backend to Your Mobile App appeared first on Xamarin Blog.


    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.