There is no package to install and nothing to configure. Pick whichever of these four suits you — they run the same language.

१ The standalone binary nothing else required

वाक्.exe ships in the repository. It is the whole toolchain — lexer, parser, analyser, compiler and machine — compiled to one file, and it needs neither Python nor anything else. Copy it where you like and run it:

वाक्.exe प्रोग्राम.vak

The binary in the repository is built for 64-bit Windows. On Linux or macOS, build your own — see Building the binary below; the C sources are platform-neutral.

२ With pip Python 3.10 or newer

Vāk pulls in no third-party packages. A standard Python is all it needs; it was developed on 3.13.

pip install vak-lang
vaak प्रोग्राम.vak

This gives you the interpreter, the bytecode virtual machine, the native back end, the REPL and the standard library, and the vak command works from any directory.

३ From a clone everything a wheel does not carry

Clone it for the C runtime, the Vāk-written toolchain behind --self, the documentation generators and the editor extension:

git clone https://github.com/vidyadheeshp/vak.git
cd vak
python -m vaak examples/01_namaste.vak

# bash / zsh
PYTHONPATH=/path/to/vak python -m vaak ~/प्रोग्राम.vak

# PowerShell
$env:PYTHONPATH = "C:\path\to\vak"; python -m vaak प्रोग्राम.vak

On Windows the two launchers in the repository do this and set UTF-8 for you:

.\vaak.ps1 examples/01_namaste.vak     # PowerShell
vaak.cmd examples/01_namaste.vak       # cmd.exe

४ In a browser nothing installed at all

The playground is this same toolchain compiled to WebAssembly. It runs entirely in the page — your program is not uploaded, and nothing you type leaves your machine. Use it to try the language before deciding whether to install anything.

Checking that it works

python -m vaak --version          # वाक् (Vāk) 0.12.1
python -m vaak --builtins         # the 39 built-in functions
python -m vaak                    # संवादः — the interactive session

Then a program of one line. Put this in परीक्षा.vak and run it — if you see the greeting, everything works:

मुद्रय "नमस्ते जगत्"।

A terminal that can show Devanagari

Two separate things have to be right: the console must be in UTF-8, and the font must contain Devanagari.

• Windows. The CLI reconfigures its own output, so Devanagari normally works in Windows Terminal. If you see boxes, the font is the problem, not the encoding — choose Nirmala UI or Noto Sans Devanagari. The older conhost console may also need chcp 65001.
• Linux and macOS. A UTF-8 locale is the default almost everywhere; locale will confirm it. Most terminal fonts fall back to a system Devanagari face automatically.

Building the binary

The native back end turns a program into C and hands it to gcc, so a C compiler is the only extra requirement. On Windows, w64devkit is the one Vāk looks for by default; on Linux and macOS the system compiler is already there.

python -m vaak --native प्रोग्राम.vak       # produce an executable
python -m vaak --run-native प्रोग्राम.vak   # build it and run it

If no compiler is found, Vāk says so rather than failing obscurely.

The editor extension

Copy the vscode-vak folder from the repository into your VS Code extensions directory and reload the window:

# Windows
%USERPROFILE%\.vscode\extensions\vscode-vak

# macOS and Linux
~/.vscode/extensions/vscode-vak

Then point it at whichever toolchain you installed — set vak.executable to your वाक्.exe, or leave that empty and set vak.pythonPath so it uses python -m vaak. You get highlighting, the .vak file icon, romanised typing that becomes Devanagari, and the analyser's diagnostics as you save — the same ones listed in दोषसूची.

Three ways to run a program, all producing identical output. The first needs Python; the last needs nothing at all.

python -m vaak प्रोग्राम.vak          # the tree-walking interpreter
python -m vaak --vm प्रोग्राम.vak     # compile to bytecode, run on the SanskritVM
./वाक्.exe प्रोग्राम.vak              # the self-hosted toolchain, no Python

Two more you will want early — the first analyses without running, the second starts a REPL:

