v/CHANGELOG.md

V 0.1.27

5 May 2020

• vfmt has been re-written from scratch using the new AST parser. It's much faster, cleaner, and can format files with compilation errors.
• strconv, sprintf, and printf in native V, without any libc calls.
• Interfaces are now a lot more stable and have all expected features.
• Lots of x64 backend improvements: function calls, if expressions, for loops, local variables.
• map() and filter() methods can now be chained.
• New []int{cap:cap, len:len} syntax for initializing array length and capacity.
• New is keyword for checking the type of sum types and interfaces.
• as can now be used to cast interfaces and sum types.
• Profiling with -profile. Prints a nice table with detailed information about every single function call: number of calls, average time per call, total time per function.
• import(xxx) syntax has been removed in favor of import xxx for simplicity and greppability.
• Lots of fixes and improvements in the type checker.
• time.StopWatch
• dl module for dynamic loading.
• Automatic str() method generation for every single type, including all arrays and fixed size arrays.
• Short struct initialization syntax for imitating named function args: foo(bar:0, baz:1).
• New operator !in.
• Performance improvements in critical parts of the builtin data structures (array, map).
• High order functions improvements (functions can now be returned etc).
• Anonymous functions that can be defined inside other functions.
• Built-in JSON module is back.
• Closures.
• Lots and lots of new tests added, including output tests that test error messages.
• Multiple errors are now printed, the compiler no longer stops after the first error.
• The new JS backend using the AST parser (almost complete).
• Variadic functions.
• net.websocket module (early stage).
• vlib is now memory leak free, lots of autofree improvements.
• Simplified and cleaned up cmd/v, v.builder.
• V UI was updated to work with the new backend.

V 0.1.25

1 Apr 2020

• The entire compiler has been re-written with an AST parser. The code is now a lot cleaner and more maintainable. ~15k lines of old compiler code were removed.

V 0.1.24

31 Dec 2019

• A new parser/generator built on top of an AST that simplifies code greatly and allows to implement new backends much faster.
• Sum types (type Expr = IfExpr | MatchExpr | IntegerLiteral).
• B-tree map (sped up the V compiler by ~10%).
• v fmt -w.
• The entire code base has been formatted with vfmt.
• Generic structs.
• SDL module.
• Arrays of pointers.
• os: is_link(), is_dir(), exists().
• Ranging through fixed size arrays.
• Lots of fixes in ORM and vweb.
• The first tutorial: building a simple web application with vweb.
• Match expressions now must be exhaustive.
• freestanding: malloc()/free().
• ++ is now required instead of += 1 for consistency.
• Interpolated strings now allow function calls: println('val = $get_val()').
• string.replace_each([]) for an efficient replacement of multiple values.
• More utf8 helper functions.
• -prealloc option for block allocations.
• type aliases.
• Running v with an unknown command will result in an error.
• atof implementation in pure V.
• Enums can now have negative values.
• New filepath module.
• math.factorial.
• ftp module.
• New syntax for casting: val as Type.
• Fewer libc functions used (soon V will have no dependency on libc).

V 0.1.23

30 Nov 2019

