index.html

@t header

<style>
.software{
	margin-top:30px;
}
.note {
	font-size: 80%;
}
</style>


<script>
@if . 
	alert("You've been subscribed. Thanks!") 
@end

function isMob() {
	return typeof( window.orientation ) !== "undefined" || 
	navigator.userAgent.indexOf('IEMobile') !== -1;

}

document.addEventListener("DOMContentLoaded", function(event) { 


})

var ex_id = 1; 
const nr_exs = 5; 

function prev() {
ex_id--; 
if (ex_id < 1) ex_id = nr_exs; 
update_ex()
} 

function next() {
//var old = ex_id; 
ex_id++; 
if (ex_id > nr_exs) ex_id = 1; 
update_ex()
}

function update_ex() { 
var elems = document.querySelectorAll('.hello_devs');
    for (var index = 0 ; index < elems.length; index++) {
//document.getElementById('ex' + old).style.display = 'none';  
        elems[index].style.display = 'none'; 
    } 
document.getElementById('ex' + ex_id).style.display = 'table-cell'; 
if (ex_id <= 3) {
document.getElementById('ex' + ex_id).style.fontSize = '100%';  
} 
else { 
document.getElementById('ex' + ex_id).style.fontSize = '80%'; 
} 


var select = document.getElementById("select") ;
select.value = ex_id; 
 
getAjax('/next') 

 
} 

function change_ex() {
var select = document.getElementById("select") ;
ex_id = select.value - 1;
//if (ex_id < 1) ex_id=1; 
next(); 
 
} 

function getAjax(url) {
	    var xhr = window.XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject('Microsoft.XMLHTTP');
		    xhr.open('GET', url);
								    xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
									    xhr.send();
										    return xhr;
} 

function size_note() {
alert(` 
Of course, it's not a very fair comparison. All these languages have a lot more features and support more platforms.

However, V's numbers are unlikely to become more than 10 MB / 1 second.



`) 
} 

/*
function comp_note() {
alert(` 
In this example DOOM is translated from C to V and then compiled directly to x64 machine code.
V to x64 takes 0.3 seconds. 

Compilation to x64 is at an early stage, and right now only Mach-O is supported.

Most likely for now you'll have to use compilation to C for your projects, then the compilation time
drops to about 150k lines/second, which is still pretty fast. 

Once the C++ translator is more mature later this year, it will be possible to compile Doom 3 with V 
as well.
 
The C++ translator will be done as well, then it will be possible to compile Doom 3 with V. 

`) 
} 
 
 */
function comp_note() {
	alert(`Direct machine code generation is at a very early stage. Right now only x64/Mach-O platform is supported.

This means that for now you'll have to use compilation to C. By the end of this year x64 generation should be stable enough.
`)

/*
alert(` 
In this example DOOM is translated from C to V. 

For now it takes much longer to compile DOOM with V (0.7 instead of 0.2 seconds) because x64 generation is not mature enough for this project yet. 

It's still about 25 times faster than compiling DOOM with C.

By the end of this year x64 generation should be mature enough to compile DOOM in 0.2 seconds.
`) 
*/
} 
 
</script>


<div class='sep' style='padding:0'></div> 

<div id='downloads' style='margin-top:20px; '>
<!--
	<div class='v-link'> 

		<a href='https://github.com/vlang/v/releases/download/v0.1.13/v.zip' >Download V alpha 0.1.13</a>
	<div style='font-size:80%; font-weight: 300'>
	%includes_binaries 
	</div>
		<div>
			<img src='/img/linux.png' width=31>
			<img src='/img/mac.png' width=40>
			<img src='/img/win.png' width=36>
		</div>
		<div> 1.3 MB </div> 
	</div> 
	-->
	
<div style='margin-top:1px'>

<!--
<pre>wget https://vlang.io/v.c && cc -std=gnu11 -w -o v v.c</pre>
	-->
	<a href='https://github.com/vlang/v#installing-v-from-source'>Install V from source
	<!--%install_source--></a>
	<div style='font-size:80%; font-weight: 300'>
		%couple_seconds 
	</div>
