.NET 10 is now live with new features, performance improvements, and enhancements to make developers lives easy! .NET 10 brings significant advancements which can be beneficial for everyone whether you are building cross-platform applications, mobile solutions, or cloud-native applications. As of November 2025, this is the latest long-term support (LTS) release. LTS refers to a version of a software release that receives extended support for a longer period, usually several years. This ensures that you get updates, patches, and security fixes for a long period of time.

Redhat has published the .NET 10 RPMs and container images on RHEL 8, 9 and 10 platforms. Check out this blog for more information - .NET 10 is now available for RHEL and OpenShift.  

You can install .NET 10 using below commands:

Fedora: dnf install dotnet-sdk-10.0
RHEL 8: dnf install dotnet-sdk-10.0
RHEL 9: dnf install dotnet-sdk-10.0
RHEL 10: dnf install dotnet-sdk-10.0

In our previous blog, Cross and source build .NET 9 on Ubuntu for IBM Power, we provided step-by-step guidance on cross building .NET 9 on x86 Ubuntu/RHEL/Fedora for IBM Power, followed by source building on the virtual machines (VMs) on IBM Power. Continuing with the same approach, this blog provides instructions for cross building .NET 10 on an x86 processor-based system for IBM Power.

Prerequisite

As a prerequisite to create ppc64le cross build SDK, make sure that you have the x86 processor-based Red Hat Enterprise Linux (RHEL) or the Fedora VM.

Steps to create a cross build SDK

You need to perform the following steps to create a cross build SDK.

Step 1. Generate the .NET installer by cross building .NET repositories

1. Make a copy or clone the GitHub repository to your x86 VM. It includes the following required scripts and dependencies for cross-building, and it uses an Ubuntu container.
   • cross-build-with-container.sh
   • vmr.cross.Containerfile (container file for creating Ubuntu container with all the required dependencies)
   • sources.list (a LIST file with a collection of software packages required to cross build)
   The script uses the dotnet/dotnet repository to create a cross build installer.
2. Run the following commands to create the installer:
   

   chmod +x <filename>

   Note: Grant executable permission to all the files if you have copied the above files to the x86 VM.

   bash <path/of/cross-build-with-container.sh > --containerfile <path/of/vmr.cross.Containerfile>  --cross-arch ppc64le --ref release/10.0.1xx

   Note: Place the sources.list file in the same directory as the files you copied above.

   It always builds the SDK version specified in the release/10.0.1xx branch, as mentioned in the global.json file. If you want to build another branch you can just change the --ref parameter with the corresponding branch name.

   Note: In this example, release/10.0.1xx points to the dotnet-sdk-10.0.100-rtm.25506.101 version. This may change over time.

   In the output directory (path: workdir/dotnet/ artifacts/assets/Release) you can find the following folders and files:

   • aspnetcore
   • Private.SourceBuilt.Artifacts.10.0.100-rtm.25506.101.linux-ppc64le.tar.gz
   • WindowsDesktop
   • dotnet-symbols-all-10.0.100-rtm.25506.101-linux-ppc64le.tar.gz
   • Runtime
   • dotnet-symbols-sdk-10.0.100-rtm.25506.101-linux-ppc64le.tar.gz
   • Sdk

   
   Note: The dotnet-sdk-10.0.100-rtm.25506.101-linux-ppc64le.tar.gz installer file is in the Sdk folder (workdir/dotnet/artifacts/assets/Release/Sdk).

3. Copy the dotnet-sdk-10.0.100-rtm.25506.101-linux-ppc64le.tar.gz file to the Power virtual machine where you want to install the .NET installer file.

Step 2. Install the .NET installer file on the Power VM with Ubuntu version 22.04

1. On the Power VM, go to the directory where you copied the installer file generated on the x86 system.
2. Create a subfolder, named “.dotnet”, set the DOTNET_ROOT environment variable, and extract the SDK installer into the DOTNET_ROOT folder.
   

   export DOTNET_FILE=dotnet-sdk-10.0.100-rtm.25506.101-linux-ppc64le.tar.gz
   mkdir -p .dotnet
   export DOTNET_ROOT=$(pwd)/.dotnet 
   tar zxf "$DOTNET_FILE" -C "$DOTNET_ROOT"

3. Add the DOTNET_ROOT folder in path.
   

   export PATH=$PATH:$DOTNET_ROOT

