vim-test's runner table has three languages sharing two identifiers
Run your tests at the speed of thought
At a glance
- What is it?
- vim-test is a Vim plugin that wraps test runners behind one abstraction, with no dependencies and no configuration. The page is mostly a table of runner identifiers by language, and reading the table closely is more informative than the feature list: three languages share the same two identifiers, one row has more identifiers than runner names, and one identifier contains a space.
- Who is it for?
- vim-test suits a Vim user whose projects span several languages, and who wants one keybinding instead of learning each runner's invocation. Two things to check before you rely on it.
- 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 1 day ago.
- What is it written in?
- Mainly Vim Script, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 21, 2026, and from our analysis. They are not legal advice.
Star history
- vim-test/vim-test3,166 ★ · +1
| Repository | 2026-09-24 | 2026-11-21 |
|---|---|---|
| vim-test/vim-test | 3.2k | 3.2k |
1 Stars in the last 58 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The core is an abstraction, and the runners plug into it
The plugin's architecture is described in three sentences, and they are the design.
It consists of a core which provides an abstraction over running any kind of tests from the command line. Concrete test runners are then simply plugged in, so that they all work in the same unified way.
That is the whole idea, and it is a narrow one: the plugin does not wrap a testing framework, it wraps the act of invoking one. Anything that can be run from a command line can therefore be made to look like every other runner from inside the editor.
The rest of the feature list is the same idea applied to the surrounding problems. The runners are detected automatically, so there is no registration step. The nearest test is found by falling back to constructed patterns rather than by a configuration file. The execution environment is called a strategy, which is the word for where the test runs. And the command line options are configurable, which is the one concession to the idea that detection cannot be right every time.
The description of the plugin is a slogan about speed, but the mechanism is the abstraction, and that is what makes twenty-odd languages plausible.
Three languages share two identifiers, and the JavaScript row is the outlier
The runner table is the bulk of the page, and it is worth auditing rather than skimming.
Twenty-one language rows are visible before the page is cut off, from a managed runtime through a systems language, a Lisp, a Crystal dialect, two Dart test tools, two Elixir frameworks, Elm, three Erlang runners, four Go runners, two JVM build tools, a twenty-entry JavaScript row, a shared JVM row, a Lua runner, a Mint runner, a Nim runner, nine PHP runners, a Perl runner, eight Python runners and a Racket runner.
Two arithmetic observations fall out of it.
First, the rows for three JVM languages are identical. Groovy, Java and Kotlin each list the same two identifiers, the same two build tools, with the DSL variation noted once. So one entry in the code serves three languages, and the table is one row wide where it could be three.
Second, the JavaScript row has nineteen runner names and twenty-two identifiers. Two identifiers have no matching name in the list: one is a testing library that appears in the identifier column but not the runner column, and one points at a runner name that does not appear at all. And one identifier contains a space, which cannot be what you type on a command line.
None of that makes the table unusable. It does mean the table is maintained by hand, and that the authoritative list for a given runner is the commands documentation rather than the overview.
Finding the nearest test is done by constructing patterns
One feature bullet is more specific than the rest, and it describes a technique rather than a capability.
The plugin provides a polyfill for nearest tests, and the parenthetical says how: by constructing regular expressions. The bullet links to the commands section rather than to a description.
So the file-to-test mapping is not a table you configure. It is derived, per runner, by building patterns that express where a runner expects to find tests for a given source file. That is a reasonable design for a plugin that supports twenty-odd ecosystems, because the alternative is maintaining a manifest of directory conventions per language, and every new runner would need a new entry in it.
The cost is that the patterns are the plugin's opinion about your project layout. A project that keeps tests somewhere unusual will get the nearest-test behaviour wrong, and the fix is the extension path rather than a setting.
The same paragraph covers the other half of the abstraction. The execution environments are called strategies, and both runners and strategies are listed as things you can extend, which tells you where the project's own maintainers expect new work to go.
Zero dependencies and zero configuration, argued on a wiki page
The feature list opens with two claims and then defends one of them in a parenthetical.
The first claim is zero dependencies. The second is zero configuration required, with a trademarked phrase about the plugin doing the right thing by itself and a link to a page describing its philosophy.
That page is doing real work. A plugin that runs other people's test runners has a strong temptation to ship a configuration file, because every runner has different conventions and a user with an unusual project will want to override something. This project has chosen detection over configuration, and the linked page is where that choice is argued.
The remaining bullets are consequences of the same position. A wide range of runners detected automatically follows from not wanting a registry. The nearest-test polyfill follows from not wanting a per-project mapping. And the ability to extend with new runners and strategies follows from accepting that detection will occasionally be wrong.
Fully customising the command line options is the escape valve, and it is the only item on the list that sounds like the configuration the plugin claims not to need. That tension is the project's central design question, and it is not resolved in the page.
The plugin is tested by a Ruby framework, with two CI configurations committed
The repository layout is a small project with an interesting twist in how it tests itself.
The Vim runtime is laid out conventionally, with an autoload directory, a plugin directory, a bin directory, and a doc directory holding the help file. There is a screenshots directory for the readme images and a pull request template.
Then there is a spec directory, a file naming a Ruby version, and a build file for a Ruby test framework. So the test-runner plugin is tested by a Ruby test runner, not by itself. The runner table lists that same Ruby framework as one of the identifiers it can drive, which makes the choice self-referential in a harmless way.
The configuration story is also two-layered. There is a GitHub directory and a Travis configuration file sitting side by side, which means two continuous integration systems are committed, with the older one still present.
For a project of this size, that is a larger commit than the feature list suggests, and it lines up with the contributing guide, the changelog and the licence file being at the root alongside the readme.
No releases, no homepage, and a description that is a slogan
Three small facts about how the project presents itself.
There are no published releases, and no homepage is recorded for the repository, so a user arriving from a search has the readme and nothing else to go on.
The repository description is a slogan rather than a description: run your tests at the speed of thought. That is a fine thing to have next to the repository name and a poor thing to have as the only metadata, since it says nothing about what the plugin does.
The default branch is the older name rather than the current default, and the most recent push is dated within the last month of the page's own timestamp, so the table of runners is being maintained.
None of this is a criticism of a two hundred line plugin. It is a reminder that the maintenance signal for this project is the table, not the release history: there is no version to pin from the release list, so the readme's runner identifiers are the interface contract, and they are edited in place.
Editorial conclusion
vim-test suits a Vim user whose projects span several languages, and who wants one keybinding instead of learning each runner's invocation. Two things to check before you rely on it. The runner table is maintained by the project rather than generated, and its rows do not line up perfectly, so verify the identifier for your runner against the commands documentation rather than against the table. And read the philosophy page if you are tempted to configure something, because the project's position is that it should already be doing the right thing and the extension path is the intended escape hatch rather than configuration.
Frequently asked questions
what is vim test
It is a Vim plugin that wraps test runners so they can be invoked from the editor at different granularities. A core provides an abstraction over running any kind of tests from the command line, concrete runners plug into it, and the plugin claims zero dependencies and no configuration.
Which test runners does vim-test support?
The page carries a table by language covering more than twenty ecosystems, each row naming runners and the identifiers that select them: a managed runtime, a systems language pair, a Lisp, a Crystal dialect, two Dart tools, two Elixir frameworks, Elm, three Erlang runners, four Go runners, JVM build tools, a roughly twenty-entry JavaScript row, Lua, Mint, Nim, nine PHP runners, Perl, eight Python runners and Racket, with more below the visible part.
Do the Groovy, Java and Kotlin rows in vim-test differ?
No, they are identical. All three list the same two identifiers, the same two build tools, with the two domain-specific language variants of one of them noted in the row. One entry in the code therefore serves three languages, and the table is one row wide where it could be three.
How does vim-test find the nearest test file?
The feature list describes a polyfill for nearest tests that works by constructing regular expressions, and it links to the commands section rather than describing the patterns. So the mapping from source file to test file is derived per runner rather than configured, which is the same no-configuration position the rest of the plugin takes.
Does vim-test need dependencies or configuration?
The feature list claims zero dependencies and zero configuration required, with the reasoning pointed at a separate philosophy page. The one concession is fully customising the command line options, and the documented escape hatch for anything detection gets wrong is extending the plugin with new runners and strategies.
How is vim-test itself tested?
With a Ruby test runner rather than with itself. The repository carries a spec directory, a file naming a Ruby version and a build file for a Ruby test framework, alongside a conventional Vim runtime layout, a GitHub directory and a Travis configuration, so two continuous integration systems are committed.
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/vim-test-vim-test)Star history chart for your README
[](https://hysenlabs.com/projects/vim-test-vim-test)Was this useful?