CLI tool
sloria/doitlive avatar
sloria/doitlive

doitlive fakes a live terminal and lets your typing set the pace

Because sometimes you need to do it live

3,580 stars100 forksPythonMIT

At a glance

What is it?
A terminal presentation tool that replays shell commands as you type, where the three runtime dependencies are click plus two click plugins, the readme is reStructuredText beside a Markdown contributing guide, and the license link points at a branch the repository no longer uses as default.
Who is it for?
doitlive is a good fit for rehearsing a shell heavy talk without a real terminal in front of you, because the pacing comes from your own keystrokes and the session file is ordinary bash you can edit. Two things to know first.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 13 days ago.
What is it written in?
Mainly Python, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • sloria/doitlive3,580 ★ · -2
Star history
Repository2026-09-242026-11-15
sloria/doitlive3.6k3.6k

-2 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Your keystrokes are what drives the output

The mechanism is one sentence: doitlive reads a file of shell commands and replays the commands in a fake terminal session as you type random characters. Nothing runs on a timer. Every character you press releases the next chunk of output, so a session that would take forty seconds to run can take as long as you need to narrate it, or as long as you freeze. The quickstart is three steps and no options.

code
$ doitlive play session.sh

Step one is to create a file called `session.sh` and fill it with bash commands. Step two is the command above. Step three is written as Type like a madman, which is the only description of the core interaction anywhere on the page. Everything after that pointer is on a documentation site rather than here, so the flags for slowing down, skipping a line or bailing out are not on the page at all.

Three dependencies, two of them click plugins

The runtime list is short and specific: `click>=8.0,<9`, `click-completion>=0.3.1` and `click-didyoumean>=0.0.3`. All three come from the same ecosystem, and two of them are extensions rather than libraries. click-completion is what gives the command shell completion, and click-didyoumean is what suggests a correction when you mistype a subcommand. So the two user-facing niceties of the CLI are plugins maintained elsewhere rather than code in this repository, and the page credits the same library in its Kudos section, saying Armin Ronacher's click made this quick to implement. One console script is declared, `doitlive = "doitlive.cli:cli"`, so the whole surface area is a single entry point.

The readme is reStructuredText, the contributing guide is Markdown

The documentation set is split across two formats. `README.rst` is reStructuredText, with heading underlines drawn as rows of asterisks, shell samples written as `.. code-block:: console` directives rather than fenced blocks, and the three badges declared as reStructuredText substitution definitions named homebrew, build-status and pypi before they are used. Alongside it sit `AUTHORS.rst`, `CHANGELOG.rst` and `RELEASING.rst`, all in the same format. Then there is `CONTRIBUTING.md` and a `docs/` directory. So a project whose readme has to be read by people who arrived from a package index has an RST front page, a Markdown contributor guide, and a separate docs tree that the readme defers to with a single sentence.

Two links on the page point somewhere other than where they should

The PyPI destination appears twice in different forms. The badge definition targets `https://pypi.org/project/doitlive/`, while the Project Links list says `https://pypi.python.org/pypi/doitlive`, which is the older host name that now redirects. Minor, but it means two URLs for one page in a document people copy links out of. The license link is worse. It points at `https://github.com/sloria/doitlive/blob/master/LICENSE`, and the repository's default branch is `main`. The link survives only because GitHub keeps renamed branches alive, so it is a reference to a branch the project moved away from. The Homebrew badge gets this right by pointing at `master` in a different repository, where that is still the branch name.

The source distribution ships the tests, and the docs extra pins exactly

The build backend is `flit_core<5` with `flit_core.buildapi`, and the sdist contents are declared rather than inferred.

code
[tool.flit.sdist]
include = ["tests/", "CONTRIBUTING.md", "tox.ini"]
exclude = ["docs/_build/"]

