exercism/python: the Python track repository behind Exercism's exercises

What exercism/python actually contains

The name invites a wrong assumption. This is not a Python distribution, a package on an index, or a library you import. It is the content repository for one track on exercism.org: the instructions, tests, reference solutions and support files for the Python exercises that students work through on the site. The README describes it as holding "all the instructions, tests, code, & support files for Python exercises currently under development or implemented & available for students."

The audience follows from that. Track maintainers and mentors work inside this repository. Teachers who want a ready-made set of graded Python problems can read the layout and lift the pattern. Someone who wants to run the exercises offline, or to check that a solution passes before submitting it, has a reason to clone it. Someone who wants to write Python professionally has no reason to open it at all.

The exercises split into two groups, and the distinction matters more than it first appears. Concept exercises teach the Python syllabus and are constrained to a small set of language or syntax features, so a student meets one idea at a time. Practice exercises are open-ended and unlocked by progress through the syllabus tree. Both groupings are declared in the track's config.json and stored under the exercises directory.

Concept exercises, practice exercises, and the config.json split

The architecture is a directory convention plus a manifest. Top-level entries include concepts/, exercises/, reference/, config/, docs/, bin/ and the track manifest config.json. The README points at config.json as the place where the two exercise groupings are recorded, which means the site reads that file to know what exists, what unlocks what, and how each exercise is presented.

The constraint on concept exercises is the interesting design decision. By limiting them to a small set of language or syntax features, the track can guarantee that a student is never asked to use something the syllabus has not introduced yet. That is a real restriction on exercise authors, and it is why the syllabus tree exists as a progression rather than a flat list. Practice exercises carry the opposite trade-off: no constraint, no guaranteed ordering, which makes them suitable for trying new techniques but useless as a graded introduction.

Version support is scoped explicitly. The README states that track exercises support Python 3.10 through 3.13.13, with exceptions noted where they occur, and that track tooling (test-runner, representer, analyzer and continuous integration) runs on Python 3.13.13. Read that as two separate compatibility surfaces. A student on 3.10 is inside the supported range for exercises; the tooling that grades and represents submissions is pinned higher.

Running the track's test runner with docker-compose

The repository ships a docker-compose.yml that defines a single service named test-runner. It uses the image exercism/python-test-runner, sets the working directory to /python, mounts the repository at that path, and overrides the entrypoint to run the track's own test script with a runner flag.

version: '3'

services:
  test-runner:
    image: exercism/python-test-runner
    working_dir: /python
    entrypoint: ./bin/test_exercises.py --runner test-runner
    volumes:
      - .:/python

Because the volume maps the current directory onto /python, the container sees your checkout. Start it with the usual compose command from the repository root:

docker compose up

What you should see is the test-runner service starting and executing bin/test_exercises.py against the exercises in the mounted tree. The compose file itself carries no published port and no environment variables, so there is no web endpoint to open; the output is the script's own console output. If you prefer a local install, requirements.txt pins the tooling dependencies, including pytest, pytest-subtests, flake8, pylint, black and yapf, with tomli conditional on Python versions below 3.11.2:

python -m pip install -r requirements.txt

After that, pytest.ini and the per-exercise test files are what pytest discovers. The README does not document a rollback or cleanup step for the container, so removing the service and its image is left to you.

The contribution freeze is the first thing to check

The README opens with an important notice in block capitals: the maintainers are not accepting community contributions at this time. The same message repeats twice more in the body, and the repository topics include community-contributions-paused. Suggestions, including new exercise ideas, are directed to a thread on the Exercism forum rather than to a pull request, and the README links a community blog post titled "Freeing our maintainers" for the reasoning.

This is the limitation that will decide most adoption questions. If your plan was to add an exercise, fix a typo in an instruction file, or extend a test, the repository's own front door says no. The maintainers describe the pause as temporary in tone but give no date for reopening, and nothing in the repository indicates when contributions will resume.

There is a second, subtler failure mode. Because this repository is content rather than a library, there are no releases to pin. The recent releases list is empty, so a consumer cannot say "we are on version X." Anyone building on the exercise files is tracking the main branch, and the main branch moves when exercises are added, edited or corrected. That is workable for a teacher assembling a course, and awkward for anything that needs a frozen artefact.

How this differs from Rosetta Code or a plain exercise list

The closest alternative for someone wanting graded Python practice is a static collection of problems, such as the exercise sets bundled with textbooks or the task lists on sites like Rosetta Code. The difference is in what surrounds each exercise. A static list gives you a problem statement and, often, a solution. This repository gives you a problem statement, a test suite, a reference solution directory, a syllabus position, and tooling that runs the tests in a container. The tests are the part that changes the work: a student cannot quietly write something that prints the right answer for one input, because the suite checks the contract.

A second alternative is Exercism's own website, which is where the README sends students and where the homepage lives. The site is the supported path: it handles unlocking, mentoring and submission. The repository is the source material behind it. If you only want to learn Python, the site is the shorter route. If you want to run the exercises without an account, or adapt them, the repository is the thing you need, and the docker-compose file is the entry point.

Licence, maintenance and what an upgrade costs

The repository uses the MIT License, stated in the README and present as a top-level LICENSE file. That is permissive for the track content: reuse and modification are allowed under the licence terms, and the usual obligation to carry the notice applies. Note that the README separates two licences. Python itself, and the documentation examples, fall under the Python Software Foundation License Agreement, with documentation examples dual licensed under the PSF License Agreement and the Zero-Clause BSD license from Python 3.8.6 onward. Incorporated software inside Python is listed separately by the Python project. So the MIT grant covers this repository's material, not the language it teaches.

Maintenance is active by the only measure available: the last push was on 2026-09-22, and the repository is not archived. The contribution freeze is a policy about accepting outside changes, not a sign that the track has stopped moving.

Upgrade cost is low in the ordinary sense and unusual in one respect. There are no released versions, so there is nothing to upgrade between. You pull the branch. What you do pay attention to is the Python version floor: exercises target 3.10 to 3.13.13 while tooling runs on 3.13.13, so a CI environment pinned to an older interpreter can run into the tooling boundary even when the exercises themselves would be fine. The requirements.txt pins are loose in places (tomli uses a lower bound with a version marker, pylint uses a compatible-release operator), which means a fresh install can resolve to newer patch versions than a colleague's environment.

Editorial conclusion

Adopt this repository if you want the exercise content itself: to run the track locally, to study how concept and practice exercises are separated in config.json, or to reuse the structure for your own teaching material. Do not adopt it if you expect to land a pull request; the README states plainly that maintainers are not accepting community contributions and directs suggestions to the forum. Before anything else, verify which Python versions your environment provides, because the README scopes exercises to 3.10 through 3.13.13 while the tooling runs on 3.13.13.

Frequently asked questions

Official sources

1. exercism/python on GitHub
2. Issues
3. License: MIT
4. Project website
5. README