https://www.phoronix.com/scan.php?page=news_item&px=Linux-4.18-More-Y2038-Prep
The Linux kernel has already been prepping for years for Year 2038 and that work is still ongoing with the in-development Linux 4.18 kernel.
The Year 2038 problem is when systems using a signed 32-bit integer for storing the time since 1 January 1970 (standard for the Unix time-stamp) will wrap around.
Solving the Year 2038 problem in the Linux kernel
https://opensource.com/article/19/1/year2038-problem-linux-kernel
8 Comments
Tomi Engdahl says:
Because of the way time is represented in Linux, a signed 32-bit number can’t support times beyond January 19, 2038 after 3:14:07 UTC. This Year 2038 (Y2038 or Y2K38) problem is about the time data type representation. The solution is to use 64-bit timestamps.
https://opensource.com/article/19/1/year2038-problem-linux-kernel
Tomi Engdahl says:
more on the Unix 2038 time 32 bit integer coming apocalypse #y2k38 #y2k #y2038
Year 2038
Unix time rollover
Main article: Year 2038 problem
The original implementation of the Unix operating system stored system time as a 32-bit signed integer representing the number of seconds past the Unix epoch: midnight UTC, 1 January 1970. This value will roll over on 19 January 2038. This problem has been addressed in most modern Unix and Unix-like operating systems by storing system time as a 64-bit signed integer, although individual applications, protocols, and file formats will still need to be changed as well.
https://en.wikipedia.org/wiki/Time_formatting_and_storage_bugs#Year_2038
https://www.unixtimeconverter.io/
https://www.unixtimestamp.com/
Tomi Engdahl says:
Need 32-bit Linux to run past 2038? When version 5.6 of the kernel pops, you’re in for a treat
I’ve been to the year 3000… Not much has changed, but they’re still patching Linux
https://www.theregister.com/2020/01/30/linux_5_6_2038/
Linux fans intent on holding back the years will be delighted to hear that the upcoming version 5.6 of the kernel should see 32-bit systems hanging on past the dread Y2038.
Arnd Bergmann, an engineer working on the thorny Y2038 problem in the Linux kernel, posted to the mailing list that, yup, Linux 5.6 “should be the first release that can serve as a base for a 32-bit system designed to run beyond year 2038″.
Tomi Engdahl says:
Linux 5.10 Solves the Year 2038 Problem Until 2486
https://linux.slashdot.org/story/20/10/17/2237236/linux-510-solves-the-year-2038-problem-until-2486?
utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+Slashdot%2Fslashdot%2Fto+%28%28Title%29Slashdot+%28rdf
%29%29
Linux 5.10 to make Year 2038 problem the Year 2486 problem
XFS timestamp tweak extends Unix time for a few centuries
https://www.theregister.com/2020/10/19/linux_5_10_y2k38_fixes/
Y2K was caused by systems representing years with two digits and assuming that a year ending with two zeroes would be 1900. Y2K38 is different because it’s derived from Unix and Unix-like systems counting time since January 1st, 1970 in seconds. Come January 19th, 2038, that number will be a bigger value than can be stored as a single 32-bit integer. At which point, things could get interesting.
The need to remedy the Y2K38 problem has been known before the Y2K problem erupted into the public imagination, proved the world’s most expensive and unspectacular piece of proactive maintenance and inevitably spawned truthers who suggest the whole thing was a hoax dreamed up to make work for the computing services industry.
Tomi Engdahl says:
Linux Kernel 5.6 Ready To Fix Year 2038 Problem
https://fossbytes.com/linux-kernel-5-6-fix-year-2038-problem/
Tomi Engdahl says:
Is the Year 2038 problem the new Y2K bug?
This article is more than 5 years old
Reports proclaim that the Year 2038 problem is going to cause computerised doom: here’s what you need to know
https://www.theguardian.com/technology/2014/dec/17/is-the-year-2038-problem-the-new-y2k-bug
Tomi Engdahl says:
Get ready for epoc time. It’ll actually be a huge issue this time. Epoch time ends on January 19, 2038 at 03:14:07 UTC
Y2K was child’s play compared to this one.
But with AI coding, and planned obsolescence… Maybe not…
Y2K seems like a joke now, but in 1999 people were really freaking out
https://www.npr.org/2024/12/28/nx-s1-5116271/y2k-year-2000-preparations
Tomi Engdahl says:
The Epochalypse: It’s Y2K, But 38 Years Later
https://hackaday.com/2025/07/22/the-epochalypse-y2k-but-38-years-later/
Picture this: it’s January 19th, 2038, at exactly 03:14:07 UTC. Somewhere in a data center, a Unix system quietly ticks over its internal clock counter one more time. But instead of moving forward to 03:14:08, something strange happens. The system suddenly thinks it’s December 13th, 1901. Chaos ensues.
Welcome to the Year 2038 problem. It goes by a number of other fun names—the Unix Millennium Bug, the Epochalypse, or Y2K38. It’s another example of a fundamental computing limit that requires major human intervention to fix.
Unlike Y2K, which was largely about how dates were stored and displayed, the 2038 problem is rooted in the fundamental way Unix-like systems keep track of time. Since the early 1970s, Unix systems have measured time as the number of seconds elapsed since January 1st, 1970, at 00:00:00 UTC. This moment in time is known as the “Unix epoch.” Recording time in this manner seemed like a perfectly reasonable approach at the time. It gave systems a simple, standardized way to handle timestamps and scheduled tasks.
The trouble is that this timestamp was traditionally stored as a signed 32-bit integer.
For an unpatched system using a signed 32-bit integer to track Unix time, the immediate consequences could be severe. Software could malfunction when trying to calculate time differences that suddenly span more than a century in the wrong direction, and logs and database entries could quickly become corrupted as operations are performed on invalid dates. Databases might reject “historical” entries, file systems could become confused about which files are newer than others, and scheduled tasks might cease to run or run at inappropriate times.
This isn’t just some abstract future problem. If you grew up in the 20th century, it might sound far off—but 2038 is just 13 years away. In fact, the 2038 bug is already causing issues today. Any software that tries to work with dates beyond 2038—such as financial systems calculating 30-year mortgages—could fall over this bug right now.
The obvious fix is to move from 32-bit to 64-bit timestamps. A 64-bit signed integer can represent timestamps far into the future—roughly 292 billion years in fact, which should cover us until well after the heat death of the universe. Until we discover a solution for that fundamental physical limit, we should be fine.
Indeed, most modern Unix-based operating systems have already made this transition. Linux moved to 64-bit time_t values on 64-bit platforms years ago, and since version 5.6 in 2020, it supports 64-bit timestamps even on 32-bit hardware. OpenBSD has used 64-bit timestamps since May 2014, while NetBSD made the switch even earlier in 2012.
Most other modern Unix filesystems, C compilers, and database systems have switched over to 64-bit time by now. With that said, some have used hackier solutions that kick the can down the road more than fixing the problem for all of foreseeable time. For example, the ext4 filesystem uses a complicated timestamping system involving nanoseconds that runs out in 2446. XFS does a little better, but its only good up to 2486. Meanwhile, Microsoft Windows uses its own 64-bit system tracking 100-nanosecond intervals since 1 January 1601. This will overflow as soon as the year 30,828.
The challenge isn’t just in the operating systems, though. The problem affects software and embedded systems, too. Most things built today on modern architectures will probably be fine where the Year 2038 problem is concerned. However, things that were built more than a decade ago that were intended to run near-indefinitely could be a problem. Enterprise software, networking equipment, or industrial controllers could all trip over the Unix date limit come 2038 if they’re not updated beforehand. There are also obscure dependencies and bits of code out there that can cause even modern applications to suffer this problem if you’re not looking out for them.
The 2038 problem is really a case study in technical debt and the long-term consequences of design decisions. The Unix epoch seemed perfectly reasonable in 1970 when 2038 felt like science fiction. Few developing those systems thought a choice made back then would have lasting consequences over 60 years later. It’s a reminder that today’s pragmatic engineering choices might become tomorrow’s technical challenges.
The good news is that most consumer-facing systems will likely be fine. Your smartphone, laptop, and desktop computer almost certainly use 64-bit timestamps already. The real work is happening in the background—corporate system administrators updating server infrastructure, embedded systems engineers planning obsolescence cycles, and software developers auditing code for time-related assumptions. The rest of us just get to kick back and watch the (ideally) lack of fireworks as January 19, 2038 passes us by.