Tiny🔥 Torch Preview: Help Shape the Direction!

[profvjreddi]

Hi everyone,

I'm sharing TinyTorch early because I'd rather shape the direction with community input than build in isolation.

What is Tiny🔥Torch?

TinyTorch is a from-scratch educational ML framework designed as the hands-on companion to our open-source ML Systems textbook.

Each module is like an "AI brick." 🧱 You build tensors, autograd, optimizers, data loaders, and other core components, and eventually the pieces click together into a complete working mini-framework that mirrors how modern ML stacks function.

However, the key thing is that we bring the systems aspects of ML into TinyTorch.

What makes it educational:

• 🧱 20 progressive modules — Build up from tensors to transformers, layer by layer
• 🏛️ Historical milestones — Recreate breakthroughs from Perceptron (1957) to Transformers (2017) to MLPerf (2018-Present)
• ⚡ Systems thinking — Understand memory, compute, and optimization trade-offs
• 🎯 Real capability — Train CNNs and language models with code you wrote yourself

Current status:

• ✅ Core framework and all modules implemented
• 🔧 Documentation and polishing in progress
• 📅 Classroom ready: Summer/Fall 2026

I Want Your Input 🙏

If you're a student:
→ What hands-on labs or projects would help you learn ML systems?

If you teach:
→ What would make TinyTorch easy to bring into a course?

If you're a practitioner:
→ What real-world systems tasks should we simulate?

For everyone:
→ What natural extensions belong in the "AI bricks" model?

Links

• 📘 TinyTorch Guide
• 📝 TinyTorch Paper
• 📖 Documentation
• 💻 Repository (browse the code)
• 📚 ML Systems Textbook

Acknowledgments

Credit where credit is due: TinyTorch builds on the spirit of MiniTorch, micrograd, and tinygrad. Those projects showed how powerful it is to learn by building from first principles. TinyTorch extends that idea across the full ML systems stack.

[sueszli]

This is easily my favorite educational ML project on GitHub right now!

The "AI bricks" framing is exactly right for building intuition.

One extension I'd love to see: integration with xDSL (https://xdsl.dev/) to bring compiler/IR-level systems thinking into the curriculum.

Right now TinyTorch covers the algorithmic and framework layers well, but there's a gap between "here's how autograd works" and "here's why PyTorch compiles to MLIR and what IREE does for inference".

Understanding that middle layer (how high-level ops become efficient machine code) would complete the systems story.

For the practitioner question: simulating the compile-time vs runtime tradeoffs in graph execution (eager vs traced vs compiled) would teach something most ML engineers never learn until they hit production bottlenecks :)

[profvjreddi]

Hey @sueszli - thanks so much for dropping a note. I appreciate you sharing the xDSL work; it looks very interesting! My background is in Just-in-time compilers, so I’m a fan of DSLs and related topics. I’ll be sure to check it out.

By the way, I want you to know that this project is very much open for feedback and contributions. I just put it out there to get those boots wrapped.

One thing we need to watch out for is scope creep, because there's definitely a lot we could add. But we want this to be educational. Ideally, I hope the first version can serve as an introduction to machine learning systems—volume one of the textbook. I'm currently working on volume two, which covers advanced machine learning systems, and perhaps that's where we can introduce some of these advanced concepts.

[sueszli]

Thanks for the response, Prof. @profvjreddi! Given that you're one of the very very few people currently sitting at the intersection of computer architecture and ML systems, there's a lot to learn from you :)

I actually reached out via email already about contributing to and collaborating on volume two. Would love to help build out that compiler/IR layer content.

In the meantime, I'm actively working on contributing to xDSL directly and in touch with Prof. Tobias Grosser's lab to see where I can be useful there. Happy to bring whatever I learn from that into TinyTorch if it fits.

[profvjreddi]

Keep in touch and do share anything interesting as we can all learn from one another!

[vserranodev]

Hi professor!

First of all, congrats on this wholesome job, I can see you are really making a change in the way people should approach ML systems, focusing on the low level understanding rather than focusing on high level implementation.

