Something big is coming to the Fyne universe - better performance, smoother animations and removing race conditions all in one bumper release!

All this goodness requires substantial change internally and we have done a lot of work to make this happen. It could have been a breaking release - but we have created a migration path that should mean that all apps just continue to work.

However this is a big jump and we are asking the community to help us test - using your apps. This is the first time we have ever tagged a release from our development branch.

What’s Changing in Fyne v2.6.0?

Internally to the Fyne toolkit we are changing the threading model. From the next release onward all the callbacks, events and rendering will happen on a single goroutine. This leads to better performance, smoother animations and helps us to eliminate data race conditions as well!

With these changes internally most apps will see significant performance improvements - CPU usage typically drops 30-50%. We have turned on race detection in all of our unit testing automations so your apps will be more robust than ever.

Because we are now working all Fyne code from a single goroutine it means the process for running code in the background has changed. Instead of implicit safety provided internally we have changed to explicitly joining - using the new fyne.Do API. This means that if you launch a new goroutine (using the go keyword) you should wrap Fyne code with fyne.Do or fyne.DoAndWait - the latter being used if you want to wait for the code to complete.

What does this mean for me?

Because this is a big change we know it can impact existing apps. This could have been v3.0 but we want to avoid any breaking API changes - and so we have opted to create a migration instead. That is what we need help with - verifying that our migration works for as many apps as possible.

The testing is a three step process:

1) Upgrade your app to use Fyne v2.6.0-alpha1 2) Verify that everything still works (there may be a lot of logs) 3) See the logs for errors and update your code where it needs to use fyne.Do

That should be it, let’s look at the details:

1) Upgrading your app

This is like the normal upgrade process, just get the tagged version and update your modules:

go get fyne.io/fyne/v2@v2.6.0-alpha1
go mod tidy

After that the compilation may take a little time as that’s a lot of code changed!

2) Verify your app still works correctly

Run your app as normal using go run or fyne build (don’t package it yet - we need to see terminal output). For simple apps and those using no background processing your app will run perfectly!

However if your app does background processing or works with slow network data sources you may see logs that look like the following:

2025/02/11 09:57:10 *** Error in Fyne call thread, this should have been called in fyne.Do[AndWait] ***
2025/02/11 09:57:10   From: /Users/andy/Code/Fyne/terminal/internal/widget/termgrid.go:56

These are to be expected, and mark the line where you should update your app. If your app logs a lot of information then it could impact performance a little (sorry about that, but it means we can avoid crashing and help with the migration). If your app crashes or does not work as expected please get in touch or open an issue.

### 3) Fix API usage where the logs indicate

For each of the lines logged above you should wrap your code in fyne.Do. So if, for example, you had the following code:

clock := widget.NewLabel(time.Now().String())

go func() {
	for {
		time.Sleep(time.Second)

		clock.SetText(time.Now().String())
	}
}()

That will update your clock label each second to the current time - but this is happening on a background thread. This worked in the past due to a complex set of locks and verifications that were slowing down apps.

For 2.6 onwards you will need to wrap the Fyne code. Be sure to wrap the smallest scope possible - you don’t want to accidentally have slow code, or a wait or timer holding back the rendering or event handling process.

clock := widget.NewLabel(time.Now().String())

go func() {
	for {
		time.Sleep(time.Second)

		fyne.Do(func() {
			clock.SetText(time.Now().String())
		})
	}
}()

Completing the migration

Once your are sure that the app is working perfectly you can get even more performance by marking it as migrated. This step means that Fyne will remove the safety / assistance checks to assist with the migration. You can turn this all off by updating your FyneApp.toml to add the following lines:

[Migrations]
  fyneDo = true

Thanks so much for your help with testing - please do open an issue if you have any problems.

And if you need to read any more then check out our upgrade docs at docs.fyne.io.

We are excited to announce the release of Fyne v2.5.0! This version is packed with new features, enhancements, and fixes that will significantly improve your experience in developing cross-platform applications. Whether you’re building desktop, mobile or web apps, this release brings powerful new tools and optimizations to help you create better, more polished software.

What’s New in Fyne v2.5.0?

New Features and Additions

1. Internationalization and Translations

Fyne v2.5.0 introduces support for internationalization (i18n) and translations, making it easier to build applications that cater to a global audience. This new feature allows your app to display text in multiple languages, improving user experience worldwide.

2. Advanced Font Handling

