VukaGo, with a few things more

Result, the ? operator, match, enums and decorators, plus a web framework where pages are files and the UI stays live. It compiles to plain Go.

Get started

Your first web app

GitHub

It is Go

A .vuka file is Go plus a handful of additions. Every Go function, type and library works as it is, from the standard library, go get, or your own .go files.

Using Go code

Errors as values

Result and Option, ? to pass an error on, enums with exhaustive match. Go's (T, error) works with all of it.

Result and Option

Decorators and statics

@retry(3) on a function, User.New("ada") on a type: retries, caches, guards and constructors in a few lines, compiled to ordinary Go.

Decorators

Pages are files

Folders under pages/ are your routes, with [id] parameters, (group) folders and layouts that stay put while you navigate. Links between pages are typed.

Folder routes

Live UI without a JS build

A .vuka.html shape is one struct and its markup. Server state, browser state and Vue or React islands share one form, and events patch the page in place.

Shape files

An ORM

Models declared with field attributes, queries the compiler checks, such as Post.Objects.Filter(Post.Title.Contains("Go")), and migrations written in Go.

Database

Try it

With Go 1.25 or newer:

go install github.com/vuka-lang/vuka/cmd/vuka/v2@latest
vuka new hello && cd hello
vuka run

For your editor, install the Vuka extension from the VS Code Marketplace or Open VSX. Other editors use vuka lsp; see Editors.

A taste

Errors as values, decorators and match, in a .vuka file:

vuka

func lookup(arg string) Result[User] {
	id := strconv.Atoi(arg)?          // Go's (T, error) works directly
	u := find(id)?
	return Ok(u)
}

@retry(3)
@logged
func charge(ctx context.Context, id int) (Receipt, error) { … }

match lookup(arg) {
case Ok(u):
	fmt.Println(u.Name)
case Err(&NotFound{ID: id}):
	fmt.Println("missing user", id)
case Err(e) if errors.Is(e, strconv.ErrSyntax):
	fmt.Println("not a number:", arg)
case Err(e):
	fmt.Println("error:", e)
}

A live page, pages/counter/index.vuka.html, served at /counter. Each click runs Add on the server and patches the count in place:

html

<script lang="go">
package counter

import "github.com/vuka-lang/ui/v2"

type Index struct {
	ui.Live
	count int
}

func (p *Index) Add() { p.count++ }
</script>

<main>
  <h1>{count}</h1>
  <button onClick={Add}>Add one</button>
</main>

Built on Go

Vuka stands on the work of the Go team. It doesn't have a parser or type checker of its own for Go: it finds its own additions token by token, rewrites them into Go, and leaves everything else to go/parser, go/types and the go command of the toolchain you have installed. The editor support is gopls behind a proxy. What Vuka adds is small on purpose; the language underneath is Go, and the credit for it belongs to the Go Authors. See Credits.