Skip to content

Back to Changelog Download README (.md)

izom PropUI

izom PropUI is a Blender extension for building custom-property panels with a visual editor. You author entries, arrange the generated layout, and press Generate UI to create normal Blender panels that can live in sidebars or Properties tabs.

  • Extension id: izom_propui
  • Version: 1.0.0
  • Blender: 5.0.0 or newer
  • License: GPL-3.0-or-later
  • Website: https://propui.bigizom.com/

What It Makes

PropUI turns an editor setup into generated Blender UI code. The generated UI can be saved in the .blend as a Text datablock and can also be exported as portable .py files. A generated panel can keep running without the PropUI editor being open.

Generated panels can expose managed custom properties, existing Blender RNA paths, operator buttons, display links, text blocks, sub-panels, row boxes, visibility rules, dynamic labels, and object/bone selection filters.

Installation

Install the built extension zip through Blender's extension/add-on installer, then enable izom PropUI.

The extension may ask Blender for:

  • File access, used for setup import/export, generated Python export, and bundle ZIP export.
  • Clipboard access, used for copying and pasting setup JSON, editor settings JSON, and entry presets.

Finding The Editor

By default, the PropUI editor appears in the 3D Viewport sidebar. Open the sidebar with N, then look for the PropUI tab.

In Blender's add-on preferences for izom PropUI, the editor location can be changed. The editor can appear in supported sidebars, supported Properties tabs, or both. Sidebar filters include 3D Viewport, Graph Editor/Drivers, Dope Sheet, NLA, Image/UV Editor, Node Editor, Sequencer, Movie Clip, Text Editor, File Browser, and Spreadsheet. Properties filters include the common Blender Properties tabs such as Object, Modifiers, Material, Scene, World, Render, Output, Bone, Constraints, Physics, and related data tabs.

The editor location preferences can also hide the editor while transforming or while animation playback is running.

Basic Workflow

  1. Choose a Property Storage target in Output Setup.
  2. Add entries in the Entry List.
  3. Configure the active entry in Selected Entry.
  4. Import or add entries into Generated Layout.
  5. Arrange rows, shared rows, row boxes, and sub-panels.
  6. Set the generated panel title, tab, location, and visibility.
  7. Press Generate UI.
  8. Use the generated panel like any other Blender panel.

Apply Properties can be used when you only want to create or update the managed custom properties without generating a panel.

Entry List And Generated Layout

PropUI separates authored entries from generated layout.

The Entry List is your authored list. It stores each entry, its settings, hierarchy, child conditions, storage settings, dynamic labels, presets, and display behavior.

Generated Layout decides what appears in the generated UI and where it appears. You can place entries in a different order from the Entry List, put several entries in shared rows, create sub-panels, wrap rows in row boxes, add spacing, and link entries more than once with Display Links.

Removing an item from Generated Layout does not delete the original Entry List entry.

Output Setup

Output Setup controls generation, saved setups, generated UI identity, generated UI management, visibility, and property storage.

Generate UI creates or updates managed custom properties, writes the generated Python UI script, registers the panel classes, and shows the generated UI.

Generation options:

  • Replace Storage on Generate: clears custom properties from the default storage target before rebuilding the managed properties.
  • Clean Old Targets on Generate: removes matching managed properties from old targets after entries move to another target.
  • Empty generated layouts can ask, apply properties only, or cancel, depending on the confirmation setting.

UI Variants

UI Variants are saved PropUI setups stored in the current .blend. They are useful when one file needs several generated panel designs.

Variants store the generated-output setup, Entry List, Generated Layout, row boxes, sub-panels, storage, and generated panel settings. They do not store Editor Settings, Editor Layout, shortcut target state, or editor section collapsed/open defaults.

Variant tools let you add, duplicate, remove, reorder, save, load, and clear setups.

  • Add creates a new variant holder.
  • Duplicate copies the selected variant holder and its saved setup.
  • Remove deletes the selected variant holder but does not delete generated panels or current editor data by itself.
  • Save writes the current setup into the selected variant, or creates a new variant depending on the confirmation setting.
  • Load replaces the current editor setup with the selected saved setup.
  • Clear removes all variant holders.

Loading a variant can ask what to do with unsaved changes in the current editor. Depending on the confirmation setting, PropUI can save to the last loaded variant, save as a new variant, discard changes, or ask each time.

Setup JSON import creates a UI Variant first. It does not immediately overwrite the current editor until that imported variant is loaded.

Generated UI Identity

