mrkeyoor.com_
Tue 01 Sept 17:14 UTC
AI Toolsevaluationupdated 26 Aug 2026

tinygrad review

tinygrad is a compact deep-learning framework with tensors, automatic differentiation, a compiler, JIT execution, training tools, and support for several accelerator backends. It is meant for people who want a PyTorch-like programming surface while still being able to read and change the machinery below it.

+23stars / 7d
Verdict

Our tinygrad run installed 137 packages and consumed 7,916 MB, then pytest finished with 125 failures and 75 errors, so the simple source install did not produce a ready contributor workstation. Use tinygrad to learn, inspect, and experiment with a compact ML stack. For production model development, PyTorch or JAX is the safer default unless tinygrad's compiler access or hardware work is the reason you came.

We ran it

Lab card: what happened when we ran tinygradScreenshot of tinygrad (github.com/tinygrad/tinygrad)
Install✓ · 96s137 packages · 7916 MB
Build✓ · 10s
Tests✗ · 83s1 passed · 125 failed · 75 errors of 201 (pytest)
Known vulns14(pip-audit)
Repo1569 files~510,003 lines of source · 42.3 MB · 9 CI workflows · tests dir

Answers from our run

Does tinygrad build from source?

Dependencies installed in 96 seconds (137 packages), and the build succeeded in 10 seconds. We cloned commit dc04c78 into a clean Debian container with 3 CPUs and no project-specific setup.

Do tinygrad's tests pass?

Not all of them: 1 of 201 passed and 125 failed when we ran the project's own test command (pytest), with 75 collection errors. Some failures need services or credentials a bare container does not have.

Does tinygrad have known vulnerabilities in its dependencies?

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

Who should not use tinygrad?

Teams that require a green test baseline in a plain Debian environment: our run ended with 125 failures and 75 collection or setup errors.

What are the alternatives to tinygrad?

PyTorch, JAX, Apache TVM. Our tinygrad run installed 137 packages and consumed 7,916 MB, then pytest finished with 125 failures and 75 errors, so the simple source install did not produce a ready contributor workstation.

Setup2/5Short install, huge footprint, missing compiler, and failed tests
Docs4/5Direct comparisons, runnable examples, and strict contribution guidance
Community5/5Daily code activity, current releases, and busy technical review
Maturity3/5Capable stack with an explicitly pre-1.0 API

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

ML systems engineers who want to study or modify an end-to-end tensor compiler.
Researchers experimenting with kernel scheduling, code generation, accelerator backends, or model execution.
Developers who find micrograd too small for real training but PyTorch too large to understand as one system.
Contributors willing to benchmark claims, write regression tests, and keep changes small enough for the project's strict review style.

Who it’s NOT for

Teams that require a green test baseline in a plain Debian environment: our run ended with 125 failures and 75 collection or setup errors.
Developers without a C compiler available: the tail of our failing run repeatedly reported that the clang executable could not be found.
Production users who need a stable 1.0 API: the README explicitly says the library is not 1.0, and v0.14.0 removed earlier training APIs.
JAX users depending on a full set of vmap or pmap transforms: the project's own comparison says those are not present yet.
Contributors planning broad documentation cleanups or large speculative changes: the contribution rules say such work will be closed and favor small, tested changes.

Setup reality

Our sandbox install succeeded in 96 seconds, adding 137 packages and occupying 7,916 MB on disk. The build completed in 10 seconds. The test command failed in 83 seconds: pytest recorded 1 pass, 125 failures, and 75 collection or setup errors out of 201.

The final test lines repeatedly showed FileNotFoundError for clang in AMD hardware tests. That proves the compiler executable was missing from our fresh Debian container, but the log tail does not prove one cause for every failure. pip-audit also reported 14 known vulnerabilities.

The README's basic editable install is short, while contributor setup adds testing extras and pre-commit hooks. Accelerator work also depends on the chosen backend and hardware. The repository had 9 CI workflow files and a tests directory but no Dockerfile, so a fully equipped contributor environment is something you assemble.

tinygrad exposes the compiler that larger frameworks hide

tinygrad sits between a teaching autograd project and a full application framework. Its Tensor API will feel familiar to PyTorch users, but the repository also contains the intermediate representation, kernel fusion, lowering passes, scheduler, code generation, JIT, graph execution, neural-network layers, optimizers, and data helpers. You can follow a matrix operation from Python expression to generated device code without crossing into a separate compiler project. That visibility is the main reason to choose it.

The repository is compact by ML-framework standards, yet our checkout still held 1,569 files and about 510,003 lines of source across the measured tree. It supports CPU, OpenCL, Metal, CUDA, AMD, NVIDIA, Qualcomm, and WebGPU paths according to the README. tinygrad says a new accelerator needs roughly 25 low-level operations. That claim describes the intended interface, not a guarantee that bringing up unfamiliar hardware is a 25-step task.

