# V — Simple Fast Systems Programming Language

> V is a statically typed compiled language focused on simplicity, performance, and ease of use, offering C-like speed with a clean modern syntax and built-in memory safety.

## Install

Save as a script file and run:

# V — Simple Fast Systems Programming Language

## Quick Use
```bash
# Install V from source
git clone https://github.com/vlang/v
cd v && make
sudo ./v symlink

# Hello world
echo 'import os
fn main() { println("Hello, V!") }' > hello.v
v run hello.v

# Build optimized binary
v -prod hello.v
```

## Introduction
V is a general-purpose programming language designed for writing maintainable and predictable software with minimal complexity. It compiles directly to C and achieves performance comparable to C/C++ while offering memory safety, a clean syntax, and fast compilation speeds measured in seconds for large codebases.

## What V Does
- Compiles to native machine code via C backend with optional direct LLVM codegen
- Provides automatic memory management without a garbage collector using ownership semantics
- Offers built-in concurrency with coroutines and channels similar to Go
- Includes a standard library covering networking, JSON, crypto, and UI
- Supports hot code reloading for rapid development iteration

## Architecture Overview
V's compiler is written in V itself (self-hosted) and translates V source into C code, which is then compiled by any C compiler (GCC, Clang, MSVC). This two-stage approach provides broad platform support while keeping the V compiler simple. The compiler is single-pass and produces output in under a second for most projects.

## Self-Hosting & Configuration
- Clone the repository and run `make` to bootstrap from the pre-compiled C source
- No external dependencies required beyond a C compiler
- Use `v symlink` to add V to your PATH system-wide
- Configure project settings via `v.mod` manifest file in the project root
- Cross-compile to Linux, macOS, Windows, FreeBSD, and WASM from any platform

## Key Features
- Sub-second compilation even for large codebases
- No null, no undefined behavior, no implicit type casts
- Built-in testing framework with `v test`
- Package manager (VPM) for community libraries
- Interoperability with C libraries via direct header imports

## Comparison with Similar Tools
- **Go** — V has a similar syntax philosophy but compiles to native code without a runtime or GC
- **Rust** — Rust offers stronger memory guarantees but has a steeper learning curve and slower compile times
- **Zig** — Zig provides low-level control for systems programming; V prioritizes simplicity over manual memory management
- **Nim** — Both compile via C, but V emphasizes minimalism and faster compilation
- **C** — V provides modern safety features while matching C performance

## FAQ
**Q: Does V have a garbage collector?**
A: No. V uses a combination of ownership tracking and autofree to manage memory at compile time without runtime overhead.

**Q: Can I use C libraries from V?**
A: Yes. V can directly call C functions and use C headers with minimal wrapper code through its C interop layer.

**Q: How mature is the V ecosystem?**
A: V is actively developed with a growing package registry (VPM) and standard library, though it is younger than Go or Rust.

**Q: What platforms does V support?**
A: V targets Linux, macOS, Windows, FreeBSD, OpenBSD, and WebAssembly, with cross-compilation built in.

## Sources
- https://github.com/vlang/v
- https://vlang.io/docs

---
Source: https://tokrepo.com/en/workflows/asset-cb5fc4ef
Author: Script Depot