# dockerlings, Docker exercises that run inside your terminal

> dockerlings is a Go terminal application that teaches Docker through a series of bite sized exercises, each verified by a check command and each backed by a shell script that explains what went wrong. The curriculum runs from running a container to multi-stage builds, and it needs a working Docker daemon on the machine doing the exercises.

**furkan/dockerlings** — learn docker in your terminal, with bite sized exercises

- Repository: https://github.com/furkan/dockerlings
- Stars: 1,038 · Forks: 73
- Language: Shell
- License: MIT
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/furkan-dockerlings

## A terminal UI, not a website of tutorials

dockerlings is described as a way to learn Docker by doing, in an interactive fashion, and the interface is the point. The application is a terminal user interface powered by Bubble Tea, so the exercises run in the same window where you would type your Docker commands. The README lists the properties it claims, and two of them are about the learning loop rather than the content. Verification is instant, you run check and know immediately whether you are right, and the curriculum is progressive, more than fifteen exercises that build on each other. The intended audience is stated plainly at the end of the README, beginners who want to understand Docker commands, intermediate developers preparing for real container workflows, and anyone who learns best by breaking and fixing things. It is a teaching tool, and it assumes the learner is at a terminal already.

## Fifteen exercises, arranged as a ladder

The curriculum table in the README is the outline. The first four exercises, core-01 to core-04, cover running containers, logs, exec and file operations, which is the day to day surface of the CLI. The next three, core-05 to core-07, move to writing Dockerfiles and to the instructions COPY, EXPOSE, ENV and LABEL, so image building starts early rather than at the end. The pair core-08 and core-09 is about state, persistent volumes and bind mounts with live reloading, which is the first point where a beginner meets the difference between a container and a durable file. core-10 and core-11 cover container networking and port publishing. The next three, core-12 to core-14, deal with Docker Compose, multi-service applications, named volumes and custom networks. The last exercise, core-15, is about multi-stage builds for small production images. The ordering is deliberate, each group assumes the previous one, and the progression from a single container to a Compose file is the arc a working project follows.

## How the checking works

Verification happens two ways, and the second one is the more instructive. Inside the interface you press c to check your solution, and the application tells you whether you are right. Outside it, every exercise directory contains a check.sh script that can be run directly and produces detailed feedback, which is what you want when the check fails and the interface only says no.

```bash
cd exercises/core-01
bash check.sh   # see detailed feedback
```

The tree explains the rest. The exercises/ directory holds one directory per exercise with its content, dockerlings.toml is the configuration file that the application reads, and the internal/ and cmd/ directories hold the Go implementation, with cmd/dockerlings being the entry point that the build command compiles. The reference to internal/ matters if you want to extend the tool, since Go keeps anything under internal/ private to the module. The interesting property of the design is that the checks are shell scripts against a real Docker daemon rather than mocked calls, so a passing exercise means the containers actually behaved as intended on your machine.

## Building it takes Go and a Docker daemon

The quick start is a clone, a build and a run, and the prerequisites are stated up front. You need Go installed and Docker installed, which is a heavier requirement than a tool that only prints text.

```bash
git clone https://github.com/furkan/dockerlings.git
cd dockerlings
go build -o bin/dockerlings$(go env GOEXE) ./cmd/dockerlings
./bin/dockerlings$(go env GOEXE) watch
```

The GOEXE suffix is what makes the same command work on Windows, where the binary needs a .exe extension, and the watch subcommand is the mode that runs the exercise loop. Inside the interface the controls are minimal by design, the up and down arrows to navigate, c to check, h for hints and q to quit. The module is github.com/furkan/dockerlings and the go.mod asks for go 1.25.1, so a recent toolchain is needed. The dependency list shows where the interface comes from, with bubbletea, bubbles, lipgloss and glamour from the Charm libraries, plus a markdown renderer for hints, viper for configuration, fsnotify for watching files and chroma for syntax highlighting.

## The author sells this skill as a service

