ROS 2 Humble vs Jazzy vs Iron: Which Distro Before EOL (2026)

한국어로 읽기

On 2026-10-04 I ran one script 5 times inside the official ros:jazzy-ros-base Docker image. It did three things. It checked which ROS 2 distro and which Ubuntu release the image is actually built on. It used the container clock to work out how many months each distro has left before its end-of-life (EOL) date in the official Releases table. And it sent 100 messages between two Jazzy nodes running in separate processes. All 5 runs exited with code 0, and every value I had predicted before running came out as predicted.

Here is the short version, computed at 2026-10-04T14:52:16Z (run 1): Iron is at -22 months, which means it reached EOL long ago. Humble has 7 months left, Kilted 2, Jazzy 31 and Lyrical 55. If you start an 18-month project now, Humble runs out of support 11 months before you finish (slack -11). Jazzy still has 13 months to spare (slack 13).

Environment

  • Image: ros:jazzy-ros-base, digest ros@sha256:066420e07f60aa18262f2479981def87ebcfcec42eefb0c0c57c4a46098348ca
  • ROS distro: jazzy on Ubuntu 24.04 (noble)
  • RMW: rmw_fastrtps_cpp (default, RMW_IMPLEMENTATION unset)
  • Python 3.12.3, ros-jazzy-rclpy 7.1.12-1noble.20260902.053513
  • Container limits: 1 CPU, 1 GiB, --network none
  • Runs: 5, all exit code 0 (wall time 4.41 to 4.46 s per run)
  • Script hash (results.json script_sha256): e8baa391a9c0734d697c8a93c32429018dbffe719502352bf561d2138029231a

Prediction vs. result

The predictions came from the plan I wrote before running anything. They were based on the official Releases table and the Jazzy release page.

Check Prediction Measured (identical in all 5 runs)
ROS_DISTRO / Ubuntu jazzy on 24.04 noble jazzy, VERSION_ID=24.04, noble; matches the official Jazzy Tier 1 (24.04): true
Distros under /opt/ros only jazzy ["jazzy"], count 1
Installed ros-* packages all ros-jazzy-, all noble builds 201 installed; 201 with the ros-jazzy- prefix; 201 with a noble build suffix; apt suite noble
Months left (Oct 2026) Humble 7, Jazzy 31, Kilted 2, Lyrical 55, Iron -22 Humble 7, Jazzy 31, Kilted 2, Lyrical 55, Iron -22
Support length from table Humble, Jazzy, Lyrical 60; Iron, Kilted, Makoa 19 Humble, Jazzy, Lyrical 60; Iron, Kilted, Makoa 19
Slack for an 18-month project Humble -11, Jazzy 13, Kilted -16, Lyrical 37 Humble -11, Jazzy 13, Kilted -16, Lyrical 37 (Iron -40)
Last month to start an 18-month project on Jazzy 2027-11 2027-11
Same-distro pub/sub received = sent sent 100, received 100, unique seq 100, in order, publisher distro jazzy

The script tried project lengths of 6, 12, 18, 24 and 36 months. Here is the slack it computed for each (months left minus project length; a negative value means support ends before the project does):

Distro Support (table) Months left 6 12 18 24 36
Humble 60 7 1 -5 -11 -17 -29
Iron 19 -22 -28 -34 -40 -46 -58
Jazzy 60 31 25 19 13 7 -5
Kilted 19 2 -4 -10 -16 -22 -34
Lyrical 60 55 49 43 37 31 19
Makoa 19 not released yet, skipped

Distros that still fit the project, as listed by the script: 6 months: humble, jazzy, lyrical. 12, 18 and 24 months: jazzy, lyrical. 36 months: lyrical.

The pub/sub check used RELIABLE QoS with depth 100. The publisher sent one std_msgs/String roughly every 10 ms. Across the 5 runs, the first message arrived 0.371 to 0.384 s after the subscription was created. Median latency was 0.431 to 0.455 ms, p95 was 0.497 to 0.653 ms, and the maximum was 0.556 to 1.684 ms. The 1.684 ms maximum came from run 4. The publisher endpoint reported node distro_check_publisher, type std_msgs/msg/String, reliability RELIABLE.

The installed Jazzy binaries carried build dates from 20260121 to 20260903, spread over 14 distinct dates.

Raw output from run 1 (platform and summary lines) and run 4 (pub/sub line, the run with the highest max latency), unedited:

{"kind": "platform", "ros_distro_env": "jazzy", "ubuntu_version_id": "24.04", "ubuntu_codename": "noble", "opt_ros_distros": ["jazzy"], "opt_ros_distro_count": 1, "ros_packages_total": 201, "ros_packages_known_not_installed": ["ros-jazzy-rmw-connextdds", "ros-jazzy-rmw-cyclonedds-cpp"], "ros_packages_by_distro_prefix": {"jazzy": 201}, "version_suffix_codenames": {"noble": 201}, "packages_with_build_stamp": 201, "packages_without_build_stamp": [], "oldest_build_date": "20260121", "newest_build_date": "20260903", "distinct_build_dates": 14, "rclpy_deb_version": "7.1.12-1noble.20260902.053513", "ros_apt_suites": ["noble"], "official_tier1_for_running_distro": "24.04", "running_ubuntu_matches_official_tier1": true}
{"kind": "summary", "ok": true, "running_distro": "jazzy", "ubuntu": "24.04", "tier1_match": true, "months_remaining": 31, "received": 100, "sent": 100, "elapsed_seconds": 3.52}
{"kind": "same_distro_pubsub", "rmw_implementation_env": "(unset: default)", "sent": 100, "received": 100, "unique_seq": 100, "in_order": true, "publisher_distros_seen": ["jazzy"], "seconds_to_first_message": 0.384, "latency_ms_median": 0.455, "latency_ms_p95": 0.653, "latency_ms_max": 1.684, "publisher_endpoint": {"node_name": "distro_check_publisher", "topic_type": "std_msgs/msg/String", "topic_type_hash": "RIHS01_df668c740482bbd48fb39d76a70dfd4bd59db1288021743503259e948f6b1a18", "reliability": "RELIABLE"}, "publisher_exit_code": 0}

The first trial runs found two problems in my own script. First, the publisher’s node name was recorded as _NODE_NAME_UNKNOWN_. The script had read the endpoint info right after discovery, before the name had propagated. The fix was to re-read until the real name showed up. Second, dpkg-query 'ros-*' returned two entries with empty versions, ros-jazzy-rmw-connextdds and ros-jazzy-rmw-cyclonedds-cpp. dpkg knows those package names but they aren’t installed. The script now counts only packages in state ii and lists the others separately. The 5 runs above came after both fixes.

Keep in mind what those numbers are. The months-left figures are date arithmetic on the official table, done with the container’s clock. They don’t measure anything about how well a distro is supported, and they will be different if you run the script next month. What the container run actually observed is narrower. The official Jazzy image is tied to Ubuntu 24.04 all the way down to the package build suffix, and two nodes on the same distro exchanged every message. The latency figures are loopback numbers inside one 1-CPU container. They tell you nothing about a real robot network.

“Iron or Humble?” no longer applies

Search for which ROS 2 distro to install and you will still find a 2023 Robotics Stack Exchange thread titled “Which ROS2 Distro? Iron or Humble?”. The asker had a fresh Ubuntu 22.04 install. The accepted answer leaned toward Humble because it is the LTS release. That was sound advice in November 2023. By October 2026 the question itself is out of date:

  • Iron Irwini reached EOL on December 4, 2024 and is on the official End-of-Life list. Don’t start anything new on it, even if the tutorial you’re following uses it.
  • Humble Hawksbill is still supported, but only until May 2027.
  • The supported distros today are Humble, Jazzy, Kilted and Lyrical. These are the highlighted rows of the official distributions table (rendered at docs.ros.org Releases).
Distro Released EOL (official table) Type Tier 1 Ubuntu
Humble Hawksbill 2022-05-23 May 2027 LTS 22.04 Jammy
Iron Irwini 2023-05-23 2024-12-04 (ended) non-LTS 22.04 Jammy
Jazzy Jalisco 2024-05-23 May 2029 LTS 24.04 Noble
Kilted Kaiju 2025-05-23 December 2026 non-LTS 24.04 Noble
Lyrical Luth 2026-05-22 May 2031 LTS 26.04 Resolute
Makoa Mata-mata (planned) May 2027 December 2028 regular release not yet listed

So the useful question is no longer “which name?”. It is whether a distro will still be supported when your project ends.

The rule: months left minus project length must be zero or more

For any distro:

months_left = (eol_year - this_year) * 12 + (eol_month - this_month)
slack       = months_left - project_months     # want slack >= 0

If the slack is zero or positive, the distro’s EOL comes after your project ends. If it’s negative, support ends while you’re still working. That’s the whole method. Applied in October 2026:

  • Project of 7 months or less: Humble technically fits. A 6-month project leaves 1 month of slack, and since EOL is given only as a month, that one month could really be a few weeks. On Ubuntu 22.04 Humble is still the only supported distro with Tier 1 binaries, so this is the case where it makes sense. Still, it leaves very little room.
  • Roughly 8 to 31 months: Jazzy or Lyrical. Jazzy fits until about the 31-month mark.
  • Longer than 31 months: only Lyrical fits among released distros.
  • Kilted: 2 months left, so it’s not a starting point for new work.

The same arithmetic gives the “last safe start” for a distro: subtract your project length from the EOL month. For an 18-month project on Jazzy (EOL May 2029), that’s November 2027. If you start after that, Jazzy will reach EOL before you finish.

Why LTS distros get 60 months and regular ones 19

