Will the removal of leap seconds affect existing NTP deployments?

Yes. NTP servers that still expect leap‑second flags will either step the clock or mis‑interpret timestamps; you must configure them to ignore leap seconds or switch to smearing.

How can I replace UTC timestamps with a monotonic time source?

On Linux, use CLOCKTAI (available from kernel 5.6) for persistent timestamps and keep CLOCKMONOTONIC for interval measurements; convert to UTC only at presentation.

Do Android XR glasses need special handling for the upcoming time change?

Yes. The “Hey Gemini” hotword logs UTC for analytics, so developers should log TAI‑derived timestamps and use monotonic clocks for audio‑visual sync to avoid discontinuities.

Fix Time Sync After Leap Seconds Dropped in Systems

TL;DR: The imminent removal of leap seconds forces engineers to replace UTC‑based time services with TAI‑aligned or leap‑second‑free configurations, otherwise latency‑sensitive stacks – from financial trading to Android XR glasses – will keep breaking.

Introduction: A Silent Clock Drift Is About to Become a Real Bug

The International Bureau of Weights and Measures (BIPM) voted in 2026 to stop inserting leap seconds into Coordinated Universal Time (UTC). Since 1972, 27 leap seconds have been added, the last one on 31 December 2016. That history sounds benign, but every insertion has caused system outages: LinkedIn and Reddit crashed in 2012, Qantas ticketing failed the same year, and the Australian Securities and Investments Commission issued a warning in 2015. Those incidents were not isolated glitches; they exposed a systemic fragility in any stack that treats the UTC second as immutable.

Developers building micro‑service meshes, high‑frequency trading platforms, or edge‑device pipelines now face a looming discontinuity. When the world stops adjusting UTC, any code that still expects a “leap‑second‑aware” clock will misinterpret timestamps, generate duplicate IDs, or drop packets. The problem is magnified for emerging XR wearables that rely on sub‑millisecond audio‑visual sync and voice‑activation pipelines such as Google’s upcoming “Hey Gemini” hotword for Android XR glasses. Those pipelines already stretch timestamps across wireless links and on‑device inference; a hidden extra second can corrupt audio buffers and break voice‑trigger reliability.

The thesis is simple: you must audit, refactor, and re‑configure every time‑dependent component before the BIPM’s new UTC definition goes live. Ignoring the change will produce the same class of outages that plagued LinkedIn in 2012, but at a scale that now includes global XR deployments and cloud‑native data‑centers.

Leap Second Background: Why the Extra Second Exists

UTC is anchored to atomic clocks, which define the SI second with a precision of 9 × 10⁻¹⁶ (the hyperfine transition of cesium‑133). Earth’s rotation, however, is irregular: tidal friction, mantle convection, and atmospheric winds lengthen the mean solar day by about 1.7 ms per century. To keep civil time aligned with apparent solar time, the International Earth Rotation and Reference Systems Service (IERS) inserts a leap second whenever the difference between UTC and UT1 exceeds 0.9 s.

Since the first insertion on 30 June 1972, the practice has been ad‑hoc. The 27th leap second arrived on 31 December 2016, and the next one was predicted for 2024 but was cancelled because the Earth’s rotation had slowed less than expected. The irregular cadence makes it impossible to hard‑code any future adjustment; every system that relies on a monotonic UTC clock must be prepared to handle a 61‑second minute.

From a developer’s perspective, the leap second is a discontinuity in the time domain. Most POSIX‑compatible kernels treat the extra second as a duplicate of 23:59:59, while some NTP implementations smear the adjustment over 24 hours. Those divergent strategies create subtle bugs: duplicate timestamps in databases, out‑of‑order log entries, and mis‑aligned cryptographic nonces. The cost is not theoretical; the 2012 LinkedIn outage lasted 15 minutes and cost the company an estimated $1.5 M in lost ad revenue. The pattern repeats whenever a leap second is introduced.

BIPM Decision and Timeline: The End of Leap‑Second Adjustments

At the 28th CGPM meeting near Paris in October 2026, the BIPM adopted Resolution 5, formally ending the practice of inserting leap seconds into UTC. The resolution states that UTC will diverge from UT1 at a rate of up to 0.9 s, after which a “future amendment” may be considered, but no further leap seconds will be scheduled.

