Why everything is instant
Every click paints its real result in the same frame, from memory on your device. Saving to disk, syncing, search and AI run behind it, and the screen never waits for them.
An example
A “To do” view shows tasks that are not done, with a counter: “5 open”. You tick “Book dentist”. In the same frame, the task leaves the list and the counter shows 4.
The screen does not guess. A small copy of the engine’s rules, called the pure core, runs beside the screen. It is built from the same code as the engine, so its answer always matches. It applies the change, fills defaults, works out derived values (like a preset’s title), and filters, sorts and totals the rows on screen.
Formulas and dynamic defaults on the screen already run this way. When the app starts, it loads the pure core as a small WebAssembly file (code the browser runs almost as fast as the app itself). This never holds up the first paint: for the first moment, the old copy of the rules answers.
Saved in the background
The save itself runs behind the paint. The engine (the part of the app that owns your database) checks the change, writes it to disk and adds one line to the log: who made it, what changed, and when. That line is what makes Undo and history work.
If the engine refuses the change, the screen goes back to how it was and a toast says why. This is rare, because the pure core already applied the same rules.
Big collections
A screen only needs the rows you can see. So it can ask the engine for just those, a window: for example rows 1 to 100 of a Log with 30,000 entries, with the view’s filter and sort, plus the total for the scroll bar. When you scroll, it asks for the next rows. When anything changes, it asks again, so the window stays live.
The engine then reads only that collection, the sub-entries under it, and the few other rows it names. Formulas come with the rows, worked out by the engine, so a sum over sub-entries is right even when those sub-entries are not on screen.
The engine keeps a collection it has read in memory. When something changes, it reads again only the entries that changed, so asking for the window again takes a few milliseconds, not the time to read 30,000 entries. It also remembers the order of your rows until the next change, so scrolling and coming back to a screen do not sort everything again. Right after the desktop app starts, it loads your biggest collections in the background, so even their first visit is quick.
The desktop app still keeps your whole account in memory, which is faster for most accounts. But a collection with 5,000 entries or more shows its table, list and board through a window:
- The engine picks the rows and their order, with the view’s filter and sort. The screen no longer sorts every entry each time one changes.
- You see the first 100 rows. As you scroll near the end, the next 100 load by themselves. The last line says how many are left. For a Log of 30,000 entries it starts as “Show more entries (29900 more)”.
- A click still paints at once. An edit, a new entry or a delete shows from memory in the same frame, and the window catches up a few milliseconds later.
- A board groups the rows that are loaded, so its columns fill in as you scroll. Cards you placed by hand always stay in their column.
- A few filters the engine reads differently (“ends with”, Files, Related entries, a date filter in a view whose day starts late) keep that view on the old way: every entry, in memory.
Later the web app will use windows for every big account, so it never has to load it all.
What you never see
- A spinner or a loading skeleton.
- A button that turns grey while it saves.
- A dialog that waits for the network.
- A value that shows a guess and then jumps to the right answer.
The speed budgets
| What you do | Painted within |
|---|---|
| Click a place you visited before | 16 ms (one frame) |
| Open a place for the first time | 50 ms |
| Start the app, to your last screen | 300 ms |
| Save anything, on any app | the same frame; on disk within 5 ms |
The app’s start-up time does not grow with the size of your account. The hundredth save in a row feels like the first. No stage of the app ships if a click got slower.
Measured on a real account
We measured the new engine on a copy of a real account from the old app: 144 collections and 5,902 entries. The numbers below are for the engine on its own, on one Windows computer.
| What the engine did | How long |
|---|---|
| Bring in the whole account (27,435 changes, none refused) | 5.0 s, once |
| Open the database after a restart | 348 ms |
| Read the whole account for the screen | 79 ms |
| Save one value to disk, half of the time | under 1.6 ms |
| Save one value to disk, 19 times in 20 | under 2.9 ms |
| Search all entries, half of the time | under 2.6 ms |
| Search all entries, 19 times in 20 | under 6.8 ms |
So a save is on disk well inside the 5 ms budget, and the screen did not wait for it.
We also tested a made-up account of 90,000 entries. Opening the database takes about 30 ms, and a collection of a few dozen entries opens in about 10 ms. In a collection of 30,000 entries, the first 100 rows show in about 12 ms, scrolling to row 15,000 takes about 2 ms, and a save shows in the rows in about 14 ms, the save included.
Two things are still too slow there. Starting the app takes about 0.8 seconds, because it loads the whole account. And a big collection opened in the first second after start, before the background loading is done, takes about 0.65 seconds the first time.
Why the network never slows a click
Every read and every save happens against the database on your device. The network carries only finished changes to your other devices, plus things that are not your data: AI, timed automations on Pro, sign-in, buying, the Library, sharing, and data from services like Google Health. A slow or missing connection only delays when your other devices see a change.
A browser on a computer with the desktop app paints from memory in the same way. It saves through the link to the desktop app, which runs on your computer, not over the internet. So this holds offline too.