UnityDynamicPanels: draggable, dockable panels for Unity's UI system

A docking system built on the ordinary UI

UnityDynamicPanels is a Unity asset for creating dynamic panels using Unity's UI system. The panels can be dragged around, resized, docked to canvas edges or to one another, and stacked next to each other as separate tabs.

That last capability is the one that separates it from a panel manager you could build with layout groups in an afternoon. A docked panel is moved by the layout system depending on where it is docked, and a panel can hold multiple tabs. The result is the kind of interface a user rearranges once and then keeps, with the layout remembered by the user rather than fixed by the developer.

The feature list names four things, and each is a decision about scope.

It supports all canvas modes, screen space and world space, which means the panels can live on a 3D surface rather than only as an overlay. It supports multiple canvases, and panels can be moved between canvases by dragging. It has an extensive Scripting API to create and manipulate panels by code, so the panel set can be defined by data rather than by scene authoring. And each panel costs 3 additional batches, a number that can increase with each tab using a custom icon.

That last item is the honest cost of the design and it is stated in the project's own feature list rather than buried. Three extra batches per panel is not free, and a scene with a dozen panels pays it twelve times over.

The project is available on the Unity Asset Store, has a forum thread on the Unity forums, a Discord server and a WebGL demo hosted by the author, and the primary language is C# with an MIT licence.

Five installation routes

The documentation lists five ways to install the plugin, which is a reasonable answer to the fact that Unity projects are distributed in several incompatible ways.

The first is to import DynamicPanels.unitypackage from the releases page via Assets and Import Package. The second is to clone or download the repository and move the Plugins folder into your Unity project's Assets folder. The third is to import it from the Asset Store.

The fourth and fifth are the package manager routes. Through the Package Manager you click the plus button and install the package from its git URL:

https://github.com/yasirkula/UnityDynamicPanels.git

Or through OpenUPM, where after installing openupm-cli you run:

openupm add com.yasirkula.dynamicpanels

The repository supports both styles of consumption because it ships both: a Plugins folder for the classic Assets workflow and a package.json at the root for the package manager, with the name com.yasirkula.dynamicpanels, the display name Dynamic Panels, the version matching the release, and links to the documentation, the changelog and the licences. The package.json also sets hideInEditor to false, so the package appears in the package manager listing rather than being an invisible local dependency.

The practical difference between the routes is where the update comes from. The Asset Store route gives you the author's release cadence through Unity's own updater, the git URL gives you the repository's master branch, and the unitypackage import gives you a specific tagged build. For a project that will live for years, the third is usually the one that ages best.

Free panels and docked panels, and who is allowed to move them

The panel model has two kinds, and the difference is about who controls the position.

Free panels are moved around and resized freely, by the user. Docked panels are moved by the layout system, depending on where they are docked to. A panel can have multiple tabs in either case.

The setup begins by adding the Dynamic Panels Canvas component to the RectTransform inside which the panels will reside. That RectTransform does not have to be the Canvas object itself: it can be a child of the canvas, and it can have a custom size. That flexibility is what lets a project put a panel system in a corner of the screen rather than filling it.

There are two ways to create panels, using the GUI of the Dynamic Panels Canvas or the scripting API, and the documentation walks through the GUI path in detail.

To add a free panel you click the Add New button under the Free Panels section, then the plus button to start adding tabs to that panel. Each tab has four properties: the content, a RectTransform displayed while the tab is active, a label, an optional icon, and the minimum size of the content associated with the tab. To remove a free panel you select a tab inside the panel and click Remove Selected.

Docked panels are created with the buttons under the Docked Panels section. To dock a panel to the edge of the Dynamic Panels Canvas you use the buttons next to Dock new panel to canvas. You can click a panel inside the preview zone, immediately under the Docked Panels section, and edit its tabs, and you can dock a panel to the selected panel using the buttons next to Dock new panel inside.

The settings that actually define the docking behaviour

A docking system lives or dies on its drop zones, and the Dynamic Panels Canvas exposes the relevant numbers as plain settings.

Leave Free Space, when enabled, means there is always some free space in the canvas that docked panels cannot fill; otherwise docked panels fill the whole canvas. Minimum Free Space determines how much of that free space there is when the option is enabled, and Free Space Target Transform lets you assign a RectTransform whose position and size are then kept in step with the free space automatically.

Prevent Detaching Last Docked Panel, when enabled, makes an attempt to detach the last docked panel from the canvas fail automatically. That is a guard rail for a specific situation: a docked panel is the only one there, and removing it would leave an empty canvas.