Generated UI Identity controls the user-facing and cosmetic identity of generated panels.

  • Sidebar Tab: the tab/category for sidebar panels.
  • Panel Title: the visible generated panel title.
  • Use Custom Branding: enables generated-code naming customization.
  • Text Name: optional generated Text datablock name.
  • Namespace Prefix: prefix for generated registry keys, helper operators, and generated-control properties.
  • Panel Class Prefix: prefix for generated Blender panel classes.
  • Text Datablock Prefix: prefix for generated Text datablock names.
  • Show Credit Comment: include or omit the generated code credit comment.
  • Credit Comment: custom credit text when credit comments are enabled.

Branding changes are cosmetic for generated output. PropUI still keeps stable internal IDs, unique hashes, and saved generated UI records so old generated panels can be stopped, removed, detected, or regenerated.

Generated UIs

Generated UIs are managed generated outputs. The Generated UIs section lists generated panels saved by PropUI and portable scripts imported into PropUI management.

Common actions:

  • Run an existing generated script.
  • Stop a running generated panel for the current Blender session.
  • Remove one generated UI or clear all generated UI records.
  • Import generated scripts from Text datablocks.
  • Export generated .py files as a ZIP.
  • Remove stale running panels whose generated Text datablock is gone.
  • Unregister all running generated panels while keeping saved records.

Removal behavior:

  • Remove From Editor Only: removes the generated UI row from PropUI management, but leaves the panel running and keeps the generated Text datablock.
  • Stop UI, Keep Script: removes the generated UI row, unregisters the live panel for the current Blender session, and keeps the generated Text datablock.
  • Remove Everything: removes the generated UI row, unregisters the live panel, and deletes the generated Text datablock.

Stopping a generated UI is session-scoped. If its generated Text datablock and saved slot remain, it can come back when the .blend is reopened or when it is run again.

A stale generated UI means Blender still has generated panel classes registered, but PropUI can no longer find the saved generated Text script it expects. Regenerate, import a valid generated script, remove the stale row, or use the stale cleanup tools.

Running an imported generated UI script executes Python from a Blender Text datablock. Only run generated scripts you trust.

Visibility

Visibility controls where and when generated panels appear.

Generated UI locations include supported sidebars and supported Properties tabs. Sidebars can be targeted broadly or individually. Graph Editor/Drivers, Image/UV Editor, and Node Editor have more specific filters so a generated panel can appear only in the intended editor subtype.

Supported sidebar targets include 3D Viewport, Graph Editor/Drivers, Dope Sheet, NLA Editor, Image/UV Editor, Node Editor, Video Sequencer, Movie Clip Editor, Text Editor, File Browser, and Spreadsheet.

Supported Properties tabs include common Blender tabs such as Tool, Render, Output, View Layer, Scene, World, Collection, Object, Constraints, Modifiers, Object Data, Bone, Bone Constraints, Material, Texture, Particle, and Physics.

Generated panels can also be visible only when selected objects or bones match a configured list. Child generated sub-panels inherit the same visibility rules as their parent panel.

Property Storage

Property Storage is the default owner for managed custom properties. It decides where PropUI writes generated custom-property values.

Supported storage owner categories include:

  • Object
  • Object Data
  • Bone
  • Scene
  • Collection
  • Material
  • World
  • Action
  • Armature Data
  • Blender data-block owners such as Camera, Mesh, Curve, Light, Image, Text, Texture, Node Tree, Movie Clip, Sound, Speaker, Volume, Brush, Palette, Paint Curve, Particle Settings, Point Cloud, Cache File, Screen, Workspace, and Window Manager

Storage pickers adapt to the selected owner type. Object-like targets show object pickers, bone targets show armature and bone fields, scene targets show scene pickers, and data-block targets use Blender data-block search fields where available.

Selected entries can use Target Override to store their managed custom property on a different owner than the default Property Storage target.

Object storage writes to the Object itself. Object Data writes to the data-block used by the object, such as a Mesh, Curve, Camera, Light, or Armature data-block. Bone storage writes to a pose/edit bone owner. Data-block storage writes to the chosen Blender data-block directly.

Apply behavior:

  • Apply All Managed: creates or updates every managed non-text entry on its resolved target.
  • Apply Selected: creates or updates only the active Entry List entry.
  • Replace Storage on Apply: clears the default storage target before rebuilding all managed properties.
  • Clean Old Targets on Apply: removes matching managed properties from old targets.

