# WindowTabs: browser-style tabs for Windows desktop windows

> An F# WinForms application that puts tabs on top of ordinary application windows, groups them by dragging, moves and resizes grouped windows together, and can restore saved workspaces. It is Windows only, runs as a single portable executable, and its most recent release is a preview beta.

**leafOfTree/WindowTabs** — A utility that brings browser-style tabbed window management to the desktop.

- Repository: https://github.com/leafOfTree/WindowTabs
- Stars: 1,015 · Forks: 86
- Language: F#
- License: MIT
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/leafoftree-windowtabs

## Tabs on top of ordinary application windows

WindowTabs is a utility that brings browser-style tabbed window management to the desktop. It groups windows from any apps and switches between them with a click or a shortcut.

The important detail is that these are not browser tabs and not virtual desktops. They are real application windows, and the tab bar is an overlay that WindowTabs draws on top of them. The README's screenshots show the concept: three File Explorer windows grouped under a single tab bar, in both a light and a dark rendering.

The behaviour that follows from that is worth understanding. Grouped windows move and resize together, so the group behaves as one unit on the desktop. Tabs hide on maximized windows, and you point at the top edge to show them, or set the Auto-hide tabs option to Never if you would rather they stayed visible.

Grouping is done by dragging. You drag a tab onto another window's tab bar to group them, and drag it away to ungroup. There is also an automatic route: right-click an application's tab and choose Enable auto-grouping, which groups every window of that application together without any dragging.

The project is MIT licensed, the primary language is F#, and the repository is not archived with the last push on 2026-10-18. The homepage for the project is empty in the metadata, so the repository and its releases are the reference.

## Shortcuts, and a way to back out of a conflict

The shortcut table is short, and each entry has a default you can change under Settings, then Shortcuts.

Next and previous tab are Ctrl + Alt with the right and left arrow. Tabs one through nine are Ctrl plus the number, or Alt plus the number. Search tabs is Ctrl + Alt + T. A new window of the current application is Ctrl + Alt + N.

Switching tabs with the mouse is two separate gestures: scroll over the tab bar, or Shift and scroll over the window itself. Moving the current tab is Ctrl and scroll over the tab bar. Closing a tab is a middle click.

The conflict handling is the part that makes this usable with real software. If Ctrl or Alt plus a number conflicts with an application, you can turn it off for that application from the tab's right-click menu. So the shortcut set is global by default and per-application by exception, which is the right way round for a tool that wraps every window on the desktop.

Four behaviours are optional and off by default: switching on hover, a leader key to pick tabs by letter, where you press Alt + F and then the key shown on the tab, automatic tab colours, and an Alt+Tab replacement.

That last one is the most opinionated feature in the list. Replacing Alt+Tab is a system-wide change to a habit people have for decades, and making it opt-in is the only defensible choice for a utility that otherwise sits quietly in the tray.

## Dragging files onto a tab, and why admins break it

Drag files onto a tab and pause to bring that window forward. On a File Explorer tab, let go to drop them into its folder as Explorer would: Ctrl copies, Shift moves, right-drag asks, and Ctrl + Z in Explorer undoes it.

That is a small feature with a large amount of subtlety. The point of the implementation is that the drop is handed back to Explorer rather than being reimplemented, so the copy and move distinction, the collision prompt and the undo history all keep working. A tool that dropped files with its own file API would have to reimplement all three.

The troubleshooting section names the failure mode precisely: dropping files on a tab does nothing if Windows blocks dragging from an app into one running as administrator. And the general case: running as administrator is not needed and not recommended, because Windows blocks some input between admin and normal windows.

That is a genuine constraint on the tool's usefulness, and it comes up more than you would expect. An administrator's PowerShell or a service console running elevated cannot be dragged into a normal-privilege window, so the elevated windows are effectively outside the grouping system.

The other diagnostic worth knowing is about dialogs. If a window has no tab, check Settings, then App rules, because dialogs do not get tabs. A modal dialog is a separate top-level window with its own lifecycle, and grouping it with the window that opened it would be wrong.

## Rules, workspaces and the taskbar

The App rules section is the part that goes beyond grouping by hand.

You choose which applications get tabs and which group automatically. In the Grouping rules tree you create named groups and add applications to them. Each application belongs to one rule group, and while its rule is enabled it disables Group by app. The new-application default at the top of the tree keeps existing application choices unchanged when you change the rules.

That last clause is a small design decision with real consequences. A rule that reclassified every window of an application would be disruptive, so the default protects what you have already configured.

Workspaces come next. You save groups and window positions, then restore them onto open windows. A workspace is therefore a saved arrangement of windows, which is closer to a saved desktop layout than to a virtual desktop, because it restores onto windows that are already open rather than swapping the whole session.

The taskbar integration is optional: you can combine each group into one taskbar button, so a group of five windows occupies one slot instead of five.

Appearance is configurable along three axes: light, dark or follow the Windows theme, Joined, Folder or Floating tab styles, and per-tab or per-application colours. The README lists English, Chinese and Japanese as the available languages, and the F# source keeps every visible string in one file, with the English, Chinese and Japanese versions side by side.

## Settings, portable use and updates by replacing the executable

Settings save automatically to a JSON file in the Windows application data directory, at `%AppData%\WindowTabs\WindowTabsSettings.json`. For portable use, you put that same file next to `WindowTabs.exe`, which is the arrangement for someone who runs the tool from a USB stick or keeps it on a drive that is not synced.

Export, import and reset are under Settings, then Support. The reset is also the first thing the troubleshooting section tells you to try after an upgrade that behaves oddly, and it backs up your old settings first, so the reset is not destructive.