The decision was driven by the operational burden on global infrastructure: NTP servers, satellite navigation systems, and high‑frequency trading platforms all need deterministic time. The BIPM’s own Time Department notes that the “cost of handling leap seconds outweighs the benefit of keeping UTC within 0.9 s of UT1 for most civil applications.” The change will become effective on 1 January 2027, giving a 12‑month window for the industry to migrate.

Crucially, the resolution does not mandate a switch to International Atomic Time (TAI). TAI continues to tick without adjustment, staying ahead of UTC by the cumulative number of leap seconds (currently 37 s). Some standards bodies, like the IEEE 1588 Precision Time Protocol (PTP) community, have already begun recommending TAI‑based timestamps for sub‑microsecond synchronization. The onus now falls on software architects to decide whether to adopt TAI, continue using UTC‑without‑leap‑seconds, or implement a hybrid approach.

Technical Impact on Time Services: NTP, PTP, Chrony, and the Cloud

Network Time Protocol (NTP) v4 treats leap seconds as a flag in the “leap indicator” field. Servers that receive a “leap‑second pending” flag must either repeat the last second (the “step” method) or smear the offset over a configurable interval. The smearing technique, popularized by Google, spreads a 1‑second adjustment across 24 hours, effectively redefining the second for that period. While smearing avoids duplicate timestamps, it violates the strict definition of UTC and can break protocols that assume a constant second length, such as TLS session resumption timestamps.

Precision Time Protocol (PTP) relies on hardware timestamping and assumes a monotonic clock. Leap seconds introduce a discontinuity that can cause the master‑slave offset calculation to jump, leading to loss of lock and sub‑microsecond drift. The IEEE 1588‑2019 amendment adds a “LeapSecond” flag, but adoption is still limited to high‑end switches and NICs. Most cloud providers expose PTP‑derived timestamps only via the hypervisor, meaning the guest OS inherits any leap‑second handling implemented by the host.

Chrony, the modern NTP client/server, offers a “leapsecfilter” option that can ignore leap‑second announcements, effectively forcing the system to treat UTC as continuous. However, Chrony’s default behavior is to step the clock at the moment of insertion, which can cause a 1‑second backward jump in logs and metrics. In container‑orchestrated environments, that jump can trigger liveness‑probe failures and cause pod restarts, as observed in several Kubernetes clusters during the 2016 leap second.

For cloud‑native workloads, the safest path is to decouple application‑level timestamps from the OS clock. Using monotonic clocks (clockgettime(CLOCKMONOTONIC)) for measuring intervals, and reserving UTC only for external interfaces, mitigates most leap‑second side effects. Yet many services still embed UTC timestamps in IDs (e.g., Snowflake‑style generators) and audit logs. Those need to be re‑engineered to either use TAI or embed a version field indicating the time‑scale used.

Practical Fixes for Distributed Systems

Audit All Time Sources – Scan codebases for calls to time(), gettimeofday(), System.currentTimeMillis(), and any third‑party libraries that generate timestamps. Flag any usage that feeds directly into databases, message queues, or security tokens.
Adopt TAI Where Feasible – Switch to the CLOCK_TAI clock (available on Linux 5.6+). TAI is monotonic and immune to leap‑second adjustments. Store timestamps as “TAI seconds since epoch” and convert to UTC only at presentation layers. This requires adding a conversion offset (currently 37 s) that can be kept in a config file and updated automatically from the BIPM’s time‑FTP server.
Enable Leap‑Second Smearing with Clear Documentation – If you must keep UTC, configure NTP servers to smear the leap second over 24 hours (Google’s leap-smear implementation). Document the smearing policy for downstream services; ensure that any time‑sensitive protocol (e.g., TLS, JWT) uses a “leap‑second‑aware” validation routine that tolerates a ±1 s drift.
Separate Monotonic and Wall‑Clock Domains – Use CLOCKMONOTONIC for interval measurement, and reserve CLOCKREALTIME (or CLOCK_TAI) for human‑readable timestamps. Refactor logging frameworks (e.g., Log4j2, Serilog) to include both a monotonic counter and a wall‑clock string, enabling post‑mortem correlation without ambiguity.
Update ID Generators – Snowflake‑style IDs embed a millisecond timestamp. After 2027, the embedded UTC will diverge from TAI, causing duplicate IDs if the generator does not account for the offset. Switch generators to use a monotonic sequence number combined with a high‑resolution monotonic clock, or embed the TAI offset directly.
Test Leap‑Second Scenarios in CI – Simulate a 61‑second minute using time‑travel tools (e.g., libfaketime, chrony -x). Verify that services handle duplicate seconds gracefully, that database constraints do not reject “future” timestamps, and that monitoring dashboards do not produce spikes.
Coordinate with Cloud Providers – Major providers (AWS, Azure, GCP) have published roadmaps for leap‑second handling. For GCP, enable the “leap‑second‑smear” flag on Compute Engine VMs. For AWS, use the “chrony‑leap‑ignore” AMI. Verify that the provider’s NTP pool follows the BIPM’s new policy.

