1654d8b810 | ||
---|---|---|
.ctags.d | ||
.github | ||
cmd | ||
doc | ||
examples | ||
thirdparty | ||
tutorials/building_a_simple_web_blog_with_vweb | ||
vlib | ||
.cirrus.yml | ||
.editorconfig | ||
.gitattributes | ||
.gitignore | ||
CHANGELOG.md | ||
CODE_OF_CONDUCT.md | ||
CONTRIBUTING.md | ||
Dockerfile | ||
Dockerfile.alpine | ||
Dockerfile.cross | ||
GNUmakefile | ||
LICENSE | ||
Makefile | ||
README.md | ||
ROADMAP.md | ||
TESTS.md | ||
make.bat | ||
v.mod |
README.md
Key Features of V
- Simplicity: the language can be learned in less than an hour
- Fast compilation: ≈110k loc/s with a Clang backend, ≈1 million loc/s with native and tcc backends (Intel i5-7500, SSD, no optimization) (demo video)
- Easy to develop: V compiles itself in less than a second
- Performance: as fast as C (V's main backend compiles to human-readable C)
- Safety: no null, no globals, no undefined behavior, immutability by default
- C to V translation
- Hot code reloading
- Innovative memory management (demo video)
- Cross-platform UI library
- Built-in graphics library
- Easy cross-compilation
- REPL
- Built-in ORM
- Built-in web framework
- C and JavaScript backends
- Great for writing low-level software (Vinix OS)
Stability guarantee and future changes
Despite being at an early development stage, the V language is relatively stable and has backwards compatibility guarantee, meaning that the code you write today is guaranteed to work a month, a year, or five years from now.
There still may be minor syntax changes before the 1.0 release, but they will be handled
automatically via vfmt
, as has been done in the past.
The V core APIs (primarily the os
module) will still have minor changes until
they are stabilized in V 1.0. Of course the APIs will grow after that, but without breaking
existing code.
Unlike many other languages, V is not going to be always changing, with new features being introduced and old features modified. It is always going to be a small and simple language, very similar to the way it is right now.
Installing V from source
Linux, macOS, Windows, *BSD, Solaris, WSL, Android, Raspbian
git clone https://github.com/vlang/v
cd v
make
That's it! Now you have a V executable at [path to V repo]/v
.
[path to V repo]
can be anywhere.
(On Windows make
means running make.bat
, so make sure you use cmd.exe
)
Now you can try ./v run examples/hello_world.v
(v.exe
on Windows).
V is constantly being updated. To update V, simply run:
v up
C compiler
It's recommended to use Clang, GCC, or Visual Studio. If you are doing development, you most likely already have one of those installed.
Otherwise, follow these instructions:
However, if none is found when running make
on Linux or Windows,
TCC is downloaded as the default C backend.
It's very lightweight (several MB) so this shouldn't take too long.
Symlinking
NB: it is highly recommended, that you put V on your PATH. That saves
you the effort to type in the full path to your v executable every time.
V provides a convenience v symlink
command to do that more easily.
On Unix systems, it creates a /usr/local/bin/v
symlink to your
executable. To do that, run:
sudo ./v symlink
On Windows, start a new shell with administrative privileges, for
example by Windows Key, then type cmd.exe
, right-click on its menu
entry, and choose Run as administrator
. In the new administrative
shell, cd to the path, where you have compiled v.exe, then type:
.\v.exe symlink
That will make V available everywhere, by adding it to your PATH. Please restart your shell/editor after that, so that it can pick the new PATH variable.
NB: there is no need to run v symlink
more than once - v will
continue to be available, even after v up
, restarts, and so on.
You only need to run it again, if you decide to move the V repo
folder somewhere else.
Docker
Expand Docker instructions
git clone https://github.com/vlang/v
cd v
docker build -t vlang .
docker run --rm -it vlang:latest
Docker with Alpine/musl
git clone https://github.com/vlang/v
cd v
docker build -t vlang --file=Dockerfile.alpine .
docker run --rm -it vlang:latest
Testing and running the examples
Make sure V can compile itself:
v self
$ v
V 0.2.x
Use Ctrl-C or `exit` to exit
>>> println('hello world')
hello world
>>>
cd examples
v hello_world.v && ./hello_world # or simply
v run hello_world.v # this builds the program and runs it right away
v run word_counter/word_counter.v word_counter/cinderella.txt
v run news_fetcher.v
v run tetris/tetris.v
NB: In order to build Tetris or 2048 (or anything else using sokol
or gg
graphics modules)
on some Linux systems, you need to install libxi-dev
and libxcursor-dev
.
V net.http, net.websocket, v install
If you plan to use the net.http module, or the net.websocket module, you also need to install OpenSSL on non-Windows systems:
macOS:
brew install openssl
Debian/Ubuntu:
sudo apt install libssl-dev
Arch/Manjaro:
openssl is installed by default
Fedora:
sudo dnf install openssl-devel
V sync
V's sync
module and channel implementation uses libatomic.
It is most likely already installed on your system, but if not,
you can install it, by doing the following:
MacOS: already installed
Debian/Ubuntu:
sudo apt install libatomic1
Fedora/CentOS/RH:
sudo dnf install libatomic-static
V UI
Android graphical apps
With V's vab
tool, building V UI and graphical apps for Android can become as easy as:
./vab /path/to/v/examples/2048
Developing web applications
Check out the Building a simple web blog tutorial and Gitly, a light and fast alternative to GitHub/GitLab:
https://github.com/vlang/gitly
Vinix, an OS/kernel written in V
V is great for writing low-level software like drivers and kernels. Vinix is an OS/kernel that already runs bash, GCC, V, and nano.
https://github.com/vlang/vinix
Troubleshooting
Please see the Troubleshooting section on our wiki page