Core concepts

On this page

Panes

A pane is one slot in the grid. Most panes are a terminal — a real PTY running a shell, an agent CLI, or anything else you’d run in a terminal, with full color, escape-sequence, and wide-character fidelity. Panes can be named (F2, or double-click the title) so a wall of agents stays legible.

Pane kinds

Every pane starts on the welcome screen, where you pick what it becomes. There is no global mode — each pane declares its own kind:

Kind What it is
Agent A coding-agent CLI (Claude, Copilot, or your own command). Optionally fans out to N panes, each in its own git worktree.
Orchestrator + workers An orchestrator pane plus idle workers, in its own project tab, with guardrails. See the orchestration guide.
Terminal A plain shell — PowerShell, Command Prompt, or Git Bash.
File explorer A native-style file manager rooted at a folder you choose.
File editor The file tree + code editor (the Alt+F surface) as a pane, rooted at a folder you choose.
Git The git view (the Alt+G surface) as a pane, over a repo you choose.

The last three are content panes: a pane that is a surface rather than a process. No shell, no CLI, no PTY — just the surface, in a pane. They split, dock, drag, maximize and restore exactly like a terminal pane, and they never count toward a tab’s agent badge, because a viewer is not an agent.

The file editor and git panes

The Alt+F editor and the Alt+G git view are overlays: they float over a terminal pane, so you can see the shell underneath, and they go away when you press Esc. That’s right for a quick look. It’s wrong when you want the surface to stay — you end up toggling it in and out, or you give up a whole terminal to it.

So both are also pane kinds. Pick File editor on the welcome screen, give it a folder, and the pane is the editor: tree, code editor, project-wide search and replace, permanently. Pick Git, give it a repo, and the pane is the git view: graph, status, diffs, staging, and worktree switching. Split one beside your agent and it stays put while the agent works.

What differs from the overlay, and only this:

  • No ✕, no Esc-to-close. There is nothing to close back to — the pane’s ✕ closes it, like any pane.
  • The pane adopts a re-root. Change the editor’s root folder from its header and the pane follows: its title updates and session restore reopens that folder. (In the overlay, browsing elsewhere is deliberately view-local — it must not disturb the terminal underneath.)
  • Unsaved edits are guarded, everywhere. An editor pane holds real buffers, so closing it with unsaved changes asks first — from the header ✕, from its dock chip, or from Ctrl+Shift+W. Closing the whole tab asks too (click ✕ once to arm, again to confirm — the same two-step a tab with live agents uses), and its tooltip says what is at stake. Re-rooting the editor to a different folder asks, because the file you had open doesn’t exist under the new root. And quitting loomux asks: one dialog listing every unsaved file across every tab — including the Alt+F editors you left open inside terminal panes, which are the ones you forget — with Quit anyway or Cancel. If nothing is unsaved, quitting is silent, as it should be.
  • Nothing automatic destroys a buffer. A pane whose process exits (or whose orchestration group is ended) stays open if its editor has unsaved edits, and its banner says so. The agent is already dead; your half-written file needn’t be.
  • Discard means discard. Answering “Discard unsaved changes?” with Discard drops the edits — the file goes back to what’s on disk. It no longer hides the buffer and asks you the same question again later.
  • The git pane refreshes on open, after its own actions, and on ↻ — not on focus. Refreshing rebuilds the changes strip, which would wipe a half-typed commit message every time you tabbed away and back.

Alt+F / Alt+G inside a terminal or agent pane still open the overlays — same overlay, same sizing, same Esc. Inside a content pane there is no terminal for an overlay to float over, so the hotkey for the surface the pane already is just focuses it, and the others answer with a toast naming what isn’t available where — “The git view isn’t available in a file editor pane.” If a git view is what you want beside your editor, open a git pane; the toast won’t tell you that, this page does.

Everything else is the same code. The editor pane is the same editor; the git pane is the same git view, worktree switching included.

The file explorer pane

A file explorer pane is loomux’s Windows-Explorer equivalent, living inside a pane. Pick a folder and you get a real file manager: browse it, open things, and do the usual housekeeping — without leaving loomux or opening an OS Explorer window per project.

  • Browse — double-click a folder to go in; the breadcrumb and the ↑ button take you back out. Backspace (or Alt+←) goes up, arrow keys move the selection, Enter opens.
  • Double-click a file → it opens in your default app for that extension, exactly like Explorer. A .png goes to your image viewer, a .pdf to your PDF reader, a .docx to Word. Loomux doesn’t open it and has no opinion about its type.
  • New file (Ctrl+N) and new folder (Ctrl+Shift+N) — type the name inline. A new file is created empty and is not opened; double-click it when you want it.
  • Rename (F2) and delete (Del).
  • On Windows, delete goes to the Recycle Bin, so a mis-click is recoverable — and the confirmation says so. On macOS/Linux there’s no bin, so it’s permanent, and the confirmation says that instead. It never promises an undo you don’t have.
  • A delete runs off the UI thread: a node_modules-sized folder can take a while, and nothing else in loomux stops while it does. The row pulses, the status line names what’s going, and the ops that would write to the same tree wait their turn — but you can keep browsing, hashing and opening files throughout. There is no Cancel, because a delete stopped halfway leaves half a folder in the Recycle Bin and half on disk; once you confirm, it finishes.
  • Hidden toggle — shows hidden files, and widens the Go-to-file index to include git-ignored paths (node_modules, build output).

