## V 0.3.4 *30 Apr 2023* - **vweb now supports live page reloading**. The web app is instantly updated in the browser (no need to refresh the page) everytime a .v or a .html file is changed. - vweb is now significantly faster and more stable under load, due to a new multithreaded worker pool, which is much more efficient at spreading the workload among all threads equally. - Middleware support in vweb. - vweb now supports controllers. It's now possible to have multiple app structs to better separate logic. - vweb: overridable `.not_found()` method for custom 404 pages. - A new pure WASM backend, based on binaryen, a WASM `builtin` module, and a pure V WASM serialization library. - Lots of playground improvements: [play.vlang.io](https://play.vlang.io), including a really cool feature: "Show generated C code". - `v share file.v` for sharing code via the playground. - All ORM queries now return `![]` (`Result` of an array). This allows to handle/propagate DB errors and simplifies working with ORM (one way). - Many ORM improvements: type checks for `limit/offset/order by/where`; support of reference objects in `insert`; struct fields can be used with `limit/offset`; `Connection` interface. - ORM now supports the `like` operator: `users := sql db { select from User where name like 'Bob%' }`. - A new `-d trace_orm` option to see all SQL queries generated and used by V ORM and `-d trace_pg_error` to trace PG errors. - A new command line flag `-e` for running short V programs on command line: `v -e "println(2+5)"` (works just like in Perl). - `v up` sped up for when it hasn't been run for a long time (vc/ bootstrapping has been optimized). - Lots of new checks in the checker. - Variable shadowing has been completely banned (previously variable names could conflict with module names). - If guards now work with struct fields which are `Option` functions. Such fields can now also be assigned to other fields/variables. - net.ssl: types using ssl contexts can now be converted to strings via `.str()`/printed via `println()`. - v.reflection: type symbol info metadata has been added. - cgen: do not generate unused interface functions. - A new `[spawn_stack: 131072]` fn attribute for controlling the max size of the stack of the spawned threads. - Final steps in making the Option type a first class type. - Lots of documentation/readme improvements. - Option receivers can no longer have methods. - `none` can now be cast to all `Option` types, including aliases. - Enums can no longer be initialized like structs. - Builtin methods `first/last/repeat` can now be used in custom user types (previously they only worked in builtin arrays). - `v init` no longer overwrites existing `src/main.v`. - Anonymous fn params can no longer be shadowed. - Channel pop now works with an `or` block: `ch := <-self.item or { return none }` - Option references are now supported: `?&Type`. - Now code generated by the С backend, can be compiled by a C++20 compiler. - `v self` now uses a faster tcc backend on macOS/Apple Silicon, just like on Windows/Linux. - `os.hostname()` and `os.loginname()` now return `Result`. - The "Is V still fast?" web page has been sped up by splitting the results table into multiple years. - Allow `foo := Foo{}`, when `Foo` has an Option field, that is a struct, that has a `[required]` tag on its fields (#17516). - Comptime reflection now supports interface fields. - comptime: `$option` (`for f in Foo.fields { $if f.typ is $option { ...`). - comptime: compile-time enum evaluation with `$for - comptime: all types are now lowercase (`$int, $enum, $option` etc). item in MyEnum.fields { dump(item.value) dump(item.name) }`. - Arrays of `Option`s are now allowed. - `it` has been renamed to `index` in array inits. - `datatypes.LinkedList[map]` now works correctly. - `crypto` and `math` modules have been updated to use `Result` instead of `Option`. - `[required]` fields are now checked for embedded structs. - `readline` module now works much better on macOS: key navigation, history, etc (now on par with Linux). - Basic QNX support. - A new `-ldflags` option, in addition to `-cflags`. Works just like LDFLAGS in C. - `urllib.Values.get()` now returns an Option. - `strconv`: `v_printf()` was made private, `v_sprintf()` was deprecated. String interpolation should be used instead. - Fixed a bug with closures with fixed array variables. - Generic struct inits no longer need explicit types provided: `struct Foo[T, U] { a T; b U } foo := Foo{a:2, b:'x'}` - `os.Process` now has a `create_no_window` option (Windows only). - `os.Process` now has a `set_work_folder()` method to set the initial working folder of the new child process. - `json`: enums are serialized as strings by default, `[json_as_number]` attribute can be used for the old behavior. - `net.http`: mime types have been updated to include all official types. - `gg`: `create_image()` now returns `!Image` instead of `Image`, allowing to handle errors. - sokol: errors during image creation no longer result in a panic, but can be handled by the programmer. - sokol: macOS apps can now be quit using Cmd+Q. - A new `termios` module. - Lots of fixes and new features in the native backend, including making codegen logic platform-independent. - `strconv.atoi` optimizations. - `println()` now supports arrays with recursive references. - Multipart form parsing fixes in vweb. - A database pool in vweb. - termux: support for cross-compilation from termux to other platforms. - GitHub Copilot summaries in PRs. - unsafe: dereferencing nil references is no longer allowed. - os: fixed a memleak in `getline()`. - Mixing multi-return results with other types in return statements is no longer allowed (this simplifies the code). - Assigning anonymous structs to named structs is no longer allowed. ## V 0.3.3 *30 Jan 2023* - String interpolation simplified to just '${name}', enforced by vfmt, and updated in the entire code base. - `[]` is now used for generics instead of `<>`. - Various ORM fixes and improvements, including string interpolation support, type checks, fn calls in `where`. - Accessing a pointer map value requires an `or {}` block outside `unsafe`. - `math.vec` module for generic vector math including 2D, 3D, and 4D vector operations. - `go foo()` has been replaced with `spawn foo()` (launches an OS thread, `go` will be used for upcoming coroutines instead). - vfmt now supports `// vfmt off` and `// vfmt on` for turning off the formatting locally for short snippets of code. Useful for keeping your carefully arranged matrices intact. - fast.vlang.io fixes & improvements, new server. - New official IntelliJ plugin: https://intellij-v.github.io. - Lots of fixes in the type checker. - Match branch range expressions with consts: `match x { const1...const2 {} }` - Builtin stb_image.h used by gg has been updated to the latest v2.28. - Lots of new language documentation, a nicer table of contents. - Improved documentation for most of the vlib modules - All of vlib has been updated to use separate Option/Result types. - To avoid confusion, all references in the code and documentation to `Optional` have been replaced with `Option`. - `gg.Context` pipeline has more effects, including the `additive` effect. - Hot code reloading via `[live]` is now supported in imported modules, not just the main module. - VFS support in the builtin `sqlite` module; `sqlite.get_affected_rows_count()`. - `make.bat` & `v up` improvements on Windows. - Syntax sugar for map inits without needing explicit casts for interfaces: `all.children := { "abc": rect, "def": ui.rectangle()}`. - `$embed_file()` fixes, including variable args support. - `none` fixes: no longer allowed to be used as a separate type, `dump()` support, not allowed inside `unsafe`. - Much cleaner eof checks in `os`: refactor `err == IError(os.Eof{})` to `err is os.Eof`. - Const functions: `const y = term.yellow`, then `println(y('abc'))`. - Lots of work on `x.json2`, the pure V json encoder, soon to become official. - Improved compile time checks, like `$if x is Type {`; `$if T in [$Array, $Struct, $Alias, $Function] {`. - New `v.reflection` module for runtime reflection. - Improved `os.mv()`, which now works consistently even across different windows drives/mount points. - `string.trim_indent()`, useful with multi line strings, that start/end with new lines and indentation. - Reduced memory consumption in the `crypto` modules. - Installation instructions for using V on NixOS. - TeamCity test runner support via `v -test-runner teamcity foo_test.v`. - Better `make` support for OpenBSD. - Much improved experience for `v install pcre` on Windows (it now bundles its own .c files, so it compiles cleanly, even if the platform does not have another pcre package installed). - Improved vweb stability under load. - Improved `pg` compatibility with older PostgreSQL versions before 2014. - Native backend: operator support for floats, multi return. - V can now be compiled with tcc on latest macOS and Apple Silicon. - CI optimizations for faster runs. - Official V UI library is now licensed under MIT. - Deprecated `math.util` and `math.mathutil` have been removed. - Builtin type names can no longer be used as identifiers. - Generic `typeof[T]()`, `sizeof[T]()`, `isreftype[T]()` functions. - New official AdventOfCode repo with AOC solutions, also added to CI. - New time format support: `time.format_rfc3339()`. - `encoding.html.escape()`. - Deprecated `-error-limit` in favour of the documented `-message-limit` option. - Maps now support aliased keys. - Operator overloading now works with reference types. - Generic struct inits with nested generic structs and generic optional types are now allowed. - During array creation, `len:` is required when using default values for the array. - Optimized one byte `[]u8` arrays creation. - Int signedness mismatch is now checked: `cannot use literal signed integer as u8`. - New comptime features for fields: `field.is_`, `field.is_alias`, `field.is_enum`. - More detailed timings in `v -show-timings`. - `$for in` works with alias types. - `v new web` for quickly scaffolding new web projects. - All public functions in the `hash` and `encoding.base32` modules have been documented. - Recursive aliasing is no longer allowed (e.g. `type Alias = map[string]Alias`). - `sqlite`, `pg`, `mysql` have been moved to `db.sqlite`, `db.pg`, `db.mysql`. - New `crypto.pem` module. - New `map.reserve()` method. ## V 0.3.2 *31 Oct 2022* - New simplified string interpolation: `println("Hello, {name}!")`. It will be the only way, old syntax (`${name}` and `$name`) will be deprecated. - New stunning playground with an improved look and feel, a much better and more responsive editor, code sharing by link, more convenient keyboard control, reusability for potential embedding: https://play.vlang.io. - `net.ssl` has been migrated from a dynamically linked OpenSSL to a statically linked Mbed TLS. This means that V binaries will no longer have an OpenSSL dependency. OpenSSL can still be enabled via `-d use_openssl`. - msgpack module for decoding/encoding msgpack. (`v install msgpack`) - Easier custom error creation: `return MyCustomErr{}` instead of `return IError(MyCustomErr)`. - Lots of native backend improvements, including library calls, comptime conditionals, enums, method definitions/calls, structs. - Removed the need for the `[console]` attribute in Windows GUI apps. - All floats outputs now have `.0` conditionally appended to them to improve clarity. - Improved type checker: lots of new type checks and fixed checker bugs. - Custom integer enum types: `enum Xyz as u64 {`. - Some further interpreter work. - Improved call tracing via `-trace-calls`. - Most of vlib has been updated to use the new Option/Result types. - Lots of documentation improvements, including a better documentation of the recent Option/Result split. - net, net.http, vweb bugs and fixes. - V REPL: Home/End keys support. Lots of clean up. - QuadTree and RingBuffer types in `datatypes`. - Forward iterator for `datatypes.LinkedList`, forward and backward iterators for `datatypes.DoublyLinkedList`. - More precise WINAPI declarations for easier integration on Windows. - Unused last expression in `if` is now checked. - AST transformer fixes and optimizations. - cgen cleanups. - Lots of fixes in the builtin `dump()` function. - Stylistic improvements and bug fixes in vfmt. - Casting integers to enums now requires `unsafe{}`. - Improved error and warning messages. - A new `maps` module, similar to existing `arrays`. It has generic `filter`, `flatten`, `invert`, `to_map`, `to_array`, `from_array` functions. - Parallel compilation now uses `sync.Pool`. - `utf8.is_number()`, `utf8.is_space()` functions. - New `encoding.base32` module. - `-skip-unused` fixes, soon to be made the default. - `gg.TouchPoint` to differentiate between different types of touch input. - Anonymous structs visibility issues fixed. - orm: support parenthesized expressions like `select from User where (name == 'Sam' && is_customer == true) || id == 1`. - `vweb.csrf` module. - `str.int()` conversion speedup (without -prod). - More CI tests on FreeBSD. ## V 0.3.1 *31 Aug 2022* - Anonymous structs. - Lots of bug fixes: 90% of all bugs ever submitted are closed. - Major improvements to the fast native backend including linking support on Linux. The goal is to be able to self host V soon. - Parallelized cc step. Speeds up -prod and clang/gcc compilation by 300-500% (depending on the number of cores). Experimental and hidden behind a -parallel-cc flag, soon to be the default. - New keyword/type: `nil`. Only to be used inside `unsafe`. Replaces `voidptr(0)`. - V can now find code in the `src/` directory. This allows making V repos much cleaner. - Intel C compiler support. - Older macOS support (<10.12). - `os.mkdir()` now has an optional `mode` parameter. - Full termux support via `$if termux {`, more predictable logging on Android. - Go backend fixes. - More type checks. - DOOM is now translated/compiled and launched on CI servers. A screenshot of the running game is made via `vgret` and is compared to the expected result. - VLS performance improvements, especially on Windows. - `v ls` tool for installing, for updating, and for launching VLS (V Language Server). - Support `assert condition, extra_message`, where the `extra_message` will be evaluated and shown if the assertion fails. - Anonymous sumtypes have been removed (deprecated for now) due to complicating the language and the compiler too much. - `encoding.csv` is now generic, supports bools, accepts a custom delimiter, and is compatible with io.Reader/io.Writer. - Operator overloading now works with aliases and generics. - `datatypes` module now uses operator overloading. - All `datatypes` types can be converted to V arrays. - `smtp` improvements including multiple recipients and base64/utf8 support. - `v doc` now has syntax highlighting. - `arrays.carray_to_varray()` for converting C arrays to V arrays. - `strconv.v_sprintf()` has been deprecated in favor of string interpolation. - TOML module now supports `[toml:...]` attributes, just like the JSON module. - `os.walk()` is no longer recursive (still works the same). - Windows code has been removed from `v.c` distributed on non-Windows systems. (`v_windows.c` is used on Windows.) - ORM functions now return `Result`, so the errors can be handled. - `#preinclude` for low level C interop. - `net.urllib` ipv6 support. - Lots of fixes in `shared` types. - `io` has been migrated to `Result`. - Third party window control in Sokol. - Scanner optimizations. - `string.replace_char()`, `math.round_sig()`. - Improved multiplication performance in `math.big`. - `net.Http.Response.text` renamed to `body`. - Using C's #define is no longer allowed in normal V code, only in `.c.v` files. - V interpreter improvements. - `net.websocket` timeout is now configurable. ## V 0.3 *30 Jun 2022* - C to V translation via C2V: `v translate file.c`. (Demo video: [Translating DOOM from C to V, building it in under a second and running it!](https://www.youtube.com/watch?v=6oXrz3oRoEg)) - Lots of bug fixes in V, cgen, and C interop to allow running translated DOOM.v. - Programs built with the V compiler no longer leak memory by default. - Closures. All operating systems are supported. ([Demo](https://twitter.com/v_language/status/1528710491882852352)) - `Option` and `Result` are now separate types: `?Foo` and `!Foo` respectively. Old code will continue working for 1 year and will result in a warning/hint. - Hundreds of new checks in the type checker. - All V's backends have been split up into separate processes. As the result, building V got 26% faster. - Maps and arrays can now return options: `m[bad_key] or { ... }`, `if x := arr[key] { ... }`. - `ustring` has been replaced with `[]rune` (works just like in Go). - Maps can now have non-string keys. - A new compiler pass for transforming the AST (doesn't slow the compiler too much, adds about 25ms to `v self`). It eliminates unreachable branches and performs other simple optimizations and transformations. - C backend is now parallel (just the cgen part for now). - Lots of compiler source code clean up and minor optimizations. The compiler got ~30% faster according to fast.vlang.io. - Better compiler source code organization (absolutely necessary as it's surpassed 100k loc). - The naming of V's integer types is now more consistent: `byte` has been renamed to `u8`. Old code will continue working for 1 year and will result in a warning/hint. - The typo detector now highlights the suggested name so that it's more visible. - `datatypes` module now has `Heap, Queue, Stack, BSTree, LinkedList`. - Interfaces can now be embedded (like structs). - vlib now has a TOML parser, fully compatible with TOML 1.0. - Lots of work done on the V.js backend, including the graphics library, which has been ported to V.js. - JS promises, await (V.js). - It's now possible to do more complex array initialization by using each individual element of the array (`[]int{init: it}`). - Unsigned right shift operators `>>>` and `>>>=` have been added to V. (They work exactly like in Java.) - `-nofloat` option, which is useful for writing kernels and for embedded systems without an FPU (used in Vinix). - Generic interfaces. - TCC is now bundled with the language, this allows building V programs without an external C compiler dependency. - Null can be used in `unsafe` only (for example, for C interop). - Pointer arithmetic and comparing pointers to numbers is now also only allowed in `unsafe`. - Inline sumtypes. - New module `compress.gzip`. - Lots of `net`/`net.http`/`vweb` fixes (also used for the upcoming Gitly launch). - IPv6 support. - `net.http` headers are now enum fields instead of strings. This allows to avoid typos and offers autocomplete. - Struct field deprecation. - Static GC (no longer a dynamic lib dependency). - New various algorithms for random number generation: MT19937RNG, etc (module `rand`). - Fix immutability bugs that allowed to bypass compiler immutability checks and modify const/immutable values. - Lots of fixes in the JSON serializer. - Heap allocated only structs marked with `[heap]`. - Significantly improve lots of error messages, make them more clear, suggest hints. - Bug fixes and new features in the pure V `regex` module. - Lots of new drawing functions in the graphics module (like `gg.draw_polygon_filled(), gg.draw_arc_empty()` etc) - Builtin FPS display in `gg`. - Latest Sokol backend in `gg`. - Advanced CI tests for the graphics module. Graphical apps are run on GitHub Actions instances, their output is saved to an image, uploaded, and compared to the expected result. - More bug fixes in generics. - Bug fixes in aliases. They can now fully replace the types they alias. - `[minify]` struct attribute for struct minification. - `for in` now works with fixed arrays. - The parser was made a bit faster by skipping `vfmt` code when not in `vfmt` mode (by using `-d vfmt`). - Lots of vfmt improvements, especially with comments. - Experimental `#[index]` syntax for negative indexing (like in Python, but needs special syntax instead of being used by default). - Visibility bug fixes in modules (`pub`). - Error propagation in complex expressions (e.g. `foo(bar()?)`). - Optionals can now by used in consts (`const x := opt() or {}`). - Lots of new documentation, including vlib modules documentation and the official V Documentation. - vpm improvements (including a new vpm mirror). - `sync` improvements including `sync.thread_id()`, `sync.Once`.. - V can now be used to generate object files (`foo.o`) that can be used in existing C projects. - `-usecache` and `-skip-unused` fixes, they are close to being on by default. - Lots of Windows issues fixed. - Amazon Linux support. - Fixes in shared maps and arrays. - `term.ui` improvements, including multi byte/UTF-8 events. - New `crypto` modules, including `crypto.des, crypto.cipher, crypto.blowfish`. - Comptime fixes. - 4 byte bool option (`-d 4bytebool`) for compatibility with some C software. - `strconv` (pure V formatting module used in string interpolation) fixes and performance improvements. - ORM fixes (pg, mysql, sqlite). Tables are now created automatically based on the V structs, no more need in sql files to create tables for apps. - `volatile` keyword. - `"stringliteral".len` optimization (replaced by the actual number by the new `transform` pass). - Lots of inline assembler improvements (it's used a lot in Vinix). - Many new functions in the `math` module. - Separators in number literals: `1_000_000`. - `strings.Builder` optimizations and new methods. - Autofree fixes (still not production ready, hidden behind the `-autofree` flag). - Lots of Android fixes in V and in vab. - Lots of commits to the native backend (amd64/arm64). - V interpreter fixes. (Still at an early stage.) - Go2V translator has been started by the community, and can already translate simple programs. - An early version of the Go backend (`v -b go -o file.go file.v`). ## V 0.2.4 *30 Aug 2021* - Introduce `isize` and `usize` types, deprecate `size_t` in favor of `usize`. - Add `datatypes` and `datatypes.fsm` modules. - Add `compile_error` and `compile_warn` comptime functions. - Bare metal support. Vinix OS kernel is now being developed in V. - Builtin web framework vweb is now multithreaded, all CPU cores are used. - String interpolation and struct stringers are now implemented in pure V with a much cleaner and faster implementation. Previously libc's `sprintf` was used. - Improved `unused variable` warning. Assigning to a variable no longer marks it as used. *... lots of missing changelog for this version, sorry (will update a bit later)* ## V 0.2.2 - 0.2.3 *22 Jan 2021* - Allow interfaces to define fields, not just methods. - `vweb` now uses struct embedding: `app.vweb.text('hello') => app.text('hello')`. - Consts can now be declared outside of `const()` blocks: `const x = 0`. - Overloading of `>`, `<`, `!=`, `==`, `<=` and `>=` operators. - New struct updating syntax: `User{ ...u, name: 'new' }` to replace `{ u | name: 'new' }`. - `byte.str()` has been fixed and works like all other numbers. `byte.ascii_str()` has been added. - Smart cast in for loops: `for mut x is string {}`. - `[noinit]` struct attribute to disallow direct struct initialization with `Foo{}`. - Array decompose: `[1, 2, 3]...` is now `...[1, 2, 3]` - Treating `enum` as `int` and operations on `enum` except `==` and `!=` are removed for strict type checking. - Support `[manualfree] fn f1(){}` and `[manualfree] module m1`, for functions doing their own memory management. - Allow usage of `<` and `>` operators for struct in `.sort` method for arrays, i.e. `arr.sort(a < b)`. - Auto generate assignment operators like `+=`, `-=`, `*=`, `/=` and `%=` if the operators are defined. - Colorize and improve failing tests output. - Fix `go` with a generic function: `go test(c, 'abcd')`. - Add comptime `x := $embed_file('v.png') println(x.len) println(ptr_str(x.data()))`, for embedding files into binaries. - Advanced vdoc search on mobile layout. - string's `left()`/`right` were removed in favor of slicing syntax: `str[..pos]`. - gg: native graphics mode on macOS/iOS (using Cocoa Drawing API). - Full path to consts must be specified everywhere. This makes it easy to distinguish them from local variables. - `__offsetof` for low level needs (works like `offsetof` in C). - vfmt now preserves empty lines, like gofmt. - Support for compile time environment variables via `$env('ENV_VAR')`. - Allow method declaration of `==` and `<` operators and auto generate `!=`, `>`, `<=` and `>=`. - support `dump(expr)`, i.e. tracing of both the location, name and value of an expression - deprecate os.exec in favour of os.executable() which does *NOT* return an option, when the command was not found ## V 0.2.1 *30 Dec 2020* - Hashmap bootstrapping fixes. - Array decomposition to varargs: `fn sum(i ...int) int` => `a := [2,3,4] println(sum(a...))` - HTML module docs generated by vdoc now have global search. ## V 0.2 *22 Dec 2020* - Compile-time memory management via `-autofree` (not production ready yet). [Video demonstration](https://www.youtube.com/watch?v=gmB8ea8uLsM). - Channels and locks. - Thread safe typed arrays via keyword `shared`. - Struct embedding. - IO streams (`io.Reader`, `io.Writer` etc). - A powerful websocket module that conforms to RFC 6455 and passes the Autobahn test suite (498 client tests and 249 server tests). - The `net` module is now non blocking and is more feature complete providing similar API to Go. - V's graphics module now uses Metal/DirectX/OpenGL instead of just OpenGL. - V can now run in the browser via WASM and execute V code by translating it to JavaScript: https://v-wasm.now.sh - V binaries for Linux/Windows/macOS are now built and deployed automatically via GitHub Actions. - Smart casting for sumtypes and interfaces, including complex expressions: `if x.expr is int { println(x.expr + 1) }`. - Clean and easy way to sort arrays: `users.sort(a.name > b.name)`. - A huge amount of `vfmt` fixes and improvements. It has now reached a point where it can be safely used on any V source file. - A new CI job that runs `v fmt -verify` on the entire code base, a new command that makes sure the file/directory has been vfmt'ed. This ensures that all code submitted to the V project is formatted. - A new tool `v vet` for analyzing the project and finding potential bugs and errors. - A new `term.ui` module for building dynamic terminal UIs with an example editor written in it. - Early iOS and Android support. - All missing ORM features from the old backend were brought back. - Magic `it` variable has been replaced with smart casts (the change is completely handled by vfmt). - Cross-compiling to Windows and Linux brought back. - C2V can now generate wrappers. Example: https://github.com/medvednikov/libsodium. (C2V will be released by 0.3) - C++ compiler support: code, generated by the C backend can now by compiled by C++ compilers. - Short generics syntax: `foo(5)` instead of `foo(5)`. - Cached modules via `-usecache`. Faster compilation due to not needing to rebuild the entire vlib for each program. Will be enabled by default in 0.2.1. - New improved sum types implementation. - Lots of errors that happen often during the development cycle were turned into warnings to increase development speed. They are still errors in production builds. - Labeled `break` and `continue`. - Lots of documentation. The official language documentation grew 3 times in size. - `modules.vlang.io` is now generated automatically on every commit. - Builtin compile-time JSON serializer now supports `time.Time`. - Fixes in type aliases, to make them behave just like the types they alias. - `array.contains(element)` is now generic. - Lots of improvements in the JS backend and its type system. - Simpler and more constinent function arg syntax: `foo(a int, b int, c string)` instead of `foo(a, b int, c string)` - Lots of fixes and optimizations in the hashmap. - Lots of missing checks in the type checker were added (for example, checking the correct usage of public struct fields). - Mutability bug fixes - Taking the address of a map value is no longer allowed, like in Go. - Matrix multiplication. - A new `#pkgconfig` flag to provide platform independent way to get compilation flags for C libraries/packages. - Explicit parentheses requirement in complex boolean expressions. - `println` was made even smarter, and can now handle complex types. - Precompiled text templates can now be used outside of vweb via `$tmpl()`. - Gitly, a big web application written in vweb has been released: https://github.com/vlang/gitly - `['/:arg1/:arg2/action']` vweb action attribute for easily getting query parameters assigned to method arguments. - Improved performance of text rendering, `gg.text_width()`. - Webview module in V UI. - Binary enum flags. - `[export]` attribute to change exported function name (for example for calling from a C library). - `unsafe` fixes and improvements. - Improvements to rand: `rand.ulid()`, `rand.uuid()`, a unified customizable PRNG API. - Hundreds of other fixes, features, and tests (from now on the changelog will be updated right away as the feature/bug fix lands). ## 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 details 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. - 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. - 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](https://github.com/vlang/v/blob/master/tutorials/building_a_simple_web_blog_with_vweb/README.md) - 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](https://github.com/vlang/v/issues/2849). Hello world being built in 3 milliseconds. - Bare metal support via the `-freestanding` flag, 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 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 directories. - 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 (use `[a..b]` slicing syntax instead). ## V 0.1.22 *28 Oct 2019* - Generic functions (`fn foo(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](https://github.com/vlang/v/wiki/The-V-language-now-compiles-itself-in-0.09-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 options. - f32/f64 comparison now uses machine epsilon by default. ## V 0.1.21 *30 Sep 2019* - `none` keyword for options. - 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 modified inside the function). - `http` functions now return options. - `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 `defer`s. - `key in map` syntax (replacing `map.exists(key)`). ## V 0.1.15 *15 Jul 2019* - FreeBSD, OpenBSD, NetBSD, DragonFly support. - Hot reloading now works with graphical applications: [bounce.v](examples/hot_reload/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. - Compile `glad` and `cJSON` only once. Programs using `gg` or `json` compile 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 options in all functions that return `File`. - Lots of bugs with options were 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.