Datom.World

Yin.vm: Chinese Characters for Programming Languages

Published Nov 14, 2025

The Chinese Character Insight

There are hundreds of Chinese dialects. Many are mutually unintelligible to the point of being foreign languages to each other. A Mandarin speaker cannot understand Cantonese. A Shanghainese speaker cannot understand Hokkien. Yet all of these are considered "Chinese" for one reason: they share the same written characters.

The character 水 means "water" whether you pronounce it shuǐ (Mandarin), seoi (Cantonese), or chúi (Hokkien). The meaning is in the character, not the sound. A reader in Beijing and a reader in Hong Kong can read the same text despite speaking mutually unintelligible languages.

This reveals a profound architectural pattern: semantics unified, syntax divergent. The written form (semantics) remains constant. The spoken forms (syntax) vary wildly. The characters are the canonical representation that defines what "Chinese" is.

Historically, this extended even further. Korean, Japanese, and Vietnamese all used Chinese characters. Vietnam and Korea eventually abandoned them entirely, breaking from the family. Japan kept the characters (Kanji), but the meanings drifted over time. Individual characters often retain similar meanings, but compound words (two or more characters combined) frequently diverged. Language learners call these "false friends". The same character sequence means one thing in Chinese and something subtly or completely different in Japanese. This semantic drift means Japanese cannot be called "Chinese" despite sharing many of the same character forms. Semantic preservation requires more than just static definitions. It requires ongoing alignment.

The Programming Language Problem

Programming languages have the same problem, but worse. Python and C++ are mutually unintelligible, not just in their syntax (surface form), but in their runtime representation (semantic layer). There is no shared semantic foundation at all. You cannot move code between them without losing meaning.

Unlike Chinese dialects which share characters but vary in pronunciation, programming languages vary in both syntax and semantics. It's as if every programming language invented its own character set from scratch.

The JVM tried to solve this with bytecode: compile Java, Scala, and Kotlin to the same JVM bytecode. But this is surjective compression. Many languages collapse into one bytecode, and you lose the original semantics. You cannot perfectly reconstruct the "why" from the bytecode alone. It's like trying to unify languages by erasing their differences, not by finding common ground.

What if we applied the Chinese character pattern instead? What if we gave programming languages a shared semantic layer while letting their syntax vary?

Yin.vm's Universal Semantic AST is this shared semantic layer.

How It Works: The Universal AST

The Universal AST becomes the "character set" for programming. Just as the meaning of 水 must be preserved across all Chinese dialects, the meaning of every AST node must be preserved across all languages in the family.

The critical challenge: preventing semantic drift. Just as Japanese Kanji developed "false friends" through compound words diverging in meaning, programming languages could develop their own "false friends" if AST node compositions took on different meanings.

This means a map operation composed with a filter operation must mean exactly the same thing in Python, C++, and Clojure. Individual AST nodes preserve semantics at the atomic level. Compositions preserve semantics at the structural level. The system must actively prevent divergence.

