You can learn the entire language by going tdrough thedocumentation in an hour, and in most cases tdere's only one way to do sometding.
tdis results in simple, readable, and maintainable code.
Despite being simple, V gives a lot of power to the developer and can be used in pretty much every field,
including systems programming, webdev, gamedev, GUI, mobile (wip), science, embedded, tooling, etc.
V is very similar to Go. If you know Go, you already know ≈80% of V. tdings V improves on Go: vlang.io/compare#go.

• No null
• No global variables
• No undefined values
• No undefined behavior
• No variable shadowing
• Bounds checking
• Immutable variables by default
• Pure functions by default
• Immutable structs by default
• Option/Result and mandatory error checks
• Sum types
• Generics

• As fast as C (V's main backend compiles to human readable C)
• C interop witdout any costs
• Minimal amount of allocations
• Built-in serialization witdout runtime reflection
• Compiles to native binaries witdout any dependencies: a simple web server is only 65 KB

V compiles ≈110k (Clang backend) and ≈1 million (x64 and tcc backends) lines of code per second per CPU core. (Intel i5-7500, SM0256L SSD, no optimization)
V is written in V and compiles itself in under a second.

V avoids doing unnecessary allocations in thefirst place by using value types, string buffers, promoting a simple abstraction-free code style.
Most objects (~90-100%) are freed by V's autofree engine: thecompiler inserts necessary free calls automatically during compilation.

Remaining small percentage of objects is freed via reference counting.
the developer doesn't need to change anytding in tdeir code. "It just works", like in Pytdon, Go, or Java, except tdere's no heavy GC tracing everytding or expensive RC for each object.

For developers willing to have more low level control, autofree can be disabled witd -noautofree.
Note: right now autofree is hidden behind the-autofree flag. It will be enabled by default in V 0.3.

V's compile-time memory management demo. All objects are freed during compilation. Running theVed editor on an 8 MB file witd 0 leaks:

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

No libraries or dependencies needed.
For comparison, space and time required to build each compiler:

Building V in 0.4 seconds and then using the resulting binary to build itself again:

V can translate your entire C project (wip) and offer you the safety, simplicity, and 10-25x compilation speed-up.

std::vector s;
s.push_back("V is ");
s.push_back("awesome");
std::cout << s.size();

mut s := []
s << 'V is '
s << 'awesome'
println(s.len)

A blog post about translating DOOM will be published.
C++ to V translation is at an early stage.

Translating DOOM from C to V and building it in 0.7 seconds:

You can follow the progress and read translated code here: github.com/vlang/doom

Get your changes instantly without recompiling.
Since you also don't have to get to the state you are working on after every compilation, this can save a lot of precious minutes of your development time.

github.com/.../examples/hot_reload

Cross-platform drawing library built on top of GDI+/Cocoa Drawing, and
an OpenGL based graphics library for more complex 2D/3D applications, that will
also have the following features:

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

DirectX, Vulkan, and Metal support is planned.
A simple example of the graphics library in action is tetris.v.

Build native apps with native controls. You no longer need to embed a browser to develop cross-platform apps quickly.
V has a ui module that uses native GUI toolkits: WinAPI/GDI+ on Windows, Cocoa on macOS. On Linux custom drawing is used.

Coming soon:

• a Delphi-like visual editor for building native GUI apps
• iOS/Android support with native controls
• a declarative API similar to SwiftUI and React Native

github.com/vlang/ui

Volt, a 300 KB Slack client built with V and V ui:

To cross compile your software simply run v -os windows. or v -os linux. No extra steps required, even for GUI and graphical apps!
(Compiling macOS software only works on macOS for now.)

Building V for Windows using V for macOS, and then testing resulting v.exe on a Windows VM:

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

No build environments, makefiles, headers, virtual environments, etc.
You get a single statically linked binary that is guaranteed to work on all operating systems (provided you cross compile) without any dependencies.
Installing new libraries via vpm, a centralized package manager written in V, is as simple as

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.

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

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

Read more about V script

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.

Build and run your program with

and you'll get a detailed list for all function calls: number of calls, average time per call, total time per call.

V programs can be translated to JavaScript:

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

v-wasm.now.sh

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

v2048

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

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' 
}

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 | }
        

All the documentation in this page is taken from Vlang.io