iOS and Android Programming with Go

By Chris Ward

Using Android Studio? Download our Handy Cheat Sheet of Keyboard Shortcuts!

Whilst not a new language, Go has gained a lot of interest over the past two years and the number of bigger name projects utilizing the language is growing rapidly. I wrote an introductory article on the language for SitePoint and came across mentions of mobile support, so thought I’d take a look at the possibilities.

I was most excited to see what Go support on Android was like as they are both Google technologies and there have been rumblings of support from developers for a language to replace Java.

Getting Started

You will need GoLang 1.5+ installed.

Next install the GoMobile tool which compiles and runs pre-existing Go applications for Android and iOS:

go get
gomobile init

We will be referring to the example applications shipped with the gomobile package in GoLangInstalldir/src/ If you don’t have them installed, fetch them with this command:

go get -d

Build and Install a Native Go Application

For many application use cases, compiling Go to a native application and ignoring platform libraries and interfaces may be fine. If so it’s simple to compile your existing Go code, with a subset of functionality available. This includes:

  • App control and configuration
  • OpenGL ES 2 bindings
  • Asset management
  • Event management
  • Experimental packages include OpenAL bindings, audio, font, sprite and motion sensors

We will be using one of the pre-existing gomobile examples to step through the process, but these can be replaced with your own project files.


Build an Android APK

gomobile build -target=android

Deploy to a Device

gomobile install


Build an iOS IPA

gomobile build -target=ios

Deploy to a device

There is no equivalent command for deployment on iOS as on Android, so after creating the app above you will have to follow your own personal favorite way of copying it to a device or emulator, such as the ios-deploy tool.

For something a bit more exciting, also try the steps above with the example.

Let’s take a look inside the audio example (I wont reproduce the complete code here) and you don’t need to be overly familiar with GoLang (I’m not), this is more about looking at what is possible.

Firstly you see a set of import statements:

import (

If you dig around the folders and files that are imported in GoLangInstalldir/src/* you will notice the various Java and Objective-C files that are compiled with your code.

Digging further you will see references to some of the classes imported and used in the code, such as app and glctx.

Going Native

We can code in Go and build a compact and optimized native app, but it’s not very ‘native-like’ right now, as all the required support libraries are only available in Java and Objective-C / Swift. How can we improve this experience?

The Go Mobile team have created another option, using go packages (your applications) inside a native application. Perfect for sharing some common Go code and binding to native code. It’s easy to get started, but may be complex to maintain in the long run.


If you’re using Android Studio, import the reference project from GoLangInstalldir/src/ and open the build.grade (Module: hello) file to update your GOPATH and GO paths, here are mine (I installed GoLang with Homebrew):


Sync Gradle and the application is then deployable to an emulator or device.

Note: Currently this is only supported on ARM based devices and emulators.

Let’s look at the Java and Go code:

package org.golang.example.bind;

import android.os.Bundle;
import android.widget.TextView;

import go.hello.Hello;

public class MainActivity extends Activity {

    private TextView mTextView;

    protected void onCreate(Bundle savedInstanceState) {
        mTextView = (TextView) findViewById(;

        // Call Go function.
        String greetings = Hello.Greetings("Android and Gopher");


package hello

import "fmt"

func Greetings(name string) string {
    return fmt.Sprintf("Hello, %s!", name)

The go file is imported with import go.hello.Hello and the Greetings function within it accessible in the Java file via Hello.Greetings. With not too many extra steps, bindings between go functions and native UI elements are possible.


Binding an iOS application to Go requires different steps. First execute the following commands:

cd GoLang_Install_dir/src/
gomobile bind -target=ios

This will create a framework bundle called Hello.framework in the current folder that we can use in our project.

Open the sample iOS project found at GoLangInstalldir/src/ in Xcode and drag Hello.framework into the project, checking Copy items if needed. This should result in the following folder structure:

Go in Xcode

Build and run the application which, much like the Android app, calls Go methods into Objective-C code.

Let’s look at the code:

#import "ViewController.h"
#import "hello/Hello.h"  // Gomobile bind generated header file in hello.framework

@interface ViewController ()

@implementation ViewController

@synthesize textLabel;

- (void)loadView {
    [super loadView];
    textLabel.text = GoHelloGreetings(@"iOS and Gopher");


#import "hello/Hello.h" imports the framework file generated earlier and textLabel.text = GoHelloGreetings(@"iOS and Gopher"); calls the function it exposes to set a label variable.

It’s possible to use the same auto-generated Objective-C framework file in a Swift based project and then use something like:

let msg = Hello.GoHelloGreetings("gopher")

Is It worth It?

Well, in short, probably not. If you’re already programming your applications in Go and you’re OK with non-native looking interfaces then there’s nothing stopping you, as you can see it’s easy to build and deploy native applications written in Go. If you’re willing to take the extra steps to follow the binding option then you can take things a lot further, but still within certain limitations.

If you’re not using Go, then it’s likely not worth considering as a mobile native programming option yet. But I still feel strongly that there is enough potential and interest to make it a possibility in the not-distant-future and would of course, love to hear your opinions below.

  • Dmitriy WebMaker

    This is great article! thx alot! :)

    • Chris Ward


  • Great article!

    • Chris Ward


  • svartalf

    Truly it depends on what you’re looking for. Since someone provided an idiomatic Golang version of nanomsg, it became an item worth consideration. NDK is going to be the only other choice and it’s have a fully and correctly supported native Go binding or have a wrapper that is still a bit in it’s infancy around the C libs for the project I’m working on. If I could mostly get the Go stuff working on the backend, it becomes close to or over the threshold of being “worth it” for my problem set.

    • Chris Ward

      Yes, agreed!

  • fasya

    how to import go.hello.Hello?i was try but i fail.
    give tutorial please

  • Bastien Pourcine

    Have you ever experienced any untreated classes with complex structs in it ?
    By untreaded i mean that gomobile build works but -vv outputs only a small
    part of the original code is pushed into the .aar :| (And unreachable
    within Android studio or any IDE)

    • Chris Ward

      @bastienpourcine:disqus No, sorry!

Get the latest in Mobile, once a week, for free.