MATLAB GPU computing on RTX PRO Blackwell and H200 NVL: releases, FP64 and servers

MATLAB GPU computing requirements for RTX PRO Blackwell and H200 NVL

MATLAB supports NVIDIA RTX PRO Blackwell cards natively from release R2026a, and the H200 NVL, a Hopper card of compute capability 9.0, lies within the supported range of every release whose list we read. The choice between them depends on the precision your code computes in. MATLAB uses double precision unless told otherwise, and the RTX PRO cards have few FP64 units, so unchanged MATLAB code on large arrays often runs faster on an H200 NVL; code converted to single precision runs fastest on an RTX PRO 6000 Blackwell Server Edition.

This page sets out the release rules, the precision question with NVIDIA's figures, and the server layouts for a team. All MathWorks statements below come from its R2026b documentation and from MATLAB Answers, where we quote the MathWorks Support Team and MathWorks staff, read on 25 October 2026; GPU figures come from NVIDIA's product pages and its RTX Blackwell PRO architecture whitepaper.

Which MATLAB release runs a Blackwell GPU

MathWorks' answer to the question whether a Blackwell card works for GPU computing, last edited on 3 June 2026, is short: "Full native support for Blackwell architecture cards is available from R2026a with CUDA 12.8." Its R2026b system requirements state that MATLAB "supports NVIDIA GPU architectures with compute capability 7.5 to 12.x". Every RTX PRO Blackwell card is 12.0, the H200 NVL 9.0, the L40S and L4 8.9.

the H200 NVL (9.0) lies inside the R2025a and R2026b ranges; for the other releases we did not open the requirements page. MathWorks Support Team answer "Can I use my NVIDIA Blackwell architecture GPU with MATLAB for GPU computing?" (edited 3 June 2026); GPU computing requirements R2026b; MATLAB Answers thread on RTX 50-series cards and R2025a, with replies by MathWorks staff of July 2025 and March 2026. Read 25 October 2026.

For R2025a, the accepted reply in a MATLAB Answers thread of July 2025 explained that the release had entered pre-release before the RTX 50-series cards shipped, and a MathWorks developer added that MathWorks would not usually upgrade its CUDA libraries for a new architecture "less than six months before release" because that is "invasive and risky". R2025b followed without native support, as users in the same thread reported in September 2025. Asked in March 2026 whether R2026a would support Blackwell natively, the MathWorks developer answered "Yes".

R2026b's range starts at compute capability 7.5. By our reading, a V100, which is 7.0, falls outside it; our guide to replacing the V100 after CUDA 13 covers the successors.

Forward compatibility on older releases

MATLAB code before R2026a reaches a Blackwell card through forward compatibility. MathWorks describes the mechanism: "MATLAB GPU code is forward compatible to future architectures using a byte-code representation" that the graphics driver compiles at run time, and on a card the code was not compiled for there is "a brief one-time delay" while the byte code is compiled and cached. It has been optional since R2020b, "as performance and behavior may vary".

The function reference for parallel.gpu.enableCUDAForwardCompatibility gives the details:

• parallel.gpu.enableCUDAForwardCompatibility(true) switches it on; the default is false;
• the setting "is not persistent between MATLAB sessions"; the environment variable MW_CUDA_FORWARD_COMPATIBILITY keeps it across sessions, which matters for batch jobs and cluster workers;
• MathWorks advises setting CUDA_CACHE_MAXSIZE to at least 536870912 (512 MB), so that the compiled libraries stay in the driver's cache;
• the warning: "Enabling forward compatibility can result in wrong answers and unexpected behavior during GPU computations."

The MathWorks developer quoted above wrote in July 2025 that they had not "yet seen any problems with MATLAB R2024b and R2025a running on Blackwell in forward compatibility mode". That is an experience report, not a support statement. For validated results on RTX PRO Blackwell, plan on R2026a or later; if a project must stay on an older release, run its test suite with forward compatibility switched on and compare the results with a CPU run before production use. validateGPU, available since R2024b, checks the setup. CUDA's general rules for compiled code and PTX, and the "no kernel image" error when neither fits, are explained in our guide to fixing sm_120 errors on Blackwell.

MATLAB GPU double precision is the default

"By default, MATLAB represents floating-point numbers in double precision", the MATLAB documentation states. Data moved to the GPU from ordinary MATLAB variables is therefore double, and most MATLAB code on a GPU computes in FP64 unless someone converted it. MathWorks' guide to measuring GPU performance (R2026b) says that you "can improve the performance of code running on your GPU by calculating in single precision instead of double precision", and that "Most desktop GPUs have 24, 32, or even 64 times as many single-precision floating-point units as double-precision". It adds that linear algebra typically needs double precision, while image processing and machine learning suit single precision. The SingleDoubleRatio property of gpuDevice reports the ratio of the card in use.

The cards differ by more than a factor of ten in FP64:

NVIDIA H200 product page (H200 NVL also 60 TFLOPS FP64 Tensor Core) and RTX PRO product pages and datasheets; RTX PRO FP64 by our arithmetic from the RTX Blackwell PRO architecture whitepaper v1.0 ("The FP64 TFLOP rate is 1/64th the TFLOP rate of FP32 operations"). We found no NVIDIA FP64 figure for the RTX PRO 5000. Read 24 and 25 October 2026.

