Fast. Typed.
Native.
A statically-typed language for games, systems, and graphics. No build system needed — just write code and compile. Pluggable backends, C today, LLVM next. GPU compute and AI support on the roadmap.
struct Player {
name: str
health: i32
pos: vec3
}
fn main() {
var p = Player{"Alice", 100, vec3{0.0, 1.0, 0.0}}
p.health -= 10
print("Player {p.name} at ({p.pos.x}, {p.pos.y}, {p.pos.z})")
}Why GX?
A language designed for people who want modern syntax without giving up control over performance and memory.
C Performance, Modern Syntax
No garbage collector, no runtime. GX compiles to plain C, then to native code.
Built-in Graphics Types
Native vec2/3/4 and mat2/3/4 with operator overloading and swizzle (v.xy, v.zyx).
First-Class C Interop
Use any C library with @c_include and extern declarations. No bindings generator needed.
Compile-Time System
#if, #for, #fn, #type — conditional compilation, loop unrolling, compile-time functions, and monomorphized templates. All resolved before the C compiler sees the code.
Self-Contained Builds
@link("opengl32") in your source file — no CMake, no Makefile.
Compile-Time Reflection
@fields(T), @field(T, i), @members(E) — iterate over struct fields and enum members at compile time.
On the Roadmap
GX is in beta and actively developed. Here is what is coming next.
LLVM Backend
Optimized native code generation. The C backend stays as the portable fallback for every platform C compilers support.
GPU Compute
Run parts of your program on the GPU as compute shaders. No separate shader language, no manual dispatch. Just mark the code and go.
AI Support
Tensor types and GPU execution for machine learning workloads. Train and infer directly in GX without external frameworks.
LSP & More IDEs
Language Server Protocol for VS Code, Sublime, and other editors. IntelliJ plugin already available.
Quick Taste
C interop in 5 lines. No bindings generator.
import math.scalar
fn main() {
var angle: f32 = radians(45.0)
var result = sinf(angle)
print("sin(45) = {result}")
// Compile-time reflection
struct Vec { x:f32 y:f32 z:f32 }
print("Vec has {@fields(Vec)} fields")
}