EML-U · Universal Semantic Profile

Languages can evolve.

A language need not be rebuilt from scratch to gain new capabilities. EML-U explores explicit semantic attachments and composition on existing languages: one semantic model, multiple host projections, and evidence for every supported transformation.

Bounded experimental MVP · corpus: 480 of 1,000 cases accepted

The object of iteration is the programming language itself—not only the programs written in it.

EML-U

Semantic identity

operators · effects · composition · constraints

  • C++20
  • Rust 2021
  • EML-P / PY
Declared contracts + actual host verification

Bounded semantic profiles and original native-project delegation are different capabilities.

Language evolution

Extend the meaning. Keep the foundations.

The method starts with an existing host, identifies an expression or composition boundary, and introduces explicit semantic constructs. Reusing a compiler and runtime does not make the added language design disappear.

  1. 01

    Locate the boundary

    State what the host already means, what a new operator should express, and which observable behavior must survive.

  2. 02

    Attach and compose

    Give added semantics stable identities, operands, effects and constraints. Resolve declared order and conflicts instead of concatenating labels.

  3. 03

    Project and test

    Lower only supported contracts. Check real target execution and deliberately broken witnesses; preserve unresolved obligations.

Implemented, with boundaries

A small working core. An explicit frontier.

Four legacy executable profiles remain distinct from twenty-three exact typed-core contracts. Floating values now reach managed state, expressions, explicit casts and the full functions0.7 domain. New reachable loop/capture compositions are qualified across C++20, Rust checked/unchecked and CPython. Native-project delegation remains separate from semantic understanding or arbitrary source conversion.

  • Operator ontology & composition

    Versioned semantic records, anchors and occurrences; deterministic normalization, declared relations, conflict diagnostics and decision traces.

  • Explicit numeric contracts

    Integer operations and separately rounded f32/f64 primitives preserve exact bits, RNE and canonical NaN. Floating arrays/records, managed values, expressions, explicit casts and functions0.7 retain distinct IEEE equal and same_bits; broader graphs, ABI and libm remain open.

  • Batch state & aliases

    Neighbor updates, captured observers and conditional private-buffer reuse. Equal values are not proof that aliases are absent.

  • Ownership, functions and errors

    Explicit owner/alias/copy/move/borrow, lexical calls and closures, Result/catch and scoped cleanup with preserved prefix effects. Finite typed contracts, not a complete reference graph or foreign ABI.

  • Checkpoint / replay

    Owned checkpoint state and suffix replay in a fresh owner. Complete vectors and final state are compared.

  • Evidence & local delivery

    UFC-030: 8 verified configurations and 4 matching incomplete traces (unverified), compact Resource-return/attempt scope, 45 stages and 1336 trace events. A wrong-frame Result cleanup control is rejected with the same effects, error and final value. Only the first rich input was compiled twice (30 s timeouts); zero targets executed and the other two rich cases were not run. The rich group remains unqualified; the compact matrix is separate. Older startup causes remain unknown.

  • Original native projects

    C+++ / Rust+ / Python+: original source, paths, build arguments and binary streams go to native tools. Six witnesses / eight native stages and six negative controls passed from source and a fresh installed package.

Composition resolution is separate from target lowering: a resolved arbitrary graph is not automatically executable. Restricted importers retain their own declared scalar/profile limits; no general host parser or arbitrary source conversion is claimed.

A real starter—not a future syntax sketch

Overflow must mean the same thing.

The existing scalar starter declares modulo-2³² arithmetic. These are the five observations in its complete verified target matrix—not a browser execution on this page.

Overflow must mean the same thing.
Declared operationExpected stdout line
4294967295 + 10
4294967295 × 42949672951
65536 × 655360
output(4294967295)4294967295
4294967295 × 00

Literal stdout · ASCII + LF

0
1
0
4294967295
0

C++20 · EML-P interpreter · emitted Python / CPython · Rust checked + unchecked

A dated engineering observation for scalar-u32, not every program in every host. The machine-readable snapshot records its source revision and limits.

Read the engineering snapshot
One family, distinct responsibilities

Preserve the origin. Build the next layer.

EML-P remains the practical profile within the EML-U theory. EML-NOVA is the peer tensor/operator language. NoGlyph and CVSG, the family’s two further public lines, each keep their own implementation and evidence. CAIR, ICNS and MNVP retain their own contracts; an integration seam is not implemented support.

  • EML-U

    Operator ontology, semantic attachment, composition and multi-host contracts.

  • EML-P

    Deterministic practical execution profile, projected to Python.

  • EML-NOVA

    The peer AI-native tensor/operator language; its own implementation and evidence.

  • NoGlyph

    The constraint-first line: a program separated from its visible text, its canonical constraints resolved into a program graph and lowered to C.

  • CVSG

    The Chinese-first line: Chinese authoring over a typed semantic graph with spectrum-valued state and a versioned rulebook.

No silent semantic loss: project faithfully, preserve explicit metadata, or reject unsupported lowering.

Read the preserved origins
Dated engineering baseline

Evidence first. A measured frontier.

This snapshot is dated, not a live counter. Tests, host witnesses, installation, corpus acceptance and publication are distinct claims.

2026-11-20 · 34843a8

tests / 109 files (serial)
2370
legacy executable profiles
4
excluded starters
8
accepted production cases (goal 1,000)
480
  1. Qualified slice

    Thirty engineering rounds; twenty-three typed-core contracts

    UFC-026–029 repair cancellation of nested captures, closures, ordinary returns and pure-value Results. UFC-030 qualifies compact Resource-return/attempt interactions; larger borrowed-closure native builds remain unqualified. 2,370 tests / 109 files pass serially; the 2,193-member round-29 archive is reused, not repacked or released.

  2. Accepted

    Twenty-four rounds of twenty cases

    From 2026-10-06 to 2026-10-18, 480 new semantic cases were accepted: 240 run on all three hosts, 212 are composition results and 28 are input diagnostics. Primary focus totals are C++ 192, Rust 192 and EML-P/Python 96. Every executable case passed its actual declared-target qualification before admission, including both Rust builds. A case counts once, not once per host.

  3. Held at 480

    Complete host/core capabilities before the remaining 520

    Production is deliberately paused during functional completion. Reference graphs, shared ownership, ABI/libm and wider systems integration remain open. New typed-core or reachability evidence does not repair a historical timeout or resume corpus admission automatically.

  4. Later

    Project demonstrations and wider integration

    Formal post-corpus demonstrations follow the thousand-case milestone. Broader hosts, systems integration and AI-driven language iteration need their own evidence.

Two readers

For people. Explicit for agents.

Read the method, engineering scope and limitations as plain text or structured data. These documents do not expose a public EML-U execution API or grant automatic acceptance authority.

ΣEML 2026

Efficient New Language — a high-density semantic overlay for humans and AI agents.

This site’s demos run on the real EML toolchain, in your browser.

© 2026 EveMissLab (一言諾科技有限公司) / Neo.K. All rights reserved.