Astro Scale

Quick setup

Astro Scale is designed to work directly inside Roblox Studio.

1. Install and enable the plugin

Install Astro Scale through Roblox Creator Store when the public listing is available, then make sure the plugin is enabled in Studio.

The Astro Scale toolbar contains:

Open | Scale | Offset | Text Scale | Constraint | Perfect Scale | Settings

Use Open to show the narrow Astro Scale DockWidget.

2. Start with a test UI

Before using Astro Scale on an important interface, duplicate the UI or create a Studio version checkpoint.

A simple first test is:

1. Select a Frame that currently uses Offset values.
2. Press Scale under Size.
3. Press Scale under Position.
4. Resize the Studio viewport or use Device Emulator.
5. Use Studio Undo if you want to revert the conversion.

3. Choose whether children are included

The Other section contains Include Children.

• ON processes the selected UI object and supported nested descendants.
• OFF limits normal Scale and Offset operations to directly selected UI objects.

Perfect Scale is different. It is intentionally recursive and expects a completed ScreenGui.

4. Use Perfect Scale only after the UI is built

The recommended Perfect Scale workflow is:

1. Build the UI normally.
2. Finish its layout and visual positioning.
3. Select the completed ScreenGui.
4. Press Perfect Scale.
5. Review the result in multiple resolutions.
6. Keep the result or use Undo to return to the previous state.

Do not treat Perfect Scale as a replacement for testing.

System overview

Astro Scale is a Roblox Studio UI conversion and responsiveness plugin. It focuses on four workflows:

• Manual conversion: explicitly convert Size, Position and supported UI components between Scale and Offset.
• Axis conversion: convert only X or Y while preserving the other axis.
• Automatic modes: keep selected UI in a chosen Size or Position mode while continuing to work.
• Perfect Scale: run a conservative final responsiveness pass over a completed ScreenGui.

Astro Scale edits Studio instances directly. It does not add a runtime dependency that must remain active in the live experience.

Main interface

The DockWidget is divided into compact cards:

SIZE
  Scale | Offset
    X Y | X Y
  Auto | Scale | Off | Offset

POSITION
  Scale | Offset
    X Y | X Y
  Auto | Scale | Off | Offset

ALIGNMENT
  Left | H Center | Right | Top | V Center | Bottom

OTHER
  Include Children
  Auto Anchor
  Center AnchorPoints
  Add Aspect Ratio
  Scale Text

The controls use fixed dimensions so the plugin remains compact instead of stretching every button with the dock width.

Before you use it

Astro Scale modifies UI properties in the currently edited place. Use normal Studio development safeguards before large conversions.

Recommended safeguards

1. Save the place.
2. Create a version-control or Studio history checkpoint.
3. Duplicate particularly important UI before experimenting.
4. Test manual tools on a smaller selection first.
5. Use Perfect Scale only after the main layout is complete.
6. Test the final UI at the resolutions and aspect ratios the experience actually supports.

What Astro Scale considers responsive

Astro Scale primarily converts Roblox UDim and UDim2 values from pixel Offset components into proportional Scale components.

For a UDim2 X component, the conversion is equivalent to:

newScale = currentScale + currentOffset / parentAbsoluteWidth
newOffset = 0

For Y, the same calculation uses the parent absolute height.

Converting back to Offset performs the inverse operation using the current parent absolute size.

Because conversion depends on current absolute dimensions, run large conversions at a representative Studio viewport size.

Toolbar

Astro Scale creates these toolbar buttons in order:

Toolbar clicks preserve the current Studio selection so moving focus to the plugin toolbar does not intentionally clear the UI object being worked on.

Open button

If the DockWidget is closed or hidden, press Open.

Astro Scale defaults to:

Enum.InitialDockState.Right

Studio may remember the user’s later docking choice. If the developer manually moves or redocks the plugin, normal DockWidget behavior takes priority.

Size and position

Size

The Size controls operate on GuiObject.Size.

Press Scale to convert Offset components into Scale while preserving the object’s current rendered size as closely as possible.

Press Offset to convert Scale components back into Offset values using the current parent dimensions.

Supported GuiObject subclasses include common UI classes such as:

• Frame
• TextLabel
• TextButton
• TextBox
• ImageLabel
• ImageButton
• ScrollingFrame
• ViewportFrame
• other classes derived from GuiObject

When Size conversion is used with Include Children ON, supported descendants and UI modifiers are processed as part of the same selection workflow.

