# futurecoder: a Python course that grades every line a beginner writes

> futurecoder is a free interactive Python course for complete beginners, where each step is checked automatically, hints are rationed, and tracebacks are rewritten to point at the operation that failed. It suits learners who stall on the blank editor, and it is a self-hosted web application rather than a PDF.

**alexmojaki/futurecoder** — 100% free and interactive Python course for beginners

- Repository: https://github.com/alexmojaki/futurecoder
- Website: https://futurecoder.io/
- Stars: 1,552 · Forks: 190
- Language: Python
- License: MIT
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/alexmojaki-futurecoder

## The problem is the empty editor, not the syntax

Most Python material aimed at complete beginners assumes the student already tolerates an empty file and a terminal. futurecoder takes the opposite stance. The README describes it as a 100 percent free and interactive course for people teaching themselves programming, especially complete beginners, and it says the design goal is to reduce frustration while still ensuring the student learns how to solve problems. The stated goal is plain: as many people as possible should learn programming. That framing matters for what the project is not. It is not a video library, not a problem archive you can grep, and not a language reference. It is a linear course whose unit of progress is a single verified exercise, delivered through a browser frontend backed by a Python core. The repository layout backs that up: a `core/` directory, a `frontend/` directory, a `translations/` directory, and a `homepage/` directory, plus `firebase.json` and `database.rules.json` at the top level, which indicates a Firebase hosted deployment rather than a self-contained Python package. `pyproject.toml` sets `package-mode = false`, so there is no library to import. You either use the hosted site at futurecoder.io or run the whole stack yourself.

## Every step is checked, hinted, and finally revealed in pieces

The core loop is the thing worth understanding. The README calls the course a fully interactive book that requires the user to run code in the provided editor or shell in order to advance. Each step mixes two kinds of work: solving a problem, or typing and running code that is already given. In the second case the student is kept engaged by being asked to predict the output in a simple multiple choice question, so the exercise still requires thought instead of blind copying. The code at each step is checked automatically, and if a student is stuck they can take small hints that gradually guide them toward the solution. When the hints are exhausted, the solution can be revealed bit by bit, which is a better failure mode than a blank page because the student still sees the pieces of the answer. A third exercise type is a Parsons problem, where the student must reorder a shuffled solution into the correct sequence. Parsons problems are a good fit for beginners because the goal is visible, the solution space is small, and ordering questions teach control flow without requiring syntax to be free. A course that only ever asked for a one line answer would let students pass by memorizing patterns. This one has several ways to be wrong.

## Tracebacks rewritten around the operation that failed

The traceback work is the most technically distinctive part of the project, and it is also where the dependency list explains most of the design. The README states that tracebacks here are more helpful than usual, with several enhancements. The exact operation that failed is highlighted rather than only the line, using the `executing` library. Tables of local variables and simple expressions are shown, evaluated by `pure_eval`. Fix suggestions come from `DidYouMean`, and beginner friendly explanations come from `friendly-traceback`, shown when hovering over a small `i` icon. Multiline statements appear in full thanks to `stack_data`, without dragging in unnecessary extra lines. The effect for a learner is concrete: when a beginner writes `total = prices[10]` against a list of three items, the screen can point at the indexing expression and show what `prices` holds, instead of printing a bare `IndexError` with a caret on the assignment. That is a real difference in kind from a stock interpreter, and it is the reason a project like this needs `pure_eval` and `executing` in `pyproject.toml` rather than just printing a formatted exception. The README also notes that common mistakes can be caught and pointed out, through specific checks in some steps and linting tailored for beginners, with `astcheck`, `pyflakes`, and `BetterErrorMessages` among the dependencies.

## Three debuggers and a visualizer sit next to the checker

Stepping through code is a separate concern from reading a failed run, and futurecoder treats them separately. Several debuggers are provided, the README naming `snoop` and `birdseye`, and Python Tutor is offered as well. A browser-based stepper is more forgiving than a terminal debugger, but it is also more limited, because the program has to be small enough for a student to hold in their head. The README does not document which debugger is attached to which exercise type, nor whether a student can reach a real pdb prompt inside an exercise, so the depth of interaction available in a given step is not something the documentation lets you predict. For an instructor building a course around this, that is a real unknown: the frontend is configurable, and the `tests/` directory plus `pytest.ini` and `selenium` in the development dependencies suggest browser level testing of the course flow itself, but the mapping from exercises to tools stays undocumented.

