API reference

Manages sessions, windows, and panes on a tmux server.

Which tmux server incarnation a handle or batch may act on: the pid tmux reports, and its start time when known, since a pid alone is reusable — a tmux started on the pid of one just probed, as a container's first processes often are, would otherwise answer as if it were that server.

What a server needs to know before it runs anything: which tmux, which server, which config.

Which tmux server to talk to.

Which tmux server a handle belongs to.

One tmux session, as one capture saw it.

Assembles the pieces Server#newSession(SessionSpec) needs before tmux has a session yet.

A tmux session id, such as $0.

Resolves a caller-given session name to the id tmux keeps it under.

How a session should be made.

Typed fields of Session, for building an expression that can be read as well as run.

One tmux window at one of its positions, as one capture saw it.

A tmux window id, such as @1.

Where a window sits in one session.

A window's layout as tmux reported it, in whichever of its two forms it used.

Where a new window is inserted relative to the current one.

How a window should be made.

Typed fields of Window.

One tmux pane, as one capture saw it.

The line typed at a pane's shell to run one command to its end, and how its output is read back.

Tracks pending and recently submitted input under each server incarnation and pane id.

Which sides of its window a pane touches.

A tmux pane id, such as %2.

One writer at a time for a pane's keyboard, paste, and shell run.

Where a pane's top-left corner sits in its window, in terminal cells.

How a command run in a pane with Pane#run() ended, and what it printed.

How big a new pane should be.

What runs in a new pane.

Polls a pane on a timer for Pane#awaitText() and Pane#await().

Typed fields of Pane.

One attached tmux client, as one capture saw it.

What a client was looking at.

Typed fields of Client.

The tmux hooks at one scope.

A tmux option and the Java type its value reads as.

The server's key bindings, in one key table or across all of them.

One tmux paste buffer, as a listing described it.

The tmux server's paste buffers.

How big something is, in terminal cells.

Which way to move or grow something.

tmux's restricted JSON grammar and layout cells, for pre-mutation workspace validation.

One of tmux's built-in pane arrangements.

Which layout names are safe to hand to tmux.

Where a new pane goes relative to the one being split.

How a pane should be split.

The environment tmux gives to processes it starts, at one scope.

What tmux tells a program running inside one of its panes.

A released tmux version, ordered the way tmux releases are.

A sequence of tmux commands where each one acts on what the last one made.

The commands this tmux knows, read without starting a server to answer.

The server's own message log, newest last.

Decodes tmux's printed output against the version the server actually reports, framed with process-local markers so a reply is read back exactly whatever quirks that version's own printing has.

The server's command-prompt history.

A shell command run by tmux, and a tmux command chosen by a shell command's exit status.

How certain the transport is that tmux applied a request.

Whether running a request twice leaves tmux as running it once does.

Receives one OperationReport after each command.

One command a transport finished or failed to finish.

Turns a drained pipe into lines while preserving tmux values.

The default transport: one child process per call, drained by a bounded pool of platform threads.

Runs one tmux command and blocks until it has an answer.

A tmux client that stays attached and answers one command at a time.

Reads bounded physical lines from a control client's byte stream.

Frames control-mode replies and encodes requests for tmux's command parser.

One command's reply in control mode.

Owns the process-pipe write and the FIFO that attributes replies to requests.

One step in a control subscription.

Pulls events volunteered by one control client.

What a control-mode notification says, typed, for matching on.

Terminal output tmux pushed without being asked.

Decodes a subscriber's raw UTF-8 output independently of other subscribers. Incomplete characters wait for the same pane's next chunk; malformed bytes become \xHH escapes. Call #reset() after each subscription gap and #finish() at termination. Confine an instance to one reader.

Starts a long-lived tmux process in a transport's realm.

A listing template and the reader for the rows it produces.

The token this process marks its own text with.

Values handed to a tmux argument position that expands formats.

Cardinality with the ambiguity removed.