./वाक्.exe --परीक्षा प्रोग्राम.vak    # report problems, run nothing
python -m vaak                        # संवादः — the REPL

The full set of options, read from the argument parser itself. Four carry a Sanskrit alias:

A statement ends with a danda — । — the full stop Sanskrit has used since manuscripts. ॥, the double danda, ends a section. A semicolon means the same thing and is easier to type.

मुद्रय "नमस्ते जगत्"।
मान क = ५;
मुद्रय क॥

मुद्रय prints its arguments separated by a space. Comments run from # to the end of the line.

मान declares a variable, ध्रुव a constant. A type may be written in place of मान, and then it binds — the analyser and every engine hold you to it.

मान नाम = "वाक्"।
ध्रुव पाई = ३.१४१५९।
पूर्णाङ्कः वर्षम् = २०२६।
शब्दः अभिवादनम् = "नमस्ते"।

वर्षम् += १।
मुद्रय नाम, वर्षम्, पाई।

Devanagari and ASCII numerals are the same numbers — २०२६ and 2026 are one value, and you may mix them freely. Output uses whichever form the value was written in where that is knowable, and देवनागरी() converts on demand.

यदि and अन्यथा branch. Parentheses around the condition are optional; the braces are not.

यदि (अङ्कः > १००) {
    मुद्रय "महान्"।
} अन्यथा यदि (अङ्कः > १०) {
    मुद्रय "मध्यमः"।
} अन्यथा {
    मुद्रय "अल्पः"।
}

Four loops, because four different things are worth saying. यावत् repeats while a condition holds, कुरु does the same but asks afterwards, आवृत्तिः repeats a fixed number of times, and प्रत्येकम् … अन्तः walks a collection.

यावत् (क < १०) { क += १। }

कुरु { क += १। } यावत् (क < १०)।

आवृत्तिः (३) { मुद्रय "ॐ"। }

प्रत्येकम् (अङ्कः अन्तः [१, २, ३, ४]) {
    यदि (अङ्कः == ३) { अनुवर्त। }
    मुद्रय अङ्कः।
}

विरम leaves a loop, अनुवर्त starts its next turn.

कुरु · asking after, not before

कुरु is the imperative — do! — and it opens the one loop whose body runs before anything is asked. The test that follows is written with यावत्, so the pair reads as a single sentence: do this, as long as that.

कुरु {
    उत्तरम् = पठ("नाम? ")।
} यावत् (दीर्घता(उत्तरम्) == ०)।

अनुवर्त inside a कुरु jumps to the test rather than back to the top of the body, since the body has already had its turn.

It needs no instruction of its own. A यावत् loop already compiles to a conditional jump out and an unconditional jump back; कुरु is those same two in the other order, which is why every engine — the C runtime included — understood it the day it was added.

विकल्पः · Choosing among alternatives

Where a chain of अन्यथा यदि only compares one value over and over, विकल्पः says it once. The word is Pāṇini's own: a vikalpa is an optional alternative in a rule. Each alternative is introduced by पक्षे — the locative, “in this case” — matching दोषे, the locative Vāk already uses for catch.

कार्यम् वासरनाम(कर्म पूर्णाङ्कः वारः) : शब्दः {
    विकल्पः (वारः) {
        पक्षे १: प्रत्यागच्छ "सोमवासरः"।
        पक्षे २, ३: प्रत्यागच्छ "मङ्गलः बुधः वा"।
        पक्षे ६, ७: प्रत्यागच्छ "सप्ताहान्तः"।
        अन्यथा: प्रत्यागच्छ "अज्ञातः"।
    }
}

One पक्षे may carry several values, separated by commas. अन्यथा is the fallback, and it is the fallback wherever it is written. The subject is evaluated once.

A विकल्पः also counts as returning on every path, so long as it has an अन्यथा and every पक्षः returns — which is why the function above needs no closing प्रत्यागच्छ.

