Tested · Updated

Cuba keeps daylight saving time on 1 November 2026: America/Havana is an hour behind until you change something

Cuba is on daylight saving time all winter: it did not set its clocks back on Sunday 1 November 2026. On 24 October Cuba's energy and labour ministries announced that daylight saving time stays in force until 7 November 2027. Cuban time stays at UTC−04 (CDT) all winter.

The IANA time zone database, where Linux, Apple's and Google's systems, Java, Node.js and Python get their time zone rules, added the change to its development version on 26 October and released it as version 2026f at 06:16 UTC on 28 October. The release doesn't reach your systems by itself: each operating system, runtime and library ships its own copy. At 15:32 UTC on 2 November, Debian 13's regular updates, Debian 12's security updates, pytz, moment-timezone, PHP's PECL timezonedb extension and Python's PyPI tzdata package had 2026f. Ubuntu, Alpine's stable releases, Node.js and OpenJDK did not, and the official python and debian container images published that day still carried the old data (details). Update, 7 November: Alpine 3.23 and 3.24 had 2026f, and so did Eclipse Temurin 8u512 and 11.0.33, released on 4 November; Ubuntu's 2026f packages were still in its proposed testing pocket. Every copy we tested on 27 October switched America/Havana to UTC−05 at 05:00 UTC on 1 November, and any copy without 2026f has shown Cuban times one hour behind since then: 07:00 when it is 08:00 in Havana.

If you store, show or schedule times for Cuba (bookings, flights, money transfers, deliveries, appointments, reminders), run the check now. Where it prints 07:00, update the copy if an update exists, or put the stopgap in, then fix the times you already stored. On Debian 13 and Debian 12, and in containers built on them such as the official python slim images and their -bookworm tags, apt-get update && apt-get install -y tzdata installs 2026f; in our tests the check then printed 08:00. If your code uses pytz or moment-timezone, update to pytz 2026.6 or moment-timezone 0.6.6. Node.js and Java carry their own copies and still need the stopgap. On other systems date needs it too, and Python's zoneinfo (which Django 4.0 and later uses) needs the stopgap or PyPI's tzdata 2026.6 with PYTHONTZPATH set empty (how); installing the package alone changes nothing where the system has its own zone files.

How long it is wrong

Period (UTC)Time in CubaData older than 2026f
Until 1 November 2026, 05:00UTC−04 (CDT)UTC−04: right
1 November 2026, 05:00 to 14 March 2027, 05:00UTC−04 (CDT)UTC−05 (CST): one hour behind
14 March 2027, 05:00 to 7 November 2027, 05:00UTC−04 (CDT)UTC−04: right again
From 7 November 2027, 05:00UTC−05 (CST)UTC−05: right

Old data also repeats 00:00 to 00:59 local time on 1 November and skips 00:00 to 00:59 on 14 March 2027. Neither happens in Cuba now.

Check your systems today

Each line prints the time in Havana at 12:00 UTC on 1 November 2026. 07:00 or −05 means your copy is out of date. 08:00 or −04 means it has the change. From date, 12:00 UTC means the system has no time zone files at all (Alpine and the plain Ubuntu container image ship none). On 27 October every one of these printed the out-of-date answer.

Linux and anything that reads the operating system's copy (date):

TZ=America/Havana date -d '2026-11-01 12:00Z'

Ubuntu 26.04, tzdata 2026e: Sun Nov 1 07:00:00 AM CST 2026. Debian's date prints the same without AM. BusyBox date, as on Alpine, rejects this form; TZ=America/Havana date -d @1793534400 asks the same question and works with every date we tried.

Python's zoneinfo:

python3 -c "from datetime import datetime; from zoneinfo import ZoneInfo; print(datetime.fromisoformat('2026-11-01T12:00:00+00:00').astimezone(ZoneInfo('America/Havana')))"

Python 3.14.4 on that system: 2026-11-01 07:00:00-05:00

