Projects sharing features with Proton Native

This project is a TypeScript desktop boilerplate and application template that combines Electron and React for building cross-platform desktop applications. It provides a structural foundation and framework for creating native system applications that bundle web technologies into distributable operating system packages. The project distinguishes itself by providing a hot-reloading desktop environment. This development setup applies code changes instantly to the user interface without requiring manual application restarts, preserving the current interface state through hot module replacement.

Electron is a framework for building native desktop applications using JavaScript, HTML, and CSS. It functions as a cross-platform desktop runtime that combines the Chromium engine with Node.js to enable web technologies to run as standalone applications on Windows, macOS, and Linux. The project serves as a desktop integration layer that allows web-based user interfaces to access low-level operating system APIs. By bridging the Chromium rendering engine with a Node.js environment, it enables a single codebase to be deployed as a native executable across different desktop operating systems. T

InjectionIII is a suite of development utilities designed for runtime code reloading, expression evaluation, and automated code injection. It provides a system for recompiling modified source files and patching function pointers in a live process to update application behavior without requiring a full restart. The project utilizes Xcode build script extensions and a live code injector to deliver Swift and Objective-C changes to desktop applications and physical hardware. It features a runtime evaluator that executes string-based Swift expressions to inspect state and retrieve values from a ru

nw.js is a Node.js desktop application framework that combines a Chromium web renderer with a Node.js runtime to build standalone software for Windows, macOS, and Linux. It serves as a cross-platform desktop runtime that allows developers to create native executables using web technologies. The project is distinguished by its integration layer that exposes Node.js system APIs and modules directly to the browser window and web worker contexts. It functions as a native module bridge, enabling the compilation and execution of low-level C++ system code and native addons within a web-based applica

Angular Electron is a project scaffolding tool that generates a preconfigured desktop application template combining Angular's web framework with Electron's native runtime. It produces cross-platform executables for Windows, macOS, and Linux from a single codebase, while providing a development server with hot reload that automatically refreshes the Electron renderer process when Angular source files change. The project handles the architectural complexity of running Angular inside Electron by separately bundling Node.js modules for the main process and Angular modules for the renderer proces

This project is a framework for building native macOS desktop applications. It serves as a desktop port of a cross-platform mobile framework, providing a development environment and a native UI library to create software using native system frameworks and a component-based architecture. The framework enables the development of native macOS applications by integrating a JavaScript-based workflow with macOS system-level frameworks. It facilitates cross-platform UI development by allowing logic and design patterns to be shared across different operating systems while maintaining native desktop i

Electron.NET is a framework for building cross-platform desktop applications using ASP.NET Core, Razor Pages, MVC, or Blazor. It serves as a wrapper that hosts .NET web projects within a native desktop shell, allowing web-based logic to function as standalone software across different operating systems. The project provides a hosting environment specifically for Blazor components and other .NET web technologies, converting them into distributable binary executable packages. It integrates a native web browser control for UI rendering and utilizes a structured communication channel to pass mess

Photon is a cross-platform desktop framework and UI development kit designed for building software that runs on multiple operating systems. It functions as an application framework for creating desktop software using a web-based frontend. The project focuses on the design of cross-platform graphical user interfaces, specifically for applications developed with Electron. It provides tools for building web-based desktop interfaces and polished layouts using HTML and CSS.

Devtool is a suite of developer tools designed to execute server-side JavaScript code within a browser environment. It functions as a bridge that allows Node.js programs to run inside a Chromium instance, enabling the use of built-in browser developer tools for visual debugging and performance profiling. The project provides a read-eval-print loop for interactive command execution with support for relative imports and piped input. It also includes a file watcher that monitors source files for changes and automatically reloads programs to accelerate the iteration cycle. The system integrates

react-native-macos is a framework for building native macOS desktop applications using a JavaScript-driven architecture. It functions as a cross-platform UI framework that renders user interfaces directly to native desktop elements and Cocoa components without relying on a web browser. The project provides a native app build tool for bundling code and static assets into distribution files for the macOS operating system. It also includes a native component previewer to verify how individual UI elements render and function within the desktop environment. The framework covers native UI componen

This project is a boilerplate and starter for building cross-platform desktop applications that integrate a web-based frontend with a native shell. It provides a pre-configured development environment combining Electron, Vite, and Vue to establish a frontend-driven desktop framework. The setup features an integrated development workflow with hot module replacement and automatic reloading for both the main and renderer processes. This allows for real-time updates to the desktop application shell and user interface components without requiring manual restarts. The project covers native system

tModLoader is a modding framework and toolset designed for expanding game content and extending core game logic. It provides a polymorphic content API that allows for the creation of new items, NPCs, projectiles, and world assets through object-oriented inheritance. The project is distinguished by its advanced code modification capabilities, utilizing intermediate language bytecode patching and reflection-based private access to alter internal game behavior. It features a hot-reloading assembly runtime that enables developers to recompile and apply source code changes in real-time without res

Webpack-hot-middleware is a development middleware and plugin that connects backend servers to web clients for live reloading and real-time bundle updates. It functions as an Express development middleware that streams real-time bundle updates and compiler events to web browsers, enabling automatic browser reloading and hot module replacement as source files change during development. The system incorporates compiler hook integration to listen to build lifecycle events and detect newly generated assets automatically. It establishes persistent server-sent event streams from the backend to conn

