v

Simple, fast, safe, compiled language for developing maintainable software. Compiles itself in <1s with zero library dependencies. Supports automatic C => V translation. https://vlang.io

35,757

2,156

35,757

886

View on GitHub

Top Related Projects

zig

33,640

General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.

Nim is a statically typed compiled systems programming language. It combines successful concepts from mature languages like Python, Ada and Modula. Its design focuses on efficiency, expressiveness, and elegance (in that order of priority).

Odin

6,742

Odin Programming Language

julia

45,598

The Julia Programming Language

dmd

2,963

dmd D Programming Language compiler

Quick Overview

V is a statically typed compiled programming language designed for building maintainable software. It is similar to Go and its design goals include simplicity, safety, and compilation speed. V aims to be a general-purpose language suitable for developing various types of software, from systems programming to web applications.

Pros

Fast compilation times, comparable to or faster than Go
Simple syntax, easy to learn for developers familiar with C-like languages
Memory safety features without garbage collection
Cross-platform support and easy cross-compilation

Cons

Relatively young language with a smaller ecosystem compared to more established languages
Some planned features are still in development or not fully implemented
Limited third-party libraries and tools compared to more mature languages
Documentation can be incomplete or outdated in some areas

Code Examples

Hello World program:

fn main() {
    println('Hello, World!')
}

Simple HTTP server:

import vweb

struct App {}

fn main() {
    vweb.run<App>(8080)
}

['/']
pub fn (app App) index() vweb.Result {
    return app.text('Hello, World!')
}

Reading a file:

import os

fn main() {
    content := os.read_file('example.txt') or {
        eprintln('Failed to read file: $err')
        return
    }
    println(content)
}

Getting Started

To get started with V:

Install V:
- On Unix-like systems: curl https://raw.githubusercontent.com/vlang/v/master/install.sh | sh
- On Windows: Download the installer from the official website
Create a new V file (e.g., hello.v):

fn main() {
    println('Hello, V!')
}

Compile and run:

v run hello.v

For more information and advanced usage, refer to the official V documentation at https://github.com/vlang/v/blob/master/doc/docs.md.

Competitor Comparisons

zig

33,640

General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.

Pros of Zig

More mature and stable language with a larger community
Advanced memory management features and compile-time code execution
Better performance and lower-level control

Cons of Zig

Steeper learning curve due to low-level concepts
Smaller ecosystem of libraries and tools compared to more established languages

Code Comparison

Zig:

const std = @import("std");

pub fn main() void {
    std.debug.print("Hello, World!\n", .{});
}

fn main() {
    println('Hello, World!')
}

Summary

Zig is a systems programming language focusing on robustness, optimality, and maintainability. It offers more low-level control and advanced features but may be more challenging for beginners. V, on the other hand, aims to be simple and fast, with a syntax similar to Go. It's easier to learn but may lack some of the advanced features and performance optimizations found in Zig. Both languages are relatively new and actively developed, with growing communities and ecosystems.

crystal

19,409

The Crystal Programming Language

Pros of Crystal

More mature and stable language with a larger ecosystem
Excellent performance, close to C-level speeds
Strong type system with type inference for safety and productivity

Cons of Crystal

Longer compilation times, especially for large projects
Less cross-platform support compared to V
Steeper learning curve for developers new to statically-typed languages

Code Comparison

Crystal:

def fibonacci(n)
  return n if n <= 1
  fibonacci(n - 1) + fibonacci(n - 2)
end

puts fibonacci(10)

fn fibonacci(n int) int {
    if n <= 1 {
        return n
    }
    return fibonacci(n - 1) + fibonacci(n - 2)
}

fn main() {
    println(fibonacci(10))
}

Key Differences

Crystal uses Ruby-like syntax, while V's syntax is more similar to Go
Crystal has a more extensive standard library
V focuses on simplicity and fast compilation
Crystal offers macros for metaprogramming, which V currently lacks
V provides built-in concurrency primitives, while Crystal uses fibers

Both languages aim to combine performance with developer productivity, but they take different approaches to achieve this goal. Crystal offers more features and a richer ecosystem, while V emphasizes simplicity and rapid development.

Nim

16,530

Pros of Nim

More mature and established language with a larger community
Advanced metaprogramming capabilities and macro system
Extensive standard library and package ecosystem

Cons of Nim

Steeper learning curve due to more complex syntax and features
Slower compilation times compared to V
Less focus on simplicity and ease of use for beginners

Code Comparison

Nim:

import strutils