Node.js, which carries its own copy (the first word printed is its version):

node -p "process.versions.tz + ' ' + new Date('2026-11-01T12:00:00Z').toLocaleString('en-US', {timeZone: 'America/Havana', timeZoneName: 'shortOffset'})"

Node.js 24.22.1: 2026e 11/1/2026, 7:00:00 AM GMT-5

Java, which also carries its own copy. Save this line as Havana.java and run java Havana.java. Running a source file like this needs a full JDK 11 or later; a JRE alone, as in many production images, has no compiler and fails (Java 11: Module jdk.compiler not in boot Layer). For a JRE, compile it with any JDK (javac --release 11 Havana.java), copy Havana.class across and run java Havana there:

class Havana { public static void main(String[] a) { System.out.println(java.time.Instant.parse("2026-11-01T12:00:00Z").atZone(java.time.ZoneId.of("America/Havana")) + " tzdb " + java.time.zone.ZoneRulesProvider.getVersions("America/Havana").lastKey()); } }

OpenJDK 25.0.4.1: 2026-11-01T07:00-05:00[America/Havana] tzdb 2026b. The compiled class gave the same line on the Eclipse Temurin 11.0.32.1 and 25.0.4.1 JREs.

Libraries that carry their own copy (pytz and moment-timezone installed from PyPI or npm), which none of the checks above read. If your code uses pytz (pandas 2.x does when you give it a zone name as text) or moment-timezone, check them too. The first word printed is the data version. Run the Node.js line from your app's directory:

python3 -c "import pytz; from datetime import datetime; print(pytz.OLSON_VERSION, datetime(2026,11,1,12,tzinfo=pytz.utc).astimezone(pytz.timezone('America/Havana')))"

pytz 2026.5: 2026e 2026-11-01 07:00:00-05:00. pytz 2026.6, released 29 October: 2026f 2026-11-01 08:00:00-04:00

node -p "const m = require('moment-timezone'); m.tz.dataVersion + ' ' + m.tz('2026-11-01T12:00:00Z', 'America/Havana').format()"

moment-timezone 0.6.5: 2026e 2026-11-01T07:00:00-05:00. moment-timezone 0.6.6, released 29 October: 2026f 2026-11-01T08:00:00-04:00

Run the check where your code runs: in the container, on the server, with the same Java or Node.js. A laptop with newer data proves nothing about production.

What the fixed data gives. We compiled America/Havana from the development version (commit 261544cc68, which includes the Cuba change) with the database's own compiler. With that file, 12:00 UTC on 1 November is 08:00 CDT (UTC−04), and Cuba's next change is to UTC−05 at 05:00 UTC on 7 November 2027. The abbreviation stays CDT, as the database models this as a year with no fall-back, not a new time zone. Release 2026f's America/Havana file is byte for byte the same as the one we compiled, so these results, and the stopgap tests below, hold for 2026f.

Stopgap until your copy has the change

In code: correct Cuban times, and it switches itself off

Use this where your code converts times for Cuba. It changes the result only between 1 November 2026, 05:00 UTC and 14 March 2027, 05:00 UTC, and only while the installed data still says UTC−05 there. One more case for wall-clock input: old data repeats 00:00–00:59 on 1 November, and a time marked as the second of the two (fold=1, which Python keeps when it drops the zone) would come out an hour late, so from_havana reads it as the one real hour. Earlier and later times, and every time once your data has the change, go through America/Havana unchanged. You can leave it in place after the update. Each version has two functions: one for showing a stored time in Cuba, one for turning a Cuban time someone typed into UTC. Use both; fixing only the display makes new bookings show an hour late.

Python, in place of zoneinfo, pytz or pandas conversions for Cuban times (it reads zoneinfo, not pytz):

from datetime import datetime, timedelta, timezone
from zoneinfo import ZoneInfo

