Pith. sign in

REVIEW 2 major objections 3 minor 26 references

Meganeura: Portable GPU Training and Inference through Vulkan and Metal

T0 review · 2 major / 3 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A 34-KLOC compiler trains and deploys models through Vulkan and Metal on five consumer GPUs, reaching parity or better with vendor-compiled stacks on most AMD cells.

desk verdict A refreshingly honest systems paper that makes a credible case for a compact Vulkan/Metal train-to-deploy stack, with a real but acknowledged gap in backward-correctness evidence. read the letter →

arxiv 2608.01563 v1 pith:HYIA2PLY submitted 2026-08-03 cs.LG cs.DCcs.PL

Dzmitry Malyshau This is my paper
classification cs.LGcs.DCcs.PL
keywords GPUtrainingVulkanMetalportablecompilerautomaticdifferentiationstaticgraphperformanceportabilityon-devicedeployment
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper tries to establish that one compact compiler can span both training and deployed inference on consumer GPUs using only the general graphics APIs Vulkan and Metal, without a CUDA, ROCm, or Python runtime. It presents Meganeura, a roughly 34.5-KLOC Rust system whose typed static graph, automatic differentiation, optimizer, checkpoint, memory planner, and runtime generate specialized WGSL shaders and execute them through a portable graphics backend. Against the PyTorch reference across five devices, Meganeura wins 12 of 20 strict-f32 minimal-latency cells, reaches parity or better on most AMD workloads (four of five inference cells within 1.10x of compiled ROCm PyTorch on the discrete card, three training cells faster), and compiles workloads in 0.1–2.4 seconds versus 6–96 seconds for torch.compile. Forty-eight of 50 device-workload-mode cells pass independent forward and backward correctness gates. The paper argues the remaining gaps are attributable to kernel coverage, scheduling, and arithmetic policy rather than to any identified limitation of the graphics APIs.

What carries the argument

The load-bearing mechanism is Meganeura's shared compilation pipeline: a typed static graph with mid-level operations, followed by graph rewriting, reverse-mode autodiff, shape- and capability-aware code generation into a small set of kernel archetypes (pointwise chains, workgroup reductions, matrix products with cooperative-matrix tiles, implicit-GEMM convolutions and their derivatives, and tiled attention), then a memory planner that aliases step-local buffers by lifetime, and a static dispatch plan executed through Vulkan and Metal. A precision bit on derivative regions keeps backward computation in f32 while forward matrices may use reduced precision. The static plan removes host launch and graph-capture overhead at minimal batch sizes, which the paper credits for the latency wins.

What would settle it

Run the frozen 50-cell protocol on additional devices and workloads, or produce a third implementation of the Whisper backward pass on the AMD APU. If the reference's gradient norms are confirmed by the third implementation and Meganeura's are the outlier, the two failed gates become Meganeura's errors rather than a reference-path anomaly; and if new devices show large uniform training gaps far beyond the 4.6x worst case, the 'no API limitation' conclusion would fail.

Watch

Extended reading notes

Core claim

The core claim is that general consumer graphics APIs are a sufficient substrate for a compact shared train-to-deploy ML stack: the same graph, autodiff, optimizer, checkpoint format, memory plan, and runtime can serve both training and inference at practical, sometimes vendor-competitive performance. The evidence is the frozen benchmark matrix: 48 of 50 cells pass both forward and backward gates; the two exceptions are the Whisper backward comparison on the newest AMD APU, where Meganeura's gradients match its own discrete-GPU result while the reference's gradients shift between its two ROCm machines, implicating the reference path. In strict f32, Meganeura is faster in 12 of 20 GPU-referenced minimal-latency cells and has a median valid training gap of 1.8x, with convolution-heavy ResNet-50 as the main outlier. The paper's own framing is that where kernel coverage matches the workload, parity appears; where it does not, the losses are profiled to specific kernel families.

Load-bearing premise

The conclusions are drawn from five workloads that are partially simplified (a scaled-down U-Net not compatible with Stable Diffusion 1.5, Whisper without its decoder, ResNet with folded batch norm), one machine per vendor class except AMD, and no Windows measurement; if those workloads and devices are not representative of real consumer training and inference, the portability claim overstates what the measurements support.

Editorial extensions

