Prod update

.wordlist.txt

@@ -4590,4 +4590,81 @@ xdp
 xhci
 JFR
 conv
-servlet
+servlet
+tv
+gpiozero
+lgpio
+TinyLlama
+Superscalar
+automations
+gemma
+tinyllama
+pinout
+Makatia
+Omusilibwa
+EdgeAI
+Raspi
+abyz
+fidel
+javascript
+makatia
+uk
+STDDEV
+Stdev
+BytesToBytesMap
+HashMap
+LongToUnsafeRowMap
+Stdev
+UnsafeRow
+UnsafeRowhash
+agg
+arrayEqual
+codegen
+hashmap
+hugeMethodLimit
+ints
+kurtosis
+stddev
+wholestage
+RDD
+TEEs
+paravirtualization
+WholeStageCodegen
+Wholestage
+zshrc
+hadoop
+CBL
+DataFrame
+exitCode
+Gerganov's
+Radoslav
+rgerganov
+NSS
+spatio
+upsampling
+UE
+VGF
+NNE
+RDG
+Configurator
+RHI
+RHIs
+NNERuntimeRDGMLExtensionsForVulkan
+Unreal's
+ORT
+MLEmulationLayerForVulkan
+RenderDoc's
+vgf
+dataflow
+Sandboxed
+sandboxed
+Termina
+LXC
+Crostini
+ChromeOS's
+crosh
+Sommelier
+chromeos
+linuxcontainers
+
+

assets/contributors.csv

@@ -94,4 +94,5 @@ Peter Harris,Arm,,,,
 Chenying Kuo,Adlink,evshary,evshary,,
 William Liang,,,wyliang,,
 Waheed Brown,Arm,https://github.com/armwaheed,https://www.linkedin.com/in/waheedbrown/,,
-Aryan Bhusari,Arm,,https://www.linkedin.com/in/aryanbhusari,,
+Aryan Bhusari,Arm,,https://www.linkedin.com/in/aryanbhusari,,
+Fidel Makatia Omusilibwa,,,,,

content/install-guides/fm_fvp/fvp.md

@@ -11,15 +11,20 @@ multi_install: false             # Set to true if first page of multi-page artic
 multitool_install_part: true    # Set to true if a sub-page of a multi-page article, else false
 layout: installtoolsall         # DO NOT MODIFY. Always true for tool install articles
 ---
-Arm Fixed Virtual Platforms (FVPs) are provided as a library of ready to use platforms.
 
