powerline's install script imports a module current Python no longer ships
Powerline is a statusline plugin for vim, and provides statuslines and prompts for several other applications, including zsh, bash, tmux, IPython, Awesome and Qtile.
At a glance
- What is it?
- Powerline draws statuslines and shell prompts by replacing ordinary characters with glyphs from a patched font. It started as a vim statusline plugin and now covers three shells, a terminal multiplexer, three window managers and IPython, in Python, with no required third-party dependencies. Its default branch is named develop, its newest release is from 2024, and its front page tells you that a lighter alternative exists and names it. The packaging script is where the state of the project shows.
- Who is it for?
- This is worth having if you already have it configured, because a daemon keeps one interpreter alive instead of starting one per prompt, and that is the difference between a prompt that feels instant and one that does not. If you are installing it fresh, the cost is the font: the glyphs do not exist in ordinary monospace fonts, so you are replacing your editor font and your terminal font as part of setting up a statusline.
- 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?
- Activity is slowing. The repository last received commits 8 months 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
- powerline/powerline14,845 ★ · +24
| Repository | 2026-09-21 | 2026-11-15 |
|---|---|---|
| powerline/powerline | 14.8k | 14.8k |
24 Stars in the last 55 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The packaging script imports a module that current Python no longer ships
There is a single import in this project's install script that determines whether the compiled client gets built on a modern interpreter.
The script compiles a small C program at install time. To do that it needs a compiler, and it gets one by importing a constructor from a standard-library module that was removed from Python several releases ago. The module was part of the old packaging tooling, deprecated in favour of a build backend, and then deleted from the standard library outright.
So the primary install path for the compiled client cannot run on a current Python. Not because of anything wrong with the C code, but because the module that finds the compiler is gone.
Now the fallback chain, which is where the engineering shows. If compiling fails, the script does not stop. It prints that the compiled version failed, logs the exception, and checks for three specific binaries on the path. If all three are present it copies a shell script into place as the client, and tells you that it needs those three tools. If they are not, it copies a pure Python script instead.
So there are three clients: compiled, shell, and Python, chosen by what the machine can do.
The consequence is that on a current interpreter you land in the fallback rather than the fast path: the import sits inside compile_client(), so its failure is caught by the same exception handler that selects the shell or Python client.
The front page tells you to use a different plugin if you want something lighter
There is a paragraph in the middle of this front page that reads like an apology, and it is worth quoting in spirit.
It is introduced by a list of complaints in the reader's voice: I do not want to write Python, I do not want shell prompts, this is too much hassle, and what happened to the original project this was based on.
Then the answer: you should look at the derivatives. And it names one, describing it as currently the most lightweight and feature-rich alternative.
That is a maintainer pointing at a competitor and calling it better on the axis the competitor is optimised for. It is unusual, and it tells you two things.
First, the friction is real and acknowledged. The dependency on a patched font, the configuration files, the daemon: this is not a drop-in statusline. The front page is not going to pretend otherwise.
Second, the author is confident enough in the project's value to route people elsewhere rather than argue. If you are evaluating whether to adopt this, the person who wrote it has already told you when not to.
So the consequence is that the useful question is not whether this project is good but whether its trade is right for you: a rich statusline with a runtime cost and a font requirement, versus a lighter one that does less.
Nothing renders without a patched font, and the front page mentions this in a single link
The most common way this project fails to install is not a configuration error. It is a font.
The entire visual effect depends on characters that do not exist in ordinary fonts. The statusline is built out of glyphs that were added to patched versions of common coding fonts specifically for this project, and there is a separate repository containing those pre-patched builds.
So a correct installation still looks broken if your terminal and your editor are using an unmodified monospace font. The characters render as boxes or as the wrong shapes, and the usual reaction is to think the statusline is misconfigured.
The front page's treatment of this is one sentence, in a list of links under the configuration section, with the instruction to check out the font repository for pre-patched versions of popular open source coding fonts.
There is no warning on the front page that the obvious cause of a broken statusline is the font.
Compare that with the effort the project puts into the rest of the setup: three fallback client implementations, a daemon for performance, a directory structure for per-application configuration, and a documented override system. All of that is wasted if the glyphs do not render.
So the consequence is that you should install and configure the font before you install this, and if the statusline looks like nonsense, check the font before you check anything else.
Local configuration can override a setting but cannot remove one
The configuration system has a property that is documented in one sentence and will surprise anyone who expects local settings to win outright.
It says your local configuration only overrides the global configuration, it does not replace it, and that if you do not configure something locally, the global default is used instead.
That reads like a description of a sensible merge, and it is. But the consequence is not stated: you can change a value, and you cannot express a deletion.
The layout is a per-application directory holding a theme file that says which segments appear, and a colourscheme file that says which colours those segments use, with the colour definitions themselves in a shared file. If the default theme for your window manager includes a segment you do not want, and your local theme file does not mention it, the global theme's version is what you get.
So removing a segment means either naming every segment you want in your local file, including the ones you are keeping, or editing the installed files under the package directory, which the documentation elsewhere tells you how to find for each install method.
That second route is the one to avoid, because a package upgrade overwrites it.
The consequence is that you should write local theme files as complete lists rather than as patches, and that the global configuration files are effectively read-only defaults rather than something you are meant to edit in place.
The header says the version is beta while the releases are at two point eight
There is a small table at the top of this front page, styled as a bordered grid, and one of its rows is wrong.
The rows are the author, the source location, and the version. The version cell does not contain a number. It contains the word beta.
The project, meanwhile, has released three versions in the two point eight series, the newest of them in 2024, and the source tree's default branch is named develop rather than a release branch.
So the front page is asserting a pre-release status that the release history does not support, and it is the kind of thing that has sat there long enough to stop being read.
There is also a Python 2 notice directly under the table, saying the project does not support Python 2 anymore and will stop working with it in the near future. That is a second statement about support status, and it is from an era when it was worth saying. The current Python floor is stated elsewhere in the document as a version from the middle of the previous decade, and the install instructions still give the package directory for that same old version.
So the consequence is that the front page carries three different vintages of statement about compatibility, and none of them is being maintained. Read the installation guide rather than the readme for anything about which Python you need.
The two lists of supported applications on the front page do not match
There are two lists of what this project supports, the repository description and the readme, and they disagree.
The repository description names a statusline plugin for one editor, and then says it provides statuslines and prompts for several other applications, naming a shell, another shell, a terminal multiplexer, a notebook, a window manager and another window manager.
The bolded paragraph at the top of the readme names a longer list. It has the two shells, adds a third shell the description does not mention, the multiplexer, the notebook, and three window managers where the description names two.
The readme list is the correct one. The description is missing the third shell and one of the window managers.
Neither list is the project's problem so much as a reminder that repository descriptions are written once and rarely revisited. The description also does not carry the maintenance status, which is on the readme where you find it only if you scroll past the table.
The consequence is that the readme list is the one to trust for coverage, and the framework's willingness to support an application you care about is not something the description's count predicts.
A daemon exists because starting Python on every prompt was too slow
The performance feature on this front page is a direct consequence of the design, and the explanation is more useful than the claim.
The stated focus is good performance with as little code as possible while still providing a rich set of features. Then the specific problem: without help, prompts and statuslines would each launch their own Python process, because that is what a shell does when you ask it to evaluate something on every prompt.
The solution is a daemon, which the front page says ensures only one Python instance is launched for prompts and statuslines.
That is the whole architecture in one sentence. A shell integration cannot call a library in-process, so every prompt would normally start an interpreter, read configuration, compute a layout, and exit. On a fast machine that is a visible delay on every prompt, which is why naive prompt plugins feel sluggish.
A daemon turns N interpreter starts per prompt into one long-lived interpreter with a socket. The trade is a background process that has to be running, a little more moving parts, and one more thing to go wrong when a configuration change does not take effect because a stale daemon is still serving.
The front page also notes that the project explicitly does not have a line-count goal, which is a candour worth reading alongside the performance claim. It is telling you the performance work was not done by making the codebase small.
So the consequence is that the daemon is not an optimisation you can skip; it is what makes the approach viable, and it is also the most common thing to suspect when a configuration change appears to do nothing.
Editorial conclusion
This is worth having if you already have it configured, because a daemon keeps one interpreter alive instead of starting one per prompt, and that is the difference between a prompt that feels instant and one that does not. If you are installing it fresh, the cost is the font: the glyphs do not exist in ordinary monospace fonts, so you are replacing your editor font and your terminal font as part of setting up a statusline. Two things to weigh against that. That the front page itself points you at a lighter plugin if speed or fuss matters, and that the packaging in this repository imports a module that current Python no longer ships, so installing from source is a different job than it was.
Frequently asked questions
What is powerline?
In this project, a statusline plugin for a text editor that has grown to provide statuslines and prompts for several other applications, including two shells, a third shell, a terminal multiplexer, a notebook and three window managers. It was completely rewritten in Python to reduce how much editor script it required, which the front page says allowed better extensibility, leaner configuration files and a structured codebase with no mandatory third-party dependencies other than a Python interpreter.
Is powerline open source?
It is a public repository with a contributor guide and a licence file at the top level. The package is published under a different name from the project, with a status suffix, and configuration is handled entirely through JSON files in a per-user directory so the same configuration works across every supported application.
How do I install powerline?
Configuration lives in JSON files under a per-user configuration directory, and the documentation advises copying the shipped defaults into it as a starting point. The shipped defaults live inside the installed package, and the readme gives their location for the three install methods it covers: a system package manager, an Arch package, and a Python package install. It also links a separate repository of pre-patched coding fonts, which are required for the glyphs to render.
What is the difference between Powerline networking and this project?
They are unrelated. Networking powerline is a technology that carries data over electrical wiring. This project is a terminal statusline and prompt renderer that uses a patched font. The two share only a name.
is powerline still maintained
The default branch is named develop and took a push on 2026-03-11. The three newest releases are in the two point eight series, with the newest from 2024-08-29, preceded by one from 2022 and one from 2021. The front page's header table still says the version is beta, and the packaging script imports a compiler helper from a standard-library module that current Python releases no longer ship.
what is powerline better than
The front page answers this itself. It anticipates the objections, that you dislike Python, do not want shell prompts, consider it too much hassle, or want to know what happened to the original project it derives from. Then it recommends looking at the derivatives, and names one as currently the most lightweight and feature-rich alternative.
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/powerline-powerline)Star history chart for your README
[](https://hysenlabs.com/projects/powerline-powerline)Was this useful?