.NET Core on ARM

Announcing nightly builds of the .NET Core Runtime for Ubuntu 16.04 on ARM!

January 31, 2017

TL;DR: Nightly builds of the .NET Core Runtime for Ubuntu 16.04 on ARM are available here. These are “Hello World” tested on my Raspberry Pi 2 and Chromebook. Nightly builds of the SDK are expected in the next week or so.

Also, should probably have a disclaimer: these are unofficial builds using the master branch of the dotnet code repositories. This is about as rare / raw / blue as you can get!

Update: official nightlies are available here!

Well this one has been a long time coming! Check the commit history and you’ll see I’ve been working on this on-and-off in my spare time since September!

I first discovered the need for .NET Core on ARM when buying a new laptop. I found that we had 2 x64 devices in the house (one desktop, one laptop), and 6 ARM devices (3 phones, 2 tablets, 1 Chromebook). If the vision of “Any Developer, Any App, Any Platform” is to be realized, it must include ARM.

Wait, what’s an ARM?

Similar to how we have different operating systems, there are many types of CPU architectures. These different architectures have different instruction sets, so just like you can’t run a Windows app natively on OS X, you can’t necessarily run code from one architecture natively on another.

Most desktops, laptops, and servers run on something called x86-64 (or “x64” for short): the 64-bit version of x86. x86 has been around pretty much since the dawn of personal computing.

ARM, on the other hand, is much newer, focusing on mobile and embedded systems, and therefore prioritizing cost, physical footprint, and power efficiency over raw performance.

There’s an almost 100% chance your smartphone runs on an ARM processor. Other well-known devices include the Raspberry Pi (and most other IoT T’s) and many newer entry-level laptops (formerly called “netbooks”), like my Chromebook. Current estimates say there are around 20 billion active ARM devices worldwide. Twenty billion.

OK, what does this all mean?

.NET Core running on both my Chromebook and Raspberry Pi

In short, you can download the .NET Core Runtime here, install it on your Raspberry Pi or Chromebook or any other ARM device on Ubuntu 16.04, and run your .NET Core apps with dotnet .dll!

Once an ARM SDK is available (again, hopefully in the next week or so), and one can run Visual Studio Code and build .NET Core apps on ARM hardware, this significantly decreases the barrier to entry for new .NET developers worldwide, especially in developing markets where low-end devices are much more mainstream.

Some background

Way back when DNX was still a thing, DNX ran fine on ARM, but during the “dotnet” platform consolidation, this was something that was not so easily accomplished. After the 1.0 release, when I started seeing Rich Lander mentioning in responses to various questions that it was unlikely to make it into 1.1, I decided to take things into my own hands.

Ha! Easier said than done.

Many compilers, unit test frameworks, etc. use their own tool to build/test their tool – dogfooding inception, if you will – and likewise, .NET Core uses .NET Core to build .NET Core. But if .NET Core doesn’t exist on ARM, how does one build .NET Core on ARM?

This was the first major roadblock I hit, and while the answer is “cross-compiling,” neither I nor the codebases (yes, plural) were prepared for that.

.NET Core Components

It turns out there are many different components that make up .NET Core. I’ve tried to lay this out, slightly simplified, below:

.NET SDK dependencies

Let’s start at the right and left sides: the Runtime is what allows you to type dotnet .dll to run your app, whereas the SDK provides the developer workflow functionality for dotnet new, dotnet restore, dotnet build, dotnet run, dotnet publish, etc.

The runtime is made up of:

The others:

As you can see from the diagram, the .NET Core SDK is basically the .NET Core Runtime + CLI.


By using CPU emulation – yes, the same thing that lets you play classic video games on modern hardware – we can run applications for other CPU architectures. But even without emulation, just because one architecture can’t run another’s code doesn’t mean it can’t know what that code should be. The process of compiling code for a different target (architecture, platform) other than the one it is being built on is called cross-compilation.

Side note: remember how I mentioned performance was not ARM’s strong point? Compiling CoreCLR on a Raspberry Pi takes about an hour. By cross-compiling it for ARM on my x64 desktop (i7-4770K, 32GB RAM), it builds in about 3 minutes. That’s 20x faster!

As more of the .NET Core components became cross-compile-able, the dream of .NET Core on ARM slowly became more believable, but it really wasn’t until the last month or so that it was able become a reality.

Which brings me to the following:


One thing I want to do is put the spotlight on everyone who has been working on getting .NET Core running on ARM. I think that unless you’re knee-deep in the development of a big feature like this, it’s hard to recognize how much effort goes into something so fundamental. While I’ve largely been on the sidelines – I’ve only submitted a few ARM-related PRs – others have toiled tirelessly over the past few months on getting official support up and running.

Obviously, Microsoft has many teams working on different aspects of .NETCore. Here are those who have helped with ARM PRs:

As mentioned during Connect this year, Samsung is working on having .NET Core be a target for their Tizen-based smart TV apps. These are all the people at Samsung who have ARM-related PRs merged:

* I specifically want to call out Jiyoung Giuliana Yun here, who laid out the process she was using for her own builds, which ended up being the base for turning my scripts from a hacky mess into something more resilient.

Of course, I would be remiss if I did not mention the “volunteer” community. I was hoping that there would be more of this type of participation on the ARM side of things, given how spoiled we seem to be in ASP.NET Core land, but still some very important mentions:

I apologize if I’ve unintentionally left anyone out. Thank you for your great work!

One benefit of software being developed as open-source (aside from being able to mutually benefit off each others’ work) is that it allows us to see the effort that goes into the tools we use every day. It truly does take a village…


Share / Comment