Vx introduces a systems programming language for heterogeneous computing with type-enforced memory locality

Vx is a systems programming language designed for heterogeneous computing, where CPU, GPU, NPU, and accelerator memory are integrated into the type system. Unlike traditional languages that treat hardware boundaries as runtime infrastructure, Vx enforces data locality at compile time, making invalid host-device pointer accesses a compile error rather than a runtime segfault.

Type-Enforced Memory Locality

The core premise is that heterogeneity belongs in the type system, not the runtime. A tensor pinned to NPU high-bandwidth memory has a different type than one in host DRAM. Crossing these boundaries requires an explicit transfer() call, even if the hardware boundary is physically free (such as on Apple's unified memory architecture). This ensures data locality is provable without runtime inspection.

The compiler prevents several classes of errors through strict typing:

• Dereference safety: Host code cannot dereference pointers pinned to device memory.
• Capacity validation: Placements are checked against declared hardware limits before execution.
• Visibility checks: Accessing data before an asynchronous transfer is made visible is blocked.
• Linear types: Use-after-move errors are caught via a linear type system with ownership tracking.

Hardware-Aware Compilation

Vx does not hard-code cost models. Instead, it uses machine files that describe the memory hierarchy and interconnect of specific hardware parts. The compiler admits or rejects code placements based on these declared capabilities.

The repository includes machine files for major accelerators, including:

• NVIDIA H100, H200, B200, and A100
• AMD MI300X
• Apple M4 and multi-GPU nodes

These files use exact SI units (e.g., GiB vs GB) and cite sources for bandwidth and capacity figures. Unverified specs are explicitly marked.

Compilation Architecture

The Vx compiler is designed for parallelism and determinism. It uses a flat, array-based intermediate representation where symbols are indexed rather than pointer-chased. This allows the frontend to run in parallel without a central lock or query engine. The compiler produces identical MLIR output regardless of thread count, ensuring reproducible builds.

Backend Support and Limitations

Vx currently supports compilation to MLIR, with backends for:

• x86-64 and ARM64 CPUs (via LLVM IR)
• NVIDIA GPUs (via NVVM/PTX/SASS)
• Apple AMX/ANE (via CoreML primitive dispatch plugin)
• Distributed systems (via manifest-driven remote regions)

The language is explicitly not designed for rapid prototyping or dynamic workloads. It targets systems programming where performance predictability and memory safety across heterogeneous devices are critical. It is available for macOS on Apple Silicon and Linux x86_64.