Open-source alternatives to Layout

Litho is an Android declarative UI framework and component library used to build user interfaces through a declarative API and immutable state. It functions as an asynchronous layout engine that maps components to a structured view hierarchy to automate view updates. The framework optimizes rendering performance by computing element positions on background threads to prevent blocking the main UI thread. It further improves efficiency by flattening nested view hierarchies and caching layout results. The system includes capabilities for state reconciliation, component recycling, and the render

Duilib is a Windows UI library and custom rendering engine designed for building high-performance graphical user interfaces for PC client software. It functions as a DirectUI framework that allows for the creation of bespoke layouts and tailored interface elements without relying on standard operating system controls. The framework implements a direct user interface approach to render custom graphical elements. This allows for the design of non-standard visual layouts for desktop applications, including those that require high-performance rendering for resource-heavy software. The system cov

Xamarin.Forms is a cross-platform mobile framework for building native user interfaces using a single shared codebase and .NET. It functions as a data-driven UI library and a XAML UI toolkit, allowing application layouts and visual elements to be defined using an XML-based markup language. The framework provides native API wrappers that offer access to device-specific hardware and operating system features via C#. It utilizes a system for rendering a single user interface codebase through native controls across different operating systems. The project covers adaptive layout management and ap

MovieSwiftUI is a movie discovery application built with SwiftUI that integrates with the MovieDB API to retrieve and display movie information, ratings, and metadata. It functions as a cross-platform Apple application, providing a consistent user experience across iOS and macOS from a single codebase. The project implements a reactive data flow using Combine to synchronize global application state with the user interface. It employs a unidirectional data flow and a centralized store to maintain a single source of truth across different screens and components. The application utilizes declar

gpui-component is a native desktop UI kit and component library built for the GPUI framework. It provides a collection of reusable user interface elements, a desktop layout engine for organizing application space, and a specialized data visualization library for rendering quantitative information. The project is distinguished by its high-performance rendering systems, including a virtualized data grid and list system designed to handle large datasets with low memory overhead. It also features a comprehensive data visualization toolkit for rendering charts, axes, and coordinate scales using li

This project is a cross-platform mobile UI library and design system built for the React Native framework. It provides a collection of styleable and reusable interface components to ensure visual consistency across different mobile operating systems. The framework includes a specialized tool for transforming raw HTML strings into native mobile components using custom element rendering and style overrides. It also features a remote update system that allows interface changes and new features to be pushed directly to devices without requiring a full application store release. The library cover

jemalloc is a general purpose C memory allocator designed as a replacement for the standard library malloc and free functions. It is a multi-threaded allocation library that emphasizes fragmentation avoidance and scalable concurrency for high-performance applications. The project reduces lock contention by using multiple independent memory arenas and thread-local cache layers. It minimizes latency by offloading the reclamation of unused memory pages to asynchronous background threads and utilizes huge page metadata storage to reduce translation lookaside buffer misses. The system includes a

Toga is a cross-platform application framework and native GUI toolkit for Python. It serves as a multi-platform frontend wrapper that allows a single codebase to be deployed across macOS, Windows, Linux, Android, and iOS. The toolkit functions as a native widget UI library, mapping high-level Python interface definitions directly to the host operating system's own visual components. This ensures that applications use native system widgets to match the look and feel of the target environment rather than relying on custom drawing libraries. The framework covers cross-platform development for d

Mimalloc is a general purpose dynamic memory allocator for C and C++ designed to increase execution speed and reduce fragmentation. It functions as a scalable heap manager that replaces standard library allocation functions to improve performance and memory efficiency across applications. The project distinguishes itself as both a heap security hardener and a memory corruption detector. It employs randomized allocation, encrypted free lists, and sampled guard pages to mitigate heap exploits and identify buffer overflows or use-after-free errors during runtime. The allocator provides capabili

x-render is a configuration-driven UI framework and low-code interface builder that transforms structured data definitions into functional user interface components. It operates as a JSON-driven UI generator, using a standardized configuration protocol to render data tables, input forms, and charts. The system includes a visual form builder and interface design editor, allowing users to arrange layouts and configuration settings through a graphical interface to avoid writing manual structural code. This process is supported by a schema-based component library that maps configuration keys to a

This project is a cross-platform development framework that enables the execution of React Native applications as native desktop software. By utilizing the Qt toolkit, it maps mobile-oriented interface components to native desktop widgets, allowing developers to deploy a single codebase across Linux, macOS, and Windows. The framework functions as a bridge between JavaScript-based application logic and native system interfaces. It includes a native module bridge that exposes system-level hardware and platform capabilities to the JavaScript runtime, facilitating the integration of custom C++ or

This project is a CSS layout framework that functions as a responsive UI geometry solver. It replaces traditional static box model calculations with a constraint-based engine that determines element positions and dimensions by evaluating relational rules. The engine distinguishes itself by using a system of linear equations to resolve geometric conflicts, ensuring that all spatial constraints are satisfied simultaneously. It utilizes a shorthand visual syntax to define these relationships, allowing developers to describe complex alignment and spacing requirements through a declarative languag

