From Jammy to Resolute: how Ubuntu’s toolchains have evolved

We cover new toolchain versions, devpacks and workflows that improve the developer experience.

The evolution of Ubuntu’s toolchains story goes beyond just providing up-to-date GCC, LLVM, and Python. It is also about opinionated openJDK variants, task-focused devpacks, FIPS compliant toolchains, and snaps, like the new .NET snap and Snapcraft plugin. These are enhancements that collapse half a day of setup into a single command or two, demonstrating what a frictionless developer experience means in practice for framework and application developers on Ubuntu. 

In this blog, we’ll take a closer look at the changes we have made in the past four years of LTS releases on Ubuntu, and where we’re headed next.

Where we started: Ubuntu 22.04 LTS (Jammy Jellyfish)

Ubuntu has always provided a solid baseline of language toolchains: multiple GCC versions, modern LLVM/Clang, and current Python. Ubuntu 22.04 LTS brought more focus to Golang, Java, and .NET runtimes in the archive. 22.04 LTS was also the first Ubuntu release where we promoted Rust toolchain packages from the universe repository to the main repository, for memory‑safe systems work. This made Ubuntu a dependable foundation for C/C++, systems, and backend development, as well as enterprise application development. However, most developers still had to assemble their own workflow: IDE integration, framework command line interfaces (CLIs), build tooling, and packaging were largely left to individual teams. Likewise, Golang and Rust developers still had to go to upstream projects to get the latest and greatest.

The setup for Spring, .NET, and Golang in 22.04 LTS generally required developers to install the language and the framework via a preferred package manager, and then wire it into their project. While functional for experts, this approach made it difficult to standardize environments across organizations or support offline and constrained setups.

Ubuntu 24.04 LTS and beyond: toolchains evolve

Between 24.04 LTS and 25.04, Ubuntu moved from “toolchains are present” to “toolchains are curated.” We introduced current GCC, LLVM, Golang, Java, .NET, and Rust versions, as well as a unified “toolchain availability” reference for planning builds and continuous integration (CI). With the Ubuntu 25.04 release, we published the Ubuntu for developers portal, offering structured how‑tos for GCC, Golang, Java, .NET, Python, and Rust, so developers could easily access documented workflows, not just packages.

On the platform side, .NET on Ubuntu was transformed: .NET 8 SDKs and runtimes were made available via an official snap that included CLI tools and an installer capable of managing multiple .NET installations. Snapcraft gained a dedicated dotnet plugin and versioned .NET extensions that turned complex snapcraft.yaml files into concise, repeatable definitions. This dramatically lowered the barrier to building, publishing, and updating .NET applications on Ubuntu, whether for desktop, server, or cloud‑hosted workloads.

Devpacks for Spring and Golang: framework workflows in a snap

In the 25.04 release, devpacks arrived – devpack-for-spring being the first. Devpacks are one of the most important recent steps in improving the user experience for application developers. Devpacks are snaps that bundle framework‑specific tools, curated defaults, and packaging smarts. They’re built to give you a ready‑to‑use dev environment with a single install.

For example, the devpack‑for‑spring packages Spring CLI and adds Ubuntu‑specific value. It offers offline installation of Spring Boot libraries, helping to speed up first builds and support air‑gapped or bandwidth‑constrained environments. It also provides pre‑configured Maven and Gradle plugins for formatting, static analysis, and best‑practice defaults. From there, devpack-for-spring boot start uses Spring Initializr to scaffold a new Spring Boot project with Java 21 and a current Spring Boot release, giving Java developers a modern, policy‑aligned starting point in one command. Find out more about devpack-for-spring on our blog, or get the feature walkthrough on our Youtube channel. You can download it from the snapstore.

Likewise, devpack‑for‑go (and the Go snaps in general) follow a similar philosophy for Golang developers. These make it possible to install a complete Golang toolchain with consistent defaults across Ubuntu releases and other distros using the Snap Store, while benefiting from automatic updates and rollback.

Together with the .NET snap and Snapcraft’s .NET plugin and extensions, these devpacks shift Ubuntu from “general‑purpose OS with compilers” to “framework‑aware platform” where Java/Spring, Golang, and .NET developers can go from fresh install to first build in minutes with reproducible, centrally managed tooling.