<pre style='text-align:center'>git clone https://github.com/vlang/v
cd v
make</pre>

		<div>
			<img src='/img/linux.png' width=31>
			<img src='/img/mac.png' width=40>
			<img src='/img/win.png' width=36>
			<img src='/img/freebsd.png' width=36>
			<!--
			<img src='/img/android.png' width=36 style='position:relative;top:3px'>
			-->
		</div>

	</div>

<div style='margin-top: 30px; font-weight: 300'>
<!--
Or build V from source with a C compiler:
<pre>wget https://vlang.io/v.c && clang -o v v.c</pre>
<pre>(coming on June 22)</pre>
-->
</div>




</div>

<div class='sep' style='padding:0'></div> 

<div id='editors'>

	<div class='editor'>
	<a target=_blank href='https://marketplace.visualstudio.com/items?itemName=0x9ef.vscode-vlang&ssr=false'
	><img src='/img/vscode.png' width=25> <br>V for VS Code </a>
	</div>

	<div class='editor'>
	<a target=_blank href='https://github.com/ollykel/v-vim'
	><img src='/img/vim.png' width=25> <br>V for Vim </a>
	</div>

	<div class='editor'>
	<a target=_blank href='https://github.com/vlang/vid'
	><img src='/img/favicon.png' width=25> <br>Vid Editor</a>
	</div>

</div>


<div id='home-examples'> 

<div class='row' style='margin-top:30px'> 
<div class='next' style='text-align:right'> <img onclick='prev()' src=/img/left.png width=30> &nbsp;</div> 

	<pre class='hello_devs' id=ex1>
<key>fn</key> main() {
	areas := [<str>'game'</str>, <str>'web'</str>, <str>'tools'</str>, <str>'science'</str>, <str>'systems'</str>,
	          <str>'embedded'</str>, <str>'GUI'</str>, <str>'mobile'</str>] 
	<key>for</key> area <key>in</key> areas {
		println(<str>'Hello, </str>$area <str>developers!'</str>)
	}
}	</pre>

<pre class='hello_devs' id=ex2 style='display:none'>
<key>import</key> os

<comment>// Print file lines that starth with "DEBUG:"</comment>
<key>fn</key> main() {
	<comment>// `read_file` returns an optional (`?string`), it must be checked</comment>
	text := os.read_file(<str>'app.log'</str>) <key>or</key> {
		println(<str>'failed to read the file'</str>)
		<key>return</key>
	}
	lines := text.split_into_lines()
	<key>for</key> line <key>in</key> lines {
		<key>if</key> line.starts_with(<str>'DEBUG:'</str>) {
			println(line)
		}
	}
}
</pre>

<pre class='hello_devs' id=ex3 style='display:none'>
<key>import</key> time
<key>import</key> http

<key>fn</key> main() {
	resp := http.get(<str>'https://vlang.io/utc_now'</str>) or {
		println(<str>'failed to fetch data from the server'</str>)
		return
	}
	t := time.unix(resp.text.int())
	println(t.format()) <comment>// 2019-08-16 17:48</comment>
}
</pre>

<pre class='hello_devs' id=ex4 style='display:none'>
<key>import</key> json

<key>struct</key> User {
	name          string
	age           int
<key>mut</key>:
	is_registered bool
}

<key>fn</key> main() {
	s := <str>'[{"name":"Frodo", "age":25}, {"name":"Bobby", "age":10}]'</str>
	users := json.decode([]User, s) <key>or</key> {
		eprintln(<str>'Failed to parse json'</str>)
		<key>return</key>
	}
	<key>for</key> user in users {
		println(<str>'</str>$user.name<str>:</str> $user.age<str>'</str>)
	}
	println(<str>''</str>)
	<key>for</key> i, user in users {
		println(<str>'</str>$i<str>)</str> $user.name<str>'</str>)
		if !user.can_register() {
			println(<str>'Cannot register $user.name, they are too young'</str>)
			continue
		}
		users[i].register() <comment>// `user` is immutable, we have to modify the array</comment>
	}
	<comment>// Let's encode users again just for fun</comment>
	println(<str>''</str>)
	println(json.encode(users))
}

<key>fn</key> (u User) can_register() bool {
        <key>return</key> u.age >= 16
}

<key>fn</key> (u <key>mut</key> User) register() {
        u.is_registered = true
}


</pre>



<pre class='hello_devs' id=ex5 style='display:none'>
struct Customer {
	id int
	name string
	nr_orders int
	country string
}

