Getting Started

Getting Started Creating your first Fyne app Run Fyne Demo Application and RunLoop Updating Content in your GUI Window Handling Testing Graphical Apps Packaging for Desktop Mobile Packaging Run in a Browser App Metadata Distributing to App Stores Compiling for different platforms

Exploring Fyne

Canvas and CanvasObject Container and Layouts Widget List Layout List Dialog List Theme Icons Adding Shortcuts to an App Using the Preferences API Adding app translations System Tray Menu Data Binding Compile Options

Drawing and Animation

Rectangle Text Line Circle Image Raster Gradient Animation

Containers and Layout

Box Grid Grid Wrap Border Form Center Max AppTabs

Widgets

Label Button Entry Choices Form ProgressBar Toolbar

Collections

List Table Tree

Data Binding

Data Binding Binding Simple Widgets Two-Way Binding Data Conversion List Data

Extending Fyne

Building a Custom Layout Writing a Custom Widget Bundling resources Creating a Custom Theme Extending Widgets Numerical Entry

Architecture

Geometry Scaling Widgets Organisation and Packages

Frequently Asked Questions

Layout and Widget Size Theme and Customisation Troubleshooting

API Documentation

Upgrade to v2.5 Fyne API v2.5 app canvas container data/binding data/validation dialog driver driver/desktop driver/mobile driver/software lang layout storage storage/repository test theme widget

List My App

Compiling for different platforms

Cross compiling with Go is designed to be simple - we just set the environment variable GOOS for the target Operating System (and GOARCH if targeting a different architecture). Unfortunately when using native graphics calls the use of CGo in Fyne makes this a little harder.

Compiling from a development computer

To cross-compile a Fyne application you will also have to set CGO_ENABLED=1 which tells go to enable the C compiler (this is normally turned off when the target platform is different to the current system). Doing so unfortunately means that you must have a C compiler for the target platform that you are going to compile for. After installing the appropriate compilers you will also need to set the CC environment variable to tell Go which compiler to use.

There are many ways to install the required tools - and different tools that can be used. The configuration recommended by the Fyne developers is:

GOOS (target)	CC	provider	download	notes
`darwin`	`o32-clang`	osxcross	from github.com	You will also need to install the macOS SDK (instructions at the download link)
`windows`	`x86_64-w64-mingw64-gcc`	mingw64	package manager	For macOS use homebrew
`linux`	`gcc` or `x86_64-linux-musl-gcc`	gcc or musl-cross	cygwin or package manager	musl-cross is available from homebrew to provide the linux gcc. You will also need to install X11 and mesa headers for compilation.

With the environment variables above set you should be able to compile in the usual manner. If further errors occur it is likely to be due to missing packages. Some target platforms require additional libraries or headers to be installed for the compilation to succeed.

Using a virtual environment

As a Linux system is able to cross compile to macOS and Windows easily it can be simpler to use a virtualised environment when you are not developing from Linux. Docker images are a useful tool for a complex build configuration and this works for Fyne as well. There are different tools that can be used. The tool recommended by the Fyne developers is fyne-cross. It has been inspired by xgo and uses a docker image built on top of the golang-cross image, that includes the MinGW compiler for windows, and a macOS SDK, along with the Fyne requirements.

fyne-cross allows to build binaries and create distribution packages for the following targets:

GOOS	GOARCH
darwin	amd64
darwin	386
linux	amd64
linux	386
linux	arm64
linux	arm
windows	amd64
windows	386
android	amd64
android	386
android	arm64
android	arm
ios
freebsd	amd64
freebsd	arm64

Note: iOS compilation is supported only on darwin hosts.

Requirements

go >= 1.13
docker

Installation

You can install fyne-cross using the following command (requires Go 1.16 or later):

go install github.com/fyne-io/fyne-cross@latest

For earlier versions of Go, you need to use the following command instead:

go get github.com/fyne-io/fyne-cross

Usage

fyne-cross <command> [options]

The commands are:

	darwin        Build and package a fyne application for the darwin OS
	linux         Build and package a fyne application for the linux OS
	windows       Build and package a fyne application for the windows OS
	android       Build and package a fyne application for the android OS
	ios           Build and package a fyne application for the iOS OS
	freebsd       Build and package a fyne application for the freebsd OS
	version       Print the fyne-cross version information

Use "fyne-cross <command> -help" for more information about a command.

Wildcards

The arch flag support wildcards in case want to compile against all supported GOARCH for a specified GOOS

Example:

fyne-cross windows -arch=*

is equivalent to

fyne-cross windows -arch=amd64,386

Example

The example below cross compile and package the fyne examples application

git clone https://github.com/fyne-io/examples.git
cd examples

Compile and package the main example app

fyne-cross linux

Note: by default fyne-cross will compile the package into the current dir.

The command above is equivalent to: fyne-cross linux .

Compile and package a particular example app

fyne-cross linux -output bugs ./cmd/bugs

Improve this page