TypeScript-derived · JavaScript and native C++

VexaScript

A modern language built on TypeScript. Concise for humans, efficient for AI — less syntactic noise, the same expressive power, and compatibility with the JS/TS ecosystem.

Operator overloading, await-less async, primary-constructor classes, delegated variables, new-less instantiation, and more — without leaving the tools you already use.

Compile .vx or .ts to JavaScript or an optimized native C++ executable. The compiler can compile itself in both backends, and one FFI declaration surface connects Deno and native C++ to the same libraries.

Try the playground Get started VS Code extension

hello.vx

class Point(val x: number, val y: number) {
  operator-() => Point(-x, -y)
  operator+(other: Point) => Point(x + other.x, y + other.y)
  operator*(scale: number) => Point(x * scale, y * scale)
  length => Math.hypot(x, y)
}

sync fun loadUser(id: string): User {
  val data = fetch(`/api/users/${id}`).json()
  return User(data.id, data.name)
}

Language features

Familiar syntax, modern ergonomics

VexaScript is derived from TypeScript and keeps its ecosystem while adding deliberate, efficient language features. TypeScript files retain TypeScript semantics; .vx files opt into VexaScript syntax.

Integer character literals

Single quotes hold exactly one Unicode code point and compile directly to an integer in JavaScript and C++. Double quotes remain strings.

val letter: int = 'a' // 97
val emoji: int = '😀' // 128512
val matches = "aaa".charCodeAt(0) == 'a'

Primary-constructor classes

Declare class members directly in the constructor signature. val for read-only, var for mutable. No boilerplate.

class User(val id: string, var name: string, val score: int = 0)

val u = User("u1", "Alice")
u.name = "Bob"

Operator overloading

Define arithmetic, comparison, and index operators directly on your types. Shorthand arrow syntax keeps definitions terse.

class Vec2(val x: number, val y: number) {
  operator+(b: Vec2) => Vec2(x + b.x, y + b.y)
  operator*(s: number) => Vec2(x * s, y * s)
  length => Math.hypot(x, y)
}

val v = Vec2(1, 0) + Vec2(0, 1) * 3

Await-less async

sync fun automatically awaits any Promise produced inside the body. Write async logic that reads like sync code — no await keywords needed.

sync fun loadBytes(url: string): Uint8Array {
  val res = fetch(url)
  return Uint8Array(res.arrayBuffer())
}

Delegated variables

Kotlin-style by delegates let you attach custom read/write behaviour to any variable. Works with React-style state tuples out of the box.

fun useState(init: number) {
  return [() => init, (v: number) => { init = v }]
}

var count by useState(0)
count++
console.log(count) // 1

Null-aware access

Optional chaining and nullish coalescing are fully supported. Non-null assertions let you opt out of null checks when you know better.

val city = user.address?.city ?? "Unknown"
val label = maybeUser!.name.toUpperCase()

New-less instantiation

Call constructors without new. Classes and built-ins like Map, Set, and Uint8Array work the same way.

val users = Map<string, User>()
val buf = Uint8Array(1024)
val pt = Point(3, 4)

JavaScript and native C++

The same analyzed project can emit JavaScript, a C++ translation unit, or an optimized native executable. TypeScript entrypoints are supported too.

vexa build app.ts -o app.js
vexa cpp app.ts -o app.cpp
vexa cpp link app.ts -o app

Cross-backend FFI

@FFILibrary, ABI-aware structs, pointers, and buffers describe a native API once. Deno uses dynamic FFI while generated C++ calls the same symbols directly.

@FFILibrary("libSDL2.so", "SDL2.framework/SDL2")
ambient class SDL2 {
  static fun SDL_Init(flags: int): int
}

A self-hosting compiler

VexaScript compiles the complete TypeScript compiler graph, then runs the generated compiler to produce the next generation in JavaScript or native C++.

pnpm self-host
vexa cpp run cli/cli.ts -o vexa-native

Get started

Install and write your first file in under two minutes

One npm install, one command. The VS Code extension adds a full language-server experience on top.

Install the CLI

npm install -g vexascript

Run or compile

vexa run hello.vx
vexa build hello.vx -o dist/hello.js
vexa cpp link hello.vx -o dist/hello

Add the VS Code extension

Diagnostics, quick fixes, completions, and go-to-definition as you type.

Install VS Code extension Full quickstart

Syntax reference

Everything the language supports, in one place

The full syntax guide covers every construct — variables, functions, classes, types, generics, async patterns, destructuring, and more — rendered directly from the canonical language documentation.

Read the syntax reference Browse code samples

CLI

Compile, run, test, and inspect from the terminal

The vexa CLI bundles the compiler, formatter, test runner, and language server in a single binary. The CLI guide has every command with copy-ready examples.

Open the CLI guide

Embedding API

Live editors inside your own pages

Drop a Monaco-powered VexaScript editor into any documentation page or product demo. The embedding guide has copy-ready setup snippets for both single-editor and full-workbench modes.

Open the embed guide Try the playground

Blog

Release notes and project updates

Follow new language features, milestone releases, and ecosystem news from the VexaScript team.

Open the blog