# fyne-io/fyne

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/fyne-io-fyne).**

27,941 stars · 1,508 forks · Go · other

## Links

- GitHub: https://github.com/fyne-io/fyne
- Homepage: https://fyne.io/
- awesome-repositories: https://awesome-repositories.com/repository/fyne-io-fyne.md

## Topics

`android` `cross-platform` `fyne` `go` `golang` `gui` `hacktoberfest` `ios` `theme` `toolkit`

## Description

Fyne is a cross-platform graphical user interface toolkit for the Go programming language. It provides a comprehensive framework for building native applications that run on desktop, mobile, and web environments from a single codebase. The toolkit centers on a canvas-based rendering engine and a device-independent layout engine, ensuring that visual elements maintain consistent dimensions and behavior across diverse operating systems and screen densities.

The project distinguishes itself through a reactive data-binding system that automatically synchronizes application state with interface components, eliminating the need for manual UI refreshes. It includes a built-in native application packager that automates the creation of platform-specific binaries and installers, allowing developers to bundle assets directly into the executable for simplified distribution.

The toolkit covers a broad capability surface, including a modular driver abstraction for system integration, extensive support for custom widget creation, and a robust set of layout management tools. It also provides built-in mechanisms for persistent storage, input handling, and theming, alongside automated testing utilities that support both graphical and headless environments.

## Tags

### User Interface & Experience