Is TinyTorch currently available for starting building? I know it is not already fully functional and we should expect changes, but I'm somehow excited to start ASAP building and i wondered if all the modules were available already.

Huge thank you!

[profvjreddi]

Hi there, and thank you for the kind words. I really appreciate it.

Yes, TinyTorch is available to start building with today. That said, it is an early-stage and actively evolving. All modules are more complete but may need some tweaking and fixes, and you should expect rough edges, gaps, and changes as they mature. This is being developed openly.

If your goal is to learn by building and poking around the internals, now is actually a great time to jump in. If you are looking for a fully polished, stable framework, we are not quite there yet. The emphasis right now is on low-level understanding and systems thinking, exactly as you described.

I would encourage you to start with the guide and the early modules, and to treat the codebase as something you can explore, question, and even help shape. Feedback, issues, and contributions are very welcome. I figured I'd put something out there so we can shape it in the open source.

Thanks again for the enthusiasm, and I am glad you are excited to dive in.

Best,
Vijay

[adendek]

Dear Professor,

I am writing to express my strong interest in contributing to your Tiny PyTorch project. As a university teaching assistant, I follow research in this area and find your implementation highly impressive.

I have some relevant prior experience, having developed my own version of a similar educational tool. Given the sophistication of your project, I believe my time would be best spent contributing to its development.

I have an initial idea for an enhancement: an implementation of a CUDA backend. Specifically, a simplified Tiny PyTorch version using either Numba CUDA or Triton.

I am, however, very open to other suggestions. If there are any urgent or more relevant tasks that you need assistance with, please let me know. I am very keen to get involved.

Best regards,
Adam

[sueszli]

I love your autograd implementation Adam - Really cool stuff :)

[sueszli]

I also think Triton is really a great idea for the next chapter/book.

[profvjreddi]

Wonderful, @adendek. It is really exciting to see this, and thank you for reaching out and for the kind words. I took a look at your work, and the autograd implementation is very much in line with what @sueszli pointed out.

I would very happily welcome your help. To be candid, it has been challenging to balance this alongside teaching, writing, and other commitments, so having thoughtful contributors step in makes a real difference. There have been plenty of late nights just to get the core pieces into a coherent, minimum viable form. 😅

My goal here is to create something the academic community can use as a stable educational platform. This started from my own needs, but it is not about my code or my approach. I am very open to ideas, alternatives, and suggestions if they help make this better for everyone.

I also want to be explicit that I am a big believer in properly recognizing contributions. This project is meant to be built together. My past students and contributors from around the world have shaped this in meaningful ways, some big, some small, and I care a lot about credit where credit is due 🙏

I agree with you and with @sueszli that GPU support is an important direction. The original plan was first to stabilize the CPU path and the educational abstractions, then introduce accelerators in a way that emphasizes systems thinking rather than hides it. Triton feels like a natural next step, and I am very aligned with that direction, since it lets students reason about kernels, memory, and performance without having to drop all the way down to CUDA C.

If you are open to it, a good starting point would be to sketch a minimal GPU backend design that mirrors the existing TinyTorch abstractions. Even a small, well-scoped prototype using Triton or Numba that supports a handful of core operations would be extremely valuable, both educationally and architecturally. We can then decide together how best to integrate it cleanly into the main codebase.

Anyone can open an issue or draft a short design note outlining their ideas, and we can iterate from there. I am really glad you reached out. Let’s build something together.

Best,
Vijay

P.S. Thanks so much for engaging. It would be great to keep the ideas flowing and build something that really becomes useful in classrooms. 🚀

[sotoblanco]

Hi @profvjreddi, this is an amazing learning tool! I would love to contribute to this fantastic project! I have been thinking a lot about doing something like this, and it is a great educational tool for building ML fundamentals.

As a student, I think having some real situations that solve problems can help me to see the relevance of the exercise and some examples of how it is used either in industry or academia.

I got the repository and the notebook. Are the notebooks with the solutions currently available?

I think I like this style more, in which you have the exercise and the assignment side by side rather than notebooks, but this is just personal preference and can be considered in a later stage. Notebooks are perfect, just my personal view. The content is amazing.

