macOS users who prefer keyboard-driven workflows often find the native Spaces system limiting when it comes to tiling window management. AeroSpace tackles this by replacing native Spaces entirely with its own virtual workspace system, driven by a tree-based layout engine configured via CLI and TOML files — no GUI configuration in sight.
what aerospace does and how it’s built
AeroSpace is a macOS tiling window manager written in Swift, inspired by i3 on Linux. Instead of using macOS’s native Spaces, it emulates virtual workspaces with its own system that manages windows in a tree structure. This tree-based layout engine organizes windows hierarchically, allowing complex tiling patterns.
The project is designed to be fully keyboard-driven, catering to advanced users who favor dotfiles-style configuration over graphical interfaces. Configuration is handled through a TOML file, and users interact with AeroSpace primarily via a command-line interface that controls window management tasks.
Under the hood, AeroSpace uses mostly macOS public Accessibility APIs to control windows without needing to disable System Integrity Protection (SIP) or require notarization. It does make one private API call but carefully avoids triggering macOS’s notarization warnings by relying on Homebrew installation scripts to remove quarantine flags.
The current public beta is a significant rewrite from earlier versions. The core data structure that manages the window layout is transitioning from a mutable double-linked tree to an immutable persistent tree. This change is more than a code refactor — it addresses issues like random window jumps and enables native macOS tab support.
The stack is primarily Swift, focusing on performance and macOS integration. The architecture includes a thread-per-application model planned to improve responsiveness and stability further, alongside new shell-like command combinators to enhance the CLI’s expressiveness.
why aerospace’s layout engine rewrite matters
The switch from a mutable, double-linked tree to an immutable persistent tree is the most interesting technical aspect here. Mutable trees are straightforward and commonly used for real-time window managers, but they can lead to tricky bugs. AeroSpace experienced random window jumps due to mutations and synchronization issues.
Immutable persistent data structures, borrowed from functional programming, solve these problems by making every update produce a new tree version without altering existing ones. This means AeroSpace can maintain consistent snapshots of window layouts and roll back or compare states without side effects.
This approach also enables AeroSpace to support macOS native tab groups more naturally. Tabs are essentially a different way to organize windows hierarchically, and the persistent tree model makes it easier to integrate this feature seamlessly.
The tradeoff is performance overhead and increased complexity in managing persistent structures. AeroSpace addresses this with a planned thread-per-application architecture, isolating each window’s management to its own thread to avoid bottlenecks and improve concurrency.
Code quality-wise, the repo is surprisingly clean for a system-level macOS app with this scope. The CLI-first configuration avoids the complexity of GUI state synchronization, and the TOML config is straightforward to audit and version-control. However, the reliance on one private API call and the lack of notarization may deter less technical users.
installation and getting started with aerospace
Installation is straightforward for users familiar with Homebrew:
brew install --cask nikitabobko/tap/aerospace
This method sets up AeroSpace with auto-updates. Note that in multi-monitor setups, users need to ensure their displays are properly arranged in macOS settings for AeroSpace to manage windows correctly.
The project explicitly warns users that AeroSpace is not notarized by Apple. The developer doesn’t oppose notarization conceptually but rejects Apple’s implementation due to the overhead and restrictions it imposes. The Homebrew install script removes the quarantine attribute so users won’t see macOS warnings about unverified software.
For detailed configuration, users should consult the online guide linked in the repo: https://nikitabobko.github.io/AeroSpace/guide#installation
verdict: who should try aerospace
AeroSpace is a solid choice for macOS power users who want a keyboard-centric, tiling window manager that replaces native Spaces completely. Its focus on CLI and config-file-driven workflows makes it ideal for those comfortable editing dotfiles and working mainly in the terminal.
The immutable persistent data structure rewrite is a technically interesting solution to state consistency and stability problems common in window managers. If you appreciate functional programming concepts applied to UI state, AeroSpace offers a rare example in a real-time macOS environment.
However, the reliance on a private macOS API and the lack of notarization mean it’s not for everyone. Users who prefer GUIs, need multi-monitor support out of the box, or want a fully Apple-sanctioned app might look elsewhere.
Overall, AeroSpace is worth exploring if you’re comfortable with macOS internals, want a customizable tiling WM, and don’t mind running a public beta that’s still evolving under the hood.
Related Articles
- Thunderbolt: a cross-platform, model-agnostic AI client built with TypeScript and Tauri — Thunderbolt is a cross-platform AI client that abstracts multiple AI providers with a TypeScript codebase using Tauri, s
- nh: a Rust-based unified CLI for the Nix ecosystem with enhanced search and ergonomics — nh is a Rust CLI tool consolidating Nix, NixOS, and Home Manager commands with improved ergonomics, speed, and Elasticse
- SiYuan: A modular, privacy-first self-hosted knowledge management system with a TypeScript and Go hybrid stack — SiYuan is a self-hosted personal knowledge system blending TypeScript frontend and Go backend, offering block-level refe
- Kestra: event-driven workflow orchestration with Infrastructure as Code and UI integration — Kestra is an event-driven orchestration platform combining declarative YAML workflows with a visual UI. It supports scal
→ GitHub Repo: nikitabobko/AeroSpace ⭐ 20,592 · Swift