The framework can express normal training loops with autograd and optimizers. It also has lazy execution, kernel fusion, and a function-level JIT called TinyJit. This makes it far more useful than a notebook-sized educational engine. Still, the project's own JAX comparison says full vmap and pmap support is absent, and its PyTorch comparison emphasizes readability over ecosystem parity. Compatibility is a direction for APIs, not a promise that arbitrary PyTorch software will run unchanged.

The project favors readable core changes over broad compatibility

tinygrad's contribution rules are unusually blunt and therefore useful. Speedup claims need benchmarks. New features need regression tests. Large or complicated diffs face a high bar, while small changes and reductions in core complexity are preferred. The maintainers also warn that code outside the core tinygrad/ directory is not well tested. A prospective contributor gets a clear picture of what reviewers value before spending a week on a sweeping rewrite.

The same policy can frustrate people arriving with conventional open-source chores. The README says documentation-only and whitespace changes from unknown contributors will be closed. It warns that AI-looking contributions may be rejected without feedback and asks contributors to disclose AI use. Those are project governance choices, not technical defects, but they make tinygrad a poor target for casual portfolio pull requests. Come with a reproduced problem, a focused patch, and a test.

Version 0.14.0 also shows why production users should pin releases and read changes. Its notes say Tensor.training and Tensor.train() were removed in favor of a context variable. The same release covered work on language models, tokenization, USB transfer, weak scalar types, parallel kernel compilation, and training paths. Fast iteration is healthy for compiler research, but an explicitly pre-1.0 library can change interfaces while applications are still catching up.

What happened when we ran it

Our install at commit dc04c78 succeeded in 96 seconds, pulling 137 packages and expanding to 7,916 MB on disk. The build then completed in 10 seconds. We used a fresh unprivileged Debian container with 3 CPUs, 8 GB of RAM, Python 3.12, and no secrets. The install command was straightforward; the resulting disk use was not. Reserve space before treating this as a lightweight checkout.

The test command failed after 83 seconds. pytest reported 1 passing test, 125 failures, and 75 collection or setup errors out of 201. Its displayed suite time was 74.22 seconds. Many final failures came from AMD hardware tests that tried to execute clang and received FileNotFoundError. The log excerpt does not connect all 200 unsuccessful entries to that missing executable, so the honest finding is narrower: our clean environment lacked a tool exercised by many tests, and the suite was far from green.

pip-audit found 14 known vulnerabilities in the installed environment. The measurement does not identify their practical reachability inside tinygrad, but it prevents a clean dependency-security claim. The repository contained 9 CI workflow files and a tests directory, with no Dockerfile. The README tells contributors to install testing extras, enable pre-commit hooks, and consult CI for fuller test examples.

Hardware experimentation is the reason to accept the rough setup

A developer choosing tinygrad over PyTorch should have a reason tied to its internals. The project exposes scheduling and generated kernels, provides debug levels for inspecting output, and keeps the tensor front end beside the compiler. That combination is useful for learning how lazy tensor programs become device work, testing a code-generation idea, or bringing up an unusual accelerator without adopting a compiler-only stack.

The trade is that environment details matter. Our 201 collected tests encountered hardware-oriented paths in a container without clang, and the full installation occupied almost 8 GB. A CPU-only user following the quick install may never touch some backends, while a contributor running broad tests will. The README's one editable-install command is accurate as far as it goes, but it does not describe every system tool a broad test run can call.

Active releases do not make the API stable

GitHub showed a push on 2026-08-26, two days after the v0.14.0 release on 2026-08-24. The repository had 179 open issues and PRs, and the most recently updated work covered compiler rewrites, tokenizers, AMD support, numeric formats, model training, and benchmarks. That is current engineering activity across the areas the README advertises. It is not evidence that every backend behaves equally on every machine.

tinygrad is easy to recommend as readable systems software and harder to recommend as an ordinary application dependency. The 10-second build and active release stream are encouraging; 125 failed tests, 75 setup or collection errors, 14 audit findings, and a pre-1.0 API are reasons to keep evaluation isolated. Pick it when understanding or changing the stack is the job. Pick a larger framework when shipping the model is the job.

Alternatives

ProjectWhat it isPick it when
PyTorch gh↗The widely used tensor and deep-learning framework with a much larger operator and deployment ecosystem.pick this instead when application compatibility, established tooling, and production support matter more than reading the whole compiler stack.
JAX gh↗A functional array and transformation system built around XLA compilation.pick this instead when mature function transforms such as vectorization and parallel mapping are central to your work.
Apache TVMA compiler stack for optimizing and deploying machine-learning workloads across hardware targets.pick this instead when compiler deployment across many targets matters more than having the front-end training framework in the same project.

What people are saying

  1. [velocity-scout] tinygrad/tinygrad

Sources

  1. tinygrad README
  2. tinygrad 0.14.0 release
  3. tinygrad documentation
  4. Reviewed commit dc04c78
  5. tinygrad issues and pull requests

More ai tools reviews

claudian · SkillSpector · robin · mjlab · MoGe · awesome-design-md · the whole board →