Memory management

V avoids doing unnecessary allocations in the first place by using value types, string buffers, promoting a simple abstraction-free code style.

Most objects (~90-100%) are freed by V’s autofree engine: the compiler inserts necessary free calls automatically during compilation. Remaining small percentage of objects is freed via reference counting.

The developer doesn’t need to change anything in their code. “It just works”, like in Python, Go, or Java, except there’s no heavy GC tracing everything or expensive RC for each object.

For developers willing to have more low level control, autofree can be disabled with -noautofree.

Note: right now autofree is hidden behind the -autofree flag. It will be enabled by default in V 0.3.

For example:

  1. import strings
  3. fn draw_text(s string, x int, y int) {
  4.     // ...
  5. }
  7. fn draw_scene() {
  8.     // ...
  9.     name1 := 'abc'
  10.     name2 := 'def ghi'
  11.     draw_text('hello $name1', 10, 10)
  12.     draw_text('hello $name2', 100, 10)
  13.     draw_text(strings.repeat(`X`, 10000), 10, 50)
  14.     // ...
  15. }

The strings don’t escape draw_text, so they are cleaned up when the function exits.

In fact, the first two calls won’t result in any allocations at all. These two strings are small, V will use a preallocated buffer for them.

  1. struct User {
  2.     name string
  3. }
  5. fn test() []int {
  6.     number := 7 // stack variable
  7.     user := User{} // struct allocated on stack
  8.     numbers := [1, 2, 3] // array allocated on heap, will be freed as the function exits
  9.     println(number)
  10.     println(user)
  11.     println(numbers)
  12.     numbers2 := [4, 5, 6] // array that's being returned, won't be freed here
  13.     return numbers2
  14. }