The three zone lengths are the geometry of the interaction. Panel Resizable Area Length is the size of the invisible resize zones at each side of the panels that allow users to resize them. Canvas Anchor Zone Length is the size of the Dynamic Panels Canvas drop zones, and when a tab is dragged and dropped onto that area it is docked to that edge of the canvas. Panel Anchor Zone Length is the size of the panels' drop zones, so a tab dropped there is docked to that panel, and this area is enabled only for docked panels, since you cannot dock a panel to a free panel.

Initial Size applies to docked panels only and sets the initial size of a docked panel. It is achieved by programmatically resizing the panel after it is created, so the operation may affect the sizes of adjacent panels as well, and the value has no effect if left at (0,0).

One implementation detail is worth knowing before you edit the prefab. If you change the Resources/DynamicPanel.prefab, make sure that the panel's Header Height property equals the distance between the top of the panel and the bottom of the PanelHeader child object, which holds the tabs at runtime.

Scripting from code, and the cost in batches

The scripting API exists because a dynamic panel set is often data rather than scene content, and the API is small enough to read in a minute.

Before using it you import the DynamicPanels namespace into your scripts. PanelUtils then offers two static entry points. CreatePanelFor takes a RectTransform content and a DynamicPanelsCanvas, creates and returns a panel with a tab associated with that content, inside the specified canvas, and if the content is already part of a panel it returns the existing panel instead of creating a duplicate. GetAssociatedTab takes a RectTransform content and returns the tab it is associated with, or null if it is not associated with one.

The Panel type exposes the same context as properties, for example the DynamicPanelsCanvas it currently belongs to and its PanelGroup.

There is also a small component worth knowing about. Adding PanelCursorHandler to a GameObject makes the cursor dynamic, so its texture changes when it enters a panel's resizable area. That is a touch of polish that costs a component, with the caveat that it has no effect on Android and iOS, where the cursor is not a cursor.

The rendering cost is the part to weigh against your target device. Each panel costs 3 additional batches, and that number can increase with each tab using a custom icon. That figure is the price of the header, the tab strip and the panel background being separate draw calls rather than one, and it is why the project also publishes a WebGL demo: you can see the behaviour and the cost on a real scene before you wire it into a project with a frame budget you care about.

Old Unity versions, the input system, and the licence

Two compatibility notes are documented, and both concern older Unity releases rather than the plugin's own features.

The first is that the New Input System isn't supported on Unity 2019.2.5 or earlier. The fix is to add the ENABLE_INPUT_SYSTEM compiler directive to Player Settings, under Scripting Define Symbols, with the note that these symbols are platform specific, so if you change the active platform later you have to add the compiler directive again.

The second is that the Unity.InputSystem assembly can't be resolved on Unity 2018.4 or earlier, and the fix is to remove the Unity.InputSystem assembly from the DynamicPanels.Runtime assembly definition file's Assembly Definition References list.

Both are the kind of detail that matters only if you are on an old editor, and both are the kind of detail that is easy to lose. They are in the FAQ because they are the questions people actually ask when the plugin does not appear to work.

The licence is MIT, with LICENSE.txt in the repository root and the licence URL recorded in the package manifest, alongside the documentation, changelog and package manager entries. The package name is com.yasirkula.dynamicpanels, and the author sells the same asset on the Unity Asset Store, which is a common arrangement: the source is open, and the store listing is the supported distribution.

The release history shows the project moving steadily, with v1.3.5 on 2026-08-09, v1.3.4 on 2026-04-05 and v1.3.3 on 2025-03-29, and the last push matching the v1.3.5 release date. The current version in the package manifest is 1.3.5, so the manifest and the release tag are in step.

Editorial conclusion

UnityDynamicPanels suits a Unity project that needs a debug overlay, an in-game settings screen or a multi-tab tool window that users can rearrange, and that wants that behaviour on top of the ordinary UI system rather than a separate runtime window. It is the wrong choice for a mobile project with a tight draw call budget, since each panel costs three additional batches and that number grows with custom tab icons, and it is the wrong choice if you need the panels to live in world space on a 3D surface with the same fidelity as screen space, where the canvas mode support does not imply identical results. Verify three things before you commit: that the Unity version you use is new enough for the input system arrangement described in the FAQ, that the panel prefab has not been modified in a way that breaks the header height rule, and that the batch cost is acceptable for your target device.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. yasirkula/UnityDynamicPanels on GitHub