ultralight-ux/Ultralight

Features

• Cross-Platform UI Frameworks - Provides a cross-platform UI framework that renders web technologies to CPU buffers or GPU textures across multiple operating systems.
• Native HTML Rendering Engines - Renders HTML and CSS content directly into native application interfaces without requiring a full web browser.
• Pixel Buffer Rendering - Renders web content directly into CPU-backed pixel buffers or GPU textures for integration into external engines.
• C and C++ API Exposures - Exposes C and C++ APIs to a JavaScript virtual machine for bidirectional host-script communication.
• Script Execution Engines - Integrates a JavaScript virtual machine to execute code and provide deep connectivity between the script engine and host.
• Driver-Based Geometry Emission - Emits raw geometry and draw calls via a custom driver interface to render directly on the GPU.
• GPU Driver Interfaces - Provides a custom GPU driver interface to emit raw geometry and draw calls, bypassing intermediate CPU bitmaps.
• GPU-Accelerated UI Rendering - Implements a GPU-accelerated renderer that emits raw geometry and draw calls for high-performance UI display.
• JavaScript-Native Bindings - Provides a framework for binding native C++ functions and objects to a JavaScript environment for deep application integration.
• Multi-Language Bindings - Provides multi-language bindings (C#, Rust, Java) to connect web front-ends with native C++ logic.
• C Function Bindings - Allows exposing native C functions as callbacks that can be triggered directly by web elements.
• Native Bindings - Provides low-level bindings that enable native C++ functions and objects to interact with the JavaScript script engine.
• Layout Tree Construction - Parses HTML and CSS to construct a layout tree for calculating geometry before final rendering.
• Asynchronous View Containers - Creates independent containers for web content to decouple UI instantiation from the main application loop.
• Web-Based Desktop Interfaces - Allows building desktop software interfaces using web technologies while maintaining deep integration with C++ backend logic.
• Embedded Web UI Frameworks - Creates sized containers that render HTML, CSS, and JavaScript as integrated elements or overlays within desktop applications.
• Embedded Web Views - Ships an embedded web view that renders pages and executes JavaScript within a native C++ application.
• Hybrid Native-HTML UI Rendering - Provides a lightweight engine to render HTML, JS, and CSS content as interactive interfaces within native applications.
• Paint-Tree Layout Engines - Parses web resources and applies styles to calculate a layout that transforms into a paint tree for rendering.
• Web-Based Rendering Engines - Integrates a web-based rendering engine to host user interfaces within native applications via CPU buffers or GPU textures.
• Embedded Web Renderers - Integrates a lightweight web engine into native desktop applications to render modern web-based user interfaces.
• Platform Abstraction Layers - Provides abstraction layers to override default system behaviors for file loading and clipboard access.
• Asset Bundling - Packages HTML, CSS, and JavaScript assets directly into the application binary.
• Page Context Executions - Allows the native application to acquire a page context to execute JavaScript and manipulate the DOM.
• Renderer Window Wrapping - Wraps the renderer in a framework that manages native windows and accelerated rendering for desktop apps.
• Script String Evaluation - Runs raw strings of JavaScript code within the page context to trigger logic or update the DOM.
• Platform-Specific Runtime Overrides - Replaces default system behaviors for file-system access and clipboard management to suit specific target environments.
• Resource Loader Overrides - Overrides default system behaviors for file and font management to use application-specific logic or encrypted data loaders.
• 2D and 3D Graphics Rendering - Performs low-level 2D graphics routines including path rendering, font handling, and CPU rasterization.
• Frame-Synchronized GPU Updates - Coordinates engine state updates and background tasks with view painting to ensure smooth visual synchronization.
• Rendering Pipeline Selection - Allows switching between CPU pixel buffers and GPU texture renderers to balance memory and performance.
• Render-to-Texture Buffers - Directs pixel output into user-controlled memory blocks or GPU buffers to optimize texture uploads.
• Graphics Rendering Engines - Provides a rendering engine that can output HTML content into custom pixel buffers or GPU surfaces for integration into external graphics engines.
• State Synchronization - Exposes internal native state to web pages through direct script engine API callbacks.
• Host-to-Script Function Invocations - Triggers JavaScript functions within the renderer using direct calls and evaluation from native code.
• Update Cycle Controllers - Allows manual triggering of engine state updates and painting to manage the visual update flow.
• Render Lifecycle Controllers - Manages the visual update flow by manually triggering engine state updates and painting to underlying surfaces.
• Game Overlays and HUDs - Enables the creation of high-performance game overlays and HUDs using HTML and CSS rendered to GPU textures.
• Web-Based Native Front-ends - Renders HTML, JS, and CSS within a native application to provide a modern web-based front-end.
• Window Event Handling - Handles the creation of native platform windows, user input event processing, and the main application event loop.
• Platform Integrations - Provides interfaces to override low-level system functionality like file loading and clipboard access via custom platform handlers.
• Page-Specific Script Execution - Executes specific callbacks upon window creation or DOM parsing to synchronize native logic with page state.

Historique des stars