Updates are handled in a way that says something about the project's shape. You exit WindowTabs from the tray and replace the executable. The settings are kept. There is no updater, no installer and no registry entry to clean up, which is the direct consequence of the no-installation model: you download `WindowTabs.exe` from the releases page and run it.

The troubleshooting report is the other half of that. It is under Settings, then Support, and the README notes that it leaves out window titles and paths. That is a deliberate redaction, and it is the difference between a report you can paste into a public issue and one you cannot, since a window title is exactly the sort of thing that leaks what you are working on.

The project also ships code signing, through free code signing provided by SignPath.io with a certificate from the SignPath Foundation, and the release binaries are built from source by GitHub Actions.

## F# on .NET Framework 4.8, with one UI thread per group

WindowTabs is an F# WinForms app on .NET Framework 4.8, with a small C# project for the Win32 interop. That combination is a deliberate choice for a Windows utility that has to sit on top of other applications' windows, and the README is honest about the constraints of working in it.

The build needs the .NET 10.0 SDK with the Windows SDK installer, usually x64, and the .NET Framework 4.8 Developer Pack, since the runtime alone is not enough to build. The commands are:

```bash
git clone https://github.com/leafOfTree/WindowTabs
cd WindowTabs
dotnet build WindowTabs.sln                 # Debug: WtProgram\bin\Debug\WindowTabs.exe
dotnet build WindowTabs.sln -c Release      # Release: WtProgram\bin\Release\WindowTabs.exe (single exe)
```

The first build downloads NuGet dependencies and needs internet access, and you have to exit the running executable before rebuilding because it locks the output.

The architecture notes are the part a contributor needs. Each tab group runs on its own UI thread, and the main thread owns settings and window discovery, with calls between them going through the adapters in `Shared/Services.fs`. Every visible string lives in `Shared/Strings.fs` with the three languages, and settings names, defaults and ranges are declared once in `Shared/SettingsCatalog.fs`, with the settings window, the search and the reset all reading from that single declaration.

The DPI and theme rule is specific: use logical pixels and scale with `Dpi.scale`, and check the UI in light, dark and high-contrast modes.

The repository layout reflects this. There is a `Win32/` directory for the interop, a `WtProgram/` directory for the application, a `Shared/` area inside it, a `tests/` directory, `docs/` with an architecture and a testing document, an `AGENTS.md` and a `CLAUDE.md`, and a `dotnet-tools.json`.

## Where WindowTabs is the wrong choice

The first wrong case is anything that is not Windows. The tool is WinForms on .NET Framework 4.8 with a C# Win32 interop project, it targets Windows 10 and 11, and there is no macOS or Linux version in the repository. A cross-platform window manager is a different project with a different problem, because the tab overlay depends on Windows specific window handling.

The second is a workflow that runs elevated applications. Windows blocks some input between admin and normal windows, and specifically blocks dragging from an app into one running as administrator, so file drops into elevated windows do not work. For someone who lives in an elevated terminal, that is a real hole in the tool.

The third is a team that wants a managed deployment. There is no installer, no update mechanism and no configuration management story beyond copying an executable and a JSON file. The README's update instruction is to replace the executable, which is fine for one person and wrong for a fleet of machines.

The fourth is a user who wants virtual desktops. WindowTabs groups existing windows and can save and restore arrangements of them, which is a different model from the virtual desktops in Windows itself, and the two overlap in a way that can be confusing.

The fifth is a project that needs a stable release. The current tag is a preview beta, and the release before it is published with a note about known issues and a recommendation to use other versions. The project is clearly moving, and the moving is fun, but it is not a dependency you pin.

What you get if you accept those constraints is a small, fast, single-file window manager that does one thing well, which is the right shape for this kind of utility.

## Conclusion

WindowTabs suits a Windows user who has too many application windows open and wants them grouped into tabs the way a browser groups tabs, and who is willing to run a single unsigned or signed executable from the tray and replace it to update. It does not suit macOS or Linux, where there is no equivalent, and it does not suit a workflow that depends on dragging files into windows running as administrator, because Windows blocks that. Before adopting it, read the `AGENTS.md` and `docs/architecture.md` files if you plan to contribute, and check the release notes before installing, because the v2026.10.07 tag is published with a note about known issues and the current tag is a preview beta.

## FAQ

### How do I install WindowTabs?

There is no installation. On Windows 10 or 11, download `WindowTabs.exe` from the releases page and run it. It runs in the system tray, and settings save to `%AppData%\WindowTabs\WindowTabsSettings.json`, or next to the executable for portable use.

### How do I group windows in WindowTabs?

Drag a tab onto another window's tab bar to group them, and drag it away to ungroup. To group an application automatically, right-click its tab and choose Enable auto-grouping. Grouped windows move and resize together.

### Why do some windows not get tabs?

Check Settings, then App rules, because dialogs do not get tabs. The app rules tree is where you choose which applications get tabs and which group automatically.

### Can I update WindowTabs without losing my settings?

Yes. Exit WindowTabs from the tray and replace the executable. The settings are kept, and the settings file lives at `%AppData%\WindowTabs\WindowTabsSettings.json` unless you run it portably with the file next to the executable.

### What is WindowTabs written in?

An F# WinForms app on .NET Framework 4.8, with a small C# project for the Win32 interop. Building it needs the .NET 10.0 SDK and the .NET Framework 4.8 Developer Pack.

## Sources

- [Issues](https://github.com/leafOfTree/WindowTabs/issues)
- [leafOfTree/WindowTabs on GitHub](https://github.com/leafOfTree/WindowTabs)
- [License: MIT](https://github.com/leafOfTree/WindowTabs/blob/main/LICENSE)
- [README](https://github.com/leafOfTree/WindowTabs/blob/main/README.md)
- [Releases](https://github.com/leafOfTree/WindowTabs/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/leafoftree-windowtabs