Information & Help with Y2038

Y2038.com provides information and help with Y2038, an issue due to a limitation of the maximum number of seconds (relative to Jan 1, 1970) that can be represented in a 32-bit signed integer. The rollover will occur on Jan 19, 2038, 3:14:07AM GMT, although some problems may occur before then. Please see our FAQ for more details on the issue.

Y2038.com provides free information about the issue itself and advice on assessment and mitigation. Y2038.com also offers premium Y2038-related services, including general consultation, contract labor for help with assessment and mitigation, and training.

Years of Experience
0 +
Client Companies
0 +
Business Efficiency
0 %
Safe Resource
0 %
Business Profit
0 %

Y2038 Services

Y2038.com offers premium Y2038-related services

Y2038 Technologies

Blogs and Articles

Dedicated to articles on Y2038-related topics, products, and services.

Some frequently asked questions to our team. This is a general question or answer. If you need detailed questions, please contact us.

What is Y2038 (the short version)?

Y2038 refers to an issue related to the way time is handled by computers. Time is often represented as the number of seconds since Jan 1, 1970. Whenever a 32-bit signed integer is used for this, the maximum value that can be represented is +/- ~68 years, 19 days from the epoch, which corresponds to Jan 19, 2038. What happens after that is system dependent, but generally not good. A computer may act as if its time got reset to Dec 1901, or possibly to the epoch of Jan 1, 1970. It may give unexpected results or crash.

Basically, any software that uses time in any way may potentially have Y2038 issues. While only a small percentage of each software component is typically affected, this is still enough to cause many problems. Embedded systems with 32-bit cores and computers running 32-bit versions of Linux and Windows and are particularly at risk, but even 64-bit computer systems may have problems. In 64-bit computer systems, time can be represented in 64-bit integers, but Y2038 issues may still exist in applications, device drivers, databases, storage systems, and network protocols.

Virtually every programming language is potentially affected by Y2038. While “C” was the initial computer language in which the problem was introduced, most other programming languages adopted the same representation for current time. Many development platforms follow the conventions established on the given platform. For example, Mac applications (prior to OSX) are susceptible to the Mac’s Y2038-like issue in the year 2040, regardless of the language used to write the application.

There may be several reasons. One reason is of course that the Y2038 event seems so far off. Being over 20 years away, there is no sense of immediate urgency to fix anything. However, this is the same type of thinking that was partly responsible for the creation of the Y2038 issue to begin with.

Another reason you may not have heard about Y2038 is probably due to the extensive media coverage that preceded Y2K. Perhaps in part due to the heightened awareness by mainstream media, the Y2K issue was almost fully mitigated prior to Jan 1, 2000. When Jan. 1, 2000 arrived, there were no catastrophes, and there was a public sense that the Y2K event had been over-hyped. In fact, it is likely that the extensive Y2K media coverage forced businesses to thoroughly and proactively address it. (Chances are, media coverage will similarly increase before 2038).

Yet another reason may be a general lack of understanding of Y2038. Y2K was fairly easy to understand, but Y2038 requires a deeper understanding about the digital representation of time in computers.

The Place for Y2038 Information and Help