[Programming Languages] Valid or Void? Venturing into the V Programming Language
Introduction
If there was one aspect of modern society that can be considered closest to magic, it would certainly have to be computers. What else would you call cutting crystals of a shiny rock and making it think with lightning? And just like any self-respecting school of magic, computers respond to special languages: programming languages.
Programming languages are special languages that tell the program what to do (ex. “Add these two numbers”), and are what make up programs. They have been around for about as long as digital computers have, and there is a storied history of old and new languages evolving to meet different needs and niches as they popped up. This means that different languages have different strengths and weaknesses: C is used for very fast and lean programs like operating systems, while JavaScript makes websites interactable in your browser.
In order to make better programs, there is an ongoing quest to make better programming languages by solving the problems with current languages. One of these problems is managing computer memory. Languages like C are very fast, but require the programmer to personally decide how to deal with many memory objects; this means that objects are often forgotten and not cleared (like not cleaning up the garbage in your room) or programs try to access already freed memory (like trying to find that antique you just threw in the after it got hauled away in the dumpster). On the other hand, languages like JavaScript manage memory by using a garbage collector, which automatically allocates and frees memory (like having your mom clean up after you). However, garbage collectors can lead to pauses and other performance problems (because your mom will nag you).
One holy grail of programming language design is to find a way to manage memory that is as performant and flexible as it is in C while having the safety of a garbage collector. Some languages do this by creating rules around what kinds of programs they will allow, like having a very strict organization system with airtags on everything. Unfortunately, these workarounds can make the languages difficult to learn and slow to use in development. However, a new open-source language announced in 2019 promised to completely reinvent memory management, among other bold claims that, if all met, would revolutionize computer programming.
History of V
With this knowledge about programming languages in mind, this brings us to the subject of this post, the V language.
As we alluded to in the previous section, a new programming language named V was announced in 2019. That’s perfectly normal, but what caught many people’s attention were the promises V’s developers made regarding the language’s capabilities. To quote its official website, V would be fast, simple, and safe, among other traits - qualities it claimed no other language had all of at the same time.
Remember what we previously mentioned about memory management and how it can be a tradeoff between speed and convenience? V promised to revolutionize memory management by inserting calls to free memory when necessary, which was later called autofree. In the earlier example about picking up trash, this would be like placing a bunch of trash cans in your room such that when you throw your trash out behind your back, the trash always lands in the trash can and funnels into a Rube Goldberg machine that leads to the garbage truck. This feature would essentially provide the simplicity of garbage collection without any of the runtime costs, which would no doubt set V apart from its contemporaries.
Promises and Delivery
Of course, it’s fine to promise cool new features, as long as they are feasible and are delivered in a timely manner. Has the language met the expectations they set? Let’s see:
The most substantial feature that the language is trying to push is autofree. Unfortunately, it does not work. According to this blog post, early builds of the language are far from leak-free, and current builds compiling programs using the “-autofree” tag crash. As of January 12, 2025, the official documentation on GitHub notes that “Autofree is still WIP. Until it stabilises and becomes the default, please avoid using it.” The default memory management system is a tracing garbage collector.
V has also promised “no undefined behavior”. An undefined behavior is one that has an unpredictable outcome: for example, if you divide by zero in C, you could get 0, or your computer could blow up completely. The uncertainty in this response is what makes it undefined. Compilers sometimes use undefined behavior to put in optimizations, but that is not a given. V’s promise was essentially that it would always be predictable.
If you think that sounds hard to promise across every single program, you wouldn’t be wrong: take the earlier example of dividing by 0: if you divide by 0 in V, the code is translated into C code that divides by 0 - which is still an undefined behavior. The V developers claim that this is defined behavior because the language Go uses a similar approach, although dividing by 0 is undefined in Go as well. This blatantly goes against the common understanding of “undefined behavior” in such a way that it is like saying that you meant to spill milk on the floor in order to clean it.
What if you like the V language but can’t afford to divorce yourself from your existing codebase written in another language, like C? Well, V has a solution for you: the compiler promises to take C code and convert it to V code, with no drawbacks. This would allow you to take an existing program like the video game Doom and then port it to V. That’s exactly the kind of thing that was promised; in fact, the website claimed that programs such as Doom and SQLite had already been successfully transpiled to V, although the articles that were used to back up these claims were either never made or have disappeared somehow. Eventually, the claims that the transpilation has already been achieved degenerated into being worked on, to eventually being planned. The current state of the project cannot transpile C or C++ to V.
There are many other cases like this where the project’s website and developers have twisted words or lied about features, but to get into all of it would require a lot of technical jargon. This is a post about drama.
The V Community
As a result of these unmet promises, many outsiders came to see V as a bundle of unfulfilled promises and empty hype. The top comments in this 2019 Reddit post announcing V’s upcoming release are filled with suspicion and questions about the language’s actual performance. After the first alpha build was released later that year, an article by technical educator Xe Iaso tested all of V’s then-promised features and found that they were all either work in progress or not present at all. Xe Iaso later published two follow-up articles in 2020, noting that while some of their initial issues had been fixed, the language as a whole was still a work in progress.
Subsequent articles by GitHub user skvortsov (published in 2023) and software engineer Justinas Stankevičius (published last year) used to help write this post express similar skepticism on V’s ability to meet its own promises.
This has led many people to call V and its developer, Alexander Medvednikov, a scam. While there are definitely people who hate V and refuse to give it any benefit of the doubt, it’s disingenuous to lump in legitimate critics with the unabashed haters and not listen to what they have to say.
The V community sees things differently, as all three authors we mentioned above have been banned from the V community’s online spaces. Xe Iaso was blocked from seeing the V team’s Twitter and filing new issues with the language, skvortsov was banned multiple times from the V community Discord, and Justinas was temporarily muted from the V subreddit. We might be too, if Alex sees this post go up.
Money
If V were just an experiential programming language on GitHub, it might be viewed as a simple passion project that made some unrealistic promises. Where the situation gets complicated is that the attention around V does not just take the form of Reddit posts or GitHub discussions. The official V website offers links to sponsor the project (with money), donate to a development PayPal (with money), support the Patreon (with money), or buy merch (with money, but that weasel is pretty cute).
While the monetization of the project isn’t obtrusive and there’s nothing inherently wrong with crowdfunding, the fact that the language has continuously failed to deliver calls into serious question whether or not the money given by donors and supporters has produced quantifiable results.
Why Does This Matter
This might be a surprise, but there isn’t an infinite amount of stuff in the world. Resources are finite, so at least in the long term, effort and money moved to one project means that another is losing out. This is one of the causes of competition, even competition between entities that don’t make a profit like open-source software. A good example of this happened in the 90’s, when a fork of GNU Emacs called XEmacs became popular. Although XEmacs ultimately died, its existence spurred the developers of Emacs to implement features present in XEmacs to compete.
While competition is good, because V is taking up so much attention while not presenting any improvements, it takes away resources that could be going to other projects. Such languages include:
- https://odin-lang.org/
- https://futhark-lang.org/
- https://sourceforge.net/projects/seed7/
- https://www.oilshell.org/
- https://vale.dev/
Open source projects such as programming languages form the underpinning of modern society and thus deserve to be respected and treated seriously. But when you don’t take the work seriously… well, veird things happen.
Sources:
https://n-skvortsov-1997.github.io/reviews/
https://justinas.org/the-bizarre-world-of-v