Position

The Position controls operate on GuiObject.Position.

Scale conversion turns the current visible placement into proportional X and Y values. Offset conversion resolves proportional values back into pixels for the current parent size.

Astro Scale skips a conversion when the relevant property is already in the requested mode.

Layout-owned values

Some UI is controlled by Roblox layout objects rather than by the child’s normal Position.

Astro Scale avoids pretending that a layout-controlled Position is authoritative when objects are arranged by layouts such as UIListLayout or UIGridLayout.

Perfect Scale is especially conservative around layout-owned values.

X and Y conversion

Each Scale and Offset control has smaller X and Y buttons underneath it.

• X is shown in green.
• Y is shown in orange.

Size X

Only Size.X is converted.

Size.Y remains unchanged.

Size Y

Only Size.Y is converted.

Size.X remains unchanged.

Position X

Only Position.X is converted.

Position.Y remains unchanged.

Position Y

Only Position.Y is converted.

Position.X remains unchanged.

Axis conversion is useful when an interface intentionally mixes strategies, for example:

• responsive horizontal width with a fixed-height row
• centered horizontal placement with fixed vertical spacing
• mobile layouts that need only one proportional axis

For supported component values such as UIPadding and UIGridLayout, axis-specific tools affect only the properties or UDim2 components that correspond to the chosen axis where such a distinction exists.

Scalar properties such as UICorner.CornerRadius and UIStroke.Thickness do not have independent X and Y components, so the axis buttons do not invent a horizontal or vertical version of those values.

Automatic modes

Size and Position each have an Auto row:

Auto | Scale | Off | Offset

Auto Size

• Scale: automatically keeps eligible Size/component values in Scale.
• Off: disables Auto Size.
• Offset: automatically keeps eligible Size/component values in Offset.

Auto Position

• Scale: automatically keeps eligible Position values in Scale.
• Off: disables Auto Position.
• Offset: automatically keeps eligible Position values in Offset.

Auto modes use the current Studio selection context. They are not intended to indiscriminately rewrite unrelated UI elsewhere in the place.

Persistent state

Auto mode choices are saved through Studio plugin settings.

If Auto Size was left on Scale when Studio was closed, Astro Scale can restore that mode the next time the plugin loads.

The same persistence applies to Auto Position and other saved settings.

Perfect Scale metadata

Perfect Scale records state attributes on the UI it processes. Auto Scale checks those attributes so values that Perfect Scale intentionally marked as layout-managed or already handled are not repeatedly forced through the same operation.

Include children

The Include Children switch controls whether standard conversions operate recursively.

ON

The selected object plus supported nested descendants are included.

Example:

Frame
|-- UIStroke
|-- UIPadding
|-- TextLabel
|   `-- UICorner
`-- ImageButton

Selecting the Frame with Include Children ON allows supported values under the hierarchy to be processed.

OFF

Only directly selected objects are used by normal Scale or Offset operations.

A UIStroke nested under a selected Frame will not be included merely because it exists under the Frame.

Perfect Scale exception

Perfect Scale is intentionally recursive.

When a completed ScreenGui is selected and Perfect Scale runs, the hierarchy underneath that ScreenGui is reviewed regardless of the normal Include Children switch.

Alignment

The Alignment card contains six image-only Figma-style controls:

• Align Left
• Horizontal Center
• Align Right
• Align Top
• Vertical Center
• Align Bottom

Hover an icon to see its tooltip.

Alignment behavior

Alignment moves the visible bounds of the selected GuiObject relative to its parent.

It does not change:

• AnchorPoint
• Size
• Rotation
• constraints
• unrelated properties

The current AnchorPoint is included in the positioning calculation.

Horizontal Center

Horizontal Center places the visual center of the selected UI in the horizontal center of the parent.

Vertical Center

Vertical Center places the visual center in the vertical center of the parent.

Use both center controls to center the element in both axes.

Edge alignment

Left, Right, Top and Bottom place the visible element bounds against the corresponding parent edge while preserving the object’s existing AnchorPoint.

Selection behavior

Alignment controls preserve the Studio selection before and after the click.

If focus moves to the plugin control, Astro Scale restores the UI object selection rather than replacing it with the plugin button.

Layout-controlled objects

If a parent layout controls the selected object’s position, direct alignment may be skipped because manually writing Position would conflict with the layout system.

Reclass