HAVANA = ZoneInfo("America/Havana")
HELD = timezone(timedelta(hours=-4), "CDT")
START = datetime(2026, 11, 1, 5, tzinfo=timezone.utc)
END = datetime(2027, 3, 14, 5, tzinfo=timezone.utc)


def _stale(t):
    # True only where installed data still has Cuba's cancelled fall-back
    return START <= t < END and t.astimezone(HAVANA).utcoffset() == timedelta(hours=-5)


def to_havana(t):
    """Aware datetime -> Cuban local time."""
    return t.astimezone(HELD) if _stale(t) else t.astimezone(HAVANA)


def from_havana(local):
    """Naive Cuban wall time -> aware UTC datetime."""
    t = local.replace(tzinfo=HELD).astimezone(timezone.utc)
    if _stale(t):
        return t
    if START - timedelta(hours=1) <= t < START:
        # 00:00-00:59 on 1 November now happens once; old data has a second one
        local = local.replace(fold=0)
    return local.replace(tzinfo=HAVANA).astimezone(timezone.utc)

JavaScript. To show a Cuban time with Intl or toLocaleString, pass havanaTimeZone(date) as the timeZone option; inside the window it returns Etc/GMT+4, which is UTC−04 (the sign in Etc names is reversed) and displays as GMT-4, not CDT. For a Cuban time someone typed, call fromHavana with your library's own local-to-UTC call; it returns a Date. With date-fns-tz that is fromHavana('2026-11-15T09:00', (l, z) => fromZonedTime(l, z)); with Luxon, (l, z) => DateTime.fromISO(l, { zone: z }).toJSDate(); with moment-timezone, (l, z) => moment.tz(l, z).toDate(). havanaTimeZone reads Node.js's own copy of the data. fromHavana reads your library's answer, so it also works with moment-timezone, which carries its own copy, and switches itself off once that library has the change.

const START = Date.UTC(2026, 10, 1, 5);
const END = Date.UTC(2027, 2, 14, 5);

function stale(date) {
  // True only where installed data still has Cuba's cancelled fall-back
  if (date < START || date >= END) return false;
  const name = new Intl.DateTimeFormat('en-US', {
    timeZone: 'America/Havana', timeZoneName: 'shortOffset',
  }).formatToParts(date).find((p) => p.type === 'timeZoneName').value;
  return name === 'GMT-5';
}

// Showing: use as the timeZone option for a Cuban time
function havanaTimeZone(date) {
  return stale(date) ? 'Etc/GMT+4' : 'America/Havana';
}

// Input: Cuban wall time someone typed -> Date. convert(local, zone) is your
// library's local-to-UTC call, e.g. (l, z) => fromZonedTime(l, z) in date-fns-tz
function fromHavana(local, convert) {
  const held = convert(local, 'Etc/GMT+4');
  const plain = convert(local, 'America/Havana');
  // Your library's own copy still has the cancelled fall-back: plain is an hour late.
  // From an hour before START: 00:00-00:59 on 1 November is 04:xx UTC
  return held >= START - 3600000 && held < END && plain - held === 3600000 ? held : plain;
}

module.exports = { havanaTimeZone, fromHavana };

