fyne-io/fyne

This system is a cross-platform GUI toolkit for Go that provides a unified API for building native desktop and mobile applications. It handles rendering via OpenGL or software backends, manages platform-specific interactions like notifications and system trays, and includes a CLI tool for building, bundling, and distributing apps across macOS, Windows, Linux, Android, and iOS. The framework also offers comprehensive data binding, layout management, and localization capabilities to support complex user interfaces.

32 changes.

This period focused on the foundational development of the Fyne v2 framework, introducing a new driver package with native window contexts and a dual OpenGL/software rendering engine. The work involved restructuring the UI abstraction by removing legacy drivers, implementing comprehensive layout managers, and adding platform-specific features like system tray support and mobile touch handling.

25 changes.

This period focused on overhauling the storage system with a new URI-based API and repository architecture, while simultaneously establishing the foundational OpenGL ES and accessibility infrastructure for mobile drivers. Significant work also went into refactoring the CLI for cross-platform packaging, introducing generic data binding, and expanding the widget and container libraries with new tab and clip components.

13 changes.

This period focused on modernizing the framework's internal architecture by introducing GPU-accelerated rendering, a new SVG parsing engine, and a dedicated scale package for precise coordinate handling. Significant efforts were also directed toward expanding platform support through embedded driver interfaces, build-time configuration flags, and a robust localization system with improved fallback logic.

Users can now select colors using a new ColorPickerDialog, available via NewColorPicker and ShowColorPicker. The dialog offers a simple mode with basic, greyscale, and recent color buttons, and an advanced mode (enabled via the Advanced field) that provides a color wheel, HSL/RGB channel sliders, hex input, and a preview of the previous and current colors. The dialog persists the last seven selected colors in preferences and triggers a callback with the selected color upon confirmation.

dialog · high confidence

The \internal/driver/embedded\ package now provides a new \noosDriver\ implementation that allows Fyne applications to run without a native OS windowing system. This driver supports headless rendering by accepting a custom render callback and runloop hook, and it includes full support for touch events (down, move, up, drag, and tap) via a \touchCanvas\ that integrates with the software driver. It also implements basic device properties (orientation, mobile status, keyboard presence) and window management (creation, resizing, closing) to facilitate testing and embedded environments.

internal/driver/embedded · high confidence

Introduces a new internal scheduler that allows applications to queue notifications for delivery at a specific future time. The scheduler persists pending entries to the application cache (as JSON) so that scheduled notifications survive app restarts; upon startup, past-due entries are delivered immediately and removed from storage, while future entries are re-armed with timers. Users can schedule, cancel, and rely on the scheduler to handle delivery even if the app was previously closed.

internal/scheduler · high confidence

The GLFW driver on macOS now exposes an accessibility bridge that maps Fyne canvas objects to native macOS accessibility elements. This allows screen readers like VoiceOver to navigate and interact with application content, including menus and overlays, by exposing labels, roles, and positions through the Cocoa accessibility API.

internal/driver/glfw · high confidence

The mobile driver now exposes specific interfaces to handle mobile-only capabilities. Users can programmatically show, hide, or customize the virtual keyboard (including secure password mode) via the new Device interface. Navigation is supported through a GoBack method on the Driver interface to trigger the OS back action. Additionally, the driver now supports granular touch event handling, allowing applications to detect touch down, up, cancel, and move events with multi-touch support via the Touchable and Movable interfaces.

driver/mobile · high confidence

The \cmd/fyne/internal/templates\ package now includes a new \bundled.go\ file that embeds static resources for application packaging across multiple platforms. This change bundles the Android \AndroidManifest.xml\, iOS \Info.plist\ and entitlements, macOS \Info.plist\ and entitlements, Windows \app.manifest\ and \appxmanifest.XML\, and Linux \app.desktop\ and \Makefile\ templates directly into the binary. It also includes web-specific assets like \index.html\, \dark.css\, \light.css\, and \spinner\_dark.gif\ for the web driver, along with Go templates for metadata initialization (\fyne\_metadata\_init.got\) and pprof injection (\fyne\_pprof.got\). This ensures that packaging tools have access to these necessary configuration files without depending on external file paths, supporting reproducible builds and cross-platform distribution.

cmd/fyne/internal/templates · high confidence

The data binding package has been rewritten to use Go generics, introducing new type-safe interfaces like Item\[T\] and List\[T\] that replace the previous untyped binding mechanisms. This change brings significant new capabilities, including logical boolean operations (Not, And, Or) for combining boolean bindings, and direct conversion bindings between Int and Float types. Existing untyped bindings are deprecated in favor of the new generic versions, and the API now enforces stricter type safety while maintaining thread-safety across all operations.

data/binding · high confidence

