AI Factory Digital Twin: DSX and OpenUSD

01What you'll learn

• What a digital twin is and what the DSX blueprint adds to it.
• What DSX consists of and which specialists work with it.
• What it requires and why it is not for GX10.
• What OpenUSD is — and why pip install usd-core does not work on Linux with Arm.
• How to build a small twin of a server room in a text file.
• How to calculate heat load, PUE and yearly energy — and how far such a calculation goes.

02Before you start

• Python 3. The script uses only the standard library — nothing to install.
• Optional: a computer with usd-core or a program for viewing USD files, to open the resulting file.
• The data from the manufacturer's data sheet for your devices (electrical power) and your air conditioner (cooling capacity). The numbers in the lesson are invented.

03Steps

1. What a digital twin is and what DSX is

   A digital twin is a model of a real object that keeps its data (dimensions, power ratings, connections) in one place and can be used for “what if” questions before you buy or move something. NVIDIA's DSX Blueprint is an example of how to do this for an AI factory — a huge centre with computing power. According to the documentation its repository contains:

   • Geometry of a reference design for a 50-acre site, with a compute building and supporting infrastructure.
   • A web application for viewing the twin, running simulations and saving configurations.
   • Simulation-ready assets: computational fluid dynamics data for a hot aisle, sample configurations (GB200 and GB300 NVL72) and a simulation of electrical loading.

   Different specialists work around it: design engineers, network administrators (NVIDIA Air), mechanical engineers (Cadence tools), electrical engineers (ETAP), reviewers who look through streaming, and AI engineers. The documentation stresses: this is an example, not a production-ready application.

2. Why it is not for GX10

   The table in “Before you start” is clear: an RTX Pro 6000 Blackwell and 64 GB of DDR5 are needed. Our machine has an integrated graphics card with shared memory and an Arm CPU — it is not on the list. We do not say “it can never work” — we say the documentation does not include it and we have not run it. If you need DSX, work on a machine from the list.

   💡

   What “gigawatt scale” means

   The blueprint is for huge centres. A room with a few servers is a different task — for it you do not need DSX, you need the dimensions, the power ratings and a little arithmetic. That is exactly what we do below.

3. OpenUSD in brief — and one obstacle on Arm

   OpenUSD (Universal Scene Description) is a format for describing scenes: objects, positions, properties, layers. It has a text variant, .usda, which you can read and write with an ordinary editor. Two lines at the start say the unit of measure (metersPerUnit) and the “up” direction (upAxis).

   The obstacle: as of 03.10.2026 the usd-core package on PyPI (version 26.8) has ready wheels for Windows, macOS and Linux on x86-64, but none for Linux on Arm (aarch64) — which is what GB10 is. So pip install usd-core on GX10 will not work. The options are: to compile it from source (not run), to use another computer — or, as we do here, to write the text file with plain Python and look at it elsewhere.

