What should you check first in this article?

Strata's HIP backend runs Qwen3.8-Flash-Next on supported AMD Radeon GPUs. Windows uses a current Adrenalin driver and the bundled HIP runtime; Linux uses the kernel's amdgpu driver and prepares ROCm and a card-specific engine. This guide distinguishes card support, validation status, image and multi-GPU limits, and the 0.1.43 results.

Executable programs and extensions

Strata AMD HIP guide: Run Radeon on Windows and Linux

Windows uses the bundled runtime with the AMD driver; Linux prepares a HIP engine for supported cards.

Strata's HIP¹ backend runs Qwen3.8-Flash-Next on supported AMD Radeon GPUs. Windows uses a current Adrenalin driver and the bundled HIP runtime²; Linux uses the kernel's amdgpu driver and prepares ROCm³ and a card-specific engine. This guide distinguishes card support, validation status, image and multi-GPU limits, and the 0.1.43 results.

Strata's HIP backend is the execution path that uses a supported AMD Radeon GPU⁴ to process Qwen3.8-Flash-Next prompts⁵ and generate answers. Setup prepares the model on both Windows and Linux, but the runtime setup and validated combinations differ.

Windows uses the Adrenalin driver and a prepared HIP runtime. Linux requires the kernel driver, ROCm, and an engine built for the card architecture. Validation of model execution on individual Radeons with the current Windows bundle is limited; the steps below cover driver preparation followed by an actual model-response check.

Contents

Requirements and key details

Windows uses a current Adrenalin driver and the release HIP ZIP; a separate ROCm SDK install is not required.
Linux needs a supported Radeon and the amdgpu driver; setup handles ROCm selection and engine compilation.
Read 0.1.43 gains with the R9700 cache setting, model, context, and per-GPU test conditions.

First check the Radeon generation and operating system

The official AMD HIP guide lists the RX 7900 XT/XTX (gfx1100), RX 7800 XT/7700 XT (gfx1101), RX 9060 XT (gfx1200), and RX 9070/9070 XT and Radeon AI PRO R9700 (gfx1201) for Linux. The RX 6800/6900 family (gfx1030) has community run reports, with a different validation status from maintainer-validated cards. Match your exact GPU architecture to Strata's support table.

Integrated Radeon GPUs are currently listed as unsupported in the Linux guide. Instinct MI50/MI60 and Radeon VII (gfx906) use a separate opt-in build; Ryzen AI Max Strix Halo (gfx1151) has a Linux source-build path. A single run cannot mix AMD and NVIDIA GPUs.

A black tower PC, a blank monitor, and RAM modules beside it — Strata connects a Radeon GPU to the local runtime on your PC.

On Windows, use the driver and bundled ZIP

Install a current AMD Software: Adrenalin Edition driver and restart the PC. Run START-HERE.bat in the Strata folder; setup can select HIP automatically when there is no usable NVIDIA GPU. If both NVIDIA and AMD cards are present, choose HIP with START-HERE.bat --backend hip. Windows uses the runtime and BLAS libraries in the release ZIP, so you do not separately install ROCm, the HIP SDK, or a compiler.

Setup checks for a HIP device and the bundled engine before downloading the model. The current AMD guide says maintainers have not yet verified the ready-made Windows ZIP running a model on a discrete Radeon. The historical RX 9070 XT Windows result came from a user who compiled version 0.1.34 on that PC. As of 0.1.40.2, the prepared ZIP also lacked a discrete-card model-run validation; its bundle check was limited to device discovery and GEMM on a Ryzen integrated Radeon. Keep those historical measurements separate from validation of the current bundle.

To test a first prompt, open http://127.0.0.1:8080 and send a short message in Chat. If a model does not run with the Windows HIP ZIP, first inspect the end of the error log and the device-test results. The official guide requests engine\strata-device.exe --list-devices and engine\strata-device.exe --selftest; before running them, set PATH from the Strata folder with set PATH=%CD%\engine\rocm\bin;%PATH%.

Windows HIP requirements and validation status

Linux setup prepares ROCm and the card-specific engine

On Linux, go to the repository folder on a PC with a supported discrete Radeon and the kernel's amdgpu driver. HIP is selected automatically when no usable NVIDIA card is present; otherwise, specify the backend with an option.

Start HIP setup on Linux

./setup.sh --backend hip

Choose the model and context in the setup screen after running this command.

