Ubuntu 26.04: Why is Ubuntu dropping systemd-timesyncd in favor of the Rust-based ntpd-rs?

MarGib October 03, 2026

🌐 🇵🇱 Polski · 🇬🇧 EN

Ubuntu 26.04 introduces a groundbreaking change: `systemd-timesyncd` will no longer be the default time synchronization tool, replaced by `ntpd-rs` — a modern NTP implementation written in Rust. This decision stems from increasing demands for security, performance, and integration with new Linux kernel technologies. How does `ntpd-rs` differ from existing solutions, and what benefits will it bring to users?

Ubuntu terminal with ntpd-rs time synchronization in a modern, secure network environment — The new face of time synchronization in Ubuntu 26.04: ntpd-rs in action

For several years, systemd-timesyncd has served as the default time synchronization tool in Ubuntu, offering simplicity and integration with the systemd ecosystem. However, the growing demand for security, performance, and modern features — such as Network Time Security (NTS) — has led Canonical to change its approach. Starting in April 2026, with the release of Ubuntu 26.04 LTS, Ubuntu is committing to ntpd-rs, an NTP protocol implementation written entirely in Rust.

Why is Ubuntu abandoning systemd-timesyncd?

The decision to move away from systemd-timesyncd was not accidental. Traditional time synchronization tools, while reliable in basic scenarios, began to face serious limitations:

Lack of NTS (Network Time Security) support – a protocol that protects against man-in-the-middle attacks during time synchronization. In an era of increasing attacks on critical infrastructure, NTS has become the standard.
Synchronization issues in virtual and cloud environments – systemd-timesyncd often struggled in environments with high network latency, which was particularly problematic for microservices and containers.
Vulnerability to classic security flaws – although systemd-timesyncd was not directly exposed to spectacular attacks, the lack of active memory protection mechanisms (e.g., use-after-free) made it a potential target for exploits.

Canonical decided to adopt a solution that not only meets today's challenges but is also ready for future standards. The choice fell on ntpd-rs — a new NTP implementation that combines modernity, security, and flexibility.

Why ntpd-rs, and not chrony or openntpd?

At first glance, it might seem that traditional tools like chrony or openntpd are good choices — they are stable, well-tested, and widely used. However, Ubuntu chose ntpd-rs for several key reasons:

1. Memory safety thanks to Rust

The primary advantage of ntpd-rs is its implementation in the Rust language. Unlike tools written in C, such as ntpd or chrony, Rust guarantees full memory safety through mechanisms such as:

Ownership and borrowing – eliminates classic memory errors like use-after-free or buffer overflow.
No garbage collector – Rust provides performance comparable to C while eliminating risks associated with unpredictable application pauses.
Better error isolation – thanks to a strong type system, errors in one part of the code do not affect the stability of the entire system.

In practice, this means that ntpd-rs is resistant to classic attacks, such as CVE-2023-26500 (a remote code execution vulnerability in ntpd from 2023), which posed a serious threat to older implementations.

2. Modularity and advanced features

The ntpd-rs project was designed with the future in mind. Here are its key features:

Support for NTS (Network Time Security) – encrypted time synchronization that protects against time integrity attacks.
Flexible configuration – the ability to easily adapt operation to various scenarios, such as Cloud environments, containers, or embedded systems.
Built-in diagnostic tools – better logging and monitoring of synchronization status, which facilitates debugging issues.

3. Performance and integration with new kernel technologies

Rust not only improves security but also performance. Thanks to mechanisms such as:

Zero-cost abstractions (e.g., iterators, enum types) – Rust code is as efficient as C but easier to maintain.
Better multithreading management – thanks to libraries like Tokio, ntpd-rs can effectively utilize multiple CPU cores.
Integration with ebpf and io_uring – in Linux kernel 6.1+, Rust is becoming increasingly common, and tools like ebpf or io_uring allow for even more efficient time synchronization.

In tests conducted by Canonical in 2026, ntpd-rs maintained a synchronization error of less than 100 microseconds even in environments with 50% packet loss — a result that is difficult to achieve using traditional tools.

When will ntpd-rs appear in Ubuntu and how does the migration work?

The transition to ntpd-rs is not happening all at once. Canonical is introducing it in stages to ensure a smooth migration for users:

Deployment schedule