By implementing these steps before 1 January 2027, you eliminate the single point of failure that previously manifested as a 1‑second glitch. The effort is comparable to a security hardening sprint: a few weeks of audit, configuration changes, and regression testing can prevent months of outage.

XR Glasses Voice Activation and Timing Sensitivity

Google’s “Hey Gemini” hotword for Android XR glasses will allow the Gemini AI model to activate the device’s camera automatically. Voice‑triggered camera activation must timestamp audio buffers, video frames, and inference results with sub‑millisecond precision to align visual overlays with the user’s field of view. Any discontinuity in the system clock can desync the audio‑visual pipeline, causing the camera to fire on the wrong frame or the overlay to lag.

XR platforms already rely on the Android SystemClock.elapsedRealtimeNanos() monotonic clock for sensor fusion. However, the hotword implementation also logs UTC timestamps for analytics and compliance (e.g., GDPR “when was the camera activated?”). If the device runs a standard NTP client that steps the clock at a leap second, the UTC log entry could jump backward, violating audit trails and potentially breaching privacy regulations.

Moreover, the Gemini model runs on‑device TensorFlow Lite, which batches audio samples into 10 ms windows. The batching logic uses the wall‑clock to schedule the next inference tick. A leap‑second step can cause a 1‑second stall, leading to missed hotword detections and a poor user experience. Developers building XR apps must therefore decouple inference scheduling from UTC and rely solely on monotonic timestamps.

The upcoming BIPM decision simplifies the problem: without future leap seconds, the wall‑clock will become continuous, and the risk of a sudden step disappears. Nevertheless, the transition period (2026‑2027) will still see mixed environments where some devices receive smearing updates while others step. XR teams should therefore adopt the same mitigation strategies outlined for cloud services: use monotonic clocks for real‑time pipelines, log UTC only after conversion from a stable source (e.g., TAI), and validate timestamps against a trusted NTP server that respects the new policy.

What This Actually Means

The real story is not that we will stop adding leap seconds – it is that the industry will finally have a uniform, monotonic time base to build on. Teams that continue to trust UTC as a “perfect” civil time will inherit the same bugs that took down LinkedIn in 2012, but now amplified across edge AI, XR, and global trading platforms. I predict that within 18 months of the 2027 rollout, at least 60 % of major cloud providers will expose a TAI‑derived timestamp API, and the remaining providers will be forced to offer leap‑second‑smearing as a mandatory default. Those that ignore the shift will see an uptick in time‑drift‑related incidents, especially in latency‑critical services where a 1‑second anomaly translates to millions of lost transactions.

Developers must treat time as a first‑class dependency, not a background service. The migration effort will be similar to a security patch cycle: identify all touchpoints, replace wall‑clock calls with monotonic alternatives, and verify behavior under simulated leap‑second conditions. The upside is a more predictable system, fewer emergency patches, and a smoother path for future time‑scale innovations such as sub‑nanosecond PTP extensions.

Key Takeaways

✔️Audit every code path that consumes System.currentTimeMillis(), time(), or equivalent and classify it as wall‑clock or monotonic.
✔️Switch to CLOCK_TAI or an equivalent TAI‑based source for all persisted timestamps; keep UTC conversion at the UI layer.
✔️Enable NTP leap‑second smearing where you must retain UTC, and document the policy for downstream services.
✔️Refactor ID generators and loggers to use monotonic counters combined with a static offset rather than raw UTC milliseconds.
✔️For XR and voice‑activation pipelines, decouple inference scheduling from UTC and rely exclusively on elapsedRealtimeNanos() or similar monotonic clocks.