कार्यम् defines a function. A return type after the colon is optional and binding. Functions are values: pass them, return them, close over their surroundings.

कार्यम् क्षेत्रफलम्(पूर्णाङ्कः दैर्घ्यम्, पूर्णाङ्कः विस्तारः) : पूर्णाङ्कः {
    प्रत्यागच्छ दैर्घ्यम् * विस्तारः।
}

कार्यम् योजकः(आधारः) : कार्यम् {
    प्रत्यागच्छ कार्यम्(क) : पूर्णाङ्कः { प्रत्यागच्छ आधारः + क। }।
}

मान दश = योजकः(१०)।
मुद्रय क्षेत्रफलम्(६, ७), दश(५)।

Functions are hoisted: a function may call one defined later in the same block.

A parameter may carry a default, which must be written out — a number, a string, सत्य, असत्य or शून्य. Nothing is computed at the call, so the value cannot be shared between calls and the mutable-default trap familiar from Python cannot arise.

कार्यम् अभिवादय(शब्दः नाम, शब्दः वचनम् = "नमस्ते") : शब्दः {
    प्रत्यागच्छ वचनम् + ", " + नाम + "।"।
}

मुद्रय अभिवादय("रामः")।              # नमस्ते, रामः।
मुद्रय अभिवादय("रामः", "स्वागतम्")।   # स्वागतम्, रामः।

Where the parameters are unmarked, a default may not sit before a parameter that has none — position is all the call has to go on. Where every parameter declares its kāraka, that restriction lifts.

प्रयुज् · applying a call you did not write

Sometimes the arguments are computed rather than written out. प्रयुज् — prayuj, “to yoke, to apply” — takes a कार्यम् and either a सूची, which fills the parameters in order, or a कोशः whose keys are kāraka names, which fills them by role:

प्रयुज्(योगः, [१, २, ३])।                        # योगः(१, २, ३)
प्रयुज्(लिखतु, {"कर्ता": "कालिदासः", "कर्म": "मेघदूतम्"})।

This is what a wrapper needs — a function standing in front of another without knowing how many arguments it takes:

कार्यम् गणयित्वा(कार्यम् क, सूची अर्घाः) {
    मुद्रय "आह्वानम्:", दीर्घता(अर्घाः)।
    प्रत्यागच्छ प्रयुज्(क, अर्घाः)।
}

प्रयुज् becomes a single instruction, because the number of arguments is only known once the program is running. That has one consequence worth stating plainly: it must be called, and cannot be passed around as a value. All five engines refuse the indirect form rather than three allowing it and two not.

लक्षणम् · what a कार्यम् declares

Lakṣaṇa is the grammarians' word for a defining characteristic — the mark by which a thing is known. A function's mark is its parameters, and लक्षणम् hands them back as an ordinary कोशः:

कोशः ल = लक्षणम्(छानय)।
मुद्रय ल.नाम, ल.प्राचलसंख्या, ल.प्रतिफलप्रकारः।
प्रत्येकम् (प्रा अन्तः ल.प्राचलाः) {
    मुद्रय प्रा.कारकम्, प्रा.प्रकारः, प्रा.नाम, प्रा.मूलमस्ति।
}

The two are meant to be used together: read the roles a function wants, then build the call from them.

कोशः अर्घाः = {}।
प्रत्येकम् (प्रा अन्तः लक्षणम्(लिखतु).प्राचलाः) {
    यदि (न प्रा.मूलमस्ति) { अर्घाः[प्रा.कारकम्] = मूल्यम्_आनय(प्रा.कारकम्)। }
}
प्रत्यागच्छ प्रयुज्(लिखतु, अर्घाः)।

For a built-in, प्रतिफलप्रकारः comes back as किमपि. That is the analyser's knowledge rather than the runtime's, and two of the five engines have no way to reach it — reporting it from the three that can would be a divergence.

सूची is an ordered list, कोशः a dictionary — literally a treasury, the word Sanskrit uses for a lexicon. Negative indices count from the end.