The README carries a note near the top that says need help with Docker, and then describes what the author does for a living. He helps teams containerize applications, improve development environments and CI/CD pipelines, and troubleshoot Docker deployments, and the note is available for consulting and training with an email address. That is a common pattern for a teaching project, and it is worth naming rather than glossing over, because it tells you two things. The project is a by-product of real work, which is why the exercises cover the things that actually go wrong, and the exercise set is a funnel for a paid engagement, which means the shape of the curriculum reflects what sells consulting rather than a complete picture of Docker. For a team that is choosing training material, the practical question is whether the fifteen exercises match the gaps in your own team, and the answer is visible in the table rather than in a promise.

## The verifier is only as good as the daemon underneath it

The dependency on a live Docker daemon is the main constraint, and it cuts both ways. In exchange for real behaviour, the exercises inherit every environmental problem of the machine, so a learner with a stopped daemon, a permission problem on the socket, an outdated Compose plugin or a proxy that blocks registry access gets a failing check that looks like a failed exercise. The manual check.sh route helps here, because the detailed output usually shows the Docker error rather than a bare failure, and that is the difference between a confusing afternoon and a fixable one. The other limitation is coverage. Fifteen exercises take you from running a container to a multi-stage build, which is a solid first day and not a platform. Anything beyond that, orchestration, registry operations, image security scanning, or running Docker in production, is outside what this tool teaches. And the release history is short, a single version 0.0.7 from 2025-12-06, with the last push on 2026-08-26, so the exercises track a Docker of that era rather than guaranteeing coverage of the newest commands.

## MIT terms and a small tree

The licence is MIT, which is permissive and lets a company run the exercises internally, modify them, or use them in an onboarding document without obligations beyond keeping the copyright notice. The repository is small by design, with a.gitignore, the LICENSE, the README, the cmd/ directory for the entry point, dockerlings.toml for configuration, the exercises/ tree, go.mod and go.sum, and the internal/ directory for the implementation. The two files that matter most for an adopter are dockerlings.toml, which defines the course, and the exercises/ directory, where each task and its check script live, because those are what you would edit to teach something the shipped curriculum does not cover. The main branch is the default branch, the last push was on 2026-08-26, and the repository is not archived.

## Conclusion

dockerlings fits a developer who knows the Docker vocabulary but has not built the mental model, and it fits a team that wants an onboarding exercise rather than a video course, because each exercise leaves a shell script behind that shows exactly what the checker looked for. It does not fit a learner without a working Docker daemon, since the verification runs real commands, and it does not fit anyone looking for coverage of orchestration, since the curriculum stops at Compose and multi-stage builds. Verify three things first: that Docker actually runs on the machine you will learn on, since the exercises execute against a live daemon, that the version of the tool you build matches the exercise scripts in the tree, and that the curriculum in dockerlings.toml covers the ground your team needs, because fifteen exercises cannot cover a production container platform.

## FAQ

### What is dockerlings?

It is a Go terminal application for learning Docker through interactive exercises, with a Bubble Tea powered interface, instant verification through a check command, and more than fifteen progressive exercises that build on each other.

### What do I need to run the dockerlings exercises?

The README states that you need Go and Docker installed. The build is go build -o bin/dockerlings$(go env GOEXE) ./cmd/dockerlings, and the exercise loop starts with the watch subcommand.

### How do I check an exercise solution?

Press c inside the interface to check, or run the check.sh script in the exercise directory directly, which gives detailed feedback. The README suggests using the manual script when you want to see why a check failed.

### What topics does the dockerlings curriculum cover?

Exercises core-01 to core-04 cover running containers, logs, exec and file operations, core-05 to core-07 cover Dockerfiles and the COPY, EXPOSE, ENV and LABEL instructions, core-08 and core-09 cover volumes and bind mounts, core-10 and core-11 cover networking and port publishing, core-12 to core-14 cover Docker Compose, and core-15 covers multi-stage builds.

## Sources

- [furkan/dockerlings on GitHub](https://github.com/furkan/dockerlings)
- [Issues](https://github.com/furkan/dockerlings/issues)
- [License: MIT](https://github.com/furkan/dockerlings/blob/main/LICENSE)
- [README](https://github.com/furkan/dockerlings/blob/main/README.md)
- [Releases](https://github.com/furkan/dockerlings/releases)

---

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