Tiling

Where windows land, what happens when there are too many, and which knobs your algorithm actually reads.

Autotile places every window for you: open one and the layout redraws to fit it. The algorithm decides the shape. The settings on this page decide the behaviour around it, covering insertion order, the window cap, what dragging does, and which windows are exempt.

The 27 algorithms that ship in-box are in the algorithm gallery, along with the Luau contract for writing your own. Exact defaults and ranges for every key named here are on the settings reference.

Choosing an algorithm

Tiling.Algorithm.Default is the algorithm a screen uses until you assign it one of its own, and it ships as bsp, binary space partitioning, which splits the focused region in two for each new window. Per-screen assignment happens from the Monitors page, the same way every other context assignment does.

Not every algorithm reads every setting

This is the thing most worth knowing before you go changing numbers, because the failure mode is a setting that appears to do nothing.

Each algorithm declares what it honours. Of the 27 bundled algorithms, 19 honour SplitRatio and only 3 honour MasterCount, because most of them have no master area for a count to mean anything about. A grid divides evenly, so it has nothing to treat as a master and ignores the setting rather than guessing.

The 3 that do take a master count:

Centered MasterMaster + StackWide

SplitRatioStep is how far the increase and decrease shortcuts move the ratio per press, so it matters on the same 19 algorithms and nowhere else.

Per-algorithm parameters

Some algorithms expose parameters of their own beyond the shared ones. Those values are stored per algorithm id under Tiling.Algorithm.PerAlgorithmSettings, so switching algorithms and switching back keeps whatever you set. The settings app writes it, and the shape is an implementation detail rather than something to hand-edit.

Where new windows go

Tiling.Behavior.InsertPosition takes three values, and it is the setting that most changes how the mode feels:

FocusNewWindows is on by default here, unlike in snapping mode, since a window that autotile placed for you is usually the one you just asked for.

The window cap

Tiling.Algorithm.MaxWindows caps how many windows the algorithm will tile, and Tiling.Behavior.OverflowBehavior decides what happens to the ones past it:

Algorithms carry their own suggested cap as defaultMaxWindows, so a grid that divides nine ways suggests nine.

Dragging a tile

Tiling.Behavior.DragBehavior decides what happens when you pick a tiled window up. float pops it out of tiling into a free-floating window. reorder keeps it tiled and swaps it into whichever slot you drop it on.

Separately from that, a trigger list re-inserts a dragged window into the stack at the cursor rather than at its slot. Tiling.Behavior.Triggers works exactly like the snapping activation trigger. It uses the same modifier vocabulary, with a toggle mode and a release grace period for the case where a mouse-button trigger lifts a moment before the drop.

Windows autotile leaves alone

A tiling mode that tiles everything is unusable, so several settings carve out exceptions.

For a specific application rather than a class of window, a window rule is the better tool: excludePlacement keeps one app out of tiling without touching the mode. Global size and transient-window thresholds live under Exclusions and apply to every mode at once.

Gaps

Gaps are global rather than per-mode. Gaps.Inner sits between windows and Gaps.Outer around the screen edge, with per-side outer values if you turn Gaps.UsePerSide on.

Tiling.Gaps.SmartGaps is the one tiling-specific piece: with a single window tiled, drop the gaps entirely so it sits flush to the screen. It is on by default.

Next