mrkeyoor.com_
Fri 16 Oct 18:53 UTC
AI Toolsevaluationupdated 07 Oct 2026

tinygrad review

tinygrad is a Python tensor library, automatic differentiation engine, compiler, and hardware runtime in one codebase. It gives people who find PyTorch too large and micrograd too limited a place to inspect how neural-network operations become executable kernels.

+23stars / 7d
Verdict

Our tinygrad run installed 138 packages and occupied 7,922 MB, then finished with 2 passing tests and 200 failures because the selected AMD tests repeatedly could not find clang. Use it when inspecting or changing the path from tensors to kernels is the point of the work. Choose PyTorch or JAX when your main requirement is a predictable application framework rather than a compact compiler you intend to study.

We ran it

Lab card: what happened when we ran tinygradScreenshot of tinygrad (github.com/tinygrad/tinygrad)
Install✓ · 111s138 packages · 7922 MB
Build✓ · 11s
Tests✗ · 145s2 passed · 200 failed of 202 (pytest)
Known vulns19(pip-audit)
Repo1640 files~520,436 lines of source · 42.9 MB · 9 CI workflows · tests dir

Answers from our run

Does tinygrad build from source?

Dependencies installed in 111 seconds (138 packages), and the build succeeded in 11 seconds. We cloned commit 3c59521 into a clean Debian container with 3 CPUs and no project-specific setup.

Do tinygrad's tests pass?

Not all of them: 2 of 202 passed and 200 failed when we ran the project's own test command (pytest). Some failures need services or credentials a bare container does not have.

Does tinygrad have known vulnerabilities in its dependencies?

pip-audit flagged 19 known advisories in the dependency tree at the time of our run.

Who should not use tinygrad?

Teams that need a drop-in PyTorch replacement: the README says tinygrad has fewer functional transforms than JAX and aims for familiar APIs rather than complete compatibility.

What are the alternatives to tinygrad?

PyTorch, JAX, Apache TVM. Our tinygrad run installed 138 packages and occupied 7,922 MB, then finished with 2 passing tests and 200 failures because the selected AMD tests repeatedly could not find clang.

Setup2/5Build passed, but 7,922 MB and 200 failed tests need attention
Docs4/5Clear concepts and test commands, with system prerequisites left implicit
Community5/5October 7 push, 33,710 stars, and active issue and PR work
Maturity3/5Active v0.14.0 codebase with API changes and a failed lab suite

Discussed on

  1. hnHacked Nvidia 4090 GPU driver to enable P2P829 points
  2. hnTinygrad: A simple and powerful neural network framework434 points
  3. hnTinygrad405 points
  4. hnFive Years of Tinygrad278 points
  5. hnTinygrad 0.9.0241 points

Who it’s for

Engineers who want one Python codebase spanning 8 accelerator paths they can inspect and change.
Researchers experimenting with kernel scheduling, code generation, or unusual accelerators.
Python developers who know the PyTorch style and can accept a smaller API plus sharper compatibility edges.
Contributors willing to test small, measured changes against the project's strict review rules.

Who it’s NOT for

Teams that need a drop-in PyTorch replacement: the README says tinygrad has fewer functional transforms than JAX and aims for familiar APIs rather than complete compatibility.
Contributors who expect a clean full suite after the documented source install: our fresh Debian run ended with 200 failures, and the log tail repeatedly showed a missing clang executable.
Organizations that require a stable 1.0 API: the README explicitly says the library is not 1.0 yet, and release v0.14.0 removed Tensor.training and Tensor.train().
First-time contributors planning documentation-only or large refactor pull requests: the contribution guide says those changes will usually be closed and asks for small, tested diffs.

Setup reality

Our sandbox installed commit 3c59521 in 111 seconds, adding 138 packages and using 7,922 MB on disk. The build passed in 11 seconds. Pytest failed in 145 seconds: 2 tests passed and 200 failed out of 202. Pip-audit found 19 known vulnerabilities.

The core package needs no API credential, and the project recommends a source install. The tested checkout targeted Python 3.12; the project metadata requires Python 3.11 or newer. Accelerator choice and optional test dependencies vary by CPU, CUDA, AMD, Metal, OpenCL, Qualcomm, Nvidia, or WebGPU path.

The failing log tail repeatedly reports FileNotFoundError for clang while AMD emulator tests compile instructions. Our Debian image did not have that executable. The repository has 9 CI workflow files and a tests directory, but no Dockerfile that captures a full contributor environment.

A 42.9 MB checkout exposes the route from tensor to kernel

We measured 1,640 files and about 520,436 lines of source in the 42.9 MB checkout. That repository puts the tensor API, automatic differentiation, intermediate representation, scheduler, code generator, JIT, and device runtimes together in Python. A matrix operation does not disappear behind a separate compiler service. You can turn up the debug output, see the generated code, and trace the decisions that produced it. For engineers learning ML systems, that visibility is the product.

The scope goes well past a teaching autograd. The README lists 8 accelerator paths: OpenCL, CPU, Metal, CUDA, AMD, Nvidia, Qualcomm, and WebGPU. It also includes neural-network layers, optimizers, data helpers, graph execution, and a compiler that fuses and lowers kernels. The appeal is control over that full route without adopting several repositories at once.

