Projects sharing features with Webview

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

CefSharp is a .NET binding for the Chromium Embedded Framework that allows developers to embed a full web browser into desktop applications. It provides an embedded browser control for rendering HTML, CSS, and JavaScript content within a native host window. The project features a bidirectional JavaScript bridge interface that enables the execution of scripts and the exposure of native host classes and methods to the browser environment. It also includes a headless browser automation tool for executing web tasks and capturing page screenshots without a graphical user interface. The library co

Phoenix is a cross-platform Python framework designed for building native desktop graphical user interfaces. It functions as a language binding generator and build automation system, enabling developers to create applications that utilize the underlying operating system's native controls and visual styles. The project provides a mechanism for mapping native C++ graphical toolkit components to Python, allowing for the development of desktop

Wails is a cross-platform framework for building native desktop applications by combining a Go backend with web-based frontend technologies. It enables developers to create lightweight software by utilizing the host operating system's native web rendering engine, eliminating the need to bundle heavy browser dependencies. The framework distinguishes itself through a robust communication layer that bridges the backend and frontend. It automatically generates type-safe JavaScript bindings and proxies from Go code, allowing for seamless, asynchronous method invocation and data serialization acros

This project is a Go WebAssembly frontend framework designed for building interactive web applications. It provides a toolkit for executing Go code directly in the browser to handle client-side logic and user interface development. The framework functions as a declarative UI library and a progressive web app toolset. It enables the creation of installable applications that can operate in standalone windows and maintain offline functionality. The system manages browser-side application development through a component-based view hierarchy and a declarative syntax for defining UI elements. It i

Build cross platform GUI apps with GO and HTML/JS/CSS (powered by nwjs)

This project is an immediate-mode graphical user interface library designed for rapid development of tools and debugging interfaces. By generating UI geometry every frame through procedural code, it eliminates the need for persistent state synchronization between application data and the interface. It is primarily intended for integration into existing rendering pipelines, where it produces raw vertex buffers and draw commands that are agnostic to the underlying graphics API. The library distinguishes itself through a highly decoupled architecture that supports complex, dockable, and multi-vi

Golang bindings of Sciter: the Embeddable HTML/CSS/script engine for modern UI development

go-astilectron is a cross-platform GUI framework and binding that enables the creation of desktop software by combining a compiled Go backend with an Electron frontend. It functions as an inter-process communication bridge, utilizing an asynchronous messaging system to exchange JSON events and synchronize state between the Go process and the JavaScript user interface. The project provides a native desktop API wrapper to orchestrate system-level features from the backend. This includes the ability to manage browser windows, construct native application menus, and control system tray icons and

Go bindings for GTK3

Nuklear is a minimal, header-only graphical user interface toolkit written in C. It utilizes an immediate-mode rendering model, where the interface is reconstructed and drawn directly within the application loop each frame. This approach eliminates the need for persistent widget state or complex synchronization between the interface and underlying application data. The library is designed for portability and integration into resource-constrained environments. It requires the host application to manage memory manually, allowing it to function in systems that lack standard library support. By d

systray is a Go library used to create and manage icons and menus within the operating system notification area. It functions as a cross-platform GUI library that provides a persistent application entry point and a notification area menu manager. The library enables the creation of hierarchical menus and custom tray icons across different desktop operating systems. It supports the use of nested submenus and allows for the styling of individual menu entries with custom images. The toolset covers a range of interaction capabilities, including the management of menu item states through checked

Azul is a native desktop application builder and UI toolkit for creating high-performance graphical user interfaces. It utilizes a functional and reactive programming model for managing layout and state, enabling the development of native software through a CSS-based toolkit. The framework is distinguished by its use of the WebRender engine to provide GPU-accelerated rendering. This allows the system to display complex user interface elements with high efficiency and speed by leveraging hardware acceleration. The project enables the design of desktop interfaces using a document object model

c3c is the compiler for the C3 programming language, transforming source code into executable binaries, static libraries, or dynamic libraries using an LLVM backend. It implements a system based on result-based error handling, scoped memory pooling, and a semantic macro system. The compiler provides first-class support for hardware-backed SIMD vectors that map directly to processor instructions and enables runtime polymorphism through interface-based dynamic dispatch. The project covers a broad set of low-level capabilities, including manual and pooled memory management, inline assembly inte

JerryScript is a lightweight, ECMAScript-compliant JavaScript engine and bytecode compiler designed for resource-constrained devices. It serves as an embedded interpreter and IoT scripting runtime, enabling the execution of JavaScript code within native C applications on hardware with limited memory. The project differentiates itself through a focus on low-memory runtime management, utilizing bytecode precompilation and pre-compiled state snapshots to reduce startup time and memory overhead. It features a C-binding native bridge for bidirectional communication between native code and scripts,