I would love to contribute and help you and the team at this stage. What would be the best way to get in touch and start helping?

[profvjreddi]

Thanks for the thoughtful feedback! And please bear with me, I am swamped with the numerous things i am juggling.

Solutions: The current notebooks include implementations. For classroom use, we're developing separate assignment versions with scaffolded code. If you have thoughts or ideas, please do let me know!

Real-world context: Great suggestion. We're adding "Systems Spotlight" sections to each module showing how the concepts appear in production frameworks (PyTorch internals, JAX, etc.) and real workloads.

Side-by-side format: Interesting idea! This model works well for isolated exercises. We went with notebooks because the modules build on each other and benefit from inline experimentation. But open to exploring hybrid approaches. Can you tell me what software you were using for that so that I can consider it?

Contributing: Best path is through GitHub issues or this discussion. If you want to dive deeper, feel free to reach out directly and we can find a good starting point.

[sotoblanco]

@profvjreddi

Solutions: I was thinking we could break it into milestones to help students collect small wins, as this can be a challenging topic, especially for the first exercises.

For example:

Milestone 1: Tensor creation

class Tensor:
    """Educational tensor - the foundation of machine learning computation.

    This class provides the core data structure for all ML operations:
    - data: The actual numerical values (NumPy array)
    - shape: Dimensions of the tensor
    - size: Total number of elements
    - dtype: Data type (float32)

    All arithmetic, matrix, and shape operations are built on this foundation.
    """

    def __init__(self, data):
        """Create a new tensor from data.        
        """
        ### BEGIN SOLUTION
        
        ### END SOLUTION

    def __repr__(self):
        """String representation of tensor for debugging."""
        return f"Tensor(data={self.data}, shape={self.shape})"

    def __str__(self):
        """Human-readable string representation."""
        return f"Tensor({self.data})"

    def numpy(self):
        """Return the underlying NumPy array."""
        return self.data

    def memory_footprint(self):
        """Calculate exact memory usage in bytes.

        Systems Concept: Understanding memory footprint is fundamental to ML systems.
        Before running any operation, engineers should know how much memory it requires.

        Returns:
            int: Memory usage in bytes (e.g., 1000x1000 float32 = 4MB)
        """
        return self.data.nbytes

Milestone 2: Element wise operations

def __add__(self, other):
    """Add two tensors element-wise with broadcasting support.
    
    TODO: Implement element-wise addition that works with both Tensors and scalars.
    """
    ### BEGIN SOLUTION

    ### END SOLUTION

def __sub__(self, other):
    """Subtract two tensors element-wise.
    
    TODO: Implement element-wise subtraction.
    """
    ### BEGIN SOLUTION

    ### END SOLUTION

def __mul__(self, other):
    """Multiply two tensors element-wise (NOT matrix multiplication).
    
    TODO: Implement element-wise multiplication.
    """
    ### BEGIN SOLUTION

    ### END SOLUTION

def __truediv__(self, other):
    """Divide two tensors element-wise.
    
    TODO: Implement element-wise division.
    """
    ### BEGIN SOLUTION
    
    ### END SOLUTION

# Attach methods
Tensor.__add__ = __add__
Tensor.__sub__ = __sub__
Tensor.__mul__ = __mul__
Tensor.__truediv__ = __truediv__

We attach the methods that create the same behaviour, but with milestones that the student can collect. Although this doesn't mimic real-world software, it mirrors the process of building components separately and integrating them by breaking tasks into smaller sub-steps.

Side by side: I didn't find any specific software. The issue is that we need to run code in the environment, and most publicly available software doesn't allow adding libraries. So I created my own application to tackle these problems and isolate the code in a Modal sandbox (kinda like a Docker container within a sandbox).

I did it in a weekend using Antigravity, so it's not production-ready, but I am using this to learn TinyTorch: https://sotoblanco263542--code-app-fastapi-app.modal.run/course/11

[harishb00]