Right-click menu

Right-click a row for Open, Open with… (the OS chooser — Windows only), Reveal in file explorer (opens your OS file manager with the file selected), Open in file editor pane, Rename, Delete, Hash →, and New →. Right-click the empty space below the rows for New → on its own.

Open in file editor pane is the in-app counterpart to Open: where Open hands the file to the application your OS associates with it, this opens it in loomux’s own editor, in a new pane beside the browser — rooted where the browser is rooted, so the editor’s tree shows the same project. On a folder the item reads Open folder in editor pane and roots the new pane at that folder. Either way the browser stays exactly where it was: opening a file elsewhere is no reason to move the list you opened it from.

The menu acts on the row you right-clicked — always, even if the list re-sorts or a search finishes underneath it while the menu is open. It works the same on a Go-to-file result: right-click a search hit and you get the same menu, acting on that file.

A symlink row’s actions are greyed with a reason — loomux shows links but never follows or modifies them.

Hashes

The listing carries a short SHA-256 for every file. It is computed in the background, off the UI thread, and streamed in — opening a folder never waits on it, and navigating away cancels it. Click a digest to copy the full value.

  • Digests are cached per file, keyed by its size and modification time, so re-entering a folder is instant and editing a file re-hashes it.
  • Files over 32 MB show a hash link instead of a digest: reading a gigabyte unasked isn’t free, so that one’s your call. Click it and it hashes.
  • Hash → in the right-click menu computes any of SHA-256, SHA-512, SHA-1, CRC-32, CRC-16, CRC-8 on demand and shows the full digest in a copyable dialog. (The CRC variants are named — ISO-HDLC, ARC, SMBUS — because a bare “CRC-16” is ambiguous and you need to know which one you’re comparing against.)

This is not the in-app editor. That’s the Alt+F overlay, it still works everywhere, and it’s the right tool for a quick look or a one-line fix. The explorer is the one for “get this file into the application that owns it.”

Go to file

The Go to file box finds a file by name, anywhere under the pane’s root. It’s built to be instant: the folder’s paths are indexed once in the background, and each keystroke filters that index in memory.

  • Type any part of a name or path — matching is plain substring, case-insensitive.
  • Several terms, separated by spaces, must all match somewhere in the path: pane rest finds src/panerestore.ts, and src pane finds src/pane.ts.
  • ↑ / ↓ pick a result, Enter opens it in its default app, Esc clears the box. Opening a hit also navigates you to its folder with it selected, so you end up somewhere useful rather than back where you started.
  • Rename and delete work on a search result too, and act on that file: press F2 (or the toolbar buttons) with a result highlighted. Rename takes you to the file’s folder and opens the editor on it, so you can see exactly what you are renaming.

If more files match than the list shows, the count above it tells you — results are never cut silently. (The same box is in the Alt+F editor too, where Enter opens the file in the editor instead.)

The rest of the pane

It has no terminal underneath and never starts a process. That means the terminal-oriented chrome is gone from its header (no folder or branch chip; the overlays float over a terminal and are sized from it, so they don’t apply here — Alt+G / Alt+I answer with a toast that names what isn’t available where, e.g. “The git view isn’t available in a file explorer pane.” When it’s a git view you want over this project, open a git pane). Everything else is a normal pane: it splits, drags, docks, maximizes, renames, and comes back on session restore at the same folder. It is not an agent, so it never counts toward a tab’s agent badge.

If the folder is gone when a session is restored (deleted, renamed, or on a drive that isn’t mounted), that pane comes back as the welcome screen with a message instead of an empty listing — pick a new folder and carry on.

The split grid

Loomux arranges panes as a matrix, not a lopsided staircase:

  • Split right (Ctrl+Shift+E) adds a pane beside the current one.
  • Split down (Ctrl+Shift+O) adds one below.

Splitting again in the same direction adds a sibling column or row, so repeated splits build an even grid instead of nesting ever-smaller boxes.

Drag the divider between two panes to resize them.

Rearranging without re-splitting