To improve the rendering of text, especially with international characters, Fyne now includes the ability to look up system fonts for glyphs that cannot be found in the embedded fonts. This ensures that your application can display a wider range of characters without any rendering issues.

3. Expanded Platform Support

Fyne v2.5.0 brings completed support for Wayland on Linux, ensuring smooth and native experiences for Linux users. Additionally, our Web driver support is now almost complete, with full functionality except for file handling. For Linux apps built with Flatpak, we’ve added support for XDG Desktop Portals, enhancing security and integration with the host system.

4. New Widgets and Containers

This release introduces several new UI elements:

• Activity Indicator: A widget that visually shows ongoing processes.
• InnerWindow and MultipleWindows Containers: These allow for more complex window management in your applications.
• ThemeOverride Container: Group items within a container and apply a different theme, offering greater flexibility in design.

5. Enhanced Functionality and API Additions

Developers now have access to a range of new APIs and functionalities:

• NativeWindow.RunNative: Utilize native window handles for deeper system integration.
• SetDisableScreenBlanking: Ensure that the display stays on, useful for applications where screen timeouts are undesirable.
• Undo/Redo Support for widget.Entry: Implement undo/redo functionality easily within text entries.
• New AppendMarkdown Function: Add markdown content dynamically to RichText.
• Hide Separators in List Widgets: Improve UI aesthetics by controlling the display of separators.

6. Development and Testing Tools

To streamline the development process, we’ve introduced new test functions like NewTempApp, NewTempWindow, and TempWidgetRenderer. These automatically free resources, making your test suite more efficient and reliable.

Changes and Improvements

1. Minimum Go Version

Fyne now requires Go 1.19 or later, ensuring compatibility with the latest Go language features and improvements.

2. Improved Visuals and Usability

We’ve rounded the corners of scroll bars for a more modern look, improved text contrast on highlighted backgrounds, and enhanced the layout responsiveness on iOS and Android, particularly when the keyboard appears.

3. Platform-Specific Enhancements

• macOS Improvements: System tray and tray menu icons now match the theme on macOS, and the “About” menu item can override the default macOS “About” dialog.
• iOS and Android Adaptations: Layouts for mobile apps will now adapt when the keyboard appears, providing a better user experience on small screens.

Getting Started with Fyne v2.5.0

Upgrading to Fyne v2.5.0 is straightforward. Just update your project dependencies to start taking advantage of the new features and improvements. If you’re new to Fyne, this release is the perfect time to explore what it offers for cross-platform application development.

Check out the detailed release notes for more information on all the changes.

Looking Forward

We are continually working to improve Fyne, and we’re already planning future updates with even more exciting features and enhancements. Your feedback and contributions are invaluable as we strive to make Fyne the best toolkit for cross-platform development.

Thank you for being part of the Fyne community, and we can’t wait to see what you build with Fyne v2.5.0! And why not consider showing something at Fyne Conf?

Happy Coding!

For anyone who is new to the Fyne community you might not know that earlier this month we held the 2023 Fyne Conf event. What was super exciting was that this year we held the first hybrid event, with people joining us in person and online. It was a fantastic opportunity to gather with the community. We had half of the core contributor team, around 10 people in person and over 200 joining us live online! Everyone who arrived in person (or presented remotely) was treated to one of our limited edition Fyne Conf 2023 t-shirts (only 3 people have one from each year they were produced!).

Thanks to the kind people at CodeBase we were hosted in a comfortable event space in the center of Edinburgh, Scotland. (And check out that banner we had!) There was also a great breakfast and lunch provided by Tasty Buns Bakery. Also some drinks were enjoyed as we wrapped up, and all the food and drink was sponsored by Fyne Labs, thanks :).

Of course this was all just an excellent backdrop to a morning of workshops and an afternoon packed full of presentations. You can see all the recordings our our YouTube playlist. It was amazing to have so many contributions from around the community - it was our largest programme to date!

Thanks to everyone who came along in person, and to the hundreds online. Also thanks to everyone catching up after the event and joining the community channels to learn more. We are already planning next year and considering meeting up in Germany - see you there!

We are excited to announce the bumper v2.4.0 release - later than we hoped, but well worth the delay. With the introduction of rounded rectangles we have updated the look and feel to remove a lot of the sharp corners, Smoother edges to input and buttons primarily make the UI feel a lot more friendly. Check out the full release below and let us know what you think :)

Added features

We have some great new features for your app like rounded rectangles, emoji support in text, a new GridWrap collection widget, truncation with ellipses and support for layout debugging as well (use -tags debug).

