Briefing
When Andrej Karpathy dropped nanochat on GitHub, he wasn't shipping another production framework. He was handing out a recipe. The project is a from-scratch, full-stack version of the kind of training pipeline that sits behind ChatGPT, written to be read rather than just run. By mid-2026 it had picked up roughly 55,000 GitHub stars, which is a lot of attention for a teaching repo.
The hook that did most of the work is a number: you can train a small ChatGPT-style model for about $48 of compute, against the roughly $43,000 it would have cost in 2019. That price drop is the story. It turns "training a language model" from a thing only well-funded labs do into something a curious engineer can try over a long lunch on a rented GPU node.
For an Australian business team, the takeaway isn't that you should go train your own model. It's that the people you hire, or the staff you upskill, now have a cheap and honest way to learn how this technology actually works under the hood. That matters when you're trying to tell genuine AI capability apart from sales pitch.
A fair bit of the lore that has grown up around nanochat, though, runs ahead of what the project itself documents. Below, the parts that hold up and the parts that are more community myth than fact.
The Educational Philosophy
nanochat reflects Karpathy's long-running interest in teaching, and the repo itself is described as minimal, readable, and hackable (karpathy/nanochat). The neat four-pillar framing that follows is an editorial read on that approach rather than something the project states word for word:
Learning by Building: Abstract concepts become concrete when you implement them. Reading about transformers teaches you less than building one.
Clarity Over Cleverness: Code should be readable first and efficient second. A line that needs a comment to be understood should probably be rewritten.
Incremental Complexity: Start simple. Add complexity only when a concept actually calls for it, at the point where it's needed.
Community Learning: People learn better with company. Questions get answered, explanations get shared, and the shared understanding grows.
How This Shapes Contributions
Here's where the popular telling gets ahead of the evidence. nanochat is widely described as having formal contribution rules built around educational value, mandatory documentation, and careful pedagogical ordering. The repo's only stated contribution policy is narrower than that: an AI-disclosure rule asking contributors to declare substantial LLM-generated work (karpathy/nanochat README). Treat the guidelines below as the community's understood norms, not a published contributing guide:
Code Quality: Contributions are expected to be clear and well-commented. A clever one-liner that loses a beginner tends to get rejected even when it's technically fine.
Educational Value: A change is supposed to improve the learning experience. Performance tweaks land only when they don't muddy the code.
Documentation: Code without docs is treated as unfinished. Docstrings, inline comments, and README updates come with the territory.
Pedagogical Order: New features are meant to slot in where they make sense in the learning journey, not just where they're easy to bolt on.
The Contribution Process
Contributing to nanochat is reportedly a different experience from most projects, though the specifics below are not laid out in the repo and should be read as informal community practice:
Before Contributing
- Understand the vision: Read what guidance exists and watch Karpathy's videos.
- Start with issues: A
good-first-issuelabel is sometimes cited as the entry point for beginner-friendly work, though the repo doesn't document such a workflow. - Discuss first: For anything substantial, open a discussion before a PR.
The PR Review
It's often claimed that Karpathy personally reviews many PRs against criteria like the ones below. There's no public confirmation of this, and nanochat reads more like a personal reference harness than a community-governed project, so take it as reputation rather than process:
- Does this help someone learn?
- Is the code clear enough for a beginner?
- Does it fit the teaching narrative?
- Is the documentation complete?
The reported logic is that PRs adding complexity without a learning payoff get politely declined, less as gatekeeping and more as keeping the project pointed at its purpose.
Types of Contributions
Bug Fixes: Always useful. A bug confuses learners, so squashing one carries real teaching value.
Documentation: Usually the contribution that helps the most people. Better explanations, more examples, a clearer README.
Educational Content: Jupyter notebooks, tutorial scripts, and example configs that extend what you can learn from the repo.
Translation: Some accounts say the community has translated nanochat into 15+ languages. There's no evidence for this, and nanochat is a code and training harness rather than a documentation project with a multilingual translation program, so treat the figure as unconfirmed.
Performance Improvements: Accepted when they don't cost clarity, often carrying extra comments to explain the optimisation.
Not Accepted: Features that add complexity for no learning gain, framework integrations that hide how things work, or production-focused changes that pull attention away from the teaching goal.
The Community Culture
nanochat's community has a reputation for being unusually patient:
Beginner-Friendly: A question that might get you mocked elsewhere tends to get a real answer here. "How does attention work?" earns a patient explanation, not a curt link to a paper.
Learning Together: Experienced people share what they know, and often pick up something from a beginner's question in the process.
No Hype: The conversation leans toward understanding rather than benchmarking. "How does this work?" gets more airtime than "How fast is this?"
Cross-Disciplinary: Students, researchers, engineers, educators, and hobbyists all show up, and that mix tends to make the explanations better.
The Impact
nanochat's reach is often described as extending well past the repo. Some of these claims are firmer than others:
University Adoption: The article version of this story names Stanford, MIT, Berkeley, and dozens of other institutions. That's unsupported. The only documented course tie is nanochat serving as a capstone for Karpathy's own LLM101n at Eureka Labs (Andrej Karpathy, Wikipedia).
Corporate Training: It's plausible that companies use nanochat to bring engineers up to speed on AI, but no sources confirm it. Unverified.
Self-Taught Success: The claim that thousands of developers credit nanochat for breaking into AI is aspirational and unquantified, so treat it as a hope rather than a measured outcome. What is solid is the economics behind it: the $48 training cost puts a real, end-to-end training run within reach of an individual.
Research Foundation: Researchers can use a clean codebase like this as a starting point for poking at architectural variants, which is one of the more credible uses given how readable it is.
Karpathy's Role
Karpathy is the author of the project (announced on X on 13 October 2025). Beyond that, several commonly cited details about his ongoing day-to-day involvement aren't confirmed, so the items below are reputation, not record:
- Code review: He's said to personally review significant contributions, though this isn't documented.
- Video content: He's known for teaching videos like the nanoGPT "Zero to Hero" series; a dedicated companion-video series specifically for nanochat hasn't been confirmed.
- Community engagement: Reported responsiveness in discussions and questions.
- Vision setting: Defining where the project goes next.
The story people like to tell is that his involvement is teaching as much as management, every interaction a chance to help someone understand. That's a fair characterisation of his public persona, even where the nanochat specifics are thin.
The Long-Term Vision
A roadmap often gets attributed to nanochat, listing larger models, multi-modal work, distributed training, and safety modules. These are forward-looking and not confirmed as stated project goals; Karpathy's stated aim has been improving small models that stay accessible under roughly $1,000 budgets. Read the list below as extrapolation:
- Extend to larger models: Teaching paths for training 1B+ parameter models.
- Multi-modal education: Going beyond text into vision and audio.
- Distributed training: How to scale across multiple GPUs.
- Evaluation and safety: Modules on responsible AI development.
The point isn't to replace production frameworks. It's to grow a generation of practitioners who actually understand what they're building.
Why 55,000 Stars Matter
The star count is a rough proxy for reach. Each one is someone who saw value in learning this way. In a field that often gets accused of gatekeeping and hype, nanochat offers the opposite: a cheap, honest path to understanding how a language model is built, free and out in the open.
That's a vision worth contributing to.