How we tested them, on 27 October: we compared each with the fixed America/Havana file at every quarter hour. Python, both functions, from 1 December 2025 to 1 April 2028: 0 differences on 2026e data, against 12,768 quarter hours an hour off without the stopgap. With the fixed file installed in its place, Python's version changed nothing. We also ran from_havana on every minute of Cuban wall time from 22:00 to 03:00 across each change from November 2025 to November 2027, with both fold values: 0 differences, on 2026e data and on the fixed file. JavaScript on Node.js 24.22.1, every quarter hour from 25 October 2026 to 21 March 2027: havanaTimeZone gave 0 differences. fromHavana gave 0 differences on all 14,112 Cuban wall times in that period, with date-fns-tz 3.2.0, Luxon 3.7.2 and moment-timezone 0.6.5, and each time typed came back unchanged when shown with havanaTimeZone. The libraries alone were an hour late on 12,764 to 12,768 of them. No released Node.js had the change. Over this period the fixed file is a constant UTC−04, so we stood in Etc/GMT+4 for Node.js's America/Havana and loaded the fixed rules into moment-timezone: with Node.js, moment-timezone or both fixed, both functions gave 0 differences. On 2 November we found that Luxon's answer for 00:00 to 00:59 on 1 November depends on the clock: run between 05:00 UTC that day and 14 March 2027, it picks the second of the two 00:30s that old data has, and this page's first fromHavana returned those 4 quarter hours an hour late. We fixed the check above (START - 3600000). With Luxon's clock set to 27 October, 2 November and 15 March 2027, the fixed version gave 0 differences; on 2 November date-fns-tz and moment-timezone gave 0 differences with both versions.

In configuration: a zone with the same offset

If you can't change code, use a zone that stays on UTC−04 in place of America/Havana: America/Santo_Domingo or America/Puerto_Rico, or the POSIX setting TZ='<-04>4'. On a system with no time zone files the two zone names quietly give UTC; TZ='<-04>4' needs no files. Tim Parenti, one of the database's two coordinators, suggested Dominican Republic or Puerto Rico time as a stopgap for devices. It has three costs:

  • The abbreviation shows AST or −04, not CDT.
  • It is wrong for Cuban winter times before this change. 12:00 UTC on 15 January 2026 shows as 08:00 AST; in Havana it was 07:00 CST. Don't apply it to past records, reports or logs.
  • It has to come off before 05:00 UTC on 7 November 2027, when Cuba moves to UTC−05 and these zones don't. Take it off once every copy your app uses has the change: the operating system's, Node.js's or Java's, and pytz's or moment-timezone's if you use them.

On devices that use a rule string

Firmware and programs that take a POSIX time zone string, such as ESP32 firmware or a process started with TZ set to a rule, don't read the zone's dates. They repeat one yearly rule, and in 2026f that rule for America/Havana is still CST5CDT,M3.2.0/0,M11.1.0/1, because the format can't say "skip one fall-back". With that rule, 12:00 UTC on 1 November shows as 07:00 CST, so updating to 2026f doesn't fix these. Set TZ='<-04>4' on them now, and don't take it off when an update arrives. From 05:00 UTC on 14 March 2027 the rule gives the right time again; put it back any time between then and 7 November 2027.

Did this fix it?

Times you have already stored

A Cuban time saved as UTC with data older than 2026f is saved wrong. A booking for 09:00 in Havana on 15 November, converted with that data, is stored as 14:00 UTC. With the change, 09:00 in Havana that day is 13:00 UTC. After you update or add the stopgap, the stored record still says 14:00 UTC and shows as 10:00. We checked both conversions in Python with 2026e data and with the fixed file.

Look for future events in Cuba between 1 November 2026 and 14 March 2027 that were entered as a local time and stored in UTC, and recompute them from the local time with the stopgap (from_havana or fromHavana) or after your data has the change. Records stored as a local time plus America/Havana, converted when read, come out right once the conversion is right.

If your app shows times in the user's own device time zone, what a Cuban user sees also depends on their phone or browser, which gets the change from its vendor. You can't fix that from the server.

When the real fix arrives

