Introducing Fairfax, a fast, keyboard-first task manager made for Omarchy: plan your day, type tasks in plain English, and sync through your own git repo. Import those tasks from your other tasks managers, too!
https://t.co/GRS8m1Sj10
Thanks to the Omarchy community and especially @NixFred & @tcballard for the inspiration & motivation!
@AxialisSoftware Thanks. No, you don't need to close it. Click Install and Fairfax downloads, checks and installs the update, then quits cleanly and restarts on the new version.
Fairfax 1.1 is out, and it now updates itself. Fairfax is my keyboard-first task manager for Omarchy and Linux.
Once a week it checks GitHub for a new release. When there is one, a pill appears beside the title. Click it to see what's new, then install. It installs the same way you did: pacman, deb, rpm, AppImage or tarball. Releases are signed, and an update goes in only if its signature checks out. It's privacy-considerate and the checks can be turned off in Settings.
Behind that is praeco, my small updater for Linux desktop apps, https://t.co/gkPuKz93jC
Also in 1.1:
- Tasks with a future start date stay visible, marked "Starts 11 Mar"
- Tasks that link to each other show the link both ways
- Monthly repeats can land on the last day, last weekday or last weekend day
- The find bar searches notes too
Release notes & install: https://t.co/dt2qjh7TXe
Feedback very welcome!
Debugging story! When a window keeps losing focus on Wayland, record the focus events before you change any rules. A focus bug is often a handoff over time, not the wrong window owning focus, and a rule can't fix timing.
In Ofolder 1.0.1, clicks on the strip beside the dialog were refused on Hyprland with focus-follows-mouse: "the dialog is not the active window." My first fix, a no_follow_mouse rule on the strip, only changed which window took the keyboard. I reverted it.
Recording Hyprland's focus events showed the real sequence. The dialog got the keyboard 0.15s after a click on the strip, and the window under the pointer took it 0.8s later, partway through typing a path.
So the fix works with that timing. ofolder takes the keyboard for each group of keys and gives the pointer back 40ms afterward.
Ofolder 1.0.1 for Omarchy is out. It adds a little help to the save and open dialogs, inspired by Default Folder X on the Mac.
https://t.co/XkwObZ7IXF
https://t.co/zQ1jVETyoS
Ofolder adds docking action strips besides file dialogs with your favorite and recent folders, "new folder", go-to-folder, and previews selected pictures or videos. It works with Flea, Strata, and the GTK portal dialog, and doesn't change the code or config for any of them.
The fun part: this is a kind of experiment in enhancing live applications. Wayland won't let one app reach into another's window, so Ofolder sits beside each dialog rather than inside it. Flea's picker reports its folder and selection through IPC while Ofolder reads GTK and Strata through accessibility. When a dialog can't do something, Ofolder dims the related feature button. The 224 end-to-end tests run against the real dialogs.
Thanks to @thisisgm for Flea, which got me thinking about what could be possible with Ofolder, and for Flea's picker IPC, which lets Ofolder read the folder and selection directly!
Feedback very welcome, especially from anyone using a dialog it doesn't cover yet!
How Babbage got built, part 5: What I'd keep, and what I'd change
If you're building something that has to be right, with agents or without, here's what I'd do again with Babbage, and the one thing I'd do differently.
Keep the hard part on its own
Babbage's math lives in its own Rust crate, babbage-core, with no interface at all. The build fails if floating point or a UI toolkit ever gets into it. That's why the engine's 512 tests, which include every oracle line, run in about 23 seconds without opening a window. It's reusable too: babbage-core 1.0.0 is on https://t.co/MtqC9ZVmQf, so you can put the math in your own app.
If the hard part of your project can live apart from the interface, split it out first. Everything after that is easier to test.
Write rules that stop the guessing
The agents worked from a short goal file. A few lines in it did more for correctness than any single test:
- Every feature is checked against an independent oracle: "Never the Rust table checking itself."
- "Never weaken a check to make it pass. If a check is wrong, say so and why."
- "Where the maintainer's notes are silent on semantics, refuse and file a ticket. Never guess a value."
- "Counts in reports are measured, never recalled."
By release that added up to 87 tickets and 136 recorded decisions. My favorite: "0^0 is an error. No single convention is safe. Revisit if it bites." An honest error beats a confident guess, from a calculator or from an agent.
The goal file: https://t.co/neOD3smTyp
Ask for the trade-off, not the decision
When the time zone data turned out to be stale, the ticket didn't just pick a fix. It laid out four options, recommended two, and left the choice to me "because it trades repeatability against freshness." That's the split I want: the agents do the digging and the measuring, and I make the calls that come down to what I want the app to be.
Write down what your tests don't prove
Mutation testing breaks the code on purpose to see whether the tests notice. In Babbage, a few of those breaks survive, and none of them can alter an answer, like breaking a check that a later check repeats. Babbage's mutation record lists each one with the reason, and it ends with a section called "What this does not prove." A green build only tells you what it checked. Writing down the rest keeps you honest about the gap.
What I'd change: give the interface more time
If rebuilt Babbage I'd spend more time on the interface. I'm wary of overengineering, so I start light and build it out as I get a feel for how it's used. This time I may have started too light. Two days before release, the work was still polish: light themes, with a contrast rule for each one, a setup command so it fits in on Omarchy the same way Fairfax does, and a small pop-up window for one quick calculation.
Getting the math right felt like all that mattered, so that's where the work went. When the math is the hard part, it's easy to let the interface ride along. I'd start using &living with it sooner.
Thanks for reading along. I hope it was interesting, maybe even useful. If you try Babbage, tell me what it gets wrong. And please reply or message me with what you're building. I'd love to hear about it.
Babbage: https://t.co/mOWHWfFOox
Guide: https://t.co/BWGT1gyCmX
@jasona I’ve an M4 iPadPro and plugged in to inquire and Claude/Opus immediately noped out. I’d love to hear of any progress folks make. These are crazy powerful machines handicapped by a phone-based UX.
How Babbage got built, part 4: Wrong answers that look right
The worst bug in a calculator isn't a crash. It's a wrong answer that looks right. Here are three ways to catch them, each learned from a Babbage bug that did exactly that.
Fair warning: still nerdy, still about tests. If you're here for the calculator, it's at https://t.co/mOWHWfFOox
Move your inputs around
If your tests always put an input in the same spot, they're testing the spot as much as the input.
This is the date read as subtraction I mentioned last time. On the second day of the build, "2019-04-01" worked fine, but "(2019-04-01)" answered 2,014. That's 2019 minus 4 minus 1. The check that spots a date looked at the first four characters of the line, not the four where the date starts. Every earlier test put the date first, so every test passed.
Mutation testing found it, and the fix was one line of code. It came with the ISO Oracle, a Python program that writes 11,323 date and time lines and works out the answers with Python's own datetime. Of those, 5,289 put the date somewhere new: in parentheses, after spaces, after "0 days +". Run them against the commit before the fix and all 5,289 fail, while the other 6,034 pass.
So try your input in brackets, mid-line, and after something else. The fix: https://t.co/jxOkkUlBvv
Define your units once, exactly
If a unit can reasonably mean two things, pick one, write it down, and make every operation use it.
A few hours before the date bug, "$500/workday * 4 weeks" came out at $42,000. The right answer is $10,000. Babbage counted a workday as 8 hours and a week as 168, so four weeks became 84 workdays. Nice raise, wrong math. Each rule made sense on its own. Together they didn't.
The fix was one rule: whenever a workday is involved, a week is exactly five of them, and conversions, sums, products, comparisons and percentages all follow it. The Workday Oracle that came with it checks 9,000 lines across six different work-hours settings. That's the other half of the lesson: test the rule under more than one setting.
Don't let your oracle read your data
An oracle that shares your inputs will share your bugs.
Babbage carries its own copy of the time zone rules, so answers don't depend on whose computer you're on. The Zone Oracle read the same release of those rules, on purpose, so the two would agree. The catch: if the copy goes stale, they agree on the wrong answer. A small script compared that copy with the newest time zone data, week by week from 2020 to 2045. Morocco started to differ in late September 2026, and western Canada in early November 2026. So, this week.
That finding became a ticket, and about fifteen minutes later the app read the computer's own time zone files, kept its copy as a fallback, and gained the System Zone Oracle: 7,926 lines from Python reading newer files, a test that the newer rule wins, and a check that runs the real app both ways.
So check your data against a source your code doesn't read.
What it adds up to
None of these crashed or showed an error. Each gave a number you'd believe. All three were fixed days before release, and each fix came with an oracle that runs every time the tests do.
If there's one habit to take from this, ask what your passing tests have in common. Mine all had the date at the start of the line, one meaning of a week, and one copy of the time zone rules. Each of those hid a bug.
Next up is the last post in the series: what I'd keep, and what I'd change.
See you there, and may all your wrong answers be obvious ones!
Agreed, and Babbage has them. Property tests came with the first engine commit, in proptest (Rust's Hypothesis): commutativity, distribution, print-then-parse round trips and more. This post's fuzz test uses it too. Same limit, though: a property only checks rules you thought of.
How Babbage got built, part 3: What an oracle can't tell you
An oracle can check hundreds of thousands of answers exactly, but only for the questions it thinks to ask. On the second day of development, Babbage's 605k oracle lines missed three bugs that other kinds of tests found within 45 minutes.
Fair warning: this one's nerdy, and it's all about tests. If you're here for the calculator, it's at https://t.co/mOWHWfFOox
What an oracle is good for
Quick refresher from part 1: an oracle is a testing technique where a separate program writes its own tests and works out the expected answers on its own, so Babbage's answers can be checked against it. For a calculator it's a useful testing strategy because the answers are exact and you can have a lot of them. On the second day there were 19 oracles, all in Python, 14 built on Python's exact fractions. They covered arithmetic, logic, functions, percentages, money, finance, units, dates, workdays, times and time zones. The biggest, the Logic Oracle, had written 171k lines. Today there are 21 oracles and 662k lines, and the engine's 512 tests, every oracle line included, run in about 23 seconds.
Where an oracle falls short
An oracle only checks the sentences its generator writes. The Date Oracle had written 800 "workdays between" lines, and not one started and ended on the same day. It wrote 500 "date + N workdays" lines, and the biggest N was 400. The agents put it plainly in a commit message: "the oracle corpora only cover the phrasings their generators write." So nobody asked about June 5 to June 5, or June 5 plus 99,999,999,999 workdays. Both were broken.
There are two things to do about that: First, make the generator write the edges on purpose: the same start and end, zero, the biggest number the input allows. Second, accept that you'll never list every edge yourself, and add tests that don't depend on your imagination. That's the next section.
Three other kinds of tests, and what they're for
For the timings in this post, I reran the old and new code on an 8-core Linux box.
Mutation testing breaks the code on purpose and checks that some test notices. It shows you where your tests are blind. On the five modules that handle dates and time zones, the first run made 1100 broken copies, and 143 went unnoticed. It also found "workdays between June 5 and June 5" recursing forever, because one "<=" sent the same-day case back into itself. Rerun at the commit before the fix, that sentence dies with a stack overflow in 13 milliseconds and takes the whole program with it. After two rounds of new tests, a final run over every function that had still let one slip by made 273 broken copies, and 0 went unnoticed.
Fuzz testing throws random input at the code. With a time limit on every answer, it catches hangs, not just wrong answers, and hangs were a real risk here. "June 5 + 99999999999 workdays" counted one day at a time, and an optimized build took 150.7 seconds to answer. The fix skips whole weeks and answers in about 1 millisecond, roughly 130,000 times faster. The fix came with a fuzz test: 30,000 random sentences built from every word the date, time, zone and unit forms know, each with 5 seconds to answer, plus 30,000 random sheets of 1 to 5 of those sentences. That fuzz test still runs on every check, in 1.7 seconds.
Real-use testing means using the app the way a person would. Replaying example lines through a whole sheet found "sqrt(16)" answering 16, not 4, with no error. In a sheet, the function name was read as ordinary words and dropped. The fix pinned 13 lines across 10 functions so it stays fixed. Ten minutes later came a check that types 15 everyday lines into the real app and reads the answers back.
What it adds up to
Each of those bugs was the kind a user notices: a crash, a frozen window, a calculator confidently giving the wrong answer. All three were fixed days before the release, and each fix landed with tests that run on every build. The blind spots shrank too, from 143 unnoticed broken copies in the first mutation run to 0 in the last. The oracles keep hundreds of thousands of answers exact, and the other tests cover the questions nobody thought to ask.
If you're testing something with exact answers, start with an oracle. Then add mutation testing to see where your tests are blind, fuzz testing with a time limit on every answer to catch hangs, and real-use testing to catch what only shows up when a person uses it. Each one catches what the others can't.
It wasn't a clean sweep, though. A couple of hours later, mutation testing found a date being read as subtraction. The fix was one line of code, plus a new oracle that checks 11,000 dates in places the old tests never put them. That's in the next post.
See you there, and happy bug hunting. I mean, bug preventing!
For Omarchy folks: praeco hooks into omarchy update, so the apps it manages update along with the system, using the password omarchy update already asked for. #Omarchy
Praeco 0.4.0 is out, now checking signature. It's a small Rust library and command-line tool that lets Linux desktop apps update themselves from their GitHub or Forgejo releases. When a GitHub release carries a packslip bundle, praeco verifies it before downloading anything.
Release notes: https://t.co/VrqmkL7G5F
The signing is built on packslip: https://t.co/GWkvwJYh9D. praeco's own releases are signed with packslip's action, and the signed format and the verifier praeco embeds are packslip's too. Thank you to its authors, @jdxcode among them.
Releases without a bundle, and Forgejo and GitHub Enterprise sources, keep the SHA-256 check. Signing is never required.
It's still pre-1.0, so I'd welcome security feedback.
Good call, and the fix already covers most of it. When Babbage isn't on the PATH, setup now writes its full path, and the acceptance check covers both cases. The menu action ran with a bare PATH in a nested compositor and opened the window.
What's missing is your negative half: run the old command under that same bare PATH and watch it fail, so I know the check can catch the gap. That one's worth adding - thanks!
The fix: https://t.co/mDSBSQ1CsG
How Babbage got built, part 2: Defining done for agents
Agents finish the job they can check, not the job you meant. So the real work is writing "done" as something a test can fail.
Fair warning: this one's for people who build with agents. If you're here for the calculator, the link's at the bottom.
How to define done
You need three things: a written list of the work, a check for each item that fails until it's really built, and written rules for when the check can't decide.
How I defined it for Babbage
Five minutes after the first commit there was a 24-row v1 checklist with 2 rows done. Lines Babbage couldn't handle yet sat in skipped tests, so "cargo test -- --ignored" printed the to-do list. The same commit renamed a test whose name implied the unit and money lines worked. They didn't exist yet.
About an hour later came the gate. A row was done only when its answers matched an independent oracle ("never the Rust table checking itself"), every test passed, and mutation testing left no survivors in the code it touched. The rules were to never weaken a check to make it pass and, where my notes are silent, to refuse and file a ticket. Never guess a value.
The window got real checks too. One types two lines into the real app, waits for the autosave, kills the app hard, restarts it, and expects both lines back with their answers. Another makes sure "39" is actually lit on screen, not just in the app's state.
What it got me
Overnight, all 24 rows were built, unattended, plus a short list of tickets that needed my call. The gate also caught a fix that never happened. An agent's find-and-replace silently matched nothing because the formatter had rewrapped the file, so the test it was fixing still failed. New rule: a scripted edit has to prove it changed something.
Where done was too loose
Later that day, it turned out a test file had been committed empty, so the gate had been passing without running anything in it. Now the checks fail any test file with no tests. Later, the Omarchy setup passed every check against a fake home with stubbed commands, since my own rules kept agents off my real config. On my machine, its menu entries did nothing. Babbage wasn't on my PATH, and setup never checked. Green, and wrong.
So write the job down, make "done" something a test can check, and make sure the checks are actually checking. Then let the agents cook!
Babbage: https://t.co/mOWHWfFOox
@joeysim Software factory kind of thing; check out my post history. So my usage is traditionally automated. It appears with many smaller prompts which makes sense for testability and recoverability.
How about you?