mrkeyoor.com_
Mon 28 Sept 03:42 UTC
Dev Toolsevaluationupdated 28 Sept 2026

fyne review

Fyne is a Go toolkit for building graphical desktop and mobile applications from one codebase. It supplies its own widgets, layouts, themes, packaging tool, and mobile simulator, so a Go developer can make an app without adopting a browser frontend.

Verdict

Our Fyne build passed in 37 seconds, but 25 of 101 Go test packages failed, so the repository is easy to compile and harder to trust without platform-specific checks. Use it for Go-first utilities and internal apps when one shared widget API saves more time than chasing native appearance. For accessibility-sensitive software, browser delivery, or touch interfaces, reproduce the open platform defects on your exact target before committing.

We ran it

Lab card: what happened when we ran fyneScreenshot of fyne (fyne.io)
Install✓ · 24s69 packages
Build✓ · 37s
Tests✗ · 41s76 passed · 25 failed of 101 (go test)
Repo2148 files~147,534 lines of source · 17.7 MB · 4 CI workflows · tests dir

Answers from our run

Does fyne build from source?

Dependencies installed in 24 seconds (69 packages), and the build succeeded in 37 seconds. We cloned commit a978f1c into a clean Debian container with 3 CPUs and no project-specific setup.

Do fyne's tests pass?

Not all of them: 76 of 101 passed and 25 failed when we ran the project's own test command (go test). Some failures need services or credentials a bare container does not have.

Who should not use fyne?

Teams that require native operating-system widgets and exact platform styling: Fyne draws a consistent toolkit inspired by Material Design.

What are the alternatives to fyne?

Gio, Wails, Flutter. Our Fyne build passed in 37 seconds, but 25 of 101 Go test packages failed, so the repository is easy to compile and harder to trust without platform-specific checks.

Setup3/5Build passed, but C tools are required and 25 test packages failed
Docs4/5Clear first app and packaging path; platform details live elsewhere
Community5/528,724 stars with pushes and issue work in September 2026
Maturity4/5v2.8.1 spans many targets, with current platform defects

Discussed on

  1. hnFyne: Cross-Platform GUI in Go Based on Material Design360 points
  2. hnFyne: Native Mobile UX in Go113 points
  3. hnShow HN: Cross Platform Go GUI18 points
  4. hnFyne-Io/fyne: Cross Platform GUI in Go Based on Material Design5 points

Who it’s for

Go developers building internal desktop tools, utilities, or mobile companions from a shared codebase.
Small teams that prefer Go callbacks and widgets over a separate HTML, CSS, and JavaScript frontend.
Projects that value a consistent Material-inspired interface across operating systems.
Maintainers willing to test packaging, input, and rendering on every platform they ship.

Who it’s NOT for

Teams that require native operating-system widgets and exact platform styling: Fyne draws a consistent toolkit inspired by Material Design.
Developers who need a pure-Go toolchain with no system setup: the README requires a C compiler and platform development tools.
Browser apps that must preserve every normal browser shortcut: open issue 6541 reports that the web backend consumes reload and tab-selection keys while its canvas has focus.
Products that must pass a macOS screen-reader audit today: open issues 6491 and 6492 report missing card content and an unnamed system-tray item in the accessibility tree.
Mobile teams unable to run device-level UI tests: issue 6527 reports that Android dialogs can move under a finger when the soft keyboard closes.

Setup reality

Our sandbox install succeeded in 24 seconds and added 69 packages. The build succeeded in 37 seconds. Tests failed after 41 seconds: go test reported 76 passed and 25 failed out of 101. The log tail ended with successful package lines followed by FAIL, so it does not identify the failing cases or their cause.

The README requires Go 1.22 or later, a C compiler, and the development tools for your operating system. Mobile packaging also needs the relevant Android or Apple tooling, app identifiers, signing material, and store accounts.

Fyne can package desktop, Android, iOS, iOS Simulator, and web targets, but each target still needs real testing. The README warns that a first Windows compilation can take up to 10 minutes, and current issues document platform-specific input, rendering, and accessibility defects.

Fyne 2.8.1 uses one Go widget API across desktop and mobile

Fyne 2.8.1 gives Go developers a direct route to windows, layouts, widgets, dialogs, menus, preferences, and app packaging. The first README example is a complete window with a label and button, written in ordinary Go callbacks. The same project can target desktop systems and mobile devices, with a mobile simulation tag available during development. That is the appeal: you keep application logic and interface code in one language.

The consistency comes from Fyne's own Material-inspired toolkit rather than native operating-system controls. That makes a 2.8.1 app look related across platforms, but it also means your product inherits Fyne's rendering, input, and accessibility behavior. Teams choosing it should like that visual identity. If a macOS app must look and behave exactly like AppKit, or a Windows app must follow every native convention, the shared widget layer works against the requirement.

Go 1.22 and a C compiler sit behind the short starter app