Hi @profvjreddi , thanks a ton for this work! I have just finished module 1. I loved the lesson, the way you explained the applications for even a simple operation like subtraction, mean etc., in ML context is amazing. Planning to finish all the modules. I also liked how you left the readers to explore other ideas (say, SIMD instructions, ). This make the students to not only depend on your writing but also gives all different pointers to go through once done with the book.

One thing I observed is, when I start the module using tito module start 01, the jupyter notebook generated has all the solutions between ### BEGIN SOLUTION and ### END SOLUTION lines. I think this is something related to nbgrader. The files in the src directory has all the solution which is what getting converted to notebooks and put inside modules/ folder when we run start command. So, I had to manually open the files in src folder in vscode and do replace all ### BEGIN SOLUTION[\s\S\r\n]*?### END SOLUTION with
### BEGIN SOLUTION\n\t\t### END SOLUTION to remove all solution so that I can write the answer. I think the file generation should use other nbgrader commands which strips out the solution. Not sure, if I missed any commands. If this is a known issue, I would love to look into this.

If there is a feedback I could give, it would be

• In the assignment, first the Tensor class is given with all the methods to be filled with solution. Then we have multiple separate sections explaining Element wise ops, reduction ops, reshaping, matrix multiplication. If the methods (to be filled) are also broken and grouped under this section, that will be great for readers. So that, reader reads a section and then writes solutions for those methods. Dynamically these methods can be added to the class.

I love the work! I appreciate what you're doing to the community. 💖 from India.

[profvjreddi]

Hi @harishb00! Thanks for finishing module 1 and for the detailed feedback!

Solutions: This is intentional for now. During this preview phase, we want learners to see the full implementations so they can study and understand the code. In the future, we'll add a mode to generate assignment versions with solutions stripped for classroom use.

Breaking methods by section: Great idea. Having readers implement methods incrementally after reading each section (element-wise ops, then reductions, then reshaping, etc.) would defintiely reinforce the learning better than presenting the full class upfront. We'll restructure the assignments this way.

Thanks for the love from India! 💛

[MaximumBeings]

Hello,
This is a pretty good course. I am test driving it and I have two observations to share. I couldn't get it working out of the box using the installation instruction but was able to get it started using this

