A C-like language for programming thousand-core supercomputers. Designed for a Connection Machine-inspired architecture with TDMA message passing.
Single Program, Multiple Data. All 4,096 processors run the same code with different data. Write once, execute massively parallel.
No hidden costs. All communication happens in exchange blocks with bounded latency and zero collisions.
12-dimensional hypercube with deterministic routing. Neighbor exchanges, reductions, and scans map directly to hardware.
Use where() blocks to run code on a subset of processors. Divergent control flow without branches.
Distinct types for per-processor (pvar) and shared variables. Catches parallelism bugs at compile time.
No race conditions. No deadlocks. TDMA scheduling makes every operation predictable and repeatable.
THIS ISN'T A GPU. GPUs have thousands of threads with shared memory. StarC has thousands of processors with explicit communication. You don't hide latency—you design algorithms that use the hypercube topology.
THIS ISN'T MPI. There's no send(dest, msg). Communication is symmetric (everyone exchanges with neighbors) and deterministic (bounded latency, no collisions).
THIS IS DATA-PARALLEL COMPUTING. Inspired by the Connection Machine CM-1, StarC brings 1980s supercomputer thinking to modern hardware. Write topology-aware code, and the machine executes it predictably.
void main() {
// Each processor has its own copy of 'x'
pvar<int> x = pid(); // 0, 1, 2, ..., 4095
// Exchange with neighbor in dimension 0
exchange {
pvar<int> neighbor = nbr(0, x);
}
// Sum across all processors
exchange {
int total = reduce_sum(x); // 8,386,560
}
// Only some processors execute this
where (x < 64) {
led_set(255); // Light up first 64 LEDs
}
}
Ready to get started? Try the interactive playground to see 4,096 processors in action, grab the tools to build your own StarC programs, or dive into the documentation to learn the language.