vlanguage-designmaturity
How mature is V, in numbers rather than adjectives
What the repository, the release cadence and the standard library actually say about V's state in 2026, and the one thing that decides whether a project can depend on it.
"Mature" gets used for two different things: is the project healthy, and can I
depend on it. V is in an unusual position where those two answers diverge, so it
is worth separating them.The project is healthyStraight from the GitHub API, read on 2026-09-30:Stars37,936Forks2,292Watchers458Open issues88LicenceMITCreated2019-02-08Last push2026-09-30ArchivednoThat is a project with seven years of continuous work, three to four thousand
issues handled, and about three contributors a day pushing to master. It is not
abandoned, and it is not a hobby project with a weekend following.The issue count is the one number that moves visibly — 88 then, 72 when I
checked again while updating this. That is a project closing issues faster than
they arrive, not one accumulating a backlog.The releases are frequent and the binaries exist
0.5.2 2026-07-12
0.5.1 2026-03-09
weekly.2026.08 2026-02-17
weekly.2026.07 2026-02-09
weekly.2026.06 2026-02-03
weekly.2026.05 2026-01-26
0.5 2025-12-31
Roughly a release every three to four months, with weekly builds in between.
Each ships five platform archives — linux, linux_arm64, macos_arm64,
macos_x86_64, windows — so cross-compilation is a supported path rather than
something you assemble yourself.Note what the version numbers mean, though. This is a language at 0.5 after
nearly seven years. Go took four and a half to reach 1.0 — February 2008 to
August 2012.V has had a stable-looking release cadence and a pre-1.0 number for its whole
life. And the compiler is still being fixed hard enough that a kernel will not
build without the fixes — PR #29161, v3: fix the compiler bugs that
stopped the Vinix kernel from compiling, merged on the day I wrote this.That PR is not the tip any more. When I last looked the tip was SIMD vector
types and a single-C-unit production build. Both facts are true at different
moments, and neither is a judgement about the project.Master is not a releaseThis matters more than any of the numbers above.The commit you get from git clone is not what a release gives you. I hit this
installing V: the checkout was on master, v.exe had been rebuilt from a newer
commit than the vlib beside it, and every standard-library import failed withbuilder error: cannot import module ""time"" (not found)
with vlib/time/chrono.v sitting right there containing module time. Setting
VROOT did nothing. Going the other way — an older binary against a newer
vlib — produced unknown type 'u128' from inside vlib/builtin/int.v.The compiler and the standard library are versioned together in a release zip
and versioned independently in a checkout, and nothing checks that they agree.
A clone-and-build V is not a supported configuration; the release is. That is a
larger gap than "the language moves fast" — it means the default thing a new user
does produces a broken install with error messages that blame the standard
library.The standard library is the weak partThe free functions in strings are a short list:random
find_between_pair_u8
find_between_pair_rune
find_between_pair_string
split_capital
repeat
repeat_string
Plus a Builder and a set of string-distance functions — levenshtein_distance,
jaro_winkler_similarity, dice_coefficient and others.There is no strings.split, no strings.to_lower, no strings.trim. In Go that
module is the one you reach for constantly. In V, string handling is methods on
the type:parts := "a,b,c".split(",")
println(parts.join(","))
println("mahdi".to_upper())
println("a-b-c".replace("-", "/"))
println(" x ".trim_space())
That is a defensible design and I do not mind it — arguably split belongs to a
string more than to a namespace. But it means porting Go code fails at every
string call.I could not find strings.replace_all, strings.count, strings.index_any, or
anything resembling strings.NewReplacer. For a language whose pitch is that it
is batteries-included, strings is where I would spend the next round of work.The thing that would decide this for a projectGetting the source is a manual step. Not the compiler, not the language —
the install. Nothing verifies that the v.exe and vlib you downloaded came from
the same day, and when they have not, every error points at a module or a type
instead of at the installation.That is a bigger deal than a missing library, because a missing library fails
loudly on the line you call it. This one produces a working compiler that rejects
a file it should accept:main.v:2:1: builder error: cannot import module ""time"" (not found)
vlib/time/chrono.v is sitting right there with module time on line 5.A compiler that refuses to start when its own standard library does not match
would turn a twenty-minute diagnosis into one sentence. That is the check I would
want before depending on V for team work.Where it landsBefore the criticism. I write these notes because I want to use V, and I
could not decide whether to without knowing where it stands. What follows is
the honest answer, including the part that is not flattering. It is not an
argument against the language — the mutability default is better than Go's and
the compile speed is better than most things I have used. If you are here to
find a reason not to try V, the same posts should send you the other way.The project is not the risk. Seven years of work, a maintainer who ships weekly,
38,000 stars, 88 open issues — that is a healthy project with a lot of people
using it, and none of that is in doubt.The risk is narrower than it looks. The compiler and the standard library move
together at a pace where nothing guarantees they agree, and the failure presents
as a broken standard library rather than a broken install. strings being thin
is an inconvenience you discover once.I would use V for a single-file CLI or a scratch tool today, with no hesitation.
For a shared service I would want the version check first — not because the
language design is not ready, which is a separate question and largely settled,
but because a toolchain that cannot tell you it is inconsistent makes every other
problem harder to diagnose.