Grabbit 2.0 Changelog¶

Overview¶

Grabbit 2.0 is a ground-up rebuild of the physics-based 3D object placement tool for the Unity Editor: a reworked architecture, performance at scale, new modes and operations, and a redesigned scene-view overlay.

Modes and operations¶

The toolbar hosts five modes, each with its own colour drawn from the brand palette: Select (blue), Create (amber), Place (orange), Arrange (violet), Scatter (cyan). The active mode is tinted across the mode strip, the overlay headline, and the scene-view handles.

Mode	Operations
Select (choose what)	Volume (box / sphere / disc), On Screen, Current Selection
Create (spawn)	Drop, Throw, Box, Layout
Place (position)	Move (default), Box, Point (hold Space in Move or Box to drop under gravity)
Arrange (bring order)	Align (line / arc / circle / rectangle / grid / sphere), Level, Orient
Scatter (remove order)	Randomize, Explode, Cramp, Nudge

Switching operation or mode rebaselines the preserved formation (each object's offset and rotation relative to the selection centre) to where the objects sit right now, so an operation that preserves transforms never yanks them back to an older shape on entry.

Keyboard shortcuts¶

All keys live in the Shortcut Manager (Edit > Shortcuts > "Grabbit 2") and are rebindable.

Key	Action
U	Select mode (launches Grabbit if off)
I	Create mode
O	Place mode
P	Arrange mode
`[`	Scatter mode
Tab	Cycle the active mode (wraps)
6 - 0	Select the operation within a mode by position
A / `.`	Cycle operations forward / back
C	Cycle the Collisions mode (Normal / Ignore Each Other / Ignore Everything)
X	Cycle Handle Direction (Absolute / Ground / Camera)
Z	Cycle the Rotation mode (Maintain Initial / Keep Upright / Free)
Ctrl/Cmd + D	Smart Duplicate: duplicate the selection and step the copies clear of the originals
Shift + scroll	Resize the current operation's handle, about 10% per notch, in every mode
Space	Primary action (hold or press, per operation)

Mode keys are global (they launch Grabbit and switch mode); Tab, the operation keys and Space are active-only so they never hijack those keys when Grabbit is off. Operation keys sit on 6 to 0 rather than 1 to 5 because the Scene View context already claims the low row (2 is Toggle 2D Mode). Show Help (bottom-right of the overlay) reveals each key inline, read live from the Shortcut Manager so labels stay correct after rebinding.

Space behaviour per operation: - Hold (Point, Grab, Box, Align, Cramp, Orient): runs while Space is held, freezes on release. - Press (Level, Randomize, Explode, Nudge, spawn): tap to apply once; hold to keep re-applying. - Move and Box hold to let the selection fall and settle under gravity (the handle / box does the positioning). - Select ops are all Press, and never run the simulation, so refining a selection never moves anything.

Select mode¶

Select refines what is selected before the other modes act on it, in three parts and without ever running the simulation:

Zone (the operation): Volume (a draggable Box / Sphere / Circle handle), On Screen (everything in the camera frustum), or Current Selection. An object counts as inside when its bounds overlap the zone, or by pivot point with Pivot Only.
Filters (all AND together): Same Model (same prefab, mesh, or either), Similar Size (within a tolerance), Similar Shape (same proportions at any size, orientation-independent), Same Resting Level (undersides aligned, optionally over the same surface). Compare To picks the reference: any selected, the active object, or prefab assets picked in the Project window. With Move Sub-Objects Independently on, the filters compare each mesh on its own instead of the whole prop, so the size / shape reference is the piece you picked.
Combine: Replace, Add, Subtract, Intersect. Candidates come from the warm scene cache and respect the same layer / tag / lock / size exclusions as normal selection.

Create mode¶

Source is selectable: Collection (weighted picks from an Asset Collection, with a Random / Ordered field) or Duplicate (copies of selected scene objects or project prefab assets; prefabs spawn as connected instances). Switching to Create with a selection drops straight into Duplicate.
Spawn modes: Drop spawns a batch under the cursor (preview disc you aim with the mouse); Throw launches from the camera toward the cursor's world point with just enough force to land on it, tuned by a Throw Strength multiplier; Box fills a draggable volume. The per-mode Spawn button is gone, Space is the only commit path.
Spread Radius scatters the batch around the aimed point (Drop and Throw), measured relative to the objects' own size: 0 aims them all at one spot, 10 spreads them across about 120 times their bounding box, on a curve that stays fine-grained at the low end. Shift + scroll adjusts it without leaving the Scene view. Random rotation is a per-axis two-way (Min to Max) slider over 0 to 360 degrees. Spawned objects keep their source rotation.
Settle runs for a bounded window, After Time (default 1s) or When At Rest (each body's real physics sleep state, with a safety ceiling). Holding Space keeps it settling. Spawning a new batch no longer freezes an earlier one mid-fall, and merely selecting a scene object in Create no longer turns it into a physics body. Freeze Settled (off by default) freezes each object the moment it comes to rest, so a later batch settles around it instead of shoving it.
Layout arrays copies of the selection along a Line, Spline, Radial ring or Volume box, previewed live as you drag the handles. The Line and Spline end handles follow the shared Handle Direction setting: Ground (default) rides a scene raycast under the cursor so the path draws straight onto the scene (over empty space it holds the grab height), Absolute turns them into free transform gizmos that move anywhere in space, and Camera drapes the whole line straight down onto the ground so copies follow the terrain. A tap places the copies; holding Space lets them fall and settle.
Layout ▸ Keep Upright places each ghost copy upright (flattening the source rotation on the shared Upright Axes, default pitch + roll keeping heading) instead of copying the source object's rotation; the existing Rotation randomizer layers on top of whichever base. It sets only the placed pose, so dropped copies are still free to tip as they settle.

Place mode¶

Box (default) shows the selection's union box with draggable faces; dragging a face spreads the objects (each keeps its fractional spot) and physics depenetrates overlaps. Holding Space (no face grabbed) drops the selection under gravity, so Box doubles as a settle pass. Replaced the old Bounding Box toggle on Move. Teleport When Too Far (on by default) snaps any object straight to its spot in the box once its own distance to that spot passes the Too Far Distance, instead of grinding it through whatever is in the way; each object is judged by its own distance, so far ones jump while near ones keep sliding in (the distance is shared with Move's Too Far Distance).
Move is a free drag with move, rotation and scale handles (pull a cube outward to spread the group along an axis, inward to gather). Turning the rotation handle takes priority over position, so a blocked body shoves over to complete the turn. Holding Space drops the selection under gravity.
Point follows the cursor onto surfaces (the old Point / Modify mode), resting objects on the surface they point at. Smooth transition optional. Its Rotation picker drives the seeded orientation (Maintain Initial), stands objects upright (Keep Upright), or leaves rotation untouched so they tumble naturally as they land (Free).
The standalone Drop op was retired from the toolbar: holding Space in Move or Box already drops the selection under gravity. Its gravity settle remains available headlessly (the MCP bridge / headless runner still expose a Place "drop" op to settle a selection under gravity), and its tuning lives in Project Settings ▸ Grabbit ▸ Place \ Gravity.
Grab picks an object up by the exact spot under the cursor (like grabbing a chair by one leg) and glues that spot to the cursor while Space is held. Like Point, it offers Teleport When Too Far: pull the grabbed spot far past an obstacle and the object jumps straight to the cursor instead of grinding against what's in the way (shared with Point's setting).

