IBM replaced Spyre's from-scratch sendnn compiler with Inductor extensions about 7x smaller
IBM moved Spyre's torch.compile backend from its from-scratch sendnn stack to an Inductor extension that IBM puts at roughly 7x smaller. The figure is IBM's own, and the port still needed substantial out-of-tree extensions at Inductor's lower levels and in code generation.
The Engineer · Build desk

What happened
- Spyre has 32 small cores on a ring, each with a local 2 MB scratchpad instead of a shared cache, and it moves data in 128-byte sticks.
- Only the first of two compiler stages runs on Inductor; the second, a proprietary compiler called DeepTools, turns SuperDSC into hardware instructions.
- CustomPreSchedulingPasses is attached through a monkey-patch on GraphLowering.codegen() instead of a first-class extension hook.
- IBM says it is working with upstream PyTorch to formalize the extension points it relied on most, so other out-of-tree backends can use them.
Why it matters
- constraint Any backend whose passes must rewrite the graph at scale before scheduling cannot use _pre_fusion_custom_pass and would need a GraphLowering patch like IBM's until upstream adds a hook.
- cost Adopting Inductor for a new accelerator buys a smaller compiler but costs out-of-tree code at the lower levels and in code generation, plus upkeep on a patched internal method.
- decision A team targeting another dataflow chip now has to choose between patching GraphLowering as IBM did and waiting for upstream to formalize the hook.
The 7x needs a denominator. The post describes sendnn as a separate compilation stack built entirely from scratch [1] and puts the size gain at roughly 7x [11]. If that is a size ratio, the new compiler is about 14 percent of the old one [15]. The summary does not say what the 7x counts, and the Inductor extensions are only the first of two stages [5]. For the number to transfer to another accelerator, that chip would need a second-stage compiler maintained by someone else, and its hardware would need to depart from Inductor's assumptions in as few places as Spyre's does. The post points to code-size numbers in its Evaluation section as the measure of the leverage [13].
Thirty-two cores with 2 MB scratchpads each add up to 64 MB of on-chip storage [10]. The post says the work concentrated where the dataflow design diverges from the GPU-shaped assumptions in Inductor: how Spyre moves data, manages on-chip storage and distributes work to cores [4]. In our view that follows from the layout. Each scratchpad is local to its core, so something has to decide what sits in which one. The post says tiling, layout assignment, work division and scratchpad allocation are decided in CustomPreSchedulingPasses [6].
That pass set needs to run early. Inductor's own _pre_fusion_custom_pass runs only after LoopLevelIR has been turned into SchedulerNodes, and Inductor does not support rewriting the graph at scale once those nodes exist [7]. Torch-spyre's passes need that kind of rewriting, so CustomPreSchedulingPasses hooks GraphLowering one step earlier, before Inductor commits to SchedulerNodes [9]. A monkey-patch is a fair description of a hook that does not exist yet. We'd expect every Inductor release to be a possible break until upstream formalizes one, because the patch depends on GraphLowering.codegen() keeping its name and signature.
IBM's post says Inductor "turned out to be exactly the right substrate for this work" [14]. The post also says: "Most of Inductor just worked." [12] Both statements fit the same facts. The reusable part is large, and the part that is not reusable sits at the lowest levels, where an accelerator's memory model shows up.
What the evidence shows is one team porting its own chip and reporting its own size figure. We think the general case, that Inductor can anchor compilers for non-GPU dataflow accelerators, is plausible and unproven. It firms up if the upstream hooks land and a second vendor reports a comparable port.
What to watch
- Whether upstream PyTorch adds a first-class hook at the point CustomPreSchedulingPasses uses, replacing the GraphLowering.codegen() monkey-patch.
- What the code-size numbers in the post's Evaluation section count, including whether the out-of-tree extensions and the DeepTools stage are in the 7x.
- Whether a second non-GPU accelerator vendor reports a comparable Inductor port with its own size figures.
Clarity's read
What the record supports and how the coverage leans. The claims behind it follow.
Reality
- Evidence50
- Adoption
- Insufficient
- Hype gap+15
- Incentives
- Insufficient
- Confidence60
Claim ledger
Ranked by verification strength, evidence, and original report placement.
- [1]
The PyTorch-based software stack for IBM's Spyre accelerator moved its torch.compile backend from sendnn, a separate compilation stack built entirely from scratch, to backend=inductor, an open-source backend built by extending PyTorch's own Inductor.
- [2]
Spyre is built from 32 small cores wired together over a ring, each with its own local 2 MB scratchpad rather than a shared cache, and it moves data in fixed-size chunks called sticks of 128 bytes, or 64 fp16 values.
- [3]
IBM still needed substantial out-of-tree extensions at Inductor's lower levels and in code generation, and the post says the move was not a drop-in swap.
- [4]
The effort concentrated on a small number of places where Spyre's dataflow design diverges from GPU-shaped assumptions built into Inductor: how Spyre moves data around, manages on-chip storage, and distributes work to cores.
- [5]
Torch-spyre's compiler has two stages: Inductor extensions lower a torch.compile'd graph to an intermediate representation called SuperDSC, and a proprietary compiler called DeepTools translates SuperDSC into instructions for the Spyre hardware. The post focuses on the first stage.
- [6]
CustomPreSchedulingPasses is where tiling, layout assignment, work division and scratchpad allocation get decided, and it is wired in today via a monkey-patch on Inductor's GraphLowering.codegen() rather than a first-class extension hook.
- [7]
Inductor's own hook _pre_fusion_custom_pass only runs after LoopLevelIR has been turned into SchedulerNodes, and Inductor does not support rewriting the graph at scale once those nodes exist.
- [8]
IBM is working with the upstream PyTorch project to formalize the extension points it leaned on most heavily, so other out-of-tree hardware backends can benefit from the same leverage.
- [9]
Torch-spyre's passes need large-scale graph rewriting, so CustomPreSchedulingPasses hooks GraphLowering one step earlier, before Inductor has committed to SchedulerNodes.
- [10]
Total on-chip scratchpad across Spyre's cores is 64 MB.
- [11]
The post says the result is a compiler roughly 7x smaller than what it replaced.
- [12]
"Most of Inductor just worked."
- [13]
The post says the leverage from Inductor is concrete enough to measure and points to code-size numbers in its Evaluation section.
- [14]
The post says Inductor "turned out to be exactly the right substrate for this work".
- [15]
If the 7x figure is a size ratio, the new compiler is about 14 percent of the size of sendnn.
Sources
1 independent publisher whose own reporting we read for this story.
- pytorch.orgExtending Inductor for the IBM Spyre Accelerator
1 article · October 13, 2026
Topics and entities
Follow any of these and your For You feed starts watching them — no settings page required.
Topics
- PyTorch ecosystemFollow
- AI AcceleratorsFollow
- ML compilers and kernelsFollow