End to end by choice.
JavaScript, Rust, and C# each own their native lifecycle and browser path.
Three languages · six runtime paths
Test the language you ship.
Use one native JavaScript module unchanged in Node.js and real browsers. vanilla-test works with bundlers and without a bundler. Native ESM uses a standard import map and no transpilation.
- Node.js
- Real browser
- Native V8 coverage
Use one dependency-free Rust implementation natively and compile the same unit-test inventory into browser WebAssembly.
- Native Cargo
- Browser WASM
- LLVM source coverage
Use one dependency-free C# lifecycle library in .NET and execute the same parameterless MSTest inventory in a browser-hosted .NET AppBundle.
- .NET 8 library
- Browser AppBundle
- Cobertura coverage
# JavaScript · Node + browser
npm install vanilla-testNo build step. Node and browsers execute the ES module directly.
# Rust · native + browser WASM
cargo add vanilla-testZero dependencies. Safe Rust owns the lifecycle and Cargo owns the build.
# C# · verified GitHub packages
gh release download 2.1.3 --repo RIAEvangelist/vanilla-test --pattern '*.nupkg' --dir ./packages
dotnet add package vanilla-test --version 2.1.0 --source ./packages
dotnet tool install --global vanilla-test.tool --version 2.1.0 --add-source ./packagesNo runtime dependencies. The core targets .NET 8; the browser tool publishes a complete .NET AppBundle. Both packages currently come from the verified GitHub release bundle.
Why Vanilla Test
Less machinery between code and truth.
Vanilla is a control-surface choice. JavaScript stays an ordinary ES module in Node and Chrome. Rust stays ordinary safe Rust natively and compiles its tests with Cargo. C# stays an ordinary .NET library and reuses its parameterless MSTest methods through a browser-hosted .NET runtime. No language implementation wraps another.
Runtime paths, not test copies.
Each language's browser path executes the same source used by its native path.
A smaller control surface.
No JavaScript build pipeline, Rust WASM framework, or C# test-source copy is required.
Published quality snapshot
Loading verified status… latest successful main build main
One untransformed verification module in both runtimes.
CLI, configuration, timeout, server, and path-safety behavior.
Statements, branches, functions, and lines in Node and Chrome.
The same lifecycle and Behavioral inventory runs natively and as browser WASM.
The native adapter and browser host execute the same parameterless inventory, including Behavioral coverage.
.nupkg packing, clean local-source consumption, tool install, and generated AppBundle are verified separately.
Native .NET coverage remains separate from real-Chrome browser compatibility.
Browser builds, target selection, artifact discovery, and documented usage.
Instrumented regions, lines, and functions plus a detailed report.
Badge information
What each badge proves.
Badges are compact links to package metadata or build evidence. Use the testing and coverage pages when you need the scope, commit, timestamp, and raw reports behind them.
Required repository gates
Links to the workflow that runs JavaScript, Rust, and C# natively and in real Chrome, verifies packages, and deploys Pages evidence.
Published package metadata
Version and download badges come from npm. The license badge reflects the repository's MIT license.
Published Rust metadata
Version and download badges point to the dependency-free Rust crate.
Verified .NET package assets
The dependency-free C# library and companion tool are separate .nupkg assets. Neither package ID is currently published on NuGet.org.
Test results with provenance
The quality endpoint is generated from the successful main build. The Testing page shows each gate separately.
Runtime-specific evidence
Node and Chrome badges stay separate because each runtime collects and enforces its own native V8 coverage.
Instrumented Rust source
Regions, executable lines, and functions come from Rust's bundled LLVM tools; browser WASM remains a separate pass/fail lane.
Instrumented C# source
Native line and branch coverage comes from the .NET test run; the browser AppBundle remains a separate pass/fail lane.
JavaScript engineer paths
Focused Node + browser references.
These detailed pages belong to the JavaScript lane. Use the persistent language selector for Rust or C# documentation.
Run one suite in two hosts
Create the shared entry, add the Node adapter, and configure the complete document-relative browser import map.
Read the getting-started guide →Copy complete working patterns
Start from runnable browser, Node, async, failure, and type-check examples.
Browse the examples →Use the lifecycle correctly
Understand active-test guards, immutable result snapshots, completion events, and strict decisions.
Open the API reference →Run code in the playground
Edit a real ES module, inspect its mirrored console output, and reset the isolated runtime between runs.
Launch the playground →Rust engineer paths
Focused native + browser WebAssembly references.
Every Rust topic has its own page and stays separate from the JavaScript contract.
Native to browser guide
Install, write one Rust suite, run Cargo, build WASM, and deploy.
Read the Rust guide →Complete Rust examples
Passing suites, failed results, typed errors, and a custom browser page.
Browse Rust examples →Rust API reference
Public types, methods, result fields, lifecycle errors, and invariants.
Open the Rust API →Native Rust coverage
Built-in LLVM source coverage plus the separate real-Chrome WASM gate.
Open Rust coverage →C# engineer paths
Focused native .NET + browser AppBundle references.
Every C# topic distinguishes the dependency-free core library from the companion browser-build tool.
Native to browser guide
Install, write one MSTest inventory, run it natively, publish an AppBundle, and deploy.
Read the C# guide →Complete C# examples
Passing suites, lifecycle exceptions, MSTest reuse, and a compatible browser page.
Browse C# examples →C# API reference
Public classes, methods, immutable result fields, typed errors, and invariants.
Open the C# API →Native C# coverage
Line and branch coverage plus the separate real-Chrome AppBundle gate.
Open C# coverage →Install
Choose the package for your language.
Each package preserves the same small lifecycle while staying idiomatic to its runtime.
npm install vanilla-testcargo add vanilla-testdotnet add package vanilla-test --version 2.1.0 --source ./packagesCheck the terminal.
A successful install exits with status 0.