▃ | ▃ | ▃ |

⬤ | ⬤ | ⬤ | ⬤ |

⬤ | ⬤ | ⬤ | ⬤ |

⬤ | ⬤ | ⬤ |

⬤ | ⬤ | ⬤ |

This is my design for a binary watch face. The top-left cell is an AM/PM indicator. The two other cells on the top row increment every four hours. The big dots are a four hour clock accurate to the nearest minute. The small dots count seconds. I'll explain how minutes and seconds are counted later on, but the representation makes it easier to read off idiomatic times like "half past" than with a true binary representation of minutes. (If you laugh in the face of such standards, see the True Binary Time Clock.)

Leap seconds should work. On a leap second, the second bits should all be set. Next time there's a leap second you can come here and check if I (and your operating system and browser) got it right.

The implementation is based on Snarkles.Net Useless Binary Time (SNUBT). It's in JavaScript. You can view the source.

Writing a number as two rows of binary in this way is equivalent to each column representing a base-4 digit. Base-4 has properties that make it uniquely suitable to represent minutes and seconds:

- Four is a root of 64. (64 is a little larger than 60.)
- One-twelfth is represented by one fixed and one repeating digit. Therefore, all twelfths are represented by a pattern of two digits.
- Four is larger than two.

I'll explain why these properties are important later. For now, let's look at representing hours in two-row binary. It's currently [JavaScript required] hours on the 24-hour clock. In base 4, this is [JavaScript required]. On a two-row binary grid, with each column a base-4 digit, and high values at the top, that looks like this:

⬤ | ⬤ | |

⬤ | ⬤ | ⬤ |

It's a bit of a waste to have a column with only one bit, so we could also look at the 12 hour clock. Here (with 12 as zero), the current time is [JavaScript required] in decimal or [JavaScript required] in base-4.

⬤ | ⬤ |

⬤ | ⬤ |

The last two bits of these two hour-grids are always the same, so only the right-hand column is always the same. Because of this, the standard two-row displays have one column for hours, giving them a period of four hours. This is less than a conventional clock, but fine for a desktop clock. It's unusual to be working on something so absorbing that you aren't aware of the current time to the nearest four hours.

Now, the importance of 64 being a little larger than 60 may not be immediately apparent. Obviously, 60 is the number of minutes to an hour and the number of seconds to a minute. 64 is a power of two, and so can be represented by six binary digits, or three digits of base-4, or two digits of octal (base-8). We can use these digits to count 60 things, and waste the opportunity to count 4 other things. That means the things we want to count are 93.75% of the things we are capable of count in these number bases. No other number base less than 60 is this efficient at counting 60 things. Decimal, as a simple example, is only 60% efficient.

A simple representation of twelfths is useful because a traditional clock face is divided into twelve parts, so we tend to think of intervals of 5 minutes as being significant. We also tend to think that binary doesn't work with thirds, because one-third can't be represented by a finite number of digits. But that doesn't matter for a fixed-precision display. What does matter is that the fraction ends with a simple pattern of repeated digits. Repetition of any digit is as easy to recognize as repeated zeros. One-third in base-4 is 0.111111…. On a two-row binary display, this means the lower bits (as I show them) are set and the upper bits are unset. One-twelfth is a quarter of this, so 0.0111111…. Because we need three digits of base-4 to count to sixty, at 5-minute intervals the two right-hand columns are identical.

The hours and minutes on my binary clocks skip one value in 15. This means they count up in steps of either minutes or seconds, but also show the fraction of an hour to six bits precision (truncated instead of rounded off). You can use this table to convert from an array of dots to a count of minutes or seconds:

30 | 8 | 2 |

15 | 4 | 1 |

Where this shows minutes, you can also think of the left-hand column as showing quarter-hours, and the other two columns as showing 5 minute intervals when they match (either all unset, or one row set and the other unset). To this array of minutes, add a column on the left to count hours. The 4-hour time to the minute in base-4 is then [JavaScript required]. As an array of dots, it looks like the following.

⬤ | ⬤ | ⬤ | ⬤ |

⬤ | ⬤ | ⬤ | ⬤ |

You can also read the unset bits as being minutes to the next quarter. That works because there's one unused state every quarter of an hour. You may at this point be muttering something about one's complement. If so, you're probably correct.

It's also possible to use block elements from Unicode to show a two-row binary clock as text, where the current time is [JavaScript required]

If you want to show a time as a string, hexadecimal is more efficient than base-4. Then, the current time is [JavaScript required]. This is a terse but still readable time format. The first digit counts quarters of an hour. If you have an appointment on the hour, take the hour modulo 4, multiply it by 4, convert it to hex, and that's what the first digit of the clock will show at the due time. The second digit counts minutes after the quarter and counts from 0 to e.