Rust-bindgen is a build-time foreign function interface binding generator and C header parser designed to automate cross-language interoperability. It functions as a tool to bridge Rust with C, C++, and Objective-C libraries by producing platform-specific declarations during the compilation process. The project distinguishes itself through its ability to handle complex C-family language constructs, including C++ inheritance and methods, as well as Objective-C classes and protocols. It ensures binary compatibility across different architectures by calculating target-aware memory layouts and va

Scala Native is an ahead-of-time compiler that transforms Scala source code into standalone native binaries for direct execution on hardware. It provides a native binary toolchain designed to eliminate virtual machine warm-up times and ensure instant startup by compiling code into optimized executables. The project features a C interoperability interface and foreign function interface that map native C headers to language objects, allowing for the direct execution of external libraries. It includes a low-level memory manager that supports direct pointer manipulation and the use of structs for

Torch7 is a scientific computing environment and tensor computation library used for deep learning research and numerical analysis. It functions as a Lua-based framework for training neural networks and learning agents, providing a toolkit for implementing architectures and training through reinforcement learning algorithms. The project is distinguished by its tight integration with C, utilizing a binding layer to map high-level scripting to low-level C structures for direct memory access. It supports hardware-accelerated computation by offloading linear algebra and convolution operations to

Crystal is a statically typed, compiled programming language designed for high performance and memory safety. It leverages an LLVM-based compiler to translate source code into optimized machine-executable binaries, while its type-inference-based static analysis enforces strict safety rules during the build process. The language distinguishes itself through a fiber-based concurrent runtime that manages lightweight execution units for asynchronous input and output without blocking the main process. It also features a powerful compile-time macro system that allows for the inspection and transfor

Nim is a statically typed, compiled systems programming language designed for high performance and cross-platform development. It translates high-level source code into C, C++, or JavaScript, allowing developers to produce efficient native binaries or web-compatible scripts from a single codebase. The language emphasizes a clean, indentation-based syntax that simplifies code hierarchy while maintaining the power of a full-featured systems language. What distinguishes Nim is its robust metaprogramming framework, which allows developers to inspect, modify, and generate code structures during th

The Android NDK samples provide a comprehensive collection of code examples demonstrating how to integrate C and C++ native code into Android applications. This repository serves as a practical guide for developers utilizing the Android Native Development Kit to implement performance-critical application components that require direct hardware access and low-level system interaction. The project highlights the use of the Java Native Interface to bridge managed code with native modules, enabling cross-language function calls and efficient data exchange. It demonstrates how to manage native act

This project is a comprehensive technical interview question bank and reference library designed for software engineering roles at major technology companies. It serves as a study guide and knowledge base covering the core principles of high-performance systems programming and computer science theory. The collection focuses on deep technical domains, including C++ language mastery, distributed systems design, and database engineering. It provides detailed material on consensus protocols, cluster coordination, and the architectural differences between SQL and NoSQL implementations. The resour

Microsoft UI XAML is a XAML UI framework and Windows desktop UI toolkit used for building native desktop user interfaces. It functions as a cross-version Windows UI library that adapts modern interface features to remain compatible across different versions of the operating system. The project includes a low-level composition engine for creating high-performance animations, lighting effects, and translucent window materials. It provides a system for native desktop interface construction using a consistent design system for layouts and interactions. Capability areas cover interactive map rend

Eel is a framework for creating desktop applications using a Python backend and a web-based frontend. It acts as a bidirectional bridge between Python and JavaScript, allowing developers to build graphical user interfaces with HTML and JavaScript that communicate with local system logic. The project facilitates two-way communication by enabling the exposure of Python functions to the browser and allowing the backend to trigger JavaScript functions. It uses a local server to render web interfaces as standalone desktop windows and provides tools to bundle the Python code and web assets into a s

NativeScript is a cross-platform mobile development framework that enables the creation of native iOS and Android applications using JavaScript or TypeScript. It provides a direct bridge to native platform APIs, allowing developers to invoke native classes, methods, and properties directly from script code while maintaining full access to underlying mobile operating system features. The framework distinguishes itself through its direct native UI rendering, which maps declarative markup components to actual platform-native widgets rather than web-based views. This architecture is supported by

Pencil is a cross-platform design environment and vector drawing application used for GUI prototyping and diagramming. It provides a canvas-based editor to create interactive user interface mockups, system architecture diagrams, and scalable visual representations of technical flows. The tool functions as a vector graphic editor that renders shapes as mathematical paths to ensure scalability across different resolutions. It includes a PDF export layout engine specifically designed to convert screen-based visual designs into fixed-layout documents for physical printing and distribution. The p

Elements is a C++ GUI library and component-based UI framework used for building desktop user interfaces. It features a retained-mode layout engine that manages the positioning, sizing, and layering of elements within a window. The framework functions as a cross-platform window manager, handling application event loops and embedding graphical views into native platform windows. It allows for the creation of custom widgets by composing basic primitive elements and alignment wrappers. The system supports responsive layout organization through the use of tiles, grids, and flows. It also provide