The V Programming Language 0.5

Performance

• C interop without any costs
• Minimal amount of allocations
• Built-in serialization without runtime reflection
• Compiles to native binaries without any dependencies: a simple web server is only about 250 KB
• As fast as C (V's main backend compiles to human readable C), with equivalent code.
  V does introduce some overhead for safety (such as array bounds checking, GC free), but these features can be disabled/bypassed when performance is more important.

Small and easy to build compiler

V can be bootstrapped in under a second by compiling its code translated to C with a simple

cc v.c

Flexible memory management

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

There are 4 ways to manage memory in V.

The default is a minimal and a well performing tracing GC.

The second way is autofree, it can be enabled with -autofree. It takes care of most objects (~90-100%): the compiler inserts necessary free calls automatically during compilation. Remaining small percentage of objects is freed via GC. The developer doesn't need to change anything in their code. "It just works", like in Python, Go, or Java, except there's no heavy GC tracing everything or expensive RC for each object. Autofree is still experimental and not production ready yet. That's planned for V 1.0.

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

Arena allocation is available via v -prealloc.

V's autofree demo. All objects are freed during compilation. Running the Ved editor on an 8 MB file with 0 leaks:

A powerful graphics library

Cross-platform drawing library gg, using OpenGL/Metal/DirectX 11 for rendering 2D applications.

There's also a 3D engine in development with the following features already available:

• Loading complex 3D objects with textures
• Camera (moving, looking around)
• Skeletal animation

A simple example of the graphics library in action is tetris.v.

For 3D examples, check out this.

Painless deployments and dependency management

To build your project, no matter how big, all you need to do is run

v .

v install ui
		

Run everywhere

V can emit (human readable) C, so you get the great platform support and optimization of GCC and Clang. (Use v -prod . to make optimized builds.)

Emitting C will always be an option, even after direct machine code generation matures.

V can call C code, and calling V code is possible in any language that has C interop.

REPL

v
>>> import net.http
>>> data := http.get('https://vlang.io/utc_now')!
>>> data.body
1565977541

Cross-platform shell scripts in V

V can be used as an alternative to Bash to write deployment scripts, build scripts, etc. The advantage of using V for this is the simplicity and predictability of the language, and cross-platform support. "V scripts" run on Unix-like systems as well as on Windows.

for file in ls('build/') {
  rm(file)
}
mv('v.exe', 'build/')

v run deploy.vsh

Read more about V script

Code formatting with vfmt for consistent style

No more arguments about coding styles. There's one official coding style enforced by the vfmt formatter.

All V code bases are guaranteed to use the same style, making it easier to read and change code written by other developers.

v fmt -w hello.v

A built-in code profiler

Build and run your program with

v -profile profile.txt x.v && ./x

JavaScript and WASM backends

V programs can be translated to JavaScript (WIP):

v -o hello.js hello.v

The JS backend is at an early stage.

They can also be compiled to WASM (for now with Emscripten, but native WASM support is planned). V compiler compiled to WASM and running V programs by translating them to JavaScript:

v-wasm.vercel.app

A game written using V's graphical backend and compiled to WASM:

Automatic documentation

Use vdoc to get instant documentation generated directly from the module's source code. No need to keep and update separate documentation.

v doc os

Built-in testing framework

Writing tests is very easy: just start your test function with test_

fn get_string() string { return 'hello' }

fn test_get_string() {
  assert get_string() == 'hello'
}
      

Friendly error messages

Helpful error messages make learning the language and fixing errors simpler:

user.v:8:14: error: `update_user` parameter `user` is mutable, you need to provide `mut`: `update_user(mut user)`

    7 |     mut user := User{}
    8 |     update_user(user)
      |                 ~~~~
    9 | }
	

Powerful built-in web framework Veb

Veb is very fast (built on top of pico.v which has been at the top of TechEmpower benchmark), it compiles into a single binary (html templates are also compiled), supports hot code reloading (the website is automatically updated in the browser once you change any .v/.html file).

github.com/vlang/v/tree/master/vlib/veb

['/post/:id']
fn (b &Blog) show_post(id int) veb.Result {
  post := b.posts_repo.retrieve(id) or {
    return veb.not_found()
  }
  return veb.view(post)
}

Gitly, a light and fast alternative to GitHub/GitLab is built in V and Veb.

Built-in ORM

import db.sqlite

struct Customer {
  id int
  name string
  nr_orders int
  country string
}

fn main() {
  db := sqlite.connect('example.sqlite') or {
    panic('could not create/find example.sqlite')
  }

  nr_customers := sql db {
    select count from Customer
  }!
  println('number of customers: ${nr_customers}')

  // V syntax can be used to build queries
  uk_customers := sql db {
    select from Customer where country == 'uk' && nr_orders > 0
  }!

  for customer in uk_customers {
    println('${customer.id} - ${customer.name}')
  }

  // by adding `limit 1` we tell V that there will be
  // only one object
  customer := sql db {
    select from Customer where id == 1 limit 1
  }!
  println(customer.name)

  // insert a new customer
  new_customer := Customer{name: 'Bob', nr_orders: 10}
  sql db {
    insert new_customer into Customer
  }!
}