Panes get cramped fast once an orchestrator opens one per agent, so the grid can be rearranged in place:

  • Drag to reorder or move — grab a pane by its header and drag it over another. A snap preview shows where it will land:
    • drop on the middle to swap the two panes, or
    • drop on an edge (left/right/top/bottom half) to move the pane there, re-splitting the target.

    Release to drop, or press Esc to cancel. Swapping two equally-sized slots never resizes their terminals, so no scrollback is disturbed.

  • Maximize (Ctrl+Shift+M or the ⤢ button) blows one pane up to fill the grid; the same shortcut (or the ⤡ restore button) puts it back. The other panes are hidden rather than shrunk, so they don’t repaint. Maximize is sticky: when the orchestrator spawns an agent in the background, the new pane joins the grid underneath without dropping you out of fullscreen.
  • Minimize (Alt+M or the — button) parks a pane in the dock strip at the bottom of the grid — it keeps running. Click its chip to bring it back, or the chip’s ✕ to close it for good.
  • Fold a whole group — an orchestrator pane has a fold toggle (the stacked panes icon) that minimizes every worker/reviewer pane in its group to the dock at once, leaving just the orchestrator. Click again to restore them all. Handy once a big group has opened a pane per agent and you want the screen back. (More in the orchestration guide.)

Why overlays, never re-splits, for the git/issues/board/audit panels: resizing a PTY forces the program inside it to repaint, which pollutes scrollback. Loomux’s feature panels float over the terminal instead, so the PTY box never changes size. You’ll see this promise repeated across the feature pages — it’s a core design rule.

Project tabs

The split grid above is one workspace. Project tabs give you several: each tab is a whole workspace — its own split grid and minimize dock — and switching tabs swaps the entire workspace in and out, so you can keep several projects side by side without their panes competing for space.

  • New tab Ctrl+Shift+T (or the + in the tab strip); close it with Ctrl+Shift+K (or its ✕); page between tabs with Ctrl+Shift+[ / Ctrl+Shift+].
  • A background tab is hidden, not torn down — its terminals keep running and its scrollback stays intact, and switching never repaints a terminal (the same no-resize promise as maximize).
  • Launch an orchestrator and it opens its own repo-named tab; a blocked agent in a hidden tab raises an alert on its tab so a background project can’t hide its ask.

Full details — rename/color, live previews, per-project pause, and what survives a restart — are on the Project tabs feature page.

Copy & paste

  • Copy / paste — Ctrl+Shift+C / Ctrl+Shift+V (Ctrl+V also pastes).
  • A CLI running in a pane (e.g. an agent that says “copied to clipboard”) copies straight to your system clipboard too, via OSC 52 — no manual re-select needed.

Keyboard shortcuts

The single source of truth for keybindings is src/shortcuts.ts in the repo; this table mirrors it.

Action Shortcut
Split right Ctrl+Shift+E (or ◫ in a pane header)
Split down Ctrl+Shift+O (or ⬓)
Close pane Ctrl+Shift+W (or ✕)
New project tab Ctrl+Shift+T (or + in the tab strip)
Close project tab Ctrl+Shift+K (or the tab’s ✕)
Prev / next tab Ctrl+Shift+[ / Ctrl+Shift+] (or click a tab)
Rename pane F2, or double-click its title
Move focus Alt+←/→/↑/↓ (or click)
Resize panes drag the divider between them
Reorder / move panes drag a pane by its header
Maximize pane Ctrl+Shift+M (or ⤢); same keys restore
Minimize pane Alt+M (or —); restore from the dock
Session browser Ctrl+Shift+P (or the sessions button)
Open in editor Alt+E (or the </> button in a pane header)
Git view Alt+G (or the ⑂ icon)
GitHub issues view Alt+I (or the ◉ icon)
Voice prompt Alt+S (push-to-talk; Esc cancels)
Copy / paste Ctrl+Shift+C / Ctrl+Shift+V (Ctrl+V also pastes)

Orchestrator panes add a few more (steering strip, task board, audit viewer, lifecycle panel) — those live in the orchestration guide.

Stack (what a pane actually is)

  • Backend: Rust + Tauri 2 + portable-pty (WezTerm’s PTY layer) — real ConPTY on Windows, forkpty on macOS/Linux.
  • Frontend: xterm.js (the emulator VS Code uses) with the WebGL renderer + Unicode 11 addon, vanilla TypeScript, Vite. No UI framework.

On Windows the installer ships one prebuilt, MIT-licensed runtime — a modern ConPTY host (conpty.dll + OpenConsole.exe) for clean terminal resize. Voice input’s whisper.cpp runtime is not shipped (it would add ~150 MB); it’s an opt-in download covered on the voice prompts page.

Loomux is MIT-licensed. This site documents what ships on main; the source of truth is the code.

This site uses Just the Docs, a documentation theme for Jekyll.