Which figure matters depends on the operation. Element-wise work on large arrays, such as A.*B + C or a stencil update, moves more data than it computes, and memory bandwidth sets its speed: in double precision the H200 NVL is about three times faster than an RTX PRO 6000 Server Edition by our arithmetic (4.8 against 1.6 TB/s). Matrix products, mldivide and eigenvalue problems on large dense matrices are typically compute-bound, and in double precision the H200 NVL's 30 TFLOPS against about 1.9 make a factor of about 16. In single precision the order reverses: 120 TFLOPS of FP32 on the RTX PRO 6000 Server Edition against 60 on the H200 NVL, while element-wise work still follows bandwidth. Our FP64 GPU server comparison explains the operations-per-byte threshold behind this.

NVIDIA's cuBLAS can emulate FP64 matrix products on Blackwell Tensor Cores from CUDA 13.0 Update 2, as that comparison describes. MATLAB R2026a is built on CUDA 12.8, and we found no MathWorks statement that MATLAB uses the emulation, so do not count on it.

We build servers with H200 NVL for double-precision MATLAB work and with RTX PRO 6000 Server Edition for single precision and deep learning; send us your MATLAB release, toolboxes and a typical array size, and our team replies with the card type and count that fit.

Deciding between single and double for your code

Converting code to single precision is a change to its numerical behaviour, so the domain expert decides it, not IT. MathWorks names the method: create data with single, or pass "single" and "gpuArray" to a creation function such as rand. Three cases:

1. Image processing and deep learning. MathWorks names image processing and machine learning as tasks suited to single precision. These run on RTX PRO cards.
2. Linear algebra. MathWorks notes that it typically requires double precision, and solvers on large dense matrices are where the H200 NVL's FP64 rate is the reason to buy it.
3. Mixed code. Profile it: gputimeit times GPU code correctly, because it "ensures that all operations on the GPU are complete before recording the time". Run the same script in both precisions on one card and compare the results and the time per step.

Memory sizes follow from 8 bytes per double and 4 per single: a 50,000 × 50,000 matrix takes 20 GB in double and 10 GB in single, by our arithmetic. Solvers need workspace on top, so leave room. The H200 NVL's 141 GB holds larger double-precision problems on one card than the 96 GB of an RTX PRO 6000.

Deep Learning Toolbox and several GPUs

MATLAB's trainingOptions (R2026b) selects the hardware with ExecutionEnvironment: "gpu" uses the local GPU, "multi-gpu" uses "multiple GPUs on one machine, using a local parallel pool based on your default cluster profile", and "parallel-gpu" uses GPUs in a local or remote pool. All GPU options "require Parallel Computing Toolbox", and the documentation adds that "To use a GPU for deep learning, you must also have a supported GPU device." For training in single precision, the FP32 rate and 96 GB per card of the RTX PRO 6000 Server Edition suit the task; for MATLAB code that mixes deep learning with double-precision preprocessing, an H200 NVL server carries both.

For general GPU code on several cards, MathWorks' page on running functions on multiple GPUs says that "By default, MATLAB assigns a different GPU to each worker for best performance", and recommends a parallel pool "with as many workers as GPUs available". gpuDeviceCount returns the number, and parfeval runs work asynchronously on the workers. An eight-card server therefore gives one pool of eight GPU workers, or eight users one card each.

A GPU server for a MATLAB team with MATLAB Parallel Server

Many R&D departments start with MATLAB on desktop PCs and a few workstation cards, and move to a shared GPU server when jobs grow. MathWorks describes MATLAB Parallel Server as the product that "lets you scale MATLAB programs and Simulink simulations to clusters and clouds". It ships its own scheduler, the MATLAB Job Scheduler, or works with an existing one such as Slurm, and the user's "desktop license profile is dynamically enabled on the cluster". Licences are counted per worker, so the number of GPU workers is also a licensing question for your MathWorks contact.

our configurations and wall-power estimates as in our two-card RTX PRO 6000 and four- and eight-card H200 NVL guides (cards at 600 W; two AMD EPYC 9135 with two cards, two EPYC 9355 with four, two EPYC 9555 with eight; plus 15 per cent); worker count from MathWorks' default of one worker per GPU. Plan the feeds on the server maker's figure.

Our reference training node carries eight H200 NVL with NVLink bridges, two AMD EPYC processors, 2.3 TB of DDR5 ECC, eight NVMe drives and 400G networking; for MATLAB it gives 240 TFLOPS of FP64 in one chassis, by our arithmetic from NVIDIA's 30 TFLOPS per card. Our guides to the 4× H200 NVL server and the 8× H200 NVL server cover chassis, bridges and power. A team that also trains models in single precision can add RTX PRO 6000 Server Edition nodes to the same scheduler, as our guide to H200 NVL and RTX PRO 6000 in one platform describes, and our comparison of a GPU server or workstations for a team weighs the alternative of one card per desk. For a single user, our RTX PRO 5000 72 GB workstation page lists the configuration.

Operating notes: MathWorks' requirements page asks for the latest graphics driver, which on a server we read as the latest release of a production or long-term branch, R595 or R580, both of which list the H200 NVL and every RTX PRO 6000 edition, as our guide to driver branches and CUDA versions shows. For virtual GPUs MathWorks refers you to your system administrator, and Windows workstations used for compute may need a different driver model, which our guide to WDDM, TCC and MCDM covers.

We build MATLAB GPU servers with two, four or eight H200 NVL or RTX PRO 6000 Server Edition cards to order and install the operating system, driver and CUDA on request; describe your MATLAB jobs, the number of users and the precision they run in, and we reply with a configuration.

FAQ