If you’ve picked up Unity recently, you’ve probably heard the push: “Use UI Toolkit! It’s the future! It’s based on web standards like HTML and CSS!”

So, when I started my recent internship and was tasked with building a full inventory system from scratch, I figured it was the perfect time to dive into the new workflow. The requirements were clean: use the new UI Toolkit and power everything via Scriptable Objects. Every item spawned in the inventory slots had to be driven by data from those Scriptable Objects.

I was excited. And for a while, it actually went great. I got the core logic down, the Scriptable Objects were binding correctly, and I was pretty close to crossing the finish line.

Then came the UI design requirements.

The layout called for windows inside windows. Nested panels. Scrollbars that needed to behave properly within those nested views. On top of that, I needed a clean system of radio buttons for filtering and tabs.

That is exactly where the honeymoon phase ended.

Trying to wrangle nested windows, dynamic scrollrects, and custom radio button behavior inside UI Toolkit felt less like modern development and more like getting tangled up in a massive spider web. Every time I tried to fix a layout issue or get a UI element to scale right inside a nested panel, something else broke. The documentation felt sparse for complex, nested game layouts, and the visual editor started feeling more like a hindrance than a help for what I was trying to achieve.

I was spending 80% of my time fighting the UI layout engine instead of actually building the inventory system. With internship deadlines looming, I had to make a call.

I scrapped the UI Toolkit setup, opened up a new canvas, and switched back to good old UGUI (Unity's legacy Game Object-based UI system).

The relief was instant. Within a fraction of the time, I had:

• Nested canvases and panels behaving exactly how I wanted.
• Scroll Rect components that didn’t require a blood sacrifice to configure.
• Toggle Groups functioning perfectly as radio buttons right out of the box.
• My Scriptable Object data spawning prefabs into grid layouts smoothly.

Don't get me wrong—UI Toolkit has massive potential. For simple layouts, clean UI documents, and specialized editor tooling, it’s great. But when you are building complex, deeply nested, highly interactive in-game menus, UGUI still wears the crown. It’s predictable, the workflow is deeply integrated with standard Game Objects and prefabs, and when you're on a tight deadline, predictability beats "cutting-edge" every single time.

If there is one thing this internship taught me, it's that choosing the shiny new tool isn't always the right move. Sometimes, the best tool is the one that actually lets you finish the project.