4. To verify if dotnet is installed, run the following command:
   

   dotnet --info

   The output should look as follows:

   [root@ibm-ic922-14 ~]# dotnet --info
   .NET SDK:
    Version:           10.0.100-rtm.25506.101
    Commit:            e15b1c0a8c
    Workload version:  10.0.100-manifests.5a43af15
    MSBuild version:   18.0.0-preview-25506-101+e15b1c0a8
   
   Runtime Environment:
    OS Name:     rhel
    OS Version:  9
    OS Platform: Linux
    RID:         linux-ppc64le
    Base Path:   /root/.dotnet/sdk/10.0.100-rtm.25506.101/
   
   .NET workloads installed:
   There are no installed workloads to display.
   Configured to use workload sets when installing new manifests.
   No workload sets are installed. Run "dotnet workload restore" to install a workload set.
   
   Host:
     Version:      10.0.0-rtm.25506.101
     Architecture: ppc64le
     Commit:       e15b1c0a8c
   
   .NET SDKs installed:
     10.0.100-rtm.25506.101 [/root/.dotnet/sdk]
   
   .NET runtimes installed:
     Microsoft.AspNetCore.App 10.0.0-rtm.25506.101 [/root/.dotnet/shared/Microsoft.AspNetCore.App]
     Microsoft.NETCore.App 10.0.0-rtm.25506.101 [/root/.dotnet/shared/Microsoft.NETCore.App]
   
   Other architectures found:
     None
   
   Environment variables:
     DOTNET_FILE                              [dotnet-sdk-10.0.100-rtm.25506.101-linux-ppc64le.tar.gz]
     DOTNET_ROOT                              [/root/.dotnet]
   
   global.json file:
     Not found
   
   Learn more:
     https://aka.ms/dotnet/info
   
   Download .NET:
     https://aka.ms/dotnet/download
   [root@ibm-ic922-14 ~]#
   

Step 3. Run the 'Hello World' program on the Power VM with Ubuntu version 22.04

1. Create a 'Hello World' console application using the dotnet new console command.
   

   mkdir HelloWorld 
   cd HelloWorld 
   dotnet new console

   The output should look as follows:
   

   The template "Console App" was created successfully.
   Processing post-creation actions...
   Restoring /root/HelloWorld/HelloWorld.csproj:
   Restore succeeded.
   [root@ibm-ic922-14 HelloWorld]#

2. Build and run the 'Hello World' app using the dotnet build and the dotnet run commands.
   

   dotnet build 
   dotnet run

   The output should look as follows:

   [root@ibm-ic922-14 HelloWorld]# dotnet build
   Restore complete (2.0s)
       info NETSDK1057: You are using a preview version of .NET. See: https://aka.ms/dotnet-support-policy
     HelloWorld net10.0 succeeded (7.2s) → bin/Debug/net10.0/HelloWorld.dll
   
   Build succeeded in 10.8s
   
   
   
   [root@ibm-ic922-14 HelloWorld]# dotnet run
   Hello, World!
   [root@ibm-ic922-14 HelloWorld]#
   

Now, let us see how to create the source-build SDK using the cross-build SDK generated above.

Step 4. Source build the .NET repositories to generate SDK for Power on Ubuntu

1. Ensure that you have copied the generated SDK .tar file and the package file (Private.SourceBuilt.Artifacts.10.0.100-rtm.25506.101.linux-ppc64le.tar.gz) from the generated cross build SDK folder (refer to the output folder on the x86 machine: workdir/dotnet/artifacts/assets/Release) to your Power virtual machine on Ubuntu.
   
   To create a source-build SDK, use the same dotnet/dotnet repository, a Virtual Monolithic Repository (VMR) that includes all the source code and the infrastructure needed to build the .NET SDK. (https://github.com/dotnet/dotnet).
2. Clone the GitHub repository using the following command:
   

   git clone https://github.com/ppc64le/build-scripts/
   cd d/dotnet10

   
   Note: The dotnet-source-build.sh script in the d/dotnet10 path includes all the patches and the dependencies required to source build. Source build uses the dotnet/dotnet VMR repo which is earlier used to cross build.
3. Run the following command to start your source build:
   

   ./dotnet-source-build.sh --sdk-path /path/to/dotnet-sdk-*-linux-ppc64le.tar.gz --artifacts-path  /path/to/Private.SourceBuilt.Artifacts-*-linux-ppc64le.tar.gz --ref release/x.x.xxx

   For example:
   

   ./dotnet-source-build.sh --sdk-path /root/dotnet-sdk-10.0.100-rtm.25506.101-linux-ppc64le.tar.gz --artifacts-path  /root/Private.SourceBuilt.Artifacts.10.0.100-rtm.25506.101.linux-ppc64le.tar.gz --ref release/10.0.1xx

   
   The resulting SDK can be located at /workdir/dotnet/artifacts/assets/Release/dotnet-sdk-10.0.*-ppc64le.tar.gz.

Summary

.NET 10 is a successor of .NET9, and it offers many enhancements which make standard libraries more powerful, thereby letting you solve real world problems more clearly. It offers great performance with runtime and just-in-time (JIT) compiler which reduce memory overhead, garbage collection pressure, branch mispredictions, and runtime overhead that makes the applications run faster and more efficiently. Do let us know if you find these instructions on cross building .NET 10 on x86 for IBM Power architecture helpful.