The Fyne Demo application's tutorial section has been completely restructured into a modular package, introducing new demonstrations for data binding (including list and struct binding), canvas animations, and advanced screen information like scale and texture resolution. The demo now showcases updated container layouts such as InnerWindow and DocTabs, new collection widgets like GridWrap, and enhanced dialog capabilities with validation. Additionally, it includes a new shader-based 3D cube animation, an icon browser, and a custom theme example to illustrate the toolkit's theming API.

_cmd/fyne\demo/tutorials · high confidence

The internal GL painter now supports rendering arbitrary polygons, arcs, ellipses, and Bézier curves using signed distance field (SDF) fragment shaders, alongside optimized shaders for rounded rectangles with support for large corner radii and shadows. A new blur shader enables Gaussian blurs with configurable radii and corner-radius masking, while line shaders provide feathered edges. These changes bring GPU-accelerated drawing capabilities to mobile (OpenGL ES) and desktop platforms, improving visual fidelity and performance for complex UI elements.

internal/painter/gl/shaders · high confidence

This change introduces the first pass of accessibility support for mobile devices, enabling screen readers like TalkBack on Android and VoiceOver on iOS to interact with Fyne applications. The implementation adds platform-specific bridges (accessibility\_android.go/c and accessibility\_ios.go/m) that traverse the canvas hierarchy to expose visible leaf elements (buttons, text, links) as native accessibility nodes. This allows visually impaired users to navigate and interact with the app using standard mobile accessibility tools.

internal/driver/mobile · high confidence

The \cmd/fyne/internal/mobile\ package has been added, containing a partial clone of the \golang.org/x/mobile/cmd/gomobile\ toolchain. This includes the build logic for Android (APK/AAB) and iOS (IPA), certificate handling, and APK signing. This change introduces a new internal dependency for mobile builds, replacing the previous external \gomobile\ tool requirement with an integrated, vendored implementation.

cmd/fyne/internal/mobile · high confidence

The internal mobile driver now includes the \key\ package, defining the \Event\ struct, \Code\ constants for physical keys, and \Modifiers\ for keyboard input handling. This change introduces the foundational data structures for processing keyboard events within the mobile driver, generated via stringer for code readability.

internal/driver/mobile/event/key · high confidence

Users can now configure application metadata via a new FyneApp.toml file, supporting fields for app details (name, ID, version, icon), source repository information, Linux/BSD desktop entry specifics, language lists, and environment-specific release/development data. The system includes logic to automatically scale bundled icons to the required size to optimize bundle size, and provides APIs to load and save this metadata configuration.

internal/metadata · high confidence

The application now includes a new software painter implementation located in \internal/painter/software\. This engine renders Fyne canvas objects (such as images, text, shapes, gradients, and shadows) directly into memory using standard Go image libraries, providing a fallback or alternative to hardware-accelerated rendering. The implementation supports features like image scaling modes, drop shadows, rounded corners, and clipping, and is accompanied by a comprehensive test suite to verify visual correctness across different canvas elements.

internal/painter/software · high confidence

A new standalone application, Fyne Settings, has been added to allow users to manage saved configuration. The app provides a UI for controlling appearance settings, including scale selection and animation toggles, and is registered with metadata (ID io.fyne.settings) for inclusion in app listings.

_cmd/fyne\settings · high confidence

A new standalone Hello World demonstration application has been added to the repository, providing users with a minimal, runnable example of a Fyne GUI. The app, located in cmd/hello, features a simple interface with a label and a button that updates the text upon interaction, serving as a quick starting point for new users to understand basic widget usage and window management in Fyne v2.

cmd/hello · high confidence

The app package now implements platform-specific notification and system tray capabilities. On macOS, it uses the native UserNotifications framework for immediate and scheduled alerts, with a fallback to osascript for unbundled apps. Windows notifications are delivered via PowerShell scripts using the Windows Toast API, supporting scheduled and cancelled notifications. Linux desktop environments utilize D-Bus directly or the xdg-desktop-portal (specifically for Flatpak) to send notifications. Additionally, system tray menus and icons are now configurable on macOS, Windows, and Linux through the new SetSystemTrayMenu, SetSystemTrayIcon, and SetSystemTrayWindow methods.

app · high confidence

The container package now includes dedicated \AppTabs\ and \DocTabs\ widgets for managing application sections and document-based content, respectively, replacing the previous generic \TabContainer\. These new containers support dynamic item management, tab disabling, and theme overrides. Additionally, a new \Clip\ container has been added to restrict rendering to a specific rectangular area, providing a way to hide content that extends beyond defined bounds.

container · high confidence