मान अङ्काः = [१, २, ३, ४, ५]।
मुद्रय अङ्काः[०], अङ्काः[-१], दीर्घता(अङ्काः)।
योजय(अङ्काः, ६)।

मान छात्रः = { "नाम": "रामः", "वयः": २० }।
मुद्रय छात्रः.नाम, छात्रः["वयः"]।
छात्रः.नगरम् = "काशी"।

A dictionary key may be reached with a dot or with brackets; the dot form is the same lookup written more quietly.

Typing is gradual. Write no type and nothing is checked; write one and it is enforced everywhere — at declaration, at assignment, at every call, and on the way out of a function. किमपि flows both ways, so only a provable mismatch is an error.

पूर्णाङ्कः आयुः = २५।
आयुः = "पञ्चविंशतिः"।   # प्रकारदोषः — शब्दः दीयते, पूर्णाङ्कः अपेक्षितः

This is the part of Vāk that exists nowhere else.

Pāṇini analysed a sentence not by word order but by kāraka — the role each participant plays in the action. Vāk lets a parameter declare its role, and then checks the grammar of your function the way Pāṇini checked the grammar of a sentence.

कार्यम् छानय(अपादानम् सूची संग्रहः, करणम् कार्यम् परीक्षा) : सूची {
    सूची फलम् = []।
    प्रत्येकम् (अङ्गम् अन्तः संग्रहः) {
        यदि (परीक्षा(अङ्गम्)) { योजय(फलम्, अङ्गम्)। }
    }
    प्रत्यागच्छ फलम्।
}

Because the roles are marked, the arguments carry their own labels and the order stops mattering — exactly the freedom case marking gives a Sanskrit sentence. All three of these calls are the same call:

छानय(अङ्काः, समः)।
छानय(अपादानम्: अङ्काः, करणम्: समः)।
छानय(करणम्: समः, अपादानम्: अङ्काः)।

अनुक्तम् कारकम् — the role that goes unsaid

Sanskrit does not require every kāraka to appear. देवदत्तः पचति — “Devadatta cooks” — is a whole sentence, and it states neither what is cooked nor by what means. Those roles exist; this sentence does not name them.

A parameter with a default says exactly that. The role is part of the action, and this call leaves it unexpressed.

कार्यम् छानय(अपादानम् सूची संग्रहः, करणम् किमपि परीक्षा = शून्य) : सूची {
    यदि (परीक्षा == शून्य) { प्रत्यागच्छ संग्रहः। }
    सूची फलम् = []।
    प्रत्येकम् (अङ्गम् अन्तः संग्रहः) {
        यदि (परीक्षा(अङ्गम्)) { योजय(फलम्, अङ्गम्)। }
    }
    प्रत्यागच्छ फलम्।
}

छानय(अपादानम्: अङ्काः)।              # करणम् अनुक्तम् — everything comes back
छानय(करणम्: समः, अपादानम्: अङ्काः)।   # both stated, in the other order

Because the roles are named rather than counted, a default may sit anywhere in the parameter list — not only at the end, as a language with positional arguments must insist. A call names the roles it supplies and says nothing about the rest:

कार्यम् लिखतु(कर्ता शब्दः लेखकः,
              करणम् शब्दः साधनम् = "लेखन्या",
              कर्म शब्दः ग्रन्थः) : शब्दः {
    प्रत्यागच्छ लेखकः + " '" + ग्रन्थः + "' " + साधनम् + " लिखति"।
}

लिखतु(कर्ता: "कालिदासः", कर्म: "मेघदूतम्")।   # साधनम् अनुक्तम्

A role that is neither supplied nor defaulted is an error, and the message names it — न्यूनाः प्राचलाः: कर्म — because with the order free, a position would tell the reader nothing about which role is missing.

Before anything runs, the analyser walks the syntax tree and reports what it can prove wrong: undefined names, type mismatches, assignments to constants, wrong argument counts, विरम outside a loop, kāraka violations, unreachable code, a declared return type some path does not satisfy.