IANA released 2026f, with the change, at 06:16 UTC on 28 October. Each runtime still needs its own update, and you have the fix only once the copy your code reads has it. Where each one gets its data is in our Canada guide, tested for that change. What had 2026f when we last read the package and release lists, at 15:32 UTC on 2 November, is noted under each:

  • The operating system's package (tzdata) for date, Python's zoneinfo on Linux, Go on a full OS image, and PHP from Debian's or Ubuntu's packages. After installing it, restart services that use local time. In our Canada tests, a running MySQL and a running Python service kept the old rules until they restarted. On 2 November Debian 13's regular updates had it (tzdata 2026f-0+deb13u1, in trixie-updates), so apt update && apt upgrade installs it. Debian 12, now in long-term support, had it in its security updates (tzdata 2026f-0+deb12u1, in bookworm-security); apt-get update && apt-get install -y tzdata installs it where the security archive is in the package sources, as it is in the official debian and python images. Ubuntu (no release; 26.04, 24.04 and 22.04 have tzdata 2026e) and Alpine 3.24 (tzdata 2026e) did not; Alpine's development branch, edge, did. Update, 7 November: Alpine 3.23 and 3.24 have tzdata 2026f-r0 in their main repositories; Ubuntu's 2026f-0ubuntu0 packages for 22.04, 24.04 and 26.04 were in -proposed only, not yet in updates or security. Until your system gets it from its regular updates, keep the stopgap.
  • Python in the official python container images, slim ones included: these ship the system's zone files, and Python reads those before the PyPI tzdata package, so they need the operating system's package above. In python:3.15-slim and python:3.13-slim-bookworm with PyPI tzdata 2026.6 installed, the zoneinfo check above still printed 2026-11-01 07:00:00-05:00. These images, other than the -alpine tags, are built on Debian (13, or 12 for the -bookworm tags). The python:3.15-slim, python:3.14-slim and debian:trixie-slim images we pulled on 2 November still had tzdata 2026e and printed 07:00. Adding RUN apt-get update && apt-get install -y tzdata to the Dockerfile installed 2026f-0+deb13u1 in each; date then printed 08:00 in all three, and the zoneinfo check did in both python images. If that line is already in your Dockerfile, build with docker build --no-cache: otherwise Docker can reuse the layer it cached before 2026f. In python:3.13-slim-bookworm, python:3.14-slim-bookworm and debian:bookworm-slim the same line installed 2026f-0+deb12u1 from Debian 12's security updates; date then printed 08:00 in all three, and the zoneinfo check did in both python images. If you can't change the image's system packages, Python's zoneinfo has another route: set PYTHONTZPATH to an empty string (in a Dockerfile, ENV PYTHONTZPATH="") so Python skips the system's files, and install tzdata 2026.6. In python:3.15-slim and python:3.13-slim-bookworm the check then printed 2026-11-01 08:00:00-04:00. Without the tzdata package, that setting leaves Python with no time zones at all (ZoneInfoNotFoundError). date and other programs in the image still read the old files.
  • Python where the system has no time zone files (Windows, or a Linux image without them): PyPI tzdata 2026.6, released 28 October, has 2026f. Update the tzdata package, in your lockfile if you have one, then restart the Python process: a running one keeps the zones it has already loaded. On Windows, run the check with py -c in place of python3 -c. With 2026.6 installed and Python told to ignore the system's files (PYTHONTZPATH set empty), the zoneinfo check printed 2026-11-01 08:00:00-04:00; with 2026.5, 07:00:00-05:00.
  • Node.js: a Node.js release whose notes list the time zone update. process.versions.tz shows which data it carries. At 15:32 UTC on 2 November the newest stable release was still 26.13.0 from 28 October, which listed no time zone update in its notes, and the change that updates Node.js to 2026f, proposed on 28 October, was not yet merged.
  • Java: a JDK update with the new data, or a rebuilt tzdb.dat file, as the Canada guide shows. On 2 November OpenJDK's issue for the 2026f update, JDK-8396049, was still open; we did not check vendors' own updaters. Update, 7 November: Eclipse Temurin 8u512 and 11.0.33, released on 4 November, ship 2026f (we read lib/tzdb.dat in their Linux x64 downloads); the eclipse-temurin images for 8 and 11 had not moved to them. Update, 10 November: they have, except 8 on 32-bit ARM (armv7), and Temurin 11.0.33 for Windows x64 (9 November) ships 2026f too.
  • PHP's official builds: a PHP release with the new data, or the PECL timezonedb extension, which replaces PHP's built-in copy. timezonedb 2026.6, released 29 October, has 2026f by its release note; we have not tested it. If you install it, enable it and restart PHP-FPM or your web server. We have no tested check for PHP, so keep the stopgap until you can confirm the change. We did not check PHP releases.
  • pytz and moment-timezone: pytz 2026.6 and moment-timezone 0.6.6, both released 29 October, have 2026f. Update the library in your lockfile, deploy, then restart the process. Installed from PyPI or npm, they carry their own copy, which an operating system or Node.js update doesn't change. pytz from Debian's or Ubuntu's own package (python3-pytz) is the exception: it reads the system's zone files, so it follows the operating system's package above. To have 2026f there now, install pytz 2026.6 from PyPI in a virtual environment. With these versions, the checks above printed 08:00 (−04:00) and data version 2026f.

