ZXO / COMPACT AI DESIGN STUDY

GB10
ROSSO.

A bold desktop.
A considered thermal path.

Racing red, graphite and the ZXO signature. A compact AI computer concept built around a clear path from intake to exhaust.

ZXO GB10 ROSSO red-and-black desktop exterior concept with honeycomb intake and diagonal red accents
ROSSO / THE COMPLETE EXTERIORView the collection ↗

Design concept · Engineering validation pending. Platform figures below are NVIDIA references. ZXO cooling, sustained-load performance and final specifications have not been measured or confirmed.

THE PLATFORM
AT A GLANCE

NVIDIA references ↗
Unified memory target
128 GB
Shared by CPU and GPU
Peak AI reference
1 PFLOP
Up to · FP4 with sparsity
Memory bandwidth
273 GB/s
DGX Spark reference
CPU reference
20 cores
Arm CPU architecture

01 / KNOW THE MACHINE

Three numbers.
Three different stories.

Compute describes how much arithmetic a suitable workload can use. Memory determines what can reside locally. Bandwidth influences how quickly that data can move.

01 / COMPUTE

A peak, with conditions.

1 PFLOP FP4 · sparse

NVIDIA quotes up to one petaFLOP of AI compute at FP4 precision with sparsity for the reference platform. This is a theoretical low-precision Tensor Core peak under specific conditions, rather than a general FP16 or FP32 rating.

Real inference speed depends on the model, supported kernels, quantization, prompt length, batch size and software stack. The peak figure does not establish tokens per second, first-token latency or a workstation-to-workstation performance ratio.

Hardware reference [1]
02 / CAPACITY

One shared workspace.

128 GB unified memory target

GB10 combines its CPU and GPU with unified LPDDR5x system memory. The target configuration gives compatible AI workloads access to a large shared memory space without a separate graphics-card memory ceiling.

The operating system, CPU applications, model weights, KV cache and runtime allocations all draw from this system capacity. It is not 128 GB of GPU memory plus an additional CPU memory pool.

Memory reference [1]
03 / DATA MOVEMENT

Capacity is only half the picture.

273 GB/s reference memory bandwidth

Large language model decoding can spend substantial time moving weights and other data. A model may fit in memory while its response speed remains constrained by data movement or software efficiency.

Quantization can reduce model-weight storage and transfer requirements. Its actual speed and quality trade-offs depend on the model format, kernels and task. Memory capacity alone does not promise real-time interaction.

Bandwidth reference [1]

THE CPU AND SOFTWARE MATTER

20 Arm cores.
Build for the right software target.

The reference CPU has 10 Cortex-X925 and 10 Cortex-A725 cores. It handles orchestration, data preparation and the application around the GPU workload.

NVIDIA’s reference software is DGX OS on an Arm64 Linux platform. Check Arm64 container images, framework builds, CUDA kernels and third-party applications before choosing a workflow. A conventional x86 Windows binary is not automatically compatible with this target.

Explore the software reference ↗
THE FIRST TOKEN / PREFILL

Process the prompt.

Prefill processes the input context and can be compute-intensive. A longer document or prompt may increase the delay before a response begins, even when later token generation is responsive.

THE NEXT TOKEN / DECODE

Supply the data.

Decode generates the response step by step and often stresses memory bandwidth and KV-cache capacity. More simultaneous requests can improve aggregate throughput while increasing each user’s latency.

Compare the same model, precision, context and concurrency when assessing these two stages. NVIDIA serving explanation [5]

02 / SIZE THE WORKLOAD

Start with the weights.
Leave room for the work.

NVIDIA describes reference-system inference support for models up to 200 billion parameters. That ceiling depends on the model and representation; it is not a full-parameter training claim or a guarantee for every 200B model.

What else needs memory?

  • Quantization metadataScales, packing and implementation overhead add to raw weight arithmetic.
  • KV cache and activationsContext length, concurrency and model architecture influence the working set.
  • Runtime and operating systemFramework workspaces, services and CPU tasks share the available memory.

The illustration uses decimal GB and a nominal 128 GB planning budget. It does not model an operating system’s reported capacity or predict whether a specific model will load or perform acceptably.

