Open-source project
sebastienros/jint avatar
sebastienros/jint

Jint: an in-process ECMAScript interpreter, its corpus numbers and its branch policy

Javascript Interpreter for .NET

4,750 stars612 forksC#BSD-2-Clause

At a glance

What is it?
Jint runs JavaScript inside a .NET process with no native dependency and no separate runtime. What is worth reading closely is everything around that: prepared scripts that are safe to share, values that are not, browser and Node APIs that stay switched off until a host grants them, conformance percentages scoped to pinned corpora, and a main branch that is already Jint 5.
Who is it for?
Fit if you need to evaluate JavaScript inside a .NET service with no native runtime to install, and if you can live with modern ECMAScript plus opt-in platform pieces. Skip it if you need Node compatibility out of the box, an isolation boundary you can rely on across trust domains, or a stable API on the branch you would clone.
Can I use it commercially?
Yes. BSD-2-Clause is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly C#, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • sebastienros/jint4,750 ★ · +25
Star history
Repository2026-09-232026-11-15
sebastienros/jint4.7k4.8k

25 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

One package reference, then a new Engine

The core package is added with a single command:

bash
dotnet add package Jint

Evaluation then takes two lines:

csharp
var engine = new Engine();
var result = engine.Evaluate("40 + 2").AsNumber();

The design constraint behind that API is stated up front: Jint runs JavaScript directly in your process with no native dependencies, no bytecode generation and no separate runtime. That is the whole pitch for a hosting decision, since there is no engine to install, no library to load through a native binding and no sidecar process to supervise. It also sets the ceiling. The target frameworks are .NET Framework 4.7.2, .NET Standard 2.0 and 2.1, .NET 8 and .NET 10, and because the interpreter runs in-process, the script shares the process's identity, its memory and its failure modes rather than being fenced off from them.

Prepared scripts are shareable, JsValue objects are not

Repeated execution is handled by preparing a script once:

csharp
var script = Engine.PrepareScript(
    "items.reduce((sum, value) => sum + value, 0)",
    source: "sum.js",
    strict: true);

var engine = new Engine();
engine.SetValue("items", new[] { 1, 2, 3 });

var total = engine.Evaluate(in script).AsNumber();

The important detail is the boundary the documentation draws around it. A `Prepared<Script>` and a `Prepared<Module>` are thread-safe and may be shared across engines, so the parse cost is paid once and the artefact is reusable. JavaScript objects are not: a `JsValue` that contains an object belongs to the engine and the realm that created it. That distinction decides a lot of host code. Caching the prepared form across requests is fine; passing a result value from one engine into another is not, and a host that treats the value as a plain object reference will be working outside what is guaranteed.

Exposing .NET means handing over one delegate

Calling from JavaScript into the host is a matter of publishing what the script needs:

csharp
var engine = new Engine()
    .SetValue("log", new Action<string>(Console.WriteLine))
    .Execute("""
        function greet(name) {
            const message = `Hello, ${name}!`;
            log(message);
            return message;
        }
        """);

var greeting = engine.Invoke("greet", "Ada").AsString();

The script gets one global, `log`, bound to a .NET delegate, and calls back through it. Everything else it can reach depends on what you publish. The recommended usage guidance is blunt about this: expose narrow, purpose-built host capabilities instead of broad CLR access. The same guidance covers the rest of the surface, with strict mode enabled when compatible with your scripts, one operation per engine at a time, awaiting async work before reusing or disposing an engine, and a fresh engine across trust domains. Global snapshots are described as helpful for trusted reuse and explicitly not an isolation boundary, which is the sentence to keep in mind if a pool of engines is tempting you.

Browser and Node APIs stay off until a host grants them

The feature list names modern ECMAScript with modules, promises, async functions, generators, `Intl` and `Temporal`, plus direct projection of .NET values, delegates, objects, collections and types, synchronous and asynchronous module loaders, execution constraints, hardened defaults for untrusted code and security diagnostics. Then the opt-in part arrives, and the rule is stated plainly: browser and Node APIs are not installed by default, and hosts explicitly grant the capabilities each script needs. Those extras live in separate packages, added only when the application needs an optional debugging or browser surface. `Jint.Browser` covers headless HTML, DOM, navigation, networking, storage and content extraction. `Jint.Browser.Tool` is the `jint-browser` command-line tool. `Jint.Browser.Mcp` is a Model Context Protocol server for browser automation. `Jint.DevTools` is a Chrome DevTools Protocol server for debugging and profiling an engine. The core package alone is not a browser.

The conformance percentages are scoped to pinned corpora

