AHXproject

Beyond tokens per watt – using Ubuntu 26.04 LTS for AI

Tokens per watt (TpW) – the measure of useful AI work produced per watt of energy consumed – is the metric at top of mind for CEOs, heads of AI, and infrastructure teams alike. With the tremendous cost of GPU clusters, extracting as much value as possible from the expense is critical.

But in the pursuit of tokens, it's important to remember that hardware efficiency isn't the only factor influencing data center operating costs, or the output of useful, revenue-generating AI work. While TpW is crucial, we also need to consider time-to-value and the impact of human productivity, which are largely determined at the software level.

We're shaping Ubuntu to be the software foundation for efficient AI, and in this article, I'll share some examples of what we mean when we say that we are optimizing Ubuntu for AI. With Ubuntu 26.04 LTS, we're not just helping organizations get more from their hardware, we're also making life easier and more productive for teams that rely on and support the AI stack. 

An OS that's optimized for silicon

How do you squeeze more tokens from your hardware? The prevailing wisdom is to prioritize model optimization, GPU utilization, time to first token, and tokens per second. However, it's also essential to have a software layer that enables you to make the most of your silicon.

The host operating system plays a central role in the AI infrastructure stack. That's "central" not just in the sense that it's important, but also in the sense that it sits in the center of the stack, acting as the bridge between the hardware and software. The OS manages the underlying compute, so it's responsible for ensuring you can take full advantage of your GPUs and other AI accelerators.

With that in mind, Canonical partners with silicon vendors  (such as NVIDIA, AMD, Intel, Arm, and Qualcomm, as well as RISC-V platforms) to optimize Ubuntu across all major architectures. This optimization helps to ensure that the maximum watts are spent on AI workloads rather than OS overhead. 

We also work with partners to certify hardware . By providing standardized, pre-integrated secure boot enablement and firmware delivery, Canonical enables organizations to avoid having to do custom OS engineering for every new piece of hardware they add to their stack. Enterprises can get to value faster, and save on engineering resources.

Single command toolkit integrations

Let's continue on that theme of accelerating time-to-value and enhancing human productivity. Even in the age of AI, Ubuntu remains a Linux for human beings, and a core pillar of our philosophy is minimizing the friction involved in deploying and operating AI infrastructure for our users.

To that end, we're collaborating with NVIDIA and AMD to integrate and distribute key AI solutions with Ubuntu. Starting with Ubuntu 26.04 LTS, users can get NVIDIA CUDA , AMD ROCm , and NVIDIA DOCA-OFED  each with a single command. 

GPGPU frameworks

NVIDIA CUDA and AMD ROCm are frameworks for general-purpose computing on graphics processing units (GPGPU). They are the critical software layers that enable developers to harness the massive throughput of NVIDIA and AMD GPUs for AI workloads.

Historically, installing these frameworks required multi-step processes, and navigating dependency and compatibility issues could often prove challenging, especially for inexperienced users. But with Ubuntu 26.04 LTS, NVIDIA CUDA or AMD ROCm can each be installed with just one apt install command. 

The new distribution model can save teams hours or even days on GPGPU framework setup, so organizations can start gaining value from GPUs faster. Canonical also ensures that users have smooth upgrade paths, so they can be confident when updating, and get the benefits of the latest features of these platforms.

Have questions about AMD ROCm on Ubuntu? We've just published a deep dive.

High-performance networking

For organizations with large-scale AI factories  and HPC clusters, NVIDIA DOCA-OFED is among the go-to high-performance networking stacks. However, traditionally, the tradeoff for enabling ultra-low latency and high-throughput data transfers was the complexity of setup and maintenance. System administrators had to manage networking drivers through external installers or complex manual builds, potentially leading to version conflicts or kernel mismatch issues during OS updates.

Now that NVIDIA DOCA-OFED can be installed seamlessly, the entire lifecycle management is simplified. Alongside rapid installation, the new workflow solves common operational pain points like kernel drift, driver incompatibility, and CI breakage following kernel or OS upgrades. Infrastructure teams can deliver speed and stability, while saving resources.

Optimized for hardware and humans