db := pg.connect(db_name, db_user)

nr_customers := db.select count from Customer
println('number of all customers: $nr_customers')

<comment>// V syntax can be used to build queries</comment>
uk_customers = db.select from Customer where country == 'uk' && nr_orders > 0
for customer in uk_customers {
	println('$customer.id - $customer.name')
}

<comment>// by adding `limit 1` we tell V that there will be only one object</comment>
customer = db.select from Customer where id == 1 limit 1
println(customer.name)

<comment>// insert a new customer</comment>
new_customer := Customer{name: 'Bob', nr_orders: 10}
db.insert(new_customer)
</pre>





<pre class='hello_devs' id=ex20 style='display:none'>
struct Story {
    title string
}

<comment>// Fetches top HN stories in 8 coroutines</comment> 
fn main() {
    resp := http.get('https://hacker-news.firebaseio.com/v0/topstories.json')?
    ids := json.decode([]int, resp.body)?
    mut cursor := 0
    for _ in 0..8 {
        go fn() {
            for  {
                lock { <comment>// Without this lock the program will not compile</comment> 
                    if cursor >= ids.len {
                        break
                    }
                    id := ids[cursor]
                    cursor++
                }
                resp := http.get('https://hacker-news.firebaseio.com/v0/item/$id.json')? 
                story := json.decode(Story, resp.body)?
                println(story.title)
            }
        }()
    }
    runtime.wait() <comment>// Waits for all coroutines to finish</comment> 
} 
</pre> 


<pre class='hello_devs' id=ex30 style='display:none'>
import ui  // Native cross-platform ui toolkit (uses Cocoa, win32, GTK+)  

// There are no globals, so we have to use a context struct 
struct Context {
    input ui.TextBox // this uses native conrols (NSTextView on macOS, edit HWND on Windows)  
    names []string   // let's log the names to demonstrate how arrays work  
}

fn main() {
    wnd := ui.new_window(ui.WindowCfg{  // V has no default arguments and overloading. 
        width:  600                     // All stdlib functions with many args use Cfg wrappers.
        height: 300 
        title:  'hello world' 
    }) 
    mut ctx := Context{
        input: ui.new_textbox(wnd) 
        // we don't need to initialize the names array, it's done automatically  
    }
    ctx.input.set_placeholder('Enter your name')
    btn := ui.new_button(wnd, 'Click me', ctx.btn_click)
    for {
        ui.wait_events()
    }
}

fn (ctx mut Context) btn_click() { 
    name := ctx.input.text()
    println('current list of names: $ctx.names')  // >> current list of names: [ "Bob", "Alex" ] 
    ui.alert('Hello, $name!')
    if ctx.names.contains(name) {
        ui.alert('I already greeted you ;)') 
    } 
    ctx.names << name 
} 
</pre> 



<pre class='hello_devs' id=ex40 style='display:none'>
struct User { /* ... */ }
struct Post { /* ... */ }
struct DB   { /* ... */ }

struct Repo &lt;T> {
    db DB
}

fn new_repo&lt;T>(db DB) Repo {
    return Repo&lt;T>{db: db}
}

fn (r Repo) find_by_id(id int) T? { // `?` means the function returns an optional
    table_name := T.name // in this example getting the name of the type gives us the table name
    return r.db.query_one&lt;T>('select * from $table_name where id = ?', id)
}

fn main() {
    db := new_db()
    users_repo := new_repo&lt;User>(db)
    posts_repo := new_repo&lt;Post>(db)
    user := users_repo.find_by_id(1) or {
        eprintln('User not found')
        return
    }
    post := posts_repo.find_by_id(1) or {
        eprintln('Post not found')
        return
    }
} 
</pre> 


<div class='next' onclick='next()'>&nbsp;<img src=/img/right.png width=30></div> 


</div> 

<div class='center' style='text-align:center'> 
<select id='select' onchange='change_ex()'>
<option value=1>Hello world</option> 
<option value=2>Filter log file</option> 
<option value=3>HTTP + time</option> 
<option value=4>JSON encoding/decoding</option> 
<option value=5>Built-in ORM</option> 
<!--
<option value=2>Concurrent news fetcher</option> 
<option value=3>Simple GUI app</option> 
<option value=4>Generic SQL repository</option> 
-->
</select> 
<br>
<input type='button' style='margin-top:15px' onclick='window.location="/play"' value='Run'> 
</div> 