• Direct x64 machine code generation. Hello world being built in 3 milliseconds.
• Bare metal support via the -freestanding flag, allowing to build programs without linking to libc.
• Prebuilt V packages for Linux, macOS, and Windows.
• string.index() now returns ?int instead of int/-1.
• Lots of fixes in Generics.
• vweb framework for developing web applications is back.
• Vorum, the forum/blogging software written in V/vweb, can now be compiled and has been added to CI.
• REPL, v up have been split up into separate applications to keep the core V compiler small.
• V now enforces short enum syntax (.green instead of Color.green) when it's enough.
• V UI for macOS.
• Interfaces have been rewritten. []interface support.
• os.cp() for copying files and directores.
• Additional compile-time flags: $if clang, msvc, mingw, x32, x64, big_endian, little_endian {.
• All C functions now have to be declared, all missing C functions have been defined.
• Global variables (only with the --enable-globals flag) for low level applications like kernels and drivers.
• Nothing can be cast to bool (previously code like if bool(1) { worked).
• << and >> now work with all integer types.
• V detects Cygwin and shows an error (V supports Windows natively).
• Improved type checking of some operators (%, |, & etc).
• Windows 7 support.
• println(true) now prints true instead of 1.
• os.exec() now uses CreateProcess on Windows.
• fast.vlang.io website for monitoring the performance of V after every commit.
• On Windows Visual Studio is now used automatically if GCC is not installed.
• vfmt!
• Lots of cleaning up in the compiler code.
• Multi-level pointers in unsafe code (****int).
• MSVC backtrace.
• $if os { blocks are now skipped on a different OS.
• C string literals (c'hello').
• AlpineLinux/musl fixes + added to CI.
• Inline assembly.
• Clipboard module (Windows, macOS, X).
• foo()? syntax for error propagation.
• Docs have been migrated from HTML to doc/docs.md.
• eventbus module.
• Haiku OS support.
• malloc/free on bare metal.
• utf8 helper functions (to_lower(), to_upper(), etc).
• Optimization of for c in str {.
• string/array.left/right/slice/substr were removed ([a..b] slicing syntax should be used instead).

V 0.1.22

28 Oct 2019

• Generic functions (fn foo<T>(bar T) T {) with varargs support.
• array[start..end] and string[start..end] slicing syntax.
• Optimized array.filter() and array.map().
• sqlite module.
• Cached modules for faster compilation.
• Dramatic compilation optimizations: V now compiles itself in 0.10 - 0.30 seconds.
• V scripts (simpler and cross-platform alternative to Bash).
• Infinite multi-dimensional arrays ([][][]int).
• unsafe.
• [deprecated] attribute.
• [if] function attributes for compile time function exclusion for performance.
• switch has been completely removed from the language and replaced by match everywhere.
• pub struct and pub const, previously all structs and consts were public by default.
• musl support (V can now run on, for example, Alpine Linux).
• Module header generation. V now supports closed source modules, which are still used in some industries.
• Constants were added to typo suggestions.
• color in [.green, .red, .blue] now works without specifying Color.green.
• V compiler is now a module that can be used by other programs.
• Backtraces now have source lines on Linux.
• runtime.nr_cpus().
• fn init() for module initialization.
• a in [1, 2, 3] optimization: no array gets allocated.
• Raw strings: s := r'hello\nworld'.
• if a := func() { } syntax for handling optionals.
• f32/f64 comparison now uses machine epsilon by default.

V 0.1.21

30 Sep 2019

• none keyword for optionals.
• Solaris support.
• All table lookup functions now use none.
• varargs: fn foo(bar int, params ...string) {.
• Double quotes (") can now also be used to denote strings.
• GitHub Actions CI in addition to Travis.
• -compress option. The V binary built with -compress is only ~90 KB!
• More memory management.
• Unused modules result in an error.
• "Unused variable/module" errors are now warnings in non-production builds.
• Duplicate methods with the same name can no longer be defined.
• Struct names must be capitalized, variable/function names must use snake_case.
• Error messages are now even nicer!
• Lots of fixes in automatic .str() method generation for structs and arrays.
• ~30% faster parser (files are no longer parsed separately for each pass).
• _ is no longer a variable, but an actual syntax construct to skip unused values, like in Go.
• Multiple returns (fn foo() (int, string) {).
• ! can now only be used with booleans.

V 0.1.20

17 Sep 2019

• JavaScript backend!
• Hundreds of C warnings were fixed. gcc v.c now builds without any warnings.
• The mutability check now applies to function args (mutable receivers that are not modified result in a compilation error).
• V tests now show how long each test took.
• Official Android support (only console applications via Termux for now).
• Typo check. If a variable/function/module etc is misspelled, V will suggest the correct name.
• Lots of Microsoft C fixes, and a separate Travis instance for this backend.
• Bitwise operators |, ^, & no longer work with booleans.

V 0.1.19

12 Sep 2019

• Lots of refactoring, simplifications, and optimizations in the compiler.
• Experimental memory management at compilation (only for the V compiler itself for now).
• Lots of ORM fixes.
• Functions can now be inlined via the [inline] attribute.
• New mysql module.
• Better error format that is supported by all major editors (go to error).
• Error messages now point to the actual place where the error happened.
• Custom json field names: struct User { last_name string [json:lastName] }.
• Raw json fields via the [raw] attribute.
• All C code was removed from the freetype module.
• gg module can now render all Unicode characters.
• [typedef] attribute for imported C struct typedefs.
• Support of Objective C interfaces (primarily for using Cocoa).
• REPL: clear command and custom functions.
• REPL tests (which are also used for testing certain compiler errors).
• Syntax bug fixed: foo[0] += 10 is now possible.
• http: support plain HTTP protocol and follow redirects.
• http: header data is now processed correctly.
• net: basic UDP support.
• import const was removed from the language.
• array.contains() was removed from the language (in should be used instead).
• [0; len] syntax was removed (replaced with a simpler [0].repeat(len))
• Primitive aliases were removed to simplify the language.
• GitHub supports V now!
• Backtraces are now printed on panics.
• A new awesome readline module.
• V.c is now regenerated automatically after every commit.
• A bug with struct ordering was fixed, now structs can be declared in any order.
• V modules can now be built with v build module.
• @FILE, @LINE, @FN, @COLUMN for debugging.

V 0.1.18

16 Aug 2019

• Built-in ORM (uk_customers = db.select from Customer where country == 'uk' && nr_orders > 0).
• Map initialization syntax: m := { ‘foo’: ‘bar’, ‘baz’: ‘foo’ }.
• map.delete(key).
• libcurl dependency was removed from the http module.
• All function arguments are now immutable by default (previously they could be modifed inside the function).
• http functions now return optionals.
• sync.WaitGroup.
• vweb static files serving.
• crypto.rand module.
• v up to update V.
• SChannel support on Windows.
• net.urllib module.
• vpm package manager, v install.
• () are now required in complex bool expressions: (a && b) || c instead of a && b || c.
• All arrays now have a default .str() method.
• Bootstrapping V with MSVC.
• Experimental ≠ etc support.
• encoding.csv module.
• $if debug { for running code in debug mode only.
• Map struct fields are now initialized automatically, just like arrays.
• Maps now support array values.
• json functions can no longer be used if the json module is not imported.

V 0.1.17

29 Jul 2019

• vweb module for developing web apps in V.
• vtalk, open source V forum software.
• Generics (very limited right now, but they will be gradually improved).
• Comptime codegen (foo.$method() where method is a string).
• @ for escaping keywords (e.g. struct Foo { @type string }).
• Windows Unicode fixes (V can now work with non-ASCII paths etc on Windows).
• Fix mutable args bugs + don't allow primitive arguments to be modified.
• Declaring a mutable variable and never modifying it results in a compilation error.
• Interactive debugging support.
• sync module for Windows.
• #! support on Unix systems (V scripts).
• Lots of Visual Studio fixes.
• crypto.aes and crypto.rc4 modules.
• Internal modules.

V 0.1.16

23 Jul 2019

• V can now be used with Visual Studio!
• Hot code reloading now works with graphical applications (e.g. graph.v, bounce.v).
• Compile time memory management for arrays.
• High order functions.
• match expression (replacing switch).
• Import cycle detection.
• crypto/md5, crypto/sha256, and crypro/sha512 modules.
• os.executable() - a cross platform function that returns full path to current executable.
• ~/.vlang and VROOT were removed entirely. The installation is a lot cleaner now.
• V can now be packaged for all Linux distros.
• Arch Linux package.
• string(bytes_buffer, len), string(bytes_array) casts.
• Multiple defers.
• key in map syntax (replacing map.exists(key)).

V 0.1.15

15 Jul 2019

• FreeBSD, OpenBSD, NetBSD, DragonFly support.
• Hot code reloading now works with graphical applications: bounce.v.
• VROOT was removed, the installation process is now much simpler.
• defer statement.
• map.v was re-written. It's now much faster.
• for key, val in map syntax.
• flag module for parsing command line arguments.
• zip module.
• crypto/sha1 module.
• Submodules and module aliases (import encoding.base64 as b64).

V 0.1.14

12 Jul 2019

• gg module Windows support, V Tetris runs on Windows.
• glad and cJSON are now compiled only once, this makes compilation of programs using gg and json a bit faster.
• v.c has been cleaned up and minimized (~16k => ~10k lines of code).
• type aliases can now have methods.
• Const overflow check during compilation (byte(1000) will no longer compile).

V 0.1.13

10 Jul 2019

• New enum syntax (token == .name), enum values are no longer global consts.
• Submodules (import encoding.base64).
• Hot code reloading.
• Special err variable for getting error values.
• Complex numbers.
• << can now append arrays (numbers << [1, 2, 3]).
• Lots of Windows fixes (Windows still needs some work).
• Lots of REPL improvements (e.g. >> 2 + 3 works now, no println required).
• The website was made easily translatable, it's now partially available in several languages.

V 0.1.12

4 Jul 2019

• V can finally compile itself on Windows (https://github.com/vlang/v#mingw-w64).
• os module now uses optionals in all functions that return File. Lots of bugs with optionals fixed.
• println was optimized. It no longer results in allocations. Now it also works correctly with all integer types.
• Lots of vfmt fixes, it will be enabled tomorrow.
• New strings module.
• Lots of other fixes and improvements, thanks to all the contributors.

V 0.1.11

1 Jul 2019

• Cross compilation for Windows!
• Lots of Windows fixes.
• socket.v.
• maps fixed.

V 0.1.9 - 0.1.10

29 Jun 2019

• Windows support via MinGW-w64. Pre-built Windows binary.
• File structure has been simplified: all vlib modules were moved to the vlib/ directory, makefile was moved to the root.
• One single archive with pre-built binaries for all operating systems.
• mut var := val was fixed (previously mut var = val was allowed as well).

V 0.1.8

28 Jun 2019

• Single file programs without fn main now work as expected.
• REPL has been fixed: it now supports imports, consts, function definitions, etc.

V 0.1.7

27 Jun 2019

• All C code in the compiler and vlib has been replaced with V.
• # syntax for embedding C code has been removed.
• Exported functions now need to be marked with pub, all public vlib functions have been updated.
• CI has been set up (Travis + Azure). On every commit and PR it is made sure that V can compile itself, all tests pass, and all examples compile.
• More tests have been uploaded.
• Cleaner bytes to string conversion: tos2(bytes) => string(bytes).
• The home page has 3 more examples next to 'hello world' that show the features of the language.
• Lots of bugs and issues fixed.