Jon Seager, Canonical's VP of Engineering, has written recently about the future of AI in Ubuntu . He signs off by stating that "Ubuntu is not becoming an AI product." But what we are committed to is making Ubuntu an enabler for AI. Whether it's at the silicon level with deep optimization for every architecture, or at the user level with streamlined toolkit adoption and lifecycle management, Ubuntu is the software layer that underpins an effective AI infrastructure strategy. It can help you get more tokens per watt, and beyond that, it can help you get to value faster and help bring down the operating costs for your stack.

If you'd like to learn more about AI infrastructure best practices, and how Ubuntu can fit into your AI strategy, read the enterprise guide to private AI infrastructure .

Tokens per watt (TpW) – the measure of useful AI work produced per watt of energy consumed – is the metric at top of mind for CEOs, heads of AI, and infrastructure teams alike. With the tremendous cost of GPU clusters, extracting as much value as possible from the expense is critical. But in the [...]


Categories: AI/ML, AI/ML Infrastructure
Source: https://ubuntu.com//blog/beyond-tokens-per-watt Jun 05, 2026, 01:44 PM

A look into Ubuntu Core 26: Deploying AI models on Renesas RZ/V series for production

Welcome to this blog series which explores innovative uses of Ubuntu Core. Throughout this series, Canonical's Engineers will show what you can build with our releases, highlighting the features and tools available to you.

In this blog, Asa Mirzaieva, engineer from the Silicon Alliances team, will show you how to deploy optimised AI models on Renesas RZ/V series hardware using the Dynamically Reconfigurable Processor for AI (DRP-AI). 

Deploying AI models for edge inference on specialized MPUs is particularly useful for developers looking to balance high performance with extremely low power consumption. Coupled with Ubuntu Core's architecture, developers have an end-to-end infrastructure for managing a secure, modular deployment.

By the end of this blog, you'll know how to package, load, and run AI inference models on Renesas DRP-AI using snaps.

AI inference on Renesas DRP-AI

If you aren't familiar with Renesas' RZ/V  series, the main takeaway is that these microprocessors feature a dedicated AI accelerator called DRP-AI. This dynamically reconfigurable processor accelerates the heavy lifting of neural network inference, such as feature extraction and classification, while maintaining exceptional power efficiency. To fully understand how this acceleration is achieved, we must look at how DRP-AI dynamically reconfigures its internal dataflow to match the network architecture, contrasting sharply with traditional sequential CPU processing.


Packaging and Deploying Edge AI with Ubuntu Core

In a nutshell, running AI workloads at the edge involves preparing the model, integrating it with the runtime and application, and ensuring it can be reliably deployed on target devices, as seen on the diagram below.

The diagram shows this workflow for Renesas RZ/V platforms: development and packaging are done on a host system (such as your laptop or build server running Ubuntu), while deployment targets the RZ/V device running Ubuntu Core.

On this host system, models are compiled with the DRP-AI toolchain and packaged together with the runtime and the application into a snap; this snap is then deployed to the target device as a complete AI solution



The following sections walk through each step in detail: from model compilation with DRP-AI TVM to packaging and running inference on the device.

Compiling with DRP-AI TVM

Just like other advanced AI pipelines, DRP-AI TVM requires you to compile your model (such as ONNX) to generate Runtime Model Data. The stack leverages the EdgeCortix MERA Compiler Framework to map your AI model into a highly efficient instruction set that the CPU and DRP-AI hardware can process collaboratively.

Because model compilation relies on specific SDKs and the EdgeCortix MERA Compiler Framework, this step is typically performed on a dedicated host machine (or Docker container) and is not handled by our runtime snap.

For step-by-step instructions on how to set up your environment and compile your ONNX models, please refer to the official DRP-AI TVM Compiling Tutorials  provided by Renesas.

Once your model has been pruned, optimized, and compiled on your host environment, the next step is getting both the runtime binaries and the compiled model onto your board.

Packaging your AI application in a snap

To run inference securely and reliably, we package the applications into a snap. Canonical has created an example repository, rzv_drp-ai_tvm_snap , which bundles the upstream Renesas example applications so they can be easily installed and managed via snapd.

In the snap, we package three major components:

