Design & Connect
Build on the board-aware canvas, then connect compatible semantic values in the Inspector. The current Visual Logic slice supports direct numeric bindings.
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 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.
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 →
Searchable Component SDK
ForgeUI does not stop at design.
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.
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.
05
Integrated Serial
Reconnect after flashing and inspect live ESP-ROM, ESP-IDF and application output without restarting the browser.
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
New · Production live
Browser Serial Terminal
Stay with the hardware after flashing.
ForgeUI's integrated Serial Terminal shows live ESP-ROM, ESP-IDF and application output directly inside Hosted Studio, with clean ownership handoff between Serial and browser flashing.
Disconnect Serial, flash the device, then reconnect without restarting the browser. The text Send field writes bytes to the device; the device firmware must implement its own command handling to respond.
01
Web Serial connection
02
Baud selection · 115200 default
03
Live output with auto-scroll
04
Clear and Copy
05
Text Send with optional newline
06
Disconnect · Flash · Reconnect
LVGL Simulator · Live in Hosted Studio
Real LVGL. Right in your browser.
Run generated C with real LVGL 9.2.2 compiled to WebAssembly before connecting a board. Test navigation and native controls with pointer interaction, then use Runtime Controls to inject approved simulated application or sensor values.
Simulate & Test
Run the generated interface in real LVGL. Transient Runtime Controls call approved FLOAT Runtime SDK setters so you can test live values and binding fan-out.
Export or Flash
Export the generated application architecture or build ESP-IDF firmware and flash a supported ESP32 board through browser Web Serial.
Designed HMI
Your canvas components, generated C and saved Visual Logic bindings are part of the application.
Sim test controls
Runtime Controls are developer-only, Sim-only and transient. They are not added to the HMI, persisted as project defaults, custom C, or hardware I/O configuration.
Hosted Sim runs generated, data-only display projects. It does not emulate ESP32 hardware or run developer-owned Hybrid C. Developer-owned Hybrid C, hardware services and application logic run through exported firmware or Build & Flash on the target. There, generated component setters connect sensors, ADC, CAN, UART and application state to the UI.
Design · Connect · Simulate · Flash
Connect compatible component values without writing glue C.
Visual Logic lets one supported semantic source drive multiple compatible display targets. Each target keeps its own configured range, clamping, formatting and component behaviour.
In the proven workflow, Analog Input Measurement.value fans out to Pressure Measurement, Sensor Tile, Premium RPM Gauge and Tank Level Card.
Real LVGL 9.2.2Generated CWebAssemblyDirect numeric binding
See Visual Logic and simulated I/O →
Existing Slider → Gauge proof
The earlier direct Slider binding remains supported. Drag the real LVGL Slider in browser Sim and watch the generated gauge respond.
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.
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
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.
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.
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 →Public / live
The Hosted Studio is live. Come have a look.
Enter the browser-based application today. Public registration and prepaid Hosted access are available under the current Hosted Access Terms.
Read Hosted Access Terms →