asticode/go-astilectronArchived

Features

• Cross-Platform GUI Frameworks - Provides a framework for creating cross-platform desktop software by combining web technologies with a Go backend.
• Web-Technology Desktop GUIs - Enables the creation of cross-platform desktop applications by combining a Go backend with a web-based Electron frontend.
• Cross-Platform Desktop Applications - Provides a framework for building cross-platform desktop applications using a Go backend and web frontend.
• Electron Applications - Facilitates the development of Electron-based desktop applications with application lifecycle management in Go.
• Browser Window Initialization - Provides the core capability to initialize web-based browser windows with configurable dimensions and positioning.
• Runtime Dependency Provisioning - Manages the download and setup of required runtime dependencies to launch the cross-platform GUI application.
• Single-Binary Distributions - Packages the entire application and its dependencies into a single executable file for simplified distribution.
• Desktop Application Bundling - Provides a pipeline for bundling Go binaries and Electron assets into distributable desktop application packages.
• JSON Stream Bridges - Uses standard input and output streams to exchange JSON-serialized events between the Go backend and JavaScript frontend.
• Inter-Process Communication Bridges - Send and receive data between the compiled backend and the web frontend using asynchronous messaging and callbacks.
• Cross-Language Data Exchange - Implements a bidirectional asynchronous messaging system to exchange data between Go and JavaScript.
• Native-to-UI Bridges - Provides a bridge to connect the native Go logic layer to the Electron user interface.
• Asynchronous Event Dispatchers - Implements a non-blocking event dispatcher to route messages between the Go backend and the Electron frontend.
• Cross-Language State Synchronizations - Synchronizes application state between Go and JavaScript using a structured asynchronous messaging system.
• Cross-Language Messaging Bridges - Provides an asynchronous messaging system to exchange data and coordinate state between Go and JavaScript.
• Cross-Platform Desktop Development - Enables the creation of native desktop applications for multiple operating systems using a single codebase.
• Frontend Process Decoupling - Decouples the application logic from the rendering engine by executing the frontend as a separate child process.
• Inter-Process Communication Bridges - Implements an asynchronous JSON messaging system to exchange events between a Go process and a JavaScript interface.
• Window Positioning Control - Provides programmatic setting of window coordinates and dimensions to center the interface or place it in specific display areas.
• Desktop GUI Orchestration - Orchestrates native system features like system tray icons and window geometry from the Go backend.
• Desktop Windowing Management - Provides comprehensive control over desktop windows, including resizing, maximizing, and focus management.
• Electron Go Bindings - Connects a Go backend process to an Electron frontend using an asynchronous JSON messaging bridge.
• Window Lifecycle Monitors - Implements callbacks for tracking real-time window state changes such as resizing, focusing, and blurring.
• Remote JavaScript Execution - Runs JavaScript code directly within web contents to manipulate the frontend from the Go backend.
• System Dialogs - Triggers native OS-level interface elements for displaying alerts, confirmation boxes, and file interaction prompts.
• Window Configuration - Provides APIs for defining initial window properties such as size, title, and URL for web-based content.
• Window Focus Control - Manages the interaction priority and z-index stacking by focusing or blurring active application windows.
• Backend-Frontend Bridges - Implements a communication layer that exposes compiled Go backend logic to the web-based frontend.
• Application Asset Bundling - Packages application logic and runtime assets into distributable installers for multiple target operating systems.
• Runtime Provisioning - Automatically downloads and installs platform-specific binary dependencies at runtime to ensure the correct execution environment.
• Distribution and Packaging - Bundles application binaries and assets into distributable formats for multiple operating systems.
• Native Application Bundlers - Packages Go binaries and Electron assets into standalone executable files and installers.
• Structured Data Exchanges - Exchanges structured JSON event data, such as window options and notifications, between application logic and the UI.
• Application Menus - Enables the creation and modification of native application menus, including nested items and checkboxes.
• Global Keyboard Shortcuts - Binds keyboard combinations to backend functions that execute regardless of window focus.
• Desktop Alert Triggers - Triggers OS-level desktop notifications from the backend to alert users of events.
• Window State Controls - Enables programmatic control over window states, including resizing, maximizing, and toggling developer tools.
• Menu Behavior Logic - Allows configuration of menu item visibility, enabled states, and keyboard accelerators.
• Menu Event Handlers - Triggers specific backend logic or events when users interact with application menu items.
• Native System Dialogs - Triggers native system-level alerts and file picker dialogs for opening or saving files.
• Hardware Display Querying - Retrieves hardware display properties such as screen dimensions and scale factors for accurate window placement.
• Event Handlers - Allows the registration of listeners that respond to system or application events to trigger custom behaviors.
• Application Event Dispatching - Marshals event data into a structured format to trigger actions in the user interface from the backend.
• Menu Item Definitions - Provides the ability to define menu entries with custom labels and roles like checkboxes or radio buttons.
• Tray Popup Menus - Triggers context-sensitive popup menus at the location of a system tray icon with precise screen positioning.
• Modal Display Controllers - Provides utilities for triggering and managing modal message boxes for user alerts and confirmations.
• Native Interface Construction - Provides a Go interface to build and manage native desktop elements like dialogs and menus.
• Native OS API Wrappers - Maps Go function calls to native system operations for windows, menus, and tray integration.
• Nested Menus - Supports the creation of hierarchical menu structures with embedded sub-menus.
• System Menus - Manages the creation of native operating system application menus, popups, and keyboard shortcuts.
• System Tray Wrappers - Provides a native wrapper to manage system tray icons and associated context menus.
• System Tray Icons - Creates and manages system tray icons with custom images and tooltips that respond to user click events.
• Dock Visibility Controllers - Provides programmatic control over the visibility and iconography of the application icon in the system dock.
• Dock Context Menus - Implements custom context menus attached to the application dock icon for quick access to common actions.
• Application Event Listeners - Handles application-level event orchestration to trigger backend callbacks in response to window or process events.
• Desktop Notifications - Renders native on-screen alerts and visual notifications, including support for user replies on macOS.
• Event Listeners - Provides mechanisms for registering and responding to application lifecycle events such as crashes or resizing.
• Asynchronous Event Triggering - Routes specific events to registered callback functions based on identifiers to execute asynchronous logic.
• Desktop and GUI Development - Electron-based cross-platform development.
• Graphical User Interfaces - Build cross-platform GUIs using Electron and Go.
• GUI Development - Builds GUI apps using Electron and Go.

Star history