How to save a window layout on Windows 11

Windows 11 · Updated August 2026

The short answer is that Windows 11 has no save-layout button. It has three features that each remember a piece of the problem, none of which survives a restart in the way people expect. Here is exactly what each one covers, where the edges are, and what to do about the gap.

What Windows 11 already remembers

Snap Groups

Snap two or more windows into a layout — hover the maximize button, press Win + Z, or drag a window to an edge — and Windows treats them as a group. Hovering any of those windows on the taskbar afterwards shows the whole group as one thumbnail, and clicking it brings all of them back together.

This is genuinely useful and most people never find it. What it does not do is persist: the group exists only as long as its windows do. Close one, and the group is gone. Restart, and it is gone. You also cannot name a group, keep several of them, or choose one deliberately — Windows forms them implicitly from whatever you snapped.

Remember window locations based on monitor connection

Under Settings → System → Display → Multiple displays. Windows stores an arrangement for each monitor configuration it sees and replays it when that configuration returns. This is the feature that saves you when a screen sleeps or a dock is unplugged.

It stores exactly one arrangement per configuration. It is a safety net, not a layout manager — there is no way to say "load my writing layout instead".

Virtual desktops

Win + Ctrl + D creates a second desktop, and each keeps its own set of windows. Recent Windows 11 builds bring virtual desktops back after a restart, so this is closer to durable than the other two. But a virtual desktop separates windows; it does not record where they sit. After a restart the desktops return, the windows do not come back positioned, and applications that were closed are not reopened.

What none of them do

Not one of the three reopens an application that isn't running. Every built-in mechanism arranges windows that already exist. If your morning involves opening the same six programs before arranging them, Windows has nothing for the first half of that.

Doing it yourself with PowerShell

Window positions are readable and writable through two well-documented Win32 calls, GetWindowRect and SetWindowPos. A script that captures every visible top-level window to a file is about thirty lines:

Add-Type @"
using System;
using System.Runtime.InteropServices;
public class Win {
  [StructLayout(LayoutKind.Sequential)]
  public struct RECT { public int L, T, R, B; }
  [DllImport("user32.dll")]
  public static extern bool GetWindowRect(IntPtr h, out RECT r);
  [DllImport("user32.dll")]
  public static extern bool SetWindowPos(IntPtr h, IntPtr after,
    int x, int y, int cx, int cy, uint flags);
}
"@

# Save
Get-Process | Where-Object { $_.MainWindowHandle -ne 0 } | ForEach-Object {
  $r = New-Object Win+RECT
  [void][Win]::GetWindowRect($_.MainWindowHandle, [ref]$r)
  [pscustomobject]@{
    Name = $_.ProcessName; Title = $_.MainWindowTitle
    X = $r.L; Y = $r.T; W = $r.R - $r.L; H = $r.B - $r.T
  }
} | ConvertTo-Json | Set-Content "$env:USERPROFILE\layout.json"

# Restore
Get-Content "$env:USERPROFILE\layout.json" | ConvertFrom-Json | ForEach-Object {
  $item = $_
  Get-Process -Name $item.Name -ErrorAction SilentlyContinue |
    Where-Object { $_.MainWindowHandle -ne 0 } | Select-Object -First 1 |
    ForEach-Object {
      [void][Win]::SetWindowPos($_.MainWindowHandle, [IntPtr]::Zero,
        $item.X, $item.Y, $item.W, $item.H, 0x0004)
    }
}

Treat that as a starting point rather than a finished tool — it is the honest shape of the problem, not a product. Run it in a normal PowerShell window and check the result before relying on it.

It also shows you where the difficulty actually lives, which is not in moving windows. It is in everything around that:

Matching. Two Explorer windows, three Chrome windows — ProcessName cannot tell them apart, so the script above puts the wrong window in the wrong place as soon as you have more than one of anything.
Maximized state. SetWindowPos on a maximized window gives you a maximized window at odd coordinates. Restoring it first, positioning, then re-maximizing is a separate step.
Monitors. Coordinates are absolute. Move a monitor in the display arrangement, or plug in a different second screen, and every saved coordinate points somewhere else.
Timing. A window that was just launched does not exist yet when the script reaches it. You have to wait for it and then position it.
Elevation. A normal process cannot move a window that belongs to an elevated one. Windows blocks it, and no flag changes that.

All of that is solvable, and if you enjoy this sort of thing it is a nice weekend. If you don't, it is the reason the tools in this category exist.

The third-party options

Several tools cover this, and they aim at different things:

PowerToys FancyZones — free, from Microsoft. Custom zones you drop windows into. It manages where windows may go rather than saving a specific arrangement; see what it remembers and what it doesn't.
DisplayFusion, WindowManager — large multi-monitor suites with window position saving among many other features. Priced accordingly.
DeskScene — the one this site is about. Below, briefly.

What DeskScene does with this

It saves the windows you have open — position, size, monitor, maximized state — as a named profile, and puts the arrangement back with one click, a global hotkey, or automatically when your monitor setup changes. Several profiles live side by side, so a writing layout and a meeting layout are one keystroke apart.

It handles the awkward parts listed above: matching windows by title similarity rather than process name alone, restoring maximized state correctly, storing positions per monitor, and launching applications that aren't running before it positions them.

See how it works Free seven-day trial, then €9.99 once. No subscription.

Its limits, stated up front: Store (UWP) apps can't be captured, windows running as administrator can't be moved by a normal program, and matching is a heuristic. The first two apply to every tool in this category, the PowerShell script included — they are Windows rules, not implementation choices.