production update

.github/pull_request_template.md

@@ -1,5 +1,5 @@
 
-Before submitting a pull request for a new Learning Path, please review [Create a Learning Path](https://learn.arm.com//learning-paths/cross-platform/_example-learning-path/)
+Before submitting a pull request for a new Learning Path, please review [Create a Learning Path](https://learn.arm.com/learning-paths/cross-platform/_example-learning-path/)
 - [ ] I have reviewed Create a Learning Path
 
 Please do not include any confidential information in your contribution. This includes confidential microarchitecture details and unannounced product information. 

.wordlist.txt

@@ -4454,4 +4454,9 @@ Zenoh's
 instrumentable
 subprocesses
 CPzfYHdpQ
-iso
+iso
+Arcee's
+commandlinetools
+ppl
+rollout
+sdkmanager

content/install-guides/aperf.md

@@ -50,26 +50,26 @@ Visit the [releases page](https://github.com/aws/aperf/releases/) to see a list
 You can also download a release from the command line:
 
 ```bash { target="ubuntu:latest" }
-wget https://github.com/aws/aperf/releases/download/v0.1.12-alpha/aperf-v0.1.12-alpha-aarch64.tar.gz
+wget https://github.com/aws/aperf/releases/download/v0.1.15-alpha/aperf-v0.1.15-alpha-aarch64.tar.gz
 ```
 
 Extract the release:
 
 ```bash { target="ubuntu:latest" }
-tar xvfz aperf-v0.1.12-alpha-aarch64.tar.gz
+tar xvfz aperf-v0.1.15-alpha-aarch64.tar.gz
 ```
 
 Add the path to `aperf` in your `.bashrc` file.
 
 ```console
-echo 'export PATH="$PATH:$HOME/aperf-v0.1.12-alpha-aarch64"' >> ~/.bashrc
+echo 'export PATH="$PATH:$HOME/aperf-v0.1.15-alpha-aarch64"' >> ~/.bashrc
 source ~/.bashrc
 ```
 
 Alternatively, you can copy the `aperf` executable to a directory already in your search path.
 
 ```bash { target="ubuntu:latest" }
-sudo cp aperf-v0.1.12-alpha-aarch64/aperf /usr/local/bin
+sudo cp aperf-v0.1.15-alpha-aarch64/aperf /usr/local/bin
 ```
 
 Confirm `aperf` is installed by printing the version:

content/install-guides/go.md

@@ -47,13 +47,13 @@ The easiest way to install Go for Ubuntu on Arm is to download a release, extrac
 Download a Go release:
 
 ```bash { target="ubuntu:latest" }
-wget https://go.dev/dl/go1.23.1.linux-arm64.tar.gz
+wget https://go.dev/dl/go1.24.5.linux-arm64.tar.gz
 ```
 
 Extract the release to `/usr/local/go`:
 
 ```bash { target="ubuntu:latest" }
-sudo tar -C /usr/local -xzf ./go1.23.1.linux-arm64.tar.gz
+sudo tar -C /usr/local -xzf ./go1.24.5.linux-arm64.tar.gz
 ```
 
 Add the path to `go` in your `.bashrc` file. 
@@ -74,7 +74,7 @@ go version
 The output should print the version:
 
 ```output
-go version go1.23.1 linux/arm64
+go version go1.24.5 linux/arm64
 ```
 
 You are ready to use the Go programming language on your Arm machine running Ubuntu.

content/install-guides/multipass.md

@@ -19,7 +19,7 @@ minutes_to_complete: 30
 author: Jason Andrews
 
 ### Link to official documentation
-official_docs: https://multipass.run/docs
+official_docs: https://documentation.ubuntu.com/multipass/en/latest/
 
 test_images:
 - ubuntu:latest
@@ -53,15 +53,15 @@ Multipass uses the terms virtual machine and instance synonymously.
 Download Multipass for macOS.
 
 ```console
-wget https://github.com/canonical/multipass/releases/download/v1.14.1-rc1/multipass-1.14.1-rc1+mac.14+gf2381bfe9.mac-Darwin.pkg
+wget https://github.com/canonical/multipass/releases/download/v1.16.0/multipass-1.16.0+mac-Darwin.pkg
 ```
 
 ### How do I install Multipass on macOS?
 
 Install the download using the package command.
 
 ```console
-sudo installer -pkg multipass-1.14.1-rc1+mac.14+gf2381bfe9.mac-Darwin.pkg -target /
+sudo installer -pkg multipass-1.16.0+mac-Darwin.pkg -target /
 ```
 
 The getting started instructions below use the command line interface. If you prefer to use the graphical interface start it from the macOS Launchpad, the initial screen is shown below. You can use the UI to create, start, and stop virtual machines.
@@ -130,11 +130,7 @@ If you need to install `snapd` run:
 sudo apt install snapd -y
 ```
 
-LXD is also required for Multipass.
 
-```bash
-sudo snap install lxd
-```
 
 {{% notice Note %}}
 You can select from three Multipass releases: stable, beta, or edge. The default version is stable.

content/install-guides/nomachine.md

@@ -66,8 +66,8 @@ Use a text editor to copy and paste this script into a file on the remote machin
 #!/bin/bash
 
 # install NoMachine for remote desktop
-wget https://download.nomachine.com/download/8.4/Arm/nomachine_8.4.2_1_arm64.deb
-sudo dpkg -i nomachine_8.4.2_1_arm64.deb
+wget https://download.nomachine.com/download/9.0/Arm/nomachine_9.0.188_11_arm64.deb
+sudo dpkg -i nomachine_9.0.188_11_arm64.deb
 if [ $? != 0 ]; then
   exit 1
 fi

content/install-guides/openvscode-server.md

@@ -53,23 +53,23 @@ Download a release of OpenVSCode Server from the [GitHub release area](https://g
 For example, use `wget` to download.
 
 ```bash
-wget https://github.com/gitpod-io/openvscode-server/releases/download/openvscode-server-v1.90.0/openvscode-server-v1.90.0-linux-arm64.tar.gz 
+wget https://github.com/gitpod-io/openvscode-server/releases/download/openvscode-server-v1.101.2/openvscode-server-v1.101.2-linux-arm64.tar.gz 
 ```
 
 ## How do I install OpenVSCode Server?
 
 Install the download by extracting the file
 
 ```bash 
-tar xvfz openvscode-server-v1.90.0-linux-arm64.tar.gz
+tar xvfz openvscode-server-v1.101.2-linux-arm64.tar.gz
 ```
 
 ## How do I start OpenVSCode Server?
 
 To start OpenVSCode Server run:
 
 ```bash
-./openvscode-server-v1.90.0-linux-arm64/bin/openvscode-server 
+./openvscode-server-v1.101.2-linux-arm64/bin/openvscode-server 
 ```
 
 The server will print a URL to access VS Code in a browser. The URL is localhost URL. If your machine is a remote system or a Linux subsystem there are two options to connect using your local browser.
@@ -112,7 +112,7 @@ On ChromeOS you can use the Linux configuration settings to automatically do por
 There are command line options to change the port, the token, and other configuration options. To see the options run:
 
 ```bash
-./openvscode-server-v1.90.0-linux-arm64/bin/openvscode-server --help
+./openvscode-server-v1.101.2-linux-arm64/bin/openvscode-server --help
 ```
 
 If you are running all on a local machine the token can be eliminated using the `--without-connection-token` option.

content/install-guides/powershell.md

@@ -52,7 +52,7 @@ You can download a release file for the Arm architecture from GitHub and install
 
 ```bash { target="ubuntu:latest" }
 # Download the powershell '.tar.gz' archive
-curl -L -o /tmp/powershell.tar.gz https://github.com/PowerShell/PowerShell/releases/download/v7.4.1/powershell-7.4.1-linux-arm64.tar.gz
+curl -L -o /tmp/powershell.tar.gz https://github.com/PowerShell/PowerShell/releases/download/v7.5.2/powershell-7.5.2-linux-arm64.tar.gz
 
 # Create the target folder where powershell will be placed
 sudo mkdir -p /opt/microsoft/powershell/7
@@ -88,7 +88,7 @@ pwsh --version
 The version is printed:
 
 ```output
-PowerShell 7.4.1
+PowerShell 7.5.2
 ```
 
 You are now ready to use PowerShell on your Arm Linux computer.

content/install-guides/swift.md

@@ -68,26 +68,26 @@ sudo apt-get -y install \
 
 ## How do I download and install Swift?
 
-This guide uses Swift version 6.0.1 on Ubuntu 24.04. 
+This guide uses Swift version 6.1.2 on Ubuntu 24.04. 
 
 You can get more information about other versions and platforms from [Download Swift](https://www.swift.org/download/).
 
 Download Swift for Arm Linux:
 
 ```bash
-wget https://download.swift.org/swift-6.0.1-release/ubuntu2404-aarch64/swift-6.0.1-RELEASE/swift-6.0.1-RELEASE-ubuntu24.04-aarch64.tar.gz
+wget https://download.swift.org/swift-6.1.2-release/ubuntu2404-aarch64/swift-6.1.2-RELEASE/swift-6.1.2-RELEASE-ubuntu24.04-aarch64.tar.gz
 ```
 
 Extract the archive:
 
 ```bash
-sudo tar -xf swift-6.0.1-RELEASE-ubuntu24.04-aarch64.tar.gz -C /usr/local
+sudo tar -xf swift-6.1.2-RELEASE-ubuntu24.04-aarch64.tar.gz -C /usr/local
 ```
 
 Add the `bin/` directory to your search path:
 
 ```bash
-echo 'export PATH="$PATH:/usr/local/swift-6.0.1-RELEASE-ubuntu24.04-aarch64/usr/bin"' >> ~/.bashrc
+echo 'export PATH="$PATH:/usr/local/swift-6.1.2-RELEASE-ubuntu24.04-aarch64/usr/bin"' >> ~/.bashrc
 source ~/.bashrc
 ```
 
@@ -102,7 +102,7 @@ swift --version
 The expected output is:
 
 ```output
-Swift version 6.0.1 (swift-6.0.1-RELEASE)
+Swift version 6.1.2 (swift-6.1.2-RELEASE)
 Target: aarch64-unknown-linux-gnu
 ```
 
@@ -116,7 +116,7 @@ print("Hello from Swift on Arm Linux!")
 
 Compile and run the program:
 
-```bash
+```console
 swift hello.swift
 ```
 
@@ -128,7 +128,7 @@ Hello from Swift on Arm Linux!
 
 You can also compile and run the program using:
 
-```bash
+```console
 swiftc hello.swift -o hello
 ./hello
 ```

content/learning-paths/automotive/openadkit2_safetyisolation/3_container_spliting.md

@@ -88,6 +88,10 @@ This avoids interruptions in later steps when you run `docker compose up` or `do
 Run the following command in your project directory:
 
 ```bash
+cd docker
+export TIMEOUT=120
+export CONF_FILE=/home/ubuntu/openadkit_demo.autoware/docker/etc/simulation/config/fail_static_obstacle_avoidance.param.yaml
+export COMMON_FILE=/home/ubuntu/openadkit_demo.autoware/docker/etc/simulation/config/common.param.yaml
 docker compose -f docker-compose.yml pull
 ```
 
@@ -309,9 +313,8 @@ export COMMON_FILE=$SCRIPT_DIR/etc/simulation/config/common.param.yaml
 export NGROK_AUTHTOKEN=""
 export NGROK_URL=""
 export TIMEOUT=300
-
 # Launch the container
-docker compose -f docker/docker-compose-2ins.yml run --rm planning-control bash
+docker compose -f docker-compose-2ins.yml run --rm planning-control bash
 ```
 
 Once inside the container shell, activate the ROS 2 environment and start publishing to the /hello topic:
@@ -330,6 +333,14 @@ This confirms that DDS communication from the planning node is received on the s
 
 Same with Publisher side, you need to set the required environment variables and launch the Simulator container.
 
+Navigate to the directory with the Docker Compose file:
+
+```bash
+cd $HOME/openadkit_demo.autoware/docker
+```
+
+Launch the application:
+
 ```bash
 export SCRIPT_DIR=/home/ubuntu/openadkit_demo.autoware/docker
 export CONF_FILE=$SCRIPT_DIR/etc/simulation/config/fail_static_obstacle_avoidance.param.yaml 
@@ -339,7 +350,7 @@ export NGROK_URL=""
 export TIMEOUT=300
 
 # Launch the container
-docker compose -f docker/docker-compose-2ins.yml run --rm simulator bash
+docker compose -f docker-compose-2ins.yml run --rm simulator bash
 ```
 
 Once inside the container shell, activate the ROS 2 environment and start publishing to the /hello topic:

content/learning-paths/automotive/openadkit2_safetyisolation/4_multiinstance_executing.md

@@ -36,8 +36,8 @@ On each instance, copy the appropriate launch script into the `openadkit_demo.au
     export NGROK_URL=$NGROK_URL
 
     # Start planning-control
-      echo "Running planning v1.."
-      TIMEOUT=120 CONF_FILE=$CONF_FILE_PASS docker compose -f "$SCRIPT_DIR/docker-compose-2ins.yml" up planning-control -d  
+    echo "Running planning v1.."
+    TIMEOUT=120 CONF_FILE=$CONF_FILE_PASS docker compose -f "$SCRIPT_DIR/docker-compose-2ins.yml" up planning-control -d  
   {{< /tab >}}
 
   {{< tab header="Visualizer & Simulator" language="bash">}}
@@ -85,8 +85,12 @@ On the Simulation and Visualization node, execute:
 ./opad_sim_vis.sh
 ```
 
-Once both machines are running their respective launch scripts, the Visualizer will generate a web-accessible interface using the machine’s public IP address. 
-You can open this link in a browser to observe the demo behavior.
+
+Once both machines are running their respective launch scripts, the Visualizer will generate a web-accessible interface on:
+
+http://[Visualizer public IP address]:6080/vnc.html
+
+You can open this link in a browser to observe the demo behavior, which will closely resemble the output from the [previous learning path](http://learn.arm.com/learning-paths/automotive/openadkit1_container/4_run_openadkit/). 
 
 ![img3 alt-text#center](split_aws_run.gif "Figure 4: Simulation")
 

content/learning-paths/cross-platform/multiplying-matrices-with-sme2/1-get-started.md

@@ -21,7 +21,7 @@ This section walks you through the required tools and two supported setup option
 
 ## Download and explore the code examples
 
-To get started, begin by [downloading the code examples](https://gitlab.arm.com/learning-cde-examples/code-examples/-/archive/main/code-examples-main.tar.gz?path=learning-paths/cross-platform/multiplying-matrices-with-sme2).
+To get started, begin by [downloading the code examples](https://gitlab.arm.com/learning-code-examples/code-examples/-/archive/main/code-examples-main.tar.gz?path=learning-paths/cross-platform/multiplying-matrices-with-sme2).
 
 Now extract the archive, and change directory to:
 ``code-examples/learning-paths/cross-platform/multiplying-matrices-with-sme2.``

content/learning-paths/cross-platform/zenoh-multinode-ros2/1_intro-zenoh.md

@@ -8,55 +8,43 @@ layout: learningpathall
 
 ## The Need for Scalable Communication in Robotics and Edge Computing
 
-Modern robotics and industrial IoT (IIoT) systems are evolving rapidly—from indoor collaborative arms on assembly lines to fleets of outdoor autonomous delivery robots. 
+Modern robotics and industrial IoT systems are evolving rapidly, from indoor collaborative arms on assembly lines to fleets of outdoor autonomous delivery robots. 
 These applications must operate in real-time, often across multiple compute nodes, over networks that may span factory LANs, 5G cellular links, or even cloud data centers.
 
 Such systems require fast, reliable, and scalable data communication between nodes. 
-This includes not just broadcasting sensor updates or actuator commands (i.e., pub/sub), but also performing state queries, storing values for later use, and even distributed computation across nodes. A modern protocol must be:
+This includes not just broadcasting sensor updates or actuator commands (pub/sub), but also performing state queries, storing values for later use, and even distributed computation across nodes. 
+
+A modern protocol must be:
 * Low-latency: Immediate delivery of time-critical messages.
 * High-throughput: Efficient data flow across many devices.
 * Decentralized: No reliance on central brokers or fixed infrastructure.
 * Flexible: Able to run on lightweight edge devices, across WANs, or inside cloud-native environments.
 
-Traditional communication stacks such as DDS ([Data Distribution Service](https://en.wikipedia.org/wiki/Data_Distribution_Service)) serve as the backbone for middleware like ROS 2. However, DDS struggles in multi-network or wireless environments where multicast is unavailable, or NAT traversal is needed.
+Traditional communication stacks such as Data Distribution Service (DDS) serve as the backbone for middleware like ROS 2. However, DDS struggles in multi-network or wireless environments where multicast is unavailable, or NAT traversal is needed.
 These constraints can severely impact deployment and performance at the edge.
 
 
-## Zenoh: An Open-Source Pub/Sub Protocol for the Industrial Edge
+## Zenoh: an open-source pub/sub protocol for the Industrial Edge
 
-[Eclipse Zenoh](https://zenoh.io/) is a modern, [open-source](https://github.com/eclipse-zenoh/zenoh) data-centric communication protocol that goes beyond traditional pub/sub. Designed specifically for edge computing, IIoT, robotics, and autonomous systems, Zenoh unifies:
+[Eclipse Zenoh](https://zenoh.io/) is a modern, open-source, data-centric communication protocol that goes beyond traditional pub/sub. Designed specifically for edge computing, industrial IoT, robotics, and autonomous systems, Zenoh unifies:
 
-* Data in motion through a powerful and efficient pub/sub model.
-* Data at rest via geo-distributed storage plugins.
-* Data in use with direct query support.
-* On-demand computation via queryable nodes that can generate data dynamically.
+- Data in motion through a powerful and efficient pub/sub model.
+- Data at rest via geo-distributed storage plugins.
+- Data in use with direct query support.
+- On-demand computation via queryable nodes that can generate data dynamically.
 
 Unlike most traditional stacks, Zenoh is fully decentralized and designed to operate across cloud-to-edge-to-thing topologies, making it ideal for industrial robotics, autonomous systems, and smart environments. 
+
 It supports heterogeneous platforms, is implemented in Rust for performance and safety, and also offers bindings for Python, enabling rapid prototyping.
 
 Zenoh is particularly effective in wireless, 5G, or cross-network deployments where multicast and DDS fall short. 
-Its routing engine avoids excessive discovery traffic, conserves bandwidth, and supports seamless bridging between legacy ROS 2/DDS apps and modern, optimized Zenoh networks using zenoh-bridge-dds.
-
-In this learning path, you’ll use Zenoh to build and validate a multi-node distributed communication system across multiple Arm-based platforms, gaining hands-on experience with data exchange and coordination between edge devices.
-
-To make the upcoming demo more intuitive and easy to follow, we’ll demonstrate the setup using two physical Cortex-A Linux devices. 
-
-I’ll be using Raspberry Pi boards in this learning path, but you’re free to substitute them with any Cortex-A devices that support network connectivity with Linux-based OS installed, depending on your development setup.
-
-In real-world ROS 2 deployment scenarios, developers typically conduct validation and performance testing across systems with more than two nodes.
-To simulate such environments, using [Arm virtual hardware](https://www.arm.com/products/development-tools/simulation/virtual-hardware) is also a common and efficient approach.
-
-This will help you quickly validate your architecture choices and communication patterns when designing distributed applications.
-
-* Raspberry Pi,
-* Linux-based Cortex-A, or
-* Arm Virtual Hardware (AVH).
+Its routing engine avoids excessive discovery traffic, conserves bandwidth, and supports seamless bridging between legacy ROS 2/DDS apps and modern, optimized Zenoh networks using Zenoh-Bridge-DDS, a bridge between DDS systems and Zenoh networks.
 
-After this learning path, you will:
-* Understand the core architecture and data flow principles behind Eclipse Zenoh, including its support for pub/sub, querying, and queryable edge functions.
-* Build and run distributed Zenoh examples across multiple Arm-based nodes—using Raspberry Pi or AVH to simulate scalable deployment environments.
-* Rebuild and extend the Zenoh queryable example to simulate edge-side logic.
+In this Learning Path, you’ll use Zenoh to build and validate a multi-node distributed communication system across multiple Arm-based platforms, gaining hands-on experience with data exchange and coordination between edge devices.
 
-By the end of this learning path, you’ll have deployed a fully functional, scalable, and latency-aware Zenoh system.
+The examples use Raspberry Pi boards, but you’re free to substitute any Cortex-A or Neoverse devices that support network connectivity running Linux.
 
-You can also check [here](https://zenoh.io/docs/getting-started/first-app) to find some simple examples.
+Upon completion, you will be able to:
+- Understand the core architecture and data flow principles behind Eclipse Zenoh, including its support for pub/sub, querying, and queryable edge functions.
+- Build and run distributed Zenoh examples across multiple Arm-based nodes using Raspberry Pi or other Arm Linux devices.
+- Rebuild and extend the Zenoh queryable example to simulate edge-side logic.