A project in a file

Write a project down, with its tabs, panes and what each runs, and isc project open makes the whole thing in one go. Keep the file in the project's directory as .insensical.toml and commit it, and everyone who clones the repository gets the same project with the same command.

isc project open                      # the .insensical.toml in this directory
isc project open ~/code/shop          # the one in that directory
isc project open ~/layouts/shop.toml  # a file by name, kept anywhere

It prints the project as project:N and goes to it.

It prints the project as project:N and goes to it.

Two panes side by side. This is a whole file:

name = "shop"

[[tab]]
columns = ["nvim", "cargo watch -x test"]

One big pane and two stacked beside it. A list inside a list goes the other way, so inside columns it's a stack. size = 2 gives the editor twice the room of the stack. "" is a shell.

name = "shop"

[[tab]]
name = "work"
columns = [{ run = "nvim", size = 2 }, ["cargo watch -x test", ""]]

A morning's work. Two tabs, two agents each in its own directory, a floating pane, and a pane that starts minimized:

name = "shop"

[[tab]]
name = "work"
columns = [
  { run = "nvim", size = 2 },
  [
    "cargo watch -x test",
    { run = "claude", dir = "api", name = "api agent", front = true },
    { run = "claude", dir = "web", name = "web agent" },
  ],
]

[[tab.float]]
run = "lazygit"
at = [0.1, 0.1, 0.8, 0.8]

[[tab]]
name = "servers"
rows = [
  { run = ["sh", "-c", "npm run dev | tee dev.log"], dir = "web" },
  { run = "docker compose up", minimized = true },
]

What a file can say. Every key is optional. A key it doesn't know is a mistake, not skipped.

Where	Key	What it means
The project, at the top	name	The project's name. Without it, the project is named after its directory.
	root	The directory its panes start in. Without it, the directory the file is in. A path not beginning with / is taken from where the file is, and ~ is your home.
A tab, under [[tab]]	name	The tab's name
	front = true	This tab is in front. Without it, the first tab is.
	columns = [ ]	Its panes side by side, left to right
	rows = [ ]	Its panes stacked, top to bottom. A tab has columns or rows, not both.
	run, dir	For a one-pane tab without a list: what it runs and where. A tab with none of these is one shell.
A pane, in a list	"command"	The command, in quotes. "" is a shell.
	{ run = "command" }	The same, with room for the keys below
	dir	Where it starts: a directory from the root, or a whole path
	name	The pane's name
	size	Its share of the list's room. Size 2 has twice the room of size 1, which is the default.
	front = true	This pane has the keyboard. Without it, the tab's first pane has.
	minimized = true	It starts in the dock, with its program running
A list in a list	[ ]	Panes going the other way: rows inside columns, columns inside rows. Nest as deep as you need.
	{ rows = [ ], size = 2 }	The same when the group needs a size, or { columns = [ ] }
A floating pane, under [[tab.float]]	run, dir, name, front, minimized	As for any pane
	at = [x, y, width, height]	Where it floats, in parts of the tab from 0 to 1. Without it, [0.2, 0.15, 0.6, 0.7].
	pinned = true	It stays above floating panes that aren't pinned
	everywhere = true	It shows over whichever tab of the project is in front

A command is words, not a shell line. run = "cargo watch -x test" starts cargo with three arguments, and quotes keep a word whole. Nothing else means anything: no &&, no $HOME, no ~. For those, write run = ["sh", "-c", "make && ./serve"]. A pane closes when its program ends, as with isc run.

It asks before it starts someone else's programs. The first time you open a file, isc lists every program it would start, with each directory, and asks. Only y starts them.

• Your yes is remembered for that file at that path. If it changes, or you copy it elsewhere, you're asked again.
• --yes skips the question and counts as your yes for next time.
• With nobody to ask (a script, a pipe), an unapproved file isn't opened. A file that only opens shells isn't asked about.

Opening it twice doesn't make two. If a project with the file's name and root is already open, isc project open goes to it and changes nothing. --again opens a second one.

A mistake makes nothing. The whole file is checked first. A misspelt key, a wrong kind of value, broken TOML or a missing dir is reported with its line, and no tab is made:

isc: /home/me/shop/.insensical.toml, line 5: a pane has no `sise`. It has `run`, `dir`,
`name`, `front`, `minimized`, `size`. Nothing was opened

If the daemon refuses something partway, what was made is closed again and you're told why.

Saving one. Arrange a project the way you like it, then:

isc project save              # writes .insensical.toml in the project's directory
isc project save shop.toml    # or a file you name
isc project save -            # or prints it

It writes the project in front: tabs, panes, split sizes, floating and minimized panes, names, and which tab and pane are in front. A file saved in the project's own directory names no root, so it works for whoever has the directory. It won't overwrite a file without --force.

• Each pane is saved with the command it was started with. A pane started as a shell is saved as a shell, and if it's running something, isc project save tells you which pane so you can add a run.
• Not saved: the scratch pane, a zoomed pane, floating panes you hid, the project's icon, and what is muted.

In the window.

• Make a new project (Ctrl+Shift+N) in a directory that holds .insensical.toml, and the window opens it as the file arranges it. If the file starts programs, it lists each and asks. "Open as written" (Enter) opens the file. "Just the directory" (D) makes an ordinary one-shell project. Escape makes nothing.
• Your yes is shared with the command line, and a changed file asks again.
• "Open a project file" in the palette asks for a directory and opens the file in it. "Save this project as a file" writes .insensical.toml in the project's directory, asking first if one is there.
• A mistake in the file shows in a notice with its line, and nothing is made.
• The window always makes a new project, even if one from the file is open. A name you type is used if the file gives none.

Limits.

• The window opens and saves files on this computer only, and only .insensical.toml in a directory. For another machine or file name, use isc project open FILE and isc project save.
• The window doesn't tell you which saved shells are running something. isc project save does.
• A file starts 100 panes at most.
• With --host, the file is read here and the project made there. root must then be a whole path on that machine, and directories aren't checked first. isc project save needs the file's name there, and always writes root.
• A file can't keep a pane open after its program ends.