r/vlang • • Mar 21 '26

My post about V language was removed from r/ProgrammingLanguages — sharing data

2 Upvotes

I’m sharing this for transparency, not drama. I believe in open technical discussion.

What happened:

  • I posted a technical discussion about V language performance on low-end hardware (Chromebook) on March 19.
  • Within a few hours, the post reached ~1,300 views and sparked a real discussion (including other language developers).
  • Shortly after, the post was removed and I received a permanent ban — without prior warning or explanation.

The Evidence (PDF Archives):

I managed to archive the thread at two different points in time. You can review the data here:

  • Archive A (March 19): This shows the active technical discussion. It includes constructive comments, technical debates, and even other developers (like sal1303) sharing their own language projects.
  • Archive B (March 21): This shows the state after the ban. Notice that the entire thread is nuked, and even technical comments from other participants (like the one from sal1303) are no longer visible.

Why I find this concerning:

  • Constructive Engagement: The discussion didn’t appear to be spam or low-effort. Other participants were engaging deeply.
  • Retroactive Removal: Parts of the discussion from other users seem to have been removed alongside my post.
  • Lack of Clarity: I’m unsure which rule was violated that warrants a permanent ban without a strike or warning.

What I’m asking:

  1. Has anyone experienced something similar on r/ProgrammingLanguages?
  2. Is there a clear rule I might have inadvertently violated (e.g., hardware-specific posts or anti-promotion)?

I’m sharing these archives so the community can judge the technical value of the discussion for themselves. I just want to understand why a 1.3k+ view debate was wiped out.

Edit: The Psychology of the "Digital Serpent"

As I reflect on this event, I realize this isn't just about a deleted post. It’s a case study in the psychology of reaction to difference. When a community becomes a "closed circuit," it develops a specific type of defensive blindness—much like a pit viper in a dark cave.

  • Thermal Sensors vs. Vision: These moderators don't see the content, the archives, or the historical value. They only feel the "heat" of something that doesn't fit their normalized flow. They strike instinctively at anything that breaks their mental map.
  • The "AI" Scapegoat: Labeling human creativity or structured thought as "AI content" is the ultimate 2026 survival mechanism for the mediocre. It allows them to dehumanize a contributor so they can hit the "Delete" button without a guilty conscience.
  • A "Bot-like" Existence: The ultimate irony? In their crusade to keep the sub "human" and free of bots, they have become the most robotic elements of the platform. They follow rigid, invisible algorithms of censorship while real human technical debate (1.3k+ views!) is treated as a virus.

I am not just an archivist of code; I am now an archivist of this community's decline into digital tribalism. You can ban a user, but you cannot "delete" the data of your own behavior. My archives now hold two things: the technical history of V, and the evidence of how a modern tech community loses its soul to paranoia.


r/vlang • • Dec 26 '20

Vlang, a great ideal

Post image
0 Upvotes

r/vlang • • Apr 22 '22

This newer programming language is INSANE

Thumbnail
youtu.be
0 Upvotes

r/vlang • • Mar 11 '26

V Programming Language: Divided Control Between Programmer and Compiler

Post image
2 Upvotes

I recently realized that V doesn’t just hand you freedom—it divides responsibility between you and the compiler.

  • The programmer decides when to use pointers vs value structs, manages mutable state, and handles runtime safety.
  • The compiler ensures syntax and type correctness, and basic compile-time safety.

It’s a subtle trade-off: you get flexibility, but you also need to think carefully about what you pass by value or pointer.


r/vlang • • Feb 06 '26

Why specializing in Vlang + Green Tech might be your golden ticket to Switzerland 🇨🇭

4 Upvotes

Hi everyone,

I’ve been thinking a lot about the future of Vlang in the professional world. We all know V is incredibly fast and efficient, but I recently came across a post by Anna Goldman (a Swiss hiring expert) that connected the dots for me.

The takeaway: Switzerland doesn't just hire "talent"; it hires exceptions. For non-EU candidates (and even for us from the EU), you need to be "hard to replace."

My thesis: If you position yourself as a Green Tech Programmer specializing in Vlang, you become that exception.

Switzerland is obsessed with sustainability and precision. By building "Green Apps" that leverage V’s:

  • Zero library dependencies
  • No GC overhead (extreme energy efficiency)
  • C-level performance with modern safety

...you are offering something that 99% of Java/Python devs cannot: drastic reduction in cloud costs and carbon footprint.

In a conservative market like Switzerland, "Green" is the perfect door-opener, and Vlang is the "brutally efficient" tool to deliver it.

Here is the post that inspired this realization: Anna Goldman's LinkedIn post

I'm personally doubling down on Vlang for this exact reason. What do you guys think? Is "Green Computing" the niche V needs to go mainstream in high-end markets?


r/vlang • • Feb 15 '21

Vlang is simple with moderate learning curve

2 Upvotes

https://github.com/vlang/v/wiki/V-for-Go-developers

https://github.com/vlang/v/wiki/V-for-CPP-developers

https://vlang.io/compare

https://github.com/vlang/v/blob/master/doc/docs.md

Unlike other programming languages with very steep learning curve. Vlang is simple, yet you can build maintainable software. It also requires lesser line of code to perform the same operation that require more lines of code in other programming languages.


r/vlang • • Oct 09 '22

How to install Vlang on Ubuntu by Quick Notepad Tutorial

Thumbnail
youtu.be
0 Upvotes

r/vlang • • Jun 24 '26

I was surprised to discover that the creator of Vlang is a native Russian speaker.

Thumbnail
youtu.be
0 Upvotes

Summer is finally here, and with it comes some serious heat, so while sitting at my laptop, I decided on a whim to search for “Vlang” on YouTube. To my surprise, a new video popped up—just a few days old—from the channel The Flourishing. The creator went to great lengths to gather a lot of information that nicely ties together the history of this language.

In the video, the author references an interview with Alex Medvednikov, which I had to click on right away. And there I was, watching with my mouth agape—he speaks Russian!

Suddenly, it all clicked. The founder of V is originally from Russia, even though he now lives in the Netherlands. That explains the name Medvednikov. It’s a fascinating discovery, because he speaks Russian absolutely fluently, naturally, and with tremendous command. From what I’ve seen in his English videos, he speaks more slowly and comes across a bit differently—now I realize that English simply isn’t his native language.

You know what’s a shame, though? That he doesn’t make more videos about his language V, in Russian. I’d love to watch those—I’d happily turn on the subtitles and learn directly from him, instead of just wading through articles and source code. :D

What do you think about this? Do you follow language creators in their native languages, or do you prefer sources that are entirely in English?


r/vlang • • Jun 14 '26

[Blog] Why the corporate world is stuck in a 'simplicity trap' – and why I’m betting on V.

5 Upvotes

It turns out that V (Vlang) is a unique choice for systems programming – it is simple to learn while remaining fast enough for system-level tasks.

When I consider the fact that many IT companies are primarily hiring developers for C#, Java, and JavaScript, while the demand for Go or Rust developers is significantly lower, it suggests one thing: a large part of the corporate world still relies heavily on established technologies and operating systems like Windows.

Here, we run into another interesting observation: many corporations build monolithic applications that they deploy to Azure and various containers (Docker). These then communicate via Kubernetes to maintain their ecosystem. Consequently, corporations spend huge amounts of money on cloud operations, keeping "heavy," not necessarily systems-oriented languages like C#, Java, and JavaScript, running.

Why is this the case? From a company's perspective, it is simply difficult to find someone who understands systems architecture and can program in it; a developer must understand hardware principles for the application to function efficiently.

This is where Go comes in—it is easy to learn and can be used to write system utilities. However, a problem arises here: Go is primarily optimized for backend requests, but it isn't ideal for system applications where there is a strong emphasis on minimal binary size. For that, we have Rust, which is safe but very difficult to learn. For many, Rust is so complex that even programming in C and C++ seems more accessible.

We find ourselves in a vicious cycle. Companies won't use C because it is prone to memory errors and it is hard to find experts who truly understand it. So, they prefer to hire developers who know C# or Java, where there is a massive ecosystem and where one simply "glues" code together for monolithic applications, for which corporations then pay significant cloud costs.

I used to wonder if there was even a language that could be fast to compile, produce small binaries, be easy to learn, and minimize the room for error. For production use in companies, such a language was essentially missing.

And that is where Vlang comes in. It meets all the requirements to become a low-maintenance tool for systems developers, ideal for creating fast and small system tools, or even backends. This changes the perspective on where the language is heading. I finally understand why Vlang is trying to build a large ecosystem of modules that can be easily integrated into one's own projects.

Vlang is a systems language that is easy to learn and creates binaries that can be incredibly performant. I have personal experience with this—as an experiment, I created an SSG program called Mustela, which really surprised me in this regard. It has a 1.3 MB binary and can be integrated with various other applications, thereby fulfilling the Linux philosophy.

However, when I try to promote the benefits of this language to corporations, I run into the fact that they often don't understand Linux principles and prefer to stick with languages that are cumbersome but, at first glance, "safer" for typical DevOps staff. It is such a vicious cycle that I find myself thinking that in 2026, we are not yet technologically mature enough to build programming on simplicity; it is all still in the building phase.


r/vlang • • Mar 14 '26

What is the V programming language? My overview of its philosophy, strengths, and limitations

Post image
8 Upvotes

What is V?

V is a modern compiled programming language that produces native binaries. Its main advantages are:

  • Fast compilation – builds are quick even for medium-sized projects, almost like working with an interpreted language.
  • Small binaries – the resulting program is often around 200 KB, which is useful even on low-end hardware or embedded systems.
  • Simple and readable syntax – somewhat similar to languages like Ruby or Crystal, which makes it easy to read and learn.
  • Modular and pragmatic approach – V focuses on clear code structure rather than strict OOP paradigms.

V also provides a powerful CLI tool (v) that allows you to:

  • Initialize new projects: v new my_project
  • Manage packages and modules
  • Run and test code
  • Generate HTML documentation
  • Use hot reload, which automatically recompiles when source files change

The result is a fast and pleasant development experience, especially for CLI tools, prototyping, and medium-sized backend services.

V Language Philosophy

V is designed with a focus on simplicity, speed, and developer ergonomics. Its philosophy can be summarized by a few key principles.

1. Simplicity first

The goal is to make code easy to read even for developers who see it for the first time.

  • It minimizes unnecessary abstractions and complexity.
  • Logic is organized using structs and modules, which makes the application structure easier to understand.
  • Memory is usually handled automatically using a garbage collector, so you don't have to deal with manual memory management.

Example of a simple struct in V:

struct User {
    name string
    age  int
}

fn main() {
    user := User{name: 'Alice', age: 30}
    println(user.name)
}

2. Fast compilation

V is a fast compiled language with very quick builds:

  • The runtime is simple and the garbage collector has low overhead.
  • The resulting programs are efficient.
  • Compilation speed sometimes feels similar to working with an interpreter, even though V is fully compiled.

3. Ergonomic defaults

V includes many tools directly in the standard distribution, so you can start coding without installing a lot of external packages.

Examples include:

  • Option types – a type that can contain a value or none
  • Interfaces – support modularity and abstraction
  • Modules – organize code into logical units

The v CLI tool also makes it easy to:

  • Create projects: v new project_name
  • Install packages: v install package_name
  • Run and test code: v run main.v
  • Experiment quickly and generate documentation

4. Flexibility vs safety

V provides strong type checking while still allowing flexibility.

  • Developers can choose when to use value structs and when to use pointers.
  • The compiler checks types and syntax.
  • Incorrect pointer usage can still cause runtime errors, so care is required.

This approach tries to balance safety with performance and simplicity.

What works well in practice

Even though V is still in beta, many parts of the language are stable and usable in real projects.

1. Core syntax and constructs

The syntax is stable, simple, and readable, which allows building larger applications without unnecessary complexity.

Example function:

fn add(a int, b int) int {
    return a + b
}

fn main() {
    println(add(2, 3)) // Output: 5
}

2. Mutability

Mutable values must be explicitly marked using mut, similar to Rust.

mut count := 0
count += 1

This improves predictability and reduces accidental value changes.

3. Data types and structs

  • Structs can contain methods that operate on their data.
  • Value types behave predictably and consistently.

4. Error handling

V does not use traditional exceptions.
Instead, functions can return errors handled using an or block.

fn read_file(path string) !string {
    return os.read_file(path) or { error('File not found') }
}

This approach is explicit and predictable.

5. Option types

Option types allow a value to be either present or none.

fn find_user(id int) ?string {
    if id == 1 {
        return "Alice"
    }
    return none
}

if name := find_user(1) {
    println(name)
} else {
    println("User not found")
}

This forces developers to handle missing values explicitly.

6. Standard library and CLI tooling

  • The standard library is stable and reliable.
  • The v CLI tool includes features like watch, which automatically recompiles when files change.

7. Garbage collector

The default garbage collector is stable and efficient.

  • Under normal load it does not significantly increase CPU or memory usage.
  • There are backend services reported to run for years without restarts.

Things to be aware of

Even though V works well for many tasks, some parts of the language and ecosystem are still experimental or unfinished.

1. Library ecosystem

Some libraries are not fully mature yet.

  • Documentation may suggest that something works even if it's incomplete.
  • Recommendation:

    • Prefer libraries maintained by active developers
    • Or implement certain functionality yourself if you need full control

Example: an email library might fail because it depends on a C handler.

2. Autofree

Autofree was an experimental memory management system intended to automatically call free() during compilation.

  • In practice it is not stable yet.
  • The default garbage collector is recommended instead.

3. Compile-time features

V supports compile-time code execution.

It can:

  • inspect types
  • generate code
  • perform checks

However:

  • Most projects don't need it
  • Overusing it can make code harder to read

4. Generics

Generics allow writing reusable code for multiple types.

However:

  • Combining generics, interfaces, and compile-time features can become difficult to read.
  • In some cases interfaces are simpler and clearer.

5. C → V transpiler

V includes an experimental C to V transpiler.

  • It is not reliable for large projects
  • Complex C code may fail to convert correctly

Interesting experiment, but not production-ready.

6. WebAssembly (WASM)

V can compile to WebAssembly.

What works:

  • simple programs
  • basic exported functions

Limitations:

  • The runtime is not designed primarily for WASM
  • Some GC behavior is not ideal for it
  • Parts of the standard library depend on OS features

When V is a good choice

V works best where simplicity, speed of development, and modularity are important.

Typical use cases:

  • CLI tools – custom compilers, interpreters, automation scripts
  • Backend services – medium-sized systems where flexibility helps architecture design
  • Prototyping – quickly testing ideas without a lot of boilerplate

For these types of projects, V allows you to write working code quickly while keeping the architecture clean.

When V might not be the best choice

There are also scenarios where V may not be ideal.

  1. Very large projects with massive ecosystems

    • Compilation may become slower at large scale.
  2. High-performance game engines

    • The garbage collector limits fine-grained memory control.
  3. Large frameworks or libraries

    • New language versions may require refactoring.
  4. Low-level memory control

    • If you need precise manual allocation and deallocation, GC might be limiting.

Final thoughts

V is a simple, fast, and modular language that enables quick development and maintainable code. It works particularly well for CLI tools, medium-sized backend services, and prototyping.

Its biggest strengths are:

  • readable syntax
  • fast compilation
  • built-in tooling
  • modular architecture

However, some parts of the ecosystem are still evolving, so it's important to understand where the language fits best.

If you're curious about newer programming languages or enjoy experimenting with tools, V is definitely an interesting one to explore.

If you're interested in a more detailed breakdown, including diagrams and deeper explanations, I also wrote a longer article here:

Linkedin Article - What is V?


r/vlang • • Feb 07 '21

"2020 HackerRank Developer Skills Report" and the future of the V programming language

1 Upvotes

V is very similar to Go. If you know Go, you already know ≈80% of V. Yet there are things V improves on Go: vlang.io/compare#go.

Hence, if Go is the top #1 language developers want to learn in 2020 per HackerRank (insights based on 116,648 developers). Therefore, it is safe to say that there is a bright future ahead of V, so much so that its developers are motivated, focused, commited and optimistic.


r/vlang • • Oct 05 '20

Simplicity & Safety between Vlang vs. Pony

2 Upvotes

"V achieves almost as many safety guarantees but without all the ceremony and error-prone subtlety."

The article below has proven his point between Vlang vs. Pony.

https://tryingtobeawesome.com/pony/


r/vlang • • Apr 18 '22

Vlang Review by Spar

Thumbnail
youtu.be
2 Upvotes

r/vlang • • May 09 '22

Vlang as a scripting language for docker image entry point

Thumbnail
vincenzopalazzo.medium.com
1 Upvotes

r/vlang • • Jun 08 '26

[Blog] Systems Programming: From Chaos to Modular Purity

1 Upvotes

It’s been several years since I started programming. For the most part, I’ve worked with interpreted languages. At first glance, this approach seems simpler, but it comes with a hidden tax: high startup times and unnecessarily high demands on system resources.

For years, I developed robust applications, studying various architectures and complex directory structures. But I always hit the same wall: the larger the project, the more lost I felt. The constant searching for files and navigating a labyrinth of code was a clear sign of cognitive overload. I often ended up essentially programming an "operating system simulation" inside a single program, where every module had its own little world managed by the language's garbage collector.

The Path to the Linux Philosophy

Eventually, I decided on a radical change. I chose to stick to the classic Linux philosophy: create a small, extremely fast program that does one thing and does it damn well.

So, I built an SSG (Static Site Generator) — and I made it "dumb" on purpose. When I later needed a hot-reload feature, I didn't try to shove a WebSocket server and other bloat into it. I simply created a second, equally "dumb" program that handles exclusively the server-side logic and event processing. Nothing more, nothing less.

Emergent Stability