If this is right

  • A native application can train or fine-tune on the deployed device and reuse the same compiler/runtime for inference, so live adaptation and personalization no longer require an export/conversion round trip.
  • Sub-second compilation makes compile-on-device practical: a shipped app can specialize a model at first launch instead of shipping a precompiled cache or stalling for a minute.
  • Deployment closure drops to a roughly 13 MiB stripped binary with no Python or vendor compute-runtime dependency, lowering the cost of embedding ML in games, robotics, and XR.
  • Portable minimal-batch latency beats the vendor reference on most devices, suggesting graphics-API stacks are not inherently launch-bound for small shapes.
  • Remaining performance gaps can be chased as concrete engineering targets—convolution derivatives, Metal attention backward, barrier elision, and cost-model-gated cooperative-matrix promotion—rather than accepted as an API tax.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If the portability result holds beyond the five frozen devices, the split train/deploy stack (framework and vendor runtime on one side, converter plus device-specific runtime on the other) may be replaceable by one compiler for a broad class of static-shape edge applications.
  • The unresolved Whisper backward disagreement on the new APU could be settled by implementing the same workload in a third independent engine; whichever path matches the other two identifies the buggy one.
  • The negative result for equality saturation suggests the rewrite space of a compact mid-level graph is shallow enough that a deterministic greedy fixed point suffices; more global search may matter only for much lower-level or much larger IRs.
  • The dynamic-residency cost (Meganeura holds the step's high-water memory plan) suggests a natural next test: an incremental memory planner that releases activations as backward consumes them, trading allocation complexity for lower peak memory.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 3 minor

Summary. The paper presents Meganeura, a compact Rust-based compiler and runtime that lowers a typed static ML graph through Vulkan and Metal and supports both inference and training (autodiff, SGD/Adam updates, checkpointing). The authors benchmark five workload families against PyTorch on five machines (NVIDIA discrete, AMD discrete and APU, Intel iGPU, Apple M3) under two arithmetic contracts, with frozen revision pairs, raw timing samples, and independent forward and backward correctness gates. They report 48 of 50 device–workload–mode cells passing both gates, the two exceptions being the same Whisper backward comparison on the AMD 780M in both arithmetic modes; strict-mode latency wins in 12 of 20 GPU-referenced minimal cells; near-parity or better with compiled ROCm PyTorch on the discrete AMD GPU; compilation in 0.08–2.4 s versus 6–96 s for torch.compile; a 13 MiB stripped binary; and a physical Android XR deployment sharing the graphics queue. The conclusion is that general consumer graphics APIs can support a compact shared train-to-deploy stack, with remaining gaps attributed to kernel coverage, scheduling, and arithmetic policy rather than to an identified API limitation.

Significance. If the results hold, this is a genuinely useful systems contribution: controlled evidence that a single small compiler can span training and inference across vendor GPU APIs without CUDA, ROCm, or a Python runtime. The methodology is unusually careful: frozen revisions, raw samples, separate strict and accelerated contracts, independent forward and backward gates, and explicit basis labels for memory figures. The paper also ships regeneration scripts and raw JSON artifacts, reports negative results (equality saturation, direct Naga-IR authoring) without overclaiming, and handles the two anomalous APU cells honestly, including scoring itself zero in the Pennycook aggregate for the invalid Whisper cell. The DinoVision physical-device study is a concrete deployment-closure demonstration. The main risks are that the headline claim is broader than the five simplified workload families and five machines, and that backward-correctness evidence is norm-based and can miss elementwise gradient errors; both are acknowledged in Section 10 but need to be reflected in the manuscript's claims.

major comments (2)
  1. [Section 4.3 and Section 10] The load-bearing correctness evidence for training is the backward gate of Section 4.3, which accepts a cell when total-gradient-norm error is below 5% and the L2 error over per-parameter gradient norms is below 5%. Norm-based gates cannot detect elementwise cancellation inside a parameter tensor: a backward pass with large per-element errors can still pass if the norms agree. This matters because the paper's central claim is a shared train-to-deploy stack, and the '48 of 50 cells pass both gates' result, the DinoVision training run of Section 5.2, and the Whisper precision repair of Section 4.2 all presuppose that the backward pass is correct at the element level. Section 10 concedes exactly this: 'Gradient-norm gates can miss elementwise cancellation; the artifact should add sampled or full gradient vector comparisons where memory permits.' I recommend that the artifact be extended with sampled or full gradient-vector comparisons for at least the strict-mode cells and the DinoVision check, or that the manuscript explicitly limit the correctness claim to norm-level agreement and soften the abstract accordingly.
  2. [Abstract, Section 1, Section 10] The abstract's concluding claim — 'general consumer graphics APIs can support a compact shared train-to-deploy stack at useful, sometimes vendor-competitive performance' — generalizes from a deliberately small matrix: five workload families, several of which are simplified (scaled diffusion U-Net, Whisper without decoder, ResNet with folded batch norm), one machine per vendor class except AMD, and no measured Windows device. Section 10 states these limits, but the abstract and the phrase 'general consumer graphics APIs' are not so qualified. Either add workload or device breadth before publication, or rephrase the headline to 'on the audited workloads and devices, consumer graphics APIs can support...' so the external-validity caveat is part of the claim being made.
minor comments (3)
  1. [Table 6] Several numeric cells in Table 6 are run together without separators (for example, '3.210.9047.00' and '2.730.83'), which makes the ratio columns very hard to read; please add explicit column separators and ensure the ratio columns are labeled consistently.
  2. [Section 5.9] The cross-device evidence that 'strongly implicates the reference path' for the 780M Whisper backward cell is suggestive rather than conclusive, as the paper itself says; consider adding a pointer to the exact artifact rows so a reader can independently verify the 16.3% PyTorch cross-machine norm difference.
  3. [Section 10] The statement that the eager-only Apple reference makes Apple ratios 'generous to Meganeura' is clear, but the same asymmetry is not mentioned in the abstract; a brief clause there would help readers who do not reach Section 10.

Circularity Check

0 steps flagged · score 1.0 of 10

No significant circularity: the central benchmark is externally referenced, and the only self-citation is explicitly non-load-bearing.

full rationale

The paper's load-bearing claim—that a compact Vulkan/Metal stack can span training and inference at useful, sometimes vendor-competitive performance—is an empirical benchmark claim, not a derivation. Every table cell is gated against an external reference (PyTorch) with matched workloads, frozen revisions, raw samples, and explicit arithmetic contracts (Section 4). The paper does not fit a parameter to a subset of data and then rename the fit as a prediction; the only fitted-looking step, the Whisper precision repair in Section 4.2, is a correctness fix validated against the external reference and reported as a repair, not as a predicted result. The 48-of-50 gate outcome and the invalid-cell treatment in Sections 5.8–5.9 are self-consistent with the protocol: the one anomalous backward comparison is scored zero rather than used to certify Meganeura, and the paper explicitly asks for a third implementation. The only self-citation is the companion Blade study [9], used in Sections 3.4 and 7.3 to attribute barrier costs and "demonstrated headroom" for future barrier elision; Section 7.3 explicitly says those measurements predate the current Blade and are cited "as demonstrated headroom rather than as a gain this stack currently banks." That is a minor, non-load-bearing self-citation. The Section 10 admission that "Gradient-norm gates can miss elementwise cancellation" is a real validity limitation of the backward check, and Section 4.2 shows forward agreement alone did not bound training error; but a coarse measurement gate is not a circular derivation—the paper does not use the gate as the proof of any predicted quantity, and it flags the needed improvement. Overall, no step reduces to its own input; score 1 reflects only the non-load-bearing self-citation.

Assumptions & free parameters 4 free parameters · 3 assumptions · 0 invented entities

The evaluation relies on hand-selected thresholds and a small workload set rather than on fitted parameters or newly postulated physical entities. All thresholds are stated in Section 4.3, workload choices in Section 4.1, and the paper's own limitations section (Section 10) enumerates the coverage risks. No invented entities are introduced; Meganeura and Inferena are public software artifacts, not theoretical constructs.

free parameters (4)
  • Forward correctness gate thresholds = relative L2 < 1%, symmetric relative loss error < 1%
    Hand-chosen in Section 4.3; these thresholds define whether a forward cell 'passes', directly determining the reported 48/50 count.
  • Backward correctness gate thresholds = total-gradient-norm error < 5%, per-parameter gradient-norm L2 < 5%
    Hand-chosen in Section 4.3; the two invalid cells are determined by these gates, so the headline validation statistic depends on them.
  • Competitive threshold = median no more than 2x PyTorch median
    Hand-chosen in Section 4.3 to make qualitative language like 'competitive' falsifiable; it shapes the parity claims in the abstract.
  • Workload scales and reductions = diffusion scaled to 10.93M params, Whisper encoder-only, ResNet folded BN
    Hand-chosen simplifications in Section 4.1 that make the workload set tractable; they bound the representativeness of the measured coverage and are listed in the paper's own limitations.
assumptions (3)
  • domain assumption PyTorch with vendor backends is a valid performance and numerical reference for the compared runs.
    Section 4 uses PyTorch as the reference; across devices it runs compiled CUDA/ROCm, eager MPS, or CPU fallback, so the reference is not uniform and is treated as authoritative for the gates.
  • domain assumption Driver-reported device capabilities (cooperative matrix support, GPU timestamps, memory budgets) are accurate and consistent.
    Section 5.4 and Section 4.3 rely on driver-reported capabilities to explain when the accelerated path engages and to compute per-dispatch profiles; if drivers misreport, those explanations weaken.
  • domain assumption The five matched workloads and two arithmetic modes are representative of common training and inference deployment workloads.
    Defined in Section 4.1 and acknowledged in Section 10 as a threat to validity; the paper's general conclusion about consumer graphics APIs rests on this set.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Meganeura: Portable GPU Training and Inference through Vulkan and Metal." pith.science (2026). https://pith.science/paper/HYIA2PLY

@misc{pith2026260801563,
  author       = {Pith},
  title        = {Pith review of: Meganeura: Portable GPU Training and Inference through Vulkan and Metal},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/HYIA2PLY}},
  note         = {Machine review of arXiv:2608.01563}
}
read the original abstract