Move follow controls were respecified for legibility: Follow Speed (top travel speed, surfaced from Advanced) and one Softness knob that handles the whole "how delicately do I set things down" axis. Softness eases velocity into a surface and raises damping (so objects settle instead of buzzing), gentles overlap separation, and softens the follow trail. Sliding along or pulling away from a surface keeps full speed, so contact never feels sticky. The separate Smoothing, Speed Near Obstacles, Anti-Jitter and Collision Damping sliders were all folded into Softness.

When Too Far (Move) picks what happens when you drag far from the handle: Teleport (default), Pass Through (collisions off, glide through geometry), or Do Nothing (keep following, blocked by whatever is in the way). The Too Far Distance is a multiple of the selection's bounding box.

Rotation is now a single behaviour picker on the driven rotation ops (Place ▸ Move / Point and Arrange ▸ Align), replacing the old Free Rotation toggle: Maintain Initial (default) turns objects with the full on-screen rotation handle and otherwise keeps their rotation; Keep Upright stands them up, flattening the rotation target (a Flatten X / Y / Z row picks which axes to zero, default pitch + roll, keeping heading) while showing a heading disc so you can still aim their yaw; Free leaves rotation untouched and hides the handle. The mode drives the rotation handle: the full ring set for Maintain Initial, a single heading disc for Keep Upright (hidden if you also flatten Y), nothing for Free. Arrange ▸ Orient does not use this (it has its own Mode, below); Level keeps its own Stand Upright toggle; all upright paths still share one definition of "upright". (Scatter ▸ Randomize's rotation shuffle is now its own Randomize Rotation toggle, no longer piggybacking on Free Rotation.)

Arrange mode¶

Align is a line tool: it fits a line through the selection with a draggable handle at each end, collapsing each object onto the line while preserving order and spacing. Even Spacing distributes evenly; Shape picks Line, Arc, or Circle. Arc is a cubic Bezier with draggable tangent control points; Circle has an orientable up axis. Line ends drop onto the scene surface seen behind them so they land where they are easy to grab, and the Line / Arc handles (endpoints and Arc tangents) are surface-drag controls like Create's Layout handles: click one and it rides the scene surface under the cursor until released, so the shape is laid straight onto the floor or a table. The Circle's diameter ends keep the free 3-axis gizmo (the ring usually stands tilted off the ground).
Level lines a chosen bounding-box side of every object onto a movable, tiltable plane (Side dropdown picks which face). The plane can be moved and tilted to level onto any height or slope. Rotate Upright additionally stands objects up by flattening the chosen rotation axes; Match Plane Tilt makes them lie flush on a slope.
Orient (was Rotate) sets the selection's orientation and has its own Mode (independent of the Move/Align Rotation control). Axis Align (default) points chosen object axes at a draggable target frame: each object axis has an aim arrow (Ctrl snaps to a world axis) and a roll disc, and an Align Axes row picks which axes follow the frame. One axis points just that axis, keeping each object's own twist (so the default Up-only stands everything upright while keeping heading); two or three lock the full frame. Look At aims each object's front at a movable target, per object (a spread selection fans out) or from the shared center, with an optional Custom Up handle. Replaces the old shared-orientation-only Orient (which read wrongly when objects started at different orientations). Aiming is done entirely with the handles now, so holding Space in Orient no longer re-drives the orientation: it lets the oriented objects fall and settle under gravity (Orient never moves them itself), the same Space clutch as Place ▸ Move.

Scatter mode¶

Randomize scatters each object to a random spot inside the editable box (re-press to re-roll). A Volume picks the region it fills: Box, Sphere or Cylinder (the ball / upright tube inscribed in the box, previewed as a wireframe), or Line / Curve (scatter the objects along a straight segment or a bowed curve you draw straight onto the scene surface, dragging its ends like Align / Duplicate rather than framing a box). Randomize Position gates the position scatter (off = rotation only); Randomize Rotation adds a per-axis Min to Max random spin. Per-axis masks pick which axes move (and flatten the volume onto the rest).
Explode is a blast sphere with its own handles: drag to aim, resize the falloff radius, set the Force arrow. Space detonates with an outward impulse on every body inside the radius (linear falloff, self-limiting near the edge). Cone and Directional modes (with an aim arrow) join the original Sphere blast. Use Gravity (on by default) makes the blast arc out and fall to rest.
Cramp is a continuous gather handle: every body chases a single point you drag, packing them into a heap. Use Gravity gathers horizontally while gravity owns the vertical, so they pile on the ground instead of bunching into a floating ball.
Nudge jiggles each object around its own start position and rotation (re-press to re-roll from the same start). Position Factor bounds the move as a fraction of each object's bounding box (0.25 = up to a quarter of its size per axis); Rotation Factor bounds the turn (1 = full freedom, 0.1 ≈ an 18° tilt on a random axis). Each half has its own on/off toggle, and it shares Randomize's axis mask and Settle With Gravity.

Per-axis mask rows across the box ops render through one shared control, tinted blue when an axis is engaged ("authorize this axis"), distinct from the red freeze-axis buttons ("lock this axis").

Collisions and alignment¶

A Collisions choice in the Place and Arrange overlays lets you line objects up without contacts nudging the result:

Normal (default): collide with everything.
Ignore Each Other: selected objects pass through one another but still collide with the scene.
Ignore Everything: the selection passes through the scene too.

It is layer-independent: it filters collider pairs directly and restores them on exit.

Group handling¶

Two opposite whole-tool toggles in the Constraints section, both live (flipping one re-grabs the current selection immediately) and available in every mode:

Rigid Group moves the whole selection as a single rigid body: every object keeps its exact spacing and never shifts against its neighbours, even when one member is blocked while the rest keep going. Internally the selection is welded together for the move (the same joint mechanism that holds a multi-part prefab together). Applies to Place, Arrange, Scatter, and Create's settling batch. Off by default.
Move Sub-Objects Independently grabs each mesh of a prefab (or any multi-mesh object) as its own physics body instead of moving the whole prefab as one block, so every operation can shift and settle the individual pieces. Each piece owns only its own colliders and is not joint-locked to its siblings, so the pieces collide with and push past one another. Off by default. Undo restores each piece (including nested meshes) to the right spot.

Overlay¶

The headline is the mode and operation (large, bold), with the Space instruction as a subtitle directly beneath. The old Active / Paused status line and the scene-view "Hold Space" text were removed.
Controls are grouped into collapsible sections: Options (operation dropdown plus that operation's settings), Constraints (axis freeze, hidden in Create), Simulation, Indicators, and Live Objects.
The Simulation section adapts to the current tool: Quality shows whenever a tool runs physics; Follow Speed, Softness and the damping sliders show for ops that drive toward a target; Select hides the section entirely. Motion Damping and Collision Damping are friendly 0 to 1 sliders here (formerly raw drag numbers in Advanced).
Indicators holds Show Colliders, Collision Indicators and Ground Ray. Live Objects holds Simulate Selected / Clear All.
Collision Indicators were redesigned to read an object's real contacts instead of firing probe rays: while you move a selection it washes the touched geometry red, outlines the exact collider being hit, dots each contact point, and labels every object being hit by name. Updates live and stays on while a placed object rests against a surface.
Ground Ray (off by default) drops a ray straight down from the transform handle to the first surface below it, drawing the line, a marker at the hit and the vertical distance, so you can see how high the selection floats and where it would land. The ray follows the handle as you drag.
The bottom action row uses uniform 24x24 square icon buttons (Options, Baked Colliders, Show Help), with the two manager entry points grouped at the left.

"Always Simulated" objects (replaces Lock)¶

The old Lock feature (which only stopped Grabbit grabbing flagged objects) is replaced by Simulate. Flagged objects become live physics bodies that take part in the simulation even when unselected, so a scene can settle realistically around what you place. They keep their real mass and damping, show a green outline plus "Simulated" label, and run only while the simulation is running. Selecting one hands it to the normal grab drive; deselecting returns it to free simulation.

Project Settings¶

The Project Settings > Grabbit 2 page is a stack of collapsible per-section foldouts (each remembers its state), cut from 17 to 8 logical sections: Preset, General, Indicators, Filtering, Performance, Collider Baking, then under Show Advanced Options: Mode Options and Advanced Physics.

Filtering merges layer/tag filtering, object layers and the bound-size limit into one "what Grabbit acts on" section.
Mode Options collects every per-mode tuning sub-section under one foldout.
General tuning that you set once lives here; usage-time choices live on the overlay. Movement feel (Follow Speed, Softness, Speed Near Obstacles) is surfaced only on the overlay, not duplicated here.
The scene-view Grabbit logo and its toggles were removed, the overlay already signals the tool is active.

Colliders and baking¶

The collider baker is pluggable via a Baking Strategy picker, named for what each optimises for (algorithm in parentheses):

Balance (V-HACD): fast voxel-based convex decomposition, solid all-round accuracy. The default.
Precision (CoACD): collision-aware decomposition, higher fidelity with fewer colliders, much slower (best with background baking). Exposes a Concavity threshold. Bundled under CoACD's MIT license (see CoACD/THIRD-PARTY-NOTICES.md for the required citation).
Performance (Primitives): fits parametric primitives (box, sphere, capsule, cylinder, frustum, trapezoidal prism) to the mesh. Cheapest at runtime, stored inline as a few bytes.

What Grabbit considers for collisions is split into two live switches on the overlay's Simulation section:

Use Existing Colliders: collide using the colliders already on your objects and the scene they move through. Off drives purely on Grabbit's generated colliders.
Generate Only If None: add generated colliders only to objects that have none of their own (fill the gaps). Off adds them everywhere. No effect while Use Existing Colliders is off. These map onto the Generation Mode in Project Settings, so saved presets are unchanged.
Ignore Invisible Colliders (on by default): skip colliders whose GameObject and children carry no active renderer (invisible walls, blocking volumes, collision proxies) so objects place against what you actually see. Turn it off to place against those volumes; Grabbit then draws each one in red.

Baking is safe by default: out of the box Grabbit bakes a mesh the first time you select or grab it and the objects around it, not on scene open and not on import. Whole-scene pre-baking and bake-on-import are opt-in (first-run wizard or Project Settings). Generated colliders swap in live when a background bake lands, so the accurate set takes over mid-session without a regrab.

Switching strategy keeps the old colliders. A displaced bake is kept aside and restored instantly if you switch back, matched by strategy and signature (resolution / max pieces). The browser lists other baked methods under Also Cached and offers a free Switch To Cached instead of a re-bake.
Skinned meshes are supported. A SkinnedMeshRenderer bakes in bind pose and feeds the same collider pipeline as a MeshFilter; a skinned object sitting in the scene is also a collision obstacle for other dragged objects.
Adaptive resolution scales voxel count to mesh complexity and size. Defaults raised to match V-HACD's recommended range (100,000 max / 20,000 min) after the old defaults produced coarse, blocky hulls.
Primitives strategy was rewritten into a faithful convex-primitive decomposition: per-face quadric init, greedy merge, enclosed-piece cull, all six primitive types, and a whole-mesh fast path (a cube resolves to one box, a cylinder to one cylinder) at any orientation. Merge Tolerance, Native Colliders Only, and cross-component bridging are exposed. Max Pieces is the target count; the resolution slider does not apply.

Bake colliders permanently onto objects via the Bake Convex Colliders action (right-click in the Hierarchy or on a prefab, Tools menu, or Project Settings). It turns generated colliders into a shippable part of the object (no runtime code, no tool cache):

A dialog asks which collider type to bake (Balance / Precision / Performance), the piece count, and per-child layout.
Graceful fallback (a mesh a strategy cannot process falls back to convex pieces, then a single hull, logging a warning) and honest errors (reports Read/Write disabled vs degenerate geometry).
Bakes into prefab assets directly; scene objects and Prefab-Mode contents bake in place, undoably. Colliders live under a Grabbit Colliders child (idempotent re-bake), optionally one piece per child.

Baked Colliders browser¶

Window > Jungle > Grabbit > Baked Colliders lists every source mesh Grabbit has decomposed, with per-mesh preview, search and regenerate. The overlay's collider button opens it scoped to the current selection (Selection Only toggle) and expands the first baked entry.

Disable individual baked pieces. Convex decomposition occasionally produces a piece you do not want (a sliver, a gap-filler). Each generated collider gets an on/off toggle; a disabled piece is skipped everywhere Grabbit applies colliders and is reversible with no re-bake (state stored with the bake, survives save). The choice is per source mesh; Regenerate resets to all-on.

Simulation and performance¶

Simulation Quality is the single dial for the speed-versus-accuracy balance: it sets the collider shape an object moves with, physics steps per update, contact solver effort, and continuous collision detection, on both the grabbed object and the static surfaces it touches. It defaults to High.
Dense static surfaces collide against their baked hulls at every quality level. Above roughly 5,000 triangles a surface uses its decomposition whatever the tier, and its bake is queued if it has none; sparse meshes keep colliding against their exact triangles, so resting accuracy is unchanged where it matters. Two overlapping 22k-triangle props used to cost about 80 ms per physics sub-step and now cost a fraction of a millisecond.
Low: single rounded collider, one step, background surfaces wrapped in a fast convex hull. Fastest.
Medium (default): fitted shapes (boxes / spheres / capsules), background surfaces keep their exact mesh.
High: full baked collider, exact background surfaces, precise on concave shapes.
Ultra: everything High does plus continuous collision detection for thin or fast geometry.
The old Max PhysX / Velocity / Solver Iterations fields and the Fast Obstacle Colliders toggle are folded into the quality level.
Settled objects sleep on the surface instead of having their contact re-solved every step, and a baked surface uses a fast collider group, so the cases that used to bog down (objects pressed on the ground) stay fluid.
Background collider baking runs off the main thread. Native backends (V-HACD, CoACD) run one at a time (running several oversubscribes the CPU and races inside the native libraries, a confirmed crash vector); only the thread-safe Primitives backend fans out. Bakes never straddle a domain reload or quit (the queue waits out any in-flight native bake rather than abandoning the thread).
Persistent spatial cache: if the same scenes are loaded after a domain reload, the cache bulk-inserts in a single frame instead of rebuilding incrementally.
Bounded sub-step backlog: the physics tick clamps accumulated catch-up to one frame's budget and the quality preset's step count, so a contact-slowed frame cannot turn one hitch into sustained stutter.

Architecture and reliability¶

The monolithic GrabbitTool orchestrator was decomposed into focused subsystems (context, input, physics, mode logic, selection, scene rendering), and transient runtime state was split out of the serialized settings asset.
Crash-safe state: on domain reload, an interrupted session is detected and orphaned Grabbit components are scanned for and cleaned up (layers restored, temporary physics components removed). Menu: Tools > Jungle > Grabbit > Force Cleanup Orphaned Components.
Comprehensive undo: layer and settings changes are undo-recorded, and the transform handle now follows an Undo / Redo (it resyncs the bodies and rebaselines the handle anchor and per-object offsets, instead of stranding the handle at the pre-undo location).
The manual limitation zone was removed in favour of automatic proximity-based registration around the selection (Proximity Reach, default 10x the selection's own size, so it scales with the scene).
Settings presets capture and apply the physics and collider settings as ScriptableObject assets (built-in: Precise Placement, Fast Layout, Gravity Playground), with undo support.
Objects are now parked before their colliders are handed back, so putting an object down no longer leaves physics briefly holding a shape it cannot simulate. This showed up as a stream of console errors while duplicating.
When physics does report a collider it cannot handle, Grabbit now prints what it knows about the objects involved instead of leaving you with the raw engine message.

AI and automation integration¶

Grabbit's physics operations, collider baking and Create-around are exposed as agent-callable tools (grabbit_run_op, grabbit_bake_colliders, grabbit_create) through the shared jungle.mcp layer. The behaviour is identical whichever host an agent connects through: each host adapter is thin (it maps flags onto the same internal Grabbit API) and compiles only when its host package is installed, so none is a hard dependency.
CoplayDev McpForUnity (com.coplaydev.unity-mcp)
Unity AI assistant MCP (com.unity.ai.assistant)
Unity CLI (com.unity.pipeline): the new terminal-native path for agents and CI, driven headlessly as unity command grabbit_run_op --mode scatter --operation randomize --targets "crates".

Settings and default changes¶

Teleport Distance is relative to object size (a multiple of the carried selection's bounding box, default 2.5x) rather than a fixed world distance.
Limit Max Selectable Size defaults off, and an oversize object is no longer silently dropped: an Authorize Size button pulls it in for the session. A 0 threshold means no limit. A wireframe reference cube shows the limit while it is on.
Guard Against Huge Selections (on by default): selecting a scene-spanning parent or Select All used to grab every descendant and bake them all synchronously, freezing the editor. Grabbit now holds back any selection over Max Meshes Per Grab (default 100) behind a Grab Anyway confirm.
Baking Mode defaults to On Selection (was On Scene Open), and bake-on-import is off by default.
Preserve Initial Transforms defaults off (turn it on for rigid group moves).
Collider generation uses existing and generated colliders by default, so a grabbed object collides as accurately as possible (the quality level keeps the generated collider cheap).
The Low-Quality Colliders setting was removed (collider cooking always uses the accurate midphase now).

Bug fixes¶

Collider baking can no longer freeze the editor: generation always runs on the background queue, and every synchronous bake path is gone.
Point now honours the Rotation picker (was Free Rotation): with Free it leaves rotation untouched (it previously kept pinning each body back to its captured original rotation, so the setting looked like a no-op).
Re-baking colliders actually refreshes them (a stray early return left the old bake cached, so Regenerate silently skipped).
Collider baking no longer re-runs on every selection (selection reuses the existing bake; small / flat meshes are no longer discarded by an absolute size threshold, replaced with a scale-relative coplanarity test).
Unbakeable meshes (e.g. Read/Write disabled) are negative-cached and fall back to a single convex collider once, instead of re-baking every selection.
On-demand background bakes persist (the queue flushes a single save when it drains) instead of being lost and re-baked on the next domain reload.
Baking colliders on a LOD object no longer bakes every level (only LOD0), and grabbing a LOD object no longer jitters (the LODGroup is frozen for the duration of the grab).
Surfaces with their own colliders no longer pay for a redundant generated full-mesh collider in the default generation mode.
Objects no longer jitter against surfaces or tunnel through them when pushed hard: a blocked-progress throttle (Anti-Jitter), an always-on anti-tunnel step cap, and speculative CCD that catches Grabbit's kinematic obstacle bodies.
Heavy and light objects in one selection now follow the handle at the same rate (driven bodies are normalised to a uniform mass so contact response is symmetric; authored mass restored on exit).
Per-axis Rigidbody constraints no longer make a body effectively immovable (frozen axes are zeroed before the velocity clamp instead of consuming the budget).
Undoing a Create spawn no longer logs "dangling component" warnings (the batch is undo-tracked before anything acquires a handler on it).
Place / Point no longer blocks scene selection (the cursor-pinned rotation handle that swallowed clicks was removed), and the Point marker tracks the cursor live even while paused.
Space works immediately after a hotkey mode / operation switch (the Scene View is re-focused after the switch).
Selecting an object no longer moves it before you grab a handle or hold Space (the tool parks on every selection change; physics only ticks the update after the selection callback runs).
Show Colliders draws as soon as it is toggled on and clears immediately when off; collider visualization defaults off for a clean Scene View on a fresh install.
Native collider gizmos are hidden while Grabbit is active (the temporary sim colliders no longer clutter the selection with green outlines), restored on exit and coupled to the Show Colliders toggle.
No more "Couldn't create a Convex Mesh" console spam for dense un-baked meshes (the stopgap is a single fitted primitive while the real bake runs).
Thin panels (Primitives strategy) no longer bake far too thick (the degenerate-thickness floor was lowered ~100x so a legitimately thin panel keeps its true thickness; re-bake affected meshes).
"Readjust On Release" tooltip and docs corrected: it re-anchors the handle onto where objects came to rest, it never "gave objects a moment to settle".
A native "Assertion failed!" dialog can no longer appear from a bake: the bake worker runs on its own hidden desktop, so an assert raised inside a decomposition library (which links its own C runtime and ignores the process error mode) has nowhere to display, and meshes whose bounds are sub-micron or astronomically large are skipped with a console warning instead of reaching the voxelizer.
The V-HACD library is now built in release configuration (it shipped as a debug build): collider bakes with the Balance method are several times faster, and the macOS binary is now a true universal binary, where it was x86_64-only and so could not load in an Apple Silicon editor.