Competitive Landscape
You'll leave with: an honest map of what Nudo is for, what adjacent tools already own, and when you should not reach for Nudo.
Positioning deep-dive: Nudo vs TypeScript · Product face: Why Nudo · What the engine does not claim: Limits.
Positioning map
Nudo is a JS engineering gate: it computes Abs facts by evaluating code, then checks Pred implications against explicit contracts. It is not a second type language, not a runtime validator, and not a theorem prover.
| Type language in source | No type language in source | |
|---|---|---|
| Static / compile-time gate | TypeScript · Flow | Nudo (Abs + Pred + nudo check) · Hegel (archived) |
| Runtime / boundary validation | — | Zod · ArkType · TypeBox · Valibot |
| Proof-oriented refinement | LiquidHaskell / SMT-backed refinements | (not Nudo) |
Two axes matter more than feature lists:
- Where the obligation is checked — statically in CI (
nudo check) vs at a runtime boundary (parse/safeParse). - What the types are — declared annotations / schema objects vs computable Abs values with Pred constraints.
vs TypeScript
TypeScript is the default static gate for typed JS/TS. Nudo replaces that gate only for JavaScript-first packages — see the full map in Nudo vs TypeScript.
The sharpest product boundary is in Microsoft's own TypeScript Design Goals: two non-goals there explicitly decline a soundness promise and any reliance on run-time type information — the full quotes are in Nudo vs TypeScript. Nudo's throws axis (L2 entry may-throw) and Pred axis (constraint implication on Abs) sit exactly on what those non-goals exclude: obligations derived from runtime-shaped behavior, not only from erasable structural annotations. That is not a TypeScript bug — it is a deliberate scope choice. Nudo takes the complementary scope.
Also: types are erased in TypeScript. Nudo keeps Abs as the model and treats .d.ts as a one-way, lossy projection (nudo export --format dts).
vs Flow
Flow is still active (recent 0.333.x lines, Rust implementation work, a typed dialect with component / renders / match, exact objects, and a this receiver). Its differentiation is syntax and safety defaults, not annotation-free contract inference.
| Flow | Nudo | |
|---|---|---|
| Surface | .js / .jsx + Flow annotations | Plain .js (no type syntax required) |
| Differentiation | Typed dialect, exact objects, checker defaults | Contracts as computable Pred; facts from evaluating the code |
| Gate | Flow checker | nudo check (L1 contracts + L2 entry throws) |
| Types at runtime | Erased | Abs retained; runtime artifacts are export projections |
If you want Flow's dialect and its safety defaults, use Flow. If you want JS that stays JS and obligations that come from behavior plus accepted contracts, use Nudo.
vs Hegel
Hegel (JSMonk/hegel on GitHub) was the closest conceptual neighbor: strong inference without annotations, plus a Typed Errors idea. It was archived on 2024-01-29; its README states development has stopped.
That leaves a real hole: the “infer a type gate for untyped JS without asking authors to write a type language” niche is unfilled by an actively maintained tool. Nudo occupies that hole with a different center of gravity — Abs algebra, explicit sidecar contracts (*.nudo.js / @nudo:contract), and a CI gate that prints signatures and cases.
vs schema libraries (Zod, ArkType, TypeBox, Valibot)
These libraries are boundary runtime validation. They parse or safeParse data that enters the system. They are not static Pred implication over a program's internal computation.
Schemas manage data that crosses the boundary; Nudo manages facts computed inside.
| Zod / ArkType / TypeBox / Valibot | Nudo | |
|---|---|---|
| When | parse / safeParse at an API / form / IO edge | nudo check on logic + contracts in CI |
| What | Shape of incoming data | Pred obligations on computed results and entry throws |
| Truth | The schema object | Abs (shape × term × pred × conf) |
| Compile-time | Schema-as-type helpers | Full Abs algebra (x>0 ⇒ x+1>1) |
They compose: nudo export projects Abs into schema dialects (Zod dialect, Standard Schema, guards) so boundary code and CI agree on the same facts. The projection is one-way and lossy — Abs stays the source of truth. See Export.
ArkType's library docs are at arktype.io. (arktype.org is an unrelated company — do not send readers there.)
vs refinement types (LiquidHaskell and the SMT lineage)
LiquidHaskell and related systems use predicate refinement types discharged by an SMT solver — toward proofs about programs.
Inside the engine, Nudo's Pred layer is analogous: refinements are predicates on terms and they participate in implication. Outwardly, do not describe Nudo as a theorem prover. Nudo is a JavaScript engineering gate:
- No SMT backend, no proof certificates, no “verified” claim
- Fail-closed evaluation budget (call budget, widen to
unknown) rather than incompleteness as a mathematical property - Products are CI diagnostics, signatures, cases, and
exportprojections — not proofs
Use the refinement-type lineage when you need machine-checked proofs. Use Nudo when you need a practical contract gate on JS.
When not to use Nudo
Stay elsewhere when any of these dominates:
- The type language is the product. Heavy generics / conditional / template-literal type programming, declaration merging, project references → TypeScript.
- You need Flow's dialect or checker culture. Typed
component/renders/match, exact-by-default object types → Flow. - You only need boundary parse. One-shot validation of external JSON → Zod / ArkType / TypeBox / Valibot alone is enough (add Nudo when internal arithmetic and contracts matter too).
- You need proofs. Soundness / “provably correct” obligations → LiquidHaskell-style refinement types, not Nudo.
- You want fully automatic types with zero contracts and zero call sites. Nudo observes what it can evaluate and otherwise reports
unknown; it does not invent obligations. Unconstrained entry params display asany.
LLM hybrid (SCAM 2026)
LLM type-inference research (e.g. SCAM 2026) fits a hybrid loop, not a replacement for a deterministic gate:
- LLM drafts — contracts (
*.nudo.js),@nudo:contract, or@nudo:casescenarios from code or prose. - Nudo checks —
nudo check/nudo testdecide with the Abs algebra (no sampling at CI time). - Repair — machine-readable
check --json(actual/expected/fix:/actions[]) feeds the next draft round.
Drafts are never silent obligations: accepting a contract draft is what creates an L1 obligation. See AI-native DX and Agent integration.
Related
- Nudo vs TypeScript — when Nudo replaces
tsc - Why Nudo — product face
- Export —
export→ Standard Schema / Zod / guards /.d.ts - nudo check — L1 contracts + L2 entry throws
- Limits — what the engine does not claim
- Mental model