MODEL-WEIGHT ILLUSTRATION

Weights ≈ parameters × bits ÷ 8
Raw weights only35 GB≈ 32.6 GiB
Raw weightsSelected allowanceWithin the selected planning budget

70B × 4 bits ÷ 8 = 35 GB of raw weights, before overhead.

Arithmetic illustration only. Quantization support, usable memory, KV cache and performance require model-specific validation.

4-BIT RAW WEIGHTS
8B≈ 4 GB
32B≈ 16 GB
70B≈ 35 GB
200B≈ 100 GB

A PLATFORM FOR DEVELOPMENT

Bring the next idea
closer to your desk.

Choose the model, latency target and software together. A local development system can be one part of a workflow that also uses larger servers or cloud resources.

01 / LOCAL INFERENCE

Explore larger local models.

Evaluate compatible quantized LLMs, document assistants and retrieval-augmented generation. Balance parameter count against context length, concurrency and the response time your application needs.

02 / ADAPT & EVALUATE

Develop focused adaptations.

NVIDIA publishes Spark recipes for 8B LoRA and 70B QLoRA with a 4-bit base model under recipe-specific settings. Training also needs gradients, optimizer state and activations, so inference capacity does not establish an equivalent training limit. Fine-tuning playbook [6]

03 / BUILD APPLICATIONS

Connect models to useful tools.

Prototype agents, vision pipelines and local AI services with compatible Arm64 software. Plan data handling, application integration and the wider deployment environment alongside the model itself.

WHEN ONE NODE IS NOT ENOUGH

Connect systems.
Plan the distribution.

NVIDIA documents ConnectX-7 QSFP ports at up to 200 Gb/s per port in Ethernet mode for DGX Spark. This is network connectivity between systems; it is not an NVLink fabric or an automatic shared GPU-memory pool.

Two nominal 128 GB systems have 256 GB of physical system memory in aggregate. A compatible distributed runtime must partition a workload across them. Communication, parallelization and synchronization affect results, so two nodes do not imply twice the throughput.

Clustering and networking reference [3]

03 / THERMAL ARCHITECTURE

Give heat
a deliberate exit.

The ROSSO brief treats cooling as an entire air path: open intake, heat spreading, guided flow and a broad rear exhaust. High airflow is the design objective.

ZXO GB10 thermal concept with two front blowers, a copper spreader, four heatpipes, rear fins and right-side secondary cooling
01 / THE INTERNAL DESIGN PROPOSALOpen original PNG ↗
  1. 01

    Admit cool air.

    Front honeycomb mesh and side louvers create the proposed intake area. Clearance above the blower inlets is part of the packaging brief.

  2. 02

    Spread the heat.

    A central copper vapor-chamber concept and four heatpipes transfer heat toward the rear fin bank. Contact pressure, flatness and interfaces need engineering development.

  3. 03

    Guide the flow.

    Two centrifugal blowers feed bounded passages toward the fins. Shrouds aim to limit warm-air recirculation and separate intake from exhaust.

  4. 04

    Finish the thermal path.

    Rear fins and the upper rear outlet provide a proposed exit. Low-profile SSD and power-delivery cooling address additional heat sources.

Proposed twin-blower module with a copper spreader, four heatpipes and rear fin bank
THE COOLING MODULE

One coherent assembly.

Blowers, ducts, heat spreading and fins developed as a system.

Schematic arrows show front and side intake, twin-blower duct flow and rear exhaust; this is not a CFD simulation
THE AIRFLOW PRINCIPLE

From intake to exhaust.

Explanatory arrows show the intended direction, without claiming CFD or measured airflow.

The internal layout is an illustrative ZXO proposal. Board fit, air pressure, fan curves, thermal contact, temperatures, acoustics and sustained-load behavior require prototype validation.

THE DESIGN, LAYER BY LAYER

Considered outside.
Explored within.

The red shell, cooling module, illustrative board and lower structure form a complete design conversation. The internal views make the intended relationships visible before mechanical and electrical integration are finalized.