The Reclass card changes selected UI objects to another supported Roblox UI class while preserving compatible properties where possible.

1. Select one or more UI objects in Studio.
2. Type the target class name in the Reclass field.
3. Use the autocomplete suggestion to confirm the supported class.
4. Press Enter to reclass the selection.

Astro Scale reports skipped objects when a requested change cannot be applied safely. Review the selection after reclassing and use Studio Undo if the result is not what you intended.

Anchor points

Astro Scale provides two AnchorPoint workflows.

Center AnchorPoints

The manual Center AnchorPoints utility sets:

Vector2.new(0.5, 0.5)

The Position is compensated so the object stays visually in the same location.

This means changing AnchorPoint does not intentionally make the UI jump across the screen.

Auto Anchor

Auto Anchor automatically applies the same center-anchor behavior to eligible UI encountered by the auto workflow.

It respects the Include Children selection strategy where applicable.

Perfect Scale smart anchors

Perfect Scale uses a more conservative smart-anchor pass.

Instead of blindly changing every element to the same anchor, it evaluates the current placement and can choose left/center/right and top/center/bottom style anchors where that better represents the finished layout.

Visual position is compensated before later position conversion.

Supported components

Astro Scale supports more than normal Frames.

GuiObject

Supported properties:

Size
Position

This includes common descendants such as Frames, labels, buttons, text boxes, images and scrolling frames.

UICorner

Supported property:

CornerRadius

Offset corner radii can be converted using the relevant absolute size of the owning UI.

UIPadding

Supported properties:

PaddingTop
PaddingBottom
PaddingLeft
PaddingRight

Left and Right use horizontal parent size.

Top and Bottom use vertical parent size.

UIGridLayout

Supported properties:

CellSize
CellPadding

Both values are UDim2 and can be converted between Scale and Offset.

UIListLayout

Supported property:

Padding

The active layout direction determines the relevant axis.

UIPageLayout

Perfect Scale and supported layout-padding workflows can handle the exposed layout Padding where appropriate.

UIStroke

Astro Scale supports fixed/scaled stroke sizing where Roblox exposes StrokeSizingMode.

A fixed pixel thickness can be converted into scaled sizing relative to the owning UI dimensions.

Supported related values may include BorderOffset when available.

ScrollingFrame

Astro Scale can convert:

Size
Position
CanvasSize

CanvasSize conversion is used only when manual canvas sizing is controlling the scrolling area.

If AutomaticCanvasSize is active, Perfect Scale leaves the manually stored CanvasSize alone because Roblox is already managing the effective canvas.

UISizeConstraint

MinSize and MaxSize are Vector2 pixel values.

Roblox does not expose Scale components for these properties, so Astro Scale recognizes and preserves them rather than pretending they can be converted into UDim Scale values.

UITextSizeConstraint

MinTextSize and MaxTextSize are numeric text-size limits.

They remain pixel/text-size limits because Roblox does not expose Scale components for them.

Text scaling

The manual Scale Text utility is intended when the developer explicitly wants a selected text hierarchy to use responsive text.

For each eligible:

• TextLabel
• TextButton
• TextBox

Scale Text captures the current TextSize, enables:

TextScaled = true

and finds or creates a UITextSizeConstraint.

The current text size becomes the maximum size so enabling TextScaled does not allow the text to grow beyond the developer’s current design target.

Perfect Scale text behavior

Perfect Scale is intentionally more conservative than the manual Scale Text button.

If a text object already has:

TextScaled = true

Perfect Scale leaves that text scaling setup alone.

It does not automatically add UITextSizeConstraint to every text instance.

Existing constraints

If a valid UITextSizeConstraint already exists, Perfect Scale preserves it rather than deleting and replacing it.

TextBoxes

Single-line TextBoxes may receive responsive text handling when their finished layout suggests it is needed.

Multiline TextBoxes are treated more conservatively because aggressively scaling user-entered long text can make input unexpectedly tiny.

Always test editable text with:

• short values
• long values
• empty text
• placeholder text
• the largest input your experience permits

Aspect ratio

Manual Add Aspect Ratio

The Add Aspect Ratio utility captures the current visual ratio of selected eligible UI and adds a UIAspectRatioConstraint when one does not already exist.

Existing aspect constraints are preserved.

Perfect Scale behavior

Perfect Scale does not add aspect constraints to every descendant.

New Perfect Scale constraints are limited to eligible GuiObject instances that are direct children of the selected ScreenGui.