`# TinyTorch Complete Installation Guide

Prerequisites

Before starting, ensure you have:

• Python 3.8+ (check: python3 --version)
• Git 2.15.0+ (check: git --version)
• Google Chrome (recommended for Jupyter Lab)
• Internet connection

---

Step 1: Installation

Method A: Automated Installation (Recommended)

# 1. Navigate to your projects folder
cd ~/projects  # or ~/Desktop or any preferred location

# 2. Run the installer
curl -sSL mlsysbook.ai/tinytorch/install.sh | bash

# When prompted:
# - Press Enter to accept default directory "tinytorch"
# - Type "Y" and press Enter to continue
# - WAIT for ALL 4 steps to complete: [1/4], [2/4], [3/4], [4/4]

# 3. If installer completes all 4 steps successfully:
cd tinytorch
source .venv/bin/activate
cd tinytorch  # Navigate to inner directory

# 4. Install additional required dependencies
pip install pytest jupytext nbdev

# 5. Verify installation
tito system health

Method B: Manual Installation (If Automated Hangs at [1/4])

# 1. Navigate to your projects folder
cd ~/projects

# 2. Clone the repository
git clone --depth 1 --branch dev https://github.com/harvard-edge/cs249r_book.git tinytorch

# 3. Set up virtual environment
cd tinytorch
python3 -m venv .venv
source .venv/bin/activate

# 4. Install dependencies
pip install -r requirements.txt

# 5. Navigate to inner tinytorch directory and install package
cd tinytorch
pip install -e .

# 6. Install additional required dependencies
pip install pytest jupytext nbdev

# 7. Verify installation
tito system health

---

Step 2: Configuration

A. Configure Jupyter to Use Chrome

# Generate Jupyter config (if doesn't exist)
jupyter lab --generate-config

# Set Chrome as default browser for Jupyter
echo 'c.ServerApp.browser = "/usr/bin/open -a \"Google Chrome\" %s"' >> ~/.jupyter/jupyter_lab_config.py

B. Set Up Jupyter Password (Recommended)

This eliminates the need to copy/paste tokens every time:

# Set up a password
jupyter lab password

# You'll be prompted:
# Enter password: [type your password]
# Verify password: [type it again]

C. Verify Configuration

# Check you're in the correct directory (should see src/)
pwd  # Should show: .../tinytorch/tinytorch
ls -la | grep src  # Should show src/ directory

# Verify tito is available
which tito  # Should show path to tito

# Run health check
tito system health

# Verify all required packages are installed
pip list | grep -E "pytest|jupytext|nbdev"

---

Step 3: Start Your First Module

# Make sure you're in the correct directory
cd ~/projects/tinytorch/tinytorch  # Inner tinytorch directory

# Activate virtual environment (if not already)
source ../.venv/bin/activate

# Start Module 01
tito module start 01

# Chrome should open automatically with Jupyter Lab
# If prompted for password, use the one you set up earlier
# If prompted for token, see troubleshooting below

---

Understanding the Directory Structure

~/projects/
└── tinytorch/                     # Outer directory (cloned repo)
    ├── .venv/                     # Virtual environment
    ├── requirements.txt
    ├── book/
    └── tinytorch/                 # Inner directory ⭐ WORK HERE
        ├── src/                   # Source Python files
        │   ├── 01_tensor/
        │   │   ├── 01_tensor.py   # Source file
        │   │   ├── ABOUT.md
        │   │   └── module.yaml
        │   ├── 02_activations/
        │   └── ...
        ├── modules/               # Generated Jupyter notebooks
        │   ├── 01_tensor/
        │   │   └── tensor.ipynb   # Your working notebook
        │   └── ...
        ├── tinytorch/             # Exported package code
        │   ├── core/
        │   │   └── tensor.py      # Your exported implementations
        │   └── ...
        ├── pyproject.toml
        └── bin/tito

Important: Always work from ~/projects/tinytorch/tinytorch/ (the inner directory).

---

Module Workflow

Starting a Module

tito module start 01

This will:

1. Convert src/01_tensor/01_tensor.py to modules/01_tensor/tensor.ipynb
2. Open Jupyter Lab in Chrome
3. Track your progress

Working in Jupyter

1. Implement the required functions in the notebook
2. Test your code by running cells
3. Save your work (Cmd+S or Ctrl+S)

Completing a Module

tito module complete 01

This will:

1. Run tests on your implementation
2. Export your code to the TinyTorch package (using nbdev)
3. Make your code available for import: from tinytorch.core.tensor import Tensor
4. Update your progress tracker

Checking Progress

# View module progress
tito module status

# View milestone requirements
tito milestone list

# Run a milestone (after completing required modules)
tito milestone run perceptron

---

Common Commands

# Module commands
tito module start <N>       # Start a new module
tito module resume <N>      # Resume working on a module
tito module complete <N>    # Test and export module
tito module status          # View all module progress

# Milestone commands
tito milestone list         # See all milestones
tito milestone run <name>   # Run a milestone
tito milestone status       # View unlocked capabilities

# Utility commands
tito system health          # Check environment
tito setup                  # Re-run setup (safe)
tito update                 # Update TinyTorch
tito --help                 # Full command reference

---

Troubleshooting

Issue: tito: command not found

# Ensure you're in the inner tinytorch directory
cd ~/projects/tinytorch/tinytorch
ls -la | grep src  # Should see src/

# Activate virtual environment
source ../.venv/bin/activate

# Reinstall package
pip install -e .

Issue: Export Failed - nbdev_export Not Found

# Install nbdev
pip install nbdev

# Re-run module completion
tito module complete 01

Issue: Token Required in Jupyter

Option 1: Get the token from terminal

jupyter server list
# Copy the URL with token and paste in Chrome

Option 2: Set up a password (recommended)

jupyter lab password
# Enter your desired password
# Restart Jupyter

Issue: Jupyter Opens in Safari Instead of Chrome

# Set environment variable
export BROWSER="open -a 'Google Chrome'"

# Or set Chrome as system default browser:
# System Settings → General → Default web browser → Chrome

Issue: Notebook Not Created

# Manually convert source to notebook
cd ~/projects/tinytorch/tinytorch
jupytext --to ipynb src/01_tensor/01_tensor.py -o modules/01_tensor/tensor.ipynb

# Verify creation
ls -la modules/01_tensor/

Issue: Missing Dependencies

# Install all required packages
pip install pytest jupytext nbdev

# Or reinstall all requirements
pip install -r ../requirements.txt

Issue: Wrong Directory

# Check current location
pwd

# Should show: /Users/[username]/projects/tinytorch/tinytorch
# If not, navigate to correct directory:
cd ~/projects/tinytorch/tinytorch

# Verify you see src/
ls -la

Issue: Import Error After Completing Module

# Make sure nbdev is installed
pip install nbdev

# Re-run the export
tito module complete 01

# Verify your code was exported
ls -la tinytorch/core/tensor.py

---

Quick Health Check Checklist

Run these commands to verify everything:

# ✓ In correct directory (should see src/)
ls -la | grep src

# ✓ Virtual environment activated (should show .venv path)
which python

# ✓ Tito available (should show path)
which tito

# ✓ Environment healthy
tito system health

# ✓ Module source exists
ls -la src/01_tensor/

# ✓ All required packages installed
pip list | grep -E "pytest|jupytext|nbdev"

---

Module Progression & Milestones

Modules	Milestone	What You Build	Time
01-04	Perceptron	1957 First Neural Network	~12h
01-08	Backprop	1986 Backpropagation	~18-24h
01-09	LeNet	1998 CNN Architecture	~24-32h
01-13	Transformer	2017 Attention Mechanism	~36-48h
01-19	MLPerf	Industry Benchmarks	~54-68h

Total Time: 60-80 hours over 14-18 weeks (4-6 hours/week)

---

Quick Start Summary

# Installation (one-time setup)
cd ~/projects
curl -sSL mlsysbook.ai/tinytorch/install.sh | bash
cd tinytorch
source .venv/bin/activate
cd tinytorch
pip install pytest jupytext nbdev
jupyter lab password  # Set a password

# Daily workflow
cd ~/projects/tinytorch/tinytorch
source ../.venv/bin/activate
tito module start 01
# Work in Jupyter Lab
# Save your work
tito module complete 01

# Check progress and continue
tito module status
tito module start 02

---

Getting Help

# System health check
tito system health

# Command help
tito --help
tito module --help
tito milestone --help

# View module information
cat src/01_tensor/ABOUT.md

---

Understanding the Export Process

When you run tito module complete 01:

1. Tests Run - Your implementation is tested with unit and integration tests
2. Export via nbdev - Your notebook code is exported to Python modules in tinytorch/
3. Progress Tracked - Your completion is recorded
4. Code Available - Your implementations become importable:

   from tinytorch.core.tensor import Tensor
   x = Tensor([1, 2, 3])  # YOUR implementation!

This is why nbdev is essential - it converts your Jupyter notebook into a proper Python package.

---

Ready to Build?

cd ~/projects/tinytorch/tinytorch
source ../.venv/bin/activate
tito module start 01

`

