For years, a user interface in embedded systems meant a few segments on a 16×2 display or, at most, a monochrome display with simple icons. Projects requiring something more had to resort to expensive, proprietary solutions or costly application processors. LVGL has changed the rules – today, a full-colour, animated, touch-enabled UI runs on a microcontroller costing just a few pounds, and the library that makes this possible is free and open-source.
What is Light and Versatile Graphics Library?
LVGL (Light and Versatile Graphics Library) is an open-source C library designed for creating graphical user interfaces on embedded devices. The project originated in Hungary – it was originally created by Gábor Kis-Varga as a one-man project, which has since grown into a global ecosystem.
Today, LVGL describes itself as “the world’s most widely adopted open-source embedded UI ecosystem” – and it is hard to argue with that. The library is:
technology-neutral – it is not tied to any specific hardware manufacturer
royalty-free – no licence fees, even for commercial products
vendor-independent – it works on any MCU, MPU, operating system and display type
The project’s official partners include, amongst others, Espressif, ARM, NXP, Renesas, ST Microelectronics, Texas Instruments, Xiaomi and VeriSilicon – which clearly illustrates just how widely LVGL is used in the industry.
Three problems that LVGL solves
Developing an embedded user interface from the ground up is rarely straightforward. Teams face a recurring set of challenges regardless of the project – tight hardware budgets, demanding schedules and the sheer complexity of building a polished graphical experience on constrained devices. LVGL was designed with precisely these pain points in mind, and addresses three of them directly.
1. Reducing time to market
Building an embedded user interface from scratch is a laborious process: display drivers, touch support, memory management, font rendering, animations. As an open source GUI library, LVGL provides all of this in a ready-to-use, tested package. All you need to do is configure it and start building widgets.
The MIT licence means there are no barriers to getting your project off the ground. There’s no need to negotiate licences, seek permission or pay upfront. The community comprises thousands of active users, and the documentation is comprehensive and up to date.
2. Performance on low-end hardware
One of the most common concerns when evaluating any embedded user interface library is whether it will actually run on the target hardware. LVGL’s minimum requirements are impressively low:
| Resource | Minimum |
|---|---|
|
RAM |
50 KB |
|
Flash |
100 KB |
|
Fonts |
30 KB |
|
Processor clock speed |
~100 MHz |
In practice, a typical application with a few screens and several dozen widgets – including a multi-screen IoT dashboard displaying live sensor data, charts and status indicators – requires around 48 KB of RAM. That is still well within the capabilities of inexpensive microcontrollers. The library optimises rendering by refreshing only the changed areas of the screen, supports hardware graphics accelerators where available (DMA2D on STM32, DAVE2D on Renesas, VGLite on NXP), and falls back to its own software engine where they are not.
3. Project cost reduction
Because LVGL runs efficiently on less powerful hardware, it becomes possible to select cheaper components without sacrificing the visual quality of the interface. The absence of licence fees, compared with paid alternatives such as TouchGFX, emWin and Qt for MCU, represents a further saving in the project budget. For teams developing a certifiable embedded GUI—such as in medical, industrial, or automotive applications—the availability of a well-documented, open codebase also reduces the effort required to meet regulatory requirements. For mass production, the combined savings across hardware, licensing, and compliance preparation can be significant.
Architecture and technical capabilities
Widgets
LVGL offers over 30 built-in widgets that form the building blocks of any embedded user interface, and can be created or removed dynamically in real time. Selected components:
| Category | Widgets |
|---|---|
|
Data display |
Label, Image, Chart, Bar, Arc, Meter, LED |
|
Controls |
Button, Switch, Checkbox, Slider, Roller, Dropdown |
|
Navigation |
Tabview, List, Menu |
|
Text input |
Text area, Keyboard (on-screen) |
|
Containers |
Panel, Tile view, Message box, Calendar |
Each widget supports states (normal, pressed, selected, focused, disabled) with the option of animated transitions between them.
Styles and themes
One of the strengths of LVGL as an open source GUI library is the flexibility of its styling system. With over 100 available properties – colours, rounded corners, shadows, borders, transparency and fill colours – developers have fine-grained control over the appearance of every element. The system works in a cascading manner similar to CSS: styles can be defined globally, per widget class or for specific instances. The theme of the entire application can be switched at runtime using a single function.
Layouts
LVGL implements two layout systems inspired by web standards:
Flex layout – analogous to CSS Flexbox, positioning of children along an axis, line wrapping.
Grid layout – analogous to CSS Grid, a grid of columns and rows with widths expressed as percentages.
This means that interfaces designed for one resolution adapt relatively easily to others. The Grid layout is particularly well suited to building an IoT dashboard, where sensor readings, charts and status indicators need to be arranged in a structured, multi-column view that scales cleanly across different display sizes.
Rendering
The LVGL graphics engine supports:
anti-aliased rendering (smoothed edges)
linear and radial gradients
shadows and blur
image scaling and rotation
masks and arcs
16-bit, 32-bit and 64-bit platforms
Where the hardware provides a 2D accelerator (e.g. DMA2D in the STM32H7, DAVE2D in the Renesas RA8), LVGL can utilise it, significantly reducing the load on the main processor core.
Typography
Typography is one of the areas where Light and Versatile Graphics Library genuinely stands out among embedded UI solutions. Font support extends far beyond basic ASCII:
1-, 2-, 4- and 8-bit bitmap formats (includes a dedicated Font Converter tool for conversion from TTF/OTF)
UTF-8 encoding
bidirectional languages: Arabic, Persian, Hebrew
special languages: Thai
CJK characters: Chinese, Japanese, Korean
emojis
Input
Handling user input is a fundamental requirement of any embedded user interface, and LVGL makes this straightforward by supporting multiple input types simultaneously:
touchscreen (capacitive and resistive)
mouse
physical keyboard
rotary encoder with a button
external buttons
All input devices are managed through a unified abstraction layer, meaning the embedded user interface code remains the same regardless of which input method is in use — or whether several are active at once.
Operating systems
LVGL runs on all popular platforms:
| Category | Systems |
|---|---|
|
No OS |
Bare metal |
|
RTOS |
FreeRTOS, Zephyr, RT-Thread, NuttX |
|
FullOS |
Linux (framebuffer, DRM), Windows, macOS |
|
Frameworks |
Arduino, PlatformIO, Tasmota |
|
Languages |
MicroPython bindings |
Development tools
LVGL’s toolchain covers the full development workflow, from initial design through to deployment on target hardware. Whether you are building a simple control panel or a multi-screen IoT dashboard, the following tools help streamline the process:
SquareLine Studio – a graphical UI editor with drag-and-drop layout, real-time preview and C code export; particularly useful for rapidly prototyping an IoT dashboard layout before writing any application logic
LVGL Simulator – testing the interface on a PC without the target hardware
Font Converter – online TTF/OTF conversion
Image Converter – preparing images for LVGL resources
Project Creator – generating project configurations for specific boards
Boards ecosystem
LVGL offers official support for over 50 boards from 15 manufacturers, with ready-made projects maintained by the library team. This is a significant difference compared to integrating the components yourself – a ready-made project means a tested display driver, a configured port layer and a working demo straight after uploading.
Espressif – a platform for embedded and IoT projects
Espressif is an official LVGL partner, and the ESP32-S3 family is one of the most popular platforms for projects with a graphical user interface. Boards available with official LVGL support:
| Board | Display | Notes |
|---|---|---|
|
ESP32-S3-LCD-EV-Board |
800×480 or 480×480 RGB |
Espressif development board |
|
ESP32-S3-BOX-3 |
320×240 touch |
dual mic, AI voice |
|
ESP32-S3-EYE |
240×240 |
camera, microSD |
|
M5Stack CoreS3 |
320×240 |
compact module |
|
Viewe ESP32-S3 Smart Display |
GT911, 300 cd/m² |
MicroPython bindings |
|
Viewe ESP32-S3 Touch Knob |
466×466 AMOLED |
rotary knob |
It is worth noting that the ESP32-S3 – although it is an MCU rather than an application processor – supports an RGB interface for displays with a resolution of 800×480 without the need for an external graphics controller. This is made possible by the built-in LCD controller and 8 MB of PSRAM, which serves as a framebuffer.
Other platforms
LVGL’s hardware support for building an embedded user interface spans an exceptionally wide range of platforms:
| Manufacturer | Development board | Chip | Display |
|---|---|---|---|
|
ST Microelectronics |
STM32H7S78-DK |
Cortex-M7 600MHz |
800×480 RGB |
|
Renesas |
EK-RA8D1 |
Cortex-M85 480MHz |
480×854, GPU DAVE2D |
|
NXP |
MIMXRT1170-EVKB |
i.MX RT1176 |
480×800 MIPI DSI |
|
Texas Instruments |
SK-AM62B-P1 |
Cortex-A53 1.4GHz |
HDMI 2K |
|
Raspberry Pi / NuttX |
RP2040-LCD-1.28 |
RP2040 |
240×240 round |
|
Alif Semiconductor |
E7 AI/ML AppKit |
Dual Cortex-M55 |
800×480 |
|
Riverdi |
STM32H7 7″ |
STM32H757 |
1024×600 industrial |
This range – from the RP2040 with 264 KB of RAM to multi-core application processors with gigabytes of memory – shows that LVGL is not a niche library for a single family of chips, but a genuine industry standard for embedded user interface development.
LVGL in industry – case studies
The best evidence of the library’s maturity is the commercial products that make use of it.
Xiaomi Watch S1 Pro
Xiaomi faced the challenge of unifying the user interface across different hardware platforms – different displays, different SoCs, yet a single, consistent UX. LVGL enabled the creation of a hardware-independent rendering layer. The result: a visually award-winning interface, smoother animations and – crucially from a business perspective – cost savings through the ability to use diverse hardware without having to rewrite the UI code.
Quote from the LVGL website, by Yaoyao Gu, Senior Director of the Mobile Software Division at Xiaomi:
“We’ve been using LVGL for our embedded graphics needs, and it has been used in a huge number of devices. We are very happy with its performance and its lightweight nature.”
Whisker - Litter-Robot (automatic cat litter tray)
Whisker, a leader in automated pet care equipment, needed a new UI for its Litter-Robot product line running on microcontrollers with limited memory. The key problem: Lottie animations (a popular vector animation format) took up 325 KB – too much for the target MCU.
The LVGL solution: an optimised animation rendering pipeline reduced the footprint to around 50 KB – a reduction of more than sixfold – whilst maintaining smoothness and visual quality.
SumUp Solo Lite - payment card reader
SumUp chose the Zephyr RTOS as the platform for its compact Solo Lite card reader. The UI requirements were complex: dynamic screen updates, QR code rendering, support for multiple languages and character encodings – all whilst adhering to the memory constraints of a payment device.
LVGL delivered these capabilities within the Zephyr ecosystem, providing a product ready for payment certification.
LIT DUO 1 - a professional light meter
Lit Systems has set itself an ambitious goal: to replace all the light meters in a photographer’s bag with a single pocket-sized device. The hardware platform – the STM32U575 – is an energy-efficient chip not designed with rich graphical interfaces in mind.
Despite these limitations, LVGL has enabled the creation of a hybrid interface combining physical and digital elements, with instant start-up, seven specialised measurement modes and one-handed operation – for photographers, camera operators and stage crew.
Darkglass Anagram - bass effects processor
Darkglass has built an effects processor based on embedded Linux, featuring a touchscreen interface that supports drag-and-drop routing of effects modules. LVGL on Linux (framebuffer/DRM) has delivered a responsive UI of the quality that musicians demand on stage and in the studio.
Practical example: ESP32-S3-Touch-LCD-7
Hardware
Waveshare ESP32-S3-Touch-LCD-7 is a ready-to-use all-in-one panel:
| Specification | Value |
|---|---|
|
MCU |
ESP32-S3, Xtensa LX7, 240 MHz, dual-core |
|
Memory |
8 MB Flash + 8 MB PSRAM |
|
Display |
7″, RGB 800×480 px, 16-bit |
|
Touch |
Capacitive, GT911 controller |
|
Connectivity |
Wi-Fi 2.4 GHz, Bluetooth 5.0 |
|
USB ports |
Two USB-C: USB Serial JTAG + CH343 |
PSRAM is crucial – the framebuffer for 800×480×2 bytes is 768 KB, which exceeds the ESP32-S3’s on-board SRAM (512 KB). External memory is what makes this resolution possible in the first place.
LVGL dashboard demo
lv_demo_widgets() – the official showcase of the Light and Versatile Graphics Library – runs with a single line of code and presents a complete interface with several tabs, dozens of widgets and animated transitions between states. This is not a simple functional test: the demo has been designed to showcase the library’s full potential within a single, visually cohesive interface.
The demo is navigated via three tabs – Profiles, Analytics and Shop – which can be switched between either by clicking the tab header or by swiping with your finger. At the bottom of the screen, a fixed toolbar allows you to switch the colour theme (light/dark) in real time: all widgets respond immediately, without reloading the interface. This is a good demonstration of the LVGL theme system – a single global theme defines the appearance of the entire application.
The Profiles tab displays a user card with an avatar in a circular frame, contact details and action buttons. Analytics displays charts and data metrics. Shop shows a tiled layout with a list of products.
Selected widgets for dashboards
Of the more than 30 built-in LVGL components, several are particularly useful for building dashboards – data monitors, control panels and device status displays.
Chart - real-time data chart
lv_chart showcases two types of charts: line (with points at the nodes) and stacked bar (two series – green and red – superimposed on top of each other). The library supports a total of five formats – including curvilinear (Bezier), standard bar and scatter – but these two are most clearly visible in the screenshot. A key feature for monitoring systems: data streaming mode – new data points shift the graph to the left, as on an oscilloscope or ECG monitor. The graph supports multiple series simultaneously, four axes (left/right Y, bottom/top X), cursors to highlight specific points, and interactive zooming with scrolling.
Arc - circular indicator and control
lv_arc is a circular arc with an interactive indicator. It consists of three layers: a background, an indicator that fills in according to the value, and a drag handle. The demo shows the arc in normal mode with a value of 58 within the range [-20..220] – the non-standard range (not just 0–100) is clearly visible here. Three display modes – normal (clockwise), reversed and symmetrical (filling from the centre) – allow you to build both classic gauges and indicators showing deviations from a nominal value. Each layer is styled independently: colour, width, opacity, and even a texture from an image instead of a colour. Typical uses: battery charge level, temperature, power, engine revs.
Scale - analogue scale with a needle
lv_scale generates analogue scales: linear (horizontal or vertical) and circular. It automatically positions and labels the scale – you simply need to specify the range and the number of ticks. A standout feature for dashboards: colour sections that divide the scale into visual zones. The demo shows a heart rate monitor (110 bpm) with four sections – blue, green, orange and red – and a black needle indicating the current value. Each section can have its own colour, tick style and label. A pointer – either a line or an image – is attached to the circular scale and is controlled directly by the value via data binding. Other examples from the LVGL documentation include a compass and sunrise and sunset indicators.
Bar - linear progress bar
lv_bar is a horizontal or vertical bar with a background and a pointer. Three modes: normal (from minimum to current value), symmetrical (from zero in both directions – useful for indicating deviations) and range-based (any start–stop range). Value updates can be animated with a configurable speed and acceleration curve – a smooth transition looks more professional than a sudden change. The background and pointer can be styled independently: gradients, rounded corners, shadows.
LED - status indicator
lv_led simulates an LED: a small rectangle or circle with adjustable brightness. The API is deliberately minimalist – lv_led_on(), lv_led_off(), lv_led_toggle() and lv_led_set_brightness() (range 0–255). Visual effects are achieved through style properties: the border creates a ring around the ‘LED’, whilst the shadow simulates a glow. Typical uses in a dashboard include indicating connection status, process activity, device output status or alarm levels using colour-coding.
Switch - binary switch
The lv_switch looks like a mobile switch: a rounded track with a sliding knob. It supports touch, keyboard and rotary encoder input. The three parts of the widget are styled independently: the track (background), the indicator (the filled-in section indicating the ON state) and the knob (the movable element). The orientation automatically adapts to the widget’s aspect ratio – if it is wider than it is tall, it adopts a horizontal layout; if taller, a vertical one. In a dashboard, it is typically used to switch functions, operating modes, controller outputs or notifications on and off.
Tabview - tabbed navigation
lv_tabview divides the interface into named tabs that can be switched by clicking on the tab header or using a swipe gesture. Tabs can be placed on any edge of the container: top, bottom, left or right. Each tab is a separate container – you can add any widgets to it just as you would to a standard LVGL object. Tabview is the most common navigation mechanism in the LVGL demo – visible as Profile, Analytics and Shop – and a natural solution for dividing the dashboard into thematic views: overview, details, settings.
LVGL Safe – UI for critical systems
The growing prevalence of touchscreens in medical, industrial, aviation and automotive devices creates a new requirement: a UI library must not only be functional, but also certifiable in accordance with functional safety standards.
The standard version of LVGL – despite its maturity – does not meet certification requirements: lack of a formal safety analysis, lack of a Safety Manual, and external dependencies.
LVGL Safe
LVGL Safe is a new product written from scratch, independently of the main branch of the library, with safety as a design priority:
| Aspect | LVGL (open-source) | LVGL Safe |
|---|---|---|
|
Architecture |
Evolved over the years |
Written from scratch |
|
Certifiability |
None |
Yes |
|
External dependencies |
Several |
None |
|
Safety Manual |
None |
Included |
|
Access to source code |
Open-source |
Full audit |
|
Widgets |
30+ interactive |
Interactive (not just image blending) |
|
Licence |
MIT |
Commercial |
Target standards
| Standard | Industry |
|---|---|
|
IEC 61508 |
Industry – safety of E/E/PE systems |
|
ISO 26262 |
Automotive – safety in road vehicles |
|
Medical – software life cycle |
|
|
DO-178C |
Aviation – software in aviation systems |
Status and availability
LVGL Safe is in the early testing phase. Planned launch: Q3 2026. Sign up for early access at lvgl.io/safe.
The significance of this product extends beyond the library itself – until now, UI developers for safety-critical systems have had to choose between full graphical capabilities (which cannot be certified) and simple, certified but visually limited solutions. LVGL Safe is designed to fill precisely this gap.
When should you choose LVGL?
LVGL is the right choice when:
the project requires a colour, animated UI on an MCU or MPU
the budget rules out expensive SoCs with a full operating system
time-to-market is critical – ready-made widgets, comprehensive documentation, an active community
the application must run on FreeRTOS, Zephyr or bare metal
the product includes an IoT dashboard displaying live sensor data, charts or status indicators – LVGL handles all of these efficiently, even on modest hardware
we want to avoid licence fees in the production product
LVGL is probably too complex when:
the UI is limited to a few segments (a simple display driver is sufficient)
the target platform runs full Linux with Qt or GTK available natively
WizzDev’s LVGL PoC
Getting started in this ecosystem is now easier than ever – an ESP32-S3 board, a USB cable and ESP-IDF are all you need to have a working demo within an hour, featuring a fully-fledged, animated touchscreen interface on a 7-inch 800×480 display.
A proof-of-concept was developed alongside this article: a four-tab IoT dashboard transferred directly from a Figma project onto a physical touchscreen. The exercise had one aim – to check whether using Figma as a starting point and LVGL as the rendering engine is an approach worth recommending for production projects.
The ‘Company’ tab displays the corporate layout with a header, a grid of three sectors (Smart Home, Smart City, Medical Devices) and statistics. ‘Technologies’ showcases the technology stack in the form of cards featuring logos – programming languages, MCU platforms, RTOS systems, AWS cloud and development tools. IoT Data is a real-time telemetry panel: line and bar charts, four Arc gauges for temperature, humidity, pressure and WiFi RSSI, sensor level bars, device control switches and an alerts section. Plot Data is an interactive scatter chart displaying material data – PIP stress versus tensile strength for six types of metal (Al, Cu, Ni, Ot, St, Ti) with filtering by processing method. Bonus: after 60 seconds of inactivity, a screensaver with animated slides is activated.
Result: 33 FPS at 7–10% CPU load. A microcontroller costing just a few dozen zlotys supports a responsive, multi-tab dashboard with live IoT data – whilst leaving over 90% of its computing power available for the application’s business logic. This is probably the shortest answer to the question of whether LVGL on the ESP32-S3 is suitable for anything serious.
Summary
Over the course of a few years, LVGL has evolved from a hobbyist library into a fully-fledged ecosystem with official partners amongst the largest semiconductor manufacturers and tens of thousands of production deployments – ranging from Xiaomi smartwatches to professional light meters and payment card readers.
Key advantages:
minimal hardware requirements,
a rich set of widgets,
no licence fees,
extensive support for platforms ranging from bare metal to Linux,
Tools such as SquareLine Studio lower the barrier to entry for UI designers with no experience in embedded systems.