Lowers a FilterExpr to a tmux -f format when every node is one tmux can apply.

The versioned wire form of a filter expression.

What a document's field and relation ids mean.

A named, kinded accessor.

Typed field handles.

The scalar comparisons an expression can hold. Evaluation stays a total switch.

A filter that is both runnable and readable.

Retains metadata and handles from one authenticated server capture.

What part of a pane to read, and how.

A client as one capture saw it.

A pane as one capture saw it.

A live copy of one tmux server's sessions, windows, panes and clients, rebuilt whenever tmux announces a change.

One tmux hierarchy, as it was at one moment.

A session as one capture saw it.

One tmux winlink: a window as it appears in one session, at one index.

A window as one capture saw it, at one of its positions.

Reads a whole tmux server into one snapshot.

Why a wait for text on a pane ended.

Discounts input recorded by this library when reading a pane's output.

Applies a validated workspace as one session and attempts to remove it after a failure.

Converts the supported YAML shape into immutable workspace values.

One tmux invocation: how to reach the server, then the commands to run there.

A lookup that required exactly one match, or at most one, did not get it.

tmux ran a command to completion and refused it.

The control client ended, and anything reading from it will not resume.

The request did not complete, with how certain it is that tmux applied it.

The root of every operational failure this library raises.

tmux answered, and the answer did not have the shape this library asked for.

The server answered, and the session, window, pane, buffer or server incarnation a handle addresses is gone.

Text this JVM cannot hand to tmux intact, with no route left to send it by.

The running tmux does not have something the call asked for.

A document could not be read as the expression it claims to be.

A handle was used after the io.github.libtmux.Server it belongs to was closed.

No tmux daemon answered on this endpoint.

What became of every operation in one batch.

One operation's own result within a batch.

What shape a facade needs to give one operation of the core API.

Something tmux volunteered, rather than an answer to a request.

The tmux options at one scope.

The value kind a field reads.

One completed invocation.

A mode a pane can be in, as tmux names them.

A tmux -C client of a FakeTmux, as the process a control client talks to.

One pane in a FakeWindow.

One session in a FakeTmux, holding its windows in creation order.

A tmux server that is not there, for testing code that uses this library without starting one.

One window in a FakeSession, holding its panes in creation order.

A command's flags and the words after them, read as tmux's argument parser reads them.

The part of tmux's format language the library sends: variables, comparisons, && and ||, ? conditionals, and the W: and P: loops.

Reads a command group the way tmux's command parser reads it: words in single quotes, a quote spelled '\'', a line break spelled "\n", commands separated by ;.

Owns the safe teardown of a tmux server addressed by socket name.

A session, one of its windows, and one of that window's panes: what a command is scoped to.

Gives each test its own tmux server and checks its exit during teardown.

The socket a fixture server is listening on.

Qualifies a carrier-owned endpoint before the first control effect.

What tmux printed on its error stream, as it appears in a failure's message.

A pin created only by carriers that own this filesystem.

What the supported daemons can do, and the release defects this library works around.

The tmux version check shared by command dispatch and control-client startup.

Feature boundaries for literal commands and the commands hidden by managed guards.

The UTF-8 boundary shared by process and control transports, in both directions.

Encodes a tmux command for each of the two parsers tmux reads commands with.

Owns bounded, idempotent termination of one process and its observable descendants.

Several tmux commands in one invocation, each with an outcome of its own.

What became of one operation in a batch.

Public for orchestration across processes or clients, such as the MCP server's pane reservations; not part of the surface a language facade mirrors.

Classifies one public method of the core API as a tmux operation of a given Kind.

One of tmux's wait-for channels, named once.

What the running tmux does with a session or window name.

Shared validation for the sigil-prefixed ids tmux hands out.

How a wait for text on a pane ended, and what the pane had shown by then.

Why a wait on a tmux channel ended.

The wire ids for this library's own entities.