venutian run <file.ven|file.vbc>
Compiles if needed, then executes.
One CLI, one language server, a native IDE and eight testing and quality tools, all written in Venutian.
The venutian binary is one program with ten commands a working day actually uses.
venutian run <file.ven|file.vbc>
Compiles if needed, then executes.
venutian build <file.ven> [-o out]
Compiles to a .vbc bytecode file, with an optional per‑function source map.
venutian disasm <file.ven|file.vbc>
Prints human readable bytecode.
venutian repl
Starts an interactive session.
venutian ast <file.ven>
Dumps the parsed AST as JSON.
venutian tools <file.ven>
Dumps every tool calling schema as JSON.
venutian check <file.ven>
Runs the pure Venutian static type checker.
venutian lsp
Starts the pure Venutian language server on stdin and stdout.
venutian tokens <file.ven>
Dumps the raw lexer output line by line.
venutian introspect <file.ven>
Prints a module's real exported functions, shapes and behaviors.
$ venutian run hello.ven
Hello from Venutian
venutian repl opens a prompt against the same compiler and VM as venutian run. Every line is compiled and executed on the spot, the same grammar, the same standard library, the same error reporting a script gets.
$ venutian repl
venutian lsp is a real Language Server Protocol server written in pure Venutian, a thin protocol skin over the same checker venutian check runs. It speaks standard Content-Length framed JSON-RPC over stdio, so any LSP client can start it as a subprocess. It handles initialize, textDocument/didOpen, textDocument/didChange, textDocument/hover, textDocument/completion, shutdown and exit. Diagnostics come straight from the type checker. Hover and completion read the real parsed AST for the open file and hand it to the same functions venutian introspect uses, so what you see hovering over a name is what the checker sees too.
VS Code, a generic LSP client extension pointed at the language:
{
"languageServerExample.servers": [
{
"id": "venutian",
"name": "Venutian",
"command": "venutian",
"args": ["lsp"],
"filetypes": ["ven"]
}
]
}
Neovim, with the built in LSP client:
vim.lsp.start({
name = "venutian",
cmd = { "venutian", "lsp" },
root_dir = vim.fs.dirname(vim.fs.find({ "venutian.json", ".git" }, { upward = true })[1]),
})
Zed, as a custom language server for .ven files:
{
"languages": {
"Venutian": {
"language_servers": ["venutian-lsp"]
}
},
"lsp": {
"venutian-lsp": {
"binary": {
"path": "venutian",
"arguments": ["lsp"]
}
}
}
}
Helix, in languages.toml:
[language-server.venutian-lsp]
command = "venutian"
args = ["lsp"]
[[language]]
name = "venutian"
scope = "source.venutian"
file-types = ["ven"]
language-servers = ["venutian-lsp"]
One note: didChange re-reads the file from disk rather than the client's in memory buffer, so diagnostics reflect the last save, not every keystroke. Save, and the language server catches up.
Venutian Studio is a native IDE, a macOS app today, with Linux and Windows builds on the way. Its own text engine, layout engine and native formatter keep typing and formatting instant, with no browser and no Electron runtime between a keystroke and a cursor.
Diagnostics come from the same venutian lsp every other editor talks to. A visual block editor, venutian studio-visual <file.ven>, maps a file's real AST to a draggable graph and writes real Venutian source back to disk on every edit, live reloading against the language server for the same diagnostics.
make grade(score)
choose score
is n: Integer where n >= 90
give "A"
is n: Integer where n >= 80
give "B"
is n: Integer where n >= 70
give "C"
is : Integer
give "F"
otherwise
give "not a number"
Eight tools, all pure Venutian, each built on the same small set of existing hooks rather than new native code.
| Tool | Does |
|---|---|
testrunner.ven | Discovers and runs test files, the same way venutian test runs the conformance suite. |
proptest.ven | Property based testing with automatic shrinking: a generator produces many random values from a seed, and a failure shrinks to the smallest input that still fails before it is reported. |
golden.ven | Golden file testing: write, compare and update modes, with a readable line numbered diff when fresh output no longer matches the approved file. |
litmus.ven | A memory model checker for small multi threaded programs: it enumerates every execution a model allows and returns the set of outcomes that model permits. |
benchstats.ven | The statistics core behind every benchmark number on this site: compensated mean and variance, median, MAD, linear percentiles, outlier flagging by modified z score, and the Mann-Whitney U test for whether two benchmark runs actually differ. |
typecheck.ven | The static type checker venutian check runs, and the diagnostics engine behind venutian lsp. |
verify_annotations.ven | Real, executable requires() and ensures() style functions that give the loop invariant and induction measure verifier a syntactic convention to recognize. |
depaudit.ven | Checks a project's dependency manifest against what its source actually imports, so a manifest's claims cannot drift from the real code. |
venutian debug <file.ven> [--break N ...] runs a target program as a real subprocess and stops at the breakpoints you name; debugger.ven then parses the crash report and call stack venutian run already prints on an uncaught error into a structured analysis.
venutian profile <file.ven> runs the same way through profiler.ven, parsing the real wall clock report table the VM prints rather than sampling from the outside. sourcemap.ven loads and queries the per-function source map JSON that venutian build --emit-source-map writes, so a bytecode offset in a report can be traced straight back to a source line.
Every one of these tools is installed the same way your own project's dependencies are: venutian install, a real project manifest, a real lockfile, real content hashes. See the full workflow on the package manager page.