You may ask why the last column of bits needs to be there at all. There aren't many situations in daily life when you need to know the exact time when it isn't a quarter of an hour. Meetings and radio or television programs tend to be scheduled on the hour or half hour. Bus timetables are published with a resolution of minutes. If you want to catch a bus, and are under the illusion that it will arrive when it is timetabled, then it's useful to know the time to the minute. As you don't tend to be using a desktop (metaphorical or otherwise) when hurrying to catch a bus, this isn't an argument for keeping the minutes on a desktop clock. So, indeed, 6 bits are enough for normal purposes to give the "domino clock" or [JavaScript required] or

⬤ | ⬤ | ⬤ |

⬤ | ⬤ | ⬤ |

This is an example of what the alternative timepiece community calls a fuzzy clock. It divides the quarter into four parts, and so is slightly more precise than a more conventional three part division. The bits translate to English roughly as follows (with the first digit of the hex times counting hours rather than quarters).

Hex | Blocks | English | Range |
---|---|---|---|

10 | One o'clock | 1:00–1:03 | |

11 | Five past one | 1:04–1:07 | |

12 | Ten past one | 1:08–1:11 | |

13 | Nearly quarter past one | 1:12–1:14 | |

14 | Quarter past one | 1:15–1:18 | |

15 | Twenty past one | 1:19–1:22 | |

16 | Twenty-five past one | 1:23–1:26 | |

17 | Nearly half past one | 1:27–1:29 | |

18 | Half past one | 1:30–1:33 | |

19 | Twenty-five to two | 1:34–1.37 | |

1a | Twenty to two | 1:38–1.41 | |

1b | Nearly quarter to two | 1:42–1.44 | |

1c | Quarter to two | 1:45–1.48 | |

1d | Ten to two | 1:49–1.52 | |

1e | Five to two | 1:53–1.56 | |

1f | Nearly two | 1:57–1:59 | |

20 | Two o'clock | 2:00–2:03 |

I wrote a command line binary clock that outputs the time in text format and can produce unicode block characters like in the "Blocks" column. You may run it in an xterm, remove the decorations, and have the time like that sitting on your desktop.

It is possible to divide the hour into sixteen equal parts without giving up on SI seconds. A "long minute" would be 225 seconds by this definition, or 3 regular minutes and 45 seconds. The long minute can be represented as two digits, each counting from zero to fourteen. So, when you show the seconds, one second to the hour comes out as fee in hex or in binary instead of fbe or .

Six bits can be written as two columns of three bits instead of three columns of two bits. A column of a three-row display shows octal (base-8). Two rows are better than three because 5 minute intervals make an easier pattern to read. But octal clocks are still worth a look. The current time on a three row array is

Hour | Minute | Second | |||
---|---|---|---|---|---|

⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ |

⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ |

⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ |

The first two columns show the current hour represented in binary and grouped in octal. The next two columns show the current minute past the hour and the last two columns show the current second past the minute. These are not direct binary conversions, however, because there are less than 64 minutes to an hour and less than 64 seconds to a minute.

The advantage of three rows is that the clock naturally repeats every eight hours instead of four. That means you can doze off for longer and not lose track of what time it is. The current 8-hour time to the minute as an octal string is [JavaScript required]. As an array,

⬤ | ⬤ | ⬤ |

⬤ | ⬤ | ⬤ |

⬤ | ⬤ | ⬤ |

This is an attractive (yet thoroughly incomprehensible to the uninitiated) display that would look good on a watch face. However, I don't plan to use it because I find it confusing to switch between two and three rows.

We hear that the world isn't a binary place, and that reality is about shades of gray. So why am I here promoting binary time? Well, we can take fuzzy time a step further, and have the old time fade out and the new time fade in. Here's the domino clock working like that:

⬤ | ⬤ | ⬤ |

⬤ | ⬤ | ⬤ |

Making the time fuzzy like this means that you get more states from the same bits. That means you can get a way with fewer bits. So, here's a fuzzy clock with bits showing quarter hours.

⬤ | ⬤ |

⬤ | ⬤ |

There are times when a set of bits get in an equally intermediate state, and you wouldn't be able to tell what times it was fading between if they were all the same color. So, I applied a red shift to bits fading out and a blue shift to bits fading in for people with color vision.

A 3x3 fuzzy clock:

⬤ | ⬤ | ⬤ |

⬤ | ⬤ | ⬤ |

⬤ | ⬤ | ⬤ |