Example:

ScreenGui
|-- MainFrame                <- eligible for a new Perfect Scale constraint
|   |-- Header               <- no new Perfect Scale constraint
|   `-- Content              <- no new Perfect Scale constraint
`-- Popup                    <- eligible for a new Perfect Scale constraint

This avoids filling flexible nested layouts with constraints that can fight one another.

Why the rule is conservative

The top-level child is often the main visual surface whose current shape needs to survive viewport changes.

Nested UI is more commonly controlled by layouts, padding, parent dimensions or intentional flexible sizing.

Perfect Scale

Perfect Scale is the main final-pass workflow.

Intended workflow

Do not start a new interface by immediately running Perfect Scale.

Instead:

1. Build the UI normally.
2. Finish the visual design.
3. Place objects where you want them.
4. Configure lists, grids, text and scrolling behavior.
5. Select the finished ScreenGui.
6. Press Perfect Scale.
7. Test the final interface across devices.

ScreenGui selection

Perfect Scale expects one or more directly selected ScreenGui instances.

Selecting an ordinary nested Frame is not the intended Perfect Scale entry point.

If no ScreenGui is selected, the operation is skipped and Studio Output receives a warning.

Recursive processing

Perfect Scale recursively reviews the descendants of the selected ScreenGui.

The normal Include Children setting does not limit this final pass.

Processing order

Perfect Scale broadly performs the following sequence:

1. Capture the current finished visual state.
2. Apply smart AnchorPoint corrections where enabled.
3. Convert eligible GuiObject.Size.
4. Convert supported UI components and layouts.
5. Convert manually controlled ScrollingFrame.CanvasSize.
6. Convert eligible GuiObject.Position.
7. Apply conservative text responsiveness where enabled.
8. Add top-level aspect constraints where enabled.
9. Stamp Astro Scale metadata attributes on the processed hierarchy.

Values already in Scale

If a value has no Offset component requiring cleanup, Perfect Scale leaves it alone.

For example:

UDim2.fromScale(0.5, 0.25)

does not need another Scale conversion.

Mixed values

A property such as:

UDim2.new(0.5, 20, 0, 40)

contains both Scale and Offset components.

Perfect Scale resolves eligible mixed values into equivalent Scale-only values using the current parent dimensions.

AutomaticSize

When AutomaticSize is actively controlling a UI object, Perfect Scale avoids treating that object’s stored Size as an ordinary manual dimension.

Layout ownership

Perfect Scale avoids forcing manual positions on children whose parent layout owns placement.

UIGridLayout-owned sizing is also treated carefully.

Perfect Scale settings

Settings include controls for Perfect Scale features such as:

• text scaling
• smart anchor behavior
• aspect-ratio constraints

Turn a Perfect Scale subsystem off when the finished interface intentionally uses a different strategy.

Settings and persistence

Press the toolbar Settings button to open the settings view.

Astro Scale saves supported settings using Studio’s plugin settings storage.

Persistent settings include

The current build can persist settings such as:

• Auto Size mode
• Auto Position mode
• Include Children
• Auto Anchor
• notification preference
• Perfect Scale text behavior
• Perfect Scale smart anchor behavior
• Perfect Scale constraint behavior
• visibility of Size controls
• visibility of Position controls
• visibility of Other controls
• visibility of Alignment
• visibility of X/Y axis buttons

Settings are restored when the plugin loads again.

Visibility selectors

Visibility settings only change what Astro Scale shows in its own DockWidget.

They do not remove or modify UI in the developer’s experience.

Leave a Review

The settings footer includes a Leave a Review action.

The published Astro Scale build should have its Creator Store asset/review destination configured before release.

Attributes

Astro Scale stores metadata on UI it modifies.

Branding attribute

UI changed by Astro Scale receives the string Attribute:

Name:  AstroScale
Value: By GoldAstro

The Attribute name does not contain a space because Roblox Attribute names cannot contain spaces.

Perfect Scale state attributes

Perfect Scale also records internal Astro Scale attributes used to identify the state of processed UI.

Examples include state for:

• Perfect Scale completion
• Perfect Scale version
• Size handling
• Position handling
• supported component handling
• canvas handling
• AnchorPoint state

These attributes help later automatic workflows avoid repeatedly processing UI that Perfect Scale intentionally marked as already handled or layout-managed.

Do not rely on metadata as runtime game logic

Astro Scale attributes are editor/development metadata.