The \fyne\ CLI now includes dedicated commands for building (\fyne build\), bundling assets (\fyne bundle\), and installing (\fyne install\) applications. The build command supports targeting specific operating systems, enabling release mode, and injecting custom metadata or pprof profiling. The bundle command embeds static resources into Go code, while the install command packages and deploys applications to system directories, including Start Menu integration on Windows and proper icon handling on macOS and mobile platforms.

cmd/fyne/internal/commands · high confidence

A new \Split\ function has been added to the \internal/repository/mime\ package, allowing users to separate a full MIME type string (e.g., "text/plain") into its main type and subtype components. The implementation uses \strings.Cut\ for efficient parsing and includes handling for edge cases like missing subtypes or empty strings.

internal/repository/mime · high confidence

The \internal/painter/gl\ package now provides a complete, standalone OpenGL renderer for Fyne. This change introduces a new \Painter\ interface and implementation that handles all canvas drawing operations—including shapes, text, images, shadows, and blurs—via dedicated GL shaders and a unified \context\ abstraction. The renderer supports multiple backends (desktop GL, GLES, mobile, and WASM) through platform-specific build tags, implements GPU-side blur using a two-pass separable algorithm, and adds a \Capture\ method to render the canvas to an in-memory image.

internal/painter/gl · high confidence

The Fyne Settings application now includes a dedicated Appearance screen allowing users to select between Dark, Light, and System default themes (on macOS and Windows), choose a primary color, toggle widget animations, and adjust the UI scale with live previews. This change introduces new settings components (appearance.go, scale.go) and a bundled icon, replacing the previous appearance configuration interface.

_cmd/fyne\settings/settings · high confidence

The internal/build package now exposes compile-time constants that allow applications to be customized via build tags. Users can disable animations with the 'no\_animations' tag, enable hints with 'hints', disable metadata with 'no\_metadata', and disable thread safety checks for performance with 'migrated\_fynedo'. The package also detects the build environment, setting IsFlatpak for Flatpak packages, IsWayland for Wayland sessions, and HasNativeMenu for native menus on macOS (unless 'no\_native\_menus' is used). Additionally, the build mode (Debug, Release, or Standard) is now exposed via the Mode constant.

internal/build · high confidence

The canvas package introduces several new drawing primitives: Arc (including pie and doughnut variants), Blur, BezierCurve (linear, quadratic, and cubic), Ellipse, and ArbitraryPolygon. It also adds animation support via NewColorRGBAAnimation, NewPositionAnimation, NewSizeAnimation, and NewShaderAnimation, allowing developers to animate colors, positions, sizes, and shader uniforms. Additionally, Image now supports a CornerRadius property for rounded corners and a new ImageFillCover mode for aspect-ratio-preserving fills that clip content.

canvas · high confidence

The \driver/desktop\ package now exposes a set of new extension interfaces that allow applications to access desktop-specific capabilities. \desktop.App\ enables setting system tray menus, icons, and associating a window with the tray for left-click activation. \desktop.Window\ provides methods to request full-screen mode on secondary monitors, keep windows always on top, and request specific window positions. \desktop.Driver\ adds support for creating splash windows, querying active key modifiers, and detecting secondary displays. Input handling is enhanced via \desktop.Keyable\ and \desktop.Mouseable\ for granular key and mouse events, while \desktop.Cursorable\ allows custom cursor definitions. Additionally, \desktop.Canvas\ exposes raw key down/up hooks, and \desktop.Shortcut\ introduces a \CustomShortcut\ type for complex keyboard combinations.

driver/desktop · high confidence

The new \driver\ package provides the \NativeWindow\ interface, allowing applications to access platform-specific runtime contexts (such as Android JVM pointers, Windows HWND, macOS NSWindow, and Wayland surfaces) via the \RunNative\ method. It also introduces the \Painter\ interface for rendering canvases to images, consolidating these low-level platform interactions and utilities into a single location.

driver · high confidence

The \driver/embedded\ package introduces a new \Driver\ interface and \Event\ type, providing a standardized way to integrate Fyne with custom embedded hardware. This interface allows applications to handle rendering, run loops, screen size queries, and event queuing directly on embedded devices, serving as a replacement for the previous v1 'set driver' concept.

driver/embedded · high confidence

The library introduces new embedded event types for mobile input, including \KeyEvent\ and \CharacterEvent\ in \driver/embedded/keyboard.go\ and touch events (\TouchDownEvent\, \TouchMoveEvent\, \TouchUpEvent\) in \driver/embedded/touch.go\, enabling applications to handle hardware and virtual keyboard actions as well as multi-touch interactions. Additionally, \geometry.go\ adds a \Vector2\ interface and a \Delta\ type to represent generic X/Y coordinates and movements, alongside helper methods like \NewSquareOffsetPos\ and \NewSquareSize\ for creating square-aligned positions and sizes.

fyne.io/fyne/v2 · high confidence

