High Performance Compute
The compute layer.
Every vendor, device, OS.
Low-level C++ library for GPU-accelerated compute — memory, cryptography, and artificial intelligence in a single substrate. Runs on NVIDIA, AMD, Intel, Qualcomm, and mobile. One codebase. One binary.
Architecture
Four pillars of the compute substrate.
Memory
High-performance memory management for GPU workloads. Efficient data streaming and buffer operations for compute-intensive applications.
Compute Kernels
Unified compute platform that runs across all GPU vendors. Write your code once and deploy on any GPU hardware.
Cryptography
Post-quantum cryptographic operations accelerated on GPU. Secure signatures and hashing for modern security requirements.
Runtime Integration
Artificial intelligence, cryptography, and general compute work together seamlessly. One unified platform for all your compute needs.
Capabilities
Everything between your code and the hardware.
Cross-Vendor Compute Kernels
The same code runs on every GPU vendor. Discrete, integrated, mobile — write once, deploy anywhere.
Dataset Streaming
Efficient data pipeline for datasets of any size. Large datasets stream directly to the accelerator for processing.
Embedded Compute Pipeline
Kernels compile at build time and embed into the binary. Ship one executable that runs on any supported device.
Post-Quantum Cryptography
Modern cryptographic operations accelerated on GPU. Quantum-resistant security from the start.
Topology-Aware Threading
Intelligent thread scheduling adapts to hardware topology for optimal performance across different CPU architectures.
Embedded Shader Registry
Shaders compile ahead of time and load through a dependency-aware parallel registry with a persistent Vulkan pipeline cache.
Compatibility
One binary. Every accelerator.
OA targets Vulkan and selects kernels from the capabilities exposed by each device. The application API remains stable while precision, subgroup, cooperative-matrix, media, and memory routes adapt to the available hardware.
The 10-year-old ultrabook
A ThinkPad X1 Carbon from 2017. Intel HD 620. No discrete GPU. Runs the full HPC stack — compute kernels, cryptography, ML inference. 2-7x faster than CPU-only.
The multi-GPU laptop
Integrated GPU for light workloads. Discrete GPU for heavy compute. Both at the same time? Yes. Integrated and discrete GPUs dispatching in parallel. Same binary.
The repair shop scenario
Your dedicated workstation goes in for service. Nobody knows when it comes back. You grab whatever machine is available — any machine, any netbook. Build environment stays identical. Same code. Same tests. Same results.
The scale axis
From an integrated GPU in a thin laptop, through a discrete consumer card, to multi-GPU server racks in a data center. The binary doesn't change. The kernel language doesn't change. Only the hardware does.
Performance
Measured. Not promised.
Same portable binary, Vulkan compute on the device under test. Integrated or discrete GPUs, or multi-GPU. No second runtime.
640K
Text Gen
samples/s wall
900K
Fashion-MNIST
samples/s wall
13.8K
PQC Verify
Dilithium-3
100%
Accuracy
text generation
Foundation
The Oa Library
Black magic mixed with alien technology. A hand-crafted C++ compute library for matrix operations, graph execution, machine learning, vision, audio, cryptography, and runtime services.
Inspired by real-time engine architecture. Every function optimized by hand. Every abstraction earned. Written like calligraphy — with precision, at 3 AM, because the code has to be right.
The foundation beneath every OA module: one matrix contract, one graph, one capability model, and one Vulkan runtime.
Compute Engine
OaEngine
The all-seeing eye. One object owns the entire compute context — device, memory allocator, kernel registry, and stream pool. Create it once. Everything flows through it. Every tensor, every module, every dispatch — orchestrated from a single point of consciousness.
Real-time compute for artificial consciousness. Multithreaded kernel dispatch with work-stealing. Persistent compute streams with batched recording — dozens of operations submitted in a single call. Pipeline compilation at build time. First dispatch is as fast as the millionth.
The engine awakens with three lines of code. From that moment, the hardware obeys. No ceremony. No configuration. No delay between thought and execution.
Batched
Dispatch Model
Pooled
Streams
Build-time
Compilation
Global
Context
Compute Scheduler
OaComputeGraph
Record once. Replay thousands of times. The compute graph captures an entire pipeline of GPU operations — dependencies, memory barriers, dispatch order — and compiles it into a replayable unit. Every subsequent execution is near-zero CPU cost. The hardware replays the exact sequence without the CPU touching a single command.
Automatic dependency analysis tracks every buffer read and write across the graph. Barriers are inserted only where true data hazards exist — eliminating 60-70% of synchronization overhead. Operations that don't overlap in time share the same memory, cutting VRAM usage by up to 92%.
For ML training where the same computation repeats every step, this means compile once at initialization and replay for the entire training run. Zero per-step overhead. Zero re-recording. The graph just runs.
