Fallow
A to-do app that does calculus so you don't have to.
Try it → — no account, no server, works
offline.
Fallow answers a question every productive day poses: you have N tasks and only
so many hours — how should you split your time to get the most out of the day?
Instead of guessing (or splitting time equally), Fallow models each task's
productivity curve and solves for the time allocation that maximizes the
quality of your worked hours, subject to your real limits: the hours in your
day and how much mental and physical energy you can actually sustain.
It started as a faithful, over-engineered implementation of the
Zenith Gradient Algorithm
and has since revised the article's math where it didn't hold up (model v2),
extended with a dual energy-pool model, context-switching costs, and a
personalization loop that learns your constants from measured data.
MATH.md is the authoritative record of the implemented math —
every formula, derivation, and deviation from the article, with rationale.
The idea in one picture
For any task, productivity over time isn't flat — it starts at some initial
level, ramps up as you get into the zone, peaks at flow state, then decays
as you tire:
p(t) = (a·k·t + p₀) · e^(−kt) k = (1 − p₀/a)/ϕ
Each task is described by three things you feel intuitively:
- Effort / difficulty (
E) — how demanding the task is
- Enjoyment (
β) — how much you like doing it
- Time to flow (
ϕ) — how long before you hit the zone
These shape the curve: enjoyable, low-effort tasks start productive
(p(0) = p₀); hard ones start slow but peak higher. There's a mathematically
optimal point to stop each task — between 1.5194×ϕ and 1.7933×ϕ depending on
the task, and earlier still while Fallow is unsure of your ϕ — because working
past it makes your average productivity for that task fall.
Fallow takes your whole task list and finds the allocation ⟨t₁, t₂, … tₙ⟩ that
maximizes the importance-weighted sum of average productivities. Plans are built
in 15-minute blocks: greedy marginal analysis over block values, with an
exhaustive search over which tasks deserve funding at all once context-switch
costs are charged. Against your hours alone that is exact for up to 12 tasks,
and past that whenever your day, list and switch cost together keep the search
bounded; once the energy pools bind too it reaches the optimum on ~94% of days
and lands within a few per cent on the rest. Then Fallow reports how much better
that is than an equal split. (Full derivations: MATH.md.)
What Fallow adds on top of the article
- A revised curve and per-task stopping times (model v2). The article's
curve never decays below its starting level — no burnout tail — and gives a
task that is slow to reach flow a higher peak; v2 starts at
p₀, decays to 0
and holds the peak independent of ϕ, which makes the optimal stopping point
task-dependent (1.5194–1.7933 × ϕ) instead of a universal constant. See
MATH.md §2–3.
- Dual energy pools. Cognitive and physical fatigue are separate systems.
"6h of coding" saturates your ~4h/day of intense mental work, but "4h coding +
2h gym" fits — the physical hours draw on a different pool. The allocator
solves a three-constraint problem (time + cognitive pool + physical pool),
so plans never schedule an unsustainable day.
- Context-switching costs. Every task you juggle costs ~15 minutes of
overhead (grounded in attention-residue research). Fallow charges switches
only between tasks that actually get time, and will drop a weak task when
the switch it costs outweighs its value — decided by comparing funded-task
subsets exhaustively wherever that search is affordable. It also tells you
what that charge is doing: how many hours of today it reserves, and what the
same day would be worth if your switch cost were nothing, or double what you
declared.
- Personalization from your own data. Log how long a task really took to
reach flow (the ⚡ button, stopwatch-style) and Fallow refits your personal
constants (
c₁, c₂, c₃) with a Bayesian linear regression — anchored to the
default constants, sharpening as you log more, and aware of how uncertain
its own predictions still are.
- A dashboard of derived metrics. Fallow Gain, Burnout Risk, Flow Coverage,
Cognitive/Physical Load, Energy Balance, Friction Index, Recovery Ratio, and
more — each computed from the same underlying model.
- Suggested run order. Alternates cognitive and physical tasks so the
resting energy system recovers while the clock keeps running.
- History & routines. Sessions are saved per day (browse and correct
past days) and you can save task templates as reusable routines. Everything
lives locally in IndexedDB — no account, no server.
How you use it
- Add tasks. For each, set physical difficulty, mental difficulty, and
enjoyment on 1–10 sliders, and optionally an importance (low, normal
or high). Start typing a title you have rated on an earlier day and it
appears in a list under the field — pick it and all three sliders come back
the way you last set them, still yours to adjust.
- Set your available hours for the day, and optionally tune your
cognitive/physical capacity pools and switch cost.
- Fallow suggests how many hours to give each task, what order to do them in,
and surfaces a live dashboard of what your day looks like.
- Optionally log your actual time-to-flow on tasks to personalize the model.
The app in one page
Four screens, and the whole dataset is IndexedDB in your own browser — no
account, no server, works offline.
/ — today. The task list and the plan it produces: hours per task,
priority, suggested run order, stopping times, and the metric dashboard. Which
day you are looking at comes from the URL — /?date=YYYY-MM-DD opens a past
day to correct or a future one to plan ahead, and anything invalid falls
back to today. Deletions are undoable from a toast rather than guarded by a
confirm dialog./calendar — the same days as a month or week grid, each planned day
linking back to itself./analytics — what actually happened. Stats and charts across your stored
days, a range toggle, plan adherence against what was planned, and the
calibration history: every time-to-flow and drain measurement, correctable and
deletable./energy — the Energy Lab. The model with its lid off: the constants
fitted from your logs and how sure it is of them, per-task what-ifs against
the real plan, and the button that resets its parameters to the defaults.
The nav menu carries the data controls from any page — export a backup file,
import one back, or delete everything. Theme, language (five translations) and
the animated scenery are per-browser settings.
Tech stack
The productivity math lives in
src/lib/business/model/zenith.ts (pure,
dependency-free functions — derivations in MATH.md) and the
task/dashboard logic in
src/lib/business/model/metric/calculation.ts.
Architecture, conventions and contribution rules: AGENTS.md —
the brief, which routes to the per-area rule files.
Getting started
npm install
npm run dev # start the dev server (add -- --open to open a tab)
Other commands
npm run build # production build
npm run preview # preview the production build
npm run test # unit tests (vitest) + e2e (playwright)
npm run test:unit # unit tests only
npm run check # svelte-check type checking
npm run storybook # component explorer on :6006
In Docker
No node or npm on the host; make wraps docker compose.
make dev # dev server with HMR on :5173, source bind-mounted
make deps # after a package.json change: rebuild + renew node_modules
make test # check + lint + depcheck + server unit tests
make e2e # browser unit projects + Playwright e2e → test-result/
make prod # adapter-node production build on :3000
Credits
Based on
"How to Over-Engineer a To-Do App: The Zenith Gradient Algorithm"
from The Quantastic Journal.
License
Fallow — a to-do app that solves for the optimal split of your day.
Copyright (C) 2026 Shadi
This program is free software: you can redistribute it and/or modify it under
the terms of the GNU Affero General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option) any
later version. See LICENSE.
It is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE.