Added new utility functions in the internal util package to support file operations and mobile platform detection. The file.go module provides helpers for checking file existence, copying files with specific permissions (including executable files), ensuring subdirectories exist, resolving absolute paths, and making paths relative to a root. The mobile.go module introduces functions to locate Android build tools (specifically zipalign) via the ANDROID\_HOME environment variable, and to detect whether a target OS string corresponds to Android, iOS, or other mobile platforms handled by gomobile. Tests were added to verify the mobile platform detection logic.

cmd/fyne/internal/util · high confidence

The \internal/driver/mobile/gl\ package now provides a complete OpenGL ES 2.0/3.0 binding layer for mobile rendering. This includes a Go API for GL operations, a C backend for batching calls on Unix-like systems, and a Windows implementation that automatically downloads and loads the ANGLE library (libglesv2, libegl, d3dcompiler\_47) to provide hardware-accelerated graphics on Windows without requiring native OpenGL drivers.

internal/driver/mobile/gl · high confidence

The internal/async package now provides a suite of concurrency primitives to support the new threading model. This includes an unbounded generic channel (UnboundedChan) and a specialized struct channel (UnboundedStructChan) for non-blocking, FIFO event buffering, alongside a lock-free concurrent queue (CanvasObjectQueue) and a single-threaded ring-buffer queue for migrated builds. A generic Map wrapper and Pool are also introduced to manage concurrent data structures and reduce allocations. These components are selected at build time via the 'migrated\_fynedo' tag, allowing the application to switch between a multi-threaded execution model (using sync primitives) and a single-threaded model (using ring buffers and no-ops) to prevent deadlocks and improve performance.

internal/async · high confidence

This change introduces several new internal packages to support core framework capabilities. The \internal/clip\ package provides a \ClipStack\ for managing nested clipping regions, ensuring correct intersection calculations for scroll containers and other clipped areas. The \internal/docs\ package implements the document storage interface, allowing applications to create, list, open, save, and remove documents within a scoped URI, with proper URL encoding for non-file schemes. Additionally, the \internal/overlay\_stack\ package consolidates overlay management into a dedicated stack that handles z-ordering, focus manager tracking, and automatic resizing to fit the canvas's interactive area, while \internal/geometry\ adds allocation-free size comparison helpers for performance-critical layout code.

internal · high confidence

The layout package introduces several new layout strategies to improve UI flexibility: BorderLayout positions items at the edges with remaining content in the center; FormLayout arranges objects in a two-column label-and-widget grid; RowWrapLayout dynamically flows items into rows based on available width; GridWrapLayout wraps fixed-size cells into rows; and CenterLayout centers children within their container. Additionally, VBox and HBox layouts now support custom padding via NewCustomPaddedVBoxLayout and NewCustomPaddedHBoxLayout, and a new CustomPaddedLayout allows specifying distinct padding values for each side. These changes provide developers with more declarative and fine-grained control over container sizing and alignment.

layout · high confidence

The \lang\ package introduces a new translation and localization API for Fyne applications, providing functions like \Localize\, \LocalizeKey\, \LocalizePlural\, and \LocalizePluralKey\ (with shortcuts \L\, \X\, \N\, \XN\) to handle string translation, pluralization, and template data injection. The system supports loading translations from JSON bundles via \AddTranslations\, \AddTranslationsForLocale\, and \AddTranslationsFS\, and includes built-in translations embedded via \embed.FS\. A key behavioral improvement is the robust fallback mechanism: if the system locale cannot be matched to a supported translation (e.g., Serbian Cyrillic resolving to Russian), it now safely falls back to English instead of presenting an unrelated language. The package also exposes \SystemLocale()\ to retrieve the device's primary locale.

lang · high confidence

The Fyne CLI now includes a comprehensive set of new template files in its internal data directory to support packaging and distribution across multiple platforms. For mobile, it provides templates for the Android manifest (including storage and internet permissions) and iOS asset catalogs (xcassets) with standard icon sizes. For desktop, it adds templates for macOS (Info.plist with localization and graphics switching support), Windows (app.manifest and appxmanifest for UWP), and Linux (app.desktop and a Makefile for user/system installation). Additionally, it introduces a new template for the web build entry point (index.html) that bundles the webgl-debug.js file for reproducible builds, supports dark/light CSS themes, and detects Chrome version compatibility for WebAssembly execution.

cmd/fyne/internal/templates/data · high confidence

The tools/playground package now provides functions to render Fyne UIs into inline images suitable for the Go playground and embedded contexts. New helpers like RenderCanvas, RenderWindow, and Render convert canvases and objects into base64-encoded PNGs, utilizing a software driver and a dark theme to ensure consistent visual output without hardware dependencies. A new NewSoftwareCanvas function also allows creating in-memory canvases for rendering without hardware support.

