# FancyWM is a dynamic tiler for Windows that asks applications what sizes they need > FancyWM arranges Windows 10 and 11 windows into horizontal, vertical and stacked panels that nest arbitrarily, and it has no layout configuration file because the layout is built as you work. Its two-pass algorithm queries every window for its minimum and maximum size and floats anything that would be squeezed below its declared minimum. **FancyWM/fancywm** — FancyWM - Dynamic Tiling Window Manager for Windows - Repository: https://github.com/FancyWM/fancywm - Website: https://fancywm.github.io/fancywm/ - Stars: 1,249 · Forks: 54 - Language: C# - License: NOASSERTION - Published: 2026-10-19 · Updated: 2026-10-19 · Language: en - Canonical page: https://hysenlabs.com/projects/fancywm-fancywm ## Tiling without leaving the Windows ecosystem FancyWM is described as a dynamic tiling window manager for Windows 10 and 11 that brings the productivity of tiling windows to the Windows desktop, without complex configuration and without sacrificing the familiar mouse-and-keyboard interactions most users expect. The positioning is deliberately aimed at a particular group of people. The Why Tiling on Windows section names developers, researchers and power users managing multiple applications at once, whether coding with reference docs, multitasking across projects, or orchestrating complex workflows, and makes the argument that tiling reclaims time and cognitive load. The comparison the project draws is with what Windows already ships. Snap Layouts and Virtual Desktops are useful, the documentation concedes, but they lack the control and dynamic behaviour that tiling provides. FancyWM is positioned as a practical entry point for users who are curious about tiling but not willing to leave Windows. The design philosophy section says the result is a tiler that feels like a natural extension of Windows rather than a Linux port, and it notes that several of the criteria it was built with are not implemented together elsewhere. The project is C# on the .NET runtime, and the repository is under the FancyWM organisation with a Gitter community channel. ## Three panel primitives that nest The organising idea is the panel, and there are three kinds. A horizontal panel places windows side by side, a vertical panel places them one above the other, and a stack panel lets windows overlap as tabs. That third type is what a tiling window manager usually lacks, and it is the reason a browser with many tabs or a chat client with several conversations can live inside a tiled layout. The key property is that these panels can be nested arbitrarily. A horizontal panel can contain vertical sub-panels, with stack panels embedded inside them. The documentation puts the result plainly: you build custom layouts by combining primitives rather than by editing configuration files. The behaviour follows from that structure. Windows flow into the focused panel as they open, they resize gracefully when siblings close, and they can be rearranged with keyboard shortcuts or by mouse drag and drop. The description of the result is a clutter-free workspace where every application has a deliberate place. For someone coming from a floating desktop, the mental shift is that a window no longer claims space on top of another. It claims a slot, and the layout adapts around it. ## The layout is created by working, not by configuring The No Configuration Needed section is a short walkthrough of what a first session looks like, and it is the clearest description of the design in the readme. The available keybindings are shown after you press Shift+Win, so the interface teaches itself. Then the sequence is: open your first window and it automatically fills the workspace. Open a second window and FancyWM creates a horizontal split, so both windows share the space. Press Shift+Win and then V to create a vertical panel, which moves the focused window into a new vertical panel. Press Shift+Win and then S to create a stack panel, where windows can overlap as tabs. From there you drag windows between panels, or embed panels into other panels, refining the layout in real time. So there is no layout file to author and no template to pick. A layout is the result of the order in which you opened things and the handful of shortcuts you pressed, which is a genuinely different workflow from every other tiling window manager you have configured. The trade is real, though. A layout you built by accident is a layout you have to rebuild after a restart, unless the tool persists it, and the readme does not describe a way to declare a layout in advance. For a workflow that is stable across days, that is a genuine weakness, and the project accepts it as the price of the zero configuration entry point. ## Applications get to say how small they can be The layout constraints feature is the part of the design that distinguishes FancyWM from a tiler that assumes it can size any window however it likes. Applications declare their minimum and maximum window sizes through the Windows API, in the WM_GETMINMAXINFO message. If an application refuses to resize smaller than its declared minimum, FancyWM respects that constraint, and the windows never shrink below their declared minimums. Windows that are not really windows in the layout sense are handled separately. Dialogs, tooltips and transient windows are automatically floated, which means removed from tiling, so they do not interfere with the layout. And if a new window would cause the columns to shrink below the minimum size, that window is floated too. The documentation states the consequence directly: no overlapping tiles and no broken layouts, because the tiler adapts to application constraints rather than forcing applications into unsuitable sizes. This is a design choice with a cost. A window that floats is a window you have to place yourself, so a badly behaved application does not get resized into uselessness but it does get a hole in your layout. For an application that reports a minimum size of a full screen, that hole will be the whole screen. The behaviour is defensible, but it is the place where a tiler on Windows can surprise you. ## A two-pass algorithm behind the layout The readme has a section on the internals, headed Two-Pass Layout Algorithm, and it explains how positions are calculated behind the scenes. Pass one is called Constraint Collection. The algorithm queries each window's minimum and maximum sizes through the WM_GETMINMAXINFO message, and the sizing constraints are gathered before anything is placed, rather than being discovered while placing. That ordering is the whole point of the constraint system described earlier. A tiler that sized windows as it went would have to resize something it had already placed whenever a new window turned up with an inconvenient minimum, and the result would be a layout that shifts under the pointer. Collecting the constraints first means the arrangement can be computed with the limits already known, which is what allows the no-overlapping-tiles behaviour to be a property of the algorithm rather than a hope. The repository layout backs the claim that this is a substantial piece of engineering rather than a thin shell over the Windows API. There is a FancyWM.Layouts/ directory with a matching FancyWM.Layouts.Tests/ project, a separate FancyWM.ThemeEngine/ with its own tests, a FancyWM.GUI/ project, a FancyWM.DllImports/ project for the native interop, and a FancyWM.Package/ project. The winman and winman-windows directories suggest a native window management component underneath the managed code, and ModernWpf is a submodule. ## Mouse and keyboard, and the native virtual desktops FancyWM makes a point of respecting that Windows users value both input methods, and the wording is that this balances power-user efficiency with the approachability expected on Windows. The keyboard side is the Shift+Win chord, which opens a panel of available keybindings, and the actions behind it are ordinary: a V for a vertical panel, an S for a stack panel, digit keys for virtual desktops, and F11 to toggle tiling off entirely so you can briefly use floating windows. Everything is rebindable, and the activation hotkey itself can be remapped to Ctrl+Win or Alt+Win if Shift+Win conflicts with other software, which on Windows is a real problem rather than a hypothetical one. Virtual desktops are native rather than emulated. The manager integrates with the Windows virtual desktop feature, so you jump between desktops 1, 2 and 3 with the same chord and a digit, and you can move a window to a different desktop with a second Shift modifier. The panel layouts can be per-monitor or global, and the readme gives the multi-project pattern of desktop 1 for coding, desktop 2 for research and desktop 3 for meetings, each with its own arrangement. Using the operating system's own desktops rather than a virtual desktop implementation of its own is a sensible choice on Windows, because it keeps the taskbar, the Alt+Tab behaviour and the existing shortcuts working. ## A userland process with a custom licence FancyWM runs as a lightweight userland process rather than a system service, and the documentation claims typical idle CPU usage of less than one percent, with optional animation toggles to reduce power consumption on laptops. The claim about the C# implementation with the .NET runtime being efficient enough for background window management without noticeable system impact is the project's own. The release history shows a project on a 2.x line with release candidates published alongside finals, v2.19.0 on 2026-03-14, v2.19.0-rc on 2026-03-07 and v2.18.6-rc on 2026-02-21. The repository is not archived and the last push was on 2026-09-21, so the code is being worked on even though the last tagged release is from the spring. The licence is the item to look at carefully. It is recorded as a custom licence that GitHub cannot classify, and the LICENSE file in the repository holds the actual terms. For a window manager that replaces part of the desktop shell, the terms of a licence you cannot read at a glance are worth checking before you install it, particularly if you intend to redistribute a packaged version. The rest of the tree is a normal Visual Studio solution, with FancyWM.sln at the root, Directory.Build.props for shared build settings, version.json for the version stamp, a CHANGELOG.md, a docs/ directory, a funding.yml file and the .editorconfig file at the top. ## Conclusion Adopt FancyWM if you want tiling on Windows and have been put off by the configuration files other tilers require, and you are comfortable with a keyboard shortcut that starts as Shift+Win and can be remapped to Ctrl+Win or Alt+Win. Do not adopt it if you need a stable, documented configuration file, because the design philosophy is explicitly that layouts are created as you work rather than declared. Verify first that the applications you use declare sensible minimum sizes through the Windows API, since the tiler floats any window that would be shrunk below its declared minimum, and read the licence in the LICENSE file, because GitHub cannot classify it as a standard one. ## FAQ ### What is FancyWM? It is a dynamic tiling window manager for Windows 10 and 11. It organises applications into vertical, horizontal and stack panels that can be nested arbitrarily, and it aims to give tiling behaviour on Windows without complex configuration and without giving up mouse and keyboard interaction. ### Do I need a configuration file to use FancyWM? No. The documentation describes a No Configuration Needed design where layouts are created as you work. The available keybindings appear after you press Shift+Win, and you create panels with V for vertical and S for stack, then refine the result by dragging windows or embedding panels. ### How does FancyWM handle applications that cannot be resized small? Applications declare minimum and maximum sizes through the Windows API WM_GETMINMAXINFO message, and the tiler respects those constraints. Dialogs, tooltips and transient windows are floated automatically, and a new window that would push columns below their minimum size is floated too, so there are no overlapping tiles. ### Does FancyWM work with Windows virtual desktops? Yes, it integrates with the native Windows virtual desktops rather than implementing its own. You jump between desktops with Shift+Win and a digit key, move a window to another desktop with an extra Shift, and panel layouts can be per-monitor or global. ### What is the resource cost of FancyWM? It runs as a lightweight userland process rather than a system service, and the documentation claims typical idle CPU usage below one percent, with optional animation toggles for battery-conscious workflows on laptops. ### Can I change the FancyWM hotkey? Yes. The documentation lists customisable keybindings, and says the activation hotkey can be remapped to Ctrl+Win or Alt+Win if Shift+Win conflicts with other software. ## Sources - [FancyWM/fancywm on GitHub](https://github.com/FancyWM/fancywm) - [Issues](https://github.com/FancyWM/fancywm/issues) - [Project website](https://fancywm.github.io/fancywm/) - [README](https://github.com/FancyWM/fancywm/blob/main/README.md) - [Releases](https://github.com/FancyWM/fancywm/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/fancywm-fancywm