glzr-dots (Omarchy* on Windows)

_{* Omarchy is ofcouse Linux; this recreates the experience on Windows with GlazeWM + a top bar that's either the Command Palette Dock (default) or Zebar.}

A faithful port of the Omarchy tiling-WM experience to Windows. If you've used Omarchy (or Hyprland), your muscle memory works here: same keybinding layout, same workflow, same dwindle autotiling, just with Alt standing in for Super (Windows reserves it).

Lives at %USERPROFILE%\.glzr (the default config path for both tools), so the repo is the config. No symlinks, no bootstrap script.

💡 Cross-machine muscle memory: the binding pattern is shared, while the physical modifier follows each OS: Super on Omarchy and Alt on Windows. Read both as Mod. The one-page keyboard cheat sheet shows the common chords and the few platform-specific differences.

Screenshot

Top: the Zebar bar option (overline-zebar pack) with workspace switcher, system stats, tray, and clock. Center: PowerToys Command Palette acting as the launcher. (The default bar is now the Command Palette Dock — see Choose your bar.)

lazygit on the left, fastfetch on the right, both running in minimal Terminal windows with Starship.

What this gives you

The goal is Omarchy parity: the core binding grammar mirrors Omarchy with Super represented by Alt. Platform-specific applications and the documented deviations remain intentionally different.

Omarchy / Hyprland	This config	Notes
Super as mod key	Alt	Windows owns Super (Win key); using it as a mod conflicts with too many OS shortcuts.
Super + 1..0 workspaces	Alt + 1..0	10 workspaces, same layout.
Super + Shift + N to send window to workspace and follow	Alt + Shift + N	Same "follow" behavior (not vanilla GlazeWM default).
Super + Arrows focus, Super + Shift + Arrows move	Alt + Arrows / Alt + Shift + Arrows	Identical.
Super + =/- resize	Alt + =/-	Plus a vim-style Alt + R resize mode (hjkl).
Super + Shift + B/E/F/... app launchers	Alt + Shift + B/E/F/...	Same letters (Zen, Outlook, Obsidian, Teams, Gemini). The file manager and editor are TUIs in a Terminal window — elio and fresh — rather than Explorer and VS Code, which keeps them inside the tiling layout.
Hyprland dwindle layout	autotile.py	WebSocket client that flips split direction based on the focused window's longest axis.
Lone window centered on ultrawides	autotile.py	On a monitor wider than ~2:1, a single window in a workspace floats centered at half the monitor width instead of stretching edge-to-edge; opening a second window drops it back to tiling. No-op on 16:9 displays.
Waybar top bar	Command Palette Dock (default) or Zebar with overline-zebar	Two options — see Choose your bar. The Dock reserves its own space (AppBar); Zebar needs a 50px top gap.
Focus-follows-cursor	✅	Plus cursor-jump on monitor focus change.
Tiling by default	✅	initial_state: tiling.
Super + C/V/X universal clipboard	Alt + C/V/X via clipboard.py	Sends Ctrl+Insert / Shift+Insert / Ctrl+X — works in terminals and GUI. Alt + Ctrl + V opens the Win+V history.

Extras specific to Windows: window rules that ignore PowerToys overlays, browser picture-in-picture, Office sub-windows, Outlook reminders, and Lively wallpaper.

Choose your bar

The top bar (workspace switcher + status) can be one of two things. This repo ships with the Command Palette Dock as the active default — gaps.outer_gap.top is 2px and no bar is launched from startup_commands. Zebar is a one-uncomment fallback.

	Command Palette Dock (default)	Zebar
What it is	A Command Palette extension (GlazeWMDock, see cmdpal/) that renders the workspace strip on the CmdPal Dock	Standalone status bar app with the overline-zebar pack
Install	Command Palette gallery → GlazeWM Workspaces (Store listing pending; sideload meanwhile — see cmdpal/)	winget install glzr-io.Zebar + install the pack from the Marketplace
Screen space	Reserves its own via the Windows AppBar API → keep outer_gap.top: 2px	Overlay bar → set outer_gap.top: 50px
Shows	Workspace numbers as glyphs (filled = focused, outline = active, plain = empty)	Full widgets: workspaces, system stats, tray, clock
Startup	None — enabled in Command Palette settings	shell-exec zebar in startup_commands

Use the Dock (default): install the extension (see cmdpal/), then in Command Palette — Settings → enable Dock (Position = Top) → Bands → toggle GlazeWM Workspaces on.

Switch to Zebar: in glazewm/config.yaml, uncomment the shell-exec zebar line in startup_commands, set shutdown_commands to ['shell-exec taskkill /IM zebar.exe /F'], and set gaps.outer_gap.top to 50px. Then do the Zebar pack step in Install.

Prerequisites

Tool	Purpose	Install
GlazeWM	Tiling WM	winget install glzr-io.GlazeWM
PowerToys (Command Palette)	Launcher + the default top bar (Dock)	winget install Microsoft.PowerToys
Zebar	Alternative top bar (only if you don't use the Dock)	winget install glzr-io.Zebar
Python 3 + websockets	Autotile script	winget install Python.Python.3.12 then pip install websockets
Windows Terminal	Default terminal binding	winget install Microsoft.WindowsTerminal

PowerToys / Command Palette does double duty here: it's your app/file launcher (the Omarchy walker/wofi equivalent) and, via the GlazeWMDock extension, the default top bar. winget install Microsoft.PowerToys

Optional (only needed if you use the matching launcher binding): Zen Browser, Obsidian, Microsoft Teams, New Outlook, plus elio (cargo install elio) and fresh (winget install sinelaw.fresh-editor) for the file-manager and editor bindings.

Shared keyboard language

These dotfiles use the same shortcut grammar as the companion Omarchy and Squarebox configs:

Scope	Omarchy	Windows	Meaning
OS / window manager	Super	Alt	Windows, workspaces, and app launchers
Focused application	Ctrl	Ctrl	Immediate tabs, panes, and app commands
Modifier	Shift	Shift	Move, reverse, or a higher-level variant

Herdr is the reference implementation of the application layer: Ctrl+Arrow focuses panes, Ctrl+Shift+Arrow moves them, and familiar browser-style Ctrl bindings manage tabs. See herdr/. Its F12 prefix remains as a compatibility path, not the primary interaction model.

For the compact daily reference, use the one-page keyboard cheat sheet.

Install

Clone directly into the config location:

# If ~/.glzr already exists (fresh install), move it aside first
Move-Item $env:USERPROFILE\.glzr $env:USERPROFILE\.glzr.bak -ErrorAction SilentlyContinue

git clone https://github.com/BrettKinny/glzr-dots.git $env:USERPROFILE\.glzr
pip install websockets

Set up your top bar. The default is the Command Palette Dock; Zebar is the alternative. See Choose your bar for the full comparison.

• Command Palette Dock (default): install the GlazeWMDock extension and enable it in Command Palette — details in cmdpal/. Nothing to launch from GlazeWM; the Dock lives with Command Palette.
• Zebar (alternative): this repo ships only the pointer to mushfikurr.overline-zebar (in zebar/.marketplace/); the widget code lives in %APPDATA%\zebar\downloads\ and isn't versioned here. Launch Zebar, open the Marketplace UI, install overline-zebar by mushfikurr, then restart Zebar. Also make the config edits noted in Choose your bar.

Then launch GlazeWM. It starts the autotile and clipboard scripts automatically via startup_commands (and Zebar too, if you enabled that option).

Structure

.glzr/
├── glazewm/
│   ├── config.yaml      # keybindings, workspaces, gaps, window rules
│   ├── autotile.py      # dwindle-layout autotiler (WebSocket client)
│   └── clipboard.py     # Omarchy-style universal clipboard (Alt+C/V/X) — ctypes keyboard hook
├── cmdpal/
│   └── README.md        # pointer to the GlazeWMDock Command Palette Dock extension (default bar)
├── zebar/
│   ├── settings.json    # startup widget (overline-zebar / main / default) — alternative bar
│   └── .marketplace/    # references to installed marketplace packs
├── powershell/
│   ├── profile.ps1      # shell profile (zoxide, fzf, eza, bat, PSReadLine, `ask`)
│   └── set-edit-associations.ps1  # open text/config files in Microsoft Edit (TUI)
├── fresh/
│   ├── config.json      # fresh editor keymap — Ctrl+Alt mirrors the WM's Alt layer
│   └── README.md        # the three-layer keyboard grammar + why it's passed with --config
├── herdr/
│   ├── config.toml      # native Ctrl application bindings; F12 prefix fallbacks
│   └── README.md        # binding reference + HERDR_CONFIG_PATH setup
├── lazygit/
│   ├── config.yml       # open files in Microsoft Edit; Nerd Font glyphs
│   └── README.md        # LG_CONFIG_FILE setup
├── windows-terminal/
│   ├── settings.json    # WT keybindings stripped so editor keys reach fresh
│   └── README.md        # what's unbound and why (tracked copy, not a link)
├── elio/
│   ├── config.toml      # TUI file manager: sidebar places + open rules
│   └── theme.toml       # elio colour theme
└── omarchy/
    └── bindings.conf    # Omarchy-side clipboard override (copy into ~/.config/hypr/bindings.conf)

Shell (PowerShell)

Brings the modern-Linux terminal niceties to PowerShell 7+. powershell/profile.ps1 is the real profile; everything in it is guarded with Get-Command, so it loads cleanly on a fresh machine and each feature lights up only once its tool is installed.

Tool	Gives you	Install
zoxide	z <dir> frecency jump, zi interactive picker	winget install ajeetdsouza.zoxide
fzf + PSFzf	Ctrl+T fuzzy file finder, Ctrl+R history	winget install junegunn.fzf + Install-Module PSFzf
fd	fast file walk behind fzf (skips .git, respects .gitignore)	winget install sharkdp.fd
bat	cat with syntax highlighting; powers the Ctrl+T preview	winget install sharkdp.bat
eza	ls/ll/la/lt with git status, icons, tree	winget install eza-community.eza
delta	syntax-highlighted git diffs (configured in ~/.gitconfig)	winget install dandavison.delta
gsudo	sudo for Windows (aliased only if no native sudo)	winget install gerardog.gsudo
starship	prompt; config in powershell/starship.toml, styled with ANSI colour names so it follows the terminal theme	winget install Starship.Starship
elio	TUI file manager; config in elio/ — see elio	cargo install elio
Microsoft Edit	edit TUI editor — the $EDITOR and file-association target	winget install Microsoft.Edit
Claude Code	ask one-shot question answerer — see ask	winget install Anthropic.ClaudeCode
glow	renders ask's markdown in the terminal (optional)	winget install charmbracelet.glow

Plus which and touch helpers for muscle memory.

Aliases

Single letters for the things opened dozens of times a day. Defined in the Aliases region of profile.ps1.

Alias	Runs	Notes
c	Claude Code	The interactive session. ask is the one-shot equivalent.
f	fresh	A wrapper function, not a plain alias — it passes --config at the repo keymap. See fresh/.
h	Herdr	Terminal workspace manager. See herdr/.
e	Microsoft Edit	Resolves via the edit alias to the winget v2 build, not the legacy System32 edit.exe.
lg	lazygit	winget install JesseDuffield.lazygit
lj	lazyjira	Manual install; not on winget.

h is the only one that shadows a PowerShell built-in — stock h is Get-History. It's a plain alias (Options: None, not ReadOnly), so Set-Alias replaces it without the Remove-Item Alias: dance that ls and cat need. History is still there as Get-History, or Ctrl+R for the fuzzy picker. c, f, e, lg and lj are unused in stock PowerShell.

Also live, from their own regions rather than the alias block: ls/ll/la/lt (eza), cat (bat), z/zi (zoxide), sudo (gsudo, only when Windows has no native sudo).

Wiring: unlike GlazeWM/Zebar, PowerShell's profile path isn't ~/.glzr, so it can't live in the repo directly. Instead the real $PROFILE is a one-line shim that sources this one:

# Point your $PROFILE at the repo copy (run once):
$shim = '$glzrProfile = "$HOME\.glzr\powershell\profile.ps1"' + "`n" + 'if (Test-Path $glzrProfile) { . $glzrProfile }'
New-Item -ItemType File -Path $PROFILE -Force | Out-Null
Set-Content -Path $PROFILE -Value $shim
. $PROFILE

delta also needs a few lines in ~/.gitconfig (not tracked here):

git config --global core.pager delta
git config --global interactive.diffFilter "delta --color-only"
git config --global delta.navigate true
git config --global delta.line-numbers true
git config --global merge.conflictStyle zdiff3

ask — one-shot Claude in the terminal

For the "what's the flag for…" questions that don't deserve a browser tab. ask wraps the Claude Code CLI in a single-shot function, so it reuses whatever auth claude already has — no API key to manage.

ask "what's the command to find which process is using port 8080?"   # chat mode
ask -f "which module provides the ctrl+r binding here?"              # reads the cwd
git diff | ask "explain what changed"                                # piped context

Flag	Effect
(none)	Chat mode. No tools, general knowledge only, ~5s. Streams token by token as plain text.
-f	File mode. Answers from the files in the current folder and cites path:line, ~10-14s. Prints a dim · Read line per tool call.
-m <model>	Override the model (default haiku, chosen for latency).
-r	Force glow rendering in chat mode.
-Raw	Force plain streaming in file mode.

-f is read-only and scoped to $PWD — Read, Glob and Grep are allowed; Edit, Write, Bash and web access are explicitly denied, so it can't modify anything or stop to ask permission. cd to the project first; it won't reach into a parent directory.

Each call is an independent one-shot with no memory of the last, and no session is written to disk. For an actual conversation, use claude (aliased to c).

Design notes (why it's fast, and why only -f renders markdown)

Latency. --effort low is the single biggest win — it suppresses the extended thinking block, which otherwise burns several seconds reasoning about a one-line question. --no-session-persistence, --strict-mcp-config and --disable-slash-commands skip startup work a one-shot question never uses. Output is parsed out of --output-format stream-json, so tokens appear as they arrive instead of landing in one dump at the end.

Rendering is per-mode because glow can't stream — it needs the whole document, so piping through it means nothing appears until the answer is complete. That trade is only worth making where markdown actually shows up:

• Chat mode passes --tools "", which makes Claude Code's default system prompt (all the tool-use scaffolding) dead weight, so it's replaced outright via --system-prompt. A terse plain-text instruction is then reliably obeyed, leaving nothing to render — it streams raw.
• File mode needs that default prompt for the tools to work, so the terse instruction can only be --appended to it. Fences and bold keep coming regardless of wording, so it buffers and renders.

The BOM. The console-encoding region at the top of profile.ps1 sets $OutputEncoding to UTF-8 with a BOM, and PowerShell writes those bytes into any native command's stdin. glow reads them as document text and prints a stray U+FEFF before the first word, so the glow pipe swaps in a BOM-less encoder and restores it after. Worth knowing before piping strings into other native tools from this profile.

Positional binding. $Question is declared Position = 0 with ValueFromRemainingArguments so ask what is a hard link works unquoted. Without the explicit position, -Model (declared earlier) silently swallows the first word as the model name. Quotes are still needed for anything containing ?, |, $ or '.

Text files open in the terminal

The Omarchy reflex is that a config file opens in a terminal editor, not a GUI. powershell/set-edit-associations.ps1 points plain-text and config extensions at Microsoft Edit (winget install Microsoft.Edit), so double-clicking one from Explorer, Command Palette, or Everything drops you into the TUI editor in a Windows Terminal window — which GlazeWM then tiles like any other window.

.\powershell\set-edit-associations.ps1                # apply
.\powershell\set-edit-associations.ps1 -Verify        # show what each extension opens with
.\powershell\set-edit-associations.ps1 -Revert        # undo

Covers .txt .md .markdown .log .ini .cfg .conf .env .properties .json .jsonc .yaml .yml .toml .xml .ps1 .psm1 .psd1 .sql .diff .patch — no admin, no reboot. Pass -Extensions to override the list. Executable types (.bat .cmd .reg .py .sh .vbs) are deliberately left alone: retargeting those would break double-click-to-run. -Verify resolves each extension through AssocQueryString, i.e. it reports what the shell will actually launch rather than what the registry looks like it says.

Why this needs more than a registry write (getting past UserChoice)

Extensions an app has already claimed — .txt, .log, .ini, .json, .xml, .ps1* here — carry a UserChoice key whose Hash value Windows verifies. You cannot rewrite it. You can delete it, after which the extension falls back to the HKCU\Software\Classes default the script owns. Three things get in the way:

1. The key's DACL grants you nothing. You're still its owner though, so WRITE_DAC is implicitly yours — grant yourself FullControl first.
2. RegistryKey.DeleteSubKeyTree() can't do it. It opens the victim KEY_READ|KEY_WRITE before deleting, and that open is refused. .NET then reports the refusal as "Cannot delete a subkey tree because the subkey does not exist" — badly misleading. RegDeleteKeyExW needs only DELETE, so it works.
3. RegDeleteKeyExW only deletes leaf keys, and recent builds add a UserChoiceLatest alongside UserChoice with a ProgId subkey. Delete children depth-first, or you strand an orphaned Hash — which sends the extension to OpenWith.exe instead of your default.

The script also seeds edit.exe into each extension's OpenWithList MRU, since an extension left with an empty MRU can resolve to OpenWith.exe rather than falling through to the class default.

This is destructive to your existing picks. -Revert restores Windows' defaults, not what you had before — if VS Code owned .json, re-assign it afterwards via Open with → Always use this app. -PickManually remains as a fallback for anything the registry path misses; note Windows only offers the "Always" option once the old UserChoice is gone, so apply first.

Requires Windows Terminal as your default terminal (Settings → System → For developers → Terminal), otherwise edit opens in legacy conhost.

profile.ps1 also exports EDITOR=edit, which covers anything that shells out to an editor (git, lazygit) rather than going through a file association. It's set as a persistent User-scope env var too, so GUI-launched apps see it; the profile line is what makes a fresh clone work before that's been done.

elio (TUI file manager)

elio (cargo install elio) does not consult Windows file associations — it has its own opener rules — so elio/config.toml carries a matching rule:

[[open.rules]]
ext = ["txt", "md", "log", "ini", "conf", "json", "yaml", "toml", "ps1", "..."]
command = "edit {path}"
terminal = true

terminal = true is load-bearing: it runs edit inline in elio's own terminal instead of spawning a separate window that GlazeWM would then tile alongside elio. Extensions are bare — no leading dot — matching elio's own [extensions.*] tables. Valid rule keys are type, ext, platform, command, terminal; at least one of type/ext is required, and elio prints elio: open.rules[N]: unknown field ...; skipping rule on stderr for anything it rejects, which is the quickest way to check a rule took.

Wiring: elio reads %APPDATA%\elio (or $XDG_CONFIG_HOME/elio), so like the PowerShell profile it can't live in this repo directly. It's junctioned rather than shimmed:

# Run once, after cloning (no admin needed -- junctions don't require it):
Move-Item $env:APPDATA\elio $env:APPDATA\elio.bak -ErrorAction SilentlyContinue
cmd /c mklink /J "$env:APPDATA\elio" "$env:USERPROFILE\.glzr\elio"

Don't be tempted by XDG_CONFIG_HOME=~/.glzr as a no-symlink alternative — elio honours it on Windows, but so do other tools, and it would redirect everything already living in ~/.config (git, scoop, micro…) to a directory that has none of their configs.

The OneDrive place entry points at a plain ~/OneDrive, because a real OneDrive folder is named after the tenant (OneDrive - <Company Name>) and hardcoding that would put an employer in a public repo. elio only expands ~, not environment variables, so there's no portable way to express it in the config — junction the generic name at the real folder instead:

# Run once, if you use the OneDrive sidebar entry:
$tenant = (Get-ChildItem $env:USERPROFILE -Directory | Where-Object Name -like 'OneDrive - *').FullName
cmd /c mklink /J "$env:USERPROFILE\OneDrive" "$tenant"

Keybindings

Mod key: Alt (stands in for Omarchy's Super). The core grammar matches; application choices and the deviations listed below do not.

Window management

Binding	Action	Omarchy equivalent
Alt+W	Close window	Super + W
Alt+F	Toggle fullscreen	Super + F
Alt+T	Toggle tiling/floating	Super + T
Alt+Shift+V	Toggle floating (centered)	Super + Shift + V
Alt+J	Toggle tiling direction	Super + J
Alt+M	Minimize	(no Omarchy equivalent)

Focus & move

Binding	Action	Omarchy equivalent
Alt+←/→/↑/↓	Focus window	Super + Arrows
Alt+Shift+Arrows	Move/swap window	Super + Shift + Arrows
Alt+Shift+Ctrl+Arrows	Move workspace to monitor	Super + Shift + Alt + Arrows

Resize

Binding	Action	Omarchy equivalent
Alt+=/-	Grow/shrink width 2%	Super + =/-
Alt+Shift+=/-	Grow/shrink height 2%	Super + Shift + =/-
Alt+R	Vim-style resize mode (hjkl, Esc to exit)	(extra)

Workspaces

Binding	Action	Omarchy equivalent
Alt+1…0	Focus workspace 1–10	Super + 1..0
Alt+Shift+1…0	Move window to workspace and follow	Super + Shift + 1..0
Alt+Tab / Alt+Shift+Tab	Next / previous workspace	Super + Tab / Super + Shift + Tab
Alt+Ctrl+Tab	Recent workspace	Super + Ctrl + Tab

Launchers

Same letters as Omarchy, mapped to Windows-native apps.

Binding	App	Omarchy equivalent
Alt+Enter	Windows Terminal	Super + Return (terminal)
Alt+Shift+B	Zen browser	Super + Shift + B (browser)
Alt+Shift+N	fresh in a Terminal window	Super + Shift + N (editor)
Alt+Shift+F	elio in a Terminal window	Super + Shift + F (file manager)
Alt+Shift+O	Obsidian	Super + Shift + O (Obsidian)
Alt+Shift+E	Outlook (mail)	Super + Shift + E (email)
Alt+Shift+C	Outlook calendar (Edge PWA)	Super + Shift + C (calendar)
Alt+Shift+G	Microsoft Teams	Super + Shift + G (messaging)
Alt+Shift+A	Gemini (Edge PWA)	Super + Shift + A (AI)

Clipboard

Omarchy's trick: Super + C doesn't send Ctrl+C (which is SIGINT in a terminal) — it sends Ctrl+Insert, the legacy CUA combo that copies in both terminals and GUI apps. This config does the same with Alt as the trigger, via a small stdlib ctypes keyboard hook (glazewm/clipboard.py, started at login by startup_commands). Native Ctrl+C / Ctrl+V keep working as a fallback.

Binding	Action	Sends	Omarchy equivalent
Alt+C	Copy	Ctrl+Insert	Super + C
Alt+V	Paste	Shift+Insert	Super + V
Alt+X	Cut (GUI only)	Ctrl+X	Super + X
Alt+Ctrl+V	Clipboard history	Win+V	Super + Ctrl + V (walker)

Win+V needs Clipboard History enabled once (Settings → Clipboard, or press it and accept the prompt). If the hook ever isn't running, native Ctrl+C/Ctrl+V still work.

Omarchy side (for true cross-machine parity): Omarchy's clipboard.conf hardcodes Super and is not covered by its Super↔Alt mod toggle, so flipping the mod key leaves copy/paste on Super. To put it on Alt to match this config, add to ~/.config/hypr/bindings.conf (sourced last, highest priority):

unbind = SUPER, C
unbind = SUPER, V
unbind = SUPER, X
unbind = SUPER CTRL, V

bindd = ALT, C, Universal copy, sendshortcut, CTRL, Insert, activewindow
bindd = ALT, V, Universal paste, sendshortcut, SHIFT, Insert, activewindow
bindd = ALT, X, Universal cut, sendshortcut, CTRL, X, activewindow
bindd = ALT CTRL, V, Clipboard manager, exec, omarchy-launch-walker -m clipboard

WM control

Binding	Action
Alt+Shift+R	Reload config
Alt+Shift+P	Pause WM
Alt+Ctrl+W	Redraw all windows
Alt+Ctrl+Q	Exit WM

Known deviations from Omarchy

• Mod key is Alt, not Super. Windows hard-binds many Super (Win key) chords to OS-level actions (search, snap layouts, etc.), so using Super as the WM mod is a constant fight. Alt is the cleanest substitute.
• Exit is Alt + Ctrl + Q, not Super + Shift + E. That letter is reserved here for the Outlook launcher to match Omarchy's email binding.
• No app-rofi / launcher menu. Recommended to pair with PowerToys Command Palette as your launcher; it fills the same role as walker / wofi / rofi on Omarchy.

Customization

• Change the mod key: search/replace alt+ in glazewm/config.yaml. Note that lwin+ / rwin+ work but collide with many Windows shortcuts.
• Top bar height: gaps.outer_gap.top in config.yaml. The Dock reserves its own space, so leave it small (2px); for Zebar, set it to the bar height (50px).
• Swap the Zebar pack: edit zebar/settings.json → startupConfigs[].pack to any pack listed in zebar/.marketplace/.
• Border color: window_effects.focused_window.border.color (currently #8dbcff).
• Ultrawide centering: tune the constants at the top of glazewm/autotile.py — WIDTH_FRACTION (centered width, default 0.5), ULTRAWIDE_MIN_RATIO (default 2.0), or set ENABLE_CENTER_SINGLE = False to turn it off.

Credits

• Omarchy for keybinding philosophy and defaults
• mushfikurr/overline-zebar, the Zebar pack this config launches (Zebar option)
• glzr-io for GlazeWM and Zebar themselves
• GlazeWMDock — the Command Palette Dock extension that renders the default workspace bar (see cmdpal/)

License

MIT. Do whatever you want with it.