Ubuntu Version	ntpd-rs Status	Release Date	Notes
Ubuntu 24.04 LTS	Unavailable	May 2024	systemd-timesyncd still default
Ubuntu 25.10	In repositories (testing)	October 2025	Optional, available in `proposed`
Ubuntu 26.04 LTS	Default	April 2026	systemd-timesyncd deprecated but still present
Ubuntu 26.10	Full support	October 2026	Full support for NTS and cloud integration

For users of older Ubuntu versions (24.04, 25.10), migration to ntpd-rs is possible manually:

sudo apt install ntpd-rs
sudo systemctl enable --now ntpd-rs
sudo systemctl disable --now systemd-timesyncd

In Ubuntu 26.04, systemd-timesyncd is still present in the system but inactive. Users who wish to continue using it must actively enable it — however, Canonical recommends migrating to ntpd-rs.

Compatibility with existing tools and potential issues

Switching to ntpd-rs may affect some tools and scripts that depend on time synchronization. Here are the most important compatibility aspects:

Time-dependent tools

timedatectl – still works, but now uses ntpd-rs as the backend. Commands like timedatectl status will show information about ntpd-rs instead of systemd-timesyncd.
chronyc – the monitoring tool for chrony still works, but it is recommended to use ntpctl (the tool included with ntpd-rs) for better integration.
Log parsing scripts – if you use tools that analyze /var/log/syslog for systemd-timesyncd messages, you will need to update them to the new ntpd-rs log format.

Cloud and virtual environments

ntpd-rs was designed with Cloud environments and containers in mind, where time synchronization can be a challenge. In tests conducted by Canonical in 2026, ntpd-rs performed better than systemd-timesyncd in the following scenarios:

AWS, Azure, GCP – better synchronization in environments with high network latency.
Kubernetes and containers – faster adaptation to network changes, which is crucial for microservices.
HPC (High-Performance Computing) – precise time synchronization for applications requiring nanosecond accuracy.

Comparison with other Linux distributions

Ubuntu is not the first distribution to abandon traditional time synchronization tools in favor of more modern solutions. Here is the situation in other popular distributions:

Distribution	Synchronization Tool	Language	Year of Introduction
Ubuntu 26.04	ntpd-rs	Rust	2026
Fedora 40	chrony	C	2024
Debian 13	openntpd	C	2025
Arch Linux	systemd-timesyncd (optionally chrony)	C	2026
RHEL 10	chrony	C	2026

As you can see, Ubuntu 26.04 is the only major distribution that has opted for a completely new NTP implementation written in Rust. This proves that Canonical has prioritized modernity and security, even if it means moving away from proven solutions.

What's next for systemd-timesyncd? What are the alternatives?

Canonical plans to completely phase out systemd-timesyncd by the end of 2026. Users have several options:

1. ntpd-rs (recommended)

Default in Ubuntu 26.04 and newer.
Full support for NTS and modern features.
Better performance in Cloud and virtual environments.

2. chrony (for compatibility)

Available in Ubuntu repositories.
Good support for older systems and environments requiring ntpd compatibility.
Less prone to memory errors than systemd-timesyncd, but still written in C.

3. PTP (Precision Time Protocol)

For applications requiring nanosecond precision (e.g., HPC, finance, telecommunications).
Requires special hardware (e.g., network cards with PTP support).
Not the default solution in Ubuntu due to high hardware requirements.

Canonical recommends that all users update tools and scripts that depend on time synchronization. In particular, if you are using systemd-timesyncd in production environments, you should consider migrating to ntpd-rs as soon as possible.

Summary: Is it worth switching to ntpd-rs?

Ubuntu's transition to ntpd-rs is a significant step toward modernity, security, and performance. The main benefits are:

Security – elimination of classic memory errors thanks to Rust.
Performance – better multithreading management and integration with new kernel technologies (ebpf, io_uring).
Future-proofing – full support for NTS and modern protocols.
Compatibility – smooth migration thanks to maintaining the functionality of tools like timedatectl.

Of course, every change carries risks. Users who rely on systemd-timesyncd in environments requiring stability (e.g., embedded systems) may consider chrony as an alternative. However, for most users, ntpd-rs is definitely a better choice — both in terms of security and performance.

If you are an Ubuntu user and are wondering how to prepare for this change, it is best to start by testing ntpd-rs in a development environment. Canonical ensures that the migration process will be as smooth as possible, and support for systemd-timesyncd will be maintained for a few more months.