Rebellions Inference Platform

Start with the framework you already use. No migration, no retraining required.

Your existing PyTorch, TensorFlow, or Hugging Face model works as-is. Rebellions SDK plugs into your current workflow - you don't need to rewrite model code or switch frameworks.

Translates your model into instructions Rebellions NPUs can execute — with automatic performance optimization baked in.

One compile step converts your model to a hardware-optimized binary. The Frontend Compiler handles model abstraction and graph optimization; the Backend Compiler produces the final Command Stream for the NPU. Most models compile without code changes.

A comprehensive library of NPU-optimized math operations that power every model inference - from CNNs to the latest LLMs.

Hundreds of low-level operations (GEMM, LayerNorm, attention kernels) are pre-optimized for Rebellions Neural Engines. This is what makes inference fast - and it expands with every SK release to support new model architectures.

Manages model execution on the NPU - memory, scheduling, and throughput - while integrating natively with your serving framework.

The Runtime sits between your serving layer (vLLM) and the hardware. It handles data movement, execution scheduling, and performance monitoring -so your serving stack just works, without custom integration code.

Bridges your OS and orchestration layer to the NPU - including native Kubernetes device plugin support for cluster deployments.

The Kernel-Mode Driver (KMD) makes the OS recognize Rebellions NPUs as standard compute devices. The User-Mode Driver (UMD) provides clean APis for application integration. Kubernetes Device Plugin and NPU Feature Discovery are included for cloud-native deployments.

The lowest software layer on the chip - orchestrates workloads across memory and Neural Engines, and monitors hardware health in real time.

Firmware handles workload scheduling across the NPU's memory hierarchy and Neural Engines. It runs on-chip and is updated alongside the SDK. Health status and power metrics are exposed up the stack to Prometheus/Grafana via the Metrics Exporter.

Purpose-built Al inference hardware - from a single accelerator card to rack-scale infrastructure.

Every layer above is co-designed with the hardware - which means the full stack runs without friction from model file to NPU execution. Start with a single RebelCard, scale to RebelServer, then RebelPOD without changing your software stack.