# V — Fast Compiled Language for Maintainable Software

> V is a simple compiled programming language focused on performance, safety, and readable code. It compiles directly to C and offers fast build times with zero dependencies.

## Install

Save as a script file and run:

# V — Fast Compiled Language for Maintainable Software

## 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
```

## Introduction
V is a statically typed compiled language that aims to combine the best aspects of Go and Rust while keeping syntax simple. It compiles to human-readable C and supports hot code reloading, making it suitable for systems programming and rapid prototyping alike.

## What V Does
- Compiles to native binaries via C backend with sub-second build times
- Provides memory safety without a garbage collector through ownership semantics
- Offers built-in concurrency with coroutines and channels
- Includes a cross-platform UI library and a built-in ORM
- Supports C and JavaScript interop for gradual adoption

## Architecture Overview
V's compiler is written in V itself (self-hosted). Source code is parsed into an AST, type-checked, then lowered to C code which is compiled by a system C compiler (gcc, clang, or tcc for fast debug builds). The language runtime is minimal — no GC by default, with optional autofree and manual memory modes. A separate JavaScript backend enables browser targets.

## Self-Hosting & Configuration
- Build from source with `git clone` and `make`; no external dependencies required
- Use `v.mod` for project metadata and dependency declarations
- Install third-party modules via `v install author.module` from VPM
- Configure memory management mode: autofree, GC, or manual per project
- Cross-compile to Windows, Linux, macOS, and FreeBSD from any platform

## Key Features
- Sub-second compilation for projects of any size
- No null, no undefined behavior, no global state by default
- Built-in testing framework with `v test`
- Hot code reloading for live development without restarts
- Minimal runtime with no libc dependency option for embedded use

## Comparison with Similar Tools
- **Go** — Go has a GC and larger runtime; V aims for simpler syntax and zero-dependency binaries
- **Rust** — Rust provides stricter memory guarantees but with steeper learning curve and longer compile times
- **Zig** — Zig focuses on replacing C with low-level control; V targets higher-level ergonomics
- **Nim** — Nim compiles via C too but uses GC by default; V emphasizes no-GC as the primary mode
- **D** — D offers more features but carries a heavier runtime and ecosystem complexity

## FAQ
**Q: Does V really compile as fast as claimed?**
A: V uses a lightweight parser and emits C code, then compiles with tcc in debug mode, achieving sub-second builds for most projects.

**Q: Is V production-ready?**
A: V is under active development. Some features are stable, but the language spec and standard library continue to evolve.

**Q: Can I use C libraries from V?**
A: Yes. V supports direct C interop with `#include` and `C.function_name()` syntax for calling C code without wrappers.

**Q: How does V handle memory without a GC?**
A: V uses an autofree system that inserts deallocation calls at compile time, supplemented by optional manual and GC modes.

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

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