tools · high confidence

A new internal scale package has been introduced to handle conversions between Fyne canvas coordinates and screen pixel coordinates. It provides ToScreenCoordinate and ToFyneCoordinate functions for precise coordinate mapping based on the canvas scale factor, as well as ToFyneSize for converting pixel dimensions to Fyne sizes by automatically detecting the relevant canvas for a given object.

internal/scale · high confidence

The internal painter now includes a software rendering backend that supports drawing circles, arcs, lines, rectangles, ellipses, and polygons (both regular and arbitrary). This change introduces new canvas types for these shapes and implements their rasterization logic, allowing for consistent rendering across different platforms and improving support for complex vector graphics.

internal/painter · high confidence

The \driver/software\ package now provides a dedicated, generic system for rendering Fyne canvases to images without requiring a window or hardware support. This includes the \WindowlessCanvas\ interface and constructors like \NewCanvas()\ and \NewTransparentCanvas()\ for in-memory rendering, as well as public helper functions \Render()\ and \RenderCanvas()\ that allow users to capture UI components or full canvases as standard Go images using a specified theme. This capability, previously embedded in test utilities, is now exposed for broader use in non-interactive rendering scenarios.

driver/software · high confidence

The storage package introduces a modern API centered on URIs, replacing older file-path-based methods. Users can now parse URIs via \storage.ParseURI\ (with \storage.NewURI\ deprecated) and perform operations like reading (\storage.Reader\), writing (\storage.Writer\), and listing directories (\storage.ListerForURI\). New capabilities include loading resources directly from URIs (\storage.LoadResourceFromURI\) and filtering file dialogs by extension or MIME type using \storage.ExtensionFileFilter\ and \storage.MimeTypeFileFilter\. Error handling is standardized with new \storage.ErrAlreadyExists\ and \storage.ErrNotExists\ errors, and URI equality is handled by \storage.EqualURI\.

storage · high confidence

The internal repository package now includes four new storage backends: \FileRepository\ for local \file://\ URIs, \HTTPRepository\ for remote \http://\ and \https://\ URIs, \InMemoryRepository\ for testing and virtual file systems, and \IndexDBRepository\ for browser-based storage via IndexedDB. These implementations provide standard storage operations (read, write, list, delete, etc.) and are registered with the storage system to handle their respective URI schemes, enabling applications to persist and retrieve data across local disks, remote servers, and web browsers.

internal/repository · high confidence

The data/validation package now includes NewTime for validating strings against specific time formats (since 2.1) and NewAllStrings to combine multiple string validators into a single check (since 2.2). These additions complement the existing NewRegexp validator, providing users with more flexible options for data entry validation in widgets.

data/validation · high confidence

The EFL (Enlightenment Foundation Libraries) driver implementation has been removed from the codebase. This deletes the \ui/drivers/efl/efldriver.go\ file, which previously handled window creation and rendering using Ecore and Evas C libraries for both Wayland and X11 backends.

ui/drivers · high confidence

The legacy \ui/driver.go\ and \ui/window.go\ files have been removed, eliminating the \Driver\ and \Window\ interfaces that previously defined the core UI abstraction. This change removes the global \driver\ variable and the basic window title management methods, indicating a shift away from the previous driver-based architecture towards a new implementation (likely the EFL abstraction mentioned in commit messages, though not visible in this diff).

ui · high confidence

The gendex tool, which generates the Android dex file for Go mobile apps, now uses golang.org/x/sys/execabs instead of the standard os/exec package. This change improves security on Windows by preventing command injection via PATH manipulation when invoking javac and dx.

cmd/fyne/internal/mobile/gendex · high confidence

This change adds a new \internal/driver/common\ package that consolidates shared implementation details previously scattered across specific drivers. It introduces a common \Canvas\ struct to handle focus management, shortcut handling, and the render cache tree, alongside a \deduplicatedObjectQueue\ to optimize refresh requests by preventing duplicate processing. The package also provides a shared \overlayStack\ that manages render caches for overlays and a \DonePool\ for efficient channel reuse in window operations. These components serve as the foundational layer for standardizing how different drivers (such as GLFW and mobile) manage rendering, layout, and event loops.

internal/driver/common · high confidence

The internal animation runner now correctly handles changes to an animation's duration while it is running. Previously, altering the duration could cause the animation progress to snap or reset unexpectedly. The new implementation pins the current progress and time when a duration change is detected, ensuring the animation continues smoothly from its current state against the new duration, whether the duration is increased or decreased.

internal/animation · high confidence