4. The small twin: a server room in .usda

   The script describes a room and four devices. Each device is a node with a position and its own property twin:it_watts — its electrical power. This way the data lives in the scene, not in a separate table. The 20 cm cube body is only a stand-in for the size; a real model is brought in from the designer's file. The numbers are invented (240 W per server, 60 W for the switch) — replace them.

   python · room_twin.py (part 1)copy

   # A small "twin" of a server room: a scene in USDA (text) format + a power budget.
   # The numbers below are EXAMPLES — replace them with the manufacturer's data and your own measurements.
   DEVICES = [  # name, X in metres, Z in metres, electrical power in watts
       ("server_01", 0.0, 0.0, 240.0),
       ("server_02", 0.8, 0.0, 240.0),
       ("server_03", 1.6, 0.0, 240.0),
       ("switch_01", 2.4, 0.0, 60.0),
   ]
   ROOM_W, ROOM_D, ROOM_H = 4.0, 3.0, 2.6     # metres
   PUE = 1.5               # total facility power / IT equipment power (an assumption)
   AC_COOLING_KW = 2.0     # YOUR air conditioner: cooling capacity in kW (from its data sheet)
   EUR_PER_KWH = 0.20      # EXAMPLE price; use yours, VAT included
   
   def write_usda(path):
       out = ['#usda 1.0', '(', '    defaultPrim = "Room"', '    metersPerUnit = 1', '    upAxis = "Y"', ')', '',
              'def Xform "Room"', '{',
              f'    custom double twin:width_m = {ROOM_W}',
              f'    custom double twin:depth_m = {ROOM_D}',
              f'    custom double twin:height_m = {ROOM_H}']
       for name, x, z, watts in DEVICES:
           out += [f'    def Xform "{name}"', '    {',
                   f'        double3 xformOp:translate = ({x}, 0.1, {z})',
                   '        uniform token[] xformOpOrder = ["xformOp:translate"]',
                   f'        custom double twin:it_watts = {watts}',
                   '        def Cube "body"', '        {', '            double size = 0.2', '        }', '    }']
       out += ['}', '']
       with open(path, "w", encoding="utf-8") as f:
           f.write("\n".join(out))

   The result is plain text — it begins like this (see the whole file in an editor):

   room.usda · the beginningcopy

   #usda 1.0
   (
       defaultPrim = "Room"
       metersPerUnit = 1
       upAxis = "Y"
   )
   
   def Xform "Room"
   {
       custom double twin:width_m = 4.0
       custom double twin:depth_m = 3.0
       custom double twin:height_m = 2.6
       def Xform "server_01"
       {
           double3 xformOp:translate = (0.0, 0.1, 0.0)
           uniform token[] xformOpOrder = ["xformOp:translate"]
           custom double twin:it_watts = 240.0

5. The budget: heat, PUE, energy

   What we calculate and why: almost all the electrical power of the IT equipment turns into heat, which the air conditioner must remove (1 kW = 3412.14 BTU/h). PUE is the total consumption of the site divided by the consumption of the IT equipment; with an assumed PUE = 1.5 the site uses 1.5 times more than the equipment alone. Yearly energy is power × 8760 hours. The check “is the air conditioner enough” is rough: it does not count people, lighting, sun, losses in the power supplies, redundancy and an open door.

   python · room_twin.py (part 2)copy

   def budget():
       it_kw = sum(d[3] for d in DEVICES) / 1000
       heat_kw = it_kw                          # all electrical power of the IT equipment becomes heat
       total_kw = it_kw * PUE
       return {"it_kw": round(it_kw, 3), "heat_kw": round(heat_kw, 3),
               "heat_btu_h": round(heat_kw * 3412.14), "total_kw": round(total_kw, 3),
               "cooling_ok": heat_kw <= AC_COOLING_KW,
               "kwh_year": round(total_kw * 8760), "eur_year": round(total_kw * 8760 * EUR_PER_KWH, 2)}
   
   if __name__ == "__main__":
       write_usda("room.usda")
       print(budget())

   bashcopy

   python3 room_twin.py

   With the invented numbers the output looks like this (run on an ordinary Linux machine):

   outputcopy

   {'it_kw': 0.78, 'heat_kw': 0.78, 'heat_btu_h': 2661, 'total_kw': 1.17, 'cooling_ok': True, 'kwh_year': 10249, 'eur_year': 2049.84}

   Read it like this: 4 devices at 240 + 240 + 240 + 60 = 780 W = 0.78 kW; 0.78 × 1.5 = 1.17 kW in total; 1.17 × 8760 ≈ 10,249 kWh a year; at an example price of 0.20 EUR/kWh — about 2,050 EUR. These are example numbers, not a forecast.

6. Read the scene back (optional)

   On a computer with usd-core (not on GX10) you can prove that the data really lives in the scene. This is how we checked it with usd-core 26.8 on x86-64 Linux — we got 780.0 watts:

   python · on a machine with usd-corecopy

   from pxr import Usd
   
   stage = Usd.Stage.Open("room.usda")
   total = sum(p.GetAttribute("twin:it_watts").Get()
               for p in stage.Traverse() if p.HasAttribute("twin:it_watts"))
   print("total watts:", total)

7. What DSX would add — and why a twin must be checked

   Our small twin is an inventory with arithmetic. DSX adds things that cannot be done in ten lines: a simulation of airflow (CFD), electrical loading, a network model, streaming of the scene. Specialists and professional tools use them.

   ✅

   A twin is a model — check it against measurement

   Put a power meter on the real line and record the power for a week; put a temperature sensor at the intake of the equipment. If the numbers in the twin and in the measurement differ, correct the assumptions (PUE, the power ratings), not the measurement. A model without checking is only a guess.
   ⚠️

   Not an engineering design

   The cooling and the electrical installation of a server room are the work of qualified specialists. This lesson teaches thinking and arithmetic; it does not replace a design.

04Check

• You can say which graphics card and system DSX requires and why GB10 is not covered.
• room.usda is created and opens in a USD program or with pxr.
• The sum of the watts in the file matches the “IT power” of the budget.
• You replaced the invented numbers with data from the manufacturer's data sheet and with measurements.
• You can name what DSX adds: CFD, electrical simulation, a network model, streaming.

Test

05What's next

06Sources

1. NVIDIA Omniverse DSX Blueprint (build.nvidia.com) — the blueprint's page (03.10.2026). 🌐 global
2. DSX: overview · DSX: prerequisites — contents, roles, system requirements (pages updated on 02.10.2026).
3. The blueprint's repository — README; not run by us.
4. usd-core on PyPI — the file list of version 26.8 (no Linux aarch64).
5. OpenUSD: documentation — the format, layers, .usda.
6. ⚠️ The definition of PUE and the conversion 1 kW = 3412.14 BTU/h are generally accepted; we did not read the standard (ISO/IEC 30134-2) during this check. Verify it if the numbers go into a contract.