Training and deployed inference often cross export, conversion, and platform-specific runtime boundaries. Meganeura asks whether one compact native compiler can span both phases on consumer GPUs. Its typed static graph, automatic differentiation, optimizer, checkpoint, memory planner, and runtime lower specialized programs through Vulkan and Metal. We compare five matched workloads with PyTorch on NVIDIA and AMD discrete GPUs, an AMD APU, Apple silicon, and an Intel iGPU. The protocol separates strict f32 from validated fast paths and gates forward and backward independently. Forty-eight of 50 device-workload-mode cells pass both gates; the other two share one unresolved backward-reference disagreement on a newly supported APU. In strict f32, Meganeura wins 12 of 20 GPU-referenced minimal-latency cells and has a median valid training gap of 1.8x. On the discrete AMD GPU, four of five inference workloads are within 1.10x of compiled ROCm PyTorch and three training workloads are faster. Under accelerated contracts, the worst training gap is 4.6x. Compilation takes 0.1-2.4 seconds versus 6-96 seconds for torch.compile on supported GPU paths; the stripped binary is 13 MiB. Dispatch profiles localize the largest gaps to convolution derivatives and attention backward. A physical Android XR case study transfers a Meganeura-trained decoder into an Adreno/OpenXR application sharing the graphics queue. The results show that general consumer graphics APIs can support a compact shared train-to-deploy stack at useful, sometimes vendor-competitive performance. The measured gaps point to kernel coverage, scheduling, and arithmetic policy rather than an identified API limitation.