The README requires Go 1.22 or later and a C compiler, though its starter program is small enough to understand in one sitting. You create an app, open a window, assign content, and call ShowAndRun. Adding the module uses standard Go commands, while the separate Fyne utility handles icons, installation, mobile packages, and store releases. The docs also point to a widget demo and a separate examples repository, which is more useful than a page of isolated API signatures.

That simple source file still relies on the development tools for the host system. Android and iOS add their own SDK, device, signing, and store requirements. The README also warns that the first Windows compilation can take up to 10 minutes. A team should prove the full release path early, not stop after a local desktop window opens.

What happened when we ran it

Our sandbox installed Fyne in 24 seconds and added 69 packages. We cloned commit a978f1c and built it in a fresh unprivileged Debian container with 3 CPUs and 8 GB of RAM. The build succeeded in 37 seconds. The checkout contained 2,148 files and about 147,534 lines of source, so that clean build is a useful result for a toolkit that carries desktop, mobile, and web backends in one repository.

The test step failed with exit code 1 after 41 seconds. Go reported 76 passed and 25 failed out of 101 test packages. The supplied log tail lists successful packages such as layout, storage, theme, and widget, then ends with FAIL. It does not name the failed packages or show their errors, so we cannot assign a cause. The safe conclusion is narrower: commit a978f1c built, but its full test command did not pass in our stated sandbox.

The repository has 4 CI workflow files and a tests directory, but no Dockerfile. That fits a library whose real targets are host operating systems, though it leaves container users to assemble the C and graphics dependencies themselves. Our measurement covers repository setup and checks. It does not show whether a packaged window draws correctly, whether touch input feels right, or whether a signed mobile build reaches a store.

Cross-platform still means testing each target

Fyne's recent work shows why platform testing stays part of the job. Release v2.8.1 fixed Windows URI handling, Android keyboard input, macOS menu refreshes, KDE Wayland tray behavior, touchscreen taps, and several rendering cases. Those are practical fixes, and they also map the size of the compatibility surface. A shared API removes duplicate application code. It cannot make Windows, Wayland, Android, and iOS behave alike underneath.

Open reports remain specific. Issue 6540 describes a Wayland crash when the monitor holding a window disappears. Issue 6541 says a packaged web app calls preventDefault() for every key event, blocking shortcuts such as browser reload and numbered tab selection while the canvas is focused. On Android, issue 6527 reports a dialog recentering as the soft keyboard closes, which can move buttons during the tap meant to press them. These reports need reproduction before they become release blockers, but they are credible test cases to add.

Three open issues leave accessibility work for the application team

Open issues 6491, 6492, and 1515 leave concrete gaps in the macOS accessibility tree and keyboard behavior. Open issue 6491 reports that, on macOS with the accessibility build tag, labels inside widget.Card disappear from the Accessibility tree. Issue 6492 reports an unnamed system-tray item under the same setup. A longer-running keyboard-access issue still has unchecked behavior for accordions, tabs, and sliders.

Those gaps matter differently by product. An internal status panel used by a known team may be able to avoid the affected widgets. A public app subject to a screen-reader audit cannot accept that uncertainty. Build with the documented accessibility tag, inspect the resulting tree, and run VoiceOver plus keyboard-only tests on the shipping UI. The 25 failed test packages from our run make that independent check more important, even though the log does not connect those failures to accessibility.

Current maintenance is active, with a large open queue

GitHub showed 28,724 stars and 745 combined issues and pull requests when fetched. The last push was September 27, 2026, one day before this review, and recently reported defects were also being closed in September. Release v2.8.1 arrived on August 26 with performance changes and a long fix list. That is active maintenance, not a project coasting on an old tag.

The open queue is still substantial for a GUI foundation. Read it by target instead of treating 745 as a quality score. A Linux desktop team should filter for Wayland and X11, a mobile team for keyboard and touch reports, and a web team for the canvas backend. Fyne is a sensible choice when Go ownership and a shared interface outweigh native fidelity. The cost is a platform test matrix that your application still has to own.

Alternatives

ProjectWhat it isPick it when
GioA Go GUI library built around an immediate-mode rendering model.pick this instead when you want lower-level control over drawing and interaction, and you accept writing more of the interface yourself.
Wails gh↗A desktop app framework that pairs a Go backend with a web frontend.pick this instead when your team already knows HTML and CSS or needs browser-grade layout and styling.
Flutter gh↗A Dart toolkit with a large widget catalog and broad desktop and mobile support.pick this instead when mobile polish and ecosystem depth matter more than keeping the application in Go.

What people are saying

  1. [github-trending] fyne-io/fyne

Sources

  1. Fyne README
  2. Fyne v2.8.1 release notes
  3. Web backend keyboard shortcut issue 6541
  4. macOS Card accessibility issue 6491
  5. Android dialog movement issue 6527

More dev tools reviews

agent-manager · navi · exodium · Submarine · Madeira · mitmproxy · the whole board →