Open entry points
Ingest mainstream frameworks and open model formats without demanding a rewrite before evaluation.
HOLYCORESHOLYFLOW™ SOFTWARE STACK
Let models move freely.
One compiler, runtime, and developer experience from cloud systems to edge processors.
HOLYFLOW™ SOFTWARE STACK
One model, through every layer.
HOLYFLOW is not a single abstraction. It is a stack that lets teams import existing models quickly, inspect compilation, replace operators, author kernels and control execution across devices.Hardware aware
Compilation understands dataflow, memory hierarchy, parallel topology and product-level system boundaries.
Visible and tunable
Graph partitioning, operator mapping, memory use and communication cost remain inspectable.
Across every scale
Carry model assets from AETHER to NOVA and SPARK, recompiling and validating for each deployment scale.
THE STACK
From framework semantics, all the way to silicon.
Every layer has a defined responsibility and interface. Developers can stay with high-level APIs or follow the same call path into runtime, kernels and device resources.MODEL & FRAMEWORKSPyTorchJAXONNXTensorFlowHugging Face
01 / GRAPH
HOLYFLOW Compiler
Model ingestion, graph optimization, intermediate representations, parallel planning and target code generation.
02 / OPERATORS
HOLYFLOW NN
High-level Python / C++ operators, fused operations and model building blocks.
03 / TOOLS
HOLYFLOW Studio
Graph inspection, memory analysis, profiling, numerics and debugging.
04 / EXECUTION
HOLYFLOW Runtime
Device discovery, queues, memory, synchronization, communication and multi-card execution.
05 / KERNELS
HOLYFLOW Kernel
Custom data-movement, matrix, vector and fused kernels.
DRIVER · FIRMWARE · TELEMETRY · SECURITY
AETHER / CLOUD SYSTEMNOVA / DATACENTERSPARK / EDGE
HOLYFLOW TOOLKIT
Six tools. One software lifecycle.
From model ingestion, operators, and kernel development to multi-device execution, analysis, and production deployment, each tool owns a clear engineering boundary.
01 / COMPILE
HOLYFLOW Compiler
Model ingestion, graph optimization, and hardware-aware compilation.
Explore Compiler →
02 / OPERATORS
HOLYFLOW NN
High-performance operators for common model structures.
Explore NN →
03 / PROGRAM
HOLYFLOW Kernel
Custom operators and low-level dataflow programming.
Explore Kernel →
04 / RUN
HOLYFLOW Runtime
Unified execution from one device to cards and clusters.
Explore Runtime →
05 / OBSERVE
HOLYFLOW Studio
Graph analysis, profiling, debugging, and telemetry.
Explore Studio →
06 / DEPLOY
HOLYFLOW Deploy
Model serving, releases, and fleet operations.
Explore Deploy →HOLYFLOW COMPILER
Bring the model. Let the compiler understand the hardware.
The compiler is organized around open multi-level intermediate representations, lowering a framework graph into a device executable while retaining traceability through every transformation.01
→IMPORT
Ingest framework graphs and open formats while preserving shape, precision and control-flow information.
02
→OPTIMIZE
Apply constant folding, fusion, layout conversion, precision policy and graph rewrites.
03
→MAP
Place data and compute around cores, on-chip memory, bandwidth and topology.
04
GENERATE
Produce runtime plans, kernel calls and single- or multi-device programs.
Multiple frontends
A consistent ingestion layer is planned for PyTorch, JAX, ONNX and TensorFlow. Coverage will be governed by a compatibility matrix.
Multi-level IR
Separate framework semantics, tensor optimization, dataflow planning and kernel code generation for clarity and extensibility.
Hardware-aware optimization
Plan on-chip reuse, communication overlap, batching and parallel partitioning around the target system.
HOLYFLOW NN
Familiar high-level APIs. Inspectable execution detail.
Python and C++ libraries provide common neural-network operations, fused modules and model components. The default path prioritizes usability; the optimization path exposes layout, precision, parallelism and memory placement.- Tensor, attention, convolution, normalization and collective operators
- Automatic selection of validated kernels and fused implementations
- Explicit control of format, math fidelity and memory hierarchy
- Extension and fallback paths for custom operators
model.pyILLUSTRATIVE API
import holyflow as hf
model = hf.load("model.onnx")
target = hf.device("nova-n200")
program = hf.compile(
model,
target=target,
precision="mixed"
)
result = program.run(inputs)HOLYFLOW KERNEL
When common operators are not enough, design the dataflow directly.
The low-level SDK is for teams building custom operations, fusing critical paths or researching new algorithms. Host programs, device kernels, buffers and synchronization remain explicit.Data-movement kernel
Read external and on-chip memory, transforming data into target layouts and circular buffers.
Matrix and vector kernel
Execute matrix, vector, scalar and reduction work while overlapping data movement.
Result kernel
Convert, synchronize and write results for the next operator or device.
BEGINNER
High-level operators
Use the default HOLYFLOW NN Python API and let the stack select kernels.
INTERMEDIATE
Explicit optimization
Choose fusion, layout, precision, batching, parallelism and storage policy.
ADVANCED
Custom kernels
Author data-movement and compute kernels in C++/DSL and register them with the operator library.
HOLYFLOW RUNTIME
Take one program, across many devices.
The runtime owns devices, memory, queues, synchronization and communication while presenting one execution boundary to the compiler.Devices and topology
Discover cards, nodes and links to build a logical grid for single-card, multi-card and cluster execution.
Memory and data
Manage allocation, transfer, reuse and lifetime across host, device and on-chip storage.
Queues and synchronization
Schedule kernels, events and dependencies while overlapping compute, communication and movement.
Multi-device communication
Provide broadcast, reduction and all-gather operations adapted to the target topology.
Health and recovery
Connect device state, error reporting, retries and fault-isolation strategy.
Unified telemetry
Place model, runtime and device metrics on one correlated timeline.
HOLYFLOW STUDIO
See the system, before optimizing it.
The toolchain brings model graph, compilation decisions, memory behavior, kernel time and multi-device communication into one analysis workflow.INPUTATTENTIONMLPOUTPUT
CORE UTILIZATION—Pending validation
MEMORY PRESSURE—Pending validation
COMM / COMPUTE—Pending validation
Graph Explorer
Inspect subgraphs, operator mapping, fusion boundaries and compiler transformations.
Profiler
Correlate host, runtime, kernel, memory and communication timelines.
Numerics
Compare references, precision policy and layer-by-layer error propagation.
System Monitor
Observe temperature, power, links, errors and device health.
HOLYFLOW DEPLOY
Compilation is not the end of the work.
Production also requires packaging, service interfaces, versioning, observability and device lifecycle. HOLYFLOW Deploy is planned to connect them into one release path.PACKAGE
Lock model, compiler output, runtime version, target device and validation evidence.
SERVE
Run models in containers or local services, with planned integration for common inference APIs.
ORCHESTRATE
Place, scale and roll out across servers, clusters and edge fleets.
OBSERVE
Connect request, model, runtime and hardware signals into an end-to-end service view.
AETHER
Cloud and cluster
Container services, scheduling, multi-node telemetry and capacity operations.
NOVA
Datacenter node
Single- or multi-card serving, enterprise platform integration and dedicated pools.
SPARK
Edge fleet
Offline execution, signed versions, staged updates, rollback and field health.
CHOOSE YOUR ENTRY
Start at the right abstraction level.
The same stack provides different entry points for model developers, performance engineers, kernel developers and platform teams.Run an existing model
Begin with ingestion, compatibility, compilation and correctness validation.
Compiler → NN → RuntimeOptimize the critical path
Inspect graph, memory and timeline, changing only the actual hotspots.
Studio → NN → CompilerImplement a new operator
Author data-movement and compute kernels, then register them with the library.
Kernel → Runtime → NNOperate in production
Connect compiler output with serving, scheduling, telemetry and releases.
Deploy → Runtime → FleetAVAILABILITY & RESOURCES
Make the maturity of every capability clear.
Platform architecture and programming modelAvailable now
This page documents the planned HOLYFLOW layers, responsibilities and boundaries.
Model and operator compatibilityJoint validation
Track status by model, precision, hardware and software version.
SDK, documentation and examplesPlanned release
Installation, APIs, tutorials, kernels, tools and release notes.
Production deployment componentsPlanned release
Serving, containers, cluster integration, edge updates and operations.
SOFTWARE FAQ
Questions to answer early in evaluation.
Is HOLYFLOW a single SDK?+
No. It is a layered system covering compiler, operator libraries, runtime, kernels, tools and deployment, connected through explicit interfaces.
Can an existing model move directly?+
Mainstream frameworks and open formats are the planned entry points, but actual readiness depends on the model, operators, dynamic shapes, precision and target hardware.
Can teams write custom operators?+
Custom operators and kernels are central to the HOLYFLOW Kernel direction, with planned integration into high-level libraries, compilation and performance tools.
How does joint validation start?+
Bring the model, input shapes, accuracy baseline, throughput or latency target, deployment environment and current dependencies, then define a staged validation plan.
READY TO BUILD?