The \cmd/fyne/commands\ package now marks the \Command\ interface and the \NewBundler\, \NewInstaller\, \NewPackager\, and \NewReleaser\ constructors as deprecated, signaling that direct access to internal CLI commands is being removed. While \NewGetter\ remains available for downloading and installing Fyne apps, users relying on the other bundled tools should expect these to be replaced by better versions in the future. A test has been added to verify the correct initialization of the Getter command.

cmd/fyne/commands · high confidence

The Fyne Demo application has been reorganized into a new repository structure, now including a FyneApp.toml configuration file that defines app metadata (version 2.8.0, ID io.fyne.demo) and platform-specific details for Linux/BSD. The main entry point (main.go) now initializes the app with lifecycle logging for start, stop, and foreground/background transitions, and displays a dialog informing users of the move to the new repository. The demo UI includes a main menu with File, Edit, and Help sections, featuring shortcuts for Cut/Copy/Paste and a Settings option. A new theme.go file introduces a forcedVariant theme wrapper to test theme color retrieval under specific variants, accompanied by corresponding unit tests in theme\_test.go.

_cmd/fyne\demo · high confidence

The internal theme package has been restructured to support dynamic feature overrides and improved rendering context management. A new feature system allows themes to override specific capabilities, such as forcing a mobile form factor for tabs, via the new FeatureTheme interface and FeatureForWidget lookup. Additionally, a rendering theme stack has been introduced to correctly handle theme overrides during layout and rendering calculations, ensuring that nested or overridden themes are applied accurately. The implementation of primary color lookups (PrimaryColorNamed and ForegroundOnPrimaryColorNamed) and variant constants has also been consolidated into this internal package.

internal/theme · medium confidence

This change introduces foundational internal components for the widget package, including a new \Base\ struct to standardize widget state (size, position, visibility) and \BaseRenderer\/\SimpleRenderer\ to simplify renderer implementations. It also adds an \OverlayContainer\ to manage overlay lifecycle and dismissal, and a \Shadow\ widget to render elevation effects based on Material Design levels. On macOS, scroll bars now respect the system preference for visibility (always visible vs. overlay) and paging behavior, while mobile platforms receive updated drag-to-scroll handling.

internal/widget · high confidence

The storage/repository package now provides a structured, scheme-based repository interface that replaces ad-hoc URI handling. It introduces generic implementations for common hierarchical operations (Parent, Child) and data operations (Copy, DeleteAll) that work across registered URI schemes, ensuring consistent behavior for file URIs (including Windows path normalization) and URNs. URI parsing is now centralized in ParseURI, which validates schemes, handles IPv6 addresses, and delegates to custom parsers when available, while new error types (ErrOperationNotSupported, ErrURIRoot) clarify failure modes for unsupported or root-level operations.

storage/repository · high confidence

A new geometry package has been added to the internal painter module, defining a set of named constants for common angle values (such as 0, 45, 90, 180, and 360 degrees). This change provides standardized angle references for internal geometric calculations, replacing magic numbers with readable identifiers.

internal/painter/geom · high confidence

The internal SVG handling has been refactored into a dedicated \internal/svg\ package, introducing a new \Colorize\ API that allows SVG resources to be dynamically recolored by replacing fill attributes with a specified color. The rendering pipeline now utilizes the \oksvg\ and \rasterx\ libraries to parse SVG XML and rasterize it to an \NRGBA\ image, optimizing performance by rasterizing to \RGBA\ first before copying. This change also adds robust detection for SVG files and resources, fixes for handling \currentColor\ at the root node, and support for negative viewport offsets.

internal/svg · high confidence

