Tooling

One CLI, one language server, a native IDE and eight testing and quality tools, all written in Venutian.

The CLI you type

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.

Recorded output
$ venutian run hello.ven
Hello from Venutian

The REPL

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.

Start a session
$ venutian repl

Editor support

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:

JSON
{
  "languageServerExample.servers": [
    {
      "id": "venutian",
      "name": "Venutian",
      "command": "venutian",
      "args": ["lsp"],
      "filetypes": ["ven"]
    }
  ]
}

Neovim, with the built in LSP client:

Lua
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:

JSON
{
  "languages": {
    "Venutian": {
      "language_servers": ["venutian-lsp"]
    }
  },
  "lsp": {
    "venutian-lsp": {
      "binary": {
        "path": "venutian",
        "arguments": ["lsp"]
      }
    }
  }
}

Helix, in languages.toml:

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

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.

Testing and quality

Eight tools, all pure Venutian, each built on the same small set of existing hooks rather than new native code.

Eight tools, all pure Venutian.
ToolDoes
testrunner.venDiscovers and runs test files, the same way venutian test runs the conformance suite.
proptest.venProperty 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.venGolden file testing: write, compare and update modes, with a readable line numbered diff when fresh output no longer matches the approved file.
litmus.venA 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.venThe 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.venThe static type checker venutian check runs, and the diagnostics engine behind venutian lsp.
verify_annotations.venReal, executable requires() and ensures() style functions that give the loop invariant and induction measure verifier a syntactic convention to recognize.
depaudit.venChecks a project's dependency manifest against what its source actually imports, so a manifest's claims cannot drift from the real code.

Debugging and profiling

Debugging

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.

Profiling and source maps

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.

The package manager

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.

Next chapter The package manager