Taskwarrior has a calc command that exposes the algebraic expression evaluator used by all other commands and filters. This is handy for quick calculations from the command line, but combined with DOM access, can be very useful.


This can be used to perform basic mathematics using the +, -, * and / operators:

$ task calc 1+2*3

In the above example, care was taken to not allow that * operator to be expanded by the shell into a list of file in the current directory. The best solution to this is to simply quote the expression.

In addition to integers, you can use real numbers and scientific notation:

$ task calc '1.23e-4.5 ^ 2'

In addition to exponentiation, ^, there is the % modulus operator.


The and, or, xor, ==, !==, =, !=, !, ~, !~, <=, <, >=, and > operators allow Boolean expressions:

$ task calc true and false
$ calc true or false
$ calc true xor true
$ calc '1 < 2 and -1 < 0'

A number can be converted to a Boolean value with a double negative:

$ task calc '!!3'

Otherwise, type conversions are automatic.


Text, or strings, can be manipulated in more limited ways, for example there is concatenation:

$ task calc foo + bar

Multiplication is supported in the form of replication:

$ task calc 'x * 40'

There is support for regular expressions, using the ~ match and !~ no-match operator:

$ task calc 'foo ~ f'
$ task calc 'foo !~ z'
$ task calc '"The quick brown fox" ~ "q"'

Again, you’ll need to protect the ~ and !~ characters from interpretation by the shell, and in the last example, to protect the spaces in the sentence.


With date support, basic date synonyms like now, today, yesterday and tomorrow are supported:

$ task calc now
$ task calc today

Dates can be added, subtracted and compared, and combined with durations:

$ task calc tomorrow + 2 weeks - 1d

The expression evaluator understand ISO-8601 date formats, and in fact supports over 40 of them. For example when does week 40 start in 2014?

$ task calc 2014W40

When is the FIFA World Cup final, which starts at 4pm in Brasil local time, shown in the EST (local) time zone?

$ task calc 2014-07-13T16:00:00-03:00


A duration is either the difference between dates, or a specified interval. Durations can be summed:

$ task calc 12h + 25m +30s

Subtracting dates yields a duration, here answering the question of how much time is there between the end of this month (June 2014) and the end of the year:

$ task calc eoy-eom

Note that the ‘1H’ corresponds to the extra hour gained when summer time ends.

When does the 32-bit time_t problem (Unix Epoch, Y2K38) arrive?

$ task calc later-now

Looks like we have 23 years to deal with that. More importantly though, how long until the FIFA World Cup final?

$ task calc 2014-07-13T15:00:00-03:00 - now

Durations are shown using the ISO-8601 designated format, using only precise units, that is, not in years or months.

DOM Access

The expression evaluator has access to the Taskwarrior DOM, which is a complete source of task information. This information can be accessed and used in an expression using regular Taskwarrior DOM references:

$ task calc '1.urgency > 2.urgency'

Because of DOM access, the calc command can mimic the _get helper command. In what year did I enter task 100?

$ task calc 100.entry.year

What week was that?

$ task calc 100.entry.week

Calc Utility

Taskwarrior has a standalone calc utility that has the same features, except for DOM access. This utility is used for testing, but has a few interesting features of its own.

Calc Postfix

Internally, the expression evaluator converts infix expressions (1 + 2 * 3) to postfix (1 2 3 * +), which is easier to implement and optimize, but calc exposes this:

$ calc --postfix '1 2 3 * +'

Calc Debugging

There is also support for a --debug command line option, which displays the stack operations as the expression is evaluated in postfix form.

$ calc --postfix --debug '1 2 3 * +'
[0] eval push '1'
[1] eval push '2'
[2] eval push '3'
[3] eval pop '3'
[2] eval pop '2'
[1] eval operator '*'
[1] eval result push '6'
[2] eval pop '6'
[1] eval pop '1'
[0] eval operator '+'
[0] eval result push '7'

You can see that the processing begins by pushing the three values on to the stack, then two are popped when the * binary operator is encountered. The two value are multiplied, and the result, 6 is pushed back.

Next the + binary operator is encountered, which pops two values off the stack, the sum, 7, is pushed back.

The number in brackets is the stack size before the operation is performed.

If there is a problem found with the Taskwarrior expression evaluator, it can be verified and tested in this way, using the calc utility.