The internal color package now provides a \Parse\ function to convert CSS-style color strings (such as \\#rgb\, \\#rrggbb\, and their alpha variants) into \color.Color\ objects, along with a \ToNRGBA\ helper that converts various color types into non-premultiplied 8-bit RGBA values. These utilities are internal implementation details used by the framework's theming and widget logic.

internal/color · high confidence

The application now determines the root configuration directory and default theme variant using platform-specific implementations. Config paths are resolved to standard locations for each OS: \\~/Library/Preferences/fyne\ on macOS, \%APPDATA%/fyne\ on Windows, \$XDG\_CONFIG\_HOME/fyne\ on Linux/FreeBSD, \/data/fyne\ on Android, iOS Documents, \/data/\ on WebAssembly, and a temp directory for CI/testing. Theme detection automatically switches between light and dark modes by reading macOS \AppleInterfaceStyle\, Windows registry \AppsUseLightTheme\, XDG system state, or WebAssembly \prefers-color-scheme\. Additionally, the focus manager now prevents focusing disabled or hidden objects and returns a boolean indicating whether a focus request was handled.

internal/app · high confidence

The internal cache system has been rewritten to use expiring cache entries and async maps, replacing previous locking mechanisms. This change introduces a \Clean\ function that runs on paint events to remove expired SVGs, font metrics, blur kernels, renderers, and canvases, which helps prevent memory leaks and reduces per-object allocations during repaints. Theme overrides are now managed via a scope-based system that correctly handles cache keys and cleanup, and texture caching is separated into text and object maps to better match OpenGL contexts.

internal/cache · high confidence

The internal driver package now exposes consolidated utility functions for walking and querying the canvas object tree. \AbsolutePositionForObject\ calculates the global screen position of a UI element, while \FindObjectAtPositionMatching\ identifies which widget is located at a specific coordinate, respecting visibility and clipping bounds. New traversal helpers, \ReverseWalkVisibleObjectTree\ and \WalkCompleteObjectTree\, provide flexible iteration over visible or all objects, supporting features like hit-testing and layout debugging. These changes underpin fixes for focus management, click-through prevention, and hidden element semantics.

internal/driver · high confidence

The theme package has been reorganized to bundle default fonts (Noto Sans, DejaVu Sans Mono Powerline, Inter Symbols, and EmojiOne) and standard icons directly into the binary using Go's embed feature, replacing previous external loading mechanisms. This change introduces a comprehensive set of new theme color names (such as foregroundOnPrimary, headerBackground, and innerWindowBorder) and size names (including innerPadding and lineSpacing) to support more granular styling. Additionally, a legacy wrapper is provided to help migrate from the previous theme interface, and JSON-based theme loading now supports fallback themes for partial overrides.

theme · high confidence

The internal Android binary resource bundle (arsc) has been updated to include metadata required for recent Android OS versions and to support API level 33, ensuring compatibility with the August 31 deadline for new app submissions.

cmd/fyne/internal/mobile/binres · high confidence

The \cmd/fyne\_demo/data\ package now contains a regenerated \bundled.go\ file with an updated \logo.png\ resource. This change reflects the adoption of a new application logo, replacing the previous embedded image asset used in the demo application.

_cmd/fyne\demo/data · high confidence

The Fyne settings application has replaced its custom bundler scripts with the standard \fyne bundle\ tool. This change updates the embedded assets, including new SVG icons for appearance and language settings, and modifies the \data.go\ generation directive to use the official Fyne bundler for creating the bundled Go source file.

_cmd/fyne\settings/data · high confidence

The widget package has been restructured to improve internal organization and performance. Several internal components, including the base renderer, shadowing renderer, and menu item widgets, have been moved into the internal widget package to prevent external misuse and reduce API surface area. Concurrently, the public BaseWidget has been updated to be more easily extensible, and various widgets (such as Slider, Select, and Entry) have been optimized by caching theme lookups, reducing unnecessary refreshes, and improving thread safety through atomic operations and refined locking mechanisms.

widget · medium confidence

The \cmd/fyne\ command-line tool is now deprecated and displays a warning message directing users to install the latest version from \fyne.io/tools/cmd/fyne\. While the tool remains functional and includes commands such as bundle, env, get, install, package, release, version, serve, translate, build, and vendor, users are advised to migrate to the new package location for future updates and support.

cmd/fyne · high confidence

Added internal test utilities for image comparison and font resolution; Added test data fixtures and helper script for widget tests; Expanded test utilities for UI testing and markup rendering; Updated dialog test fixtures and data.

The main module (fyne.io/fyne/v2) has been updated to require Go 1.22.0 and upgraded numerous dependencies, including systray, toml, fsnotify, gl-js, glfw-js, image, oksvg, go-gl bindings, go-text render/typesetting, dbus, portal, icns, locale, goversioninfo, goinfo, runewidth, version, atomic, resize, go-i18n, cli, goldmark, image, mod, sys, text, and tools. Additionally, two new test data modules were added under cmd/fyne/internal/commands/testdata to support testing of module-based application packaging.

(dependencies) · high confidence

The repository has been initialized with essential project configuration files, including a .gitattributes file to enforce LF line endings for Go source code, a .gitignore file to exclude build artifacts and IDE settings, a .golangci.yml file to configure the linter suite (including revive, gosec, and staticcheck), and standard documentation files such as LICENSE, AUTHORS, CHANGELOG.md, and README.md.

(repo-wide) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 42 → 45 (+2.5)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 78 → 84 (+5.6)
• Architecture 99 → 93 (-5.5)
• Maturity 55 → 55 (+0.1)
• Readiness 68 → 68 (+0.0)
• Security 43 → 52 (+9.2)
• Accessibility 28 → 28 (+0.0)

• Change coupling: app_darwin.go ↔ app_mobile_ios.go (app/app_darwin.go)
• Change coupling: draw.go ↔ vector.go (internal/painter/draw.go)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (cmd/fyne/internal/mobile/binres/node.go)
• Duplicated block (10 lines × 2) (cmd/fyne/internal/mobile/build_androidapp.go)
• Duplicated block (10 lines × 2) (cmd/fyne_demo/tutorials/collection.go)
• Duplicated block (10 lines × 2) (internal/painter/draw.go)
• Duplicated block (10 lines × 2) (internal/painter/gl/draw.go)
• Duplicated block (10 lines × 2) (widget/check_group.go)
• Duplicated block (10 lines × 2) (widget/entry.go)
• Duplicated block (10 lines × 2) (widget/gridwrap.go)
• Duplicated block (10 lines × 2) (widget/textgrid.go)
• Duplicated block (11 lines × 2) (internal/driver/embedded/touchscreen.go)
• Duplicated block (11 lines × 2) (internal/painter/gl/draw.go)
• Duplicated block (11 lines × 2) (internal/painter/gl/draw.go)
• Duplicated block (11 lines × 2) (widget/table.go)
• Duplicated block (11 lines × 3) (container.go)
• Duplicated block (11 lines × 8) (internal/painter/gl/draw.go)
• Duplicated block (12 lines × 2) (internal/driver/embedded/driver.go)
• …and 97 more

• Bundler.Run (cognitive 17) (cmd/fyne/internal/commands/bundle.go)
• Change coupling: draw.go ↔ painter.go (internal/painter/draw.go)
• ClassTooLong: Entry (widget/entry.go)
• ClassTooLong: Table (widget/table.go)
• Dependency pinned to a stale untagged commit: github.com/mcuadros/go-version
• Dependency pinned to a stale untagged commit: github.com/nfnt/resize
• Dependency pinned to a stale untagged commit: github.com/srwiley/rasterx
• Deprecated module: golang.org/x/tools/go/vcs
• Duplicated block (10 lines × 2) (cmd/fyne/internal/mobile/build_androidapp.go)
• Duplicated block (10 lines × 2) (data/binding/maps.go)
• Duplicated block (10 lines × 2) (internal/driver/embedded/touchscreen.go)
• Duplicated block (10 lines × 2) (layout/boxlayout.go)
• Duplicated block (10 lines × 2) (widget/entry.go)
• Duplicated block (11 lines × 2) (cmd/fyne_demo/tutorials/collection.go)
• Duplicated block (11 lines × 2) (data/binding/lists.go)
• Duplicated block (11 lines × 2) (internal/driver/embedded/touchscreen.go)
• Duplicated block (11 lines × 2) (internal/painter/draw.go)
• Duplicated block (11 lines × 2) (storage/repository/generic.go)
• Duplicated block (11 lines × 2) (widget/gridwrap.go)
• Duplicated block (11 lines × 2) (widget/gridwrap.go)
• …and 392 more

• 205 commits — 175 feature/other, 30 fixes

• internal/driver — 38 commits
• storage/repository — 27 commits
• (root) — 23 commits
• (repo) — 17 commits
• data/binding — 12 commits
• internal/painter — 9 commits
• widget/entry.go — 9 commits
• app/app.go — 5 commits
• container/apptabs.go — 5 commits
• container/innerwindow.go — 5 commits
• .github/workflows — 3 commits
• driver/software — 3 commits
• internal/cache — 3 commits
• widget/gridwrap.go — 3 commits
• widget/popup.go — 3 commits
• widget/richtext.go — 3 commits
• app/storage_test.go — 2 commits
• canvas/rectangle.go — 2 commits
• dialog/file.go — 2 commits
• internal/app — 2 commits

• fix: A temporary fix until the upstream PR is landed
• fix: Add fix and test for file URIs with special characters that need encoding
• fix: Bug fixes in SVG
• fix: Fix apps with systray showing hidden "SystrayMonitor" window on KDE Wayland (#6428)
• fix: Fix file paths on windows
• fix: Fix iOS build
• fix: Fix inconsistent vertical positioning of mixed-font text lines (#6448)
• fix: Fix issue where iOS feels much slower than Android (#6513)
• fix: Fix issue where some touchscreen taps are missed
• fix: Fix issue where tab hints were missed on constructor
• fix: Fix issue with the emoji parser
• fix: Fix issue with the emoji parser
• fix: Fix nil pointer panic in FileDialog before Show
• fix: Fix ranges
• fix: Fix selection of row on mobile triple tap
• fix: Fix submenus taller than the window not being scrollable
• fix: Fix: Multiline Entry ignores scroll position on mobile TouchDown (#6307)
• fix: Fix: rebuild native MacOS menu when switching windows (#6431)
• fix: Fix: rebuild native MacOS menu when switching windows (#6431)
• fix: Merge pull request #6463 from andydotxyz/fix/systrayshortcut
• …and 185 more

• Unchanged — 0 containers · 1 contexts · 0 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

fyne-io/fyne was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.