Test DSL
Make the code show its work
Tests live next to the code they check. A test block and an observe line read like normal Vary, so the proof is right where you need it.
READABLE CODE, CHECKABLE TESTS.
vary
A readable, statically-typed programming
language that measures test strength.
Install the toolchain manager and latest compiler. Full install docs →
curl -fsSL https://github.com/ccollicutt/vary/releases/latest/download/install.sh | sh
Features
Why varylang
A lie detector for tests
Tests can lie. Mutation testing exposes the ones that do. vary mutate shows which tests are weak, which mutations survived, and exactly what to fix.
Contracts and assertions
Contracts (in / out) declare what a function expects and what it promises. observe assertions check behaviour at runtime. Both are part of the language, not annotations you bolt on.
One CLI for the entire workflow
Run, check, test, format, and mutate from a single binary. Everything ships with the compiler. No plugins or extra tools required. Get started in minutes.
Fast JVM execution
Vary compiles to JVM bytecode and runs on any JVM. Mutation testing uses bytecode patching, so mutants run without recompiling.
See it in action
What Vary looks like
Testing is part of the language
Test blocks and observe assertions are normal Vary code. Put the checks beside the functions they protect.
Readable syntax
Vary keeps the plain shape developers like in Python and adds static typing plus compile-time checks. No semicolons, no ceremony.
Mistakes caught before runtime
Static typing, null safety, and compile-time analysis catch common errors before the program runs. The code stays compact.
Core ideas
What makes Vary different
Mutation testing
Passing tests are the start
A green suite can still miss the bug. Vary changes the compiled program on purpose, then checks whether your tests catch it.
Read mutation testing docsContracts
Turn assumptions into checks
If a function has rules, put them in the function. Contracts keep promises out of comments and let tests enforce them.
Read contracts docsEcosystem
Keep the toolchain together
The compiler, runtime, tests, mutation runner, and app workflow ship together. You should not need a pile of side tools before the work feels real.
Read ecosystem docsVAST
Test the compiler as it grows
VAST writes small valid programs and runs them more than one way. If the answers differ, there is a seed to replay and a compiler bug to chase.
Read about VASTTypes
Readable code, fewer late surprises
Vary keeps the code compact. Static types and explicit optional values catch mistakes before they turn into runtime cleanup.
Read the types docsCheck engine
Diagnostics should explain themselves
vary check points at weak tests, unclear code, and risky patterns. The message tells you what is wrong, not just which rule fired.
HTTP
Put app boundaries in the code
HTTP contracts and public JSON types keep routes, inputs, and outputs in one place. Less framework glue, fewer mystery edges.
Read HTTP docsVAR
Tell agents what to prove next
vary var reads the working tree and picks the next useful check. Agents get a command to run, not a hand-wavy "looks good".
Ecosystem
One ecosystem for building, testing, and shipping
Compiler verification
VAST
Vary Automated Semantic Testing
Generates valid Vary programs and runs each one through two independent execution paths. If the AST interpreter and JVM backend disagree, VAST fails the run.
Agent workflow VAR Vary Adaptive Reviewvary var reads the working tree, chooses the next validation stage, and emits the exact command a coding agent should run next.
Push source to a Via host. Via builds, verifies, and attaches public routes only after policy, certificate, and ownership checks pass.
From the blog
Articles
Learn
Courses
Start with a guided path instead of a blank file. Each course is made of short runnable lessons with commands to try, output to check, and a clear next step.
Vary: It's very good
Start Exploring
Install the toolchain manager and the latest compiler.
Install Vary →