The policy comes from REP 2000. A new distro comes out every year in May. Even-year releases are LTS and are supported until their Ubuntu LTS reaches the end of standard support. REP 2000 describes that as “5 years”, or “4 years and 11 months” after the ROS release. Odd-year releases target the same Ubuntu as the previous LTS and get 1.5 years, which overlaps the next LTS by six months so you have time to migrate.

Subtracting the table’s months gives 60 for LTS and 19 for regular releases. That doesn’t quite match the policy’s 59 and 18 months. The table only gives EOL as a month, so the arithmetic can be off by up to about a month. Treat 60 and 19 as “months computed from the official table”, not as official support terms.

Second check: the distro decides your Ubuntu version

REP 2000 says it directly: “A single ROS 2 distribution will only have full Tier 1 support for a single Ubuntu LTS” (REP 2000, platforms). Tier 1 means official binary packages you can apt install. Tier 3 means community support, and you build from source.

The container run fits this picture for Jazzy: every installed ROS package was a noble build, and apt pointed at the noble suite. Picking a distro also means picking an Ubuntu version. If your machines have to stay on 22.04, Humble is your only supported binary option. If the subtraction comes out negative, treat that as a sign that it’s time to plan the move to 24.04 and Jazzy, not as a reason to source-build Jazzy on 22.04.

Choosing between Jazzy and Lyrical mostly depends on which Ubuntu you can run, 24.04 or 26.04. Then check that your drivers, your simulator and the packages you depend on (Nav2, MoveIt, vendor SDKs) have actually been released for that distro. The month arithmetic can’t tell you that. Look it up in each project’s own docs.

Third check: put every machine on the same distro

The official docs are explicit: “Nodes are not guaranteed to be able to communicate across distributions… It may or may not work, but it is not supported and should not be relied upon” (Releases, cross-distribution communication). A Humble robot talking to a Jazzy laptop falls into that unsupported category. Put the robot computer, the dev laptops, the simulation PC and your Docker images on one distro.

My run only covers the baseline: two nodes on the same distro, the same RMW and the same container. They got all 100 messages, in order, in every run. I did not test Humble talking to Jazzy, so this article makes no claim about whether that works. The rule above comes from the official support statement, not from a failure I reproduced.

Quick answers

  • Can I still use Iron? Not for anything new. It reached EOL on 2024-12-04, about 22 months before October 2026.
  • Should a new project start on Humble? Only if it will finish within the roughly 7 months Humble has left. Anything longer will hit EOL partway through.
  • Kilted? It reaches EOL in December 2026, so no.
  • Rolling? It has no EOL, but breaking changes land there directly. The official docs recommend that most people use the latest stable distro rather than Rolling. That sentence is about stable vs. Rolling. It is not a recommendation of Jazzy over Lyrical.
  • Makoa? It’s planned for May 2027 with EOL in December 2028, so you can’t start on it today.

Where official sources disagree

The Releases table and REP 2000 don’t agree on two dates. REP 2000 gives Iron as “May 2023 – November 2024” (L970), but the table says December 4, 2024. For Kilted, REP 2000 says “May 2025 – November 2026” (L1204) and the table says December 2026. I used the Releases table because that’s the page that marks which distros are currently supported. With REP 2000’s dates, Kilted would have 1 month left instead of 2 and Iron would be at -23 instead of -22. Neither change affects the conclusion.

Some third-party trackers fill in month-only EOLs with the last day of the month, such as 2027-05-31 for Humble. Those exact days don’t appear in the official table. I also left out claims I’ve seen elsewhere that Humble moves to a “security-fix-only mode”, because I couldn’t find them in the Releases page or REP 2000.

Limits

  • The months-left numbers assume October 2026, and they’re accurate only to the month. Rerun the script, or redo the subtraction, on the day you decide.
  • I didn’t check what happens to apt repositories or packages after EOL. EOL means official maintenance stops. It doesn’t mean your robot stops working the next day.
  • Only one image (ros:jazzy-ros-base) and one RMW (the default Fast DDS) were run. I didn’t run Humble, Lyrical or Kilted containers, and I didn’t test cross-distro or cross-RMW communication.
  • No real robot or simulator was involved. Being on a supported distro does not make a robot safe.

Reproduce it

The script, the plan with the pre-run predictions, and the raw results from all 5 runs are at github.com/sungpyo9053/blog/experiments/ros2-distro-choice-iron-humble-remaining-support-months. The individual files are experiment.py, plan.md and results.json. From a checkout of that directory:

docker run --rm --network none --cpus 1 --memory 1g -v "$PWD":/work \
  ros@sha256:066420e07f60aa18262f2479981def87ebcfcec42eefb0c0c57c4a46098348ca \
  bash -c "source /opt/ros/jazzy/setup.bash && python3 /work/experiment.py"

The months line will reflect the month you run it in. Before you type apt install ros-…, open the official Releases table and subtract your project length from the months your distro has left.