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·14 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

    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.

    What are some open-source alternatives to fyne-io/fyne?

    Open-source alternatives to fyne-io/fyne 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…

    Open-source alternatives to Fyne

    Similar open-source projects, ranked by how many features they share with Fyne.
    • 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
    See all 30 alternatives to Fyne→