Secondly, most of the tests are passing out of the box without changes. Is this the intention or do you have the plan to remove some of the solutions and mark them as TODOs? I suggest adding this def init(self, data, requires_grad=False): to the tensor class constructor from the outset. That said I think it has great pedagogical values. I have been able to pass up to Module 14 with minimal changes to the codes.
Thanks

[imflash217]

i am also confused because it seems like all the module's code has already been written.

[sotoblanco]

Yes, he mentioned this is not the final content, the purpose is building in public, so this is a first draft and the idea is to see how it works. As mentioned here #1081

[profvjreddi]

Howdy @sotoblanco and @imflash217 -- love that you guys are interacting and helping one another. I must apologize for the confusion caused by my release of the solutions. I wanted everyone to be able to read through the materials without necessarily feeling the need to implement everything right away. Originally, I didn't intend to have 20 modules, but it became impossible to make it smaller or shorter. I also worried that having to wait for all 20 modules could overwhelm people. My goal in releasing the solutions was to allow experts to review them, gain insights, and provide feedback. I promise to clean this up soon.

[blaugi]

I believe the workflow is a bit confusing, From what @MaximumBeings has written, the source of truth and what should be edited is the generated jupyter in modules (such as modules/01_tensor/tensor.ipynb).
However, when running tito module complete the notebook is overwritten by the contents of src/01_tensor/01_tensor.py and the CLI explicitly states the following:

Converting 01_tensor Python file to notebook...
📄 Source: 01_tensor.py → Target: modules/01_tensor/tensor.ipynb
🔄 Overwriting existing notebook (Python file is source of truth)

Therefore, whatever work you may have done in the jupyter gets overwritten if it's not present in the respective python file. Furthermore, the jupyter contains even more conflicting information about the source of truth:

## 📦 Where This Code Lives in the Final Package

**Learning Side:** You work in modules/01_tensor/tensor_dev.py
**Building Side:** Code exports to tinytorch.core.tensor

From my testing a file in modules/01_tensor/tensor_dev.py does not appear to impact the completion process.

Am I doing something incorrectly or is this intended behaviour?

[imflash217]

I keep getting this error whenever i run tito --help or similar command:

❯ tito --help                                                                                                                                                                          ─╯
Traceback (most recent call last):
  File "/Users/user1/Documents/study/github/tinytorch/.venv/bin/tito", line 3, in <module>
    from tito.main import main
ModuleNotFoundError: No module named 'tito'

tinytorch has been successfully installed but still i face this issue. Any help?

[harishb00]

ensure you run this command inside tinytorch directory.

[imflash217]

yes. I am running it within tinytorch directory. But still it does not work.

[PursuitOfCodeKnowledge]

You need view your path in command ls in terminal or cd

[profvjreddi]

Please let me know if you've activated your environment? venv needs to be activated. I will work on making these instructions clearer!

[modifiededition]

Is there any problem running with signin/signup ? I couldn't able to authenticate and create my profile.

[modifiededition]

@kai4avaya yes, I am still unable to login.

After I ran tito setup or community login cmd, it open up this signin page (first pic) where I try to signin via my google account and after giving permissions (2nd pic), it opened up a new signin/signup page (3rd pic) instead of providing successful authentication. Now when I tried to signup, it asks to confirm an account (4th pic) but no email come to my id. Please help to fix as I am stuck on this for more than a week.

[profvjreddi]

Thank you for your patience @modifiededition. I'm sure @kai4avaya will get to it soon.

[kai4avaya]

Hi @modifiededition I checked our auth database -- and you have successfully created an account with Google (and also Github). Can you try this, in Tito, run tito community logout. Then tito community login. Use Google and the same email. Please let me know if it works this time, if not, also let me know what your OS is (windows, Linux, etc.).

[modifiededition]

@kai4avaya It works. Thanks a lot :)

[Takosaga]

@kai4avaya Thank you, was having trouble also logging with github on linux, but using google worked for me. Though didn't try logout and login method with github.

[modifiededition]

I just started Module 1 and the solutions are already given for Tensor class in jupyter notebook. Don't we have to implement it on our own ?

[modifiededition]

yeah, also were you able to create an account via tito setup command ?

[kanenorman]

#1081 (comment)

[modifiededition]

Now I understand the rationale behind the solutions. I completed module 1 and loved it, and I think having solutions is good because it encourages logical thinking and saves time. But again, I think the professor is going to identify functions that are worth spending time implementing on our own, as mentioned in the issue.

[PursuitOfCodeKnowledge]

It's the true!

[profvjreddi]

Hey @modifiededition you are spot on!

One of my goals for this month is to determine what functions we really want learners to impelemnt cuas having us imelemnt everyhting is just teious and so i am in that process.

Next, i am really interested in running one TinyTorch Olympics challenge, and any ideas would be greatly appreciated. I basically want to run something that is not too hard, but where everyone can succeed in doing it, and be able to also show something that they learned.

[PursuitOfCodeKnowledge]

I think need time for path ... AGI