Avalonia is a cross-platform desktop framework that enables the creation of native-feeling applications for Windows, macOS, and Linux from a single codebase. It functions as a declarative UI toolkit, allowing developers to define complex visual hierarchies and interface structures using a markup-based syntax that maps directly to underlying object properties. By utilizing the Model-View-ViewModel architectural pattern, the framework facilitates a clean separation between application logic and user interface layout, which simplifies unit testing and component maintenance. The framework disting

PakePlus is a web-to-native converter and application packager that transforms website URLs or static directories into standalone native desktop and mobile applications. It provides a native browser shell to wrap web content, acting as a cross-platform application shell for Android, iOS, and various desktop environments. The project distinguishes itself through a cloud-based app packager, utilizing remote build pipelines to compile application binaries without requiring a local development environment. It includes a JavaScript injection tool and a system-level API bridge, allowing users to ad

This project is a cross-platform library for building desktop applications using Deno. It enables developers to create software with web-based user interfaces by rendering HTML, CSS, and JavaScript within native desktop windows. The framework functions as a bridge between the web-based frontend and the host operating system. It provides a communication layer that allows for bidirectional data exchange and code execution between the interface and the underlying system. By integrating with native system event queues, the library maintains window responsiveness and manages the application lifecy

Vuido is a framework for building native desktop applications for Windows, macOS, and Linux using Vue.js components, without requiring Electron or Chromium. It maps Vue components directly to native widgets from the libui library, creating lightweight applications that run on a single-threaded event loop and compile templates at build time for optimized runtime performance. The framework provides a complete Vue.js component-to-native bridge, enabling two-way data binding via v-model, component-based window composition, and platform-specific package generation for distributing executables. It

Neutralinojs is a lightweight cross-platform desktop application framework that allows developers to build native applications using web technologies and a C++ backend. It serves as a native system API bridge, enabling JavaScript frontend code to execute system commands and manage files across Windows, macOS, and Linux. The project distinguishes itself as a portable runtime that renders interfaces via the system's built-in webview instead of bundling a full browser engine. This approach enables the packaging of web assets into small, standalone executable binaries. The framework provides com

Electrobun is a desktop application framework and webview-based GUI toolkit used for building cross-platform desktop apps. It provides a TypeScript-based runtime and a native system webview to create interfaces that integrate embedded browser views with host-process logic. The project features a native GPU integration layer with direct FFI bindings, allowing for high-performance GPU surfaces and compute workloads to run within a desktop application. It also includes an inter-process communication bridge using a typed RPC system to exchange data and execute functions between the native backend

Devspace is a Kubernetes development workflow tool and declarative deployment orchestrator. It automates the build, deploy, and debug cycle for applications running inside Kubernetes clusters, functioning as a container image pipeline automator and a remote Kubernetes debugger. The project features a Kubernetes hot reloading engine that provides real-time code synchronization and bi-directional file synchronization between local filesystems and running containers. This allows for updates without requiring image rebuilds or restarts. It further enables environment parity by running build, test

LCUI is a component-based, cross-platform UI toolkit for building desktop applications using C, TypeScript, and JSX. It provides a declarative UI compiler that transforms JSX and TypeScript markup into native C code, enabling developers to construct interfaces without a browser runtime. The library includes a CSS styling engine that applies standard CSS rules to layout and style native desktop components, and supports component composition with state management and event binding. The toolkit distinguishes itself by combining web development patterns with native desktop rendering, allowing dev

This project is an Xcode runtime code injector and developer productivity tool. It enables the injection of Swift and Objective-C code changes into a running application without requiring a process restart, functioning as a hot module replacement tool for iOS development. The tool provides a dynamic UI debugger for reloading storyboards and tuning visual parameters in real time. It allows for the recompilation of individual classes and the binding of new implementations into a live process, avoiding full project rebuilds. The system covers runtime injection capabilities, including automated

This framework is a cross-platform software development kit designed for building native mobile and desktop applications from a single shared codebase. It provides a unified programming interface that allows developers to construct user interfaces using declarative markup, which are then rendered as native components on each target operating system. The framework distinguishes itself through a multi-targeting build system that consolidates platform-specific resources and native control mapping into a unified project structure. It includes a data-driven binding engine that synchronizes applica

React Refresh Webpack Plugin is a development tool that enables live reloading of React components while preserving their local state during development. It integrates with build processes to instantly update component code without losing user state or session data, while also offering options to clear and reinitialize component state when unstable interfaces need clean recovery. The plugin manages updates and state preservation in the browser by intercepting the bundling lifecycle, applying abstract syntax tree transformations to inject metadata and preamble hooks, and communicating with mod

FluentUI is a component-based UI framework that implements Microsoft's Fluent Design System for building cross-platform desktop applications. It provides a complete set of reusable UI components and styling tools that follow the Fluent Design language, enabling developers to create consistent visual interfaces across different operating systems. The framework includes a custom window frame manager that creates frameless application windows with integrated title bars and standard window controls, styled through CSS variables. It also features a single-page application router that manages view

This project is a cross-platform development framework and managed runtime environment designed for building high-performance applications. It provides a comprehensive toolkit for constructing web services, cloud-native microservices, and desktop applications, utilizing a unified runtime that handles memory management and execution across diverse operating systems. The framework distinguishes itself through a native ahead-of-time compilation toolchain that transforms source code into optimized, self-contained machine code binaries. This capability enables fast startup times and reduced memory