When a native custom property already exists, PropUI can overwrite the conflict or skip it, depending on the confirmation/default behavior.

Entry Types

Float

Creates a floating-point managed custom property. Float entries support default value, min/max, soft limits, step, precision, slider display, common Blender subtypes, label layout, dynamic labels, and target override.

Integer

Creates an integer managed custom property. Integer entries support default value, min/max, soft limits, step, slider display, and optional choice controls such as dropdowns, toggles, and buttons. Integer choices store their zero-based integer value directly.

Choice Dropdown and Choice Toggle controls are integer controls, not a separate Enum entry type. Choice row 0 stores integer value 0, row 1 stores 1, and so on. Use Integer choices when you want an enum-like user experience while keeping a simple integer custom property underneath.

Boolean

Creates a boolean managed custom property. Boolean entries can draw as a checkbox or button-like control and can use per-state labels.

Array

Creates a managed array custom property. Arrays support float, integer, and boolean storage, fixed sizes up to 32, vector/color style display, component labels, component-based dynamic labels, and component-based child conditions.

Text

Creates non-property generated content such as headings, labels, dividers, and spacing rows. Text entries can use style controls and Dynamic Text rules.

Custom

Draws an existing Blender RNA or custom-property path instead of creating a managed property. Custom entries are for full data paths such as a property on an object, modifier, material, constraint, node tree, or other Blender data owner.

Custom can sense and draw these value kinds:

  • BOOL: native boolean or boolean custom property.
  • INT: native integer or integer custom property.
  • FLOAT: native float or float custom property.
  • STRING: native string or string custom property.
  • ENUM: native Blender RNA enum property.
  • DATA_BLOCK: Blender ID pointer or data-block custom property.
  • POINTER: non-ID RNA pointer.
  • COLLECTION: RNA collection, drawn as a read-only collection summary.
  • VECTOR: numeric vector or float array without a color subtype.
  • COLOR: float array with a Blender color subtype.
  • INT_ARRAY: integer array.
  • BOOL_ARRAY: boolean array.
  • PYTHON: dictionary-like or nested IDProperty data that Blender stores as Python/IDProperty data.

Custom can use component indexing for VECTOR, COLOR, INT_ARRAY, and BOOL_ARRAY. Component indexing lets one Custom entry draw or compare one component of a multi-component value.

Native RNA pointer paths that point to Blender ID data-blocks draw like data-block pickers where Blender supports it. Non-ID pointers draw as pointer summaries. RNA collections draw as collection summaries because they are not normal editable scalar properties.

Custom paths are Blender data paths, not Python expressions. They must start with bpy. and use attribute access plus literal ["name"] or [index] lookups, such as:

bpy.data.objects["Cube"].parent
bpy.data.objects["Cube"].modifiers
bpy.data.objects["Cube"]["custom_vector"][2]

Method calls, operators, math, conditionals, and arbitrary Python are not Custom paths. Put operator behavior in Operator Button entries or other Blender tools.

Operator Button

Creates a generated button that runs a Blender operator by operator id, including operators from enabled third-party add-ons.

Operator Button entries can:

  • Run an operator by id, such as wm.tool_set_by_id.
  • Pass operator properties as JSON.
  • Use execute, invoke, or popup-style behavior depending on the selected run mode.
  • Show an optional Blender report after the button runs.
  • Use context options for operators that need a particular Blender context.

Operator buttons depend on Blender operator polling. If Blender says the operator cannot run in the generated panel's current context, the button may cancel or fail.

Draws another entry again in the generated layout. A Display Link does not duplicate storage; it redraws the same underlying property or UI.

Display Links are useful when one generated panel needs the same control in more than one place, or when a shared property should appear with a different label, tooltip, label layout, dynamic label behavior, or condition behavior in the generated layout.

Display Links can target managed property entries and Custom entries. They do not create a new custom property and they do not copy the linked entry's stored value.

String

Creates a managed string custom property. String entries use Blender's normal property drawing and support normal label layout, exact-match dynamic labels, and child visibility checks.

Data-Block

Creates a managed data-block custom property slot. Data-Block entries use a chosen ID type and draw with Blender's data-block picker behavior. Empty defaults create an empty typed slot.

The ID Type controls what kind of Blender data-block the generated property accepts, such as Object, Material, Mesh, Image, Text, Action, Collection, Node Tree, World, and other supported Blender ID types. The optional default picker can point at an existing data-block of that type; leaving it empty creates a None value until the user picks one.

Python

