# lvgl/lvgl

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/lvgl-lvgl).**

22,794 stars · 4,036 forks · C · mit

## Links

- GitHub: https://github.com/lvgl/lvgl
- Homepage: https://lvgl.io
- awesome-repositories: https://awesome-repositories.com/repository/lvgl-lvgl.md

## Topics

`c` `embedded` `graphics` `gui` `mcu` `microcontroller` `tft`

## Description

This project is a high-performance, lightweight C graphics library designed for creating interactive user interfaces on resource-constrained embedded hardware. It functions as a comprehensive framework that provides a widget toolkit, a rendering engine, and hardware-agnostic drivers to support the development of graphical displays on microcontrollers and embedded systems.

The framework distinguishes itself through a flexible, object-oriented widget hierarchy and a declarative layout engine that supports responsive design patterns like flexbox and grid systems. It enables developers to synchronize user interface elements with application state through data-binding and observer patterns, while maintaining a consistent visual identity via a cascading style system. The architecture is built to be hardware-agnostic, utilizing a unified abstraction layer to manage diverse display panels and input peripherals such as touchscreens, keypads, and encoders.

Beyond core rendering, the project includes extensive tooling for interface development, such as declarative definition formats, automated code generation, and visual design synchronization. It supports complex graphical requirements including multi-display management, gesture recognition, and localization, alongside diagnostic utilities for performance monitoring. The library is designed to integrate with real-time operating systems, allowing for efficient task scheduling and memory management in embedded environments.

## Tags

### User Interface & Experience