• The DRP-AI TVM runtime library (libdrp_tvm_rt.so and its dependencies)
• The compiled tutorial application (tutorial_app_v2ml)
• The pre-compiled AI model data (located in the project's models/ directory)

Thanks to Snapcraft's advanced tooling, you can cross-compile the entire application for arm64 right from an amd64 host.

Once built, you can transfer your resulting snap to your RZ/V2L board and install it. Currently, accessing hardware interfaces relies on devmode confinement:

sudo snap install --devmode rzv-drp-ai-tvm-examples_*.snap
Under the Hood: The snapcraft.yaml File

The magic behind this secure, cross-compiled package is the snapcraft.yaml file. This single declarative file dictates how the AI application is built and packaged. Here is a simplified snippet of how it orchestrates the three major components:

name: rzv-drp-ai-tvm-examplesbase: core24confinement: devmodeapps:  tutorial-app:    command: usr/bin/launch-tutorial.shparts:  tvm-runtime:    plugin: nil    source: [https://github.com/renesas-rz/rzv_drp-ai_tvm.git](https://github.com/renesas-rz/rzv_drp-ai_tvm.git)    override-prime: |      craftctl default      # 1. Install runtime library      cp -a $CRAFT_PART_SRC/obj/build_runtime/v2m/lib/* $CRAFT_PRIME/usr/lib/      # 2. Install the compiled model      cp -a ${CRAFT_PROJECT_DIR}/models/ $CRAFT_PRIME/usr/bin/  tutorial-app:    after: [tvm-runtime]    plugin: cmake    source: ${CRAFT_PROJECT_DIR}/../parts/tvm-runtime/src/apps    override-prime: |      craftctl default      # 3. Install compiled binary      cp -a $CRAFT_PART_BUILD/tutorial_app_v2ml $CRAFT_PRIME/usr/bin/

This configuration maps directly to the major components we discussed:

• Component 1: The Runtime Library: Handled by the tvm-runtime part. It fetches the upstream Renesas DRP-AI TVM source code and copies the pre-built TVM runtime libraries into the snap's runtime path.
• Component 2: The Compiled Model: Also handled in the tvm-runtime part. The locally prepared AI model data is pulled directly from the project's models/ folder into the snap so it's readily available at runtime.
• Component 3: The Tutorial Application: Handled by the tutorial-app part. It uses the cmake plugin to cross-compile the C++ tutorial application specifically for the arm64 architecture, placing the final tutorial_app_v2ml binary into the snap.

Installing the snap

Run the following command after the successful build of the snap (XXX stands for the version).

devmode is required to access the DRP-AI devices from within the snap.

sudo snap install rzv-drp-ai-tvm-examplesXXX.snap --devmode
Running the Inference Examples

After the snap is installed, running the pre-packaged application is as simple as calling the snap command.

To run the ResNet18/ResNet50 image-classification inference (assuming you've provided the compiled model data and input files to the board):

rzv-drp-ai-tvm-examples.tutorial-app

Make sure to use 640×480 bmp images with the default ONNX model.

That's it! You can completely separate your AI models from your application logic and firmware, providing a modular approach to updates. When you improve your model, Ubuntu Core and the Snap Store will help you deliver these updates reliably and securely over the air.

Thanks to Ubuntu Core, you can just focus on your development and not worry about the infrastructure on how to update devices in the field or maintain system security.

What's next?

The Renesas DRP-AI accelerator offers a tremendous advantage for edge AI devices, delivering high-speed inference without severe power penalties. Their value for deploying embedded AI devices is indisputable.

Now is your turn. Why don't you try packaging your optimized DRP-AI models using snaps? Through this, you will see the benefits for yourself of the infrastructure to manage and deploy software at the edge. With Ubuntu Core, you can build your production image with your targeted snaps and hardware. This will empower you to easily flash devices in production lines. Plus, in your image, you can define what user experience you want to bring, keeping your model and intellectual property secure in its sandbox.

• Getting started with inference snaps

Welcome to this blog series which explores innovative uses of Ubuntu Core. Throughout this series, Canonical's Engineers will show what you can build with our releases, highlighting the features and tools available to you. In this blog, Asa Mirzaieva, engineer from the Silicon Alliances team, will show you how to deploy optimised AI models on [...]


Categories: AI, IoT, Ubuntu Core
Source: https://ubuntu.com//blog/ubuntu-core-26-ai-renesas Jun 04, 2026, 03:36 PM

COSMIC 1.0.15 Adds Support for Multiple Full-Screen Windows per Workspace



COSMIC 1.0.15 desktop environment is now available with improvements across COSMIC Files, COSMIC Term, COSMIC Edit, COSMIC Store, COSMIC Comp, and COSMIC Applets.

The post COSMIC 1.0.15 Adds Support for Multiple Full-Screen Windows per Workspace  appeared first on 9to5Linux  - do not reproduce this article without permission. This RSS feed is intended for readers, not scrapers.


Categories: Desktops, News, COSMIC, desktop environment
Source: https://9to5linux.com/cosmic-1-0-15-adds-support-for-multiple-full-screen-windows-per-workspace Jun 03, 2026, 09:04 PM

RISC-V profiles – why is RVA23 significant?

Introduction

One of the important offerings of the RISC-V Instruction Set Architecture (ISA) is the ability to customize and extend the base instruction set. An initial reaction to hearing this is often to worry about software portability and compatibility, since if every RISC-V CPU  offers a slightly different set of instructions, software won't be portable. 

This risk is that customization becomes fragmentation, which is why RISC-V offers sets of standardized extensions to help with software compatibility and portability. These are indicated with a letter or string, such as 'F' for floating point, or 'V' for vectors. There is also a number to indicate whether the device is 32-bit or 64-bit. So a CPU might be "RV64IMAC", which means a 64-bit CPU where Integer (I), Multiply (M), Atomics (A) and Compressed (C) extensions are supported.

To execute correctly, software has to be compiled to match the hardware, or a subset of it (as an example, for code compiled as RV64IMA, it doesn't matter whether the hardware supports the 'C' extension or not, but it must support at least RV64IMA). For binary portability (the ability to run compiled binaries on different hardware) to scale, there are two options. The first is that all software would have to be written with a minimal set of extensions, which is undesirable as it would limit performance and code size. To avoid these limitations, the second option is for the ecosystem to agree on common groups of extensions that all software can target. RISC-V International calls these "profiles".

RISC-V first introduced profiles with RVI20 and RVA20, and since then RVA22 and RVA23 have also been ratified. This blog will examine the RVA23 profile, including its features, and explain why these features are important for Ubuntu. We'll also go over how they support the scaling of the RISC-V ecosystem. A future blog will discuss how custom instructions can be supported in Ubuntu.

What is a profile?

As explained above, a profile is a set of ratified extensions.  An extension is given an identifying code, from a single letter (we saw I, M, A, and C earlier) to a string such as "zicsr". These are concatenated together to form a description of the implementation. However this can become unwieldy, making profiles become a simpler way to describe a more complex feature set. For example, RVA23 expanded would be something like: 

rv64gc_zicsr_zicntr_zihpm_zicbom_zicbop_zicboz_zicond_zimop_zcmop_zfh_zfa_zawrs_zbc_zvfh_zvfhmin_zvbc_zvkg_zvkned_zvknha_zvknhb_zvksed_zvksh_zvkn_zvknc_zvknf_zvkng_zvks_zvksc_zvksf_zvksg_zvl128b_zihintpause_zihintntl_svpbmt_svinval_svade_sstc_sscofpmf_ssccptr_sscounterenw_shvstvecd_shvswatpa_shgatpa_shcounterenw_shvsvinval_shvstvala_shvsvpbmt_shvsvade

Which is a bit of a mouthful to keep repeating! A profile solves the above problem as it sets a standard for what needs to be included in a CPU implementation . The above wouldn't need repeating: all of those extensions would be included by default whenever you see "RVA23".

Profiles  are defined by the RISC-V Profiles Task group where experts from across the industry agree on what features make sense to include by considering the target application space for that profile. 

The importance of profiles for ecosystem growth

For RISC-V to thrive and grow, it needs a strong software ecosystem. While developers and enthusiasts might be willing to compile code from scratch for every different CPU, this quickly becomes limiting for larger organizations. Profiles create a target that both software and hardware developers can agree on, guaranteeing portability of software compiled to target RVA23 across different implementations. So an RVA23 compatible binary should be able to run on any RVA23 CPU.

Limitations of Profiles

While Profiles guarantee a level of binary compatibility, there are aspects of system behaviour that they don't cover. These include initial boot, device discovery and peripheral drivers. While the code for these will still all be RVA23 compliant, it may not be portable between different implementations. RISC-V International technical working groups are also acutely aware of this, and working on specifications such as the Server Platform Specification  to address items such as interrupt controllers and secure boot, which are outside of the ISA profile specification. For end users developing applications, this is less likely to be a concern, but it does matter to operating system developers or those working on bare metal.

Key features for modern Linux

RVA23 introduced two key features that were missing from earlier profiles:

• Hypervisor
• Vectors

While it was possible for earlier RISC-V implementations to include these as extensions, they were not mandated, so software couldn't rely on them to be included by default. By moving them into the profile specification for RVA23, software can be optimized to make use of these features. Now let's look at the benefits of each feature in more detail:

Hypervisors

Hypervisors are widely used in many applications. They provide a way for a single physical CPU to emulate multiple virtual machines (VMs) while providing isolation between them. Many end applications don't need a whole physical CPU to themselves, so this allows for more efficient use of physical CPUs while also providing security between the separate VMs. In a datacentre where a physical CPU might have tens of processor cores, hypervisors are essential to allow efficient scaling.

Even in small scale clusters of machines, hypervisors and VMs can be used to provide functionality such as machine migration, snapshots and isolation.. Several Canonical products make use of the hypervisor, and we see mature support for virtualization as a requirement for RISC-V to scale to applications beyond embedded devices.

Vectors

While hypervisors are important for scaling to large workloads, vector instructions are about accelerating individual workloads, especially those that are math-intensive. Adding vectors to a CPU incurs a significant amount of additional silicon area, but for workloads that make use of them, this also provides a large performance improvement.

While vectors are typically associated with heavy math tasks like machine learning and image processing, even the operating system itself uses them for basic chores like copying memory. And for vectors to be available to user space, the kernel still has to be aware of the register file and associated state to manage context switches, so support is needed at the operating system level.

RISC-V made a conscious design choice for the vector extensions to be scalable. This means that implementations can choose an appropriate vector length and the software will run without needing changes or recompilation. So a smaller in-order CPU might use 64 or 128-bit vectors in hardware, while a server class CPU could use 256 or even wider vectors without needing to recompile code. As with the hypervisor, we see vectors as essential for modern high performance processors from desktop to server.

For smaller embedded systems, power is often a concern and even small implementations of vectors may consume significant area and power. For this reason the RVB23 profile is also being developed, which removes some of the required features from RVA23.

Why now?

Hardware and software are interdependent, and with any new technology they need to be co-developed. Sometimes hardware takes the "build it and they will come" approach, while in other cases it becomes apparent that the hardware is on the way, and techniques such as emulation can be used to develop the software before there is any hardware available. The latter approach also has the benefit of reducing the time to market since software is available as soon as the hardware ships.

When we announced support for RVA23 in our Ubuntu 25.10 release, there were some questions about the lack of available silicon, but the direction of travel for the industry was obvious and we wanted to be at the forefront of it. When SpacemiT announced their K3 silicon earlier this year, we were ready to support it . I'm sure we'll see more RVA23 silicon through this year and beyond.

Conclusion

For the RISC-V ecosystem to scale successfully, it needs a stable base profile which is suitable for modern workloads covering use cases up to data centers and servers. The RVA23 profile provides that, and it's why Canonical moved to requiring RVA23 from Ubuntu 25.10. The Ubuntu 26.04 release introduces Long Term Support (LTS), providing 5 years of support for any user, and up to 15 years of support through Ubuntu Pro. But for those early adopters of RISC-V, we will continue to provide Ubuntu 24.04 LTS which requires the RVA20 profile. This itself will get the same level of LTS support as any other Ubuntu LTS release. 

Further reading

• RISC-V RVA23 profile specification
• RISC-V profiles documentation

Introduction One of the important offerings of the RISC-V Instruction Set Architecture (ISA) is the ability to customize and extend the base instruction set. An initial reaction to hearing this is often to worry about software portability and compatibility, since if every RISC-V CPU  offers a slightly different set of instructions, software won't be portable.  [...]


Categories: RISC-V, RVA23
Source: https://ubuntu.com//blog/risc-v-profiles-why-is-rva23-significant Jun 03, 2026, 07:00 PM

Giada 1.4.2 Open-Source Loop Machine Makes Working with Scenes Smoother



Giada 1.4.2 open-source loop machine and music production software is now available for download with smoother scene workflow, fixes for a few annoyances, and some welcome code cleanup.

The post Giada 1.4.2 Open-Source Loop Machine Makes Working with Scenes Smoother  appeared first on 9to5Linux  - do not reproduce this article without permission. This RSS feed is intended for readers, not scrapers.


Categories: Apps, News, Giada, loop machine, music production
Source: https://9to5linux.com/giada-1-4-2-open-source-loop-machine-makes-working-with-scenes-smoother Jun 03, 2026, 04:06 PM

T2 Linux 26.6 Brings Linux 7.0, Refined KDE Plasma Desktop with Flatpak Support



T2 Linux SDE 26.6 is now available for download as a hefty update for this highly portable source-based Linux distribution adding a refined KDE Plasma desktop with Flatpak support and Linux 7.0.

The post T2 Linux 26.6 Brings Linux 7.0, Refined KDE Plasma Desktop with Flatpak Support  appeared first on 9to5Linux  - do not reproduce this article without permission. This RSS feed is intended for readers, not scrapers.


Categories: Distros, News, Linux distribution, T2 Linux
Source: https://9to5linux.com/t2-linux-26-6-brings-linux-7-0-refined-kde-plasma-desktop-with-flatpak-support Jun 03, 2026, 02:56 PM

AI with AMD ROCm on Ubuntu: your questions answered

Canonical and AMD™ teamed up last fall to package AMD ROCm™ AI/ML and HPC libraries right into the Ubuntu archive. Our shared goal is to ensure that Ubuntu offers a seamless, out-of-the-box experience for high-performance AI and HPC on AMD hardware. 

Just last month, we launched our first version of ROCm in Ubuntu 26.04 LTS!  This marks the start of a great future. The reaction so far has been great and supportive, but I'd like to cover some questions asked by the community.

What is ROCm?

ROCm is the AMD software stack for AI/ML and HPC acceleration on AMD hardware. It enables high-speed local inference and model training using AMD GPUs, APUs, and CPUs. With these libraries now native to Ubuntu, users can get the most out of their hardware, as well as popular tools like llama.cpp, Lemonade, ComfyUI, and many more with a simple installation.

How do I use ROCm on Ubuntu?

Prior to the inclusion of ROCm directly in the Ubuntu archives, users needed to download an installation script from AMD and run it locally on their machine (amdgpu-install). This script would then download the required components, compile them as necessary for your local machine, and install them as system libraries. It was fairly straightforward, but had a few drawbacks – especially in production deployments:  

• To upgrade versions or apply security patches, the user needs to uninstall manually, download a new install script, and reinstall the full suite of libraries. It is up to the user to identify that there's a new version available and whether or not it is compatible with other applications they're using.
• ROCm needs to be installed on the host or in the container separately from applications that may want to use it: it can't be an auto-managed dependency. This is a manual process separate from installing the actual applications you want to use.

As of Ubuntu 26.04 LTS, having ROCm in the Ubuntu archives makes things much more streamlined: 

In many cases, applications can automatically install the specific ROCm libraries they need, and all their dependencies, by simply declaring them as a dependency of their own installation. In these scenarios, no additional user action is required.

For users:  to install the full suite of ROCm libraries on a host or in a container:  

sudo apt install rocm

For developers: to install the subset of libraries and headers needed for ROCm-enabled application development:

sudo apt install rocm-dev

Once installed, your regular system updates (sudo apt upgrade) automatically manage all ROCm updates and security patches. Our internal CI/CD processes verify version compatibility before release, ensuring a stable update path for your environment.

Which versions are supported? 

To ensure maximum stability for this LTS release, we integrated ROCm 7.1.0, which was the most recent version available when we started the initial packaging efforts. Preparing such a wide range of new packages for their initial inclusion in Ubuntu archive takes considerable work and time. While ROCm 7.1.0 is not the latest upstream version, this release establishes a foundation for the future.  Now that the first version is complete, future updates will get easier and faster – allowing us to keep pace in this rapidly evolving environment. By aligning our packaging efforts with the Debian community and upstreaming core components, we have created a blueprint to close the version gap quickly.

Our goals for the future

With ROCm 7.1 now released in Ubuntu 26.04 LTS, we are focusing on delivering newer ROCm versions through Stable Release Updates (SRU). This process allows us to provide support for the latest AMD hardware and new ROCm features without requiring users to wait for a completely new Ubuntu release.

We are currently working on packaging ROCm 7.2, as well as expanding the range of hardware support we build and test for. The main reason for starting here and not jumping directly to the 7.13+ branches is to work out the in-place upgrade complexities for ROCm and ensure that we have everything ready to issue updates cleanly and smoothly.   Because these updates are automatically rolled out when users update their system with apt upgrade (or with Landscape), this merits caution. 

One of the big challenges we face any time we try to update versions of a package in-place is if there are changes to the ABI ("Application Binary Interface", or essentially the interfaces that programs use to access and use the functionality of the library.) These changes risk breaking applications built for older versions of ROCm. 

By convention, minor and patch version changes (the x and y in v.x.y version numbers) shouldn't contain any ABI changes that break systems, and should be fully backwards compatible with other releases in the same major version (the first number of the version).  However, with the pace of AI software development, sometimes breaking changes are introduced into minor version changes, meaning we have to find creative ways to solve the challenges that may create. After all, our value is in providing solutions that are rock solid and that you can depend on, and which don't break installations that were running just fine on older software.

We are currently evaluating this with ROCm 7.13 and later, which includes major restructuring of the libraries in preparation for ROCm 8 ("The Rock"). This will be a significant uplift, and we will choose the release path that provides the best user experience, flexibility, and reliability for the future.

What's next?

ROCm 7.1 in Ubuntu 26.04 LTS is just the start. We have big plans, and having this foundation available has already resulted in a growing ecosystem of AI applications that support AMD hardware out of the box.

• Short-term:  in-place upgrade to ROCm 7.2.x (already underway.)
• Longer term:  Looking at ROCm 7.13+, ROCm 8, and beyond.

Our intention is to provide an upgrade path in Ubuntu 26.04 LTS and future releases as far as we possibly can. With ROCm 7.10 and beyond ("The Rock") being a major change with a complete restructuring of the entire suite of libraries, it is possible there will be changes preventing us from going that far with in-place upgrades – but that has yet to be determined.

The wider AI community and ecosystem with AMD hardware

From the very start, we announced our joint intention with AMD to put ROCm into Ubuntu, and also to help upstream that work to Debian itself.  The packaging work we're doing is structured to make that possible, and we're proud to support the wider community with these efforts. The AMD team and Debian AI community are leading those efforts already.  

Now that ROCm is easily available in Ubuntu, we're starting to see the community adopt these packages and release user applications that take advantage of them. Some of this work is being done by Canonical and AMD engineers, and more by interested community members.

One notable example is Lemonade Server (https://lemonade-server.ai/ ).  This is an open-source project that provides a hardware-accelerated back-end for AI applications using standards-compliant APIs for front-end applications to interact with. It is an essential tool when connecting ROCm to standard front-end APIs.

Our engineers have packaged Lemonade Server and Lemonade Desktop (a front-end you can use as a chat interface and more) in both snap packages and deb packages. They can be installed with either:

Snap packaging (containerized – to eliminate version or library conflicts with other applications):

snap install lemonade-server

snap install lemonade-desktop

Deb packaging (to install directly in your host environment or container):

sudo apt install lemonade-server

sudo apt install lemonade-desktop

Lemonade is similar to Ollama in many ways, but with out-of-the-box support for AMD hardware – including not only CPU and GPU support, but also NPU support – making it easy to get the most out of your system.  I'm excited about this personally because it's really the first time we can light up the NPU silicon in AMD Strix Point and Strix Halo systems (Ryzen™ AI Max and Max+ processors), and take full advantage of up to 128GB of shared memory for huge AI models.

Once Lemonade Server is running, it handles all the complex interactions with ROCm and your hardware automatically. This allows you to use a wide range of applications that do not need native ROCm support. By simply pointing these tools to the Lemonade API port, you can perform local AI inference on your AMD hardware using:

• ComfyUI (Image Generation)
• OpenWebUI (Chat Interface)
• OpenClaw (Agentic Tasks)
• OpenCode

Because Lemonade Server provides a standard OpenAI-compatible backend, almost any application designed for standard AI APIs can now leverage the full power of your AMD system without additional configuration.

AMD and Canonical engineers will be at the upcoming Ubuntu Summit 26.04 to talk about Lemonade and ROCm in Ubuntu . Make sure to tune in or watch the replay!

This is just the beginning

Now that we have the ROCm base as an integral part of the Ubuntu ecosystem, we have enabled the full community to build on top of that.  We'll be working to ensure that AMD hardware is fully supported in our AI applications and roadmap, and can't wait to see what the community does with it as well.  Let me know how you're using ROCm in Ubuntu, and maybe I'll feature you in an upcoming post!

If you've got a project you need help with, or simply want to learn more about how we're growing this important ecosystem, don't hesitate to contact us.

AMD ROCm is now available in Ubuntu 26.05 LTS. Learn what how to make the best of it, and find out what this will mean in the coming years for development in Ubuntu.


Categories: AMD, Ubuntu Desktop
Source: https://ubuntu.com//blog/amd-rocm-on-ubuntu Jun 03, 2026, 02:03 PM

Ubuntu plans to add AI-powered voice input to all text fields

Ever wished you could talk in to a text field rather than type? Ubuntu 26.10 hears you – quite literally. Canonical's VP of Engineer Jon Seager, at the Ubuntu Summit, said the distro will soon lets users "press a button and talk into any field that you could previously type in". A small, on-device AI language parsing model like Whisper will power the feature. It's part of a wider push to integrate AI features in Ubuntu this year, with founder Mark Shuttleworth aiming to position Ubuntu as the 'OS for agentic AI'. The feature aims to bolster Ubuntu's accessibility, but [...]

You're reading Ubuntu plans to add AI-powered voice input to all text fields , a blog post from OMG! Ubuntu . Do not reproduce elsewhere without permission.


Categories: News
Source: https://www.omgubuntu.co.uk/2026/06/ubuntu-speech-to-text-ai Jun 03, 2026, 05:30 PM

Transmission 4.1.2 Open-Source BitTorrent Client Released with Important Fixes



Transmission 4.1.2 open-source BitTorrent client is now available for download with various bug fixes and improvements for the Qt client, GTK client, Web client, and macOS client.

The post Transmission 4.1.2 Open-Source BitTorrent Client Released with Important Fixes  appeared first on 9to5Linux  - do not reproduce this article without permission. This RSS feed is intended for readers, not scrapers.


Categories: Apps, News, BitTorrent, torrent client, torrent downloader, Transmission
Source: https://9to5linux.com/transmission-4-1-2-open-source-bittorrent-client-released-with-important-bug-fixes Jun 03, 2026, 02:46 AM

Clonezilla Live 3.3.2 Released with Linux Kernel 7.0, Improved MDRAID Support



Clonezilla Live 3.3.2 disk cloning/imaging tool is now available for download with Linux kernel 7.0, Partclone 0.3.47, improved MDRAID support, gocryptfs mechanism for image encryption, and other changes.

The post Clonezilla Live 3.3.2 Released with Linux Kernel 7.0, Improved MDRAID Support  appeared first on 9to5Linux  - do not reproduce this article without permission. This RSS feed is intended for readers, not scrapers.


Categories: Distros, News, Clonezilla, Clonezilla Live, disk cloning, disk imaging
Source: https://9to5linux.com/clonezilla-live-3-3-2-released-with-linux-kernel-7-0-improved-mdraid-support Jun 02, 2026, 05:58 PM