Introduction

I have been waiting for an inexpensive GPU to be released that would be able to handle some light AI workloads. My wait was over when Intel released their new Arc series card, the B50. The Intel Arc B50 is a workstation card with 16GB of GDDR6 memory that runs on PCI Express 5.0. Something that I really like about it is there is no need for any power connectors since it is powered directly through the PCI-E port. You can check out more about the Intel Arc B50 here.

I have also been wanting to try out HexOS even though it is in BETA at this time. It looks like a great project and this little lab project of mine gave me a good reason to migrate away from the old VMWare server I had and try something new.

Main Topic Name

If you are not familiar with HexOS, it is a user friendly web interface that is running over TrueNAS. It is meant to make configuring TrueNAS a lot more user friendly, and on the most part succeeded. As I mentioned, it is still in BETA so there some things that are managed by HexOS and some that are managed by TrueNAS. HexOS also expects a certain release of TrueNAS to be running. This actually was my first roadblock. HexOS is running on train "Electric Eel", which does not have high enough release of the Linux kernel for running the Arc B50.

Another thing I figured out after much trial and error is that the B50 uses Intel`s Xe drivers.

Let me walk you through the steps I took to get my Arc B50 running on my server.

Change TrueNAS Train

The first thing I had to do was change the train that TrueNAS is using. You can do this by navigating to the System menu and selecting Update.

On this screen you will see a dropdown box called "Train*". You will need to change it to "TruNSA Scale Fangtooth 25.04 [release]" or later. You will then need to run the update to switch trains.

Intel Xe Drivers

Now that we are on the correct train, we need to download the proper driver.

Step 1: Download Firmware Files

There are certain folders in TrueNAS`s filesystem that are mounted as read only. This means we can not directly download the firmware files directly to the folder they need to be in. Therefore, we will download the drivers to a temp folder first.

# Create temporary directory
mkdir -p /tmp/arc-firmware
cd /tmp/arc-firmware

# Download firmware files
curl -s "https://kernel.googlesource.com/pub/scm/linux/kernel/git/firmware/linux-firmware.git/+/refs/heads/main/xe/bmg_guc_70.bin?format=TEXT" | base64 -d > bmg_guc_70.bin

curl -s "https://kernel.googlesource.com/pub/scm/linux/kernel/git/firmware/linux-firmware.git/+/refs/heads/main/xe/bmg_huc.bin?format=TEXT" | base64 -d > bmg_huc.bin

# Verify file sizes (should be ~425K and ~572K)
ls -lh

Step 2: Install Firmware to Writable Location

Now that we have downloaded the firmware, we can move it to the correct location.

# Create writable firmware directory
sudo mkdir -p /var/lib/firmware/xe

# Copy firmware files
sudo cp bmg_guc_70.bin /var/lib/firmware/xe/
sudo cp bmg_huc.bin /var/lib/firmware/xe/

# Set permissions
sudo chmod 644 /var/lib/firmware/xe/*.bin

# Verify files are there
ls -la /var/lib/firmware/xe/

Step 3: Bind Mount

As mentioned previously, we can not write the drivers to the proper folder. Instead, we will bind mount the folder the drivers are in with the driver folder.

# Bind mount to overlay the read-only firmware directory
sudo mount --bind /var/lib/firmware/xe /usr/lib/firmware/xe

# Verify mount
ls -la /usr/lib/firmware/xe/

Step 4: Load Drivers

Now that we have the drivers mounted where they can be read, we need to load the drivers.

# Unload and reload driver
sudo modprobe -r xe 2>/dev/null || true
sudo modprobe xe

# Check driver loaded successfully
sudo dmesg | grep -i xe | tail -30

# Verify /dev/dri exists
ls -la /dev/dri/
# Should show card0 and renderD128

Now let`s verify the driver is loaded and working. Before we check the status of the GPU, we will need the address of the GPU. We can find that using lspci.

lspci | grep -i vga

The command above should return results that look something like:

10:00.0 VGA compatible controller: Intel Corporation Battlemage G21 [Intel Graphics]

This means the address for the GPU is 10:00.0. We can then plug that into the following command to check if the GPU is working.

lspci -k -s 10:00.0
# Should show "Kernel driver in use: xe"

The PCIE address for my GPU is 10:00.0. Yours may vary.

Step 5: Create Startup Script

The above steps would need to be done every time the server is rebooted. A much easier way to do this is creating a script to handle all of this for us and run on next boot.

# Create the startup script
cat > /tmp/setup-arc-gpu.sh << 'EOF'
#!/bin/bash

# Create firmware directory
mkdir -p /var/lib/firmware/xe

# Download firmware if not present
if [ ! -f /var/lib/firmware/xe/bmg_guc_70.bin ]; then
    curl -s "https://kernel.googlesource.com/pub/scm/linux/kernel/git/firmware/linux-firmware.git/+/refs/heads/main/xe/bmg_guc_70.bin?format=TEXT" | base64 -d > /var/lib/firmware/xe/bmg_guc_70.bin
    chmod 644 /var/lib/firmware/xe/bmg_guc_70.bin
fi

if [ ! -f /var/lib/firmware/xe/bmg_huc.bin ]; then
    curl -s "https://kernel.googlesource.com/pub/scm/linux/kernel/git/firmware/linux-firmware.git/+/refs/heads/main/xe/bmg_huc.bin?format=TEXT" | base64 -d > /var/lib/firmware/xe/bmg_huc.bin
    chmod 644 /var/lib/firmware/xe/bmg_huc.bin
fi

# Bind mount firmware to the read-only location
mount --bind /var/lib/firmware/xe /usr/lib/firmware/xe

# Unload driver if already loaded
modprobe -r xe 2>/dev/null || true

# Load xe driver
modprobe xe

# Log success
if [ -e /dev/dri/card0 ]; then
    echo "Intel Arc B50 GPU initialized successfully"
    exit 0
else
    echo "Failed to initialize Intel Arc B50 GPU"
    exit 1
fi
EOF

# Copy to persistent location and make executable
sudo cp /tmp/setup-arc-gpu.sh /var/lib/setup-arc-gpu.sh
sudo chmod +x /var/lib/setup-arc-gpu.sh

# Test the script
sudo /var/lib/setup-arc-gpu.sh

Step 6: Create Systemd Service

Now that we have the script created, we can create a systemd service that will run the script on each boot.

# Create the service file
sudo tee /etc/systemd/system/arc-gpu.service << 'EOF'
[Unit]
Description=Setup Intel Arc B50 GPU
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot
ExecStart=/var/lib/setup-arc-gpu.sh
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target
EOF

Once the service is created, we can enable it so that it will automatically start the next time the system reboots. After that we will start the service.

# Enable and start the service
sudo systemctl daemon-reload
sudo systemctl enable arc-gpu.service
sudo systemctl start arc-gpu.service

# Verify service is running
sudo systemctl status arc-gpu.service

Additional Notes

If you are trying to set the Intel Arc B50 as an Isolated GPU Device, you will need to have more than one GPU in the system. I am running an AMD 5700G processor with built in graphics. Originally, the AMD GPU was not showing in the Isolated GPU Device(s) screen, so it would not let me select the Arc card. To remedy this, I had to go into the BIOS for the motherboard and change my primary graphics card to integrated graphics. After a reboot, both graphics cards were showing up in the Isolated GPU Device(s) screen.

Conclusion

The above instruction should allow you to get the Intel Arc B50 graphics card running on TrueNAS. Variations of this should work on most distributions of Linux that have new enough of a kernel.

I don't have a comments section yet, so feel free to send me feedback on this blog.