- [Embedded User Interfaces](https://awesome-repositories.com/f/user-interface-experience/embedded-user-interfaces.md) — Provides a lightweight C library for creating interactive graphical user interfaces on resource-constrained embedded hardware.
- [Embedded Visualization Frameworks](https://awesome-repositories.com/f/user-interface-experience/embedded-visualization-frameworks.md) — Provides a cross-platform toolkit for rendering graphical interfaces on microcontrollers and embedded systems.
- [Responsive Layout Engines](https://awesome-repositories.com/f/user-interface-experience/declarative-layout-engines/responsive-layout-engines.md) — Calculates widget positions and sizes using flexible rules like flexbox and grid to support responsive design.
- [Embedded UI Component Libraries](https://awesome-repositories.com/f/user-interface-experience/ui-widgets/embedded-ui-component-libraries.md) — Provides a collection of reusable UI components like buttons and sliders designed for small-scale display hardware.
- [Peripheral Input Drivers](https://awesome-repositories.com/f/user-interface-experience/input-controls/peripheral-input-drivers.md) — Collects events from various peripherals like touchscreens, keypads, and encoders to ensure consistent user interaction. ([source](https://cdn.jsdelivr.net/gh/lvgl/lvgl@master/README.md))
- [Embedded Input Controllers](https://awesome-repositories.com/f/user-interface-experience/input-device-detection/embedded-input-controllers.md) — Processes signals from touchscreens, keypads, and encoders to enable consistent user interaction.
- [State-Synchronized Bindings](https://awesome-repositories.com/f/user-interface-experience/data-binding-frameworks/state-synchronized-bindings.md) — Connects user interface elements to shared application state to synchronize visual updates with data changes. ([source](https://cdn.jsdelivr.net/gh/lvgl/lvgl@master/README.md))
- [Declarative UI Markup](https://awesome-repositories.com/f/user-interface-experience/declarative-ui-definitions/declarative-ui-markup.md) — Describes user interface layouts and styles using a human-readable XML format. ([source](https://docs.lvgl.io/master/xml/xml/index.html))
- [Flexbox Layout Engines](https://awesome-repositories.com/f/user-interface-experience/flexbox-layout-engines.md) — Implements engines for aligning and distributing elements within containers using flexible, responsive layout properties. ([source](https://docs.lvgl.io/master/common-widget-features/layouts/flex.html))
- [Input Event Dispatchers](https://awesome-repositories.com/f/user-interface-experience/form-and-input-management/interaction-and-event-handling/event-handling-architectures/input-event-dispatchers.md) — Captures and dispatches signals from various peripherals to specific UI components through a centralized event handling system.
- [Grid Layout Engines](https://awesome-repositories.com/f/user-interface-experience/grid-layout-engines.md) — Organizes interface elements into two-dimensional tables with flexible row and column sizing and multi-cell spanning. ([source](https://docs.lvgl.io/master/common-widget-features/layouts/grid.html))
- [Style Inheritance Systems](https://awesome-repositories.com/f/user-interface-experience/style-inheritance-systems.md) — Manages visual attributes through a cascading system that allows components to inherit and override styles.
- [Component Styling](https://awesome-repositories.com/f/user-interface-experience/styling-theming-systems/content-styling/component-styling-tools/component-styling.md) — Provides tools for applying and managing visual styles, colors, and borders across interface components. ([source](https://docs.lvgl.io/master/common-widget-features/styles/index.html))
- [Design-to-Code Workflows](https://awesome-repositories.com/f/user-interface-experience/design-to-code-workflows.md) — Streamlines the transition from design prototypes to native code using human-readable declarative formats.
- [Display Parameter Configurators](https://awesome-repositories.com/f/user-interface-experience/display-metrics/display-parameter-configurators.md) — Configures hardware-specific parameters including resolution, color depth, and pixel formatting for correct rendering. ([source](https://docs.lvgl.io/master/main-modules/display/overview.html))
- [Layout Alignment Utilities](https://awesome-repositories.com/f/user-interface-experience/layout-alignment-utilities.md) — Provides tools for positioning and aligning UI elements within parent containers using main and cross axes. ([source](https://docs.lvgl.io/master/common-widget-features/layouts/flex.html))
- [Touch Gesture Detectors](https://awesome-repositories.com/f/user-interface-experience/touch-gesture-detectors.md) — Recognizes specific motion patterns from touch inputs to trigger custom actions or navigation events. ([source](https://docs.lvgl.io/master/main-modules/indev.html))
- [Keyframe Animation Systems](https://awesome-repositories.com/f/user-interface-experience/3d-animation-libraries/keyframe-animation-systems.md) — Executes keyframe-based transformations and skinned character animations with real-time control. ([source](https://docs.lvgl.io/master/libs/gltf.html))
- [Proportional Space Distribution](https://awesome-repositories.com/f/user-interface-experience/container-spacing/proportional-space-distribution.md) — Allows child widgets to expand proportionally to fill remaining container space based on assigned growth factors. ([source](https://docs.lvgl.io/master/common-widget-features/layouts/flex.html))
- [Widget Property Setters](https://awesome-repositories.com/f/user-interface-experience/text-display-widgets/widget-property-setters.md) — Provides a unified interface for programmatically updating the state and visual properties of interface components. ([source](https://docs.lvgl.io/master/widgets/index.html))
- [Embedded](https://awesome-repositories.com/f/user-interface-experience/ui-architecture/design-utilities/workflow-automation-tools/design-to-code-tools/embedded.md) — Provides tools that sync styles from design software and generate code for deployment to embedded targets. ([source](https://cdn.jsdelivr.net/gh/lvgl/lvgl@master/README.md))

### Graphics & Multimedia

- [Embedded Graphics Engines](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/embedded-graphics-engines.md) — Provides a high-performance rendering engine for embedded devices that manages display buffers and input processing.
- [Graphics Engines and Rendering](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering.md) — Provides a lightweight rendering engine for displaying interactive UI elements on embedded hardware. ([source](https://cdn.jsdelivr.net/gh/lvgl/lvgl@master/README.md))
- [Display Hardware Initializers](https://awesome-repositories.com/f/graphics-multimedia/display-configuration-managers/display-hardware-initializers.md) — Configures and initializes physical display panels to render graphical output, supporting features like screen layering and rotation. ([source](https://docs.lvgl.io/master/main-modules/display/index.html))
- [Multi-Screen Rendering Controllers](https://awesome-repositories.com/f/graphics-multimedia/display-configuration-managers/multi-screen-rendering-controllers.md) — Configures and renders graphical interfaces across several independent hardware screens simultaneously. ([source](https://docs.lvgl.io/master/main-modules/display/overview.html))
- [Graphics Resource Integrators](https://awesome-repositories.com/f/graphics-multimedia/external-data-integrators/graphics-resource-integrators.md) — Connects custom file systems, image decoders, and third-party libraries to extend core rendering capabilities. ([source](https://docs.lvgl.io/))
- [Physically Based Rendering Materials](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/materials-shading/physically-based-rendering-materials.md) — Simulates realistic surface appearances using metallic, roughness, normal mapping, and advanced effects. ([source](https://docs.lvgl.io/master/libs/gltf.html))

### Operating Systems & Systems Programming

- [Hardware Abstraction Layers](https://awesome-repositories.com/f/operating-systems-systems-programming/hardware-interfacing-drivers/hardware-abstraction-layers.md) — Provides a unified interface for graphics and input drivers to interact with diverse embedded hardware platforms consistently.
- [RTOS Graphics Integration](https://awesome-repositories.com/f/operating-systems-systems-programming/hardware-interfacing-drivers/hardware-abstraction-layers/rtos-graphics-integration.md) — Connects graphics engines to real-time operating systems to manage task scheduling and memory allocation. ([source](https://docs.lvgl.io/master/integration/os/rt-thread.html))

### Web Development

- [Embedded Widget Libraries](https://awesome-repositories.com/f/web-development/ui-component-libraries/embedded-widget-libraries.md) — Provides a library of built-in widgets like buttons, sliders, and tables for embedded graphical interfaces. ([source](https://cdn.jsdelivr.net/gh/lvgl/lvgl@master/README.md))

### Software Engineering & Architecture

- [UI Data Observers](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/state-management/reactive-subscription-systems/observer-patterns/ui-data-observers.md) — Synchronizes user interface elements with application state by automatically triggering visual updates.
- [Widget Tree Hierarchies](https://awesome-repositories.com/f/software-engineering-architecture/object-oriented-models/widget-tree-hierarchies.md) — Organizes user interface elements into a tree structure where properties and styles propagate from parent to child nodes.
- [Dynamic UI Loaders](https://awesome-repositories.com/f/software-engineering-architecture/application-lifecycle-management/configuration-management/configuration-interfaces-and-editors/dynamic-configuration-interfaces/dynamic-ui-loaders.md) — Enables dynamic loading and rendering of user interface definitions from external files without requiring recompilation.
- [Interface Code Generators](https://awesome-repositories.com/f/software-engineering-architecture/compile-time-code-generation/interface-code-generators.md) — Converts declarative interface definitions into native C code for compilation. ([source](https://docs.lvgl.io/master/xml/editor/index.html))
- [Observer Patterns](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/state-management/reactive-subscription-systems/observer-patterns.md) — Notifies registered components automatically when specific data values change to keep user interface elements synchronized. ([source](https://docs.lvgl.io/master/main-modules/observer/index.html))

### Data & Databases

- [Display Schedulers](https://awesome-repositories.com/f/data-databases/data-synchronization/real-time/display-schedulers.md) — Connects graphics engines to real-time operating systems to handle task scheduling and hardware abstraction.

### Development Tools & Productivity

- [Performance Debugging](https://awesome-repositories.com/f/development-tools-productivity/performance-debugging.md) — Provides diagnostic tools to monitor rendering cycles and identify performance bottlenecks in graphical applications. ([source](https://docs.lvgl.io/))
- [Embedded Localization Engines](https://awesome-repositories.com/f/development-tools-productivity/localization-support/embedded-localization-engines.md) — Manages multi-language text strings and dynamic assets to support globalized user interfaces on specialized hardware.