If system ROCm 7 with hipcc and hipBLAS is available, setup uses it. Otherwise, or when the installed version is older than 7.0, setup installs AMD TheRock wheels in .venv. This route does not install ROCm system-wide or require sudo, but it needs about 10 GB of additional disk space. Setup then compiles an engine for the card architecture using C++ build tools and Git; the first build may take about 10–20 minutes.

Choose the model and context settings when setup asks; the server then starts. In the browser, send a short prompt in Chat at http://127.0.0.1:8080. The displayed answer confirms that the model processed the request. If the page does not open, enter the address shown in the setup window.

A graphics card, RAM, and an NVMe SSD on a cream-colored wood desk — The Radeon, RAM, and NVMe SSD are components used to run a local model.

The 0.1.43 results vary by card and setup

The October 11 release of 0.1.43 measured the R9700 with different cache sizes and quantization⁶ formats. Gains were larger with a limited cache, while results with the full 32 GB cache varied by model.

Official Strata 0.1.43 R9700 comparisons
GPU cache setting	Quantization and measurement	Change from previous build
R9700 32 GB · 16 GB-class cache	IQ3_XXS · decode	+21~38%
R9700 32 GB · 16 GB-class cache	IQ3_XXS · 4K / 32K prompt	+7.5% / +15.6%
R9700 32 GB · 32 GB cache	Q2_0 / IQ3_XXS · decode	+2~10%
R9700 32 GB · 32 GB cache	IQ3_S · decode	+6~14%

The test GPU is an R9700 with 32 GB of physical VRAM⁷. “16 GB-class cache” limits its expert cache to the size used on a 16 GB card. The table contains no measurements for the RX 9070 XT or older RDNA cards.

The R9700 figures are medians from five interleaved pairs against the previous build. The v0.1.43 release notes list results by model and cache setting and give the comparison conditions; card configurations are in the AMD HIP measurements.

Two graphics cards installed inside an assembled PC case — AMD measurements make sense only with the card, engine, and context conditions.

Check Linux support for images and multiple GPUs

With image input enabled on Linux AMD, the default image encoder runs on the CPU⁸. A photo prompt therefore includes CPU image processing before answer generation; record its first-response wait separately from text-only prompts. AMD setup does not yet provide automatic calibration. Linux Monitor reads card load, VRAM, temperature, and power through sysfs.

Linux can split model layers across multiple Radeon cards by specifying them with an option such as --gpus 1,0. Adding a second card may not help when one card already holds all experts; a published R9700 plus RX 9070 XT test was slower than the R9700 alone on some tasks. Compare a split when the model's experts do not fit on one card.

For image work, record the first-response wait using the same photo. For multiple GPUs, compare against one card using the same model, context, and prompt. Keeping Linux Monitor load and memory readings alongside those times helps locate delays in CPU processing or GPU splitting.

Terminology notes

HIP — An API and runtime for portable GPU C++ code. It helps with porting CUDA code.
Back to the text
Runtime — The software environment that provides facilities needed while a program runs. In local AI, it can also refer to a model execution engine.
Back to the text
ROCm — AMD’s software platform for AI and high-performance computing on GPUs. Support depends on the combination of GPU, operating system, driver, and framework versions.
Back to the text
GPU — A processor designed to handle many calculations in parallel. It performs model computations during AI inference.
Back to the text
Prompt — The input text sent to a model. For generative models it describes the desired result and strongly shapes the output.
Back to the text
Quantization — A way to represent model weights or values with fewer bits, reducing storage and memory use. The coarser representation can also affect accuracy.
Back to the text
VRAM — Memory used by a graphics card’s GPU to store model weights and intermediate values.
Back to the text
CPU — The central processor that runs the operating system and general-purpose instructions; in AI workloads it also handles tasks such as preprocessing and data movement.
Back to the text

Frequently asked questions

What should you check first in this article?: Strata's HIP backend runs Qwen3.8-Flash-Next on supported AMD Radeon GPUs. Windows uses a current Adrenalin driver and the bundled HIP runtime; Linux uses the kernel's amdgpu driver and prepares ROCm and a card-specific engine. This guide distinguishes card support, validation status, image and multi-GPU limits, and the 0.1.43 results.
How much memory does it need?: The test GPU is an R9700 with 32 GB of physical VRAM. “16 GB-class cache” limits its expert cache to the size used on a 16 GB card. The table contains no measurements for the RX 9070 XT or older RDNA cards.