$ ./वाक्.exe --परीक्षा प्रोग्राम.vak
अर्थदोषः (Semantic Analysis) — 2 दोषाः, 0 सूचनाः
  दोषः [ध्रुवदोषः] प्रोग्राम.vak:6 — ध्रुवः 'सीमा' न परिवर्तनीयः / cannot reassign the constant 'सीमा'
         6 | सीमा = ११।
  दोषः [नामदोषः] प्रोग्राम.vak:7 — अपरिभाषितम् नाम 'अज्ञातम्' / undefined name 'अज्ञातम्'
         7 | मुद्रय बाह्यम्(), अज्ञातम्।

Every message is bilingual, and every diagnostic carries a Sanskrit code — नामदोषः, प्रकारदोषः, कारकदोषः, ध्रुवदोषः, प्राचलदोषः, प्रवाहदोषः. Errors stop the program; सूचनाः are advice and do not.

The analyser exists twice: once in Python and once written in Vāk itself. The two are compared on sixty-five files — every example, the standard library, forty deliberately broken programs, and the toolchain's own source — and must produce identical diagnostics, in the same order, with the same wording.

प्रयत्नः is the attempt, दोषे the locative — “in the event of an error” — and अन्ततः what happens at the end regardless. उत्सृज throws.

प्रयत्नः {
    यदि (हरः == ०) {
        उत्सृज { "प्रकारः": "गणितदोषः", "सन्देशः": "शून्येन भागः" }।
    }
    मुद्रय अंशः / हरः।
} दोषे (द) {
    मुद्रय "दोषः प्राप्तः:", द.प्रकारः, "—", द.सन्देशः।
} अन्ततः {
    मुद्रय "समाप्तम्"।
}

The caught value is an ordinary कोशः carrying at least प्रकारः and सन्देशः. Runtime failures from the language itself arrive in the same shape, so one handler catches both.

पठ reads one line from the user and hands it back as a शब्दः. Give it an argument and that is printed first, as a prompt.

शब्दः नाम = पठ("नाम किम्? ")।
मुद्रय "नमस्ते,", नाम + "!"।

पूर्णाङ्कः वयः = संख्या(पठ("वयः? "))।
मुद्रय "आगामिवर्षे भवतः वयः", वयः + १, "भविष्यति।"।

What comes back is always text, even when it looks like a number, so wrap it in संख्या when you want arithmetic. A line that cannot be read as a number raises a catchable कार्यकालदोषः:

प्रयत्नः {
    पूर्णाङ्कः क = संख्या(पठ("अङ्कम् लिखतु: "))।
    मुद्रय "वर्गः:", क * क।
} दोषे (द) {
    मुद्रय "सः अङ्कः न आसीत् —", द.सन्देशः।
}

In the playground there is no terminal to type into, so the box under the editor is what पठ reads — one line per call.

आनय — bring — imports. A module is any .vak file; whatever it declares at the top level is what it exports.

आनय "गणितम्"।                       # गणितम्.वर्गः(...)
आनय "गणितम्" इति ग।                  # ग.वर्गः(...)
आनय "गणितम्" तः वर्गः, क्रमगुणितम्।   # वर्गः(...)

Modules run once and are cached; a circular import is reported rather than hung on. Files are read and written with the built-ins:

शब्दः विषयम् = सञ्चिकापठ("काव्यम्.txt")।
सञ्चिकालिख("फलम्.txt", विषयम्)।
यदि (सञ्चिकास्ति("फलम्.txt")) { मुद्रय निर्देशिका(".")। }

Two modules ship with Vāk, and both are written in Vāk — they are ordinary .vak files you can read, and a fair sample of what the language looks like in use. Bring one in with आनय:

आनय "गणितम्"।
मुद्रय गणितम्.क्रमगुणितम्(५)।        # १२०

