Most deep learning frameworks are a thin Python layer over someone else's C++ and CUDA. Haelixe takes the harder path: a compute engine written entirely in Rust, down to its own memory allocator.
Wrapping an existing runtime is the fast way to ship a framework. It is also the fast way to stop understanding what your framework actually does — every bug becomes a question about someone else's C++, and every optimization is bounded by an API you don't control.
Haelixe is built the slower way on purpose. The autograd engine, the tensor layout, the memory allocator, and the GPU dispatch layer are all written from scratch in Rust. When something is slow or wrong, the answer lives in this codebase — not three layers down in a vendored library.
The payoff is a framework that can be reasoned about end to end: deterministic memory reclamation, zero-copy tensor views, and GPU kernels that run unmodified on Vulkan, Metal, or DirectX through a single WGSL source.
RAII-based VRAM reclamation via Arc reference counting means a slab is freed exactly when the last autograd reference dies — never earlier, never silently.
Views, transposes, and slices manipulate shape and stride arrays only. The physical buffer moves once, at allocation — not on every reshape.
Compute kernels are written once in WGSL and dispatched through wgpu to Vulkan, Metal, or DirectX 12 — no per-platform kernel forks to maintain.
Every architectural claim is checked against a real convergence test — the haelixe-lab workspace exists specifically to validate the math, not just the API surface.
Haelixe is a Cargo workspace. haelixe-lab sits downstream as a real consumer of the public API, so ergonomics get tested the same way an external user would hit them.
Haelixe is under active development on GitHub. The clearest way to understand
it is still to clone haelixe-lab and watch the loss curve converge.