Ubuntu 26.04 LTS, the application development platform

The last four years of effort are now coming together in Ubuntu 26.04 LTS to make Ubuntu a first-class application development and deployment platform for multiple language runtimes.

The latest version of OpenJDK v25 brings up to 20% memory reduction with Compact Object Headers (JEP 519), faster startup through AOT Method Profiling (JEP 515), and better virtual thread performance. Ubuntu 26.04 LTS will also ship the fast starting variant OpenJDK-25-CRaC, and the graalvm-jdk snap’s OpenJDK 25 based release is available from the Snap Store.

.NET 10, the latest LTS release, delivers a faster, more secure, and more capable platform for modern development. It is now available in the archive in main. The .NET snap provides an easy way to install and manage multiple versions of .NET SDK and Runtime; with the 26.04 LTS, users of the .NET snap can install and configure .NET 10 SDK and Runtime, in addition to already available .NET 8. We have also released two popular .NET developer tools as snaps. The first, NetCoreDbg, is the popular open source .NET debugger that can be used with GDB/MI, VSCode DAP, and CLI interfaces for CoreCLR, the open source, cross-platform runtime engine under .NET. The second, MSBuild Structured Log Viewer, is a logger for MSBuild that records a structured representation of executed targets, tasks, property, and item values.

The latest upstream Golang release 1.26 is the default on Resolute Raccoon. This release focuses on significant runtime performance gains, developer ergonomics, and modernizing legacy codebases. The devpack-for-go snap available via the Snap Store brings together popular Golang developer tools and their easy integration with IDEs like VS Code.

Rust 1.93 is the default in 26.04, and with it brings the cargo-auditable functionality as an opt-in feature. The cargo-auditable functionality is a mechanism to record and track what Rust libraries versions were used to build a Rust binary so that the binaries can be re-built if a vulnerability is found in a given library version. The cargo-audit tool that can examine this data embedded in the Rust binaries is provided as a snap via the Snap Store.

How it all adds up for developers

Looking at the toolchains, snaps, and devpacks together, you can see the clear strategy of moving the toolchains up the value chain of a development platform has come together well in Ubuntu 26.04 LTS. Systems developers get up‑to‑date GCC and LLVM with documented availability per series and strong Rust support baked into the distribution, making Ubuntu a reliable base for kernels, drivers, and performance‑critical services. Application developers see the same care at the framework level: Spring devpacks for Java, devpacks and snaps for Golang, official .NET snaps, and Snapcraft plugins and extensions that turn complex packaging and runtime management into declarative configuration.

This combination means teams can standardize on shared devpacks and snaps that encode their best practices – IDE plugins, linters, build options, runtime versions – so onboarding a new developer becomes “install Ubuntu, install the devpack/snap, clone the repo,” rather than a multi‑page setup guide. It also means CI/CD pipelines can target supported, well‑documented toolchain versions and official snaps, improving reproducibility across laptops, build farms, and cloud environments.

The road ahead: GCC, LLVM, Rust, and devpacks

Looking forward, the toolchains team will be applying the same philosophy that shaped devpack-for-spring, devpack-for-go, and the .NET snap more broadly into the core toolchains for C/C++ and Python. While the team is still deciding what this means in practice, here’s a sneak peek of what the future might look like.

For GCC and LLVM, dedicated “dev stacks” and container images that bundle compilers, linkers, debuggers, sanitizers, and cross‑toolchains would give C/C++ and systems developers the same one‑command setup that Spring and .NET developers enjoy today. For Rust, embracing rustup as the first‑class developer path on Ubuntu, offering curated Rust images, and tightening integration with LLD would make Ubuntu an obvious choice for modern systems‑level Rust projects.

On the devpack side, future work might include devpacks for other popular stacks (Python frameworks like Conda, Rust web stacks, game engines) and deeper alignment between devpacks, Snapcraft plugins, and official documentation, so that every major language and framework has a clearly documented “golden path” on Ubuntu. 

With the foundations laid by devpack‑for‑spring, devpack‑for‑go, the .NET snaps, and the advancing GCC/LLVM/Rust story,we’re building an Ubuntu that we hope serves both Linux and application developers equally as a strong, securely designed, and supported foundation.