Shiftlists

A board for everything I have open. One column per list, notes stacked newest-at-the-bottom, shifting upward as the day fills them. Runs as a desktop app on macOS, offline, with the data on my own disk.

macOS desktop Electron TypeScript Offline Local JSON

GitHub repository ↗ Getting started ← All projects

The Shiftlists window on macOS: a Context selector with demo selected and + Context, Delete Context and + List buttons above four list columns titled Today, Reading, Shiftlists and demo, each with an Add note, action or task box at the bottom. — The board - one column per open list, sticky titles, newest note at the bottom. The Reading column here is collapsed. Hover to brighten

The idea

On any given day I have several work items, topics or themes open at once. Shiftlists puts each one in its own column across the screen, so the whole set is visible without switching windows or scrolling a single long document.

Each column grows downward as I add notes, actions and tasks, and stays scrolled to the bottom - so the newest entries are always on screen and older history shifts up out of the way. A list's title stays pinned at the top of its column whatever the scroll position, so I never lose track of which column I'm reading.

When a topic is done, I close its list and the remaining columns reflow to use the full width. It's designed to be left open on a second screen all day and referred back to, rather than opened, used and closed.

What it does

Horizontal board

Equal-width columns share the window. Close one and the rest reflow to fill the space. Drag a column's title to move it left or right.

Fills upward

New notes append to the bottom and the column stays scrolled there, so the latest items are always in view and the history shifts up.

Sticky titles

A list's name stays visible at the top of its column at any scroll position.

Contexts

Switch the whole board between home, work or any context you add. Each context has its own set of lists, stored in its own file.

Notes, actions, tasks

Type and press Enter to add; Cmd, Ctrl or Shift with Enter inserts a newline for longer notes. Mark items done, delete them, or collapse a whole list.

Offline and local

No account, no network. Each context is a plain JSON file under your user application-support directory.

Getting started

Shiftlists is a proof of concept at this stage: it runs from source rather than as a signed, packaged .app. You need macOS, Node.js 18 or newer, and - for the test suite only - Docker.

Clone the repository

git clone https://github.com/planetguru/shiftlists.git
cd shiftlists/poc/shiftlists

Run the app

run.sh installs dependencies, builds on the host, then launches the Electron window. There is no URL to open - this is a desktop window, not a web server.
```
./run.sh
```
Start with the demo context

On first run the app seeds a single context called demo, pre-populated with five example lists, so there is something to look at before you create your own. Use the selector at the top of the window to add a context, or to delete one - deleting asks for confirmation first, because it removes every list inside it.
Run the tests (optional)

Tests build and run inside Docker on node:18-slim, never on the host. The board's DOM logic is covered under jsdom; the model and the file-backed context store are covered in plain Node.
```
./run-tests.sh
```

Because it isn't packaged or code-signed yet, there's no installer to download. Running from source is the intended route for now; packaging is on the list.

Under the hood

Language: TypeScript on Node.js, 18 or newer.
Shell: Electron - a single offline window, no menu-bar or tray behaviour.
UI: Vanilla TypeScript with plain DOM and CSS. No component framework, no build-time templating beyond tsc and esbuild.
Data: One JSON file per context, written with Node's fs into Electron's per-user application-support directory.
Structure: A pure model layer with no DOM, filesystem or Electron imports, so the board logic and the store are testable in isolation.
Next: Optional cloud sync, so the same contexts follow me between two machines without copying files by hand. Packaging as a real .app. Keyboard shortcuts for the board.