prod update

content/install-guides/ams.md

@@ -37,96 +37,77 @@ test_maintenance: true
 test_images:
   - ubuntu:latest
 ---
-[Arm Performance Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio) is a performance analysis tool suite for Android and Linux application developers.
+[Arm Performance Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio) is a performance analysis tool suite for Android and Linux application developers
 
-It helps analyze how your game or app performs on production devices, so you can identify issues that affect performance, cause overheating, or drain battery life.
-
-The following table lists the tools and describes their functions:
+It comprises of a suite of easy-to-use tools that show you how well your game or app performs on production devices, so that you can identify problems that might cause slow performance, overheat the device, or drain the battery.
 
 | Component | Functionality |
 |----------|-------------|
-| [Streamline](https://developer.arm.com/Tools%20and%20Software/Streamline%20Performance%20Analyzer) | Captures a performance profile with hardware counter activity from the device. |
-| [Performance Advisor](https://developer.arm.com/Tools%20and%20Software/Performance%20Advisor) | Generates an easy-to-read performance summary from an annotated Streamline capture, and provides actionable optimization suggestions. |
-| [Frame Advisor](https://developer.arm.com/Tools%20and%20Software/Frame%20Advisor) | Captures API calls and rendering details from a specific frame and provides detailed geometry metrics to help identify rendering bottlenecks. |
-| [Mali Offline Compiler](https://developer.arm.com/Tools%20and%20Software/Mali%20Offline%20Compiler) | Analyzes how efficiently your shader programs perform on a range of Mali GPUs. |
-| [RenderDoc for Arm GPUs](https://developer.arm.com/Tools%20and%20Software/RenderDoc%20for%20Arm%20GPUs) | Debugs Vulkan graphics applications with support for Arm GPU extensions and Android features. |
+| [Streamline](https://developer.arm.com/Tools%20and%20Software/Streamline%20Performance%20Analyzer) with [Performance Advisor](https://developer.arm.com/Tools%20and%20Software/Performance%20Advisor)| Capture a performance profile that shows all the performance counter activity from the device. Generate an easy-to-read performance summary from an annotated Streamline capture, and get actionable advice about where you should optimize. |
+| [Frame Advisor](https://developer.arm.com/Tools%20and%20Software/Frame%20Advisor) | Capture the API calls and rendering from a problem frame and get comprehensive geometry metrics to discover what might be slowing down your application. |
+| [Mali Offline Compiler](https://developer.arm.com/Tools%20and%20Software/Mali%20Offline%20Compiler) | Analyze how efficiently your shader programs perform on a range of Mali GPUs. |
+| [RenderDoc for Arm GPUs](https://developer.arm.com/Tools%20and%20Software/RenderDoc%20for%20Arm%20GPUs) | The industry-standard tool for debugging Vulkan graphics applications, including early support for Arm GPU extensions and Android features. |
 
 
-All features of Arm Performance Studio are available free of charge without a license.
+All features of Arm Performance Studio are available free of charge without any additional license.
 
-## How do I install Arm Performance Studio?
+## Download Arm Performance Studio
 
 Arm Performance Studio is supported on Windows, Linux, and macOS hosts. Download the appropriate installer from [Arm Performance Studio Downloads](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio#Downloads).
 
 Full details about the supported OS and Android versions are given in the Arm Performance Studio [Release Notes](https://developer.arm.com/documentation/107649).
 
-### How do I install Arm Performance Studio on Windows?
-
-Run the downloaded `Arm_Performance_Studio_<version>_windows_x86-64.exe` installer, and follow the on-screen instructions.
-
-To open Streamline, Frame Advisor, or RenderDoc for Arm GPUs, go to the Windows **Start** menu and search for the name of the tool you want to open.
-
-Performance Advisor is a feature of the Streamline command-line application. To generate a performance report, you must first run the provided Python script to enable Streamline to collect frame data from the device. [Get started with Performance Advisor tutorial](https://developer.arm.com/documentation/102478/latest) describes this process in detail. After you have captured a profile with Streamline, run `Streamline-cli` on the Streamline capture file. This command is added to your `PATH` environment variable during installation, so it can be used from anywhere.
+## How do I install Arm Performance Studio on Windows
 
-```console
-Streamline-cli.exe -pa <options> my_capture.apc
-```
-
-To run Mali Offline Compiler, open a command terminal, navigate to your work directory, and run the `malioc` command on a shader program. The malioc command is added to your `PATH` environment variable during installation, so it can be used from anywhere.
+Arm Performance Studio is provided as an installer executable. Double-click the `.exe` file and follow the instructions in the setup wizard.
 
-```console
-malioc.exe <options> my_shader.frag
-```
+Open the Performance Studio Hub from the **Windows Start** menu, or by double-clicking the shortcut in the installation directory. You can read a description of the tools and launch them from the Hub.
 
-### How do I install Arm Performance Studio on macOS?
+### How do I install Arm Performance Studio on macOS
 
 Arm Performance Studio is provided as a `.dmg` package. To mount it, double-click the `.dmg` package and follow the instructions. The Arm Performance Studio directory tree is copied to the Applications directory on your local file system for easy access.
 
-You can remove write permission from the installation directory to prevent other users from writing to it. This is done with the `chmod` command. For example:
+Arm recommends that you set the permissions for the installation directory to prevent other users from writing to it. This is typically achieved with the `chmod` command. For example,
 
 ```
 chmod go-w <dest_dir>
 ```
 
-Open Streamline, Frame Advisor or RenderDoc for Arm GPUs directly from the Arm Performance Studio directory in your Applications directory. For example, to open Streamline, go to the `<installation_directory>/streamline` directory and open the `Streamline.app` file.
+To get started, navigate to the Arm Performance Studio installation directory in your `Applications` directory. Open the `Performance Studio.app` file to launch the **Arm Performance Studio Hub**. You can read a description of the tools and launch them from the Hub.
 
-To run Performance Advisor, go to the `<installation_directory>/streamline` directory, and double-click the `Streamline-cli-launcher` file. Your computer will ask you to allow Streamline to control the Terminal application. Allow this. The Performance Advisor launcher opens the Terminal application and updates your `PATH` environment variable so you can run Performance Advisor from any directory.
+### Install Arm Performance Studio on Linux
 
-Performance Advisor is a feature of the Streamline command-line application. To generate a performance report, you must first run the provided Python script to enable Streamline to collect frame data from the device. This process is described in detail in the [Get started with Performance Advisor tutorial](https://developer.arm.com/documentation/102478/latest). After you have captured a profile with Streamline, run the `Streamline-cli` command on the Streamline capture file to generate a performance report:
+Arm Performance Studio is provided as a gzipped tar archive. Extract this tar archive to your preferred location, using a recent version (1.13 or later) of GNU tar:
 
 ```
-Streamline-cli -pa <options> my_capture.apc
+tar xvzf Arm_Performance_Studio_2025.1_linux.tgz
 ```
 
-To run Mali Offline Compiler, go to the `<installation_directory>/mali_offline_compiler` directory, and double-click the `mali_offline_compiler_launcher` file. The Mali Offline Compiler launcher opens the Terminal application and updates your `PATH` environment variable so you can run the `malioc` command from any directory. To generate a shader analysis report, run the `malioc` command on a shader program:
+Arm recommends that you set the permissions for the installation directory to prevent other users from writing to it. This is typically achieved with the `chmod` command. For example:
 
 ```
-malioc <options> my_shader.frag
+chmod go-w <dest_dir>
 ```
 
-On some versions of macOS, you might see a message that Mali Offline Compiler is not recognized as an application from an identified developer. To enable Mali Offline Compiler, cancel this message, then open **System Preferences > Security & Privacy** and select **Allow Anyway** for the `malioc` application.
-
-### How do I install Arm Performance Studio on Linux?
-
-Arm Performance Studio is provided as a gzipped tar archive. Extract this tar archive to your preferred location, using version 1.13 or later of GNU tar:
+{{% notice Tip %}}
+You might find it useful to edit your `PATH` environment variable to add the paths to the `Streamline-cli` and `malioc` executables so that you can run them from any directory. Add the following commands to the .bashrc file in your home directory, so that they are set whenever you initialize a shell session:
 
 ```
-tar xvzf Arm_Performance_Studio_<version>_linux.tgz
+PATH=$PATH:/<installation_directory>/streamline
+PATH=$PATH:/<installation_directory>/mali_offline_compiler
 ```
 
-You can remove write permission from the installation directory to prevent other users from writing to it. This is done with the `chmod` command. For example:
+{{% /notice %}}
 
-```
-chmod go-w <dest_dir>
-```
+Inside the installation directory is a shortcut called **Performance Studio**. Double-click on the shortcut to launch the Performance Studio Hub. You can read a description of the tools and launch them from the Hub.
 
-You might find it useful to edit your `PATH` environment variable to add the paths to the `Streamline-cli` and `malioc` executables so that you can run them from any directory. Add the following commands to the .bashrc file in your home directory, so that they are set whenever you initialize a shell session:
+Alternatively, to open Streamline, Frame Advisor or RenderDoc for Arm GPUs directly, go to the installation directory, open the folder for the tool you want to open and run the application file. For example:
 
 ```
-PATH=$PATH:<installation_directory>/streamline
-PATH=$PATH:<installation_directory>/mali_offline_compiler
+cd <installation_directory>/streamline
+./Streamline
 ```
 
 ## How do I get started with Arm Performance Studio?
 
-Refer to [Get started with Arm Performance Studio](/learning-paths/mobile-graphics-and-gaming/ams/) for an overview of how to run each tool in Arm Performance Studio.
+See the [Get started with Arm Performance Studio](/learning-paths/mobile-graphics-and-gaming/ams/) learning path for an overview of how to run each tool in Arm Performance Studio.

content/learning-paths/laptops-and-desktops/chrome-os-lxc/_index.md

@@ -0,0 +1,48 @@
+---
+title: Install Ubuntu on ChromeOS Crostini as an LXC Container 
+
+draft: true
+cascade:
+    draft: true
+
+minutes_to_complete: 60
+
+who_is_this_for: This Learning Path is for software developers who want to install Ubuntu and other Linux distributions on their Arm-based Chromebook with ChromeOS file sharing and GUI support.
+
+learning_objectives:
+    - Create an Ubuntu 24.04 container on ChromeOS Crostini using the Termina shell and LXC.
+    - Set up ChromeOS integration for file sharing and GUI applications.
+    - Manage LXC containers on ChromeOS.
+
+prerequisites:
+    - A ChromeOS device with the Linux development environment enabled. The Lenovo Chromebook Plus 14 is recommended. 
+    - Basic knowledge of the Linux command line.
+
+author: Jason Andrews
+
+### Tags
+skilllevels: Introductory
+subjects: Containers and Virtualization
+armips:
+    - Cortex-A
+operatingsystems:
+    - ChromeOS
+tools_software_languages:
+    - Ubuntu
+
+further_reading:
+    - resource:
+        title: Official ChromeOS Linux Support
+        link: https://chromeos.dev/en/linux
+        type: documentation
+    - resource:
+        title: Linux Containers
+        link: https://linuxcontainers.org/
+        type: website
+
+### FIXED, DO NOT MODIFY
+# ================================================================================
+weight: 1                       # _index.md always has weight of 1 to order correctly
+layout: "learningpathall"       # All files under learning paths have this same wrapper
+learning_path_main_page: "yes"  # This should be surfaced when looking for related content. Only set for _index.md of learning path content.
+---

content/learning-paths/laptops-and-desktops/chrome-os-lxc/_next-steps.md

@@ -0,0 +1,6 @@
+---
+weight: 21
+title: "Next Steps" 
+layout: "learningpathall"
+---
+

content/learning-paths/laptops-and-desktops/chrome-os-lxc/page-1.md

@@ -0,0 +1,132 @@
+---
+title: "Create an Ubuntu container"
+weight: 2
+layout: "learningpathall"
+---
+
+The [Lenovo Chromebook Plus 14](https://www.bestbuy.com/site/lenovo-chromebook-plus-14-oled-2k-touchscreen-laptop-mediatek-kompanio-ultra-16gb-memory-256gb-ufs-seashell/6630493.p?skuId=6630493&intl=nosplash) is is powered by the MediaTek Kompanio Ultra processor, featuring an Arm-based MediaTek Kompanio Ultra processor, offers software developers a powerful and energy-efficient platform for Linux development. Its compatibility with containerized environments and support for ChromeOS Linux (Crostini) make it an excellent choice for coding, testing, and running modern development workflows on the go.
+
+This Learning Path will walk you through setting up an Ubuntu 24.04 container on your Arm-based Chromebook using ChromeOS's built-in Linux development environment. You'll learn how to create and manage containers, install essential development tools, and integrate your Ubuntu environment with ChromeOS features like file sharing and GUI application support. By the end, you'll have a flexible and powerful Arm Linux development environment.
+
+## Access the ChromeOS terminal
+
+The first step to creating an Ubuntu container on ChromeOS is to open the ChromeOS shell.
+
+Open the Chrome browser and press **Ctrl + Alt + T** to open crosh, the ChromeOS shell, crosh.
+
+![ChromeOS shell #center](_images/chromeos-shell.png)
+
+Run the command below to start the Termina shell.
+
+```console
+vsh termina
+```
+
+You are now in the Termina environment where you can manage containers.
+
+The `lxc` command is used to manage containers on ChromeOS. 
+
+You can list the running containers.
+
+```console
+lxc list
+```
+
+If you have the default Debian container running you see output similar to:
+
+```output
++---------+---------+-----------------------+------+-----------+-----------+
+|  NAME   |  STATE  |         IPV4          | IPV6 |   TYPE    | SNAPSHOTS |
++---------+---------+-----------------------+------+-----------+-----------+
+| penguin | RUNNING | 100.115.92.204 (eth0) |      | CONTAINER | 0         |
++---------+---------+-----------------------+------+-----------+-----------+
+```
+
+The name of the Debian container is penguin. When you enable the Linux subsystem on ChromeOS the Debian container named penguin is created, but you can create additional containers with different Linux distributions and different names.
+
+## Create a Ubuntu 24.04 container
+
+This command creates and starts a new Ubuntu 24.04 container named `u1`.
+
+```bash
+lxc launch ubuntu:24.04 u1
+```
+
+The output is:
+
+```output
+Creating u1
+Starting u1 
+```
+
+Check the status of the new container and confirm the status is RUNNING.
+
+```bash
+lxc list
+```
+
+Now there are 2 containers running.
+
+```output
++---------+---------+-----------------------+------+-----------+-----------+
+|  NAME   |  STATE  |         IPV4          | IPV6 |   TYPE    | SNAPSHOTS |
++---------+---------+-----------------------+------+-----------+-----------+
+| penguin | RUNNING | 100.115.92.204 (eth0) |      | CONTAINER | 0         |
++---------+---------+-----------------------+------+-----------+-----------+
+| u1      | RUNNING | 100.115.92.206 (eth0) |      | CONTAINER | 0         |
++---------+---------+-----------------------+------+-----------+-----------+
+```
+
+Create a new shell in the Ubuntu container. 
+
+```bash
+lxc exec u1 -- bash
+```
+
+## Complete the Ubuntu setup
+
+Once inside the Ubuntu container, you need to perform some initial setup tasks. 
+
+Update the package lists and upgrade installed packages to the latest versions.
+
+```bash
+apt update && apt upgrade -y
+```
+
+Install essential packages for development and system management. You can select your favorite software packages, these are examples.
+
+```bash
+apt install -y net-tools gcc
+```
+
+Creating a non-root user is a crucial security best practice and ensures that applications don't have unnecessary administrative privileges. The username `ubuntu` is already available in the container. You are free to use `ubuntu` as your non-root user or create a new user. 
+
+{{% notice Note %}}
+The following commands use `user1` as a new username. You can replace it with your actual desired username in all subsequent steps.
+{{% /notice %}}
+
+Create a new user account. Skip if you want to use the `ubuntu` user.
+
+```bash
+adduser user1
+```
+
+Add the new user to the sudo group to grant administrative privileges. Skip if you want to use the `ubuntu` user.
+
+```bash
+usermod -aG sudo user1
+```
+
+Switch to your new user account to continue the setup.
+
+```bash
+su - user1
+```
+
+If you didn't creat a new user switch to `ubuntu` as the non-root user.
+
+```bash
+su - ubuntu
+```
+
+Continue to learn how to integrate the new Ubuntu container with ChromeOS features like file sharing.