gzlang

Online Playground: https://gz-lang.vercel.app/

A Gen Z programming language that transpiles to JavaScript. no cap.

Write JavaScript using Gen Z slang -- gzlang converts .gz files into clean, readable JavaScript that runs anywhere JavaScript runs (Node.js, Bun, Deno, modern browsers).

chef greet(name) {
    spill("yo " + name)
}

cook user = "Nimesh"

greet(user)

compiles to:

function greet(name) {
    console.log("yo " + name);
}
let user = "Nimesh";
greet(user);

Install

npm install -g gzlang

Usage

# transpile and run in one go
gzlang run app.gz

# transpile to a JavaScript file
gzlang build app.gz
gzlang build app.gz -o dist/app.js

Interactive REPL

Run gzlang with no arguments (or gzlang repl) to get an interactive prompt, just like python or node:

$ gzlang
gzlang 0.1.0 -- type slang, get JavaScript (.exit or Ctrl+D to dip)
gz> cook vibes = ["fr", "sheesh"]
gz> vibes.map(v => v + "!")
[ 'fr!', 'sheesh!' ]
gz> lowkey (noCap) {
...     spill("multiline works too")
... }
multiline works too
gz> holdUp Promise.resolve("even top-level holdUp")
'even top-level holdUp'

Variables, functions, and squads persist across lines, multiline blocks are detected automatically, and history is saved to ~/.gzlang_history.

Programmatic API

import { transpile } from "gzlang";

const js = transpile('spill("yo")');
// console.log("yo");

The package also exports the lower-level pieces (tokenize, parse, generate) and the KEYWORDS map if you want to build tooling on top.

The vocabulary

| JavaScript | gzlang | Why | | ------------- | ------------- | -------------------------------- | | let | cook | Start cooking (create something) | | const | lockedIn | Value is locked in | | var | legacy | Nobody should use it anymore | | if | lowkey | "Lowkey true" | | else | deadass | Otherwise, deadass | | switch | vibeCheck | Check the vibe | | case | itsGiving | It's giving... | | default | fr | For real fallback | | for | grind | Keep grinding | | while | stillCookin | Keep cooking | | do | firstOff | Do first | | break | imOut | I'm out | | continue | keepCookin | Continue looping | | function | chef | The chef makes things happen | | return | bet | Bet, here's the result | | class | squad | A squad of behaviors | | new | spawn | Spawn an object | | this | me | Refers to me | | true | noCap | True, no cap | | false | cap | That's cap | | null | ghosted | Nothing there | | undefined | idk | Unknown | | try | yolo | Give it a shot | | catch | caughtIn4K | Caught the error | | throw | crashOut | Throw an exception | | async | waitForIt | Async function | | await | holdUp | Wait here | | import | yoink | Bring it in | | export | putOn | Share it | | console.log | spill | Spill the tea | | typeof | whatIsThis | Inspect type | | delete | yeet | Throw it away | | super | og | Original/base class |

Everything else -- operators, literals, function calls, property access -- is plain JavaScript. Words like extends, finally, of, and in are kept as-is.

Using a raw JavaScript keyword is a compile error with a helpful hint:

'let' is not gzlang. Use 'cook' instead, bestie (line 1, column 1)

A bigger taste

squad Dev extends Person {
    constructor(name, lang) {
        og(name)
        me.lang = lang
    }
    intro() {
        bet `its giving ${me.name} who codes ${me.lang}`
    }
}

waitForIt chef main() {
    yolo {
        lockedIn dev = spawn Dev("Nimesh", "gz")
        spill(dev.intro())
    } caughtIn4K (err) {
        spill("caught in 4k: " + err.message)
    }
}

holdUp main()

See the examples folder for more, including fizzbuzz and async/await.

How it works

gzlang is a real source-to-source compiler, not a find-and-replace:

.gz source -> Tokenizer -> Parser -> AST -> JavaScript Code Generator

• Tokenizer (src/tokenizer) turns source into tokens with line/column info.
• Parser (src/parser) builds an abstract syntax tree with full operator precedence.
• Code generator (src/codegen) walks the tree and emits readable, indented JavaScript.

All slang lives in a single mapping file, src/keywords.ts, so adding new vocabulary never touches compiler logic.

What's supported

Variables, functions (including arrow, async, defaults, rest), all loop forms, if/else, switch, classes (inheritance, static members, getters/setters, class fields), try/catch/finally, throw, imports/exports, template literals, spread, optional chaining, ternaries, and the full JavaScript operator set. Semicolons are optional.

Not supported yet: destructuring, generators, labeled statements, and regex literals (use spawn RegExp("...") instead).

Development

npm install
npm test          # run the test suite
npm run build     # build dist/ with tsup
npm run typecheck

License

MIT