I’ve considered time tracking and I’ve tested several software solutions. Perspective matters - I’m a systems administrator, I prefer doing things through the command line, and my favorite programming language is Python. My recommendations will be biased. I also feel strongly about open source and free software, and I want full control of my own data. Solutions where I cannot download the source code is not considered, same if I need to send my data to some “cloud solution”.
In my previous blog post I described some general thoughts. In this blog post I will compare the software solutions I found. In an upcoming blog post I will drill down describing my experiences using two of them.
Executive summary
I’ve done some research on open source time tracking software. I have decided to follow up on ActivityWatch and Timewarrior, check if they can aid me with my timetracking needs, and I will follow up with experiences in an upcoming blog post.
Some projects seems abandoned. I don’t want to use software that isn’t actively maintained, so those are out:
- Hamster
- Timetrace
- App::TimeTracker
- selfspy
- activity_tracker
The projects below do have their source code open and can theoretically be set up locally, but it seems too complicated - the business plan is that you should sign up and use it as a “cloud service” from the provider:
- solidtime
- Cattr
I found three actively maintained CLI-solutions that allow the user to start/stop activity trackers (basically, log timestamps):
- Timewarrior
- Zeit
- Timetrap
From those three, Timewarrior seems to be the most popular as well as the one having most integrations available.
uair is a count-down timer rather than a stopwatch, probably not much suitable for time tracking.
ActivityWatch can quite effectively spy on your activities on your computer. It’s useful to get some statistics on what you’re spending most time on, but it may require a lot of configuration to create reports useful for filling out the accounting system. It also has stopwatch functionality. It has some rough edges as it’s under active development. While looking into ActivityWatch it also occurs to me that it should be possible to do time tracking in HomeAssistant.
Another solution worth commenting is Emacs org-mode - all planning and time tracking can be done from the editor, in a flat file, in a well-documented file format. Perhaps it’s the ultimate solution, perhaps not.
Timewarrior
Timewarrior is a CLI stopwatch time tracking tool, made in C++. Basically one enters timew start activity and timew stop activity and it will keep a database on when you worked at what - so basically the only “input” is manually entered through the CLI. Timewarrior seems to be actively maintained and is available under the extra repository on Archlinux.
Timewarrior does not use the word “activity”, it uses the word “tag”. More than one tag can be applied. From the tutorial I get the impression that this can be used for more detailed tracking. Working for customer ACME, doing actual programming in python on their AmazingApp? Then one may use the tags ACME,python,programming,AmazingApp. This way it’s possible to get reports both on how much time you spend programming python as well as how much time you spend working for customer ACME. Now, what if one pretends being busy in a video meeting with customer ACME, and at the same time doing work for customer EMCA? Or, working for ACME on a project where it’s needed to wait for some compilation or pipelines frequently, and working aside on EMCA while waiting for the pipeline runs? Would you bill ACME and EMCA with or without a fork? This all depends on how you choose to use it of course.
I’ve been testing it quite a lot. Sometimes I can stay focused and work on one and only one task for a longer time. More often I’m multitasking. My tasks often involves running a command, waiting some few minutes and see how it went. In the meanwhile I start up working on something else. Other times I get lots of interruptions. Those may be external interruptions like private communication, work emails, personal messages on Mattermost, but also “internal” interruptions in my line of thoughts.
I was juggling three different customers, private communications and brewing some tea in addition. Running timew start ... several times a minute is just too much work. Perhaps the concept of tags can be utilized - I could simply retag the period to cover all the things I was working with - but great care should be taken that one doesn’t end up bloating up the hours sent to the billing system.
There seems to be many extensions to Timewarrior. I can find iCalendar export and much more. Not all of it works, though. Since Timewarrior is a very simple tool, it’s easy to hack around it, I’ve already made quite some personal integrations. Getting data out of Timewarrior was much more complicated than anticipated, but I will cover that in an upcoming blog post.
Conclusion
After using Timewarrior for a day, I concluded that timew was not for me. After not using Timewarrior the next day, I concluded that Timewarrior is much better than nothing! I’ve resumed using it, and will sum up my experiences in an upcoming blog post.
Zeit
Zeit has a CLI tool made in Go. Development is active.
I tried installing Zeit on Archlinux, it happily installed a completely unrelated package with same name from AUR/GitHub. This is a minus - commands and package names should ideally be as unique as possible, and packages that can be readily installed through the distro is generally preferable to hand-installing something from GitHub.
The rationale of building yet another time tracking tool was that the author found no other tools that could import his existing data from some commercial time tracking software Tyme. And he would like a tool that was built in Go. That’s not very appealing to me (being a python programmer who has never used commercial time tracking tools).
Zeit is centered around a local database, and one is encouraged to make integrations that accesses the database directly. The database is BuntDB. This is probably great for go-programmers, not so great for everyone else.
Looking into the documentation of Zeit, it’s also centered around start and stop commands. Zeit does not have tags; it has two different entities, Projects and Tasks. Projects and tasks should be set up before starting the tracking. The tracking commands are also slightly longer. Project name and task name is an option rather than a positional argument. Projects and tasks should be set up in advance if I understand it correctly. Everything considered, it seems to be more effort to use it than Timewarrior.
It takes input from one other source - it can add git commit messages as notes to the time tracking - but only commits done in the right repository to the right branch at the right time. My usage is slightly different, since I’m frequently context-switching, at the end of the day I would like to scan through all my local git repositories and see if there are any commits there that does not match the tracking data, and adjust things based on that.
Conclusion
If you have used Tyme, if you like Go, if you have few projects/tasks you work on, if all your work is tracked in git, and if you don’t do a lot of context switching throughout the day, then Zeit is the tool for you. It doesn’t seem to be the tool for me.
The list of time tracking software is long, so I decided to move on.
Timetrace
Timetrace is also a CLI-based tool made in go - available through AUR on Archlinux. Based on the rate of commits over the last few years and the number of outstanding pull requests, I deem it to a dead project. I did test it out a little bit, but not as extensively as timew.
Timetrace also has the start-and-stop-based approach to time tracking. All time tracking should be related to a project. Projects should be set up before tracking time. It’s also possible to add tags to the recording. Timetrace has a binary “billable”-flag, that’s perfect for us since we’re frequently, but not always billing customers for work done. “Modules” seems to be the equivalent of “tasks”, and it’s optional to specify a “module”.
With Timetrace one has to explicitly end a task before the next can be started. IMO, that’s stupid. I much more like the timew philosophy that starting a new task would automatically end the previous task.
Timetrace makes one file per record, stored as $HOME/.timetrace/$date/$hour-$min.json. If you start, stop and start some tracking within the same clock minute, you’ll get an error.
Timetrace will utilize your favorite editor for editing old records. I believe using an editor to amend the time tracked during a day is “best practice”. However, timetrace edit will not help you doing that, it will merely allow you to edit the .json-files in the directory, one by one.
Conclusion
I don’t see timetrace having any killer features, the fact that one needs to stop a task before starting the next bothers me a lot - and it seems like an abandoned project, so I decided to move on.
Timetrap
Timetrap is built in Ruby. SQLite3 is used as storage backend. Development seems relatively active. AUR package out of date and failed with some dependency problem.
It features speed and ease of use by allowing shortcuts for all commands - an executable timetrap is installed, but also an executable with the ultra-short name t.
Timetrap uses a completely different terminology than the other tracking tools. It has “timesheets” rather than projects. One doesn’t start and end, one “checks in” and “checks out”. Context switching seems more complicated in Timetrap than the others as switching timesheet and checking in has to be done in two different commands - but at the other hand it has the concept of “autosheet”, the possibility to automatically choose timesheet. One has to select what kind of autosheet one wants to use globally. The default will read a dot-file from the directory the command is run from. For workflows that are entirely command-driven this makes good sense. If one knows Ruby, it’s also possible to make your own autosheet algorithm.
Timetrap can export it’s data in iCalendar format.
Conclusion
It didn’t want to start for me - I should probably have tried installing it through gem - but decided not to spend time on it. For people that are into gem and who do almost all their work from the command line it may be good.
App::TimeTracker
App::TimeTracker (GitHub is a tool written in Perl. It seems abandoned, last commit 4 years ago.
It looks interesting, and it has a plugin framework. The plugins included in the package integrates with RT, IRC and Git. These plugins seem cool, but possibly a bit hard-coded for the workflow of the company where it was taken in use. Utilizing the plugins, the start and stop commands would do this:
- Take the ticket in Request Tracker.
- Create a new local branch for the git repository in the current directory with branch-name copied from RT
- Post a message on IRC that the ticket is being worked on
- Post a message that we’ve finished working on the RT ticket.
- Export time usage to RT.
- (By default, do not auto-merge the git branch to master)
Storage backend is in a flat file. Users are encouraged to keep the file in a git-repository and sync it across devices if one is working from multiple devices.
I’m not much happy installing software that isn’t actively maintained, so I decided not to give it a spin.
Conclusion
App::TimeTracker would probably be worth looking into if it was actively maintained, and/or if one likes Perl.
solidtime
Solidtime is primarily a SaaS-product, but there is also a self-hosted variant that should be run under docker containers. It’s written mostly in PHP. Development is active.
Conclusion
I don’t want to “Book a demo”. I don’t want a multi-user time tracking tool, I consider the time tracking to be a private thing. solidtime looks complicated and enterprisely, it makes me scared. Next!
ActivityWatch
ActivityWatch (GitHub) is under active development, it’s written in Python. The latest release is officially available through AUR on Archlinux (but only as a binary package, and even that one had problems at my system - replacing Archlinux with NixOS would probably solve this problem). It has a server/client/sensor architecture - sensors collect data, the server receives them, and the client can visit a web interface. Data is stored in SQLite.
ActivityWatch has a very different approach to time tracking. The sensors (“watchers”) will spy on you and automatically collect information on what you’re working on. The default sensors monitors if you’re AFK or not and the current window title. Other sensors may be installed, including plugins for popular editors and browsers and even an Android sensor.
With all this data, it’s possible to go back to any point in time and tell exactly what you’ve been working with (at least as long as it’s covered by a watcher. Even the window title typically tells a lot if one is sitting by a computer). I haven’t tried making my own custom watchers yet, but I will, and I will follow up on that in an upcoming blog post.
ActivityWatch seems to be pretty beta, many things not working exactly as expected, but it does give some interesting statistics. It may give some hints on “what did I actually do during all this time”. Would it be possible to construct useful reports for what to put into the accounting system? I don’t know yet - but it is possible to do quite a lot of configuration on how to parse the data (some AI algorithm would probably be able to make sense of all the data collected). I will let it run for a while and play with it.
ActivityWatch may collect sensitive personal data. I’m fine with that as long as the data does not leave my computer and I have full control of it. While it’s intended to be used locally on your workstation/laptop, the server/client/sensor model makes it trivial to set up some central server and have data from multiple employees ticking in. I think ActivityWatch is fine for personal time tracking, but I’m absolutely horrified of the thought of ActivityWatch being used for monitoring workers during the office hours.
Conclusion
Out of the box, ActivityWatch is useless for creating the data that should go into the accounting system - but useful for giving shiny graphs of how you waste the time by the laptop. Perhaps the mere thought that the activities are being logged would work as a motivator to do useful work. My immediate usage of AW was to manually check up with it to adjust my Timewarrior logging - but that’s a bit silly. With enough customization and configuration it could probably shine through as the ultimate Time Tracker. I will play more with it and come up with my experiences in a future blog post.
HomeAssistant
HomeAssistant is a home automation software package built in Python. It has a completely different purpose than time tracking, but while looking into ActivityWatch, it occurs to me that those two packages does quite much of the same. It’s the same architecture - a web-based application receiving lots of sensor data (including things that may be considered personal data), and then it’s possible to work in the Web-UI trying to configure things and making sense of the data, including nice statistical overviews. Both comes with smartphone watchers that can spy on the smartphone, both offers calendar integration, etc. So I did a quick web search to see if anyone already does this - and indeed. Integrations exists with cloud-based time trackers. [In this blog post] someone made a physical “time tracking cube” which reports into HomeAssistant. There are also people tracking weather they are at work or not.
Conclusion
I’m not intending to fall into this rabbit hole, but HA can certainly be used for time tracking. Many of the sensors exists, and it should be possible to configure a bridge and let HA take sensor data from AW-watchers. If you’re heavily into HA and don’t want to spend time on AW, I would recommend looking more into this.
activity_tracker
activity_tracker is a A python package that can “log, analyze, and visualize when you were using your computer”. It can write data to a CSV-file and it can read the CSV-file and make nice-looking reports. With the last commit done three years ago, I’m not spending time on researching this - but it may be a much more light-weight tool than ActivityWatch.
Selfspy
This package is mentioned as one of the inspirations for ActivityWatch - but the last commit was made 10 years ago. Next!
Hamster
Hamster apparently has a dead homepage and an inactive github project
The amount of collaborators looks amazing - so it’s strange to see that the development of this project apparently has come to an end. The official web site is timing out as of 2025-05. Last commit to the “legacy” project is two years ago. A major rewrite project has the last commit five years ago. There is a warning that newer versions of the “legacy” project has deteriorating feature base, so if one still can use older versions, then do that. “The aim is to provide a new stable v3.0 release in the coming months (i.e. early 2020)” - and when reading that, it’s already 2025. I don’t find much information on how it is supposed to work - but from what I can understand it’s a GUI-based stopwatch-style time tracking application.
With the lack of information easily available, I got some help from an AI-search engine. “The main workflow involves switching your current activity in Hamster whenever you change tasks” - so basically, start/stop timestamp logging. “Fast and easy data entry with autocompletion for recent activities”. timew lacks tab-completion on used tags, that’s bothering me a bit. “Flexible grouping using @categories and #tags” - is it up to the user to figure out the difference between categories and tags, or does the documentation come up with examples on how it’s supposed to be used? “Graphical statistics and visual breakdowns of time spent on activities”. Lots of reports and exports. “Reminders and idle detection to help ensure accurate tracking”. “Written in PyGTK and uses SQLite for data storage”.
Conclusion
I was recommended Hamster. By all means, it probably works excellent for those out there that have been using it for years. For me, it looks very much like a dead end, I won’t touch it. Though, it seems like it’s supposed to offer both CLI and GUI interface, that’s a nice thing at least.
Emacs org mode
Org is a file format that can be used for very many things apparently, but also to keep track of task lists. When using the org mode in Emacs, it does have time tracking functionality. I believe it comes as a part of the Emacs package on Archlinux.
I started using Emacs decades ago, for a period I tried to become an “Emacs power user” - utilizing it not only for simple file editing, but also for emails, Usenet, trying to learn Emacs-Lisp, any much more, Emacs even comes with an integrated browser. Anyway, I thought Emacs-Lisp was just too confusing - I’ve considered switching editor several times, but out of habit more than compassion I’ve become pretty stuck, using Emacs for most of my editing tasks.
Integrating the tools for maintaining task lists with time tracking is a good idea - or, in this case, combining task lists and time tracking in the same document is a good idea. Using an editor for making sure the time tracking is correct is a good idea. I was asked to produce a project plan the other day and had no idea what file format I should use. org-mode would perhaps be the perfect tool for such a plan - and to keep track of the time spent. I most likely should spend more time looking into org-mode, but it doesn’t give me the perfect warm and fuzzy feeling, for one thing, to me it seems like a project without a clearly defined scope.
Conclusion
If you’re using org-mode for task lists, then you should consider using it for time tracking, too. If you want to write down a project plan, then org-mode is maybe something to look into. I have a bit of a problem grasping what it’s all about and how it may make my day more organized.
Cattr
Cattr seems to primarily be a SaaS-solution. It looks a bit less enterprisely than Solidtime. It includes integration towards GitLab and can be extended with custom plugins.
Conclusion
The SSPL license is a bit controversial, and the whole thing looks a bit too overwhelming for being used as a personal time tracking solution.
uair
uair is “an extensible pomodoro timer” written in rust. uair is basically a count-down timer. Rather than work for as long as it takes and then record the time spent concurrently, you proactively plan to work for a certain amount of time. I didn’t investigate if it can actually be used for time tracking or not, but if not it it should probably be easy to implement.
Conclusion
For people who have the possibility to work without interruptions for a planned amount of time and who subscribes to the “pomodoro philosophy”, it may be useful. While I haven’t tried tohe Pomodoro technique, it does not seem to fit my working habits at all.
My previous home-brewed tracking solution
While we had our previous accounting system, I made my own a time tracking system with “plugins” and “plugin configuration”. It would read data from all my git/SVN commits on all repositories, all my activity in our ticketing system and all the IRC-logs (particularly including the stopwatch commands mentioned), and I had intentions that it would read data from calendars too.
It would sort all the events in chronological order, I could edit the log. The system read the accounting codes from the project information in our CMDB, would convert the data into CLI-commands for registering things in the accounting system and ship it off after a final edit. If anything didn’t go through, I’d get a list of the commands that failed allowing me to redo it. I think it was a quite good system, though in practice of course not without problems.
One of the problems was that there was too much noise in the logs. A bigger problem was that I would run it too infrequently. The git plugin would do a git pull in all repositories it could find, causing excessive time usage - I think it’s important to run such a script every day. The biggest problem of it all was that the accounting system was replaced, this destroyed my whole workflow.
Final thoughts
I’ve done some research into more than ten different software for time tracking, and tested some of them. My conclusion is that there seems to be no time tracking software out there fitting my needs, and it may be that I will need to roll my own.
While the research didn’t come up with anything that perfectly fits my needs, it has been a nice experience. I have learned a lot from it, wisdom I will take with me when/if I make my own time tracking solution. I will come up with an upcoming blog post detailing my experiences with Timewarrior and ActivityWatch. While working on this I also replaced my swaybar to waybay. I’m not sure if that’s an improvement, but while being at it, I realised that both calendar reminders and time tracking should be easily available from the desktop status bar. And it should be integrated!
Having multiple interfaces to time tracking and some distributed or centralized storage backend would allow one to do timetracking across multiple devices, making it possible to do time tracking also when the laptop is a bit far away. Most of the tracking solutions are storing things in flat files, if they are put into a git-repository it would probably be possible to have a distributed storage. The App::TimeTracker even encourages such distribution. Anyway, I’m still thinking that a calendaring system would be a better storage backend. It would allow time tracking information to be recorded by any calendar application on any device - though unfortunately the iCalendar standard does not offer any way to make a separation between “events you’re planning to attend to” and “events you actually participated in”.
Image credits
xkcd strips Randall Munroe, https://xkcd.com/1502/ and https://xkcd.com/303/ - and I deem the usage to be within the license at https://xkcd.com/license.html.
