Skip to content

Build Not yet confirmed elsewhere1 publisher 2 min read Published

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

How we use AI Send a correction

Illustration accompanying IBM replaced Spyre's from-scratch sendnn compiler with Inductor extensions about 7x smaller
Generated illustration

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
Why these scores

Claim ledger

Ranked by verification strength, evidence, and original report placement.

  1. [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.

    Reported Supported Source: IBM/PyTorch blog post, 'Extending Inductor for the IBM Spyre Accelerator'View cited source
  2. [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.

    Reported Supported Source: IBM/PyTorch blog postView cited source
  3. [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.

    Reported Supported Source: IBM/PyTorch blog postView cited source

Sources

1 independent publisher whose own reporting we read for this story.

  1. pytorch.org

    1 article · October 13, 2026

    Extending Inductor for the IBM Spyre Accelerator

Share your take

Let Clarity write the post for you.

Signed-in readers get a short post drafted on this story in the register they choose — narrative, analytical, or a direct position — editable to the last word before it goes anywhere. The share buttons at the top of this story work without an account.

Topics and entities

Follow any of these and your For You feed starts watching them — no settings page required.

Topics

Entities

Loading related stories