At a glance: Intel GPU D270 (Crescent Island)
- Silicon & Precision: Xe 3P architecture, 32 Xe cores, 256 XMX engines; native FP4 to FP64 with full-rate double precision.
- Memory & Platform: 160 GB LPDDR5X (1.5 TB/s bandwidth, scalable up to 480 GB); 350W PCIe 5.0 air-cooled form factor.
- Workloads & Ecosystem: HPC (e.g. Financial modeling, seismic imaging), disaggregated, and agentic AI inference; programmed via open software stack.
High-performance computing (HPC) is undergoing a fundamental shift. While traditional large-scale numerical modeling and simulation remain foundational, scientific and enterprise environments increasingly integrate simulation, analytics, and AI inference within continuous workflows. Emerging agentic AI architectures accelerate this evolution, connecting data, models, and domain tools into autonomous loops that prepare inputs, evaluate intermediate outputs, and dynamically steer the next simulation step.
This convergence demands heterogeneous infrastructure where diverse compute engines execute the exact phases of a workflow. Intel GPU D270, formerly code-named Crescent Island, directly addresses this environment. While designed from the ground up for high-efficiency AI inference, its architecture provides the high-precision math, massive memory capacity, and standard enterprise form factor required for demanding HPC environments.
Native FP64 performance and high-capacity memory for demanding workloads
Scientific, engineering, and financial simulations depend on double-precision arithmetic to preserve numerical fidelity and avoid compounding rounding errors. Built on Intel’s Xe 3P architecture, the Intel GPU D270 features 32 Xe cores and 256 Xe Matrix Extensions (XMX) engines, delivering 64 FP64 fused multiply-add (FMA) operations per core. This architecture offers developers precision optionality: lower precision (FP4 to FP8) for inference throughput alongside full-rate, native FP64 compute where mathematical accuracy is non-negotiable.
Memory architecture is equally vital for handling complex working sets. The Intel-branded card packs 160 GB of high-speed LPDDR5X memory delivering 1.5 TB/s of bandwidth, while partner-designed configurations can scale up to 480 GB. This substantial memory footprint allows researchers to keep extensive datasets and wavefields resident on the GPU, minimizing costly data movement across the host bus. All of this compute density fits into a standard 350-watt, air-cooled PCIe form factor deployable in standard enterprise servers or scaled across racks.
Real-world application benchmarks, based on pre-production silicon, demonstrate the tangible advantage of D270’s balanced architecture across financial analytics and scientific simulation:
Financial Services: In options-pricing benchmarks, the D270 delivered up to 5.9× higher application throughput[1] compared to the NVIDIA RTX PRO 6000 Blackwell Server Edition, demonstrating superior performance in compute-heavy financial modeling. This performance is particularly notable given D270 operates at 350W, compared with 600W for the NVIDIA GPU.
| Workload | Application / Model | Baseline Hardware | Intel GPU D270 Result |
|---|---|---|---|
| Financial Services | European Monte Carlo | RTX PRO 6000 (Blackwell) | 5.9× throughput¹ |
| Financial Services | Black-Scholes (European) | RTX PRO 6000 (Blackwell) | 5.6× throughput¹ |
| Financial Services | Binomial | RTX PRO 6000 (Blackwell) | 4.6× throughput¹ |
| Financial Services | Black-Scholes (American) | RTX PRO 6000 (Blackwell) | 1.92× throughput¹ |
Seismic Exploration: Seismic modeling is one of the Oil and Gas industry’s most demanding workloads, requiring repeated acoustic wave-propagation calculations across massive 3D datasets utilizing FP32 compute. The combination of high memory capacity coupled this time with the FP32 compute in D270 shows strong capabilities for this workload. Cache-aware stencil optimizations maximize data reuse across local caches, keeping large wavefield arrays resident directly on the card. Intel is demonstrating Seismic modeling capabilities via a live demo at Supercomputing ‘26 in our booth.
A still from the demonstration of the seismic analysis workload running at SC26. (Credit: Veridien)
For scientific computing, the message is simple: memory capacity helps tackle larger problems, smarter reuse simplifies data movement, and optimized open programming models deliver the application throughput researchers need.
Disaggregated inference and AI-informed HPC
In modern scientific discovery, AI inference is no longer a separate task run after a simulation finishes. Instead, it operates directly inside the simulation loop. Pre-trained AI surrogate models act as physics emulators, screening hundreds of thousands of design parameters in seconds to pinpoint promising candidates before launching full-scale numerical solvers. Concurrently, agentic decision models monitor simulation telemetry in real time, identifying instability, dynamically refining mesh boundaries, and autonomously steering the next computation without waiting for manual human intervention.
Integrating high-throughput inference into supercomputing loops, however, demands speed and extreme operational efficiency. Monolithic computing nodes force distinct computational stages to compete for the same processors, compromising throughput and inflating latency.
Disaggregation solves this bottleneck by splitting the inference workload across processors tailored to its constituent computational phases, dramatically speeding up overall execution while optimizing energy and resource utilization. In this disaggregated blueprint, the Intel GPU D270 powers the compute-intensive prefill stage, rapidly processing high-dimensional simulation datasets, large prompts, and scientific context windows. SambaNova SN50 Reconfigurable Dataflow Units (RDUs) accelerate the memory-bound decode stage, delivering fast inference, while Intel Xeon 6 and Xeon 6+ processors govern end-to-end workflow orchestration, host communications, and tool execution. By orchestrating workloads across Intel GPU D-Series and SambaNova RDUs, this heterogeneous approach speeds up the entire agentic loop, allowing autonomous decision models to guide simulations in real time without idling expensive numerical compute. At the same time, this is all achieved while keeping power demands safely within existing air-cooled rack limits. Intel and SambaNova are building this solution to help providers grow supply to meet AI token demand without waiting for new facilities and utilizing the most common software stacks.
At SC26 in Chicago, Intel will demonstrate this disaggregated heterogeneous inference architecture live at its booth, showcasing the Intel GPU D270 operating alongside SambaNova SN50 RDUs in real time.
Crucially for HPC centers and research institutions, this architecture is turnkey. Customers can deploy state-of-the-art AI inference and agentic pipelines out of the box, leveraging an engineered disaggregated infrastructure without the burden of developing custom software orchestration or low-level scheduling layers.
Frictionless software unlocks hardware value
Hardware innovation loses its practical value if it introduces software friction, forcing teams into proprietary walled gardens that restrict code portability and mandate costly rewrites. A viable software strategy cannot demand a clean break with the past; it must protect existing software investments while unlocking new accelerated capabilities.
Intel directly addresses this by delivering a single, open software stack engineered to support both traditional numerical simulation and modern AI workloads. Rather than requiring developers to rewrite algorithms into proprietary dialects, Intel meets teams where they already work. Longstanding investment in foundational HPC standards, including Intel MPI, optimized Fortran, and high-performance C++ compilers, ensures that existing parallel codebases run efficiently across modern, heterogeneous architectures without vendor lock-in.
With engineering focused on upstream integration into standard AI frameworks, inference runtimes, and open SYCL programming models, research teams can deploy the Intel GPU D270 without changing toolchains and expect performance on Day 0.
The proof is in some of the early performance data Intel is already seeing on Intel GPU D270. In the emerging, decision-making class of models, where the models make decisions rather than just generating answers, Intel GPU D270 delivers up to 29% lower latency than the NVIDIA RTX PRO 6000 Blackwell server edition running Drex 2.02. When it comes to LLM throughput also, D270 delivers 1.12x the throughput performance on Qwen 3 30B – A3B3 when compared to the same competitor GPU but at only 350W of power. These two results, achieved on pre-production silicon, already demonstrate strong agentic readiness for Intel GPU D270.
In HPC, for the Veridien seismic demo described above, porting the workload over to Intel GPU D270 required minimal effort because the open SYCL programming model allowed the team to build on the work already done for their existing HIP/CUDA workload. Migration to SYCL with no host-side code modifications and, ahead-of-time (AOT) compilation combined with kernel bundles, made it straightforward to reuse existing compute kernels. This delivered high performance without heavy retuning: 90% of the kernels performed well with no Intel-specific optimizations, and even complex kernels reached up to 70% of theoretical peak performance on the first, unoptimized port. The outcome: a seismic imaging mini-application was ported in less than a month, with both numerical accuracy and performance successfully validated.
The Intel GPU D270 may be thought of up to now as an inference-optimized GPU, but by pairing native FP64 precision and high-capacity memory with open software, it makes a surprising and compelling case for itself in high-performance computing: that of a balanced, highly capable accelerator that can deliver improved workflow outcomes as HPC and AI converge.
¹Results are based on specified FP64 financial services workloads
Performance of popular HPC workloads(financial) on Intel® GPU D270 (SYCL* implementation) vs NVIDIA RTX PRO 6000 Blackwell Server Edition (utilizing best of NVIDIA* CUDA*/ SYCL implementation)
See appendix for details. Results may vary.
²Drex v2.0 performance using Jev Decision Index latency-v1 750 rows, concurrency 1. Warm-up: 80 request shapes state lengths 64–2,560 tokens in 64-token steps × 1 and 16 questions, each sent 3 times (240 requests) before timing, so GPU graphs are captured before the timed run. See appendix for details. Results may vary.
³Qwen 3 -30B-A3B-FP8 output token throughput Intel® GPU D270 vs. NVIDIA RTX PRO 6000 Blackwell Server Edition (ISL/OSL=1k/1k, FP8, VLLM, concurrency 1 through 32). See Appendix for details. Results may vary.
Appendix
1 Financial Services Configurations:
System Summary: 1-node, 1x Intel(R) Xeon(R) 6741P, 48 cores, 300W TDP, HT On, Turbo On, Total Memory 768GB (8x96GB DDR5 6400MT/s [6400MT/s]), BIOS 1.6, microcode 0xa000151, 2x Ethernet Controller X550, 1x 3.5T SAMSUNG MZTL63T8HFLT-00AW7, Ubuntu Resolute Raccoon (development branch), 7.0.0-38-generic.
GPUs: 1x Intel GPU D270 (pre-production), 160 GiB. KMD: xeb_v7.1.4.58_260728.46, UMD: 1.18.40581, Level Zero: 1.34.0
3x Arc Pro B70, 32 GiB. KMD: xeb_v7.1.4.58_260728.46, UMD: 1.18.40581, Level Zero: 1.34.0
GPU SW stack: oneAPI 2026.2
Test by Intel as of November 6 2026.
System Summary: 1-node, 2x Intel(R) Xeon(R) 6944P, 72 cores, 350W TDP, HT On, Turbo On, Total Memory 2304GB (24x96GB DDR5 6400MT/s [6400MT/s]), BIOS 1.5, microcode 0x1000405, 2x Ethernet Controller X710 for 10GBASE-T, 2x MT2892 Family [ConnectX-6 Dx], 1x 3.6T INTEL SSDPE2KX040T8, 1x 1.7T MTFDKCC1T9TGP-1BK1DABYY, 1x 447.1G Micron_7450_MTFDKBA480TFR, Ubuntu 26.04.1 LTS, 7.0.0-42-generic.
GPUs: 8xNVIDIA RTX PRO 6000 Blackwell Server Edition, 96 GiB. Driver 595.91.07
GPU SW stack: nvidia/cuda:12.8.0-devel-ubuntu22.04 container, oneMath, DPC++ 7.2.0
Test by Intel as of November 6 2026.
DREX Configurations:
Intel CRI (D270): Jev latency-v1, run A (80-shape warm-up)
System Summary: 1-node, 1x Intel(R) Xeon(R) 6741P, 48 cores, 300W TDP, HT On, Turbo On, Total Memory 1152GB (12x96GB DDR5 6400MT/s [5200MT/s]), BIOS 1.6, microcode 0xa000151, 2x Ethernet Controller X550, 1x 3.5T SAMSUNG MZTL63T8HFLT-00AW7, Ubuntu Resolute Raccoon (development branch), 7.0.0-38-generic.
GPU: 1x Intel GPU D270 (pre-production), 160GiB (single card used for the test, 2,500 MHz, 350W power cap). KMD: xeb_v7.1.4.63_260728.50, UMD: 1.18.40430, Level Zero: 1.34.0
GPU SW stack: oneAPI 2026.3 (DPC++ 2026.3.0), container sglang-cri-drex:upstream-20261020-r28 (PyTorch 2.15.0a0 XPU, SGLang 0.5.23.dev412).
Workload: nace-ai/drex-v2.0 (FP8 W8A8), TP1 on 1 card, Jev Decision Index latency-v1 (750 rows, concurrency 1), 80-shape graph warm-up (240 probes), median of 5 runs.
Test by Intel as of November 8 2026.
NVIDIA RTX PRO 6000: Jev latency-v1, run A (80-shape warm-up)
System Summary: 1-node, Amazon EC2 g7e.24xlarge (VM), 1x Intel(R) Xeon(R) Platinum 8559C, 48 cores (96 vCPU), HT On, Total Memory 999GB (VM), AWS ENA, 200GB EBS + 2x 3.5T instance NVMe, Ubuntu 24.04.5 LTS, 7.0.0-1014-aws.
GPU: 1x NVIDIA RTX PRO 6000 Blackwell Server Edition, 96 GiB (single card used for the test, stock boost, 600W limit). Driver 595.112.07GPU SW stack: drex-sglang:local container (CUDA 13.0, PyTorch 2.13.0+cu130, SGLang 0.5.21, Triton attention).
Workload: nace-ai/drex-v2.0 (FP8 W8A8), TP1 on 1 card, Jev Decision Index latency-v1 (750 rows, concurrency 1), 80-shape graph warm-up (production.py --graph-warmup), median of 5 runs.
Test by Intel as of November 9 2026.
QWEN Configurations:
Intel CRI (D270): Qwen3-30B-A3B FP8, WW45 PDT
System Summary: 1-node, 1x Intel(R) Xeon(R) 6741P, 48 cores, 300W TDP, HT On, Turbo On, Total Memory 1152GB (12x96GB DDR5, 5200 MT/s), BIOS AMI 1.6 (07/23/2026), microcode 0xa000151, 2x Intel X550 Ethernet, 1x 3.5T Samsung NVMe, Ubuntu Resolute Raccoon (development branch), 7.0.0-38-generic.
GPU: 1x Intel GPU D270 (pre-production) [8086:674c], 160GiB LPDDR5X (163,828 MiB; single card used for the test, PCIe Gen5 x16, 2,500 MHz max, 350W power cap). KMD: xeb_v7.1.4.63_260728.50, UMD (Level Zero driver): 1.18.40863, IFWI: 208.0.0.1050
GPU SW stack: container pytorch-ipex-spr:CRI_main_2850_ww45.5 (PyTorch 2.16.0a0 XPU, vLLM 0.1.dev1+gf8d7ca1e2 vllm-xpu). XPU graphs FULL_AND_PIECEWISE, torch.compile off, Flash Attention, FP8 KV cache. AIPerf 0.13.0.
Workload: Qwen/Qwen3-30B-A3B-FP8 (FP8 W8A8, 128x128 blocks), TP1 on 1 card.
Shapes: ISL/OSL 1024/1024, 8192/1024 and 1024/8192 at concurrency 1/8/16/32/64, plus 32768/1 at concurrency 1/8.
Serving: 16,384 batched tokens, 1,024 max sequences, prefix caching off, async scheduling.
Client: chat streaming with ignore_eos. Each cell has max(20, 4×C) requests and C warm-up requests; the result is the median of 3 runs.
Test by Intel as of November 7 2026.
NVIDIA RTX PRO 6000: Qwen3-30B-A3B FP8, WW45 PDT
System Summary: 1-node, Amazon EC2 g7e.24xlarge (VM), 1x Intel(R) Xeon(R) Platinum 8559C, 48 cores (96 vCPU), HT On, Turbo unavailable (VM), Total Memory 1TB (1x1TB DDR5 5600, VM), BIOS Amazon EC2 1.0, microcode 0x210002f4, 1x Amazon ENA, 200GB EBS + 2x 3.5T instance NVMe, Ubuntu 24.04.5 LTS, 7.0.0-1014-aws.
GPU: 1x NVIDIA RTX PRO 6000 Blackwell Server Edition, 96GiB GDDR7 ECC (97,887 MiB; single card used for the test, PCIe Gen5 x16, 2,430 MHz max SM, 600W limit). Driver 595.112.07, CUDA 13.2 (driver), VBIOS 98.02.AF.00.01
GPU SW stack: vllm/vllm-openai:v0.33.0 container (CUDA 13.0, PyTorch 2.14.0+cu130, vLLM 0.33.0). torch.compile + CUDA graphs FULL_AND_PIECEWISE, FlashInfer attention, FP8 KV cache. AIPerf 0.13.0.
Workload: Qwen/Qwen3-30B-A3B-FP8 (FP8 W8A8, 128x128 blocks), TP1 on 1 card.
Shapes: ISL/OSL 1024/1024, 8192/1024 and 1024/8192 at concurrency 1/8/16/32/64, plus 3
Serving: 16,384 batched tokens, 1,024 max sequences, prefix caching off, async scheduling.
Client: chat streaming with ignore_eos. Each cell has max(20, 4×C) requests and C warm-up requests; the result is the median of 3 runs.
Test by Intel as of November 7 2026.