TreeSheets: a hierarchical spreadsheet for people who outgrow outliners

What problem TreeSheets solves, and who it is for

A spreadsheet forces every relationship into a row and a column. A mind mapper lets you nest freely but gives you almost no structure. TreeSheets sits between them: a document is a grid of cells, and any cell can itself contain a grid. The README describes it as a hierarchical spreadsheet and positions it as a replacement for spreadsheets, mind mappers, outliners, PIMs, text editors and small databases. That list is unusually broad, and it is also the clearest statement of scope: the tool is for organizing data, not for calculating over it.

Who actually benefits? People whose notes have depth. Todo lists where each task carries sub-tasks and notes. Requirements gathering where a feature has acceptance criteria. Brainstorming that later needs to be sorted into a plan. If your data is flat, a spreadsheet is a better fit and TreeSheets will feel like extra clicking. If your data is a tree but you keep drawing it in a grid, this is the tool that stops the translation.

How the hierarchical spreadsheet works

The README does not document the internal data model, so the architecture has to be read from the repository layout and from the described behaviour. The source lives in `src`, which the README describes as dense, terse and lightly commented, written for a single author rather than a team. That is a real constraint if you plan to send patches: there is no contributor guide in the repository, only the note that the code is small and has no copy-pasting or over-engineering.

What is documented is the agent interface, and it is the most interesting mechanism in the project. Starting the binary with `-a` opens a local, token-authenticated socket that lets an external process run Lobster script against whatever document is currently open, and read the result back. On macOS and Linux that is a Unix domain socket at `/tmp/TreeSheets-agent-<user>.sock`; on Windows it is a TCP socket on `127.0.0.1`, on a port chosen at each launch and written to `%TEMP%\TreeSheets-agent-<user>.port`. The token sits at the same path with `.token` appended. The wire protocol is newline-delimited JSON, documented in the bundled skill's `SKILL.md`, which means you do not need a TreeSheets-specific client library to talk to it.

Off by default and local-only is the right default for a feature that executes script against your open document. The trade-off is that the port is not fixed on Windows, so any external tool has to read the `.port` file rather than hardcode a number.

Installing TreeSheets and opening a first document

The fastest route is a pre-built binary. The README points at the Release section of the GitHub repository for Windows, macOS and Debian-based Linux packages, and notes that the Debian packages are built on `ubuntu-latest` through the GitHub Actions runner, so they may or may not install on other Debian derivatives depending on whether the required dependency packages exist there. If you use Flatpak, the README gives a Flathub app id instead:

flatpak install flathub com.strlen.TreeSheets

Building from source is a CMake job, and the README is explicit that you are expected to know C++ and compilers already. Clone, configure, then build. The configure step needs the Visual Studio C++ compiler on Windows:

cmake -S . -B _build -DCMAKE_BUILD_TYPE=Release
cmake --build _build -j

Packaging is a separate target, `cmake --build _build --target package -j`, which produces a ZIP and a Nullsoft installer on Windows, a disk image on macOS, and a binary Debian package on Linux. On Windows you append `--config Release` to the build command. If you do not have wxWidgets installed separately, the README suggests setting `wxBUILD_INSTALL` and `wxBUILD_SHARED` to off so wxWidgets is built statically inside the TreeSheets project.

Once a build exists, the first useful thing to try is the agent mode, because it is the part you cannot get from a screenshot:

TreeSheets -a

After that, check that `/tmp/TreeSheets-agent-<user>.sock` (or the `%TEMP%` `.port` file on Windows) exists. The README warns that if `-a` produces no socket or `.port` file, your build predates the feature. That is the check to run before wiring anything else to it.

Where TreeSheets is the wrong tool

The README's own comparison list is the warning. Calling something a replacement for a small database invites the question of what happens when the database grows, and the README never claims transactions, concurrent writers, queries or referential integrity. If your data needs any of those, a hierarchical document is the wrong container and you will end up exporting to something else.

Collaboration is the second gap. Nothing in the README describes multi-user editing, sync or conflict resolution. The agent socket is explicitly local and per-launch authenticated, which is the opposite of a sharing mechanism.

The third limitation is the source itself. The README says the code was never intended to be used by more than one person and that it is dense with few comments. That is honest and it is also a cost: reading `src` to fix a bug will take longer than the file count suggests, and `TODO.txt` is described as random notes rather than a roadmap, so you cannot plan against it.

Finally, platform reach. The README covers Windows, macOS and Debian-based Linux, plus Flatpak, and mentions the Windows build running under Wine on Linux for the agent feature. There is no Android or iOS client in the README, despite what people search for.

TreeSheets against outliners and mind mappers

The obvious alternative for most users is a two-pane outliner, where a single tree of items sits on the left and notes for the selected item sit on the right. That model is easier to learn and easier to print. Its limit is that a node has one parent and one place; you cannot put the same item in two contexts, and you cannot lay sibling items out in a grid to compare them.

TreeSheets takes the other approach: structure is spatial as well as hierarchical, so a cell can hold a sub-grid and you can arrange items side by side inside a single parent. The README sums the difference up as being like an outliner but in more than one dimension. For a comparison table that also needs nesting, that is a real advantage. For a plain meeting-notes tree, it is overhead you will feel every time you move something.

A conventional spreadsheet is the other alternative, and here the difference is sharper. A spreadsheet gives you formulas and a flat, uniform grid. TreeSheets gives you nesting and no documented formula engine. If your work is arithmetic, stay where you are. If your work is structure, the flat grid is what is slowing you down.

Maintenance, licence and what upgrading costs you

The repository is not archived, and the last push was on 2026-09-23, with releases 3433, 3434 and 3435 all dated within two days of each other. That pattern suggests frequent small releases rather than a slow cadence, though the README does not describe a release policy or a support window, so you should treat each build as a snapshot rather than a version with guarantees.

The licence is Zlib, per `ZLIB_LICENSE.txt` at the repository root. Zlib is a permissive licence, which in practice means you can redistribute and modify the code with few conditions, but this is not legal advice and the exact obligations are in that file. Nothing in the README discusses commercial support, so plan on self-support through the Discord channel and the Google group it links.

Upgrade cost is low if you use binaries: install the new package and open your document. It is higher if you build from source, because the build depends on wxWidgets and on CMake behaviour that differs per platform, and the README's packaging table shows four different output formats. If you pin a build, pin the whole toolchain with it. The agent socket is the one interface that could break between versions, since the README ties its presence to whether your build includes the feature at all.

Editorial conclusion

Adopt TreeSheets if your data is genuinely hierarchical and you are tired of flattening it into rows, or if you want a local document an AI agent can script over a socket. Skip it if you need a relational store, collaborative editing, or a mobile client: the README lists Windows, macOS and Debian-based Linux packages only, and the Android search term has no answer in the repository. Before you rely on it, open a real document, save it, and confirm the file round-trips, then try TreeSheets -a and check that a socket or a .port file appears, because a build that predates the agent feature will silently start without one.

Frequently asked questions

Official sources

1. aardappel/treesheets on GitHub
2. Issues
3. License: Zlib
4. README
5. Releases