आनय "शब्दाः" तः विलोमः_वा।
मुद्रय विलोमः_वा("नयन")।            # सत्य

Every signature below is printed from the module's own source, so it is exactly what the file declares — including the kāraka role each parameter takes.

आनय "गणितम्"। Mathematics — two constants and sixteen functions.

आनय "शब्दाः"। Strings — thirteen functions over शब्दः.

The point of the project is a language that does not depend on a host language.

A Vāk program can be executed by any of five engines, and all five are held to byte-identical output on every example:

1. The tree-walking interpreter, in Python — the reference, the definition of what a program means.
2. The SanskritVM, in Python — a stack machine over bytecode whose every instruction has a Sanskrit name.
3. The SanskritVM written in Vāk — the machine's semantics, expressed in the language it runs.
4. The SanskritVM in C — the native runtime, ~2,600 lines.
5. वाक्.exe — the whole Vāk-written toolchain compiled natively. No Python anywhere.

The front end is entirely self-hosted. Lexer, parser, analyser, compiler and virtual machine all exist written in Vāk, and each is checked against its Python counterpart at the finest granularity that stage allows — the lexer on every token's kind, lexeme, value and line; the parser on the whole syntax tree node for node; the analyser on every diagnostic's code, line and wording; the compiler on every instruction, constant and line number.

python -m vaak --self प्रोग्राम.vak      # compiled by Vāk, run on the Python VM
python -m vaak --self-vm प्रोग्राम.vak   # lexed, parsed, compiled AND run by Vāk
python -m vaak --native प्रोग्राम.vak    # a standalone executable (needs gcc)
python -m vaak --bytecode प्रोग्राम.vak  # disassemble

Python is used to build वाक्.exe once, exactly as a C compiler is used once to build a self-hosting C compiler. After that the language stands on its own.

The analyser reports 6 kinds of error and 6 kinds of warning. A दोषः stops the program from running; a सूचना is printed and the program runs anyway. Every one carries its Sanskrit name, so a message can be looked up here.

Separately, an error caught by दोषे carries its kind in प्रकारः. These are the 4 values it can hold:

प्रयत्नः {
    मुद्रय संख्या("न अङ्कः")।
} दोषे (त्रुटिः) {
    यदि (त्रुटिः.प्रकारः == "कार्यकालदोषः") {
        मुद्रय "गणने दोषः / a runtime error"।
    }
}

Each one, happening

A list of diagnostics teaches less than watching one fire. Below is the shortest program that provokes each, and the message the analyser actually gives — both taken from the test suite and regenerated whenever this page is built, so a reworded message changes here too.

कार्यम् क() : पूर्णाङ्कः { प्रत्यागच्छ १। मुद्रय "अगम्यम्"। }
मुद्रय क()।

कार्यम् क() { मान अ = ५। मुद्रय "अ इति न प्रयुक्तम्"। }
क()।

कार्यम् क(अ) { मुद्रय अ। }
क(कर्म: १)।

कार्यम् क(कर्ता अ, ब) { मुद्रय अ। }

ध्रुव क = ५। क = ६।

अज्ञातम् = ५।

मान क = १। मान क = २।

मुद्रय -"अ"।

कार्यम् क(अ) : पूर्णाङ्कः { यदि (अ) { प्रत्यागच्छ १। } }

विरम।

मान क = १।
विकल्पः (क) {
    पक्षे १: मुद्रय "अ"। मुद्रय अज्ञातम्।
    पक्षे २: विरम।
}

मुद्रय दीर्घता(१, २, ३)।

Each keyword may be written in Devanagari, in IAST transliteration, or in plain ASCII. They are the same word — the lexer holds all three spellings, so 28 keywords are what there is to learn.

Where a cell lists two Devanagari words joined by ·, they are synonyms for the identical token, not different keywords: दोषे and गृहाण both begin a catch block. 10 constructs have such a pair.

Available everywhere without an import. Two more — गणितम् and शब्दाः — are libraries written in Vāk and brought in with आनय.