Creates or edits literal IDProperty values that Blender's normal custom-property UI cannot fully describe, such as dictionary-like IDProperty groups. Python entries use an edit popup for literal values.

Python-value editing evaluates the text you enter as a Python literal and asks Blender to store the result as an IDProperty. Only enter values you trust and understand.

Dynamic Labels

Dynamic Labels change an entry label based on values.

For one entry, the dynamic-label rows act as a priority list: the first matching row wins. This rule is consistent across value kinds, exact matches, thresholds, ranges, boolean states, and labels driven by another entry.

Numeric dynamic-label tools can sort threshold rows for convenience, but runtime behavior still follows the visible list order.

Dynamic Labels can be driven by:

  • The entry's own value.
  • Another supported entry, when using Dynamic Labels by Other Entry.
  • A whole vector/array value for exact matches.
  • A single vector/array component when one-component matching is enabled.

Common rule styles:

  • Boolean state labels.
  • Exact value labels for strings, enums, colors, vectors, integer arrays, and boolean arrays.
  • Numeric threshold labels such as at least, at most, equals, and range.
  • Dynamic Text rows for Text entries.

If two rows match at the same time, the row higher in the Dynamic Labels list wins. Reorder rows when you want one matching rule to take priority over another.

Conditions

Child entries can react to their parent entry.

  • Child Visibility controls whether a child appears.
  • Child Availability controls whether a child stays visible but disabled.
  • Matching can be based on booleans, numeric thresholds, ranges, exact values, array components, and supported parent value kinds.
  • Hidden children in shared rows can either repack the row or keep an empty slot.

Conditions inherit through entry hierarchy where configured. Entry hierarchy depth is capped at 12.

Conditions use the parent entry as the watched value. A child entry can be shown, hidden, enabled, or disabled based on that parent's current value in the generated UI.

Supported parent-style checks include:

  • Boolean: always, true, or false.
  • Numeric: always, equals, at least, at most, or range.
  • Exact match: string, enum, color/vector arrays, integer arrays, and boolean arrays.
  • Component checks: one component of vector/color/int-array/bool-array parents.

Child Visibility removes or hides the child from the generated layout. Child Availability keeps the child visible but draws it disabled. In shared rows, hidden children can either let the row fill/repack or keep an empty slot so the row spacing stays stable.

Generated Layout

Generated Layout is the layout editor for the generated panel.

You can:

  • Import Entry List entries into the generated layout.
  • Reorder generated rows.
  • Group entries into shared rows.
  • Create generated sub-panels.
  • Move rows between the main panel body and sub-panels.
  • Add spacing rows.
  • Use row height, row alignment, column weight, and row inset controls.
  • Wrap contiguous rows in Row Boxes.

Shared rows let multiple entries draw on one generated row. The row can auto-fill available space, use custom column weights, align single-row content, and preserve or repack space when conditional children disappear.

Sub-panels become generated child panels. Rows can belong to the main panel body or to a sub-panel. Empty sub-panels remain in the editor but are skipped in generated output.

Row Boxes draw generated rows inside Blender layout.box() containers. Row Boxes are scoped to one container and can nest only as fully contained ranges; partial overlaps are rejected.

Generated Layout selection is separate from Entry List selection. Selecting a layout row edits row/layout settings. Selecting an Entry List item edits the original entry settings.

Editor Settings

Editor Settings control how the PropUI editor behaves.

Display and entry-list settings include editor float precision, dynamic-label uniqueness precision, tree hints, primary Entry List display, and default add type.

Confirmations control prompt defaults for generation conflicts, native property conflicts, empty layout generation, generated UI removal, hierarchy deletion, setup reset, type defaults, copy operations, row boxes, variants, editor layout, and factory reset.

Import/export tools support:

  • Current setup JSON.
  • Setup bundles with optional generated UI scripts.
  • Editor Settings JSON.
  • Entry preset JSON for selected entries.

Current setup JSON stores the generated-output setup, Entry List, Generated Layout, sub-panels, row boxes, storage, visibility, and generation settings. It does not store Editor Settings or Editor Layout.

Editor Settings JSON stores editor behavior, Editor Layout, and editor section open/collapsed defaults. It does not store Entry List entries or generated panels.

Entry preset JSON stores compatible settings for one selected entry type. It is useful for reusing a style or value setup without importing a full panel setup.

Saved defaults support:

  • Editor Settings and Editor Layout defaults.
  • Full setup defaults for new blank PropUI setups.
  • Entry type defaults.

