Merge pull request #3383 from ArmDeveloperEcosystem/main

Prod update

Author: pareenaverma

.wordlist.txt

@@ -6255,3 +6255,53 @@ reachy
 schedulable
 swaptions
 tmux
+Asserion
+CzBwmQNBGAA
+HostPath
+Keycloak
+Keycloak's
+LDAP
+LocalPV
+Mayastor
+MegaLights
+Megalights
+NFRU
+NSSD
+NodePort
+NodePorts
+OIDC
+OpenEBS
+OpenID
+PKCE
+PSNR
+PVCs
+PersistentVolumeClaims
+QATQHtI
+Raytracing
+ReSTIR
+Revalidate
+SAML
+SIGGRAPH
+VFX
+YQK
+albedo
+appsn
+authlib
+deduplication
+denoise
+denoisers
+gdc
+keycloak
+nocookie
+oauth
+openebs
+openid
+reprojected
+splitscreen
+summarizer
+testuser
+timestep
+unbuffered
+upserting
+userinfo
+voicechatbot

content/install-guides/sbx.md

@@ -0,0 +1,204 @@
+---
+title: Docker Sandboxes (sbx)
+
+description: Install Docker Sandboxes (sbx) on macOS with Apple Silicon to run AI coding agents in isolated Arm Linux microVMs using Apple's virtualization framework.
+
+minutes_to_complete: 10
+
+official_docs: https://docs.docker.com/ai/sandboxes/
+
+additional_search_terms:
+- docker
+- sbx
+- sandbox
+- microvm
+- containers
+- apple silicon
+
+author: Jason Andrews
+
+test_images:
+test_maintenance: false
+
+weight: 1
+tool_install: true
+multi_install: false
+multitool_install_part: false
+layout: installtoolsall
+---
+
+Docker Sandboxes (`sbx`) is a standalone CLI from Docker for running AI coding agents in isolated microVMs. Each sandbox gets its own filesystem, network, and Docker daemon, so agents can install packages, modify files, and run containers without touching your host system.
+
+{{% notice Note %}}
+`sbx` is not available on Arm Linux. 
+{{% /notice %}}
+
+On macOS with Apple Silicon, `sbx` uses Apple's virtualization framework to launch Arm Linux (Ubuntu) microVMs. You don't need Docker Desktop.
+
+## Before you begin
+
+You need:
+
+- A Mac with Apple Silicon (M1 or later) running macOS Sonoma (version 14) or later.
+- A [Docker Hub](https://hub.docker.com/) account to authenticate `sbx`.
+- [Homebrew](https://brew.sh/) installed.
+
+## Install the sbx CLI
+
+Install `sbx` using Homebrew:
+
+```bash
+brew install docker/tap/sbx
+```
+
+Homebrew installs the `sbx` binary at `/opt/homebrew/bin/sbx`.
+
+## Verify the installation
+
+After installing the CLI, verify that the installation was successful.
+
+### Check the sbx CLI version
+
+Start by checking what version of `sbx` is installed:
+
+```bash
+sbx version
+```
+
+{{% notice Note %}}
+The following output shows the version at the time this guide was written. Homebrew installs the latest available version. To find the latest release, see the [sbx releases page](https://github.com/docker/sbx-releases/releases).
+{{% /notice %}}
+
+The output is similar to:
+
+```output
+sbx version: v0.32.0 55580366449bcfebfc1787b9944284cf64c856d7
+```
+
+### Authenticate with Docker Hub
+
+Sign in to your Docker account:
+
+```bash
+sbx login
+```
+
+This outputs a one-time code and a URL. Open the link in a browser, sign in with your Docker Hub credentials, and approve the activation.
+
+### Start a shell sandbox
+
+Navigate to your project directory and start an agentless sandbox for manual exploration:
+
+```bash
+sbx run shell
+```
+
+This launches a bare Arm Linux microVM with a shell prompt. No AI agent runs inside it.
+On your first run, the CLI will ask you to select a network policy:
+
+- `Open`: allows all network access from within the sandbox.
+- `Balanced`: allows common development services while blocking everything else.
+- `Locked Down`: blocks all outbound network traffic.
+
+`Balanced` is a good starting point for most development workflows.
+
+### Confirm the sandbox runs Arm Linux
+
+To ensure the shell sandbox runs as expected, from within the sandbox, verify the operating system and architecture:
+
+```bash
+uname -a
+```
+
+The output is similar to:
+
+```output
+Linux shell-arm-learning-paths 7.0.8 #1 SMP PREEMPT Thu Jun  4 20:59:42 UTC 2026 aarch64 GNU/Linux
+```
+
+Check the Ubuntu release:
+
+```bash
+cat /etc/os-release
+```
+
+The output is similar to:
+
+```output
+PRETTY_NAME="Ubuntu 26.04 LTS"
+NAME="Ubuntu"
+VERSION_ID="26.04"
+VERSION="26.04 (Resolute Raccoon)"
+VERSION_CODENAME=resolute
+ID=ubuntu
+ID_LIKE=debian
+HOME_URL="https://www.ubuntu.com/"
+SUPPORT_URL="https://help.ubuntu.com/"
+BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
+PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
+UBUNTU_CODENAME=resolute
+LOGO=ubuntu-logo
+```
+
+This confirms that the shell sandbox is running Arm Linux (Ubuntu on aarch64) inside the microVM. 
+
+Keep the shell running to test management commands in another terminal.
+
+### Verify sandbox management commands
+
+In another terminal window, list all sandboxes with their agent and current status:
+
+```bash
+sbx ls
+```
+
+The output is similar to:
+
+```output
+SANDBOX                    AGENT   STATUS    PORTS    WORKSPACE
+shell-arm-learning-paths   shell   stopped           /Users/arm-learning-paths
+```
+
+Copy a file from your Mac into the sandbox. For example:
+
+```bash
+sbx cp ./myfile.txt <SANDBOX>:/home/user/myfile.txt
+```
+
+Copy a file from a sandbox back to your Mac. For example:
+
+```bash
+sbx cp <SANDBOX>:/home/user/output.txt ./output.txt
+```
+
+## Clean up 
+
+Stop the running shell sandbox using its name:
+
+```bash
+sbx stop <SANDBOX>
+```
+
+The running shell sandbox in the first terminal window stops.
+
+Remove the sandbox permanently:
+
+```bash
+sbx rm <SANDBOX>
+```
+
+You'll be prompted to confirm whether you want to remove the sandbox. Answer `y` and press Enter to delete the sandbox.
+
+## Next steps
+
+You're now ready to use Docker Sandboxes to run AI agents in isolated microVMs on macOS. 
+
+To launch an agent sandbox, provide the name of the agent sandbox in the run command. For example, to launch a Claude sandbox:
+
+```bash
+sbx run claude
+```
+
+Other supported agent sandboxes include `copilot`, `codex`, and `kiro`. For the full list, see the [Docker Sandboxes agents documentation](https://docs.docker.com/ai/sandboxes/agents/).
+
+You can use AI agents with the Arm MCP Server to build on or migrate to Arm. For more information, see the [Arm MCP Server](/learning-paths/servers-and-cloud-computing/arm-mcp-server/) Learning Path.

content/learning-paths/mobile-graphics-and-gaming/neural-graphics-playbook-evaluate/01-from-neural-graphics-to-megalights.md

@@ -0,0 +1,63 @@
+---
+title: Evaluate Arm Neural Technology for your mobile game
+description: Learn why Arm Neural Technology matters for mobile games, how Neural Super Sampling provides the foundation, and how Neural Dawn validates these techniques in production.
+weight: 2
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## The opportunity: why Arm Neural Technology, why now
+
+Arm Neural Technology takes advantage of a key benefit of machine learning. When you handle certain rendering tasks more efficiently than traditional approaches, you can free up budget for other aspects of your game. 
+
+At SIGGRAPH 2025, Arm announced that [Arm GPUs will have dedicated neural accelerators (NX) in 2026](https://newsroom.arm.com/news/arm-announces-arm-neural-technology). Arm Neural Technology provides the tools you need to evaluate and integrate these techniques into your projects.
+
+## Neural Super Sampling: the foundation
+
+On mobile, every rendering decision is a tradeoff. Resolution, lighting, effects, frame rate, thermals, battery life all compete for the same limited resources. These technical tradeoffs ultimately impact player experience. Visual quality matters, but so does responsiveness, stable performance, and how long a player can stay immersed in the game without their device heating up or throttling.
+
+[Neural Super Sampling (NSS)](https://developer.arm.com/community/arm-community-blogs/b/mobile-graphics-and-gaming-blog/posts/how-to-access-arm-neural-super-sampling) was the first step in shifting that balance. Upscaling isn't new. Shader-based upscalers are already widely used across game engines and mobile games because rendering at lower resolution is one of the most effective ways to save performance. The question was whether machine learning could push that idea further.
+
+NSS enables more aggressive upscale ratios, such as rendering at 540p and reconstructing to 1080p, while maintaining image quality that's difficult to achieve with traditional approaches. It improves NX utilization in Arm GPUs while reducing pressure on bandwidth and energy consumption - often just as important to mobile developers as raw frame rate.
+
+On mobile, bandwidth is expensive. Moving less data around the system can have a major impact on power efficiency and sustained performance. This often becomes just as valuable as the rendering speedup itself.
+
+NSS opened a bigger question: what happens when machine learning becomes a normal part of the rendering pipeline?
+
+## From a single technique to something you can build on
+
+Arm Neural Technology answers that question. It includes a set of Vulkan-based tools you can use to experiment with different neural graphics techniques that are production ready and efficient for mobile.
+
+| Resource |
+|----------|
+| [Arm Neural Technology landing page](https://developer.arm.com/mobile-graphics-and-gaming/neural-graphics) |
+| [Enable Neural Super Sampling in Unreal Engine with ML Extensions](/learning-paths/mobile-graphics-and-gaming/nss-unreal/) |
+| [ML SDK for Vulkan](https://github.com/arm/ai-ml-sdk-for-vulkan) |
+| [Neural Super Sampling (NSS) model](https://huggingface.co/Arm/neural-super-sampling) |
+| [ML Emulation Layer for Vulkan](https://github.com/arm/ai-ml-emulation-layer-for-vulkan) |
+| [Neural Graphics Model Gym](https://github.com/arm/neural-graphics-model-gym) |
+
+The development kit, Unreal plugin, and sample content let you get started with minimal effort and validate how these techniques behave with your own content. Seeing a clean before-and-after in a controlled scene is one thing. Testing with dynamic lighting, fast camera movement, complex materials, and all the edge cases that come with real production conditions is another. That's where you learn whether a technique is actually useful.
+
+Arm Neural Technology use cases now extend beyond NSS into frame generation and ray denoising. This playbook focuses on those newer techniques, but NSS remains the most straightforward entry point for evaluating neural graphics in your project.
+
+## Why this matters now
+
+As engines such as Unreal adopt more advanced techniques such as ray tracing, new neural graphics use cases start to make sense in a practical way. Features such as MegaLights make it possible to work with far more dynamic lights than before, without the cost scaling directly with the number of lights. The challenge is that these approaches rely on very low sample counts, which quickly introduce noise, especially on mobile.
+
+Traditional denoisers and shader-based upscalers already help solve part of that problem. But as rendering pushes toward lower resolutions, fewer samples, and more dynamic lighting, reconstruction quality becomes harder to maintain. Neural reconstruction lets you push more aggressive upscale ratios, work with noisier inputs, and still produce stable, high-quality output. It reduces bandwidth and energy pressure, which matters just as much as raw frame rate on mobile devices. More importantly, it makes these newer rendering approaches practical on mobile in the first place.
+
+## Enter Neural Dawn
+
+Neural Dawn validates that Arm Neural Technology techniques are production ready for real games.
+
+Built as a mobile game with Unreal Engine and MegaLights, Neural Dawn tests these techniques in a complete, real-world project. Building an actual game reveals what works in practice - where neural graphics integrates naturally, where it creates friction, what performance gains emerge, and what tradeoffs you face. This hands-on approach provides credible insights that isolated demos can't.
+
+## Why this playbook exists
+
+This playbook reflects that process. It shares the journey behind Neural Dawn - what worked, what didn't, what was surprising, and what would be approached differently next time.
+
+A gap exists between seeing a technique and knowing whether it fits your game. This playbook aims to close that gap.
+
+Some projects will benefit from this approach, others won't. Success depends on what you're building, what constraints you're working under, and what artistic direction and features you care about. This playbook gives you enough context and real-world experience to answer the key question: is this worth exploring for your game?