raptor#
raptor describes a compiled GPU function (a “kernel”) in a small dict, so one package can build it and another can run it.
It is pure Python with zero hard dependencies, so a kernel producer such as hawk and an executor such as eagle can both build on it directly — see Concepts for how the manifest format and the shape-checking contracts fit together.
from raptor.schema import validate_manifest
manifest = {
"schema_version": 2,
"pattern": "pure",
"aether_abi": "aether-abi/2",
"exec_targets": ["host", "device"],
"exec_access": "sample_local",
"plugins": [{"id": "two_body_step", "order": 0, "enabled": True, "artifact": "two_body_step.ptx",
"sidecar": "two_body_step.json", "format": "ptx"}],
}
validate_manifest(manifest) # raises on a malformed or out-of-order document
key |
meaning |
|---|---|
|
which rules this document follows |
|
which kind of kernel this is; |
|
the binary-format tag paired with |
|
host / device: where this kernel may run |
|
how it touches per-sample vs. cross-sample data |
|
the compiled artifact(s) this manifest describes ( |
Where raptor sits#
aether (numerics core) ---> eagle (execution) <--- raptor (shared contracts) ---> hawk (kernel authoring)
aether is the family’s C++ numerics core (not covered on this page) that eagle runs on; raptor depends on nothing in the family, and hawk and eagle both declare it instead. hawk authors and compiles kernels; eagle launches, captures and marshals them (marshals = converts an array into exactly the layout a compiled call expects). Downstream packages wire kernels into trainable programs. Each works alone — adding a companion buys speed or a deployment option, never a new capability.
Pip install, zero hard dependencies, verify in one line.
Build and validate a kernel manifest in under five minutes.
What the contracts buy you, the manifest schema, the protocol contracts, and the certification matrix.
Every public class and function in raptor.schema, raptor.protocols and
raptor.conformance.