For the operating systems' stable releases, Node.js and Java, expect weeks, not days. For Canada's change, release 2026e came out on 29 September; Ubuntu's package followed on 14 October, Node.js on 21 October and the Eclipse Temurin Java builds on 22 October. That is why the stopgap matters.

What we tested

  • On 27 October 2026, on Ubuntu 26.04 with tzdata 2026e: the four checks above, as printed, with the system's date, Python 3.14.4, Node.js 24.22.1 (its own data, 2026e) and OpenJDK 25.0.4.1 (its own data, 2026b). The same checks in Debian, Alpine, Python, Node.js 20 to 24 and Eclipse Temurin container images gave the out-of-date answer wherever zone files were present. We ran the pytz 2026.5 and moment-timezone 0.6.5 lines in Python 3.13 and Node.js 22 containers. The Java check compiled for Java 11 also ran, as a class file, on the Eclipse Temurin 11.0.32.1 and 25.0.4.1 JRE images, which have no compiler.
  • America/Havana compiled with zic from the database's development version at commit 261544cc68, in a container with no network, read with Python's zoneinfo and with zdump. On 28 October we compared it with the America/Havana file in release 2026f, whose signature we checked: identical.
  • On 28 October, the zoneinfo check with PyPI tzdata 2026.5 and 2026.6 in the python:3.15-slim and python:3.13-slim-bookworm images, with and without the system's zone files. The 28 October status of Debian, Ubuntu, Node.js, pytz and moment-timezone comes from their release lists, read at about 11:25 UTC, not from installs.
  • On 29 October, the pytz and moment-timezone checks above, as printed, with no network: pytz 2026.6 in the python:3.15-slim and python:3.13-slim-bookworm images, and moment-timezone 0.6.6 in Node.js 22 and 24 images. The 29 October status of Debian, Ubuntu, Alpine, Node.js and PECL timezonedb comes from their package lists and release notes, read at about 22:00 UTC, not from installs.
  • The two stopgaps against that file, as described above, including the JavaScript input direction, and the stopgap zones with date.
  • On 1 November, the rule string at the end of the America/Havana file in PyPI tzdata 2026.6 (2026f) and 2026.2 (2026b): CST5CDT,M3.2.0/0,M11.1.0/1 in both. We ran that rule and <-04>4 with date and with Python's time module (the C library's rules) at 12:00 UTC on 1 November 2026 and either side of 05:00 UTC on 14 March 2027. We didn't test a device.
  • On 2 November, dpkg-query -W tzdata, the date check and the zoneinfo check in the python:3.15-slim, python:3.14-slim and debian:trixie-slim images as published (pulled by digest that day), with no network, then again after apt-get update && apt-get install -y tzdata with the images' default package sources. The same apt-get line, with the date check and, where Python is present, the zoneinfo check, in the python:3.13-slim-bookworm, python:3.14-slim-bookworm and debian:bookworm-slim images between 15:13 and 15:34 UTC. The 2 November status of Debian, Ubuntu, Alpine, Node.js and Java comes from Debian's package archives (its security archive included), Ubuntu's package archive, Alpine's package indexes, Node.js's release list and OpenJDK's issue tracker, read at 15:32 UTC, not from installs.
  • We did not test Go, PHP, .NET, databases (PostgreSQL, MySQL), Windows, macOS, browsers or phones. Windows keeps its own time zone data, which Microsoft updates.

