NADA

A standard for reading and writing code in any language.

The standard specifies how a program written in English can be read and written in another human language without the program changing. It defines the localization model, the dataset it uses, the order in which a term is resolved, how these are versioned, and what a tool must do to be called NADA.

Compatibility → The registry →

What the standard specifies.

NADA is a localization standard for source code, not a programming language and not a tool. It describes the behavior a conforming tool must implement so that the same source reads the same way everywhere.

The localization model The programming language’s vocabulary — its keywords and standard library — is translated. The canonical English source on disk is unchanged. The editor renders a faithful, reversible view in the reader’s language over those unchanged bytes.
The dataset A compiled body of term mappings — the “brain” — records how each term is written in each human language. The standard defines its shape and how a conforming tool reads it, not any one vendor’s copy of it.
The authority cascade A defined order for resolving a single term, so the same source resolves to the same rendering in every conforming tool. Resolution is deterministic; ties are broken by the cascade, not at random.
Versioning How the dataset and the specification are numbered, what a change to either is permitted to do, and how a tool declares which version it implements.
Conformance The behaviors a tool must exhibit to call itself NADA, and the open test that checks them. Anyone may build a tool; only conforming work may use the name.

The file is canonical. The view is translated.

The bytes on disk stay in canonical English. The editor renders the programming language’s vocabulary — keywords and standard library — in the reader’s language, and the identifiers and string contents the author wrote are left exactly as written. The view is faithful and reversible: it round-trips to the same source, byte for byte.

On disk — canonicalEnglish
def greet(name):
    if name:
        return f"Hello, {name}"
What you read — the viewहिन्दी · Hindi
परिभाषा greet(name):
    अगर name:
        वापसी f"Hello, {name}"
Only the language’s own vocabulary is projected. The names, the strings, and the bytes on disk do not change.
One program, two renderings. The localized view is generated from the canonical source on demand; it is never written back. See it run in the editor at nada.build →

The brain: how every term is written, in every language.

The localized view is produced from a compiled dataset — the brain — that records, for each term in a programming language’s vocabulary, how it is written in each human language. The standard defines the dataset’s shape and the contract a conforming tool reads it through. It does not endorse any one vendor’s copy: the structure is the standard, the data is open.

The mappings are maintained openly under NADA’s licensing: language data is CC-BY; the pipeline that builds and checks it is AGPL. Coverage and counts are in the registry.

One term, one rendering, resolved in a fixed order.

When more than one mapping could apply to a term, the standard resolves it by a defined order of authority — the cascade. Resolution is deterministic: the same source resolves to the same rendering in every conforming tool, regardless of vendor.

  1. 1

    The programming language

    A term is resolved within the vocabulary of the programming language the file is written in. Cross-language collisions never decide the outcome.

  2. 2

    The human language

    Within that vocabulary, the mapping for the reader’s chosen human language is selected. The author’s own identifiers and strings are out of scope and pass through untouched.

  3. 3

    The authoritative mapping

    Where a curated mapping exists for that term and language, it wins. [TO CONFIRM: the precise tier names and any project- or workspace-level overrides above the curated default.]

  4. 4

    Canonical fallback

    If no mapping resolves, the term is shown in its canonical English form. A reader is never shown a guess, and the view never drifts from the source.

Stable to rely on; changes are declared.

The specification and the dataset are versioned independently, and a conforming tool declares which version of each it implements. One rule governs change: a localized view of an unchanged file must stay reversible and deterministic across versions.

The specification Numbered so that a tool can state exactly which behaviors it conforms to. [TO CONFIRM: the versioning scheme — e.g. semantic versioning — and the support window for prior versions.]
The dataset Versioned separately from the specification, so the brain can grow — new languages, new terms — without forcing a specification change. Added coverage must not change how an already-resolved term renders.
Compatibility A change is only permitted to extend, never to silently re-resolve. A file that read one way must not, on an update, read another way without an explicit, declared break.

Anyone may build it. Only conforming work may carry the name.

A tool conforms when it implements the localization model, reads the dataset through the defined contract, resolves terms by the cascade, and round-trips every view losslessly to the canonical source. This is what lets a file written by one person open and run identically for the next, in any language and in any conforming tool. The NADA name is reserved for tools that do this; a public compatibility test checks it.

Read the compatibility contract →

Four rules the standard always follows.

  • Neutrality.

    The standard prescribes behavior, not a vendor. No human language is privileged over another, and no single company can change the resolution rules to favor its own product. The cascade is the same for everyone.

  • The file is canonical.

    The source on disk is the program. NADA never rewrites it. A localized view is only a view, so a file written by one person opens, runs, and diffs identically for the next, in any language.

  • Reversibility.

    Every projection is lossless and round-trips. What you read in your language maps back to the canonical term with no ambiguity. Turn the view off and the original English source is unchanged, byte for byte.

  • Color is content.

    Following the design system: scripts carry meaning, and a script rendered in ink is content, not decoration. Emphasis uses italic or bold, not color. The standard follows the same rule.

Two related documents.

Conformance

The behaviors a tool must exhibit to call itself NADA, and the open test that checks them.

Go to conformance →

Registry

The languages the standard covers and the open dataset that backs every localized view.

Go to the registry →