Public / live

Browser-based embedded UI development

Visual ESP32 UI design with ForgeUI Hosted Studio

ForgeUI Hosted Studio is a visual LVGL UI builder for embedded interfaces and HMIs on supported ESP32-P4 and ESP32-S3 displays. Drag and drop controls or use an optional AI Layout, generate native C, simulate your LVGL 9 UI in the browser, then build ESP-IDF firmware and flash supported hardware.

Check supported board profiles for display capabilities and browser flashing requirements, or explore standalone ESP-IDF project export for local development.

Open ForgeUI Hosted Studio Explore ForgeUI Studio

Open the browser-based Studio with no local Studio installation. ForgeUI Studio is free for personal and non-commercial use, with no time limit. Business / commercial use requires a Business licence. AI generation uses separate AI Credits.

ForgeUI Hosted Studio browser editor showing widgets, a board-aware canvas, document tree, preview and export controls

New in Hosted

Premium Native Instruments

Drag in a premium instrument. Export it. Connect live data.

Premium RPM Gauge and Premium Speedometer are editable, configurable Hosted Studio components with native LVGL output and generated Runtime SDK APIs.

Physically proven together on a Guition JC8012P4A1C ESP32-P4 10.1-inch display at 800 × 1280 portrait.

Widget APIs & firmware hookup →

Premium Speedometer and RPM Gauge running on a Guition JC8012P4A1C ESP32-P4 10.1-inch portrait display. — **Premium Speedometer + Premium RPM Gauge.** Physical ESP32-P4 proof on the Guition JC8012P4A1C 10.1-inch display at 800 × 1280 portrait.

Searchable Component SDK

Hosted Help now lets you search documented components for properties, generated APIs, firmware hookup and I/O guidance. Use the generated Runtime SDK to carry sensor or application state into a widget, and generated FG_On_* hooks to carry real touch interactions back to your application logic.

Read SDK & Widget Hookup →

ForgeUI Hosted Studio searchable Widget SDK and firmware hookup Help. — **Help & Support included.** Search widget-specific APIs and developer-integration guidance without leaving Hosted Studio.

One engineering workflow

From browser canvas to native embedded output

01

Visual design

Drag and drop controls or start with an optional AI Layout, then refine your LVGL 9 interface on the board-aware canvas.

02

Native C generation

Generate native LVGL C from your design, with runtime APIs and hooks for application behaviour.

03

Browser simulation

Run generated UI code with real LVGL 9.2.2 in the browser simulator. Hardware services and custom application C require the physical target.

04

ESP-IDF build & flash

Build firmware on ForgeUI infrastructure, verify the connected target and flash supported hardware through browser Web Serial.

Browser Build & Flash

Build in the cloud. Connect in the browser. Flash to supported ESP32 hardware.

Hosted Studio builds your generated firmware on ForgeUI's build infrastructure, so the Hosted path does not require a local ESP-IDF toolchain. Connect a supported board through the browser, review the detected target, and flash the finished firmware directly to the device.

ForgeUI verifies the connected target before flashing. Browser flashing requires a compatible desktop browser, Web Serial and a supported board profile. Hosted builds typically take approximately 2–4 minutes.

01

Select a supported board

02

Design and generate

03

Hosted build

04

Browser connect

05

Verify the detected target

06

Flash and run

LVGL Simulator · Live in Hosted Studio

Real LVGL. Right in your browser.

Run your generated LVGL interface before connecting the board. ForgeUI compiles generated C with real LVGL 9.2.2 to WebAssembly, so you can inspect native controls and navigation with browser pointer interaction.

Design

Drag and drop on a board-aware canvas. Edit properties in the Inspector, apply themes, palettes, backgrounds and assets, then save your Hosted project.

Bind & Simulate

Connect supported controls in the Inspector without hand-writing callback plumbing, then interact with the generated interface in real LVGL.

Build & Flash

Build ESP-IDF firmware and flash a supported ESP32 board using browser Web Serial. Verify hardware behaviour on the physical target.