Just as 水 can be pronounced shuǐ (Mandarin), seoi (Cantonese), or chúi (Hokkien), the same AST node can be rendered as:

  • list(map(lambda x: x * 2, values)) in Python
  • [x * 2 for x in values] in Python (alternate syntax)
  • values.stream().map(x -> x * 2).toList() in Java
  • (map #(* 2 %) values) in Clojure

The semantics are identical. Only the syntax changes. The languages remain mutually unintelligible at the source level, but unified at the semantic level.

Bijective Translation: Perfect Round-Trips

Chinese characters enable meaning-preserving translation. You can go from a character to its Mandarin pronunciation, then to its Cantonese pronunciation, and back to the character without losing the semantic content. The character is the canonical form that preserves meaning bidirectionally.

Yin.vm accomplishes the same:

  • Python code → Universal AST → C++ code (perfect round-trip)
  • C++ code → Universal AST → Clojure code (semantics preserved)
  • Any language → AST → Any language (bijective)

This is fundamentally different from the JVM's surjective compression. The AST is canonical, not the bytecode. You can perfectly reconstruct the "why" and "how," not just the "what."

Unifying Static and Dynamic: Types as Certainty

Chinese dialects vary in tone systems. Mandarin has 4 tones, Cantonese has 6-9, some Wu dialects have 7-8. The written characters accommodate all of them. Tones are metadata on the pronunciation, not changes to the semantic core.

The same principle applies to type systems. The industry treats static vs dynamic typing as a binary choice: either types are known at compile-time (C++, Java) or discovered at runtime (Python, JavaScript). But this is a false dichotomy.

Type information exists on a continuum of certainty. Certainty measures how confident we are that a value has a particular type:

High Certainty ←―――――――――――――――――――→ Low Certainty

Declared    →  Inferred  →  Runtime     →  Unknown
(programmer)   (analysis)   (discovered)   (no idea)
:static        :static      :dynamic       :unknown

Examples:

  • High certainty: def add(x: int) → int — programmer declared it, compiler enforces it
  • Medium certainty: result = [] — type inferred from usage through analysis
  • Low certainty: data = json.loads(input) — type only known when code runs
  • No certainty: eval(user_input) — could be anything

Yin.vm unifies static and dynamic types by representing certainty as metadata on AST nodes. A map operation has the same semantics whether it's in Python (low certainty) or C++ (high certainty). The certainty level is a property of the node, not a fundamental change to its meaning.

Here's the key: when the AST is canonical code, types become metadata. The AST node represents the semantic operation. The type information annotates how certain we are about it. This blurs the line between static and dynamic—they're not different kinds of code, just different levels of certainty about the same code.

This reveals that the line between static and dynamic was always artificial. Types are facts about certainty, not categories of languages.

For type-erasing languages (C++, Rust, Java), Yin.vm preserves the Universal AST as metadata alongside the optimized bytecode. You get full-speed execution plus full introspection. The semantic layer persists even when the runtime erases types for performance. This isn't a compromise. It's architectural correctness.

Queryable Semantics: Radicals and Datoms

Chinese characters aren't just for translation. They enable semantic reasoning. You can ask "find all characters with the water radical (氵)" and discover 河 (river), 海 (sea), 湖 (lake). Characters are built from radicals (semantic components), and the structure is queryable.

Yin.vm builds the Universal AST from datoms (immutable, atomic facts). Just as radicals are the building blocks of characters, datoms are the building blocks of the AST:

  • The AST structure is datoms describing nodes and relationships
  • Type information is datoms annotating certainty metadata
  • A continuation is a transaction of datoms capturing execution state
  • Transformations between languages are datom transactions with lineage preserved

The entire system is a Datalog database. You can query across languages, across time, across execution states:

  • "Show me all functions that touch network input and access the file system"
  • "Trace the full lineage of this PaymentInfo object across all languages in the system"
  • "Find code paths where dynamically-typed data enters a statically-typed function without validation"

This enables semantic firewalls, live program analysis, and self-healing codebases that detect anti-patterns at runtime.

Mobile Code: Meaning That Travels

Imagine if written Chinese could travel as semantic units. A message written in Beijing arrives in Hong Kong. The reader there can understand it immediately (same characters), or even speak it aloud in Cantonese while preserving the original meaning.

Yin.vm enables this for code. Programs can:

  • Pause execution on one machine (Python)
  • Serialize their complete state as datom transactions
  • Travel across the network
  • Resume execution on a different machine in a different language (C++)
  • Maintain perfect semantic fidelity throughout

Because continuations are datom transactions and the AST is canonical, code becomes truly portable. Not just the instructions, but the entire computational state and meaning.

Related Work

The closest existing projects are:

  • GraalVM/Truffle (polyglot runtime with a universal AST, but limited runtime introspection)
  • CodeQL/Glean (queryable AST databases using Datalog, but for static analysis only)
  • DynQ (research project by Filippo Schiavio implementing language-agnostic queries in GraalVM)

Yin.vm combines the runtime execution of GraalVM with the queryability of CodeQL and extends both with mobile agent capabilities, cryptographic identity, and an immutable fact-based architecture.

Conclusion: What Makes a Language Family

The lesson from Chinese is profound: identity comes from shared semantics, not shared syntax.

Hundreds of mutually unintelligible spoken dialects are all "Chinese" because they share the written characters with preserved meanings. Korean and Vietnamese were once part of this family. They diverged when they abandoned the characters. Japan kept the character forms (Kanji) but allowed semantic drift, especially in compound words. These "false friends" broke the semantic unity. Japan is no longer "Chinese."

The lesson: form alone is not enough. The canonical semantic layer must preserve meaning, especially at the compositional level. Individual elements might align, but if their combinations drift apart, the family fractures. The surface syntax is free to vary wildly, but the semantics must remain identical at all levels.

Yin.vm applies this principle to programming:

  • Python, C++, Java, and Clojure become a semantic family through the Universal AST
  • Static and dynamic types unify as facts about certainty, not language categories
  • Languages remain syntactically distinct but semantically unified at all compositional levels
  • Code can migrate between "dialects" (languages) while preserving complete meaning
  • New languages can join the family by adopting the canonical AST with strictly preserved semantics
  • Languages that allow semantic drift (like Kanji "false friends") break from the family
  • The system must prevent divergence, not just define initial equivalence

This is not just a better VM. It's a different architectural philosophy. When the AST is canonical and built from datoms, we create a programming language family unified by semantics, not syntax.

Chinese characters unified hundreds of spoken languages across continents and millennia. The Universal Semantic AST can do the same for programming languages.

Learn more: