V (programming language)

V

The official V logo
Paradigms	Multi-paradigm: functional, imperative, structured
Designed by	Alexander Medvednikov
First appeared	25 June 2019 (2019-06-25)
Stable release	0.4.x
Typing discipline	Static, strong
Implementation language	V
Platform	Cross-platform
License	MIT
Filename extensions	.v, .vsh
Website	vlang.io
Influenced by
Go C Rust Swift Python Oberon-2
Influenced
Aixt

Search V (programming language) on Amazon.

V, or Vlang, is a general-purpose programming language designed by Alexander Medvednikov. It is mostly inspired by the Go programming language but was also influenced by C, Rust, and Oberon-2. The foremost goal of V is to be easy to use, and at the same time, venturing to enforce a safe coding style through elimination of ambiguity. For example, variable shadowing is not allowed; declaring a variable with a name that is already used in a parent scope will cause a compilation error.

History

The language came about because of frustration with existing programming languages that were being used for personal projects. Originally the new language was intended for personal use, but after it was mentioned publicly and gained interest, it was decided to make the language public. Initially, it had the same name as a product known as Volt. The V language was created in order to develop it, along with other software applications such as Ved (also called Vid). As the extension in use was already ".v", to not mess up the git history (and reduce drama), it was decided to name it "V". Upon public release, the compiler was written in V, and could compile itself.

Along with the language creator, its community has a large number of contributors who join the project and have helped with continually developing the compiler, language, and modules. Key design goals and features that V seeks to deliver are: easier to learn and use, higher readability, fast compilation, increased safety, efficient development, cross-platform usability, improved C interop, better error handling, modern features, and more maintainable software.

Veasel is the official mascot of the V programming language, which is shown above.

Features

Safety

• Bounds checking
• Mandatory error checks
• Option/Result types
• Sum types
• Generics
• Immutable variables by default
• Immutable structs by default
• Immutable function args by default
• No undefined values
• No variable shadowing
• No null (allowed in unsafe code)
• No undefined behavior (WIP)
• No global variables (can be enabled for low level via flag)

Performance

