production update

content/install-guides/armpl.md

@@ -32,8 +32,8 @@ layout: installtoolsall         # DO NOT MODIFY. Always true for tool install ar
 
 [Arm Performance Libraries](https://developer.arm.com/downloads/-/arm-performance-libraries#documentation) provides developers with optimized math libraries for high performance computing applications on Arm Neoverse based hardware.
 
-These libraries include highly optimized functions for BLAS, LAPACK, FFT, sparse linear algebra, libamath and libastring.
-These libraries are free to use and do not require a license. They can be installed either standalone or with your installation of [Arm Compiler for Linux](/install-guides/acfl). This install guide covers the standalone installation.
+These libraries include highly optimized functions for BLAS, LAPACK, FFT, sparse linear algebra, random number generation, libamath and libastring.
+These libraries are free to use and do not require a license.
 
 Arm Performance Libraries are available for use on [Windows 11 on Arm](#windows), [macOS](#macos) (Apple Silicon), and [Linux](#linux) (AArch64) hosts.
 
@@ -63,6 +63,16 @@ Click 'Install' and then 'Finish' to complete the installation.
 
 ![win_wizard04 #left](/install-guides/_images/armpl_wizard04.png)
 
+To install Arm Performance Libraries from a command prompt and automatically accept the End User License Agreement use:
+```console
+msiexec.exe /i arm-performance-libraries_<version>_Windows.msi /quiet ACCEPT_EULA=1
+```
+
+To install Arm Performance Libraries using the `winget` package manager and automatically accept the End User License Agreement use:
+```console
+winget install --accept-package-agreements Arm.ArmPerformanceLibraries
+```
+
 You can now start linking your application to the Arm Performance libraries on your Windows on Arm device. Follow the examples in the included `RELEASE_NOTES` file of your extracted installation directory to get started.
 
 For more information refer to [Get started with Arm Performance Libraries](https://developer.arm.com/documentation/109361).
@@ -74,28 +84,28 @@ For more information refer to [Get started with Arm Performance Libraries](https
 
 In a terminal, run the command shown below to download the macOS package:
 ```console
-wget https://developer.arm.com/-/cdn-downloads/permalink/Arm-Performance-Libraries/Version_25.04/arm-performance-libraries_25.04_macOS.tgz
+wget https://developer.arm.com/-/cdn-downloads/permalink/Arm-Performance-Libraries/Version_25.07/arm-performance-libraries_25.07_macOS.tgz
 ```
 
 Use tar to extract the file:
 ```console
-tar zxvf arm-performance-libraries_25.04_macOS.tgz
+tar zxvf arm-performance-libraries_25.07_macOS.tgz
 ```
 
 Output of above command:
 ```console
-armpl_25.04_flang-new_clang_19.dmg
+armpl_25.07_flang-20.dmg
 ```
 
 Mount the disk image by running from a terminal:
 ```console
-hdiutil attach armpl_25.04_flang-new_clang_19.dmg
+hdiutil attach armpl_25.07_flang-20.dmg
 ```
 
 Now run the installation script as a superuser:
 
 ```console
-/Volumes/armpl_25.04_flang-new_clang_19_installer/armpl_25.04_flang-new_clang_19_install.sh -y
+/Volumes/armpl_25.07_flang-20_installer/armpl_25.07_flang-20_install.sh -y
 ```
 
 Using this command you automatically accept the End User License Agreement and the packages are installed to the `/opt/arm` directory. If you want to change the installation directory location use the `--install_dir=` option with the script and provide the desired directory location.
@@ -107,7 +117,7 @@ For more information refer to [Get started with Arm Performance Libraries](https
 
 ## How do I install Arm Performance Libraries on Linux? {#linux}
 
-Arm Performance Libraries are supported on most Linux distributions like Ubuntu, RHEL, SLES and Amazon Linux on an `AArch64` host and compatible with various versions of GCC, LLVM, and NVHPC. The GCC compatible releases are built with GCC 14 and tested with GCC versions 7 to 14. The LLVM compatible releases are tested with LLVM 19.1. The NVHPC compatible releases are tested with NVHPC 24.7.
+Arm Performance Libraries are supported on most Linux distributions like Ubuntu, RHEL, SLES and Amazon Linux on an `AArch64` host and compatible with various versions of GCC, LLVM, and NVHPC. The GCC compatible releases are built with GCC 14 and tested with GCC versions 7 to 14. The LLVM compatible releases are tested with LLVM 20.1. The NVHPC compatible releases are tested with NVHPC 25.5.
 
 ### How do I manually download and install Arm Performance Libraries on Linux?
 
@@ -122,26 +132,26 @@ The instructions shown below are for deb based installers for GCC users.
 In a terminal, run the command shown below to download the Debian package:
 
 ```bash
-wget https://developer.arm.com/-/cdn-downloads/permalink/Arm-Performance-Libraries/Version_25.04.1/arm-performance-libraries_25.04.1_deb_gcc.tar
+wget https://developer.arm.com/-/cdn-downloads/permalink/Arm-Performance-Libraries/Version_25.07/arm-performance-libraries_25.07_deb_gcc.tar
 ```
 
 Use `tar` to extract the file and then change directory:
 
 ```bash
-tar xf arm-performance-libraries_25.04.1_deb_gcc.tar
+tar xf arm-performance-libraries_25.07_deb_gcc.tar
 ```
 
 Run the installation script as a super user:
 
 ```bash
-sudo ./arm-performance-libraries_25.04.1_deb/arm-performance-libraries_25.04.1_deb.sh --accept
+sudo ./arm-performance-libraries_25.07_deb/arm-performance-libraries_25.07_deb.sh --accept
 ```
 
 Using the `--accept` switch you automatically accept the End User License Agreement and the packages are installed to the `/opt/arm` directory.
 
 If you want to change the installation directory location use the `--install-to` option with the script and provide the desired directory location.
 
-## How do I download and install Arm Performance Libraries using system packages on Linux?
+### How do I download and install Arm Performance Libraries using system packages on Linux?
 
 Arm Performance Libraries are available to install using Linux system package managers. The instructions shown below are for the Ubuntu system package manager `apt` command.
 
@@ -190,13 +200,13 @@ module avail
 The output should be similar to:
 
 ```output
-armpl/25.04.1_gcc
+armpl/25.07_gcc
 ```
 
 Load the appropriate module:
 
 ```console
-module load armpl/25.04.1_gcc
+module load armpl/25.07_gcc
 ```
 
 You can now compile and test the examples included in the `/opt/arm/<armpl_dir>/examples/`, or `<install_dir>/<armpl_dir>/examples/` directory, if you have installed to a different location than the default.

content/install-guides/container.md

@@ -0,0 +1,215 @@
+---
+title: Container CLI for macOS
+
+draft: true
+
+author: Rani Chowdary Mandepudi
+
+minutes_to_complete: 10
+
+official_docs: https://github.com/apple/container
+
+additional_search_terms:
+- container 
+- virtualization
+
+layout: installtoolsall
+multi_install: false
+multitool_install_part: false
+test_maintenance: false
+weight: 1
+---
+
+Container CLI is an open-source command line tool from Apple for building and running Arm Linux containers directly on macOS using lightweight virtual machines, without the need for Docker Desktop or Linux VMs.
+
+It supports the full OCI (Open Container Initiative) workflow: building, running, tagging, and pushing container images.
+
+## What should I do before installing the Container CLI?
+
+This article provides a step-by-step guide to install and use the `container` command-line tool for building and running Arm Linux containers natively on macOS systems with Apple silicon.
+
+Confirm you are using an Apple silicon Mac by running:
+
+```bash
+uname -m
+```
+
+The output on macOS is:
+
+```output
+arm64
+```
+
+Container CLI only works on Macs with Apple silicon, including M1, M2, M3, and M4.
+
+Use the following command to verify macOS version:
+
+```bash
+sw_vers -productVersion
+```
+
+Example output:
+
+```output
+15.5
+```
+
+Your computer must be running macOS 15.0 or later to use the Container CLI.
+
+## How do I install Container CLI?
+
+To install Container CLI on macOS, follow the steps below:
+
+From the [official GitHub Release page](https://github.com/apple/container/releases), download the latest signed `.pkg` installer. 
+
+For example:
+
+```bash
+wget https://github.com/apple/container/releases/download/0.2.0/container-0.2.0-installer-signed.pkg
+```
+
+Install the downloaded package using:
+
+```bash
+sudo installer -pkg container-0.2.0-installer-signed.pkg -target /
+```
+
+This installs the Container binary at `/usr/local/bin/container`
+
+After installation, start the container system service by running the following command:
+
+```bash
+container system start
+```
+
+{{% notice Note %}}
+The system service must be running to use container operations such as build, run, or push. It may also need to be started again after a reboot, depending on system settings.
+{{% /notice %}}
+
+The background server process is now running. 
+
+Verify the CLI version:
+
+```bash
+container --version
+```
+
+Example output:
+
+```output
+container CLI version 0.2.0 
+```
+
+This confirms that the Container CLI is successfully installed and ready to use.
+
+## How do I build, run, and push a container using the Container CLI?
+
+### Create a Dockerfile
+
+You can define a simple image that prints the system architecture.
+
+Use an editor to create a file named `Dockerfile` with the following contents:
+
+```bash
+FROM ubuntu:latest
+CMD echo -n "Architecture is " && uname -m
+```
+
+### Build the container image
+
+Build the image from the `Dockerfile`. 
+
+This will pull the Ubuntu base image and tag the result as `uname`.
+
+```bash
+container build -t uname .
+```
+
+The output will be similar to: 
+
+```output
+Successfully built uname:latest
+```
+
+### Run the container 
+
+Execute the container to verify it runs successfully and prints the system architecture.
+
+```bash 
+container run --rm uname
+```
+
+The output is: 
+
+```output
+Architecture is aarch64
+```
+
+The `--rm` flag removes the container after it finishes.
+
+### Tag and push the image
+
+Once the image is built and tested locally, it can be pushed to a container registry such as Docker Hub. This allows the image to be reused across machines or shared with others.
+
+Use the `tag` command to apply a registry-compatible name to the image: 
+
+```bash 
+container images tag uname docker.io/<your-username>/uname:latest
+```
+
+Replace `<your-username>` with your Docker Hub username.
+
+Before pushing the image, log in to Docker Hub:
+
+```bash 
+container registry login docker.io
+```
+
+Enter your Docker Hub username and password.
+
+{{% notice Note %}}
+The same command works with other registries such as GitHub Container Registry (ghcr.io) or any OCI-compliant registry. Replace `docker.io` with the appropriate registry hostname.
+{{% /notice %}}
+
+Next, upload the tagged image to Docker Hub.
+
+```bash 
+container images push docker.io/<your-username>/uname:latest
+```
+
+Once the push completes successfully, the image will be available in the Docker Hub repository. It can be pulled and run on other systems that support the Arm architecture. 
+
+## How can I list images and containers?
+
+You can view locally built or pulled images using:
+
+```bash 
+container images ls
+```
+
+To see running or previously executed containers:
+
+```bash
+container ls
+```
+
+## How do I uninstall the Container CLI?
+
+The Container CLI includes an uninstall script that allows you to remove the tool from your system. You can choose to remove the CLI with or without user data.
+
+Uninstall and keep user data (images, containers):
+
+```bash 
+uninstall-container.sh -k
+```
+
+Use this if you plan to reinstall later and want to preserve your local container data.
+
+Uninstall and delete all user data:
+
+```bash
+uninstall-container.sh -d
+```
+This will permanently remove the CLI and all container images, logs, and metadata.
+
+You can now build and run Arm Linux containers on macOS. 

content/learning-paths/servers-and-cloud-computing/bolt-merge/_index.md

@@ -1,23 +1,19 @@
 ---
 title: Optimize Arm applications and shared libraries with BOLT
 
-draft: true
-cascade:
-    draft: true
-
 minutes_to_complete: 30
 
-who_is_this_for: Performance engineers and software developers working on Arm platforms who want to optimize both application binaries and shared libraries using BOLT.
+who_is_this_for: This is an advanced topic for performance engineers and software developers targeting Arm platforms who want to optimize application binaries and shared libraries using BOLT.
 
 learning_objectives: 
-    - Instrument and optimize application binaries for individual workload features using BOLT.
-    - Collect separate BOLT profiles and merge them for comprehensive code coverage.
-    - Optimize shared libraries independently.
-    - Integrate optimized shared libraries into applications.
-    - Evaluate and compare application and library performance across baseline, isolated, and merged optimization scenarios.
+  - Instrument and optimize application binaries for individual workload features using BOLT
+  - Collect and merge separate BOLT profiles to improve code coverage
+  - Optimize shared libraries independently of application binaries
+  - Integrate optimized shared libraries into applications
+  - Evaluate and compare performance across baseline, isolated, and merged optimization scenarios
 
 prerequisites:
-    - An Arm based system running Linux with [BOLT](/install-guides/bolt/) and [Linux Perf](/install-guides/perf/) installed. 
+  - An Arm-based Linux system with [BOLT](/install-guides/bolt/) and [Linux Perf](/install-guides/perf/) installed
 
 author: Gayathri Narayana Yegna Narayanan