ArmDeveloperEcosystem · jasonrandrews · Jan 30, 2026 · Jan 29, 2026 · Jan 29, 2026 · Jan 29, 2026
diff --git a/content/install-guides/acfl.md b/content/install-guides/acfl.md
@@ -260,7 +260,7 @@ ACfL is now [ready to use](#armclang).
 
 Arm Compiler for Linux is available with the [Spack](https://spack.io/) package manager.
 
-See the [Arm Compiler for Linux and Arm PL now available in Spack](https://community.arm.com/arm-community-blogs/b/high-performance-computing-blog/posts/arm-compiler-for-linux-and-arm-pl-now-available-in-spack) blog for full details.
+See the [Arm Compiler for Linux and Arm PL now available in Spack](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/arm-compiler-for-linux-and-arm-pl-now-available-in-spack) blog for full details.
 
 ### How do I set up Spack for ACfL?
 

diff --git a/content/install-guides/cmsis-toolbox.md b/content/install-guides/cmsis-toolbox.md
@@ -34,7 +34,7 @@ The [CMSIS-Toolbox](https://github.com/Open-CMSIS-Pack/cmsis-toolbox) is a suite
 
 It is also used for the creation and maintenance of such packs.
 
-`CMSIS-Toolbox` is part of the [Open-CMSIS-Pack project](https://www.open-cmsis-pack.org).
+`CMSIS-Toolbox` is part of the [Open-CMSIS-Pack project](https://open-cmsis-pack.github.io/Open-CMSIS-Pack-Spec/main/html/index.html).
 
 Windows, Linux, and macOS host platforms are supported.
 

diff --git a/content/install-guides/gemini.md b/content/install-guides/gemini.md
@@ -3,7 +3,7 @@ title: Gemini CLI
 
 author: Jason Andrews
 minutes_to_complete: 15
-official_docs: https://ai.google.dev/gemini-api/docs/cli
+official_docs: https://geminicli.com/docs/
 
 test_maintenance: true
 test_images:

diff --git a/content/install-guides/java.md b/content/install-guides/java.md
@@ -144,24 +144,24 @@ For more information about the available versions and supported platforms refer
 
 You can download Java from the [Oracle website](https://www.oracle.com/java/technologies/javase-downloads.html) and install it manually. Look for the files with ARM64 in the description.
 
-Download a [tar.gz](https://download.oracle.com/java/22/latest/jdk-22_linux-aarch64_bin.tar.gz) file from the website. 
+Download a [tar.gz](https://download.oracle.com/java/25/latest/jdk-25_linux-aarch64_bin.tar.gz) file from the website. 
 
 Extract the contents of the file:
 
 ```console
-tar xvf jdk-22_linux-aarch64_bin.tar.gz
+tar xvf jdk-25_linux-aarch64_bin.tar.gz
 ```
 
 Move the contents to a directory of your choice: 
 
 ```console
-sudo mv jdk-22.0.2 /usr/local/
+sudo mv jdk-25.0.2 /usr/local/
 ```
 
 Set up environment variables to locate your installation:
 
 ```console
-export JAVA_HOME=/usr/local/jdk-22.0.2
+export JAVA_HOME=/usr/local/jdk-25.0.2
 export PATH=$JAVA_HOME/bin:$PATH
 ```
 
@@ -350,9 +350,9 @@ sudo apt install ant -y
 You can also install specific versions by downloading and extracting a zip file:
 
 ```console
-wget https://downloads.apache.org/ant/binaries/apache-ant-1.10.13-bin.zip -O apache-ant-1.10.13-bin.zip
-unzip apache-ant-1.10.13-bin.zip
-sudo mv apache-ant-1.10.13 /opt/ant
+wget https://downloads.apache.org/ant/binaries/apache-ant-1.10.14-bin.zip -O apache-ant-1.10.14-bin.zip
+unzip apache-ant-1.10.14-bin.zip
+sudo mv apache-ant-1.10.14 /opt/ant
 sudo ln -s /opt/ant/bin/ant /usr/local/bin/ant
 ```
 
@@ -365,7 +365,7 @@ ant -version
 The output is similar to:
 
 ```output
-Apache Ant(TM) version 1.10.13 compiled on January 4 2023
+Apache Ant(TM) version 1.10.14 compiled on August 16 2023
 ```
 
 ### Apache JMeter

diff --git a/content/install-guides/openvscode-server.md b/content/install-guides/openvscode-server.md
@@ -26,7 +26,7 @@ multitool_install_part: false   # Set to true if a sub-page of a multi-page arti
 layout: installtoolsall         # DO NOT MODIFY. Always true for tool install articles
 ---
 
-[OpenVSCode Server](https://www.gitpod.io/blog/openvscode-server-launch) is a version of VS Code which runs on any computer and can be accessed using a browser. The project was initiated by Gitpod and is available on [GitHub](https://github.com/gitpod-io/openvscode-server/)
+OpenVSCode Server is a version of VS Code which runs on any computer and can be accessed using a browser. The project was initiated by Gitpod and is available on [GitHub](https://github.com/gitpod-io/openvscode-server/)
 
 OpenVSCode Server supports the Arm architecture and is useful for developing on a remote Arm machine. It can be used on cloud instances, without requiring a Linux desktop to be installed. It's also useful when developing on a local Arm machine with a Linux subsystem, such as Windows Subsystem for Linux (WSL), ChromeOS with Linux enabled, or Multipass.
 

diff --git a/content/install-guides/pytorch-woa.md b/content/install-guides/pytorch-woa.md
@@ -16,7 +16,7 @@ additional_search_terms:
 minutes_to_complete: 15
 
 ### Link to official documentation
-official_docs: https://www.pytorch.org/doc/
+official_docs: https://docs.pytorch.org/docs/stable/index.html
 
 author: Pareena Verma
 

diff --git a/content/install-guides/sbt.md b/content/install-guides/sbt.md
@@ -11,7 +11,7 @@ additional_search_terms:
 layout: installtoolsall
 multi_install: false
 multitool_install_part: false
-official_docs: https://www.scala-sbt.org/download.html
+official_docs: https://www.scala-sbt.org/download/
 test_images:
 - ubuntu:latest
 test_link: null

diff --git a/content/install-guides/wperf.md b/content/install-guides/wperf.md
@@ -110,7 +110,7 @@ You see output similar to:
 
 ## How do I install the WindowsPerf Virtual Studio Extension? {#vs2022}
 
-WindowsPerf GUI (Graphical User Interface) is a Visual Studio 2022 extension designed to bring a seamless UI experience to WindowsPerf, the command-line performance profiling tool for Windows on Arm. It is available on the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=Arm.WindowsPerfGUI).
+WindowsPerf GUI (Graphical User Interface) is a Visual Studio 2022 extension designed to bring a seamless UI experience to WindowsPerf, the command-line performance profiling tool for Windows on Arm. It is available on the [Visual Studio Marketplace](https://marketplace.visualstudio.com/).
 
 Install by opening **Extensions** menu, click **Manage Extensions**, and click **Browse**. Type `WindowsPerf` to search for Arm WindowsPerf GUI extension. Click **Install**.
 
@@ -145,7 +145,7 @@ You do not need to install `wperf` on non-Windows on Arm devices.
 - [WindowsPerf Release 3.0.0 blog post](https://www.linaro.org/blog/windowsperf-release-3-0-0/)
 - [WindowsPerf Release 2.5.1 blog post](https://www.linaro.org/blog/windowsperf-release-2-5-1/)
 - [WindowsPerf release 2.4.0 introduces the first stable version of sampling model support](https://www.linaro.org/blog/windowsperf-release-2-4-0-introduces-the-first-stable-version-of-sampling-model-support/)
-- [Announcing WindowsPerf: Open-source performance analysis tool for Windows on Arm](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/announcing-windowsperf)
+- [Announcing WindowsPerf: Open-source performance analysis tool for Windows on Arm](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/announcing-windowsperf)
 
 ### WindowsPerf GUI
 

diff --git a/content/learning-paths/automotive/intro/resources.md b/content/learning-paths/automotive/intro/resources.md
@@ -7,7 +7,6 @@ weight: 4
 
 There are a number of books written to discuss software development on Cortex-M. Examples include:
 
-* [The Definitive Guide to Arm Cortex-M0 and Cortex-M0+ Processors](https://www.oreilly.com/library/view/the-definitive-guide/9780128032787/)
 * [The Definitive Guide to Arm Cortex-M3 and Cortex-M4 Processors](https://www.oreilly.com/library/view/the-definitive-guide/9780124080829/)
 * [The Definitive Guide to Arm Cortex-M23 and Cortex-M33 Processors](https://www.oreilly.com/library/view/definitive-guide-to/9780128207369/)
 * [The Designer's Guide to the Cortex-M Processor Family](https://www.oreilly.com/library/view/the-designers-guide/9780081006344/)

diff --git a/content/learning-paths/cross-platform/_example-learning-path/overview.md b/content/learning-paths/cross-platform/_example-learning-path/overview.md
@@ -30,7 +30,7 @@ Arm has a number of content channels where you can access Arm technical content
 
 * [Product Documentation and reference manuals](https://developer.arm.com/documentation) are the trusted source of detailed information for developing on the Arm architecture.
 
-* [Blogs](https://www.community.arm.com) offer news and announcements for recent and upcoming Arm activities.
+* [Blogs](https://developer.arm.com) offer news and announcements for recent and upcoming Arm activities.
 
 * [Videos](https://www.youtube.com/c/armsoftwaredevelopers) provide talks and demos of Arm tools and other software topics.
 

diff --git a/content/learning-paths/cross-platform/eigen-linear-algebra-on-arm/eigen-intro.md b/content/learning-paths/cross-platform/eigen-linear-algebra-on-arm/eigen-intro.md
@@ -29,7 +29,7 @@ It has also been ported to SYCL and CUDA backends and further ports are in progr
 ## Where is Eigen used?
 
 Eigen is a useful library and its success is proven by the number of projects that use it. 
-[The list of projects using Eigen](https://eigen.tuxfamily.org/index.php?title=Main_Page#Projects_using_Eigen) is rich, but here are a few high profile projects:
+[The list of projects using Eigen](https://libeigen.gitlab.io/#projects-using-eigen) is rich, but here are a few high profile projects:
 
 * [TensorFlow](https://www.tensorflow.org/) - an open source software library for Machine Intelligence.
 * [Celestia](https://celestiaproject.space/) - the 3D astronomical visualization application Celestia (all orbital and geometric calculations are done with Eigen).

diff --git a/content/learning-paths/cross-platform/multiplying-matrices-with-sme2/overview.md b/content/learning-paths/cross-platform/multiplying-matrices-with-sme2/overview.md
@@ -46,5 +46,5 @@ On SVE and SME:
 - [Introducing the Scalable Matrix Extension for the Armv9-A Architecture - Martin Weidmann, Arm](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/scalable-matrix-extension-armv9-a-architecture)
 - [Arm Scalable Matrix Extension (SME) Introduction (Part 1) - Zenon Xiu](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-scalable-matrix-extension-introduction)
 - [Arm Scalable Matrix Extension (SME) Introduction (Part 2) - Zenon Xiu](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-scalable-matrix-extension-introduction-p2)
-- [Matrix-matrix multiplication. Neon, SVE, and SME compared (Part 3)](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/.matrix-matrix-multiplication-neon-sve-and-sme-compared)
+- [Matrix-matrix multiplication. Neon, SVE, and SME compared (Part 3)](https://developer.arm.com/community/arm-community-blogs/b/architectures-and-processors-blog/posts/matrix-matrix-multiplication-neon-sve-and-sme-compared)
 - [Learn about function multiversioning - Alexandros Lamprineas, Arm](/learning-paths/cross-platform/function-multiversioning/)
diff --git a/content/learning-paths/cross-platform/simd-info-demo/simdinfo-example1-cont.md b/content/learning-paths/cross-platform/simd-info-demo/simdinfo-example1-cont.md
@@ -22,14 +22,14 @@ For the operations in your SSE4.2 example, you have the following intrinsics:
 
 To gain a deeper understanding of how these intrinsics work and to surface detailed descriptions, you can use the search feature on SIMD.info. Simply enter the name of the intrinsic in the search bar. You can either select from the suggested results or perform a direct search to retrieve information about each intrinsic.
 
-1. By searching for [**`_mm_add_ps`**](https://simd.info/c_intrinsic/_mm_add_ps/) you will retrieve information about its purpose, the result type, assembly instructions, prototypes, and an example demonstration. By clicking the **engine** option **"NEON"** you can find its [equivalents](https://simd.info/eq/_mm_add_ps/NEON/) for this engine. The equivalents are: **`vaddq_f32`**, **`vadd_f32`**. [Intrinsics comparison](https://simd.info/c-intrinsics-compare?compare=vaddq_f32:vadd_f32) helps you find the right one. Based on the prototype provided, you can choose [**`vaddq_f32`**](https://simd.info/c_intrinsic/vaddq_f32/) as it works with 128-bit vectors which is the same as **SSE4.2**.
+1. By searching for [**`_mm_add_ps`**](https://simd.info/c_intrinsic/_mm_add_ps) you will retrieve information about its purpose, the result type, assembly instructions, prototypes, and an example demonstration. By clicking the **engine** option **"NEON"** you can find its [equivalents](https://simd.info/eq/_mm_add_ps/NEON/) for this engine. The equivalents are: **`vaddq_f32`**, **`vadd_f32`**. [Intrinsics comparison](https://simd.info/c-intrinsics-compare?compare=vaddq_f32:vadd_f32) helps you find the right one. Based on the prototype provided, you can choose [**`vaddq_f32`**](https://simd.info/c_intrinsic/vaddq_f32) as it works with 128-bit vectors which is the same as **SSE4.2**.
 
 2. Moving to the next intrinsic, **`_mm_mul_ps`**, you can use the [Intrinsics Tree](https://simd.info/tag-tree) on SIMD.info to find the equivalent. 
 
-Start by expanding the **Arithmetic** branch and then navigate to the branch **Vector Multiply**. As you are working with 32-bit floats, open the **Vector Multiply 32-bit floats** branch, where you will find several options. The recommended choice is [**`vmulq_f32`**](https://simd.info/c_intrinsic/vmulq_f32/), following the same reasoning as before; it operates on 128-bit vectors.
+Start by expanding the **Arithmetic** branch and then navigate to the branch **Vector Multiply**. As you are working with 32-bit floats, open the **Vector Multiply 32-bit floats** branch, where you will find several options. The recommended choice is [**`vmulq_f32`**](https://simd.info/c_intrinsic/vmulq_f32), following the same reasoning as before; it operates on 128-bit vectors.
 
-3. For the third intrinsic, **`_mm_sqrt_ps`**, the easiest way to find the corresponding NEON intrinsic is by typing **"Square Root"** in the search bar on SIMD.info. From the [search results](https://simd.info/search?search=Square+Root&simd_engines=1&simd_engines=2&simd_engines=3&simd_engines=4&simd_engines=5), look for the float-specific version and select [**`vsqrtq_f32`**](https://simd.info/c_intrinsic/vsqrtq_f32/), which, like the others, works with 128-bit vectors. In the equivalents section about **SSE4.2**, you can see that **`_mm_sqrt_ps`** has its place as a direct match for this operation.
+3. For the third intrinsic, **`_mm_sqrt_ps`**, the easiest way to find the corresponding NEON intrinsic is by typing **"Square Root"** in the search bar on SIMD.info. From the [search results](https://simd.info/search?search=Square+Root&simd_engines=1&simd_engines=2&simd_engines=3&simd_engines=4&simd_engines=5), look for the float-specific version and select [**`vsqrtq_f32`**](https://simd.info/c_intrinsic/vsqrtq_f32), which, like the others, works with 128-bit vectors. In the equivalents section about **SSE4.2**, you can see that **`_mm_sqrt_ps`** has its place as a direct match for this operation.
 
-4. For the last intrinsic, **`_mm_cmpgt_ps`**, follow a similar approach as before. Inside the intrinsics tree, start by expanding the **Comparison** folder. Navigate to the subfolder **Vector Compare Greater Than**, and as you are working with 32-bit floats, proceed to **Vector Compare Greater Than 32-bit floats**. The recommended choice is again the 128-bit variant[**`vcgtq_f32`**](https://simd.info/c_intrinsic/vcgtq_f32/).
+4. For the last intrinsic, **`_mm_cmpgt_ps`**, follow a similar approach as before. Inside the intrinsics tree, start by expanding the **Comparison** folder. Navigate to the subfolder **Vector Compare Greater Than**, and as you are working with 32-bit floats, proceed to **Vector Compare Greater Than 32-bit floats**. The recommended choice is again the 128-bit variant[**`vcgtq_f32`**](https://simd.info/c_intrinsic/vcgtq_f32).
 
 Now that you have found the NEON equivalents for each SSE4.2 intrinsic, you're ready to begin porting the code. Understanding these equivalents is key to ensuring that the code produces the correct results in the calculations as you switch between SIMD engines.
diff --git a/content/learning-paths/cross-platform/simd-info-demo/simdinfo-example1-porting.md b/content/learning-paths/cross-platform/simd-info-demo/simdinfo-example1-porting.md
@@ -12,7 +12,7 @@ Follow this step-by-step process to porting:
 
 1. Change the loading process to follow NEON's method for initializing vectors. The SSE4.2 intrinsic **`_mm_set_ps`** is in reality a macro, in NEON you can do the same thing with curly braces **`{}`** initialization.
 2. Next, replace the SSE4.2 intrinsics with the NEON equivalents that you identified earlier. The key is to ensure that the operations perform the same tasks, such as comparison, addition, multiplication, and square root calculations.
-3. Finally, modify the storing process to match NEON's way of moving data from vectors to memory. In NEON, you use functions like [**`vst1q_f32`**](https://simd.info/c_intrinsic/vst1q_f32/) for storing 128-bit floating-point vectors and [**`vst1q_u32`**](https://simd.info/c_intrinsic/vst1q_u32/) for storing 128-bit integer vectors.
+3. Finally, modify the storing process to match NEON's way of moving data from vectors to memory. In NEON, you use functions like [**`vst1q_f32`**](https://simd.info/c_intrinsic/vst1q_f32) for storing 128-bit floating-point vectors and [**`vst1q_u32`**](https://simd.info/c_intrinsic/vst1q_u32) for storing 128-bit integer vectors.
 
 After identifying the NEON intrinsics that you require in the ported program, it's now time to write the code.
 

diff --git a/content/learning-paths/cross-platform/simd-info-demo/simdinfo-example2.md b/content/learning-paths/cross-platform/simd-info-demo/simdinfo-example2.md
@@ -10,7 +10,7 @@ layout: learningpathall
 
 During the porting process, you can see that certain instructions translate seamlessly. However, there are cases where direct equivalents for some intrinsics might not be readily available across architectures. 
 
-For example, the [**`_mm_madd_epi16`**](https://simd.info/c_intrinsic/_mm_madd_epi16/) intrinsic from SSE2, which performs multiplication of 16-bit signed integer elements in a vector and then does a pairwise addition of adjacent elements increasing the element width, does not have a direct counterpart in NEON. However, it can be emulated using another intrinsic. Similarly its 256 and 512-bit counterparts, [**`_mm256_madd_epi16`**](https://simd.info/c_intrinsic/_mm256_madd_epi16/) and [**`_mm512_madd_epi16`**](https://simd.info/c_intrinsic/_mm512_madd_epi16/), can be emulated by a sequence of instructions, but here you will see the 128-bit variant.
+For example, the [**`_mm_madd_epi16`**](https://simd.info/c_intrinsic/_mm_madd_epi16) intrinsic from SSE2, which performs multiplication of 16-bit signed integer elements in a vector and then does a pairwise addition of adjacent elements increasing the element width, does not have a direct counterpart in NEON. However, it can be emulated using another intrinsic. Similarly its 256 and 512-bit counterparts, [**`_mm256_madd_epi16`**](https://simd.info/c_intrinsic/_mm256_madd_epi16) and [**`_mm512_madd_epi16`**](https://simd.info/c_intrinsic/_mm512_madd_epi16), can be emulated by a sequence of instructions, but here you will see the 128-bit variant.
 
 You might already know the equivalent operations for this particular intrinsic, but let's assume that you don't. In this particular use case, reading **`_mm_madd_epi16`** on **SIMD.info** might indicate that a key characteristic of the instruction involved is the widening of the result elements, from 16-bit to 32-bit signed integers. Unfortunately, this is not the case. This particular instruction does not increase the size of the element holding the result values. You will see how this affects the result in the example.
 

diff --git a/content/learning-paths/cross-platform/windowsperf_sampling_cpython_spe/_index.md b/content/learning-paths/cross-platform/windowsperf_sampling_cpython_spe/_index.md
@@ -41,7 +41,7 @@ shared_between:
 further_reading:
     - resource:
         title: Announcing WindowsPerf Open-source performance analysis tool for Windows on Arm
-        link: https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/announcing-windowsperf
+        link: https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/announcing-windowsperf
         type: blog
     - resource:
         title: WindowsPerf release 2.4.0 introduces the first stable version of sampling model support

diff --git a/content/learning-paths/embedded-and-microcontrollers/avh_matter/2setup.md b/content/learning-paths/embedded-and-microcontrollers/avh_matter/2setup.md
@@ -64,7 +64,7 @@ The `Console` view within the browser will suffice to complete this Learning Pat
 
 If you wish to connect via `SSH` (rather than `Console`), it is easiest to follow the SSH tunnel connection instructions specified in the `Connect` tab. 
 
-As an alternative, you can also download and install the appropriate [OpenVPN Community](https://openvpn.net/community-downloads) version for your host. Click on `DOWNLOAD OVPN FILE` within the `Connect via VPN` section.
+As an alternative, you can also download and install the appropriate [OpenVPN Community](https://openvpn.net/community/) version for your host. Click on `DOWNLOAD OVPN FILE` within the `Connect via VPN` section.
 
 In the `OpenVPN` GUI, select `Import` > `Import file...` and browse to the downloaded `OVPN file`. Click `Connect`.