## Running the course locally needs Poetry, Node and a generated asset step

The hosted site is the easy path, and the README points at https://futurecoder.io/ for trying it. Running it yourself is a two toolchain build, and the ordering matters because the frontend consumes static files generated from the Python core. The documented steps are: fork the repository and clone it, install Python 3.12.1 and poetry, run `poetry install`, run `./scripts/generate.sh`, then in the `frontend` folder install `node >= 22.17.0`, run `npm ci`, run `npm run build`, and start the development server. The generate step is not a one time setup, because the README says to repeat it whenever you change Python files. After the build you also copy `service-worker.js` from the `course` folder into the `public` folder, since the service worker is what `sync-message` uses to handle `time.sleep` and reading from stdin in Python, which is what makes `input()` work inside the browser. The commands, in the order the README gives them:

```bash
poetry install
./scripts/generate.sh
```

```bash
npm ci
npm run build
npm start
```

Finally open http://localhost:3000/course/. One environment variable is documented: setting `REACT_APP_PRECACHE=1` when building enables caching, and the README says caching is not a good idea while developing, so leave it unset for local work.

## Developer mode is the escape hatch for instructors

A graded course has a built in conflict with exploration, and futurecoder resolves it in the interface rather than in the code. The README describes a Developer mode reached through the hamburger menu in the top left, then Settings, then turning Developer mode on. The result is two red buttons floating at the bottom of the screen that change the currently active step, so you can move forward without completing the exercises, or move backwards to retest a step you already passed. For a classroom this matters more than it sounds. A teacher demonstrating a concept does not want to solve the exercise live, and a learner who skipped a step through the buttons and reached content they cannot follow can go back. What the mode does not do is documented, and the distinction is worth noting: it is a step navigator, not an answer key, and the README does not say whether it disables the checker for the step you jump into. If you plan to use it for demonstrations, that behaviour is worth checking in a browser first, because the project ships no release notes and the last push was on 2026-05-09. The `translations/` directory in the repository layout suggests the course text is translatable, which is another reason an institution would fork rather than deploy.

## Conclusion

Adopt futurecoder as a self-hosted classroom tool if your learners are complete beginners who need immediate feedback on the exact expression they got wrong, and if someone on your side can maintain a Poetry plus Node build. Do not adopt it for intermediate developers, since the graded exercises and beginner linting are the point rather than an extra, and it is not a general purpose Python playground. Before committing, run `./scripts/generate.sh` and `npm run build` on a clean checkout, because the static assets are generated from Python and the build fails when those files drift. The license is MIT in `LICENSE.txt`, and the last push was on 2026-05-09 with no GitHub releases, so the README is your only changelog.

## FAQ

### Is futurecoder really free to use?

The README describes it as a 100 percent free and interactive course, and the repository carries an MIT license in `LICENSE.txt`. The project also asks readers to consider contributing or donating through Open Collective, but nothing in the README puts the course behind a paywall.

### Do I need to install anything to try futurecoder?

Not to try it, since the README points to https://futurecoder.io/ for a hosted version. To run it yourself you need Python 3.12.1, poetry, and `node >= 22.17.0`, and the build has a generated asset step.

### What happens when a beginner gets an error in futurecoder?

The README says tracebacks highlight the exact operation that failed, show tables of local variables evaluated by `pure_eval`, offer fix suggestions through `DidYouMean`, and add beginner friendly explanations from `friendly-traceback` when hovering over the `i` icon. Common mistakes are also caught by checks in some steps and by linting tailored for beginners.

### Can an instructor skip exercises when teaching a class with futurecoder?

Yes, by turning on Developer mode from the hamburger menu and Settings, which gives two red buttons that move the active step forward or backward without completing the exercises.

## Sources

- [alexmojaki/futurecoder on GitHub](https://github.com/alexmojaki/futurecoder)
- [Issues](https://github.com/alexmojaki/futurecoder/issues)
- [License: MIT](https://github.com/alexmojaki/futurecoder/blob/main/LICENSE)
- [Project website](https://futurecoder.io/)
- [README](https://github.com/alexmojaki/futurecoder/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/alexmojaki-futurecoder