Dragging a file in the File Explorer triggers a full-document style recalc (65-100 ms hitch per drag start and end)

Steps to reproduce

  1. Large vault (1,288 files / 542 MB / 611 Markdown notes; ~20 community plugins were loaded when the numbers below were captured).
  2. Open the File Explorer in the left sidebar and expand a folder that has many entries.
  3. Press and hold a file until the drag starts, move it a few pixels, then release it back where it came from.

Did you read and follow the Troubleshooting Guide? [Yes/No]

Partly. Rather than disabling every plugin I profiled the running renderer directly, and I separated the core-CSS cost from the plugin/theme CSS cost, because the trigger turns out to be a core style rule (numbers below).

Expected result

Picking up a file and dropping it should be immediate - no pause at the start or the end of the drag gesture.

Actual result

There is a visible stutter exactly when the drag starts and again when the file is released (not while moving). Measured with forced style recalculations in the renderer (2,503 elements and 11,430 CSS rules at capture time):

Probe Reading
Add is-grabbing to <body> + force a style recalc 65-100 ms
Add a class that no rule references to <body> + force a style recalc 2.2 ms
Add a class to .workspace / to one leaf / to .status-bar 0.1 / 0.0 / 0.0 ms
Style-only vs style+layout for that recalc 75.7 / 75.7 ms (100% style recalc)
Same recalc with the core app.css only (3,816 rules) 22.9 ms (vs 67.7 ms with all loaded CSS)
Override only that one rule’s selectorText 69.3 ms → 4.2 ms (71.6 ms after restoring it)

The rule responsible, in the bundled app.css of obsidian-1.14.4.asar:

body.is-grabbing,
body.is-grabbing *:not(.workspace-leaf-resize-handle) {
  cursor: -moz-grabbing !important;
  cursor: -webkit-grabbing !important;
  cursor: grabbing !important;
}

The *:not(...) tail makes the selector document-wide, so toggling is-grabbing on <body> invalidates the style of every element. The drag code adds that class when the drag starts and removes it when it ends (body.addClass("is-grabbing") / body.removeClass("is-grabbing")), which produces exactly one pause at each end of the gesture. Only 1 of the 6 core rules that mention is-grabbing has this universal tail (the others are cheap), and no JS reads the class - it is purely a CSS hook.

Reproduced on a second machine as well: Lenovo Legion Y9000X (Intel Core Ultra 9 275HX, RTX 5060 Laptop + Intel iGPU, Windows 11 Home 24H2 build 26200.9457, 2560x1600 at 150% scaling, same vault synced to a different drive) shows the same stutter when dragging files, so this does not look specific to one device, one GPU or one driver setup.

Environment

SYSTEM INFO (machine A - measured above):
	Obsidian version: v1.14.4
	Installer version: v1.14.4
	Operating system: Windows 11 Pro 10.0.26200 (build 26200)
	CPU/RAM: Intel Core Ultra 5 135H / 16 GB
	Login status: logged in
	Language: zh
	Base theme: light
	Community theme: none
	Snippets enabled: 4
	Restricted mode: off
	Plugins installed: 27
	Plugins enabled: 6
		lsj-obsidian-plugin, remember-cursor-position, notebook-navigator, obsidian-quiet-outline, obsidian-excalidraw-plugin, obsidian-style-settings

Machine B (same behaviour, not profiled):
	Lenovo Legion Y9000X / LAPTOP-LSJ-9000X
	Windows 11 Home 24H2 (build 26200.9457), Intel Core Ultra 9 275HX, RTX 5060 Laptop + Intel iGPU, 2560x1600 at 150%

Additional information

cursor is inherited, so the forced grabbing cursor does not need to be declared on every element. Narrowing that one rule keeps the effect and removes the document-wide invalidation:

body.is-grabbing,
body.is-grabbing .app-container,
body.is-grabbing .titlebar,
body.is-grabbing .modal-container {
  cursor: grabbing !important;
}

I verified this locally by overriding only that rule’s selectorText at runtime (no files changed): the hitch drops from 69.3 ms to 4.2 ms, descendants still compute to grabbing, and drag-to-resize handles keep their own row-resize / col-resize cursors (a direct declaration beats inheritance). The exact selector is not the point - anything that keeps the invalidation set local works.

Note on scale: the cost is roughly (number of elements x number of style rules), so even with core CSS only it is ~23 ms, and plugin/theme CSS multiplies it (plugins and snippets contributed ~7,600 of the 11,430 rules above). It would be good not to require every large vault to ship a CSS workaround.

Related: Large Vault: Editor lags when file explorer in view and file list is expanded (tracked) covers editor lag while the File Explorer is open on large vaults; this report is a distinct, one-shot cost per drag gesture.