Figures

Figures reproduced from arXiv: 2608.01563 by the authors.

Figure 1
Figure 1. The systems question. A conventional train/deploy boundary can split one model into several runtime [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. The shared training and inference compilation [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Quest 3S casting capture of DinoVision’s live [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: Strict-f32 Meganeura/PyTorch median ratios for all 25 device–workload cells (log scale; the solid line is [PITH_FULL_IMAGE:figures/full_fig_p010_4.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

26 extracted references · 18 canonical work pages

  1. [1]

    TVM: An automated end-to-end optimizing compiler for deep learning

    Tianqi Chen, Thierry Moreau, Ziheng Jiang, Lianmin Zheng, Eddie Yan, Haichen Shen, Meghan Cowan, Leyuan Wang, Yuwei Hu, Luis Ceze, Carlos Guestrin, and Arvind Krishnamurthy. TVM: An automated end-to-end optimizing compiler for deep learning. In 13th USENIX Symposium on Operating Systems De- sign and Implementation (OSDI 18), pages 578–594. USENIX Associat...

    work page 2018

  2. [2]

    Deep residual learning for image recognition

    Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. InProceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 770–778, 2016. 7https://github.com/kvark/meganeura 8https://github.com/kvark/inferena

    work page 2016

  3. [3]

    TASO: Optimizing deep learning computation with automatic generation of graph substitutions

    Zhihao Jia, Oded Padon, James Thomas, Todd Warszawski, Matei Zaharia, and Alex Aiken. TASO: Optimizing deep learning computation with automatic generation of graph substitutions. InProceedings of the 27th ACM Symposium on Operating Systems Prin- ciples, pages 47–62, 2019

    work page 2019

  4. [4]

    MLIR: Scaling compiler infrastructure for domain specific computation

    Chris Lattner, Mehdi Amini, Uday Bondhugula, Al- bert Cohen, Andy Davis, Jacques Pienaar, River Rid- dle, Tatiana Shpeisman, Nicolas Vasilache, and Olek- sandr Zinenko. MLIR: Scaling compiler infrastructure for domain specific computation. In2021 IEEE/ACM International Symposium on Code Generation and Optimization (CGO), pages 2–14, 2021

    work page 2021

  5. [5]

    Llamas on the web: Memory-efficient, performance-portable, and multi- precision llm inference with WebGPU.arXiv preprint arXiv:2605.20706, 2026

    Reese Levine, Rithik Sharma, Nikhil Jain, Abhi- jit Ramesh, Zheyuan Chen, Neha Abbas, James Contini, and Tyler Sorensen. Llamas on the web: Memory-efficient, performance-portable, and multi- precision llm inference with WebGPU.arXiv preprint arXiv:2605.20706, 2026

    arXiv 2026

  6. [6]

    On-device training under 256KB memory

    Ji Lin, Ligeng Zhu, Wei-Ming Chen, Wei-Chen Wang, Chuang Gan, and Song Han. On-device training under 256KB memory. InAdvances in Neural Information Processing Systems, volume 35, 2022

    work page 2022

  7. [7]

    TinyIREE: An ML execution environment for embedded systems from compilation to deployment

    Hsin-I Cindy Liu, Marius Brehler, Mahesh Ravis- hankar, Nicolas Vasilache, Ben Vanik, and Stella Lau- renzo. TinyIREE: An ML execution environment for embedded systems from compilation to deployment. IEEE Micro, 42(5):9–16, 2022

    work page 2022

  8. [8]

    Characterizing WebGPU dispatch overhead for LLM inference across four GPU vendors, three backends, and three browsers.arXiv preprint arXiv:2604.02344, 2026

    Jędrzej Maczan. Characterizing WebGPU dispatch overhead for LLM inference across four GPU vendors, three backends, and three browsers.arXiv preprint arXiv:2604.02344, 2026

    arXiv 2026

Show all 26 references
  1. [9]

    Global pass barriers without per- resource RHI tracking: A cross-vendor study with Blade

    Dzmitry Malyshau. Global pass barriers without per- resource RHI tracking: A cross-vendor study with Blade. arXiv:2607.26506, 2026

    2026 arXiv

  2. [10]

    ExecuTorch: A unified PyTorch solution to run AImodelson-device.arXiv preprint arXiv:2605.08195, 2026

    Mergen Nachin, Digant Desai, Sicheng Stephen Jia, et al. ExecuTorch: A unified PyTorch solution to run AImodelson-device.arXiv preprint arXiv:2605.08195, 2026

    2026 arXiv

  3. [11]

    PyTorch: An impera- tive style, high-performance deep learning library

    Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu ...

    2019

  4. [12]

    Pennycook, Jason D

    Simon J. Pennycook, Jason D. Sewall, and Victor W. Lee. A metric for performance portability. InPro- ceedings of the 7th International Workshop in Per- 17 formance Modeling, Benchmarking and Simulation of High Performance Computer Systems (PMBS), 2016

    2016

  5. [13]

    Robust speech recognition via large-scale weak supervision

    Alec Radford, Jong Wook Kim, Tao Xu, Greg Brock- man, Christine McLeavey, and Ilya Sutskever. Robust speech recognition via large-scale weak supervision. arXiv preprint arXiv:2212.04356, 2022

    2022 arXiv

  6. [14]

    High- resolution image synthesis with latent diffusion mod- els

    Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Björn Ommer. High- resolution image synthesis with latent diffusion mod- els. InProceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 10684–10695, 2022

    2022

  7. [15]

    Glow: Graph lowering com- piler techniques for neural networks.arXiv preprint arXiv:1805.00907, 2018

    Nadav Rotem, Jordan Fix, Saleem Abdulrasool, Gar- ret Catron, Summer Deng, Roman Dzhabarov, Nick Gibson, James Hegeman, Meghan Lele, Roman Lev- enstein, Jack Montgomery, Bert Maher, Satish Na- dathur, Jakob Olesen, Jongsoo Park, Artem Rakhov, and Misha Smelyanskiy. Glow: Graph...

    2018 arXiv

  8. [16]

    Ruan, Yucheng Qin, Akaash R

    Charlie F. Ruan, Yucheng Qin, Akaash R. Parthasarathy, Xun Zhou, Ruihang Lai, Hongyi Jin, Yixin Dong, Bohan Hou, Meng-Shiun Yu, Yiyan Zhai, Sudeep Agarwal, Hangrui Cao, Siyuan Feng, and Tianqi Chen. WebLLM: A high-performance in-browser LLM inference engine.arXiv preprint arXi...

    2024 arXiv

  9. [17]

    SmolVLA: A vision- language-action model for affordable and efficient robotics.arXiv preprint arXiv:2506.01844, 2025

    Mustafa Shukor, Dana Aubakirova, Francesco Ca- puano, Pepijn Kooijmans, Steven Palma, Adil Zoui- tine, Michel Aractingi, Caroline Pascal, Martino Russi, Andres Marafioti, Simon Alibert, Matthieu Cord, Thomas Wolf, and Remi Cadene. SmolVLA: A vision- language-action model for a...

    2025 arXiv

  10. [18]

    Nathaniel Simard, Louis Fortier-Dubois, Dilshod Tad- jibaev, Guillaume Lagrange, and Burn Framework Contributors. Burn. Software, version 0.21.0, 2026

    2026

  11. [19]

    Oriane Siméoni, Huy V. Vo, Maximilian Seitzer, Fed- erico Baldassarre, Maxime Oquab, Cijo Jose, Vasil Khalidov, Marc Szafraniec, Seungeun Yi, Michaël Ra- mamonjisoa, Francisco Massa, Daniel Haziza, Luca Wehrstedt, Jianyuan Wang, Timothée Darcet, Théo Moutakanni, Leonel Sentana...

    2025 arXiv

  12. [20]

    Gupta, Sarah Sirajuddin, D

    Daniel Smilkov, Nikhil Thorat, Yannick Assogba, Ann Yuan, Nick Kreeger, Ping Yu, Kangyi Zhang, Shan- qing Cai, Eric Nielsen, David Soergel, Stan Bileschi, Michael Terry, Charles Nicholson, Sandeep N. Gupta, Sarah Sirajuddin, D. Sculley, Rajat Monga, Greg Corrado, Fernanda B. V...

    2019

  13. [21]

    Pure tensor pro- gram rewriting via access patterns

    Gus Henry Smith, Andrew Liu, Steven Lyubomirsky, Scott Davidson, Joseph McMahan, Michael Taylor, Luis Ceze, and Zachary Tatlock. Pure tensor pro- gram rewriting via access patterns. InProceedings of the 5th ACM SIGPLAN International Symposium on Machine Programming, 2021

    2021

  14. [22]

    Philippe Tillet, H. T. Kung, and David Cox. Triton: An intermediate language and compiler for tiled neu- ral network computations. InProceedings of the 3rd ACM SIGPLAN International Workshop on Machine Learning and Programming Languages, pages 10–19, 2019

    2019

  15. [23]

    egg: Fast and extensible equality saturation.Pro- ceedings of the ACM on Programming Languages, 5(POPL), 2021

    Max Willsey, Chandrakana Nandi, Yisu Remy Wang, Oliver Flatt, Zachary Tatlock, and Pavel Panchekha. egg: Fast and extensible equality saturation.Pro- ceedings of the ACM on Programming Languages, 5(POPL), 2021

    2021

  16. [24]

    Equal- ity saturation for tensor graph superoptimization

    Yichen Yang, Phitchaya Phothilimthana, Yisu Wang, Max Willsey, Sudip Roy, and Jacques Pienaar. Equal- ity saturation for tensor graph superoptimization. In Proceedings of Machine Learning and Systems, vol- ume 3, 2021

    2021

  17. [25]

    RAF: Holistic compilation for deep learning model training.arXiv preprint arXiv:2303.04759, 2023

    Cody Hao Yu, Haozheng Fan, Guangtai Huang, Zhen Jia, Yizhi Liu, Jie Wang, Zach Zheng, Yuan Zhou, Haichen Shen, Junru Shao, Mu Li, and Yida Wang. RAF: Holistic compilation for deep learning model training.arXiv preprint arXiv:2303.04759, 2023

    2023 arXiv

  18. [26]

    Better together: Unifying data- log and equality saturation

    Yihong Zhang, Yisu Remy Wang, Oliver Flatt, David Cao, Philip Zucker, Eli Rosenthal, Zachary Tatlock, and Max Willsey. Better together: Unifying data- log and equality saturation. InProceedings of the 44th ACM SIGPLAN Conference on Programming Language Design and Implementatio...

    2023

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.