# Dailist

![logo](assets/logo.png)

An executive list task manager GUI based on todo.txt

<a href="https://dailist.ser1.net">Dailist</a> © 2025 by <a href="https://ser1.net">Sean E. Russell</a> is licensed under <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">CC BY-NC-SA 4.0</a><img src="https://mirrors.creativecommons.org/presskit/icons/cc.svg" style="max-width: 1em;max-height:1em;margin-left: .2em;"><img src="https://mirrors.creativecommons.org/presskit/icons/by.svg" style="max-width: 1em;max-height:1em;margin-left: .2em;"><img src="https://mirrors.creativecommons.org/presskit/icons/nc.svg" style="max-width: 1em;max-height:1em;margin-left: .2em;"><img src="https://mirrors.creativecommons.org/presskit/icons/sa.svg" style="max-width: 1em;max-height:1em;margin-left: .2em;">

[![Build status](https://builds.sr.ht/~ser/dailist/.build.yml.svg)](https://builds.sr.ht/~ser/dailist/.build.yml?)
★ [Releases](https://downloads.ser1.net/software/dailist/)
★ ![Latest release](https://downloads.ser1.net/software/dailist/badges/latest_release.svg)
  
★ [Changelog](https://hg.sr.ht/~ser/dailist/browse/CHANGELOG.md?rev=tip)
★ [Software metrics](https://downloads.ser1.net/software/dailist/badges/METRICS.md)
★ [Issues](https://todo.sr.ht/~ser/dailist)
★ [Mailing List](https://lists.sr.ht/~ser/dailist)
★ [Credits](https://hg.sr.ht/~ser/dailist/browse/CREDITS.md?rev=tip)  
[![Go Report Card](https://goreportcard.com/badge/ser1.net/dailist)](https://goreportcard.com/report/ser1.net/dailist)
★ ![Code linting](https://downloads.ser1.net/software/dailist/badges/linting.svg)
★ ![Code security](https://downloads.ser1.net/software/dailist/badges/vulnerabilities.svg)
★ ![Markdown linting](https://downloads.ser1.net/software/dailist/badges/doc_linting.svg)
★ ![Unit tests](https://downloads.ser1.net/software/dailist/badges/unit_tests.svg)  
![Code coverage](https://downloads.ser1.net/software/dailist/badges/coverage.svg)
★ ![Code complexity](https://downloads.ser1.net/software/dailist/badges/complexity.svg)
★ ![ABC metrics](https://downloads.ser1.net/software/dailist/badges/abc_score.svg)
★ ![Lines of code](https://downloads.ser1.net/software/dailist/badges/loc.svg)

- [Features](#features)
- [Usage](#usage)
- [Install](#install)
- [To-do & known bugs](https://hg.sr.ht/~ser/dailist/browse/CHANGELOG.md#todo?rev=tip)

![](assets/screenshot.png)

The idea for this program evolved from a [Substack essay by David
Maciver](https://drmaciver.substack.com/p/using-a-list-to-manage-executive)
about using todo lists. That's what it is in a nutshell, but there's more to it.
Read the article if you want depth; the short version is:

- To-do lists can be overwhelming. The grow faster than they're completed, become filled with OBE tasks[Overcome By Events]{.sidenote}, and can themselves become impediments to making progress.
- Executive lists are mini-lists just for today.
- Every day you create a brand-new, empty list. You put things in it that you _could_ make progress on today.
- Critical is that they're _ephemeral_. Executive lists must not exist past one day. You _must_ throw them away at the end of the day.
- Also important is that you always put more things in the list than you know you can accomplish today -- but _only_ things you _could_ do today.

The trick to executive lists is psychological: the nature of how you use them
make them not overwhelming. You don't worry about the list, because after today,
it's gone! You don't worry about doing everything on the list because you
**intentionally** filled it with more things you know you can accomplish.

"But wait!", I hear you cry. "I put things in to-do lists so I don't forget
about them. Throwing the list away would mean those things are lost." That's
where this program comes in.

## Modified process

David doesn't address this specifically; there's a bit of hand-waving about "doing it your own way," which is fine. This is my way. Here's the paper version:

1. Have 2 little notebooks. One is the Big, Horrible, Infinite, Never
   Completable List of things you have to put on paper or else they nag at you.
   Things you don't want to forget, but can't do right now. The second is an
   Executive List. Every page is a day.
2. Start your morning by scanning the BHINCL and writing things down on the
   Executive List -- pick things it's _possible_ for you to work on today. This is
   your opportunity to break Big Items into smaller, completable items: "Paint the
   house" might become "Paint the bedroom." Put in more than you have time for, but
   don't go crazy. Depending on your lists, there might be 4-12 items on this list.
   It shouldn't be a huge chore to copy things over.
3. Do things on your Executive List. Should you get close to completing your
   list, go back to your BHINCL and copy over a couple more things.
4. If you need to add more things, **add them to the NHINCL first**, and if you
   can also do it today, add it to the executive list, too. Never, ever, only add
   things to the Executive list.
5. At the end of the day, go back and cross out in your BHINCL everything you
   completed today.
6. Go to bed satisfied that you Completed Things. Repeat the next day.

I love handwriting, but I do not enjoy copying text from one place to another.
Also, paper isn't searchable or filterable. Finally, unlike many people, I do
not get an endorphin rush from crossing things off lists; crossing things off
the BHINCL might just be desert to a list-crosser-off-er, but it's just tedious
to me. Also, I've long been a big fan of [todo.txt](http://todotxt.org/), so all
of my lists are digital, and I [wrote a series of fzf bindings and shell
scripts](https://hg.sr.ht/~ser/ddt/browse/tdp/README.md?rev=tip) to manage and
sync executive and big todo lists. This is fine for me; I'm happiest in a shell,
but it did not work for my wife, who needed a GUI.

dailist is that GUI. It's better than my shell scripts, because it manages both
scripts at the same time whereas my fzf bindings communicate only through the
lists: I can add stuff to the executive list, and if I cross things out on
either list I have to remember to refresh the other list. There's no real
communication between the programs.

dailist manages all that, and does the synchronization for you.

## Features

On top is a list box for the executive list. That starts each day empty. On the
bottom is the BHINCL. These lists are automatically loaded and all operations
that affect tasks in both lists are automatically synced.

- Two "new task" entry fields; use the top one and the task is added to both the
  EL and the BHINCL. Use the bottom one and the task is added only to the BHINCL
- You can copy tasks from the BHINCL to the EL with the click of a button.
- Tasks deleted from the EL are _only_ deleted from the EL. That's for when you
  realize "there's no way I'm getting to this thing today."
- Tasks deleted from the BHINCL are completely deleted, from both lists if
  necessary.
- Checking a task as "completed" marks it complete in both lists, regardless of
  where it's checked.
- Unchecking similarly marks a task as "uncompleted" in both lists.
- Clicking on the task text lets you edit the text; the result modifies both
  tasks.
- All changes are auto-saved, to both lists (if applicable): there's no "save"
  or "load" button.
- The file format is just a todo.txt file. Right now, dailist does not add any
  todo.txt features, such as priorities or metadata annotations; however, it
  _should_ preserve them if your BHINCL contains them. It will _not_ copy them
  to your executive list, as that information is superfluous for the EL. In any
  case, you can use an existing todo.txt as your BHINCL, or in fact work with
  the BHINCL using todo.txt tools.

This last point is important, because there are many programs that also use
todo.txt. For example, I can sync my BHINCL to my phone with
[SyncThing](https://syncthing.net/) and work with it using
[Simpletask](https://github.com/fleapower/simpletask-android).[Although, see the
note below about building for Android]{.sidenote}

## Usage

By default, the application uses `~/.todo` (on Unix-y systems, like Linux and
OSX, and wherever Windows thinks `$HOME` is). This can be changed by setting the
environment variable `$TODO_DIR` before running the program.

## Install

[Releases](https://downloads.ser1.net/software/dailist/) are available for
platforms for which they can be made. If you would like me to add a target,
[drop me a note](https://lists.sr.ht/~ser/dailist). I can **not** create builds for
MacOS, because gioui requires Xcode from Apple and I can't put that in the CI.
Or maybe there's a way, but I don't care to figure it out. There are builds for
some Linux architectures, Windows amd64 (is _anyone_ trying to run Windows on
ARM?), and Android. It's easier to cross-compile GUI apps for Android than
MacOS. That's boggles the mind.

The repository contains a .desktop file. Put `dailist` and `assets/logo.svg`
whereever you want it to live and change the `Exec=` and `Icon` lines to the
full paths of the files, and you should be able to double-click to run it. You
can also just double-click on the executable if you're in KDE, but you may get
some pop-up dialogs asking you to confirm you want to run it, and you'll be
missing the nifty logo that I labored so hard for 20 minutes over. In the
[Releases](https://downloads.ser1.net/software/dailist/) directory are RPMs, debs,
apk, and what not for various distros that will do all this for you.

Compiling it yourself is straightforward. You need Mercurial to check out the
project, or just download the tarball. You need Go to compile it. The project
relies on [gioui](https://gioui.org), which has few dependencies, but the first
compile can take a long time because it's linking into X and Wayland libraries.
While it's a longer than common compile for Go, it's still not more complex to
compile than running `go build .` in the project directory.

### Android

dailist can be built for, and runs on, Android. You will need to install the JDK, the
Android SDK and Android NDK, and the
[gogio](https://pkg.go.dev/gioui.org/cmd/gogio) command. Getting Java and the
Android SDK and NDK set up on your machine is highly dependent on your
distribution, but assuming you get that done, installing gogio is easy:

```
go install gioui.org/cmd/gogio@latest
```

Once you have that installed, building an apk is also easy. The icon needs to be
in PNG format; the `cairovg` command from python-cairo or svg2png commands can
do this (as can convert and a half dozen other programs); Android wants it to be
48x48 image:

```
cairosvg --output-width 48 --output-height 48 -b white -o android.png assets/logo.svg
```

Then, to compile, I use this command (the version doesn't really matter since it
doesn't make it into the actual asset):

```
gogio -target android -buildmode exe -icon android.png -o dailist-0.0.1.apk .  
```

Assuming you can plug your phone into your computer, tell your phone to let the
computer control the phone then install the apk with `adb`:

```
adb install dailist-0.0.1.apk
```

Or, copy the apk to your phone and install it from the file browser. It looks
just and functions just like the desktop.

I do not have a Mac or Windows machine; the gioui docs say that `gogio` can be
used to cross-compile for other platforms, but if you're building _on_ one of
those machines, I suspect `go build` will work.