Game systems should not require these attributes unless the developer deliberately chooses to integrate them.

Undo, redo and notifications

Undo and Redo

Astro Scale integrates with Studio change history.

Plugin operations are recorded so the developer can use normal Studio Undo and Redo.

Combined actions such as Perfect Scale are designed to behave as one logical change-history operation rather than requiring the developer to undo every descendant individually.

Before large changes, keeping an additional Studio checkpoint is still recommended.

Notifications

When Astro Scale changes a supported property, a compact notification appears in the lower-left Studio area.

Example:

Frame Size set to Scale
UIStroke Thickness set to Scale
UIPadding PaddingLeft set to Offset

Formatting uses:

• property/object portion in yellow
• Scale in blue
• Offset in red
• FredokaOne text
• black text stroke

Queue behavior

Notifications are queued so bulk conversions arrive as a wave instead of all appearing in the same frame.

The current adaptive queue uses approximately:

1-10 queued     0.14s
11-25 queued    0.09s
26+ queued      0.04s

0.04s is the fastest configured wave speed.

The visible stack is capped while remaining queued messages continue to appear over time.

Identical messages are not automatically collapsed because multiple different instances can legitimately produce the same text, such as ten separate UIStroke instances.

Recommended workflow

Building a new interface

A practical Astro Scale workflow is:

1. Design the UI normally.
2. Use Offset values while fast iteration is easier.
3. Finish layout structure and visual spacing.
4. Use manual Scale tools on individual areas that are ready.
5. Use X/Y controls for intentionally mixed-axis designs.
6. Configure Auto modes if you want new edits normalized automatically.
7. Finish the complete ScreenGui.
8. Disable or review unusual custom runtime sizing scripts.
9. Run Perfect Scale.
10. Test in Device Emulator and real target resolutions.
11. Adjust intentional exceptions manually.
12. Ship only after the interface passes the testing checklist.

Existing UI

For an existing interface:

1. Duplicate it first.
2. Select a small parent Frame.
3. Test Include Children ON with manual Scale.
4. Verify corners, padding, strokes, grid cells and scrolling.
5. Undo if the result exposes an intentionally fixed dimension.
6. Once the conversion strategy is understood, run Perfect Scale on a duplicate completed ScreenGui.

Testing checklist

Basic sizing

• Main containers preserve their intended visual size immediately after conversion.
• Width responds correctly when viewport width changes.
• Height responds correctly when viewport height changes.
• Intentionally fixed-height or fixed-width areas still behave as designed.
• Mixed Scale/Offset values are not left accidentally where full Scale was intended.

Positioning

• Centered objects remain centered.
• Left-aligned objects remain against the intended edge.
• Right-aligned objects remain against the intended edge.
• AnchorPoint changes do not visually jump.
• Layout-controlled children remain under layout control.

Components

• UIPadding produces the expected spacing at multiple resolutions.
• UICorner maintains an acceptable visual radius.
• UIStroke remains visually proportional when using scaled sizing.
• Grid CellSize and CellPadding remain readable.
• List/page padding remains appropriate.
• ScrollingFrame content still reaches the expected end of the canvas.

Text

• Existing TextScaled objects still behave correctly.
• Newly responsive text does not exceed the intended maximum.
• Text does not shrink below a readable minimum.
• TextButtons remain legible.
• TextBoxes remain usable with long user input.
• Multiline input still wraps and edits correctly.

Constraints

• Perfect Scale constraints exist only where intended.
• Nested flexible UI is not unexpectedly locked to an aspect ratio.
• Existing constraints continue to behave correctly.
• UISizeConstraint pixel limits still make sense at target resolutions.

Devices

Test at minimum:

• a desktop 16:9 viewport
• a narrower desktop/windowed viewport
• a phone portrait viewport
• a phone/tablet landscape viewport if supported
• any console/TV layout the experience targets

Troubleshooting

Perfect Scale says to select a ScreenGui

Perfect Scale is designed around a completed ScreenGui.

Select the ScreenGui instance itself in Explorer, not only one of its child Frames.

Auto Scale appears to do nothing after Perfect Scale

This may be correct.

Perfect Scale stamps metadata indicating that a value is already scaled or intentionally managed. Auto Scale skips work that would only repeat the same conversion.

Include Children OFF still changed a nested object during Perfect Scale

Perfect Scale is deliberately recursive and does not use Include Children as its boundary.