Editor Settings defaults apply to future editor sessions. Full setup defaults apply to new blank PropUI setups. Entry type defaults apply when adding or resetting entries of that type.

Reset tools can reset the current setup, editor settings, saved defaults, or everything with Full Factory Reset.

Editor Layout

Editor Layout lets you reorder and hide PropUI editor sections and subsections without deleting setup data. Changes are staged in a list first, then applied with Apply List State.

Editor Layout defaults can save the section order, visibility, and open/collapsed defaults for future sessions.

Add-on Preferences

PropUI preferences live in Blender's add-on preferences.

Preferences include editor location, diagnostics, keyboard shortcut controls, transform/playback draw skips, and the GPL license notice.

Verbose Console Diagnostics prints additional recovery diagnostics and tracebacks to Blender's system console.

Keyboard Shortcuts

Keyboard shortcuts are optional and can be disabled in add-on preferences.

The active shortcut target is chosen by clicking a PropUI list, pressing Shortcuts Affect This List, or using the shortcut target controls. Targets include Entry List, Generated Layout, UI Variants, Generated UIs, Row Boxes, Visible When Items, Choices, Dynamic Labels, Display Link component subsets, and Editor Layout.

Default shortcuts include Generate, add, remove, duplicate, move up/down, hide/show, collapse, parent/group, outdent/ungroup, and variant save/load actions.

Shortcut actions follow the active target. For example, move up/down affects Entry List entries when Entry List is the target, Generated Layout rows when Generated Layout is the target, and Editor Layout rows when Editor Layout is the target.

Shortcuts only run when PropUI shortcuts are enabled and the current Blender area is one where the PropUI editor is allowed to live.

Cleanup Tools

Clean Property Storage can remove managed, unmanaged, or all custom properties from the current Property Storage target.

Clean Override Targets applies the same cleanup modes to entry-specific target override owners.

Cleanup tools affect Blender custom properties on storage owners. They do not delete Entry List entries, Generated Layout rows, UI Variants, or generated scripts.

Important Notes

  • Property IDs must be unique per target. PropUI auto-suffixes duplicates where needed.
  • If Property Storage or a Target Override cannot resolve, Apply/Generate reports an error.
  • Array size is capped at 32.
  • Generated Layout sub-panels draw as Blender child panels.
  • Row Boxes cannot span multiple containers.
  • Hidden-in-editor entries are hidden only in the editor; generated output is controlled by Generated Layout and conditions.
  • Generated panels are saved in the .blend as generated Text datablocks and slot data.
  • Export generated .py files if you need standalone scripts outside the .blend.
  • Stopping a generated UI is session-scoped unless you remove its saved data.
  • Imported generated UI scripts become managed Generated UI rows.
  • Setup JSON import from Editor Settings creates a UI Variant; loading that variant applies the imported setup.

Troubleshooting

No generated panel appears:

  • Check that the generated UI is running in Generated UIs.
  • Check Visibility settings and selected object/bone filters.
  • Check the generated sidebar or Properties location.
  • Check Diagnostics for missing script or registration errors.

Generate reports missing storage:

  • Set Output Setup > Property Storage.
  • Use Set Active, Set Selected, or the relevant picker.
  • Confirm the Resolved label shows a valid owner.

An entry does not appear in generated output:

  • Make sure it is in Generated Layout.
  • Check parent-child conditions.
  • Check that the Display Link target still exists.
  • Check whether a sub-panel is empty and skipped.

Shortcuts affect the wrong list:

  • Click Shortcuts Affect This List above the intended list.
  • Use the shortcut target controls.
  • Check Add-on Preferences > Disable Keyboard Shortcuts.

A Custom path shows errors:

  • Paste a valid Blender RNA or custom-property path.
  • Check for renamed or deleted data-blocks.
  • Start full paths with bpy..
  • Use attribute access and literal ["name"] / [index] lookups.
  • Avoid method calls, operators, math, and arbitrary Python expressions.
  • Use a path that resolves to a supported sensed kind such as bool, int, float, string, enum, data-block, pointer, collection, vector, color, int array, bool array, or Python/IDProperty data.

An Operator Button fails:

  • Verify the operator id.
  • Try Interactive or Popup mode for operators that require invoke behavior.
  • Check operator JSON.
  • Confirm the operator can run in the generated panel's current context.

A generated UI script is missing:

  • Use Generated UIs status to identify missing Text scripts.
  • Regenerate the UI, import an existing generated script, or remove the row if it is no longer wanted.