Last weekend I pushed up code for a TOP SECRET todo program I’ve been using for a couple years called Planfile:

https://sr.ht/~dvshkn/planfile

It’s a simple TUI program written in Rust for recording each day’s tasks that need doing into plain-text .plan files. And okay okay, it wasn’t exactly top secret, but being a Rust amateur I thought the code was too sloppy to put out there publicly. That kind of fear tends to be a paper tiger, though, especially when said program proves itself useful in real life. So here it is!

The meat of Planfile is not the code itself. The code just automates what could still be performed manually with a series of disciplined text files. It’s the file format and the process that is important. To demonstrate this let’s consider a hypothetical scenario where I use Planfile over the course of two different days.

An Example

Let’s say that it’s morning on 2025-3-14, which is a Friday. I run planfile for the first time in a new folder causing it to create a 2025-03-14.plan file. Inside I enter the following items:

> === dev tasks ===
_ fix timezone issue
_ add new event type
_ update packages

> === errands ===
_ grocery shopping
_ exercise

These are the things I want to get done today, but what is actually happening here? The _ at the start of many of the lines denotes that they are open tasks, and the lines starting with > are static note lines.

Now let’s fast forward to the evening after I have finished some work. I run planfile again which re-opens the same 2025-03-14.plan file. I now update my items like so:

> === dev tasks ===
* fix timezone issue
x add new event type
t update packages

> === errands ===
t grocery shopping
* exercise

Even more characters! The * in front of the timezone and exercise tasks means that those tasks are now complete. The t characters mean that I am pushing those tasks off until tomorrow, and the x means that I am deciding to not do that task.

Alright, let’s fast forward once more in our scenario to the following Monday morning of 2025-3-17. I run planfile again in the same directory as before, causing the creation of a new 2025-03-17.plan file for today, and Planfile also detects 2025-03-14.plan as the most recent previous planfile. The contents from last Friday’s planfile are cleaned up and copied into today’s file which now looks like the following:

> === dev tasks ===
_ update packages

> === errands ===
_ grocery shopping

All of the previously completed/abandoned tasks have been removed for me, and the tasks marked for tomorrow have been converted to open tasks. Also, as expected all of the note lines remain unchanged. Convenient!

Fits Like a Glove

Ultimately this system works for me because it gives me a way to push off tasks into the future and mentally offload them. It feeds my procrastination habits in a structured way. And I can still be confident that procrastinated items won’t get lost because having a separate file per day creates a nice history trail.

This style might not be for everyone, however. There’s no shortage of todo list apps out there, and yet it’s still a struggle finding one that works for your habits. For this reason I think it’s a great exercise for any programmer to try writing their own todo list program. Even if you eventually go back to a different app or decide to go all the way back to pen and paper you might learn some things about yourself along the way. Consider it!