Four numbers get quoted, and the README attaches a scope to each one while saying they describe the pinned test corpora in the repository rather than the entire web platform. ECMAScript and ECMA-402 stand at 99.9%, which is 102,585 of 102,692 generated test262 cases drawn from `annexB`, `built-ins`, `intl402`, `language` and `staging`, with 107 cases skipped, measured against test262 commit `419d3e0`. The WinterTC Minimum Common API sits at 79.5%, or 62 of 78, where 59 members are present and 3 are correctly absent for Jint's global shape and the remaining 16 are WebAssembly, declined by design. Jint runtime Web APIs reach 92.9%, which is 38,649 of 41,581 assertions in the vendored `.any.js` WPT corpus across 44 suite directories, and `Jint.Browser` reaches 84.0%, 9,691 of 11,541, in the gated in-process browser WPT corpus. Read the second column as progress against a fixture list, not as coverage of a platform.

The benchmarks compare cached paths and say so

The comparison is a BenchmarkDotNet run in the repository's default job, and the README is explicit that it uses each engine's recommended cached execution path. On that basis Jint is described as the fastest managed engine on 10 of 12 scripts and the fastest interpreter on all 12, with the lowest managed allocation on 10 of 12. Script-to-host interop is reported as 3.4x to 11.2x faster than the measured ClearScript lanes, and a startup-shaped minimal script runs in about 1.1 us with a prepared Jint script against about 380 us for the compiled V8 lane. The caveats are part of the claim. Cached paths are what the README recommends you use anyway, and the recommended usage section tells you to measure with your own scripts and host objects because interpreter performance depends heavily on call frequency and script-to-host traffic. A host with a different call pattern will not reproduce these numbers, and the guide links to performance and advanced hosting pages for engine lifetime, pooling, projection and caching.

main is already Jint 5, and 4.x is the compatibility lane

Branch policy is the part that decides your upgrade path. Jint 5 is under development on `main` and has not been released; that branch carries breaking changes, and development packages come from a preview feed. The `4.x` branch is the maintenance lane for Jint 4.16, preserving compatibility and concentrating on non-breaking correctness and conformance fixes. The `3.x` branch receives only security and severe-correctness maintenance. Pull requests target `main` unless they are explicit backports, and a migration guide covers moving from Jint 4 to Jint 5. Recent releases are v4.17.0 dated 2026-10-07, v4.16.4 dated 2026-09-25 and v4.16.3 dated 2026-09-19, with the last push to the repository on 2026-11-02. The repository itself is one solution with a project per package, a benchmark project, an AOT example including an unrooted host variant, a REPL, source generators, test projects per surface, `Directory.Packages.props`, `global.json` and a `docs` directory.

Named users span databases, workflows and docs

The adoption list is short and specific: RavenDB, EventStoreDB, Orchard Core, Elsa Workflows, Docfx and JavaScript Engine Switcher. That spread is a fair description of what an in-process interpreter is used for, since each of those is a system that needs to run a script inside a long-lived .NET process rather than a standalone runtime. The license is BSD-2-Clause, which is permissive enough that embedding it in a product is not the obstacle. For engine lifetime, pooling, projection and caching, the README points to its performance and advanced hosting guides.

Editorial conclusion

Fit if you need to evaluate JavaScript inside a .NET service with no native runtime to install, and if you can live with modern ECMAScript plus opt-in platform pieces. Skip it if you need Node compatibility out of the box, an isolation boundary you can rely on across trust domains, or a stable API on the branch you would clone. Before adopting, decide whether you are on Jint 4 or Jint 5, read the migration guide if moving to 5, and measure with your own scripts rather than the published benchmark.

Frequently asked questions

What is a jint?

Jint is a modern ECMAScript interpreter for .NET. It runs JavaScript directly inside your process, with no native dependencies, no bytecode generation and no separate runtime, and it targets .NET Framework 4.7.2, .NET Standard 2.0/2.1, .NET 8 and .NET 10.

How do I add Jint to a .NET project?

Add the core package with `dotnet add package Jint`, then create an engine and call `Evaluate`, as in `var result = engine.Evaluate("40 + 2").AsNumber();`. Browser, Node and DevTools pieces live in separate packages that are not installed by default.

Is it safe to reuse a prepared Jint script across engines?

Yes. `Prepared<Script>` and `Prepared<Module>` are thread-safe and may be shared across engines. JavaScript objects are the exception: a `JsValue` that contains an object belongs to the engine and realm that created it.

Which ECMAScript test results does Jint report?

99.9% on the pinned test262 corpus, which is 102,585 of 102,692 generated cases with 107 skipped, measured against test262 commit `419d3e0`. The README notes these percentages describe the pinned corpora in the repository rather than the entire web platform.

Is Jint 5 released yet?

Not yet. Jint 5 is under development on `main` and that branch includes breaking changes, with development packages served from a preview feed. The `4.x` branch maintains Jint 4.16 with compatibility preserved, and `3.x` receives security and severe-correctness maintenance only.

Official sources

  1. Issues
  2. License: BSD-2-Clause
  3. README
  4. Releases
  5. sebastienros/jint on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/sebastienros-jint.svg)](https://hysenlabs.com/projects/sebastienros-jint)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/sebastienros-jint.svg)](https://hysenlabs.com/projects/sebastienros-jint)

Was this useful?