</div> 



<div class='sep' ></div> 
<div class='center'>
	<div class='row'>
<div class='feature first'>
	<br> 
	{{ raw (T "wip_info") }} 
</div>
	</div>
</div>

<div class='sep' ></div> 


<div class='center'>
	<div class='row'>
<div class='feature first'>

<h2>%simple_language_for_maintainable_programs</h2> 
<p> 
You can learn the entire language by going through the 
<a target=_blank href='/docs'>documentation</a> in half an hour, and in most cases there's only one way to do something.
<p>
This results in simple, readable, and maintainable code.
<p> 
Despite being simple, V gives a lot of power to the developer. Anything you can do in other languages, you can do in V. 


</div>


<div class='feature'>
	<h2>%safety</h2>
	<li>No null
	<li>No global variables 
	<li>No undefined values 
	<li>No undefined behavior 
	<li>No variable shadowing
	<li>Bounds checking
	<li><a target=_blank href='/docs#option'>Option/Result types</a> 
	<li> <a target=_blank href='/docs#generics'>Generics</a>
	<li><a target=_blank href='/docs#vars'>Immutable variables by default</a> 
	<li><a target=_blank href='/docs#recvs'>Pure functions by default</a> 
	<li><a target=_blank href='/docs#mod'>Immutable structs by default</a> 
</div>

</div>
</div> 


<div class='sep' ></div> 

<div class='center'>

	<div class='row'>
<div class='feature first'>

	<h2>%performance</h2>
	<li>As fast as C
	<li>C interop without any costs
	<li>Minimal amount of allocations 
	<li>Built-in serialization without runtime reflection 
	<li>Compiles to native binaries without any dependencies: a simple web server is only 65 KB 

</div>
<div class='feature'>

	<h2>%fast_compilation</h2>
	%fast_comp1 
	<span style='font-size:70%'>(Intel i5-7500 @ 3.40GHz, SM0256L SSD, no optimization) </span> 
	<p>{{ raw (T "fast_comp2") }}</p> 
<!--
       <a href='/compilation_speed'>Compilation speed benchmark</a> 
-->
	<p>%fast_comp3</p> 
	<p>%fast_comp4</p> 
<p>
<i class='note'>Direct machine code generation is at a very early stage. Right now only x64/Mach-O is supported.

This means that for now emitting C has to be used. By the end of this year x64 generation should be stable enough.</i>


</div> 
</div>
</div> 

<!-- 
Простой язык для создания читаемого и легко  поддерживаемого ПО 
--> 

<div class='sep' ></div> 

<div class='center'>

	<div class='row'>
<div class='feature first'> 

<h2>
Small and easy to build compiler
<!-- 
%zero_deps
--> 
</h2>
<p>
The entire language and its standard library are less than 1 MB.
V is written in V, and you can build it in 0.4 seconds. 
<p>
(By the end of this year this number will drop to ≈0.15 seconds.)
</p>
<p>
For comparison:
</p>
<table>
<tr><td></td><td>Space required</td><td>Build time</td></tr>
<tr><td>Go</td><td>525 MB</td><td>1m 33s</td></tr>
<tr><td>Rust</td><td>30 GB</td><td>45m</td></tr>
<tr><td>GCC</td><td>8 GB</td><td>50m</td></tr>
<tr><td>Clang</td><td>90 GB
<a target=_blank class='sidenote' href='https://lists.llvm.org/pipermail/llvm-dev/2019-April/132028.html'>[0]</a>
</td><td>25m</td></tr>
<tr><td>Swift</td><td>70 GB 
<a target=_blank class='sidenote' href='https://github.com/apple/swift#getting-started'>[1]</a>
</td><td>90m</td></tr>
<tr><td>V</td><td>< 1 MB</td><td>0.4s</td></tr>
</table>

<p>
<i class='note'>

V has only one dependency: a C compiler. And if you are doing development, you already have a C compiler installed. 
<p>
It's a small dependency, and it's not going to be needed once x64 generation is mature enough.</i> 


</div> 


<div class='feature'> 


