Meta description: ROS 2 Lyrical Luth LTS ships 22 May 2026 with Zenoh RMW support, rosbag2 observability, and a Python 3.12 floor — here’s when to leave Humble or Jazzy.
ROS 2 Lyrical Luth, the twelfth release of ROS 2 and the new Long-Term Support (LTS) distribution, was released on 22 May 2026 and is supported until May 2031, according to the official ROS 2 documentation. If you run a maker robot or a student project on a Raspberry Pi or a Jetson, this is the first LTS since Jazzy Jalisco — a five-year support commitment, not another ten-month hop. This article is a practical upgrade decision: what actually changed, how Humble, Jazzy, and Lyrical compare, and a step-by-step migration path for each fleet.
Why Lyrical Luth matters for edge robots
Lyrical Luth is a Long Term Support release supported until May 2031, per the ROS 2 documentation. For hardware you cannot reflash every year, that is the entire argument: one install, five years of maintained support. It is the first LTS anchored to Ubuntu Resolute 26.04 as its Tier-1 deb-package target, as the ROS 2 platform page and RoboCloudHub’s guide both confirm.
The IoT Digital Twin & PLM migration guide frames the cadence clearly: ROS 2 ships roughly one release every May, alternating standard releases (~18 months of support) and LTS releases (five years). Lyrical replaces the short-lived standard release Kilted Kaiju, which reached end-of-life in November 2026. The practical consequence: teams that adopted Kilted must move sooner than teams still on an LTS.
What changed in Lyrical Luth
Zenoh becomes a first-class RMW option
The most architecturally significant change: Lyrical supports the rmw_zenoh_cpp implementation alongside DDS-based RMWs. RoboCloudHub notes Fast DDS remains the default when installed, with Zenoh as an optional selection — and, critically, Cyclone DDS is still fully available via RMW_IMPLEMENTATION=rmw_cyclonedds_cpp. Nothing breaks. Zenoh is an addition, not a replacement.
RoboCloudHub’s guidance is where the consumer value sits: Zenoh is a pub/sub plus query/reply protocol designed for edge and cloud deployments, and it is often a better fit than DDS discovery for robots spread across subnets, VPNs, Docker/Kubernetes, or constrained wireless links. For a single robot on a LAN — the typical Pi or Jetson bench setup — Fast DDS remains the simpler default. Reserve Zenoh for fleets where DDS discovery is painful to operate.
Better rosbag2 and topic observability
Lyrical brings the debugging improvements a robot builder actually feels, per the official release notes:
- Message-loss observability.
ros2 bag record --all --stats_max_publishing_rate 10publishes loss statistics on theros2 topic echo /events/rosbag2_messages_lostevent — catching dropped data early during recording. - Remote and programmatic bag control. Bag recording can be controlled remotely using ROS services, and playback/recording can be driven from Python.
- Circular bag recording. Record in a ring with a size and file-count cap, e.g.
ros2 bag record --all --max-bag-size 100000000 --max-bag-files 5. ros2 topic bwon multiple topics at once (or--all) to find which topics eat your network bandwidth.ros2 doctor --reportnow reports actions, services, and ROS environment variables — useful when filing issues or pasting into an AI debugger.- Fish shell support via
setup.fish.
Executor, Python, and tooling shifts
For resource-constrained boards, the headline compute change is the new Callback Group Events executor (EventsCBGExecutor) in rclcpp. The ROS 2 release notes report it uses 10% to 15% less CPU than the standard single- and multi-threaded executors, and it can be selected at container launch via --executor-type events-cbg. The IoT Digital Twin guide notes this is “selectable at container launch via a new –executor-type argument.”
The one change that will force real work: the Python floor rises to 3.12. RoboCloudHub’s Jazzy-to-Lyrical migration table lists the minimum Python version moving from 3.10 (Jazzy) to 3.12 (Lyrical). That means authoring for the newer Python — but it also means any ROS 2 C++ packages you compiled yourself must be rebuilt against the Lyrical binaries, because compiled packages are not portable across distributions. The IoT Digital Twin guide underscores this for the common amd64-plus-arm64 shape: both architectures need rebuilding and re-testing, since Lyrical’s arm64 Tier-1 status guarantees the ROS packages, not your OS-level dependencies.
Other practical additions in the same release (per ROS docs): per-message log severity in launch files, new XML/YAML launch substitutions, rclpy AsyncNode for asyncio, URDF 1.2 (quaternions, capsule geometry, acceleration/deceleration/jerk limits), and a generic resource-retriever service for loading meshes over the network.
Jazzy vs Humble vs Lyrical: the trade-offs
Humble and Jazzy are LTS anchors; Kilted is the short-lived standard release between them; Lyrical is the new LTS through May 2031, with Makoa Mata-mata due May 2027 — the timeline presented in the IoT Digital Twin & PLM guide. The EOL dates below come from that same lineage: Humble ends May 2027, Jazzy ends May 2029, Kilted ends November 2026.
| Distribution | Released (approx.) | EOL | Key change | Recommended action |
|---|---|---|---|---|
| Humble Hawksbill (LTS) | 2022 | May 2027 | Now three major jumps behind | Do not start new work on it; plan an upgrade to Lyrical this cycle |
| Jazzy Jalisco (LTS) | 2024 | May 2029 | Python 3.10 floor; no Zenoh-as-supported | Can wait, but Lyrical is the better target for anything built after mid-2026 |
| Kilted Kaiju (standard) | 23 May 2025 | Nov 2026 | Short runway; immediate successor of Lyrical | Move now — the shortest deadline on this board |
| Lyrical Luth (LTS) | 22 May 2026 | May 2031 | Zenoh RMW, rosbag2 observability, Python 3.12 floor, EventsCBGExecutor | Default for all new robots and any rebuild you can schedule |
The honest reading: Humble users have a deadline (May 2027) but not imminent breakage; Kilted users have the shortest runway (November 2026) and should move first; Jazzy users have three more years but gain nothing by waiting.
How to migrate, step by step, per distro
From Jazzy (and most Humble/Kilted scenarios) to Lyrical. The IoT Digital Twin & PLM path, which compresses to five steps:
-
Do a partition, not a swap. Lyrical targets Ubuntu Resolute 26.04. On a Pi or Jetson, migrate the OS and the ROS layer as one bounded exercise — reserve a fresh SD card or NVMe image rather than upgrading in place.
-
Verify availability before touching your robot. Check every third-party driver, sensor SDK, and nav-stack plugin for a Lyrical release on the ROS index under the
lyricaldistribution. This is where migrations stall — a rebuilt driver you rely on gates everything. -
Install the apt source, then the desktop stack.
sudo apt install -y ros-lyrical-desktop -
Resolve and build against the Lyrical distro explicitly. Rebuild all source packages — especially C++ ones — against Lyrical:
source /opt/ros/lyrical/setup.bash rosdep install --from-paths src --ignore-src -r -y --rosdistro lyrical rm -rf build install log colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=ReleaseOn a Jetson, budget much longer wall-clock for the arm64 rebuild, and re-validate any hardware-acceleration (CUDA/JetPack) wrapper scripts against the fresh OS image.
-
Change one variable at a time. The IoT Digital Twin guide’s sharpest warning: do not switch your RMW during the distribution upgrade. If you want Zenoh, verify the robot on Fast DDS first, then switch
RMW_IMPLEMENTATIONin a separate session.
Python-specific check. Because the floor is now 3.12, audit any vendored Python code you carry (f-strings, match, older syntax still works; the risk is packages built for 3.10). Recreate your virtual environments against the Lyrical Python.
The key gotcha: mixed-distro fleets. Migration failures rarely happen at the compiler — they happen at the seam when part of your fleet runs Lyrical and part runs an older distro and they must talk. Test cross-distro interop explicitly on a bench clone before rolling a fleet, and never run Kilted and Lyrical machines interchangeably without verifying the protocol between them.
When to upgrade: the verdict
For a maker or student on a Pi or Jetson, the decision is simpler than the industry framing suggests:
- New project, new build? Install Lyrical Luth now. There is no reason to start anything on Humble in 2026.
- Happy on Jazzy, robot works? You have until May 2029 and nothing forcing your hand immediately — but scheduling the upgrade within your hardware’s refresh cycle is cheaper than a forced one.
- On Kilted or Humble? You are on the clock (November 2026 and May 2027, respectively). Treat Lyrical as your target and migrate before the support window closes.
The Zenoh option, the rosbag2 observability, the CPU-savings executor, and — most importantly — a support line running to May 2031 make Lyrical Luth the reference install for anyone rebuilding a robot in the second half of 2026.
Reviewed and approved by Prof. Ajay S., professor at a State University in Delhi.