Glidejs is a lightweight, dependency-free JavaScript library for creating sliders and carousels. It functions as a standalone UI component and content slider that supports ES6. The library uses a modular architecture, allowing for the extension of core logic through a plugin system to implement specialized features and custom behaviors. The project provides capabilities for implementing web carousels and interactive sliding interfaces. It integrates sliding content displays into webpages without the use of external libraries or frameworks.

React Native Chart Kit is a library of responsive charting components designed for rendering interactive data visualizations within cross-platform mobile applications. It provides a suite of UI elements that map data properties to visual representations, utilizing scalable vector graphics to maintain clarity across diverse screen densities and resolutions. The library distinguishes itself through a platform-agnostic layout engine that ensures consistent alignment and responsiveness across different mobile devices. It integrates directly with native touch event systems, enabling users to explo

This is an open-source, crowd-sourced wiki textbook that teaches Linux system programming in C. It covers the core operating system concepts of process management through the fork-exec-wait model, dynamic memory allocation using implicit free list heap allocators, inode-based file systems, inter-process communication via pipes and shared memory, POSIX threads with synchronization primitives, signal-based asynchronous notification, virtual memory with page table translation, and runtime diagnostics using Valgrind and GDB. The textbook distinguishes itself by providing practical, implementation

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

Odin is a compiled, statically typed systems programming language designed for high-performance software development. It focuses on pragmatic low-level memory control, providing a toolset for manual memory management and precise control over hardware utilization. The language is distinguished by its flexible memory model, which includes custom allocators and precise data layout capabilities to optimize resource usage. It features a comprehensive foreign function interface for importing assembly files and linking with external libraries using configurable calling conventions. The type system

This project is a freestanding kernel written in Rust that boots on x86 hardware without a standard library. It serves as a low-level system implementation focusing on the creation of a bare metal operating system. The system implements a bootable disk image toolchain that transforms source code into binaries compatible with a bootloader. It features a custom memory allocator for dynamic memory management and an x86 kernel implementation that includes paging, interrupt handling, and VGA text mode. The project covers several core capability areas, including low-level memory management through

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,

EASTL is a C++ Standard Template Library implementation consisting of containers, iterators, and algorithms. It provides cross-platform data structures and a template-based algorithm library designed for use in resource-constrained game engine environments. The library focuses on game engine memory management, providing specialized utilities that ensure predictable memory allocation and high-performance access for real-time applications. These containers maintain consistent behavior across different operating systems and hardware platforms. The project covers high-performance C++ development

Taffy is a layout engine that calculates the size and position of user interface components. It is a language-agnostic tool that computes element geometry using Flexbox and Grid algorithms. The engine operates on custom tree structures and node storage through a trait-based interface. This design allows it to be integrated into various programming languages and custom memory management systems. The system handles UI layout computation, including leaf node measurement and floating point pixel snapping to prevent blurring on displays. It utilizes layout result caching to avoid redundant calcul

microui is a minimal immediate-mode graphical user interface library written in C, designed for resource-constrained environments such as embedded systems. It operates without dynamic memory allocation and has no external dependencies beyond standard C, making it a self-contained solution for building lightweight interfaces. The library is delivered as a single header file, simplifying integration into any project. It uses a fixed-allocator heap for all runtime state, guaranteeing deterministic memory use and predictable performance. All drawing is delegated to user-supplied callbacks, keepin

Bytehound is a Linux memory profiler that utilizes a custom global allocator to intercept memory requests and track allocations and deallocations. It records full call-stack traces for every memory operation to map allocations back to their originating source code. The project features a remote memory profiling system that streams capture data via network sockets to a separate machine, minimizing resource overhead on the target system. Analysis is supported by a specialized domain-specific query language used to automate the detection of memory patterns and anomalies. The tool covers heap al

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

Mbed TLS is an open-source TLS and DTLS library with a small footprint, designed for embedded systems and IoT devices. It provides a portable cryptographic library that includes symmetric ciphers, hashing, and public-key cryptography, along with a reference implementation of the PSA Cryptography API for standardized cryptographic operations across platforms. The library also offers X.509 certificate management for parsing, validating, and managing certificate chains in secure communications. The library is built around a platform abstraction layer that decouples it from OS-specific services t

rusty_v8 is a Rust wrapper for the V8 JavaScript engine that allows for the embedding of a JavaScript runtime into native applications. It provides core components for managing engine bindings, memory allocation, sandboxed isolates, and the execution of WebAssembly modules. The project features a native host function bridge to map Rust functions to JavaScript objects and a dedicated memory allocator to manage thread-safe allocation and heap pressure. It includes a system for compiling and executing binary WebAssembly modules within the hosted native environment. The runtime covers capabiliti

Flashlight is a standalone C++ machine learning library and tensor library used for building and training neural networks. It functions as a comprehensive neural network framework and automatic differentiation engine, providing the tools to construct computation graphs and calculate gradients via backpropagation. The project serves as a distributed training framework, utilizing all-reduce operations to synchronize gradients and parameters across multiple compute nodes and devices. It distinguishes itself through deep integration of high-performance tensor manipulation, native device memory in