proc greet(name: string): string =
  result = "Hello, " & name.capitalizeAscii() & "!"

echo greet("world")

fn greet(name string) string {
    return 'Hello, ${name.capitalize()}!'
}

println(greet('world'))

Summary

Nim is a more established language with advanced features and a larger ecosystem, but it may be more challenging for beginners. V focuses on simplicity and fast compilation, making it more accessible for newcomers to systems programming. Both languages aim to provide efficient and safe alternatives to C, with different trade-offs in terms of features and complexity.

Odin

6,742

Odin Programming Language

Pros of Odin

More mature and stable language with a larger community
Better documentation and learning resources
Stronger focus on systems programming and low-level control

Cons of Odin

Slower compilation times compared to V
Less emphasis on cross-platform development
Steeper learning curve for beginners

Code Comparison

Odin:

import "core:fmt"

main :: proc() {
    fmt.println("Hello, World!")
}

fn main() {
    println('Hello, World!')
}

Both languages aim for simplicity and readability, but Odin's syntax is more explicit with its import statements and procedure declarations. V's syntax is more concise and closer to Python-like simplicity.

Odin offers more fine-grained control over memory management and data structures, making it better suited for systems programming. V, on the other hand, focuses on ease of use and rapid development, with features like built-in ORM and hot code reloading.

While both languages are compiled and statically typed, V boasts faster compilation times and a more straightforward approach to concurrency. Odin provides more advanced features for low-level programming and better interoperability with C.

Ultimately, the choice between Odin and V depends on the specific project requirements and the developer's preferences for language design and features.

julia

45,598

The Julia Programming Language

Pros of Julia

More mature and established language with a larger ecosystem
Excellent performance for scientific computing and numerical analysis
Strong support for parallel and distributed computing

Cons of Julia

Longer compilation times, especially for the first run
Steeper learning curve compared to V, particularly for beginners
Larger memory footprint for applications

Code Comparison

Julia:

function quicksort(arr)
    if length(arr) <= 1
        return arr
    end
    pivot = arr[end]
    left = filter(x -> x < pivot, arr[1:end-1])
    right = filter(x -> x >= pivot, arr[1:end-1])
    return [quicksort(left); pivot; quicksort(right)]
end

fn quicksort(mut arr []int) []int {
    if arr.len <= 1 {
        return arr
    }
    pivot := arr[arr.len - 1]
    left := arr.filter(it < pivot)
    right := arr.filter(it >= pivot)
    return [...quicksort(left), pivot, ...quicksort(right)]
}

The code comparison showcases similar implementations of the quicksort algorithm in both languages. Julia's version is more concise and uses functional programming concepts, while V's version is more explicit and uses mutable arrays.

dmd

2,963

dmd D Programming Language compiler

Pros of DMD

More mature and established language with a larger ecosystem
Powerful metaprogramming capabilities and compile-time function execution
Extensive standard library with built-in concurrency support

Cons of DMD

Steeper learning curve due to more complex language features
Slower compilation times compared to V
Less emphasis on simplicity and ease of use for beginners

Code Comparison

DMD (D language):

import std.stdio;

void main() {
    writeln("Hello, World!");
}

V language:

fn main() {
    println('Hello, World!')
}

Summary

DMD (the D language compiler) offers a more feature-rich and mature ecosystem, with powerful metaprogramming capabilities and a comprehensive standard library. However, it comes with a steeper learning curve and slower compilation times. V, on the other hand, focuses on simplicity and fast compilation, making it more accessible to beginners. The code comparison shows that V has a slightly more concise syntax for basic operations. Both languages have their strengths, with DMD being better suited for complex, large-scale projects, while V excels in simplicity and rapid development scenarios.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

The V Programming Language

vlang.io | Docs | Changelog | Speed | Contributing & compiler design

Key Features of V