• Fast like C (V's main backend compiles to human readable C), with equivalent valid code.
  • Various features can be reviewed, disabled, and bypassed when speed is more important.
• C interop without any costs
• Minimal amount of allocations
• Built-in serialization without runtime reflection
• Compiles to native binaries without any dependencies

Fast build

V is written in V and can compile itself in less than a second.

Flexible memory management

V avoids doing unnecessary allocations by using value types, string buffers, and promoting a simple abstraction-free code style.

Presently, allocations are handled by an optional GC, as the default (which can be disabled).

Autofree can be enabled with -autofree. The compiler inserts necessary free calls automatically during compilation. The remaining percentage of objects are freed via GC.

For developers willing to have more low level control, memory can be managed manually with -gc none.

Arena allocation is available via v -prealloc.

Source code translators (code transpilation)

V can translate entire C projects (via modules). For example, translating DOOM from C to V, which can take less than a second.

Working translators, under various stages of development, exist for Go, JavaScript, and WASM.

Syntax

Hello world

fn main() {
	println("hello world")
}

Structs

struct Point {
	x int
	y int
}

mut p := Point{
	x: 10
	y: 20
}
println(p.x) // Struct fields are accessed using a dot
// Alternative literal syntax for structs with 3 fields or fewer
p = Point{10, 20}
assert p.x == 10

Heap structs

Structs are allocated on the stack. To allocate a struct on the heap and get a reference to it, use the & prefix:

struct Point {
	x int
	y int
}

p := &Point{10, 10}
// References have the same syntax for accessing fields
println(p.x)

Methods

V doesn't have classes, but you can define methods to types. A method is a function with a special receiver argument. The receiver appears in its own argument list between the fn keyword and the method name. Methods must be in the same module as the receiver type.

In this example, the can_register method has a receiver of type User named u. The convention is not to use receiver names like self or this, but a short, preferably one letter long, name.

struct User {
	age int
}

fn (u User) can_register() bool {
	return u.age > 16
}

user := User{
	age: 10
}
println(user.can_register()) // "false"

user2 := User{
	age: 20
}
println(user2.can_register()) // "true"

Error handling

Optional types are for types which may represent none. Result types may represent an error returned from a function.

Option types are declared by prepending ? to the type name: ?Type. Result types use !: !Type.

link

fn do_something(s string) !string {
	if s == "foo" { return "foo" }
	return error("invalid string")
}

a := do_something("foo") or { "default" } // a will be "foo"
b := do_something("bar") or { "default" } // b will be "default"
c := do_something("bar") or { panic("{err}") } // exits with error 'invalid string' and a traceback

println(a)
println(b)

Vweb (or Veb)

import vweb

struct App {
    vweb.Context
}

fn main() {
	vweb.run(&App{}, 8080)
}

or

import vweb

struct App {
    vweb.Context
}

fn main() {
	vweb.run_at(new_app(), vweb.RunParams{
	    host: "localhost"
	    port: 8099
	    family: .ip
	}) or { panic(err) }
}

ORM

V has a built-in ORM (object-relational mapping) which supports SQLite, MySQL and Postgres, but soon it will support MS SQL and Oracle.

V's ORM provides a number of benefits:

• One syntax for all SQL dialects. (Migrating between databases becomes much easier.)
• Queries are constructed using V's syntax. (There's no need to learn another syntax.)
• Safety. (All queries are automatically sanitized to prevent SQL injection.)
• Compile time checks. (This prevents typos which can only be caught during runtime.)
• Readability and simplicity. (You don't need to manually parse the results of a query and then manually construct objects from the parsed results.)

import pg

struct Member {
	id         string [default: "gen_random_uuid()"; primary; sql_type: "uuid"]
	name       string
	created_at string [default: "CURRENT_TIMESTAMP"; sql_type: "TIMESTAMP"]
}

fn main() {
	db := pg.connect(pg.Config{
		host: "localhost"
		port: 5432
		user: "user"
		password: "password"
		dbname: "dbname"
	}) or {
		println(err)
		return
	}

	defer {
		db.close()
	}

	sql db {
		create table Member
	}

	new_member := Member{
		name: "John Doe"
	}

	sql db {
		insert new_member into Member
	}

	selected_member := sql db {
		select from Member where name == "John Doe" limit 1
	}

	sql db {
		update Member set name = "Hitalo" where id == selected_member.id
	}
}

Other features

The Vinix Operating System is a demonstration of V's ability to make a usable OS that can run on real hardware, not just emulators or virtual machines. It targets modern 64-bit architectures, CPU features, and multi-core computing. Aims to have source-level compatibility with Linux, allowing the porting over of programs.

Further Reading

Books & Magazines

• Laboratory, Independent (June 20, 2020). V言語入門 (The V Programming Language) (in 日本語). ILab. ASIN B08BKJDRFR. Search this book on
• Rao, Navule (December 10, 2021). Getting Started with V Programming. Packt Publishing. ISBN 1839213434. Search this book on
• Lyons, Dakota "Kai" (April 13, 2022). Beginning with V Programming. Independently Published. ISBN 8801499963. Search this book on
• Tsoukalos, Mihalis (May 2022). "Discover the V language". Linux Format Magazine (288). ISSN 1470-4234.
• Chakraborty, Soubhik; Haldar, Subhomoy (December 6, 2023). Randomness Revisited using the V Programming Language. Nova Science Publishers. doi:10.52305/CVCN5241. ISBN 8891133280. Search this book on
• Trex, Nova (December 24, 2024). V Programming: Building Robust and Efficient Software Systems Kindle Edition. Wang Press. ISBN 8304813778. Search this book on
• Sanders, Rafael (September 18, 2025). V Language for Beginners: How to Code with V for Fast, Simple, and Maintainable Software. Lincoln Publishers. ISBN 8263861681. Search this book on
• Sanders, Rafael (September 18, 2025). V Language Intermediate Guide: How to Build Reliable Software with V’s Simple but Powerful Features. Lincoln Publishers. ISBN 8263865429. Search this book on
• Silva, Esli (November 11, 2025). Programando em Vlang (Programming in Vlang) (in português). Independently Published. ISBN 6501793047. Search this book on

Translated Documentation

• "V language learning notes". GitBook (in 中文).
• "V documentation". Qiita (in 日本語).

External links

• Official Vlang Website
• Official Vlang Twitter
• Official Vlang Discord
• Official Vlang YouTube

V Language Review (Videos)

• An introduction to V - the vlang (2022)
• How To Maintain And Iterate With V - SYNCS (2023)
• Is V Lang Better Than Go And Rust? Let's Find Out (2023)
• V language - First Impression (2024)
• V S01E01 Intro (2025)

References

This article "V (programming language)" is from Wikipedia. The list of its authors can be seen in its historical and/or the page Edithistory:V (programming language). Articles copied from Draft Namespace on Wikipedia could be seen on the Draft Namespace of Wikipedia and not main one.

📰 Article(s) of the same category(ies)

• Dingtone
• MediaWiki
• Hypra
• TCExam
• FastFlow
• Zig Programming Language
• ORMLite

---