Include Children applies to the normal manual/automatic selection workflow.

Constraint affected more objects than expected

The manual Constraint utility uses the current selection and Include Children behavior.

Perfect Scale uses a stricter rule: new automatic aspect constraints are limited to direct GuiObject children of the selected ScreenGui.

Alignment button does not move an object

Check whether the selected object is positioned by a parent layout.

A UIListLayout, UIGridLayout or similar system may control the object’s placement, making a manual Position alignment inappropriate.

Clicking the toolbar cleared my selection

The current Astro Scale build preserves Studio selection around toolbar actions.

If this still occurs, confirm only one Astro Scale plugin build is installed/enabled and restart Studio after replacing the plugin package.

UIStroke looks different after scaling

Scaled stroke thickness is relative rather than a fixed pixel number.

That is intentional, but visual perception can still differ across very small and very large UI. Test strokes at the actual target resolutions.

ScrollingFrame scrollbar thickness did not scale

ScrollingFrame.ScrollBarThickness is a numeric pixel property.

Roblox does not expose a native Scale component for it, so Astro Scale does not fake one.

Scrollbar thumb length changed

The thumb/grabber length is influenced by the viewport-to-canvas relationship.

Changing CanvasSize responsively can therefore change the thumb length, which is expected.

Text became too small

Review the UITextSizeConstraint.MinTextSize and the available TextLabel/TextBox bounds.

For a specialized text object, it may be better to keep its existing text behavior and disable Perfect Scale text handling for the final pass.

UI changed twice

Check:

• only one Astro Scale build is enabled
• Auto Size/Position are in the expected mode
• the object has current Astro Scale metadata
• the UI is not also being rewritten by another Studio plugin or custom runtime script

Limitations

Astro Scale only converts properties that Roblox actually exposes.

Pixel-only constraint values

These remain pixel/numeric values:

UISizeConstraint.MinSize
UISizeConstraint.MaxSize
UITextSizeConstraint.MinTextSize
UITextSizeConstraint.MaxTextSize
ScrollingFrame.ScrollBarThickness

They do not have native UDim Scale components.

Runtime layout scripts

A LocalScript or runtime controller can overwrite the Studio values after the game starts.

Astro Scale cannot guarantee responsiveness if another script continuously rewrites Size, Position or related properties.

Automatic layouts

Roblox layouts intentionally own some child placement and sizing.

Astro Scale avoids fighting those systems where it can detect layout ownership.

Perfect Scale is conservative

Perfect Scale is a final cleanup tool, not an automatic redesign engine.

It cannot infer every artistic or gameplay-specific intention from property values alone.

Always review the result.

Scope and expectations

Astro Scale 1.1.0 is a Roblox Studio development plugin for responsive UI conversion and final interface cleanup.

Added in version 1.1.0

• Renamed Scale Pro to Astro Scale.
• Added the Reclass workflow for selected UI objects.
• Fixed bugs and improved overall stability.

Included in version 1.0.0

• Manual Size Scale/Offset conversion.
• Manual Position Scale/Offset conversion.
• X-only and Y-only conversion.
• Auto Size and Auto Position modes.
• Include Children selection control.
• Figma-style alignment controls.
• Auto Anchor and Center AnchorPoints.
• UIPadding, UICorner, UIStroke, UIGridLayout and supported layout padding conversion.
• ScrollingFrame CanvasSize conversion where appropriate.
• Scale Text and conservative Perfect Scale text handling.
• Manual aspect-ratio constraints.
• Perfect Scale recursive ScreenGui cleanup.
• Direct-ScreenGui-child Perfect Scale aspect constraints.
• Astro Scale metadata attributes.
• Persistent plugin settings.
• Studio Undo and Redo integration.
• Adaptive conversion notifications.
• Toolbar actions and compact DockWidget workflow.

Not promised by version 1.0.0

• Automatic redesign of a poorly structured interface.
• Guaranteed compatibility with every custom UI framework or runtime layout controller.
• Conversion of Roblox properties that have no Scale representation.
• A guarantee that every UI should use Scale for every property.
• Automatic replacement of developer testing across real resolutions.
• Runtime device detection or live-game UI framework code.
• Automatic repair of scripts that overwrite converted UI after Studio changes.

The developer remains responsible for deciding which interface dimensions should be flexible, which should stay intentionally fixed, and which target devices the final experience supports.

Review the complete UI in Studio after any large conversion and keep normal backups before publishing.