Simplicity: the language can be learned over the course of a weekend
Fast compilation: â110k loc/s with a Clang backend, â500k loc/s with native and tcc backends (Intel i5-7500, SSD, no optimization) (demo video)
Easy to develop: V compiles itself in less than a second
Performance: as fast as C (V's main backend compiles to human-readable C)
Safety: no null, no globals, no undefined behavior (wip), immutability by default
C to V translation (Translating DOOM demo video)
Hot code reloading
Flexible memory management. GC by default, manual via v -gc none, arena allocation via v -prealloc, autofree via v -autofree (autofree demo video).
Cross-platform UI library
Built-in graphics library
Easy cross-compilation
REPL
Built-in ORM
Built-in web framework
C and JavaScript backends
Great for writing low-level software (Vinix OS)

Stability, future changes, post 1.0 freeze

Despite being at an early development stage, the V language is relatively stable, and doesn't change often. But there will be changes before 1.0. Most changes in the syntax are handled via vfmt automatically.

The V core APIs (primarily the os module) will also have minor changes until they are stabilized in V 1.0. Of course, the APIs will grow after that, but without breaking existing code.

After the 1.0 release V is going to be in the "feature freeze" mode. That means no breaking changes in the language, only bug fixes and performance improvements. Similar to Go.

Will there be V 2.0? Not within a decade after 1.0, perhaps not ever.

To sum it up, unlike many other languages, V is not going to be always changing, with new features introduced and old features modified. It is always going to be a small and simple language, very similar to the way it is right now.

Installing V from source

--> (this is the preferred method)

Linux, macOS, Windows, *BSD, Solaris, WSL, etc.

Usually, installing V is quite simple if you have an environment that already has a functional git installation.

Note: On Windows, run make.bat instead of make in CMD, or ./make.bat in PowerShell. Note: On Ubuntu/Debian, you may need to run sudo apt install git build-essential make first.

To get started, execute the following in your terminal/shell:

git clone https://github.com/vlang/v
cd v
make

That should be it, and you should find your V executable at [path to V repo]/v. [path to V repo] can be anywhere.

(Like the note above says, on Windows, use make.bat, instead of make.)

Now try running ./v run examples/hello_world.v (or v run examples/hello_world.v in cmd shell).

Trouble? Please see the notes above, and link to Installation Issues for help.

Note: V is being constantly updated. To update V to its latest version, simply run:

v up

[!NOTE] If you run into any trouble, or you have a different operating system or Linux distribution that doesn't install or work immediately, please see Installation Issues and search for your OS and problem.

If you can't find your problem, please add it to an existing discussion if one exists for your OS, or create a new one if a main discussion doesn't yet exist for your OS.

C compiler

The Tiny C Compiler (tcc) is downloaded for you by make if there is a compatible version for your system, and installed under the V thirdparty directory.

This compiler is very fast, but does almost no optimizations. It is best for development builds.

For production builds (using the -prod option to V), it's recommended to use clang, gcc, or Microsoft Visual C++. If you are doing development, you most likely already have one of those installed.

Otherwise, follow these instructions:

Symlinking

[!NOTE] It is highly recommended, that you put V on your PATH. That saves you the effort to type in the full path to your v executable every time. V provides a convenience v symlink command to do that more easily.

On Unix systems, it creates a /usr/local/bin/v symlink to your executable. To do that, run:

sudo ./v symlink

On Windows, start a new shell with administrative privileges, for example by pressing the Windows Key, then type cmd.exe, right-click on its menu entry, and choose Run as administrator. In the new administrative shell, cd to the path where you have compiled V, then type:

v symlink

(or ./v symlink in PowerShell)

That will make V available everywhere, by adding it to your PATH. Please restart your shell/editor after that, so that it can pick up the new PATH variable.

[!NOTE] There is no need to run v symlink more than once - v will still be available, even after v up, restarts, and so on. You only need to run it again if you decide to move the V repo folder somewhere else.

Void Linux

Expand Void Linux instructions

# xbps-install -Su base-devel
# xbps-install libatomic-devel
$ git clone https://github.com/vlang/v
$ cd v
$ make

Docker

Expand Docker instructions

git clone https://github.com/vlang/v
cd v
docker build -t vlang .
docker run --rm -it vlang:latest

Docker with Alpine/musl

git clone https://github.com/vlang/v
cd v
docker build -t vlang_alpine - < Dockerfile.alpine
alias with_alpine='docker run -u 1000:1000 --rm -it -v .:/src -w /src vlang_alpine:latest'

Compiling static executables, ready to be copied to a server, that is running another linux distro, without dependencies:

with_alpine v -skip-unused -prod -cc gcc -cflags -static -compress examples/http_server.v
with_alpine v -skip-unused -prod -cc gcc -cflags -static -compress -gc none examples/hello_world.v
ls -la examples/http_server examples/hello_world
file   examples/http_server examples/hello_world
examples/http_server: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, no section header
examples/hello_world: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, no section header

You should see something like this:

-rwxr-xr-x 1 root root  16612 May 27 17:07 examples/hello_world
-rwxr-xr-x 1 root root 335308 May 27 17:07 examples/http_server

Termux/Android

On Termux, V needs some packages preinstalled - a working C compiler, also libexecinfo, libgc and libgc-static. After installing them, you can use the same script, like on Linux/macos:

pkg install clang libexecinfo libgc libgc-static make git
git clone https://github.com/vlang/v
cd v
make

Editor/IDE Plugins

To bring IDE functions for the V programming languages to your editor, check out v-analyzer. It provides a VS Code extension and language server capabilities for other editors.

The plugin for JetBrains IDEs (IntelliJ, CLion, GoLand, etc.) also offers a great development experience with V. You can find all features in its documentation.

Other Plugins:

Testing and running the examples

Make sure V can compile itself:

$ v self
$ v
V 0.3.x
Use Ctrl-C or `exit` to exit

>>> println('hello world')
hello world
>>>

cd examples
v hello_world.v && ./hello_world    # or simply
v run hello_world.v                 # this builds the program and runs it right away

v run word_counter/word_counter.v word_counter/cinderella.txt
v run news_fetcher.v
v run tetris/tetris.v

In order to build Tetris or 2048 (or anything else using sokol or gg graphics modules), you will need additional development libraries for your system.

System	Installation method
Debian/Ubuntu based	`sudo apt install libxi-dev libxcursor-dev libgl-dev libasound2-dev`
Fedora/RH/CentOS	`sudo dnf install libXcursor-devel libXi-devel libX11-devel libglvnd-devel`
NixOS	add `xorg.libX11.dev xorg.libXcursor.dev xorg.libXi.dev libGL.dev` to `environment.systemPackages`

V net.http, net.websocket, `v install`

The net.http module, the net.websocket module, and the v install command may all use SSL. V comes with a version of mbedtls, which should work on all systems. If you find a need to use OpenSSL instead, you will need to make sure that it is installed on your system, then use the -d use_openssl switch when you compile.

To install OpenSSL on non-Windows systems:

System	Installation command
macOS	`brew install openssl`
Debian/Ubuntu based	`sudo apt install libssl-dev`
Arch/Manjaro	openssl is installed by default
Fedora/CentOS/RH	`sudo dnf install openssl-devel`

On Windows, OpenSSL is simply hard to get working correctly. The instructions here may (or may not) help.

V sync

V's sync module and channel implementation uses libatomic. It is most likely already installed on your system, but if not, you can install it, by doing the following:

System	Installation command
macOS	already installed
Debian/Ubuntu based	`sudo apt install libatomic1`
Fedora/CentOS/RH	`sudo dnf install libatomic-static`

V UI

https://github.com/vlang/ui

Android graphical apps

With V's vab tool, building V UI and graphical apps for Android can become as easy as:

./vab /path/to/v/examples/2048

https://github.com/vlang/vab. vab examples screenshot

Developing web applications

Check out the Building a simple web blog tutorial and Gitly, a light and fast alternative to GitHub/GitLab:

https://github.com/vlang/gitly

Vinix, an OS/kernel written in V

V is great for writing low-level software like drivers and kernels. Vinix is an OS/kernel that already runs bash, GCC, V, and nano.

https://github.com/vlang/vinix

Acknowledgement

V thanks Fabrice Bellard for his original work on the TCC - Tiny C Compiler. Note the TCC website is old; the current TCC repository can be found here. V utilizes pre-built TCC binaries located at https://github.com/vlang/tccbin/.

Troubleshooting

Please see the Troubleshooting section on our wiki page.

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

Top Related Projects

Quick Overview

Pros

Cons

Code Examples

Getting Started

Competitor Comparisons

Pros of Zig

Cons of Zig

Code Comparison

Summary

Pros of Crystal

Cons of Crystal

Code Comparison

Key Differences

Pros of Nim

Cons of Nim

Code Comparison

Summary

Pros of Odin

Cons of Odin

Code Comparison

Pros of Julia

Cons of Julia

Code Comparison

Pros of DMD

Cons of DMD

Code Comparison

Summary

Convert designs to code with AI

README

The V Programming Language

Key Features of V

Stability, future changes, post 1.0 freeze

Installing V from source

Linux, macOS, Windows, *BSD, Solaris, WSL, etc.

C compiler

Symlinking

Void Linux

Docker

Docker with Alpine/musl

Termux/Android

Editor/IDE Plugins

Testing and running the examples

V net.http, net.websocket, v install

V sync

V UI

Android graphical apps

Developing web applications

Vinix, an OS/kernel written in V

Acknowledgement

Troubleshooting

Top Related Projects

Convert designs to code with AI

V net.http, net.websocket, `v install`