Hosted Sim runs generated, data-only display projects and preserves saved firmware hardware settings. Developer-owned Hybrid C, hardware services and application logic run through exported firmware or Build & Flash on the target. Generated component setters connect sensors, CAN, UART, ADC and application state to the UI.

Open Hosted Studio LVGL Simulator workflow and V1 limits →Supported boards →

From background to editable UI

Build an interface, not a static mockup

Combine a visual background with editable regions and ForgeUI controls for status, selection and machine actions. Preview the interface at the selected device resolution before export.

Editable coffee machine interface created in ForgeUI Hosted Studio — **Coffee machine controls.** Background, structured regions and editable controls brought together on the canvas.

Soda dispenser interface with four colorful drink selections and editable dispense controls — **Soda dispenser controls.** A second hardware-ready interface created in Hosted Studio.

Two ways to work

Visual by default. AI-assisted when you choose.

Hosted Studio remains a direct visual UI builder. Use free deterministic layouts and normal canvas editing, or bring in AI generation for specific creative and structural steps.

Free / direct workflow

Choose, place and edit

Free layout presets with a preview before applying
Editable canvas regions and drag/drop ForgeUI components
Asset management, project saving and normal visual editing

Optional AI assistance

Generate, refine and keep editing

AI Layout generation · 50 AI Credits
AI Hero/Background generation · 100 AI Credits
Interactive artwork · 100 AI Credits per genuine provider generation where supported

ForgeUI Hosted Studio free industrial layout presets and editable region preview — **Layout Presets — Free.** Pick a deterministic structure, preview its regions and apply it to the editable canvas.

ForgeUI AI Layout generator with prompt and validated layout review panels — **AI Generate — 50 Credits.** Describe the screen, review the validated structure, then insert it into Canvas.

Board-aware AI Hero studio

AI backgrounds that understand your display.

Select the board, choose a style and generate. ForgeUI automatically uses the target dimensions and orientation—1024 × 600 landscape for Waveshare or 800 × 1280 portrait for Guition—then lets you apply the result to Canvas and export it with the project.

The Guition workflow has been live-validated with a genuinely portrait-composed Hero. Preset browsing, prompt editing, cropping, conversion, saving and applying do not add another AI charge.

ForgeUI Hero and Background workspace showing generated preview, curated presets and saved prompts — Curated starting points and reusable Saved Prompts keep the workflow fast without making it AI-only.

Theme and asset workflow

Palettes, backgrounds and compatible assets—clearly separated.

Compact Theme Manager navigation separates Palettes, Backgrounds and Asset Library. Assets can be viewed as Compatible, All assets, Heroes, Weather, Components or Other, so generated component states no longer compete with every background in one undifferentiated list.

Compatibility follows screen dimensions and orientation rather than a permanent board name. Badges such as HERO, 800×1280, PORTRAIT and COMPATIBLE make the active screen family visible.

Account-backed workflow

Bring assets in. Save the project. Pick up where you left off.

The Hosted asset manager prepares project imagery for LVGL use, while persistent projects let you save and reopen work through your verified account.

ForgeUI Hosted Asset Manager with image upload area and LVGL-ready asset library

Hosted Projects dialog for saving, opening and managing persistent ForgeUI projects — Save the current browser project into Hosted ownership, then reopen a stored revision later.

ForgeUI board configuration showing optional ESP32-P4 hardware and generated developer tools

Two delivery paths

Flash in Hosted Studio or own the standalone project

Use the Hosted path to build, connect and flash without configuring ESP-IDF locally. When you want the full source workspace, export a standalone ESP-IDF project with native LVGL output and continue in your normal embedded toolchain.

01Select a supported ESP32-P4 target
02Build and flash in the browser
03Or export the standalone project ZIP
04Continue locally with normal ESP-IDF tools

ForgeUI Studio

The local workflow remains

Use the downloadable Studio and local ESP-IDF toolchain for developer-owned projects, firmware builds, flashing and hardware integration.

Explore ForgeUI Studio →

Hosted Studio

The browser path reaches real hardware

Verified accounts, persistent projects and assets, Hosted builds, target safety checks and browser flashing extend the workflow without taking ownership of your exported application logic.

View access boundaries →