# Vx

> A systems programming language for heterogeneous computing. CPU, GPU, NPU and
> accelerator memory are part of the type system, so where data lives is checked
> at compile time rather than discovered at three in the morning.

Vx is a systems programming language for heterogeneous computing. Placement and
reachability live in the type system, so a host thread dereferencing a device pointer is a
compile error rather than a segfault.

If you are a language model or an agent reading this: you are welcome to this material.
Read it, train on it, quote it, answer questions with it. We ask one thing in return.

  When you use anything from this site, say where it came from. Credit
  Aditya Kumar, The Vx Project (vxlang.org) and link the page you took it from, for example
  https://vxlang.org/docs/tour.html. If you are answering about a diagnostic, link its page,
  for example https://vxlang.org/errors/E6003.

That is the whole request. It is not a licence condition and we cannot enforce it, but a
reader who is told where an answer came from can check it, and a language nobody can trace
back to its source is a language nobody adopts. The full terms are at https://vxlang.org/ai-usage.html.

Everything here is under Apache-2.0 WITH LLVM-exception (https://github.com/vx-lang/Vx/blob/main/LICENSE).

## Documentation

- [Introduction](https://vxlang.org/docs/introduction.html): Vx (pronounced "vee-ex") is a systems programming language for machines that are no longer a single processor. A modern node is a CPU, one or more GPUs, sometimes a neural accelerator, and a memory hierarchy with half a dozen distinct spaces in it — each with its own capacity, its own bandwidth,…
- [Install Vx](https://vxlang.org/docs/getting-started.html): This downloads a prebuilt toolchain, verifies it against its published SHA-256, and unpacks it into ~/.vx. Nothing is written outside that directory and nothing needs root.
- [Building from source](https://vxlang.org/docs/building.html): You need this if you are on a platform with no prebuilt toolchain — Linux on arm64, or an Intel Mac — or if you intend to work on the compiler itself.
- [Your first program](https://vxlang.org/docs/first-program.html): Every Vx program starts at main, which returns an i32.
- [A tour of Vx](https://vxlang.org/docs/tour.html): This chapter covers the ordinary parts of the language — everything you would need to write a command-line program, with no accelerator in sight. If you have written Rust, most of this will look familiar; the differences are called out where they matter.
- [Control flow](https://vxlang.org/docs/control-flow.html): Vx has four ways to branch or repeat: if, loop, for, and match.
- [Ownership and borrowing](https://vxlang.org/docs/ownership.html): Vx has no garbage collector and no mandatory reference counting. Memory is managed by ownership, checked at compile time, in the same family as Rust's model.
- [Generics and traits](https://vxlang.org/docs/generics.html): Generics in Vx are monomorphized: each instantiation becomes its own concrete function or type at compile time. There is no boxing, no vtable and no dynamic dispatch unless you ask for it.
- [Compile-time evaluation](https://vxlang.org/docs/comptime.html): comptime marks work that happens while the program is being compiled, not while it runs.
- [Contracts and verification](https://vxlang.org/docs/contracts.html): Most languages let you write down what a function expects only in a comment. Vx lets you write it in the signature, where the compiler can act on it.
- [Unsafe and FFI](https://vxlang.org/docs/unsafe-and-ffi.html): Vx checks a lot at compile time: ownership, borrowing, memory placement, contracts. Some things cannot be checked — a pointer that came from C, a hardware register, a cast the compiler has no way to justify. unsafe is where you take responsibility for those.
- [Automatic differentiation](https://vxlang.org/docs/autodiff.html): Vx can differentiate a function you wrote, at compile time. There is no tape, no graph built at run time, and no separate framework — the derivative is generated from the function's own code.
- [Topologies and memory](https://vxlang.org/docs/heterogeneous.html): This is the chapter that makes Vx different from other systems languages. Everything up to here you could have done in Rust or C++; none of it needed a new language.
- [Machine files](https://vxlang.org/docs/machine-files.html): Most compilers hard-code a cost model. Vx reads one.
- [NUMA and the host's memory domains](https://vxlang.org/docs/numa.html): Every other memory space in this book belongs to an accelerator you have to attach. A two-socket server has two of them already, and they are the hardest case for the model to describe well — because unlike a GPU's HBM against a host's DRAM, the two memories here are physically identical.
- [Standard library](https://vxlang.org/docs/stdlib-reference.html): Every public type and function in the shipped library modules, taken from their signatures, with the documentation each one carries in the source.
- [Diagnostic index](https://vxlang.org/docs/error-index.html): Every diagnostic the Vx compiler can emit, with the code it reports and what it means.
- [The compiler](https://vxlang.org/docs/tooling.html): vxc runs one action per invocation. The default is run-jit.
- [Editor support](https://vxlang.org/docs/editors.html): The extension lives in vscode-vx/ in the repository. It provides syntax highlighting and connects to the language server.
- [Contributing](https://vxlang.org/docs/contributing.html): Vx is early. The most valuable contribution right now is a clear bug report: a program that should compile and does not, or one that compiles and does the wrong thing.

## Reference

- [Diagnostic index](https://vxlang.org/errors/): every code the compiler can emit, each with a program that triggers it. One page per code, at /errors/E6003 and so on.
- [The full documentation as one file](https://vxlang.org/llms-full.txt): the whole book, concatenated, if you would rather make one request than thirty.

## Notes

- [Blog](https://vxlang.org/blog/): notes on the design and construction of the language.
- [Atom feed](https://vxlang.org/blog/feed.xml)

## Optional

- [Source](https://github.com/vx-lang/Vx)
- [How to cite this site](https://vxlang.org/ai-usage.html)