u/FlamingoSad9210

Every UI-heavy project I've worked on had the same bottleneck: an artist designs the menu in Photoshop, and then someone has to manually recreate that entire layer hierarchy in UMG — naming widgets, setting anchors, wiring up buttons, redoing it every time the design changes. It's slow and it eats hours that should go toward actual gameplay work.

So I built UI Widget Builder, an Unreal Engine editor plugin that automates PSD-to-UMG conversion.

How it works:

1. Design your UI in Photoshop using a set of layer naming prefixes
2. Run the included Photoshop JSX exporter — it spits out a layout.json + Textures folder
3. Import that into Unreal Engine (Tools → UI Widget Builder)
4. It auto-generates the widget hierarchy, root screens, textures, and layout structure

It also has optional Blueprint logic generation for the boring stuff — button interactions, WidgetSwitcher tab logic, close-on-escape, slider/checkbox helpers, sound hookups, etc — so you're not starting from a totally blank graph either.

Some other things it handles: portrait/landscape support, SafeZone/ScaleBox/SizeBox wrappers, a preset manager so you're not redoing import settings every time, and a clean re-import option when the design changes.

Happy to answer questions about the workflow or how the exporter handles layer naming — this came out of solving my own pain point, so curious if it'd be useful for other people's pipelines too.

Get UI Widget Builder on Fab: https://fab.com/s/9d5dec9c53ca

Video Demonstration https://youtu.be/OUc7Mwuv9XA

Documentation https://sepinood.github.io/UIWidgetBuilder/

Every UI-heavy project I've worked on had the same bottleneck: an artist designs the menu in Photoshop, and then someone has to manually recreate that entire layer hierarchy in UMG — naming widgets, setting anchors, wiring up buttons, redoing it every time the design changes. It's slow and it eats hours that should go toward actual gameplay work.

So I built UI Widget Builder, an Unreal Engine editor plugin that automates PSD-to-UMG conversion.

How it works:

1. Design your UI in Photoshop using a set of layer naming prefixes
2. Run the included Photoshop JSX exporter — it spits out a layout.json + Textures folder
3. Import that into Unreal Engine (Tools → UI Widget Builder)
4. It auto-generates the widget hierarchy, root screens, textures, and layout structure

It also has optional Blueprint logic generation for the boring stuff — button interactions, WidgetSwitcher tab logic, close-on-escape, slider/checkbox helpers, sound hookups, etc — so you're not starting from a totally blank graph either.

Some other things it handles: portrait/landscape support, SafeZone/ScaleBox/SizeBox wrappers, a preset manager so you're not redoing import settings every time, and a clean re-import option when the design changes.

To be clear about limitations: it's editor-only, generated widgets are meant to be treated as generated output (manual edits can get wiped on clean re-import), and project-specific stuff like save systems, localization, and gameplay logic still needs manual work. It's a UI generation tool, not a magic wand.

Video demo | Docs

It's up on Fab if anyone wants to check it out: [UIWidgetBuilder]

Happy to answer questions about the workflow or how the exporter handles layer naming — this came out of solving my own pain point, so curious if it'd be useful for other people's pipelines too.

Hey fellas.
Working on an UE editor plugin called UIWidgetBuilderEditor.

The goal is building a fully automated UI pipeline between designers and Unreal Engine. Instead of rebuilding everything manually in UMG, the system imports PSD/JSON layouts and automatically generates:
UMG widget hierarchies
Blueprint logic
panel/screen workflows
modal systems
DPI/platform setup
layout wrappers (SafeZone / ScaleBox)
visibility & interaction helpers

The important part:
A UI designer can test and iterate layouts directly inside Unreal Engine with very little engine knowledge.

The workflow is based on a structured naming convention from the design side.
Example naming roles:
GRP_ → UI Groups / Screens
PNL_ → Panels
BTN_ → Buttons
TXT_ → Text widgets
IMG_ → Images
ModalBG_ → Modal overlays
The importer reads those naming rules and automatically builds the proper runtime hierarchy and Blueprint logic.

Example:
You can build a full Settings UI in Photoshop/Figma, export JSON, and automatically generate:
settings panels
navigation logic
modal backgrounds
visibility switching
input/cursor handling
runtime widget hierarchy
without manually rebuilding the entire UI in UMG.

Current pipeline already supports:
✅ JSON hierarchy reconstruction
✅ automatic UMG generation
✅ generated Blueprint logic
✅ per-panel usage settings
✅ modal background generation
✅ screen-type detection from layout groups
✅ visibility logic generation
✅ platform/DPI setup
✅ SafeZone + ScaleBox wrapper generation

Goal is turning this:
PSD / Figma / JSON
→ automated Unreal UI generation
→ production-ready UI scaffolding

instead of spending hours rebuilding layouts manually.
Currently exploring:
runtime screen managers
UI state machines
animation generation
automatic navigation
responsive layouts
design-to-runtime workflows
CommonUI integration

Curious what other UE UI developers/designers would want from a tool like this.

What features would save the most production time in your UI workflow?

Hey everyone,

I’ve been working on a material baking tool for Unreal, and just released Version 2 on FAB.

This started as something I built for my own workflow — mainly to deal with converting complex materials (layered, procedural, world-aligned, etc.) into clean texture maps.

V2 is a pretty big upgrade over the first version:
• Added proper batch baking workflows
• Automatic material + instance creation
• Support for skeletal meshes (characters)
• Better handling of tiled / UDIM-style UVs
• Improved overall workflow (less manual setup)

The goal is basically:
👉 Take any material → bake it → get clean PBR textures + ready-to-use material

If you want to check it out:

🎬 Demo:
https://www.youtube.com/playlist?list=PLhqUhIN0UwzmjTkehp6K2BppBabcJlAAS

📘 Full feature documentation:
https://docs.google.com/document/d/1ioXa8aAXfeB8HRpXTOPkRaT4ZdU9VIVl/edit

🛒 FAB page:
https://fab.com/s/4baa5507c1e8

If you tried V1 before, I’d really love to hear what you think about the changes in V2.

And if you’re dealing with similar workflows, happy to answer any questions 👍