Why Do Computers Count Time From 1970?

Machine time needed a shared beginning.

A timestamp such as 0, 1704067200, or 1753095600 does not look much like a date. There is no month name, no day of the week, and no obvious clock time. Yet computers can turn those numbers into exact moments almost instantly.

The system works because the number is not trying to describe a calendar date directly. It measures how much time has passed since an agreed starting point. For Unix systems, that starting point is midnight at the beginning of January 1, 1970, in Coordinated Universal Time.

Computers prefer counting to reading calendars

Human calendars are full of irregularities. Months have different lengths. Leap years add extra days. Time zones shift clock readings. Daylight-saving rules change by place and year. Even the order of day, month, and year varies between countries.

Counting elapsed units is much simpler. Instead of storing “January 1, 2024 at midnight UTC,” a Unix-based system can store 1704067200: the number of seconds that had passed since its reference point. The calendar date can be reconstructed whenever a person needs to see it.

The Unix epoch begins at zero

At 1970-01-01 00:00:00 UTC, Unix time is 0. One second later, it is 1. One minute later, it is 60. One day later, at 1970-01-02 00:00:00 UTC, it is 86400.

Dates before the epoch can be represented with negative values. For example, -1 refers to the final second before January 1, 1970 UTC. The number line can therefore extend backward as well as forward, even though software support for older dates varies.

Why was January 1, 1970 chosen?

Unix was being developed around 1969 and 1970, so the beginning of 1970 was a practical recent reference point for the operating system. It was not chosen because anything universal happened at that instant, and it is not the moment computers or digital time began.

It is simply the baseline Unix adopted. Once Unix and Unix-like systems spread across servers, databases, networks, phones, websites, and cloud infrastructure, that baseline became one of the most widely used reference points in computing.

An epoch is not necessarily the Unix epoch

The word epoch means the reference point from which a system begins counting. Unix time uses 1970, but other systems use other beginnings. Some Apple systems historically counted from January 1, 2001. Microsoft file time counts intervals from January 1, 1601. GPS time begins in January 1980.

This matters when someone asks questions such as “Why is this timestamp showing 1601?”, “Why did my date become January 1, 1970?”, or “Why does this value convert to 2001 instead of 1970?” The number may be valid, but it may belong to a different epoch or use a different unit.

Seconds and milliseconds can look almost identical

A common Unix timestamp uses seconds, but many systems use milliseconds. For example, 1704067200 represents January 1, 2024 in Unix seconds, while 1704067200000 represents the same moment in milliseconds.

Confusing the two can produce dates thousands of years away or values a system cannot interpret. That is why searches such as “Is this Unix timestamp in seconds or milliseconds?”, “Why is my timestamp 13 digits?”, and “Why does my timestamp convert to the wrong year?” often lead back to the unit rather than the date itself.

A timestamp represents a moment, not a local clock display

Unix timestamps are normally interpreted relative to UTC. The same value can therefore display as different local times depending on the selected time zone. A timestamp representing midnight UTC may appear as the previous evening in Jamaica or New York and later that morning in Europe or Asia.

The underlying moment has not changed. Only the local calendar and clock representation have. This is why the same Unix timestamp can appear to show two different dates on two devices without either device necessarily being wrong.

The Year 2038 problem comes from storage limits

Older systems often stored Unix seconds as a signed 32-bit integer. The largest value that format can hold is 2147483647, corresponding to January 19, 2038 at 03:14:07 UTC. One second later, the number can overflow and be interpreted incorrectly by systems that still depend on that limit.

Modern systems increasingly use wider integer formats, but the Year 2038 problem still matters in older operating systems, embedded devices, industrial controls, and long-lived software that may remain in service for decades.

Machine time is useful because it separates storage from display

A system can store one numerical representation of a moment and display it later as 2026-07-21 14:30 UTC, July 21, 2026 at 9:30 AM, or another local format. The stored instant remains stable while the human-facing representation adapts to language, location, and preference.

That separation allows logs to be ordered, events to be compared, durations to be calculated, and data to move between systems without first agreeing on how a person prefers dates to be written.