- [Cross-Platform GUI Toolkits](https://awesome-repositories.com/f/user-interface-experience/cross-platform-gui-toolkits.md) — Serves as a cross-platform graphical user interface toolkit for Go, enabling native application development for desktop, mobile, and web.
- [Cross-Platform UI Frameworks](https://awesome-repositories.com/f/user-interface-experience/cross-platform-ui-frameworks.md) — Provides a framework using a canvas-based rendering engine and device-independent layout engine for consistent cross-platform UI.
- [Reactive Data Bindings](https://awesome-repositories.com/f/user-interface-experience/reactive-data-bindings.md) — Synchronizes application state with interface components automatically using a reactive data-binding system.
- [Canvas Rendering Engines](https://awesome-repositories.com/f/user-interface-experience/canvas-rendering-engines.md) — Provides a canvas-based rendering engine for drawing primitives and widgets on a unified coordinate surface.
- [Widget Data Bindings](https://awesome-repositories.com/f/user-interface-experience/widget-data-bindings.md) — Connects application data sources to interface elements so that visual components automatically update. ([source](https://docs.fyne.io/architecture/organisation/))
- [Component Hierarchies](https://awesome-repositories.com/f/user-interface-experience/component-hierarchies.md) — Organizes user interface components into a tree-based hierarchy for layout and event propagation.
- [Graphical Application Runtimes](https://awesome-repositories.com/f/user-interface-experience/graphical-application-runtimes.md) — Initializes graphical application instances using default runtime drivers to manage lifecycle and display. ([source](https://docs.fyne.io/api/v2/app/package/))
- [Interactive Widgets](https://awesome-repositories.com/f/user-interface-experience/interactive-widgets.md) — Provides a comprehensive library of pre-built interactive widgets for constructing complex user interfaces. ([source](https://docs.fyne.io/architecture/organisation/))
- [Resolution-Independent Engines](https://awesome-repositories.com/f/user-interface-experience/layout-density-utilities/resolution-independent-engines.md) — Calculates component positions dynamically based on container constraints to support varying screen densities.
- [Window Management](https://awesome-repositories.com/f/user-interface-experience/window-management.md) — Creates and manages graphical windows with support for multi-window workflows and lifecycle control. ([source](https://docs.fyne.io/started/windows/))
- [Custom Component Builders](https://awesome-repositories.com/f/user-interface-experience/custom-component-extensions/custom-component-builders.md) — Supports the creation of custom interface elements by separating state management from rendering logic.
- [Custom UI Components](https://awesome-repositories.com/f/user-interface-experience/custom-ui-components.md) — Creates unique interface elements by separating state management from rendering logic. ([source](https://docs.fyne.io/architecture/widgets/))
- [Display Scaling](https://awesome-repositories.com/f/user-interface-experience/display-scaling.md) — Adjusts interface display size based on system settings and screen pixel density for consistent physical dimensions. ([source](https://docs.fyne.io/architecture/scaling/))
- [Dynamic List Rendering](https://awesome-repositories.com/f/user-interface-experience/dynamic-list-rendering.md) — Displays large datasets efficiently by reusing templates and fetching data on demand. ([source](https://docs.fyne.io/collection/list/))
- [Input Components](https://awesome-repositories.com/f/user-interface-experience/input-components.md) — Provides a variety of specialized input components including text fields, password inputs, and editable dropdown menus. ([source](https://docs.fyne.io/explore/widgets/))
- [Windowing Abstractions](https://awesome-repositories.com/f/user-interface-experience/windowing-abstractions.md) — Abstracts native windowing protocols and system APIs through swappable backends for cross-platform consistency.
- [List Bindings](https://awesome-repositories.com/f/user-interface-experience/data-binding/list-bindings.md) — Synchronizes collections of data items with interface components for automatic display updates. ([source](https://docs.fyne.io/api/v2/data/binding/untypedlist/))
- [Data Display Components](https://awesome-repositories.com/f/user-interface-experience/data-display-components.md) — Renders large datasets in two-dimensional grids using lazy loading for high-performance tabular data display. ([source](https://docs.fyne.io/collection/table/))
- [File Dialogs](https://awesome-repositories.com/f/user-interface-experience/dialogs/file-dialogs.md) — Opens system-native dialogs for selecting files and directories. ([source](https://docs.fyne.io/api/v2/dialog/package/))
- [Interface Layout Customization](https://awesome-repositories.com/f/user-interface-experience/interface-layout-customization.md) — Provides a layout interface for programmatically calculating custom positions and minimum sizes for non-standard arrangements. ([source](https://docs.fyne.io/extend/custom-layout/))
- [Declarative Layouts](https://awesome-repositories.com/f/user-interface-experience/layout-utilities/declarative-layouts.md) — Arranges graphical components using flexible, device-independent rules that automatically handle positioning and resizing.
- [Theme Definitions](https://awesome-repositories.com/f/user-interface-experience/theme-definitions.md) — Overrides default visual properties globally to ensure a consistent look and feel. ([source](https://docs.fyne.io/faq/theme/))
- [UI Components](https://awesome-repositories.com/f/user-interface-experience/ui-components.md) — Supports extending standard interface elements with custom logic while maintaining original visual and functional foundations. ([source](https://docs.fyne.io/extend/extending-widgets/))
- [Canvas Animations](https://awesome-repositories.com/f/user-interface-experience/animation-and-motion-systems/configuration-utility-helpers/animation-properties/canvas-animations.md) — Transitions visual attributes like size, position, or color over a specified duration to create smooth motion. ([source](https://docs.fyne.io/canvas/animation/))
- [Canvas Clipping Utilities](https://awesome-repositories.com/f/user-interface-experience/canvas-clipping-utilities.md) — Restricts the visibility of graphical elements to defined rectangular boundaries by hiding overflowing child components. ([source](https://docs.fyne.io/api/v2/container/clip/))
- [Custom Theme Definitions](https://awesome-repositories.com/f/user-interface-experience/custom-theme-definitions.md) — Overrides default styling by implementing a standard interface for custom colors, sizes, and fonts. ([source](https://docs.fyne.io/extend/custom-theme/))
- [Hierarchical Bindings](https://awesome-repositories.com/f/user-interface-experience/data-binding/hierarchical-bindings.md) — Synchronizes tree-structured data models with interface components for automatic visual updates. ([source](https://docs.fyne.io/api/v2/data/binding/externaltree/))
- [Hierarchical Data Templates](https://awesome-repositories.com/f/user-interface-experience/hierarchical-data-templates.md) — Displays multi-level data structures using a callback-driven approach for high performance. ([source](https://docs.fyne.io/collection/tree/))
- [Horizontal Arrangements](https://awesome-repositories.com/f/user-interface-experience/horizontal-arrangements.md) — Organizes interface components in single rows or columns with automatic uniform dimension calculation. ([source](https://docs.fyne.io/container/box/))
- [Form Field Layouts](https://awesome-repositories.com/f/user-interface-experience/input-labels/field-label-configurators/form-field-layouts.md) — Aligns labels and input fields into structured grid patterns where labels and inputs resize dynamically. ([source](https://docs.fyne.io/container/form/))
- [Application Themes](https://awesome-repositories.com/f/user-interface-experience/presentation-frameworks/theme-systems/application-themes.md) — Adjusts visual appearance by toggling between light and dark modes using environment variables. ([source](https://docs.fyne.io/started/hello/))
- [Scrollable Containers](https://awesome-repositories.com/f/user-interface-experience/scrollable-containers.md) — Wraps UI elements in scrollable containers to enable navigation through content exceeding the visible display area. ([source](https://docs.fyne.io/api/v2/container/scroll/))
- [Split Containers](https://awesome-repositories.com/f/user-interface-experience/split-containers.md) — Arranges interface elements in split-pane layouts with interactive dividers for resizing sections. ([source](https://docs.fyne.io/api/v2/container/split/))
- [System Dialogs](https://awesome-repositories.com/f/user-interface-experience/system-dialogs.md) — Implements native-style modal windows for user confirmation, error reporting, and file system operations. ([source](https://docs.fyne.io/architecture/organisation/))
- [Tabbed Containers](https://awesome-repositories.com/f/user-interface-experience/tabbed-containers.md) — Groups content panels into switchable tabbed sections using text or icon-based navigation. ([source](https://docs.fyne.io/api/v2/container/apptabs/))
- [Toolbar Components](https://awesome-repositories.com/f/user-interface-experience/toolbar-components.md) — Provides components for building toolbars and navigation stacks to facilitate quick access to application actions. ([source](https://docs.fyne.io/explore/widgets/))
- [Visual Layering Systems](https://awesome-repositories.com/f/user-interface-experience/visual-layering-systems.md) — Stacks visual elements within a container to manage drawing order and front-to-back layering. ([source](https://docs.fyne.io/container/stack/))

### DevOps & Infrastructure

- [Native Binary Packagers](https://awesome-repositories.com/f/devops-infrastructure/native-binary-packagers.md) — Bundles source code into platform-specific native binaries and installers for desktop, mobile, and web deployment.
- [Application Packaging](https://awesome-repositories.com/f/devops-infrastructure/distribution-packaging/software-distribution/application-packaging.md) — Bundles source code into native graphical applications with platform-specific installers. ([source](https://docs.fyne.io/started/demo/))
- [Multi-Platform Build Orchestrators](https://awesome-repositories.com/f/devops-infrastructure/cicd-pipeline-automation/core-build-engines/build-tooling/native-build-orchestrators/multi-platform-build-orchestrators.md) — Automates the generation of native binaries and installation packages across multiple desktop and mobile platforms. ([source](https://docs.fyne.io/started/cross-compiling/))
- [Asset Embedding](https://awesome-repositories.com/f/devops-infrastructure/cicd-pipeline-automation/core-build-engines/bundling-extension-architectures/build-tooling-architectures/asset-embedding.md) — Bundles external resources directly into compiled binaries during the build process for portable distribution.

### Development Tools & Productivity

- [Cross-Compilation Toolchains](https://awesome-repositories.com/f/development-tools-productivity/cross-compilation-toolchains.md) — Enables cross-compilation of native graphical binaries for multiple operating systems and architectures. ([source](https://docs.fyne.io/started/cross-compiling/))
- [Native Window Contexts](https://awesome-repositories.com/f/development-tools-productivity/macos-utilities/native-window-contexts.md) — Provides low-level access to native windowing environments for platform-specific graphical operations. ([source](https://docs.fyne.io/api/v2/driver/androidwindowcontext/))
- [Application Identifiers](https://awesome-repositories.com/f/development-tools-productivity/application-identifiers.md) — Assigns globally unique identifiers to application instances to ensure consistent system registration across platforms. ([source](https://docs.fyne.io/api/v2/app/package/))
- [Build Environment Configurations](https://awesome-repositories.com/f/development-tools-productivity/project-scaffolding-config-code-generation/project-scaffolding-configuration/build-configuration/build-environment-configurations.md) — Applies build tags to customize application behavior and resource inclusion for different target environments. ([source](https://docs.fyne.io/explore/compiling/))

### Operating Systems & Systems Programming

- [Event Loop Initializers](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/event-loops/event-loop-initializers.md) — Starts a persistent event loop process to maintain graphical interface responsiveness and handle user interactions. ([source](https://docs.fyne.io/started/apprun/))
- [Native System Integrations](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/system-programming-primitives/system-abstractions/native-interoperability-bindings/native-system-integrations.md) — Executes custom logic within the host operating system context to access low-level platform APIs and native pointers. ([source](https://docs.fyne.io/api/v2/driver/package/))
- [Cross-Platform Windowing Abstractions](https://awesome-repositories.com/f/operating-systems-systems-programming/desktop-environment-frameworks/desktop-environment-components/window-management-systems/cross-platform-windowing-abstractions.md) — Offers interfaces to interact with underlying operating system windowing features. ([source](https://docs.fyne.io/api/v2/driver/nativewindow/))

### Software Engineering & Architecture

- [Automatic Layout Engines](https://awesome-repositories.com/f/software-engineering-architecture/automatic-configuration/automatic-layout-engines.md) — Organizes graphical components using predefined rules that automatically handle positioning and scaling based on available space. ([source](https://docs.fyne.io/faq/layout/))
- [Global Application Settings](https://awesome-repositories.com/f/software-engineering-architecture/application-lifecycle-management/configuration-management/configuration-scopes/application-configuration/global-application-settings.md) — Loads and persists user-defined configuration values across application sessions to maintain consistent state. ([source](https://docs.fyne.io/api/v2/app/settingsschema/))

### Programming Languages & Runtimes

- [Event-Driven Loops](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtimes/asynchronous-execution-engines/event-driven-loops.md) — Manages user interactions and rendering via a callback-driven event loop to keep interfaces responsive.

### Web Development

- [WebAssembly Compilation](https://awesome-repositories.com/f/web-development/webassembly-compilation.md) — Bundles applications into WebAssembly binaries for cross-platform accessibility within modern web browsers. ([source](https://docs.fyne.io/started/webapp/))
- [Platform Integrations](https://awesome-repositories.com/f/web-development/cross-platform-desktop-frameworks/platform-integrations.md) — Provides access to platform-specific features for desktop environments to integrate with system-level functionality. ([source](https://docs.fyne.io/api/v2/driver/desktop/app/))

### Data & Databases

- [Data Persistence and Storage](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/data-persistence-storage.md) — Provides mechanisms to access and manipulate files and data storage locations within the application environment. ([source](https://docs.fyne.io/architecture/organisation/))
- [Data Change Observers](https://awesome-repositories.com/f/data-databases/data-processing-pipelines/processing-pipelines/item-pipelines/data-change-observers.md) — Registers callback functions to automatically react to state changes in bound data items. ([source](https://docs.fyne.io/api/v2/data/binding/datalistener/))
- [Map Bindings](https://awesome-repositories.com/f/data-databases/key-value-pair-managers/map-bindings.md) — Synchronizes key-value pair collections with interface components for reactive updates. ([source](https://docs.fyne.io/api/v2/data/binding/untypedmap/))

### Testing & Quality Assurance

- [User Interaction Simulation](https://awesome-repositories.com/f/testing-quality-assurance/automation-interaction-tools/user-interaction-simulation.md) — Simulates user input events like typing and clicking to verify application behavior programmatically. ([source](https://docs.fyne.io/started/testing/))