So the test suite, the contributor guide and the tox configuration travel inside the source distribution, while the built docs are explicitly kept out. The pinning style is not consistent across the same file. Runtime dependencies use ranges, `click>=8.0,<9` and the two plugins with a lower bound only, while the docs extra pins two packages outright, `sphinx==8.2.1` and `sphinx-issues==6.0.0`. The dev extra then chains back into the project itself by listing `doitlive[tests]`.

Ruff is set to rewrite your files, not just report

The lint configuration has three settings that change what running it does rather than what it catches. `fix = true` means the linter rewrites the files it objects to, `show-fixes = true` prints what it changed, and `output-format = "full"` gives the detailed report. That means running the linter is not a read-only check, and it happens on commit, because there is a `.pre-commit-config.yaml` at the root and `pre-commit>=3.6,<5.0` in the dev extra. The rule selection is deliberately narrow: six groups, B for bugbear, E and W for pycodestyle, F for pyflakes, I for isort and UP for pyupgrade. Four codes are ignored, E203, E266, E501 and E731, of which E501 is the line length check, which the project has chosen not to enforce.

Five Python versions on the classifier list, floor at 3.10

The metadata declares `requires-python = ">=3.10"` and then lists five interpreters as supported: Python 3.10, 3.11, 3.12, 3.13 and 3.14. The package version is 5.2.1, the license is expressed as a file reference rather than a string, and `Environment :: Console` is the one environment classifier, which is the honest one for a tool that exists to draw a terminal. The optional groups are worth reading together: tests pulls pytest and IPython 8 or newer, and the reason IPython is there is in the shipped examples, one of which is `examples/python_and_ipython.sh` alongside `examples/walkthrough.sh`. So recording a Python session is a first class scenario rather than an afterthought, and the test extra exists to cover it.

No tagged releases, but a release script and a release workflow

The repository has no GitHub releases, while the tree carries `RELEASING.rst`, a `release_homebrew.sh` script at the root and a build-release workflow, the last of which is visible only because the build status badge points at it. So the release process is fully scripted and the artefacts go out through Homebrew and PyPI rather than through a GitHub tag. Two links in that chain matter if you are pinning: the Homebrew formula lives in a separate repository under a `Formula/d/doitlive.rb` path, and the PyPI page is the one the badge targets. The Kudos section also explains where the idea came from, crediting a PyCon 2014 talk called Revsets, and names two related projects in the same genre, HackerTyper and PlayerPiano, alongside the prezto themes the visual style borrows from.

Editorial conclusion

doitlive is a good fit for rehearsing a shell heavy talk without a real terminal in front of you, because the pacing comes from your own keystrokes and the session file is ordinary bash you can edit. Two things to know first. What it replays is a fake terminal session, which makes it a rehearsal aid rather than a live coding environment. And the distribution channels are Homebrew and PyPI, with no tagged releases on the repository itself, so pin the version your talk depends on rather than tracking the branch.

Frequently asked questions

What is doitlive?

A tool for live presentations in the terminal. It reads a file of shell commands and replays them in a fake terminal session as you type random characters, so the output appears at the pace you are typing rather than at the pace the commands actually run.

How do I install and run doitlive?

With pip using pip install doitlive, or on macOS with Homebrew using brew update and then brew install doitlive. To run a session, create a file called session.sh filled with bash commands and run doitlive play session.sh. The readme shows no flags; the rest is on the documentation site.

Which Python versions does doitlive support?

requires-python is >=3.10, and the classifiers list Python 3.10 through 3.14. The runtime dependencies are click>=8.0,<9, click-completion>=0.3.1 and click-didyoumean>=0.0.3, and one console script is declared, doitlive = doitlive.cli:cli.

Official sources

  1. Issues
  2. License: MIT
  3. Project website
  4. README
  5. sloria/doitlive on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/sloria-doitlive.svg)](https://hysenlabs.com/projects/sloria-doitlive)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/sloria-doitlive.svg)](https://hysenlabs.com/projects/sloria-doitlive)

Was this useful?