[kai4avaya]

Thanks for the updates. It’s really helpful to hear about your experiences so that we can improve the experience.

…

On Mon, Jan 12, 2026 at 8:38 AM Gonzalo Gamez ***@***.***> wrote: [External Sender] @kai4avaya <https://urldefense.com/v3/__https://github.com/kai4avaya__;!!AlswS5g!mPF2gPJbni2UxBuSr6uf--FfuB2SID2P9QExnXCDr-m6NXm-PIAnfKHdFPSkRpvjx0Ey5GRcklXJR494EUUXU6oq$> Thank you, was having trouble also logging with github on linux, but using google worked for me. Though didn't try logout and login method with github. — Reply to this email directly, view it on GitHub <https://urldefense.com/v3/__https://github.com/harvard-edge/cs249r_book/discussions/1076*discussioncomment-15475690__;Iw!!AlswS5g!mPF2gPJbni2UxBuSr6uf--FfuB2SID2P9QExnXCDr-m6NXm-PIAnfKHdFPSkRpvjx0Ey5GRcklXJR494EXkBHXKd$>, or unsubscribe <https://urldefense.com/v3/__https://github.com/notifications/unsubscribe-auth/BF6LSRIA5GDOQKKSSC4DMTL4GOPVBAVCNFSM6AAAAACO2AMUL6VHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTKNBXGU3DSMA__;!!AlswS5g!mPF2gPJbni2UxBuSr6uf--FfuB2SID2P9QExnXCDr-m6NXm-PIAnfKHdFPSkRpvjx0Ey5GRcklXJR494EUZ9ZHYz$> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

[Takosaga]

Dear Prof and team,
Thank you for creating Tiny Torch. I love that it is walking me through the time line and building on knowledge. Just finished module 2, could it be possible to introduce the respective Numerical Stability Considerations with the activation functions or after showing it failing. I'm doing the solutions in another notebook and avoiding ### BEGIN SOLUTION sections and didn't think about those situation as I was working through them.

[profvjreddi]

Hi @Takosaga, thanks so much for taking the time to share this. I did not expect so many people to prefer working without solutions, so this was honestly refreshing to hear. I really like that you are experimenting and thinking things through on your own.

This is helpful feedback, and I am actively thinking about how to incorporate it in future updates. We do want learners to have a way to check correctness and spot when something might be broken, without short circuiting the learning process. Striking that balance matters, and notes like yours help us get there. So, thanks again for flagging this.

[asgalon]

Hi,

Great project, I think this is just what I was looking for for a time now. I am probably much more comfortable with C++ than Python for a number of reasons, but I can understand why python may be a better choice as a tool for educational purposes. I just did the setup and went through the first module notebook. I may have expected to have to actually do a bit more to make all the tests pass in the end, since all the solutions were already there, so the hands-on experience was mainly restricted to remembering that the cells run with shift-Enter. I think I would like a few more road blocks there to make sure I did not go too fast over the code and documentation inbetween. When there is no chance for making an error, the lesson learned may be anchored very weakly, at least that is my experience from a number of online courses. So I was hesitating a bit to submit the completion because I got the feeling I missed doing some actual work there. Looking at the other posts above, this probably is not that uncommon. It reminds me a bit of the design of difficulty levels for adventure games.
From what I see, this project is off to a good start, it already looks impressive.

Cheers
Peter

[profvjreddi]

Hey @asgalon -- thanks for taking the time to drop me a note. Appreciate it.

I certainly agree. I do have a version that I'm getting ready to release, which doesn't have solutions. The key thing is to figure out just what students will really need to implement, so they have the pedagogical thing and not necessarily implement every single thing. The reason I released the solutions is really that I wanted to just make sure that everybody had an idea, especially the experts who know this. I wanted them to look at it and be like, "Yes, this is all correct, and it makes sense."

We're kind of reaching that plateau where things do work. What I think we should do next is strip away only a handful of solutions that people have to implement. That way, it makes sense for people to move progressively through the entire pedagogy and all the modules.

Thanks so much for the feedback. That sort of feedback is certainly very helpful for me!