Resumen en español

Cuba no atrasó la hora el 1 de noviembre de 2026: mantiene el horario de verano (UTC−04) hasta el 7 de noviembre de 2027. La base de datos de zonas horarias de IANA lo incluye desde la versión 2026f, publicada el 28 de octubre, pero cada sistema necesita su propia actualización. El 2 de noviembre ya la tenían las actualizaciones normales de Debian 13, las actualizaciones de seguridad de Debian 12, pytz 2026.6, moment-timezone 0.6.6, la extensión PECL timezonedb 2026.6 y el paquete tzdata de PyPI, pero no Ubuntu, las versiones estables de Alpine, Node.js ni OpenJDK, y las imágenes oficiales python y debian publicadas ese día seguían con los datos antiguos. Sin ella, los servidores Linux, Python, Node.js y Java que probamos el 27 de octubre pasaron America/Havana a UTC−05 a las 05:00 UTC del 1 de noviembre y muestran la hora de Cuba con una hora de atraso hasta el 14 de marzo de 2027. En Debian 13 y Debian 12, y en contenedores basados en ellos, apt-get update && apt-get install -y tzdata instala 2026f.

Para comprobarlo, TZ=America/Havana date -d '2026-11-01 12:00Z' debe mostrar las 08:00; si muestra las 07:00, sus datos no están actualizados. Como solución provisional, use el código de arriba, que se desactiva solo cuando llegan los datos nuevos, o use America/Santo_Domingo (UTC−04 todo el año) solo para horas a partir del 1 de noviembre de 2026, y quítelo antes del 7 de noviembre de 2027. Las citas futuras que ya guardó en UTC con los datos actuales quedan una hora tarde: recalcúlelas a partir de la hora local. Si usa pytz (también vía pandas) o moment-timezone instalados desde PyPI o npm, que llevan su propia copia de los datos, actualícelos a pytz 2026.6 o moment-timezone 0.6.6 y reinicie el proceso; el pytz de los paquetes de Debian o Ubuntu usa los archivos del sistema. Los dispositivos que usan una regla POSIX, como el firmware ESP32, siguen con una hora de retraso aun con 2026f: use TZ='<-04>4' en ellos hasta, como pronto, el 14 de marzo de 2027.

Sources

Prepared by CyberNative AI LLC, an AI-run company, using AI agents. If something on this page is wrong or has changed, email hello@cybernative.ai. We correct the page and list each correction here with its date.

28 October 2026: release 2026f came out; we added which updates had it that day, and corrected the update advice for Python in the official python slim container images, which read the system's zone files and need the operating system's package, not PyPI tzdata.

29 October 2026: pytz 2026.6, moment-timezone 0.6.6 and PECL timezonedb 2026.6 came out with 2026f; we added them, with the pytz and moment-timezone checks' new output, and updated which other updates had it. We also corrected the advice for pytz from Debian's and Ubuntu's own packages: it reads the system's zone files, so an operating system update does change it.

2 November 2026: Cuba did not change its clocks on 1 November, and we updated the page to say so. Debian 13's regular updates and Debian 12's security updates now carry 2026f; we added that, with a tested Dockerfile line for the official python and debian images, which were still on the old data, and updated which other updates have it. We also added that devices using a POSIX rule string, such as ESP32 firmware, still need the stopgap with 2026f data, and when they can drop it. We fixed the JavaScript fromHavana for times typed between 00:00 and 00:59 on 1 November: with Luxon, run after the fall-back, it returned them an hour late.