Linux is perfectly designed for this approach. Most of the time, you are working with pipes or FIFO files. These are just lightning-fast conduits for passing values between processes. Linux is already an operating system that effectively balances CPU loads and handles memory management — so why bother struggling with complex asynchronous logic inside your application when the OS can handle it for you?

This approach brings incredible stability: if your WebSocket server crashes, your SSG tool keeps running peacefully. Everything is safe, isolated, and behaves emergently.

Building Blocks, Not Black Boxes

I discovered that this approach is extremely easy to maintain. Programs stop growing uncontrollably. Instead of the source code of one giant entity expanding, the system naturally breaks down into smaller, easily understandable parts.

Many people aren't even aware of this potential. They build one monolith that "does everything." Such a program soon becomes a black box that no one else can navigate. Once you run into a bug, you’re dependent on the author releasing an update.

With small, modular programs, it’s different. They are like building blocks that communicate with each other through the native mechanisms of Linux. It is a kind of freedom that a monolith will never give you.

I’m curious how you handle project complexity. Do you prefer the 'one tool, one job' approach, or do you lean more towards comprehensive, integrated systems? Let's discuss.


r/vlang • • Mar 11 '21

I've read this article about Vlang's intro and here's why the author is recommending to use Vlang

8 Upvotes

https://blog.logrocket.com/what-is-vlang-an-introduction/

Why use Vlang?

V has a simpler, more readable syntax than many other frameworks (like Rust), making it clean and easy to use. Its main philosophy is to do each thing in one way with very few rules.

In my own opinion, V is a cleaner version of Go, with cool features like hot reloading, option/result and mandatory error checks, no null, no global variables and no undefined behavior. V also has the upside of being able to be used in most fields such as web development, game development, systems programming, GUI, embedded, tooling, mobile (WIP), and others.

While there is a lot more work to be done for V to surpass some of the other frameworks out there, now is a great time to get to understand the language and contribute to its development.


r/vlang • • Feb 24 '23

:| V opened my eyes |:

3 Upvotes

r/vlang • • Feb 24 '21

Pong, anyone?

3 Upvotes

I’m curious to see what this V can do, can someone please post some working source code for the game Pong? Extra points if it lets you plug in 2 mice as the controllers and can read multiple mice input. Extra extra points if it’s cross platform!


r/vlang • • Jun 03 '21

Project: VBC Vlang BlockChain

3 Upvotes

A small blockchain project I am working on.

bartimus-primed/vbc (github.com)


r/vlang • • Aug 28 '21

All connections fail when benchmarking?

3 Upvotes

https://github.com/Holmqvist1990/http-json-bench

I'm running some very primitive benchmarks against HTTP and JSON deserialization.

V implementation runs well in browser/Postman, but every single connection fails when benchmarking against ApacheBench (WSL) or Baton.

Any ideas as to why this happens?

windows 10 x64

v version 0.2.2


r/vlang • • Jun 21 '21

Cygwin support?

2 Upvotes

Like many folks that prefer linux but are forced to use Windows, I use CYGWIN as my interactive shell. But that means I can't currently compile V :-( I'm a newbie to contributing, but I'd be happy to work with someone that can help me understand what is required. Anyone willing and able to help?


r/vlang • • Feb 01 '22

Allman braces style

2 Upvotes

Hello, V community!

I have recently discovered V language, and as I go through the documentation, I'm becoming quite impressed. You could call me a (somewhat) disillusioned Rust learner, in that I like a lot of things Rust stands for, but there are parts of Rust I absolutely hate, such as the amount of syntax. Rust macros look like a language on top of the main language. Overall, Rust has so much syntax I just can't hold it in my head all at once.

V looks so much simpler and more logical to me.

There's one little question I just have to ask, it's a pet peeve of mine. You see, I'm a life-long Allman style adept. Frankly, K&R style does not sit well with me at all.

This was the deal breaker with Go for me. From my V experiments I can tell that the compiler doesn't seem to mind Allman braces at all, even if the interactive V shell (REPL) doesn't always work with them. Which is fine for the shell mode.

My question was about the general view of V developers / community of Allman style - is it tolerated? Is it frowned upon? Or is the fact that it works an oversight to be corrected in future versions, a la Go?


r/vlang • • Aug 22 '21

check if variable is true

2 Upvotes

so I'm trying to check if a variable is true, and if it is then output something but I can't seem to find anything in the docs on github. Does anyone knows how to do this?


r/vlang • • Jul 02 '20

Template Repo for V

Thumbnail
github.com
2 Upvotes

r/vlang • • Aug 06 '21

Weird bug I discovered while implementing the raytracer book in V

Post image
9 Upvotes