python-trio/trio: structured concurrency, and issue #1 as a change feed
Trio – a friendly Python library for async concurrency and I/O
At a glance
- What is it?
- Trio is an async and await native I/O library for Python whose whole argument is that concurrency should be easy to get right, and whose design it claims is radically simpler than asyncio or Twisted while remaining as capable. Two details reward attention: the project asks you to subscribe to issue number one for advance notice of compatibility updates, and its dependency floors are annotated with the release that introduced each feature.
- Who is it for?
- Trio fits a team that writes concurrent I/O and wants the failure modes designed rather than discovered, and that can live with a library whose structure dictates how tasks are nested. Before adopting it, subscribe to issue number one, read the design principles rather than only the tutorial, and confirm your platform is one of the four that get tested rather than one of the others that are merely hoped to work.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository last received commits 2 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.
Star history
- python-trio/trio7,365 ★ · +29
| Repository | 2026-09-23 | 2026-11-15 |
|---|---|---|
| python-trio/trio | 7.3k | 7.4k |
29 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Structured concurrency is the entire pitch
The project describes itself as aiming to produce a production quality, permissively licensed, async and await native I/O library, and the examples it reaches for are all I/O fan-out: a web spider fetching many pages in parallel, a web server juggling downloads and websocket connections at once, a process supervisor watching several subprocesses. What it claims to add over competitors is an obsessive focus on usability and correctness, with the summary that concurrency is complicated and the goal is making it easy to get things right. The design lineage is stated too, built from the ground up on async and await, drawing on a reading list and in particular on Dave Beazley's Curio, and arriving at a design the readme calls radically simpler than asyncio and Twisted while just as capable. The reference point for the idea is the article on structured concurrency, or the Go statement considered harmful.
Issue number one is a compatibility notification feed
Stability is handled in a way that is unusual enough to be worth copying. The readme describes Trio as mature and well tested, with a solid design, fully documented features and wide production use, and says breaking changes are rare. For anyone who depends on long-term API stability, the recommended move is to subscribe to issue number one, which is used for advance notice of any compatibility updates. Minor interface adjustments do happen, so the channel exists to make the rare change something you hear about rather than discover. The packaging metadata carries its own signal in the same area, listing the development status as 4 - Beta alongside a typed classifier.
Four operating systems are tested, and one dependency is platform specific
The compatibility statement is specific in a way most libraries are not. It needs Python 3.10 or better, with CPython or currently maintained versions of PyPy3 both fine, and it is tested on Linux, macOS, Windows and FreeBSD. Other environments might work, and the readme says so without claiming it. Installation is easy because all dependencies are pure Python, with one exception: CFFI on Windows, which has wheels available, so no C compiler is needed. That exception is visible in the dependency list, where CFFI is required only where the operating system is Windows and the implementation is not PyPy, with a comment noting that on PyPy it is built in. The supported interpreter range in the metadata matches the stated floor and runs through Python 3.15.
Dependency floors carry the release that introduced each feature
The dependency list is annotated like a changelog. Each floor is followed by a comment naming the release that made it necessary: attrs at 23.2.0, with comments tracing 19.2.0 adding the eq option to decorators, 20.1.0 adding the frozen decorator, 21.1.0 adding a dataclass transform for type checkers, and 21.3.0 adding an import path. CFFI is pinned for the same reason, with comments recording that 1.12 added buffer requirements and release handling and that 1.14 fixed a memory leak inside a Windows error call. The rest of the list is short and unannotated: sortedcontainers, idna, outcome, and sniffio at 1.3.0.
Licensing is a choice between MIT and Apache 2
The readme answers the corporate question directly, in a section addressed to people who want to make sure their company's lawyers will not object. Trio is permissively licensed under your choice of MIT or Apache 2, with the licence file linked for details. The repository carries both texts as separate files alongside the main licence file, and the packaging metadata expresses it as a dual licence with the licence files globbed from the tree, so a source distribution includes whichever texts apply. There is also a code of conduct, and contributors are asked to follow it in all project spaces rather than only in the repository.
Three CI setups, a docs pipeline, and a newsfragments directory
The root of the repository shows how the project is run. There is a builds directory for one continuous integration system and a GitHub directory for another, a tox configuration, a shell script named for continuous integration, and a pre-commit configuration. Documentation has its own requirements file pair, an input file and a locked output, and a readthedocs configuration, with the documentation itself in a docs directory. Test requirements follow the same input and locked output pattern. Two smaller files are easy to overlook: a blame ignore file, which keeps large formatting commits out of blame output, and a zizmor configuration, which points at a linter for GitHub Actions workflows. Change notes are collected as fragments in their own directory rather than written directly into a changelog, and the readme itself is README.rst.
Two or three releases a year, all on the zero series
The release record shows a slow, deliberate cadence rather than frequent patch work. v0.33.0 was published on 2026-02-14, v0.34.0 on 2026-08-11 and v0.35.0 on 2026-10-31, so roughly three to six months between minor releases, with no patch releases in the recent list. Each is a zero-series minor bump, which is consistent with the stability claim and with issue number one serving as advance notice of compatibility updates. Distribution is equally deliberate, since the readme badges track both the PyPI version and the conda-forge version, and a codecov badge reports test coverage. Where the design arguments happen is also part of the project's shape: a reading list wiki, a documentation page on user level API principles, issues carrying a design discussion label, and a forum sub-forum for structured concurrency that other systems' developers are invited into.
The front door is a tutorial and three runnable examples
Where to next is organised by what the reader wants, and the order is deliberate. Someone who wants to try it gets a friendly tutorial that explicitly requires no prior experience with async coding. Someone impatient gets a simple concurrency example, an echo client and an echo server, all in the tutorial. Someone evaluating the approach gets the structured concurrency article and a conference talk from 2018 that demonstrates implementing the Happy Eyeballs algorithm in an older library and then in Trio, which is the clearest available picture of the difference. Support runs through four channels, a chat room, a forum, bug filing, and a Stack Overflow tag, and the forum keeps a dedicated sub-forum for structured concurrency where developers of other systems are explicitly welcome.
Editorial conclusion
Trio fits a team that writes concurrent I/O and wants the failure modes designed rather than discovered, and that can live with a library whose structure dictates how tasks are nested. Before adopting it, subscribe to issue number one, read the design principles rather than only the tutorial, and confirm your platform is one of the four that get tested rather than one of the others that are merely hoped to work.
Frequently asked questions
What is Trio used for in Python?
Trio is an async and await native I/O library for writing programs that do multiple things at once with parallelized I/O, such as a web spider fetching pages in parallel, a web server handling downloads and websockets, or a process supervisor watching subprocesses.
How does Trio handle breaking changes?
Breaking changes are rare and minor interface adjustments happen, so the readme suggests subscribing to issue number one for advance notice of any compatibility updates. The project describes itself as mature and well tested, with its design solid and breaking changes rare.
Which platforms and Python versions does Trio support?
Python 3.10 or newer on CPython or currently maintained PyPy3, tested on Linux, macOS, Windows and FreeBSD. Dependencies are pure Python apart from CFFI on Windows, which ships wheels, so no C compiler is needed.
Official sources
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.
[](https://hysenlabs.com/projects/python-trio-trio)Star history chart for your README
[](https://hysenlabs.com/projects/python-trio-trio)Was this useful?