What happened when we ran it

We cloned and ran commit 3c59521 in our sandbox. Installation took 111 seconds, pulled 138 packages, and left 7,922 MB on disk. The build succeeded in 11 seconds. This was a fresh Debian container with Python 3.12, 3 CPUs, 8 GB of RAM, no secrets, and no elevated privileges. Pip-audit reported 19 known vulnerabilities in the installed environment.

The test step failed after 145 seconds. Pytest reported 2 passed and 200 failed out of 202 tests. The failures shown at the end all came from test/amd/hw/test_sop.py. Their error text says the emulator failed while compiling AMD instructions because it could not find the clang executable. That is the limit of what the supplied log establishes. It does not show a wrong arithmetic result or prove that all 200 failures had separate causes.

This result says something useful about setup. The source installation and build worked, yet the chosen hardware-test slice expected a system compiler that was absent from the clean image. The README's installation section gives the editable pip command, while its testing section points contributors to the CI workflow for fuller examples. A new contributor should read that workflow and reproduce the relevant job's system packages before treating pytest test/ as a self-contained check.

The empty core dependency list does not mean a small test machine

At commit 3c59521, the project metadata declared Python 3.11 or newer and no mandatory runtime dependencies for the core package. That is attractive if you only want basic tensor work. It also sits beside several optional test groups that bring in NumPy, PyTorch, pytest, ONNX tools, Transformers, audio libraries, and other packages. Our installed environment reached 7,922 MB, so the minimal core and the contributor setup are very different purchases.

Hardware expands the matrix again. Each of the 8 listed backends has its own driver, compiler, operating-system, or device assumptions. tinygrad can choose a default device, but that does not certify every path on your machine. The absent clang binary in our run is a concrete example. Pin the commit, choose the backend first, then copy the matching CI job instead of installing every optional group and hoping the full suite describes your target.

v0.14.0 still permits user-facing API removal

The project says plainly that it has not reached 1.0. Release v0.14.0 demonstrates what that means: Tensor.training and Tensor.train() were removed in favor of a TRAINING context variable. The same release changed scalar typing, made default numeric types context variables, and enabled parallel kernel compilation by default. Those are meaningful changes for code that follows the moving main branch.

That pace is reasonable for compiler and hardware research. It is less comfortable for an application team that wants a stable framework boundary. Pinning a revision is necessary, and upgrade work should include model-level regression tests on the actual device. Familiar PyTorch-style loops reduce the learning cost, but familiar syntax is not a compatibility promise.

v0.14.0 contribution rules favor small measured changes

The v0.14.0 README sets an unusually narrow bar for pull requests. Bug fixes need regression tests. Performance claims need measurements. Large or complex diffs may be rejected, and the maintainers ask contributors to split prerequisite refactors from the feature they enable. Documentation-only and whitespace changes are generally closed unless the contributor is already known to the project.

That policy protects a codebase whose stated aim is low complexity, but it changes who will enjoy contributing. Someone arriving with a 300-line abstraction or a broad cleanup is working against the review model. A focused hardware fix with a reproducer fits better. The guide also warns that code outside the core tinygrad/ folder is not tested as well, a useful boundary when deciding how much confidence to place in an example or extra utility.

An October 7 push shows active work, not settled behavior

GitHub showed 33,710 stars, 124 open issues, and 39 open pull requests on October 7, 2026. The repository was pushed that same day. One issue updated on October 7 concerned a USB GPU after a lost 12-volt supply, while another opened on October 6 documented an AMD KFD problem. Together with 9 CI workflow files, that is strong evidence of current hardware work and active maintenance.

Release v0.14.0 arrived on August 24 after more than 1,000 commits since v0.13.0. Activity does not erase the setup result from our September 30 sandbox or turn a pre-1.0 API into a fixed target. tinygrad is a good choice when the compiler, scheduler, or device layer is what you want to understand and alter. If those layers are merely a way to ship a model, the 200 failed tests are a good reason to begin with a more settled framework.

Alternatives

ProjectWhat it isPick it when
PyTorch gh↗A widely used tensor and deep-learning framework with a much broader operator and deployment ecosystem.pick this instead when production compatibility, packaged integrations, and a broad operator set matter more than reading the whole compiler stack.
JAX gh↗A Python array system built around composable transformations and XLA compilation.pick this instead when mature `vmap`, `pmap`, and functional transformations are central to the work.
Apache TVMA machine-learning compiler stack for optimizing and deploying models across hardware targets.pick this instead when compiler deployment across devices matters more than having a built-in PyTorch-like tensor front end.
microgradA very small automatic-differentiation engine built for learning the underlying idea.pick this instead when you want the shortest educational route to backpropagation and do not need device runtimes or kernel code generation.

Sources

  1. tinygrad README and repository
  2. tinygrad documentation
  3. tinygrad v0.14.0 release
  4. tinygrad test workflow
  5. USB GPU power-loss issue 18512

More ai tools reviews

universal-modder · DeepEP-Ascend · DeepGEMM-Ascend · hypoarena · jeeves · faster-whisper · the whole board →