Explore all six internal views ↗
Exploded concept showing the red lid, cooling assembly, illustrative GB10 board and lower chassis
Illustrative assembly layout · Engineering validation pending

04 / A CONFIGURATION TO DISCUSS

The platform reference.
The ZXO target.

NVIDIA’s reference system gives the performance discussion a factual starting point. ZXO’s memory, storage and physical design remain proposed integration targets.

Swipe to view all columns

NVIDIA DGX Spark reference characteristics and the proposed ZXO GB10 ROSSO direction
AreaReference / proposed configurationHow to read it
Compute platformNVIDIA GB10 Grace BlackwellIntegrated CPU/GPU platform target; OEM implementation to be confirmed.
CPU20-core Arm
10 Cortex-X925 + 10 Cortex-A725
NVIDIA reference. Validate application and container support for Arm64.
Memory128 GB LPDDR5x unified memory targetShared system capacity; OS, CPU and GPU workloads all consume memory.
Memory bandwidth273 GB/s referenceReference-system specification; no ZXO benchmark has been published.
Peak AI computeUp to 1 PFLOP at FP4 with sparsityConditional theoretical AI peak, not FP16/FP32 or measured application speed.
Storage target4 TB NVMe M.2Proposed ZXO target. NVIDIA lists 1 TB or 4 TB reference-system options.
Networking reference10 GbE · ConnectX-7
QSFP ports up to 200 Gb/s each, Ethernet mode
Final ZXO NIC integration and I/O layout require validation.
Connectivity reference4 USB-C including power delivery
HDMI 2.1a · Wi-Fi 7 · Bluetooth 5.4
NVIDIA reference interfaces; the rendered ZXO connector layout is illustrative.
Power context140 W SoC TDP
240 W external adapter reference
Chip thermal-design power and adapter rating describe different limits; neither is measured ZXO wall power.
ZXO cooling proposalTwin blowers · Copper vapor chamber
Four heatpipes · Rear fin bank
High-airflow design objective. Fan specifications, fit and thermal results remain to be tested.
EnclosureCompact ROSSO red / graphite designFinal dimensions, materials and service layout have not been confirmed.
Product stageExterior and thermal-layout design studyPricing, availability and final shipping specifications have not been announced.

Reference sources: NVIDIA hardware guide [1], platform overview [2], clustering guide [3] and software documentation [4].

WHAT WE WOULD MEASURE NEXT

Performance that can
be reproduced.

A useful result names the workload and test conditions. The following is a validation plan, rather than a set of completed ZXO benchmarks.

  1. Model behaviorModel revision, quantization, context, batch and concurrency; time to first token and sustained decode rate.
  2. Memory and softwarePeak memory, KV-cache growth, framework and kernel versions, Arm64 compatibility and runtime stability.
  3. Thermal and electricalAmbient temperature, sustained clocks, component temperatures and measured whole-system input power.
  4. Acoustics and serviceNoise under defined loads and measurement distance, airflow obstruction, dust access and maintenance clearances.

SOURCE NOTES / REVIEWED NOVEMBER 5, 2026

Follow the references.

  1. [1]
    NVIDIA DGX Spark hardware overview ↗

    CPU, memory, bandwidth, reference AI peak, storage, interfaces and power context.

  2. [2]
    NVIDIA DGX Spark platform overview ↗

    Platform positioning and model-capacity examples; workload and software conditions apply.

  3. [3]
    NVIDIA DGX Spark clustering guide ↗

    ConnectX-7 connectivity, Ethernet link characteristics and distributed-system planning.

  4. [4]
    NVIDIA DGX Spark software overview ↗

    Reference software environment. Validate the final ZXO software image and application stack.

  5. [5]
    NVIDIA Dynamo serving architecture ↗

    General prefill, decode and serving-memory explanation; not a ZXO benchmark.

  6. [6]
    NVIDIA Spark NeMo fine-tuning playbook ↗

    Recipe-specific LoRA and QLoRA examples; validate exact settings and software support.

START WITH YOUR WORKLOAD

What will you
build locally?

Tell us the model, quantization, context, concurrency and applications you plan to use. We can start the GB10 discussion with the requirements.