<p> 
Building V in 0.4 seconds and then using the resulting binary to build itself again: 
</p> 
<video style='display:block; border: 1px solid #dfdfdf' muted autoplay src='/img/buildv.mp4'></video>   
</div>
</div>

<!--
row {
	feature height:360px {
		h2 { 200 KB }
		p { The entire V 
		-->

</div> 

<div class='sep' ></div> 

<div class='center'>

<div class='feature first'>
	<h2 id=ctranslation>%c_translation</h2>
	V can translate your entire C or C++ <span class='wip'>wip</span> project and offer you the safety, simplicity, and up to 400x compilation speed-up.
	<br>
	<pre style='float:left; font-size:80%;'>
std::vector&lt;std::string> s;
s.push_back("V is ");
s.push_back("awesome");
std::cout << s.size(); </pre>
	<pre style= 'font-size:80%;'>
	mut s := []
	s << 'V is '
	s << 'awesome'
	println(s.len)</pre>
<!-- 
	Read about translating <a href='/doom' onclick='return soon()'>Doom & Doom 3</a>, 
<a href='#'>LevelDB</a>, <a href='#'>SQLite</a>.
--> 

<p> 
<!--
<a href='#cppinfo'>How does it work?</a> 
-->
<p> 
	A blog post about translating DOOM will be  published soon. <!--, <u>Doom 3</u>, <u>LevelDB</u>, <u>SQLite</u> (coming soon).  -->
<p>


<p>
<i class='note'>
Almost the entire C standard is supported right now, but C++ translation is at an early stage. The example above works,
but more complicated code won't. C++ is a very complex language, hopefully the project will be finished by the end of this year.
</i>



</div> 

<div class='feature'>
<h2 style='height:1px'>&nbsp;</h2>  <!-- i'll never understand css... --> 
Translating DOOM from C to V and building it in 0.7 seconds (x25 speed-up): <span class='wip'>wip</span>

<img id='doompic'  src='/img/doom.png'> 

<p>
You can follow the progress and read translated code here:
<a target=_blank href='https://github.com/vlang/doom'>github.com/vlang/doom</a>

</div> 
</div>




<div class='sep' ></div> 

<div class='center'>

	<div class='row'>
<div class='feature first'>

<h2>Hot code reloading</h2>
<p>
Get your changes instantly without recompiling. 
<p>
 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.
</p>
<p>

<a target=_blank href='https://github.com/vlang/v/tree/master/examples/hot_code_reloading'
>examples/hot_code_reloading</a>

</div>

<div class='feature'>
<h2 style='height:1px'>&nbsp;</h2>  <!-- i'll never understand css... --> 
<video style='display:block' loop muted autoplay src='/img/hot.webm'></video>   
 
</div>

</div>

</div> 

<div class='sep' ></div> 

<div class='center'>

	<div class='row'>
<div class='feature first'>
<h2>Powerful graphics libraries</h2> 
Cross-platform drawing library built on top of GDI+/Cocoa Drawing, and an OpenGL based graphics library
for more complex 2D/3D applications, that also has the following features:
<br> 
<br> 
- Loading complex 3D objects with textures <span class='wip'>wip</span> <br> 
- Camera (moving, looking around) <span class='wip'>wip</span><br> 
- Skeletal animation <span class='wip'>wip</span> <br> 
<p>
DirectX, Vulkan, and Metal support is planned. 

<p>
A simple example of the graphics library in action is
 <a target=_blank href='https://github.com/vlang/v/blob/master/examples/tetris'>tetris.v</a>.



</div>

<div class='feature'>
<h2 style='height:1px'>&nbsp;</h2>  <!-- i'll never understand css... --> 
<img src='/img/gg.png'> 

  

</div>

</div>

</div> 




<div class='sep' ></div> 

<div class='center'>

	<div class='row'>
<div class='feature first'>
<h2 id='ui'>Native cross-platform GUI library</h2>
Build native apps with native controls. You no longer need to embed a browser to
develop cross-platform apps quickly.
<p>
V has a <code>ui</code> module that uses native GUI toolkits: WinAPI/GDI+ on Windows, Cocoa on macOS.
On Linux custom drawing is used. 
<p>
Coming soon:  <br> 
- a Delphi-like visual editor for building native GUI apps <br> 
- iOS/Android support with native controls<br> 
- a declarative API similar to SwiftUI and React Native. 
<p>

</div>

<div class='feature'>
	Volt, a 300 KB Slack client built with V and V ui : <br>
	<a target=_blank href='https://volt-app.com'><img src='https://volt-app.com/img/screen3.png' width=500></a>
</div>
</div>
</div> 

<div class='sep' ></div> 

<div class='center'>
	<div class='row'>
<div class='feature first'>
<h2>Easy cross compilation</h2>
To cross compile your software simply run <code>v -os windows .</code> or
<code>v -os linux .</code> No extra steps required, even for GUI and graphical apps!
<p>
(Compiling macOS software only works on macOS for now.)


</div>

<div class='feature'>
<p> 
Building V for Windows using V for macOS, and then testing resulting v.exe on a Windows VM: 
</p> 
<video style='display:block; border: 1px solid #dfdfdf' muted autoplay src='/img/vwin.mp4'></video>   
</div> 


</div>
</div>


<div class='sep' ></div> 
<div class='center'>
<div class='feature first'>
<h2>Painless deployments and dependency management</h2>
To build you project, no matter how big, all you need to do is run
<code>v .</code>
<p>
No more build environments, makefiles, headers, virtual environments, etc.
<p>
You get a single statically linked binary
that is guaranteed to work on all operating systems (provided you cross compile)
without any dependencies. <a href='#' onclick='alert("Of course, if you use C libraries, things get trickier.\n\nThis can be solved by translating C to V.")'>*</a>

<p>
Installing new libraries is as simple as <code>v install sqlite</code>.
</div>


<div class='feature'>
<h2>Run everywhere</h2>
V can emit (human readable) C, so you get the great platform support and 
optimization of GCC and Clang. 

<p>
Emitting C will always be an option, even after direct machine code generation matures.
<p>
V can call C code, and calling V code is possible in any language that has C interop. 
</div>
</div>


<div class='sep' ></div> 
<div class='center'>
<div class='feature first'>
	<h2>REPL</h2>
	<pre>
 v
 >>> import http 
 >>> data := http.get('https://vlang.io/utc_now') or { panic(err) }
 >>> data.text
 1565977541
	</pre> 
</div>


<div class='feature'>
	<h2>V Script <span class='wip'>wip</span></h2>
	<pre>
#v 
for file in ls('build/') {
	rm(file) 
}  
mv('*.exe', 'build/') 

v run deploy.v 
	</pre> 
<a target=_blank href='/docs#bash'>Read more about V script</a> 
</div>
</div> 



<div class='sep' ></div> 

<div class='center'>

	<div class='row'>
<div class='feature first'>
	<h2>Powerful built-in web framework</h2>
<a target=_blank href='https://github.com/vlang/v/tree/master/vlib/vweb'
>github.com/vlang/v/tree/master/vlib/vweb</a> 

	<pre>
<comment>['/post/:id']</comment>
<key>fn</key> (b Blog) show_post(id int) vweb.Result {
  post := b.posts_repo.retrieve(id) <key>or</key> {
     <key>return</key> vweb.not_found()
  }
  <key>return</key> vweb.view(post)
}

</pre>
<p>
<a target=_blank href='//blog.vlang.io/forum'>V forum</a> and 
 <a target=_blank href='//blog.vlang.io'>V blog</a> are built with vweb/vtalk.

</div>


<div class='feature'>
	<h2>Built-in ORM</h2>

<pre>
struct Customer {
	id int
	name string
	nr_orders int
	country string
}

db := pg.connect(db_name, db_user)

nr_customers := db.select count from Customer
println('number of all customers: $nr_customers')

<comment>// V syntax can be used to build queries</comment>
uk_customers = db.select from Customer where country == 'uk' && nr_orders > 0
for customer in uk_customers {
	println('$customer.id - $customer.name')
}

<comment>// by adding `limit 1` we tell V that there will be only one object</comment>
customer = db.select from Customer where id == 1 limit 1
println(customer.name)

<comment>// insert a new customer</comment>
new_customer := Customer{name: 'Bob', nr_orders: 10}
db.insert(new_customer)
</pre>
</div>


</div>
</div>


<div class='menu' ></div> 

<div class='center'> 

	<h1 id='sponsors'>Sponsors</h1>

<!--
	<a target=_blank href='https://offscale.io/'><img style='width:300px' src='/img/sponsor1.png'></a>
	-->

	<br><br>
	<center>
	<a target=_blank href='https://patreon.com/vlang'>Become a sponsor</a>
	</center>


</div>




<div class='menu' ></div> 

<div class='center'> 

<h1 id='faq'>%faq</h1>

<div class='question'> 
<b>Why create V when there are already so many languages? Why not use Go, Rust, C++, Python etc?</b> 
<p> 
<a href='/compare'>Detailed comparison of V and other languages.</a>
</p> 
</div> 

<div class='question'> 
<b>What language is V written in? </b> 
<p> 
V. The compiler can compile itself. The original version was written in Go. 
</p> 
</div> 

<div class='question'> 
<b>Does V use LLVM? </b> 
<p>
No. V compiles directly to machine code. It's one of the main reasons it's so light and fast. 
Right now only x64 architecture/Mach-O format are supported.  Once V is open-sourced,
other architectures and formats should be implemented relatively quickly. 
</p>
<p>
V can also emit human readable C, which can then be compiled to run on any platform. 
This way the compilation speed is about 10 times slower (≈100k lines/second).   
</p>
</div> 

<div class='question'> 
<b> What about optimization?  </b> 
<p>
For now V emits C and uses GCC/Clang for optimized production builds. 
This way you get access to sophisticated optimization. 

<p>
Such builds are compiled ≈150 times slower than V development builds (but are still 
an order of magnitude  
faster than C++ production builds). 
<p> 
This can be a problem for industries where optimization is required during development (for example AAA 
games). In this case, hot code reloading can be used. 
</p> 
<p>
In the future V will have its own optimizer.
</p> 
</div> 

<div class='question'> 
<b> Is there garbage collection?  </b> 
<p> 
No. V manages memory at compilation time (like Rust). Right now only basic cases are handled. 
For others, manual memory management is required for now. Read more: 
<a target=_blank href='https://vlang.io/docs#memory'>https://vlang.io/docs#memory</a>. 
</p> 
</div> 

<div class='question'> 
<b> Is there a package manager? </b> 
<p> 
Yes! V is a very modular language and encourages creation of modules that are easy to reuse.
<p>
<a target=_blank href='https://vpm.vlang.io'>vpm.vlang.io</a>.
<p>
Submitting your V module takes a couple of seconds.
<p>
Installing modules is as easy as
<pre>v install sqlite</pre> 
</div> 


<div class='question'> 
<b> What about concurrency? </b> 
<p> 
It's going to be the same as in Go. To run <code>foo()</code> concurrently, just call it with 
<code>go foo()</code>. Right now it launches the function in a new system thread. Soon coroutines and
the scheduler will be implemented. 
</p> 
</div> 


<div class='question'> 
<b>Will I be able to build V programs without libc?</b> 
<p> 
Yes! 
</p> 
</div> 

<div class='question'> 
<b>Will I be able to use a custom allocator?</b> 
<p> 
Yes. This hasn't been implemented yet, but it will be soon after the release in June. 
</p> 
</div> 

<div class='question'> 
<b> Is V going to change a lot before v1.0?</b> 
<p> 
No. The things you can learn from <a target=_blank href='/docs'>documentation</a> today are going to 
stay the same. There will be several new features of course (like coroutines). 
<p>
When designing V, I spent a lot of time on research to make sure I won't have to change
things in the future.
<p>
Even if something does change, vfmt will take care of it automatically. 
<p>
The same will be true after v1.0 is released. 
</p> 
</div> 

<div class='question'> 
<b> When is v1.0 happening?</b> 
<p> 
The plan is to launch v1.0 by the end of 2019.

<p> 
This may sound ambitious, but V is a very small and simple language. Most of it has been figured out
already.

<p>
It's very important to give developers certainty and stability, and not to be in beta for years. 
</div> 

 

<div class='question'> 
<b> What operating systems are supported?</b> 
<p> 
Windows, macOS, Linux, *BSD. 
<p>
Android and iOS later this year. 
</p> 
</div> 

<div class='question'> 
<b>Who's behind V? </b> 
<p> 
<a target=_blank href='https://github.com/medvednikov'>Just me.</a> 
</p> 
</div> 

<div class='question'> 
<b id=cppinfo>How can it translate C++? It's impossible for one person to write a C++ parser.</b> 
<p> 
Clang parser is used for translating C/C++ to V.  
</p> 
</div> 


<div class='question'> 
<b>What about editor support?</b>
<p> 
There are basic plugins for <a target=_blank href='https://github.com/0x9ef/vscode-vlang'>VS Code</a> and 
<a target=_blank href='https://github.com/ollykel/v-vim'>Vim</a>. Also check out the <a target=_blank href='https://github.com/medvednikov/vid'>Vid editor</a>, which is written in V.
It has V support built in.
<p>
Plugins for Emacs, and other popular editors will be available soon.
<p> 
V is a small and simple language, it doesn't need a powerful IDE.  
</div> 

<div class='question'> 
<b> Why "V"? </b> 
<p> 
Initially the language had the same name as the product it was created for: Volt. The extension was ".v",
I didn't want to mess up git history, so I decided to name it V :) 
<p>
It's a simple name that reflects the simplicity of the language, and it's easy to pronounce for everyone in the
world. 
<p>
Please note that the name of the language is "V", not "Vlang" or "V-Lang" etc. 
</div> 

<div class='question'> 
<b>Any plans to implement macros?</b>
<p> 
No, sorry. Macros can be really useful, but they complicate the code significantly.
Every company, team, developer can extend the language, and it's no longer
possible to jump into a new codebase and immediately understand what's going on.
<p>
V will have sophisticated code generation.
 
<p> 
</div> 

<div class='question'> 
<b>Under which license is V published?</b> 
<p> 
MIT. 
 
<p> 
</div> 





<div class='center' style='text-align:center'> 
	Have an unanswered question?  
	<a href='mailto:alexander&#64;medvednikov.com'>Contact me.</a> 
</div> 



</div> 

<div class='menu' ></div> 


<div class='center'> 

<h1 id='software'>%built_in_v</h1>

<div class='row'>
	<div class='feature first'>
		<h2>V</h2>
		V itself is written in V.
	</div>
	<div class='feature'>
		<h2><a target=_blank href='https://volt-app.com'>Volt</a></h2>
		Native desktop client for Slack, Skype, Matrix, Telegram, Twitch and many more 
		services.
		<!--<img src='https://volt.ws/img/screen2.png'>-->
	</div>
</div>

<div class='row software'>
	<div class='feature first'>
		<h2>Filey</h2>
		Cross-platform file manager with Miller Columns and built-in selective sync
		with major cloud platforms.
		<!--<img src='/img/filey.png'>-->
	</div>
	<div class='feature'>
		<h2><a target=_blank href='https://github.com/medvednikov/vid'>Vid</a></h2> 
		Open source 200 KB editor with the performance of Sublime Text.
	</div>

</div>


<div class='row software'>
	<div class='feature first'>
	<h2>C/C++ to V translator</h2>
	This tool already supports C and will soon support the latest standard of notoriously complex C++.
	It does full automatic conversion to human readable code. 
	</div>
	<div class='feature'>
	<h2> V ui</h2>
	Cross-platform widget toolkit using native APIs.
	</div>
</div>

<div class='row software'>
	<div class='feature first'>
		<h2><a target=_blank href='http://gitly.org'>Gitly</a></h2>
Open-source light and fast alternative to GitHub/GitLab. 
	</div>
	<div class='feature'>
	<h2><a href='//blog.vlang.io'>V blog</a></h2>
	Right now it's powered by very basic blogging software, but in the future it will be a full featured
light alternative to Discourse. 
	</div>
</div>


<div class='row software'>
	<div class='feature first'>
		<h2><a target=_blank href='https://github.com/vpervenditti/vgram'>vgram</a></h2>
A bot library for Telegram Bot API.
	</div>
	<div class='feature'>
		<h2><a target=_blank href='https://github.com/vlang/awesome-v'>Awesome V</a></h2>
		A curated list of awesome V frameworks, libraries and software

	</div>
</div>




<br><br>
<div style='text-align:center;margin-top:30px;'> 
Are you using V to build your product or library? <a href='mailto:alex&#64;medvednikov.com'>
Have it added to this list</a>.
</div> 

<br><br>
<br><br>
<br><br>
<br><br>
<br><br>


	</body>

</html>
@t footer