-{{% notice  Arm Development Tools%}}
-An appropriate subset of the FVP library is installed with [Arm Development Studio](/install-guides/armds) and [Keil MDK](/install-guides/mdk) Professional Edition.
+{{% notice Note %}}
+Arm Fixed Virtual Platforms (FVPs) were available as a library of ready to use platforms (and as a component of Arm Development Studio) up until version 11.28.
+
+From 11.29 onwards the FVPs are provided solely as part of Arm Development Studio.
+
+This install guide is only applicable to the legacy FVP library.
+
+See the [Arm Development Studio Install Guide](/install-guides/armds) and the [Introduction to FVPs](https://developer.arm.com/documentation/110379/1129/Introduction-to-FVPs) documentation.
 {{% /notice %}}
 
 ## Download installer packages
 
-You can download the FVP library installer from the [Product Download Hub](https://developer.arm.com/downloads/view/FM000A).
+You can download the FVP library installer from the [Product Download Hub](https://developer.arm.com/downloads/view/FMFVP).
 
 Linux (AArch64 and x86) and Windows (x86 only) hosts are supported.
 
@@ -47,11 +52,6 @@ For full list of available options, use:
 
 FVPs are license managed. License setup instructions are available in the [Arm Licensing install guide](/install-guides/license).
 
-{{% notice  Arm Development Tools%}}
-The FVPs provided with Arm Development Studio and/or Keil MDK Professional Edition use the license of that product, not that of the FVP library.
-{{% /notice %}}
-
-
 ## Verify installation
 
 To verify everything is working OK, navigate to the install directory, and launch any of the supplied FVP executables. No additional command options are needed.

content/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm/2-env-setup.md

@@ -50,7 +50,7 @@ Run the commands below to set up the ExecuTorch internal dependencies:
 
 ```bash
 git submodule sync
-git submodule update --init
+git submodule update --init --recursive
 ./install_executorch.sh
 ```
 

content/learning-paths/embedded-and-microcontrollers/raspberry-pi-smart-home/1-overview.md

@@ -0,0 +1,73 @@
+---
+title: Run LLMs locally on Raspberry Pi 5 for Edge AI
+
+weight: 2
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Overview
+
+This Learning Path walks you through deploying an efficient large language model (LLM) locally on the Raspberry Pi 5, powered by an Arm Cortex-A76 CPU. This setup enables you to control your smart home using natural language without relying on cloud services. With rapid advances in generative AI and the power of Arm Cortex-A processors, you can now run advanced language models directly in your home on the Raspberry Pi 5.
+
+You will create a fully local, privacy-first smart home system that leverages the strengths of Arm Cortex-A architecture. The system can achieve 15+ tokens per second inference speeds using optimized models like TinyLlama and Qwen, while maintaining the energy efficiency that makes Arm processors well suited for always-on applications.
+
+## Why Arm Cortex-A76 makes Raspberry Pi 5 ideal for Edge AI
+
+The Raspberry Pi 5's Arm Cortex-A76 processor can manage high-performance computing tasks like AI inference. Key architectural features include:
+
+- **Superscalar architecture**: Executes multiple instructions in parallel, improving throughput for compute-heavy tasks
+- **128-bit NEON SIMD support**: Accelerates matrix and vector operations, common in the inner loops of language model inference
+- **Multi-level cache hierarchy**: Reduces memory latency and improves data access efficiency during runtime
+- **Thermal efficiency**: Enables sustained performance without active cooling, making it ideal for compact or always-on smart home setups
+
+These characteristics make the Raspberry Pi 5 well suited for workloads like smart home assistants, where responsiveness, efficiency, and local processing are important. Running LLMs locally on Arm-based devices brings several practical benefits. Privacy is preserved, since conversations and routines never leave the device. With optimized inference, the system can offer responsiveness under 100 ms, even on resource-constrained hardware. It remains fully functional in offline scenarios, continuing to operate when internet access is unavailable. Developers also gain flexibility to customize models and automations. Additionally, software updates and an active ecosystem continue to improve performance over time.
+
+## Leverage the Arm ecosystem for Raspberry Pi Edge AI
+
+For the stack in this setup, Raspberry Pi 5 benefits from the extensive developer ecosystem:
+
+- Optimized compilers including GCC and Clang with Arm-specific enhancements
+- Native libraries such as gpiozero and lgpio are optimized for Raspberry Pi
+- Community support from open-source projects where developers contribute Arm-optimized code
+- Backward compatibility in Arm architecture reduces friction when updating kernels or deploying across platforms
+- The same architecture powers smartphones, embedded controllers, edge devices, and cloud infrastructure—enabling consistent development practices across domains
+
+## Performance benchmarks on Raspberry Pi 5
+
+The table below shows inference performance for several quantized models running on a Raspberry Pi 5. Measurements reflect single-threaded CPU inference with typical prompt lengths and temperature settings suitable for command-based interaction.
+
+| Model               | Tokens/sec | Avg latency (ms) |
+| ------------------- | ---------- | ---------------- |
+| qwen:0.5b           | 17.0       | 8,217            |
+| tinyllama:1.1b      | 12.3       | 9,429            |
+| deepseek-coder:1.3b | 7.3        | 22,503           |
+| gemma2:2b           | 4.1        | 23,758           |
+| deepseek-r1:7b      | 1.6        | 64,797           |
+
+## LLM benchmark insights on Raspberry Pi 5
+
+- Qwen 0.5B and TinyLlama 1.1B deliver fast token generation and low average latency, making them suitable for real-time interactions such as voice-controlled smart home commands
+- DeepSeek-Coder 1.3B and Gemma 2B trade some speed for improved language understanding, which can be useful for complex tasks or context-aware prompts
+- DeepSeek-R1 7B offers advanced reasoning capabilities with acceptable latency, which may be viable for offline summarization, planning, or low-frequency tasks
+
+## Supported Arm-powered devices
+
+This Learning Path focuses on the Raspberry Pi 5, but you can adapt the concepts and code to other Arm-powered devices.
+
+## Recommended platforms
+
+| Platform            | CPU                              | RAM            | GPIO support                   | Model size suitability      |
+| ------------------- | -------------------------------- | -------------- | ------------------------------ | --------------------------- |
+| **Raspberry Pi 5**  | Arm Cortex-A76 quad-core @ 2.4GHz | Up to 16GB     | Native `lgpio` (high-performance) | Large models (8–16GB)       |
+| **Raspberry Pi 4**  | Arm Cortex-A72 quad-core @ 1.8GHz | Up to 8GB      | Compatible with `gpiozero`        | Small to mid-size models    |
+| **Other Arm devices** | Arm Cortex-A                    | 4GB min (8GB+ recommended) | Requires physical GPIO pins       | Varies by RAM               |
+
+Additionally, the platform must meet the following requirements:
+
+- GPIO pins available for hardware control
+- Python 3.8 or newer
+- Ability to run [Ollama](https://ollama.com/)
+
+In the next section, you’ll set up the software dependencies needed to start building your privacy-first smart home system on Raspberry Pi 5.

content/learning-paths/embedded-and-microcontrollers/raspberry-pi-smart-home/2-software-dependencies.md

@@ -0,0 +1,102 @@
+---
+title: Set up software dependencies on Raspberry Pi 5 for Ollama and LLMs
+weight: 3
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Overview
+
+In this section, you’ll prepare your Raspberry Pi 5 by installing Python, required libraries, and Ollama, so you can run large language models (LLMs) locally.
+
+{{% notice Note %}}
+This Learning Path assumes you have set up your Raspberry Pi with Raspberry Pi OS and network connectivity. For Raspberry Pi 5 setup support, see [Raspberry Pi Getting Started](https://www.raspberrypi.com/documentation/).
+{{% /notice %}}
+
+## Connect to your Raspberry Pi 5
+
+### Option 1: Use a display
+
+The easiest way to work on your Raspberry Pi is by connecting it to an external display through one of the micro‑HDMI ports. This setup also requires a keyboard and mouse.
+
+### Option 2: Use SSH
+
+You can also use SSH to access the terminal. To use this approach, you need to know the IP address of your device. Ensure your Raspberry Pi 5 is on the same network as your host computer. Access your device remotely via SSH using the terminal or any SSH client.
+
+Replace `<user>` with your Pi's username (typically `pi`), and `<pi-ip>` with your Raspberry Pi 5's IP address.
+
+```bash
+ssh <user>@<pi-ip>
+```
+
+## Install Python and system dependencies
+
+Create a directory called `smart-home` in your home directory and navigate into it:
+
+```bash
+mkdir -p "$HOME/smart-home"
+cd "$HOME/smart-home"
+```
+
+The Raspberry Pi 5 includes Python 3 preinstalled, but you need additional packages:
+
+```bash
+sudo apt update && sudo apt upgrade -y
+sudo apt install -y python3 python3-pip python3-venv git curl build-essential gcc python3-lgpio
+```
+
+## Configure a virtual environment
+
+Create and activate a Python virtual environment to isolate project dependencies:
+
+```bash
+python3 -m venv venv
+source venv/bin/activate
+```
+
+Install the required libraries:
+
+```bash
+pip install ollama gpiozero lgpio psutil httpx orjson numpy fastapi uvicorn uvloop
+```
+
+## Install Ollama
+
+Install Ollama using the official installation script for Linux:
+
+```bash
+curl -fsSL https://ollama.com/install.sh | sh
+```
+
+Verify the installation:
+
+```bash
+ollama --version
+```
+
+If installation was successful, the output should be similar to:
+
+```output
+ollama version is 0.11.4
+```
+
+## Run a test LLM with Ollama on Raspberry Pi 5
+
+Ollama supports various models. This guide uses `deepseek-r1:7b` as an example, but you can also use `tinyllama:1.1b`, `qwen:0.5b`, `gemma2:2b`, or `deepseek-coder:1.3b`.
+
+The `run` command sets up the model automatically. You will see download progress in the terminal, followed by an interactive prompt when ready.
+
+```bash
+ollama run deepseek-r1:7b
+```
+
+{{% notice Troubleshooting %}}
+If you run into issues with the model download, try the following:
+
+- Confirm internet access and sufficient storage space on your microSD card.
+- Try smaller models like `qwen:0.5b` or `tinyllama:1.1b` if you encounter memory issues. 16 GB of RAM is sufficient for small to medium models; very large models may require more memory or run slower.
+- Clear storage or connect to a more stable network if errors occur.
+{{% /notice %}}
+
+With the model set up through Ollama, move on to the next section to start configuring the hardware.

content/learning-paths/embedded-and-microcontrollers/raspberry-pi-smart-home/3-test-gpio.md

@@ -0,0 +1,75 @@
+---
+title: Test Raspberry Pi 5 GPIO pins for smart home devices
+weight: 4
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Overview
+
+The next step is to test the GPIO functionality. In this section, you configure an LED light to simulate a smart home device.
+
+## Verify GPIO setup on Raspberry Pi 5
+
+Gather your electronic components. Connect the anode (long leg) of an LED in series with a 220Ω resistor to GPIO 17 (physical pin 11). Connect the cathode (short leg) to a ground (GND) pin. 
+
+See the image below for the full setup:
+
+![Raspberry Pi connected to a breadboard with a green LED and jumper wires alt-text#center](pin_layout.jpg "Raspberry Pi connected to a breadboard with a green LED and jumper wires")
+
+Create a Python script named `testgpio.py`:
+
+```bash
+cd $HOME/smart-home
+vim testgpio.py
+```
+
+Add the following code to the file:
+
+```python
+#!/usr/bin/env python3
+import time
+from gpiozero import Device, LED
+from gpiozero.pins.lgpio import LGPIOFactory
+
+# Set lgpio backend for Raspberry Pi 5
+Device.pin_factory = LGPIOFactory()
+
+# Set up GPIO pin 17
+pin1 = LED(17)
+
+try:
+    while True:
+        pin1.toggle()  # Switch pin 17 state
+        time.sleep(2)  # Wait 2 seconds
+except KeyboardInterrupt:  # Ctrl+C pressed
+    pin1.close()  # Clean up pin 17
+```
+
+Run the script:
+
+```bash
+python testgpio.py
+```
+
+The LED should blink every two seconds. If you observe this behavior, your GPIO setup works correctly.
+
+{{% notice Troubleshooting %}}
+If you run into issues with the hardware setup, check the following:
+
+- Fix missing dependencies with:  
+  ```bash
+  sudo apt-get install -f
+  ```
+- If you encounter GPIO permission issues, run Python scripts with `sudo` or add your user to the `gpio` group. Don’t forget to log out for the changes to take effect:  
+  ```bash
+  sudo usermod -a -G gpio $USER
+  ```
+- Double-check wiring and pin numbers using the Raspberry Pi 5 pinout diagram
+- Ensure proper LED and resistor connections
+- Verify GPIO enablement in `raspi-config` if needed
+- Use a high-quality power supply
+{{% /notice %}}
+
+With GPIO pins working, you can now move on to the next section to interact with devices using language models and the user interface.