Enjoj this great new release !.

The complete list of new additions is as follows:

• Rounded corners in rectangle (#1090)
• Support for emoji in text
• Layout debugging (with -tags debug build flag) (#3314)
• GridWrap collection widget
• Add table headers (#1658, #3594)
• Add mobile back button handling (#2910)
• Add option to disable UI animations (#1813)
• Text truncation ellipsis (#1659)
• Add support for binding tree data, include new NewTreeWithData
• Add support for OpenType fonts (#3245)
• Add Window.SetOnDropped to handle window-wide item drop on desktop
• Add lists to the types supported by preferences API
• Keyboard focus handling for all collection widgets
• Add APIs for refreshing individual items in collections (#3826)
• Tapping slider moves it to that position (#3650)
• Add OnChangeEnded callback to Slider (#3652)
• Added keyboard controls to Slider
• Add NewWarningThemedResource and NewSuccessThemedResource along with NewColoredResource (#4040)
• Custom hyperlink callback for rich text hyperlinks (#3335)
• Added dialog.NewCustomWithoutButtons, with a SetButtons method (#2127, #2782)
• Added SetConfirmImportance to dialog.ConfirmDialog.
• Added FormDialog.Submit() to close and submit the dialog if validation passes
• Rich Text image alignment (#3810)
• Bring back theme.HyperlinkColor (#3867)
• Added Importance field on Label to color the text
• Navigating in entry quickly with ctrl key (#2462)
• Support .desktop file metadata in FyneApp.toml for Linux and BSD
• Support mobile simulator on FreeBSD
• Add data binding boolean operators Not, And and Or
• Added Entry.Append, Select.SetOptions, Check.SetText, FormDialog.Submit
• Add ShowPopUpAtRelativePosition and PopUp.ShowAtRelativePosition
• Add desktop support to get key modifiers with CurrentKeyModifiers
• Add geometry helpers NewSquareSize and NewSquareOffsetPos
• Add --pprof option to fyne build commands to enable profiling
• Support compiling from Android (termux)

Changed

The following items have changed as well, most notably you’ll need to be using Go 1.17 at least going forward.

• Go 1.17 or later is now required.
• Theme updated for rounded corners on buttons and input widgets
• widget.ButtonImportance is now widget.Importance
• The Max container and layout have been renamed Stack for clarity
• Refreshing an image will now happen in app-thread not render process, apps may wish to add async image load
• Icons for macOS bundles are now padded and rounded, disable with “-use-raw-icon” (#3752)
• Update Android target SDK to 33 for Play Store releases
• Focus handling for List/Tree/Table are now at the parent widget not child elements
• Accordion widget now fills available space - put it inside a VBox container for old behavior (#4126)
• Deprecated theme.FyneLogo() for later removal (#3296)
• Improve look of menu shortcuts (#2722)
• iOS and macOS packages now default to using “XCWildcard” provisioning profile
• Improving performance of lookup for theme data
• Improved application startup time

There are also more than 25 other fixes in that improve stability and performance. Let us know what you think and how we can improve further :).

The team are hard at work pulling in exciting new features for v2.4.0, and it is coming along well. However it will be a few more weeks before we have something ready to announce or to start public testing, so it seemed like a good opportunity to share some teasers of what will be coming in the next big release!

Rounded Rectangles

Thanks to the hard work of Renlite we have finally been able to add rounded radius to the rectangle primitive in our canvas package. In addition this means that rectangles are drawn faster than ever, speeding up all Fyne applications as a bonus!

Apps using Fyne v2.4.0 and above will have a new theme that makes use of this to round the corners of buttons. And of course this is part of the theme API as well so your app, or custom theme, can control this like all other sizes in your visual style.

In the mean time - check out this preview of some rounded rectangle shapes looking all cool!

Table headers

Another often requested feature is to have row and column headers on the table widget. Well we listened, and also we got the tremendous support of MindPoint Group to make it happen.

All tables can now get these splendid headers, which will have the “bold with background” look shown below when you use NewTableWithHeaders.

Of course you can control these completely, turning row and column headings on and off independently. More excitingly you can put custom content into these headers, adding the possibility to include buttons for sorting or column selection and similar use-cases.

Layout debugging

One of the feature that early Fyne developers struggle with is just how the layout system works - which container to use and how to put widgets in the right place to fill the area that you want.

With the upcoming release that gets a whole lot easier! By launching your app with debug enabled you will get a new overlay that shows exactly where your containers are and how each widget is positioned and sized within them.

We hope this will make a big difference in speeding up layout bugs and the learning process around Fyne’s simple but powerful layout system!

Can you believe it?! Our humble GUI project has reached 20’000 stargazers? What a journey this has been. In the last 5 years we have created something incredible. Fyne is now the most popular GUI toolkit for Go; the 6th most used of all open source GUI toolkits from any language; and if you want to avoid using HTML/CSS/JS in your app then we are third behind only Flutter and React Native! (See OSS Insight month-to-month Cross-Platform GUI tool

Thanks so much to our wonderful community, the contributors and collaborators on this project. And to you, for your interest and in helping us spread the word!

Whatever you celebrate at this time of year we hope you will enjoy this exciting, shiny new look release of the Fyne toolkit. With a refined design, cloud integration, images in rich text and a new text handling engine there is a lot to love in Fyne v2.3.0.

New Look

We have refined the visual design of Fyne in this release to give a better initial experience for app users. You can see the new design shown below in the fyne_demo app.

Cloud integration

You can now easily add cloud storage to any Fyne app through the App.Preferences() and App.Storage() abstractions. This change will be completely transparent to the rest of your app, and is as simple as calling App.SetCloudProvider().

There is a lot more information from the cloud sync presentation at Fyne Conf 2022.

The main list of additions and changes is shown below. To see the complete list including bug fixes see the GitHub release page.

Added

• Shiny new theme that was designed for us
• Improved text handling to support non-Latin alphabets
• Add cloud storage and preference support
• Add menu icon and submenu support to system tray menus
• More button importance levels ErrorImportance, WarningImportance
• Support disabling of AppTabs and DocTabs items
• Add image support to rich text (#2366)
• Add CheckGroup.Remove (#3124)

Changed

• The buttons on the default theme are no longer transparent, but we added more button importance types
• Expose a storage.ErrNotExists for non existing documents (#3083)
• Update go-gl/glfw to build against latest Glfw 3.3.8
• List items in widget.List now implement the Focusable interface

Have a very happy holiday and do let us know what you build with this new release. Head to GitHub to report issues or request new features, we will be hard at work after a few more mince pies!

It’s been a long time coming, but we are thrilled to share the v2.2.0 release. There are so many amazing features added this release, not least system tray for desktop apps, app metadata, iOS simulator support and initial version of a driver for running apps through a web browser. Also check out the improved menu experience and support for more BSD OSes as well as support for Google Play .aab file format.

Added features

Lots of new features come with this release, but here is a dhow of the system tray feature - it will adapt to the operating system the app is running on.

You can get started as simply as:

	if desk, ok := a.(desktop.App); ok {
		m := fyne.NewMenu("MyApp",
			fyne.NewMenuItem("Hello", func() {
				log.Println("Hello")
			}))
		desk.SetSystemTrayMenu(m)
	}

Don’t forget to set an application icon, which is used by default. Or you can update to specific tray icon with SetSystemTrayIcon.

Also this release is the first chance to try running your Fyne app through a web browser window. You can try this out (make sure you update fyne command first!):

$ fyne serve
Serving myapp/web on HTTP port: 8080

And just load your web browser!

Note that at this time the web driver cannot handle multiple windows or the use of storage or preference code.

For more interest here is the full list of new features:

• Add SetIcon method on ToolbarAction
• Access compiled app metadata using new App.Metadata() method
• Add support for System tray icon and menu
• Support for Android Application Bundle (.aab)
• Initial support for OpenBSD and NetBSD
• Add keyboard shortcuts to menu
• Add technical preview of web driver and fyne serve command
• Added iossimulator build target
• Allow dynamic themes via JSON templates
• Custom hyperlink callback
• Add support for .ico file when compiling for windows
• Add binding.NewStringWithFormat
• Add Entry.SetMinRowsVisible
• Add Menu.Refresh() and MainMenu.Refresh()
• Packages for Linux and BSD now support installing into the home directory
• Add .RemoveAll() to containers
• Add an AllString validator for chaining together string validators

Changed

The following items have changed and may require custom widgets or complex code to be updated accordingly.

• Toolbar item constructors now return concrete types instead of ToolbarItem
• Low importance buttons no longer draw button color as a background
• ProgressBar widget height is now consistent with other widgets
• Include check in DocTabs menu to show current tab
• Don’t call OnScrolled if offset did not change
• Prefer ANDROID_NDK_HOME over the ANDROID_HOME ndk-bundle location
• Support serialisation / deserialisation of the widget tree
• Better error reporting / handling when OpenGL is not available
• Memory is now better reclaimed on Android when the OS requests it
• Notifications on Linux and BSD now show the application icon
• Change listeners for preferences no longer run when setting the same value
• The file dialog now shows extensions in the list view for better readability
• Many optimisations and widget performance enhancements
• Updated various dependencies to their latest versions

There are also many more fixes that improve the stability of our toolkit. Let us know what you think and how we can improve further :).

The v2.1.0 release represents a huge step forward since 2.0 - just as many commits as went into the v2.0.0 release! We added new widgets, a Lifecycle API, storage helpers, build metadata and lots of optimisations too. Check out the full release below and let us know what you think :)

Note that custom focusable widgets will not automatically be focussed on tap any more, you may wish to update your code so it requests focus on tapped (see https://developer.fyne.io/api/v2.1/upgrading).

Added features

We have some great new features for your app like DocTabs, CheckGroup and a new metadata file, but perhaps the coolest new feature is the RichText widget! We have included a Markdown parser that can be used to create rich text using widget.NewRichTextWithMarkdown("* Text"), this means you can really easily include rich content in your apps. It is even a simple task to make a markdown preview for an editor widget like this:

The complete list of new additions is as follows:

• DocTabs container for handling multiple open files
• Lifecycle API for handling foreground, background and other event
• Add RichText widget and Markdown parser
• Add TabWidth to TextStyle to specify tab size in spaces
• Add CheckGroup widget for multi-select
• Add FyneApp.toml metadata file to ease build commands
• Include http and https in standard repositories
• Add selection color to themes
• Include baseline information in driver font measurement
• Document storage API (App.Storage().Create() and others)
• Add “App Files” to file dialog for apps that use document storage
• Tab overflow on AppTabs
• Add URI and Unbound type to data bindings
• Add keyboard support for menus, pop-ups and buttons
• Add SimpleRenderer to help make simple widgets
• Add scroll functions for List, Table, Tree
• Add selection and disabling to MenuItem
• Add Alignment to widget.Select
• Expose ScanCode for keyboard events originating from hardware
• Support macOS GPU switching

Changed

The following items have changed and may require custom widgets or complex code to be updated accordingly.

• Focusable widgets are no longer focused on tap, add canvas.Focus(obj) in Tapped handler if required
• Move to background based selection for List, Table and Tree
• Update fyne command line tool to use –posix style parameters
• Switch from gz to xz compression for unix packages
• Performance improvements with line, text and raster rendering
• Items not yet visible can no longer be focused
• Lines can now be drawn down to 1px (instead of 1dp)
• Support multiple lines of text on button
• Improved text layout speed by caching string size calculations
• Updated to require Go 1.14 so we can use some new features
• Window Resize request is now asynchronous
• Up/Down keys take cursor home/end when on first/last lines respectively

There are also more than 25 other fixes in that improve the stability of our toolkit. Let us know what you think and how we can improve further :).

The FyneDesk team are excited to announce the second major release of their desktop environment for Linux and BSD. This version comes packed with new features like notifications, print screen and a new module API and is also updated to the new look of version 2.0.0 of the Fyne toolkit. Read on for more details and screenshots!

Added features

We have been working hard over many months to re-work the desktop handling for better performance and higher reliability. But the main reason for a release is to get the latest cool features to our community - here are the highlights:

• Support for desktop notifications
• Created API for writing modules that plug in to FyneDesk
• Add volume control using pulseaudio
• Print screen support for desktop and window capture
• Add urls, calculations and sound/brightness to launcher
• Add support for XPM icon format
• Double tap title bar to maximise
• Hover effects for window borders
• Add option to use 24h time
• Drag border to exit un-maximize
• Support choosing between Alt and Win key for shortcuts
• Add AC power indicator to battery status
• Add option to change border button position
• Support pseudo transparency for apps like X terminals

There are many more hidden gems, try it out and see what you can find :)

New look

With the latest Fyne theme and improvements to our status widgets design (which are all modules now) we have a fresh new look to the desktop, as shown below.

Road ahead

There are huge plans for what we want to add to this project, you can see the full Roadmap at the project Wiki on GitHub.

Now that this release is out we will be working on a more complete multi-monitor configuration experience as well as virtual desktops and other improvements like lock screens and a network manager.

Stay tuned for future announcements!