Using Sinclair

Tabs, splits & layouts

Every pane in Sinclair is its own shell — a full terminal with its own process, scrollback, and working directory. You organize that work with tabs and recursive splits: stack related sessions side by side, nest them as deep as you like, and snap them into reusable layouts. This page covers moving between panes, resizing them, the tile presets, the sidebars, and typing into many shells at once.

Tabs

A tab is a workspace of one or more panes. Open a fresh one with ⌘T (new_tab). Move between them with ⌘⇧] for the next tab and ⌘⇧[ for the previous, or jump straight to a tab by index with ⌘1 through ⌘9 (goto_tab:N). To reorder the active tab, bind move_tab:DELTA — a positive delta shifts it right, a negative one left. Close the current tab with ⌘⌥W (close_tab).

The tab bar shows each tab's title, which by default tracks the focused pane's working directory; when that directory is a git repository, the current branch is shown alongside it. A background tab that posts a notification grows a small yellow attention dot so you can see at a glance which session wants you. Set a fixed label for the active tab with change_tab_title, and add the tab-title-show-host config option to keep the user@host prefix in the title (handy over SSH).

Tear a tab off into its own window. Drag a tab out of the tab bar and release it outside the window, and Sinclair re-homes that pane into a fresh window — the live shell keeps running, so nothing is restarted or lost. It's the quickest way to move a session onto a second display, or split one crowded window into two.

Splits

Inside a tab, split the focused pane to make room for another shell. Split to the right with ⌘D (new_split:right) and downward with ⌘⇧D (new_split:down); the full set is new_split:left|right|up|down. Splits are recursive, so each new pane can itself be split, nesting columns and rows to any depth.

Move focus directionally with ⌘⌥ plus an arrow key (goto_split:up|down|left|right), which jumps to the pane in that direction. goto_split:next and goto_split:previous cycle through every pane in order.

Resize by dragging a divider with the mouse, or nudge it from the keyboard with resize_split:DIR. Press zoom_split to temporarily maximize the focused pane so it fills the whole tab — it's a toggle, so the same binding restores the split. equalize_splits resets every divider in the tab to an even 50/50. Whichever pane is not focused dims slightly so the active shell stands out; tune that with the unfocused-split-opacity config option.

Tile layouts

Rather than splitting one pane at a time, a tile layout arranges several panes in a single step. Sinclair ships a set of presets:

• Two Columns and Three Columns — side-by-side panes
• Two Rows — stacked top and bottom
• 4-pane Grid — a 2×2 grid
• Main + Bottom — a large pane over a wide one
• Main + Right — a large pane beside a narrow sidebar pane

Apply any preset from the Layouts sidebar panel or the Workspace menu — both invoke tile:LAYOUT_ID. To keep an arrangement you built by hand, run save_layout: it captures the current tab's split tree as a named custom layout, stored under ~/.config/sinclair/layouts/. Saved layouts then appear alongside the built-in presets, ready to re-apply in any tab.

Sidebars

Sinclair has VS Code-style drawers on the left and right edges, each fronted by an activity bar of icons. Toggle a side with sidebar:SIDE[:PANEL] — for example sidebar:left opens the left drawer, and sidebar:right:relay opens the right drawer directly to the Relay panel. Triggering the action for the panel that's already active collapses the drawer, so the same binding flips it open and shut.

The built-in panels are:

Plugins can contribute their own sidebar panels as well — see Plugins.

Broadcast input

Toggle broadcast input with ⌘⇧B (toggle_broadcast) and everything you type is mirrored to every pane in the active tab, with a floating indicator to remind you it's on. It's the fast way to run the same command across a row of splits — restart a fleet of servers, tail several logs at once, or set the same shell option everywhere.

Git worktrees

A git worktree is a second checkout of the same repository on its own branch, in its own directory — so you can work on two branches at once without stashing or re-cloning. Sinclair turns that into a one-keystroke workflow: worktree_create:PATH runs git worktree add from the focused pane's repository, branching from HEAD, and opens the new checkout in a fresh tab already cd'd into it. Append @branch to name the branch; otherwise the path's basename is used.

# bind these in your config, or call them over MCP
worktree_create:../pr-1234@fix/login   # add + open a worktree on a new branch
worktree_open:../pr-1234               # open an existing worktree in a tab
worktree_remove:../pr-1234             # git worktree remove, when you're done

The same verbs are exposed over MCP and the single-instance socket (worktree_create, worktree_open, worktree_list, worktree_remove), so an agent can branch off an isolated checkout for a task and open it beside your work — see MCP & automation. Creating or removing a worktree also fires the worktree_created / worktree_removed plugin triggers, so a plugin can react (install dependencies, warm a build, post a note).

Read-only & restore

toggle_read_only locks a pane against input without closing it — useful for a long-running process or a log you want to watch without fat-fingering a keystroke into it. Re-running the action unlocks it.

Turn on the session-restore config option and Sinclair reopens the previous window's tabs, splits, and working directories the next time it launches, so you pick up exactly where you left off. A pane that was running a coding agent is remembered as one: on restore it relaunches the agent — resumed, reloading its own session rather than starting cold where the provider supports it (Claude Code today) — instead of dropping to a bare shell. Plain shells restore as before. The window-inherit-working-directory option makes every new tab and split open in the focused pane's current directory instead of your home folder, which keeps related shells rooted in the same project.