awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
fyne-io avatar

fyne-io/fyne

0
View on GitHub↗
27,941 stars·1,508 forks·Go·other·37 viewsfyne.io↗

Fyne

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.

Features

  • Cross-Platform GUI Toolkits - Serves as a cross-platform graphical user interface toolkit for Go, enabling native application development for desktop, mobile, and web.
  • Native Binary Packagers - Bundles source code into platform-specific native binaries and installers for desktop, mobile, and web deployment.
  • Cross-Platform UI Frameworks - Provides a framework using a canvas-based rendering engine and device-independent layout engine for consistent cross-platform UI.
  • Reactive Data Bindings - Synchronizes application state with interface components automatically using a reactive data-binding system.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
  • Application Packaging - Bundles source code into native graphical applications with platform-specific installers.
  • Canvas Rendering Engines - Provides a canvas-based rendering engine for drawing primitives and widgets on a unified coordinate surface.
  • Widget Data Bindings - Connects application data sources to interface elements so that visual components automatically update.
  • Cross-Compilation Toolchains - Enables cross-compilation of native graphical binaries for multiple operating systems and architectures.
  • Multi-Platform Build Orchestrators - Automates the generation of native binaries and installation packages across multiple desktop and mobile platforms.
  • Event Loop Initializers - Starts a persistent event loop process to maintain graphical interface responsiveness and handle user interactions.
  • Automatic Layout Engines - Organizes graphical components using predefined rules that automatically handle positioning and scaling based on available space.
  • Component Hierarchies - Organizes user interface components into a tree-based hierarchy for layout and event propagation.
  • Graphical Application Runtimes - Initializes graphical application instances using default runtime drivers to manage lifecycle and display.
  • Interactive Widgets - Provides a comprehensive library of pre-built interactive widgets for constructing complex user interfaces.
  • Resolution-Independent Engines - Calculates component positions dynamically based on container constraints to support varying screen densities.
  • Window Management - Creates and manages graphical windows with support for multi-window workflows and lifecycle control.
  • Desktop and GUI Development - Material Design GUI framework.
  • Go Desktop Frameworks - Cross-platform GUI toolkit inspired by Material Design.
  • Graphical User Interfaces - Cross-platform GUI toolkit designed for Go.
  • GUI and Desktop Development - Cross-platform GUI toolkit for native desktop applications.
  • GUI Development - Cross-platform GUI toolkit based on Material Design.
  • GUI Frameworks - Builds native GUIs based on Material Design.
  • Asset Embedding - Bundles external resources directly into compiled binaries during the build process for portable distribution.
  • Custom Component Builders - Supports the creation of custom interface elements by separating state management from rendering logic.
  • Custom UI Components - Creates unique interface elements by separating state management from rendering logic.
  • Display Scaling - Adjusts interface display size based on system settings and screen pixel density for consistent physical dimensions.
  • Dynamic List Rendering - Displays large datasets efficiently by reusing templates and fetching data on demand.
  • Input Components - Provides a variety of specialized input components including text fields, password inputs, and editable dropdown menus.
  • Windowing Abstractions - Abstracts native windowing protocols and system APIs through swappable backends for cross-platform consistency.
  • Native Window Contexts - Provides low-level access to native windowing environments for platform-specific graphical operations.
  • Native System Integrations - Executes custom logic within the host operating system context to access low-level platform APIs and native pointers.
  • Event-Driven Loops - Manages user interactions and rendering via a callback-driven event loop to keep interfaces responsive.
  • List Bindings - Synchronizes collections of data items with interface components for automatic display updates.
  • Data Display Components - Renders large datasets in two-dimensional grids using lazy loading for high-performance tabular data display.
  • File Dialogs - Opens system-native dialogs for selecting files and directories.
  • Interface Layout Customization - Provides a layout interface for programmatically calculating custom positions and minimum sizes for non-standard arrangements.
  • Declarative Layouts - Arranges graphical components using flexible, device-independent rules that automatically handle positioning and resizing.
  • Theme Definitions - Overrides default visual properties globally to ensure a consistent look and feel.
  • UI Components - Supports extending standard interface elements with custom logic while maintaining original visual and functional foundations.
  • WebAssembly Compilation - Bundles applications into WebAssembly binaries for cross-platform accessibility within modern web browsers.
  • Data Persistence and Storage - Provides mechanisms to access and manipulate files and data storage locations within the application environment.
  • Data Change Observers - Registers callback functions to automatically react to state changes in bound data items.
  • Map Bindings - Synchronizes key-value pair collections with interface components for reactive updates.
  • Application Identifiers - Assigns globally unique identifiers to application instances to ensure consistent system registration across platforms.
  • Build Environment Configurations - Applies build tags to customize application behavior and resource inclusion for different target environments.
  • Cross-Platform Windowing Abstractions - Offers interfaces to interact with underlying operating system windowing features.
  • Global Application Settings - Loads and persists user-defined configuration values across application sessions to maintain consistent state.
  • User Interaction Simulation - Simulates user input events like typing and clicking to verify application behavior programmatically.
  • Canvas Animations - Transitions visual attributes like size, position, or color over a specified duration to create smooth motion.
  • Canvas Clipping Utilities - Restricts the visibility of graphical elements to defined rectangular boundaries by hiding overflowing child components.
  • Custom Theme Definitions - Overrides default styling by implementing a standard interface for custom colors, sizes, and fonts.
  • Hierarchical Bindings - Synchronizes tree-structured data models with interface components for automatic visual updates.
  • Hierarchical Data Templates - Displays multi-level data structures using a callback-driven approach for high performance.
  • Horizontal Arrangements - Organizes interface components in single rows or columns with automatic uniform dimension calculation.
  • Form Field Layouts - Aligns labels and input fields into structured grid patterns where labels and inputs resize dynamically.
  • Application Themes - Adjusts visual appearance by toggling between light and dark modes using environment variables.
  • Scrollable Containers - Wraps UI elements in scrollable containers to enable navigation through content exceeding the visible display area.
  • Split Containers - Arranges interface elements in split-pane layouts with interactive dividers for resizing sections.
  • System Dialogs - Implements native-style modal windows for user confirmation, error reporting, and file system operations.
  • Tabbed Containers - Groups content panels into switchable tabbed sections using text or icon-based navigation.
  • Toolbar Components - Provides components for building toolbars and navigation stacks to facilitate quick access to application actions.
  • Visual Layering Systems - Stacks visual elements within a container to manage drawing order and front-to-back layering.
  • Platform Integrations - Provides access to platform-specific features for desktop environments to integrate with system-level functionality.

    • Star history

    Star history chart for fyne-io/fyneStar history chart for fyne-io/fyne

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Frequently asked questions

    What does fyne-io/fyne do?

    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.

    What are the main features of fyne-io/fyne?

    The main features of fyne-io/fyne are: Cross-Platform GUI Toolkits, Native Binary Packagers, Cross-Platform UI Frameworks, Reactive Data Bindings, Application Packaging, Canvas Rendering Engines, Widget Data Bindings, Cross-Compilation Toolchains.

    Which projects share features with fyne-io/fyne?

    Projects with overlapping indexed features include: lxn/walk — Walk is a comprehensive framework for building native Windows desktop applications. It functions as a GUI library and… therecipe/qt — This project provides a framework for building native graphical user interfaces that run consistently across desktop… andlabs/ui — This project is a cross-platform UI framework and native desktop GUI library. It provides a unified set of… wjakob/nanogui — nanogui is a native C++ toolkit for rendering interactive user interface components directly within an OpenGL graphics… zserge/webview — This is a lightweight, header-only C/C++ library used to embed browser engines into native desktop applications. It… linebender/druid — Druid is a native user interface toolkit and 2D graphics engine for the Rust programming language. It functions as a…

    Projects sharing features with Fyne

    These projects share indexed features with Fyne. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • lxn/walklxn avatar

      lxn/walk

      7,063View on GitHub↗

      Walk is a comprehensive framework for building native Windows desktop applications. It functions as a GUI library and Windows API wrapper, providing a toolkit of native widgets and a declarative layout system for developing high-performance user interfaces. The project is distinguished by its data-binding framework, which uses reflection and string-based property paths to synchronize data sources with interface widgets. It also provides specialized support for high-DPI interface scaling and an optimized native message loop to reduce runtime overhead. The toolkit covers a wide range of capabi

      Godeclarativedeclarative-uigo
      View on GitHub↗7,063
    • therecipe/qttherecipe avatar

      therecipe/qt

      10,784View on GitHub↗

      This project provides a framework for building native graphical user interfaces that run consistently across desktop and mobile operating systems. It functions as a bridge that allows developers to construct complex application layouts and render high-performance visual elements by utilizing a native C++ widget toolkit. The framework enables the creation of responsive user interfaces through both traditional widget-based components and declarative markup languages. It employs a decoupled messaging system to connect interface components and uses a pre-compilation step to manage object introspe

      Goandroidasteroidoscross-platform-gui
      View on GitHub↗10,784
    • andlabs/uiandlabs avatar

      andlabs/ui

      8,357View on GitHub↗

      This project is a cross-platform UI framework and native desktop GUI library. It provides a unified set of instructions to render native windows, forms, and layouts across different operating systems by mapping high-level instructions to the native widgets and controls of the host environment. The toolkit includes a vector graphics engine for rendering custom shapes, gradients, and high-density images using brushes and matrices. It also serves as a native dialog provider for system-level operations such as file path selection and message box alerts. The library covers a broad range of GUI co

      Go
      View on GitHub↗8,357
    • wjakob/nanoguiwjakob avatar

      wjakob/nanogui

      4,863View on GitHub↗

      nanogui is a native C++ toolkit for rendering interactive user interface components directly within an OpenGL graphics context. It functions as a cross-platform widget library and immediate-mode framework used to create windows, buttons, sliders, and input fields. The toolkit provides specialized capabilities for building technical interfaces, including real-time parameter control panels and custom tooling for graphics-heavy software. It ensures visual consistency across different operating systems and screen resolutions through DPI-aware coordinate scaling. The framework includes a constrai

      C++
      View on GitHub↗4,863
    Compare all 30 related projects→