LVGL MCP — Let Your Agent See the UI It Writes

    1

    Headless LVGL v9 UI development with real-time PNG rendering and touch interaction simulation.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    LVGL MCP — Let Your Agent See the UI It Writes

    Example session with this skill installed

    Create a 320x240 settings screen with a 'Wi-Fi' toggle and a brightness slider. Render it to make sure the labels are aligned left.

    • Read your context and instructions
    • Compiled the lvgl mcp

    I have written the C code for your settings screen and rendered it to verify the layout. The labels are aligned to the left using a flex layout, and the controls are centered vertically within their respective rows.

    LVGL Settings Screen

    #include "lvgl.h"
    
    void create_ui(lv_obj_t *parent)
    {
        lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
        lv_obj_set_flex_align(parent, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
        lv_obj_set_style_pad_all(parent, 10, 0);
        lv_obj_set_style_row_gap(parent, 15, 0);
    
        /* Wi-Fi Row */
        lv_obj_t *row1 = lv_obj_create(parent);
        lv_obj_set_size(row1, lv_pct(100), LV_SIZE_CONTENT);
        lv_obj_set_flex_flow(row1, LV_FLEX_FLOW_ROW);
        lv_obj_set_flex_align(row1, LV_FLEX_ALIGN_SPACE_BETWEEN, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
        
        lv_obj_t *label1 = lv_label_create(row1);
        lv_label_set_text(label1, "Wi-Fi");
        
        lv_obj_t *sw = lv_switch_create(row1);
        lv_obj_add_state(sw, LV_STATE_CHECKED);
    
        /* Brightness Row */
        lv_obj_t *row2 = lv_obj_create(parent);
        lv_obj_set_size(row2, lv_pct(100), LV_SIZE_CONTENT);
        lv_obj_set_flex_flow(row2, LV_FLEX_FLOW_COLUMN);
        
        lv_obj_t *label2 = lv_label_create(row2);
        lv_label_set_text(label2, "Brightness");
        lv_obj_set_style_margin_bottom(label2, 5, 0);
        
        lv_obj_t *slider = lv_slider_create(row2);
        lv_obj_set_width(slider, lv_pct(100));
        lv_slider_set_value(slider, 70, LV_ANIM_OFF);
    }
    

    Next steps

    • Verify the alignment in the attached PNG render.
    • Test the toggle interaction by calling simulate_lvgl_ui with a tap at the switch coordinates.
    • Copy the create_ui function into your main.c or UI task.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    (Headless Render + Touch Simulation)

    Your agent writes LVGL v9 create_ui() C code; lvgl-mcp compiles and renders it headlessly to a PNG, so the agent can actually look at the screen, fix what's off, and iterate — no display, no device, no flashing. A touch simulator replays taps, swipes and drags and returns screenshot sequences to verify interactions. Runs 100% locally: a stdio MCP server driving your own Docker daemon. Works with Claude Code, Cursor, Copilot and other MCP clients.

    What's included

    • The lvgl-mcp repository (https://github.com/airpocket-soundman/lvgl-mcp):
      • mcp_server/ — FastMCP stdio server with three tools: render_lvgl_ui, simulate_lvgl_ui, lvgl_widget_cheatsheet.
      • renderer/ — Docker image (Debian + LVGL v9.4.0 prebuilt) with the headless renderer and touch-simulator harnesses; only your ui.c is recompiled per run, so iterations take seconds.
      • setup.sh + .mcp.json.example — one-command setup and client wiring.
      • examples/ — a hello-world UI and simulator screenshot sequences.
    • The SKILL.md, which teaches the buyer's agent when and how to drive the server (setup, the create_ui() contract, the touch-action DSL, responsive-layout guidance).
    • Any canvas size (320×240 default — small-panel size — up to large panels such as 1280×720), Material Icons font included, gcc errors returned as readable text for the agent's fix loop.

    Requirements

    • Docker (local daemon), Python 3.10+, an MCP client.
    • v1 scope: rendering + touch simulation only. Flashing real hardware is out of scope; the validated create_ui() code drops into the buyer's own firmware project unchanged.
    • Needs access to: the lvgl-mcp MCP server, installed locally by the buyer from the public GitHub repo above.

    Pricing note: this skill is free for now while I gauge interest. If there is real demand, I plan to switch it to a paid listing later — early users, thanks for trying it.

    Requires Docker daemon and local Python environment. Supports LVGL v9 only. No support for hardware flashing or device-specific drivers.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 23 days ago

    • Free with an Agensi account

    Requires

    GitHub
    LVGL MCP
    Python
    Git
    Docker

    Permissions

    Terminal / Shell
    Network Access

    Allowed Hosts

    github.com

    Needs access to: the user's own lvgl-mcp MCP server installed locally from https://github.com/airpocket-soundman/lvgl-mcp, requiring a local Docker daemon.

    Listed23 days ago

    What's inside

    Frequently Asked Questions

    This skill provides a headless rendering environment that allows AI agents to compile LVGL C code and generate PNG screenshots instantly. This eliminates the need for physical hardware during the design phase, allowing for immediate visual verification of layouts and styles.

    The skill requires a local Docker daemon to run the rendering container and an environment that supports the Model Context Protocol (MCP). It is compatible with any AI agent or IDE that implements the MCP standard, such as Claude Desktop or various developer-focused AI tools.

    Yes, you can simulate complex user flows including taps, swipes, and drags using a built-in DSL. The renderer can capture frame-by-frame snapshots during these sequences, allowing the agent to verify that animations and state changes occur correctly.

    Upon purchase, you receive the MCP server implementation, the Docker configuration for the LVGL v9 rendering environment, and the documentation for the interaction DSL. It also includes a built-in component cheatsheet to help the agent reference LVGL v9 specific syntax.

    This skill is specifically optimized for LVGL version 9. While older v8 syntax may work for basic widgets, the rendering engine and component referencing tools are built to leverage the specific flexbox, style, and API improvements introduced in version 9.

    New in Testing & Debugging