Myna (myna-lang)

Myna is an ultra-dense, symbol-based, AI-native programming language designed to cut LLM token and character usage by ~50% while transpiling 1:1 to Python 3.12+ and to a bounded JavaScript (ES2024+) target—and decompiling existing Python code back into Myna.

Why Myna?

Coding agents spend thousands of context and output tokens on repetitive syntactic boilerplate (def __init__(self, ...):, self., Optional[...], try ... except Exception as e:, quoted JSON keys, and 4-space indentation blocks).

Myna replaces verbose multi-token boilerplate with tokenizer-friendly ASCII sigils and digraphs ($$, @, ~@, =>, ??, !?, !&, $, $?) and brace-delimited blocks ({}):

• ~46%–52% fewer LLM tokens and ~48%–58% fewer characters than equivalent Python (compact and ultra-compact modes).
• Zero indentation fragility: Blocks use { ... } or =>, making partial diffs and single-line generation rock-solid for AI agents.
• Bi-directional (Python <-> Myna) & Multi-Target (Myna -> Python / JS): Compress existing Python codebases into .myna to fit twice as much code into an agent's context window, or let agents write .myna and transpile to clean Python or JavaScript.
• Agent-Ready: Ships with a compact Rosetta Stone skill (skills/myna/SKILL.md) that teaches any coding agent to read and write idiomatic Myna in one shot.

Side-by-Side Comparison

Python (21 lines, 611 chars)

from dataclasses import dataclass
import asyncio

@dataclass
class Task:
    id: int
    title: str
    priority: int = 1
    done: bool = False

    def to_dict(self) -> dict[str, object]:
        return {"id": self.id, "title": self.title, "done": self.done}

async def pending(tasks: list[Task], min_p: int = 1) -> list[dict[str, object]]:
    try:
        await asyncio.sleep(0.01)
        items = [t for t in tasks if not t.done and t.priority >= min_p]
        return [t.to_dict() for t in sorted(items, key=lambda t: -t.priority)]
    except Exception as e:
        print(f"Error: {e}")
        return []

Myna (11 lines, 299 chars — 51% smaller)

<asyncio
$$Task(id:i,title:s,priority:i=1,done:b=F){
  @to_dict->{s:A}=>{.id,.title,.done}
}
~@pending(tasks:[Task],min_p:i=1)->[{s:A}]{
  !{
    ~asyncio.sleep(0.01)
    items=[t|t<-tasks?!t.done&&t.priority>=min_p]
    ^[t.to_dict()|t<-@srt(items,key=t=>-t.priority)]
  }!!e{p(`Error: {e}`);^[]}
}

Quickstart

The CLI requires Python 3.11+ and has zero external dependencies. Generated Python targets 3.12+ when the source declares a type alias ($= emits type X = ...); other output runs on 3.11+.

# Install from PyPI
pip install myna-lang          # or: uv tool install myna-lang / pipx install myna-lang

# Install for local development (from a checkout)
pip install -e .

# Show the package and language versions
myna --version

# Create and run a script
printf 'p(`hello from {1+1}`)\n' > hello.myna
myna run hello.myna

# The remaining examples are in a checkout of the repository.
# Run a Myna script directly (via Python)
python3 -m myna run examples/demo.myna

# Run a portable Myna script via Node.js (JavaScript target)
python3 -m myna run -t js examples/cross_target.myna

# Compile Myna -> Python (.py)
python3 -m myna compile examples/rest_api.myna -o rest_api.py

# Compile Myna -> JavaScript (.js)
python3 -m myna compile -t js examples/cross_target.myna -o cross_target.js

# Bundle a multi-file program into one standalone Python file
python3 -m myna bundle src/main.myna -o app.py

# ...or into a runnable zipapp (stdlib-only, executable)
python3 -m myna bundle src/main.myna --zipapp -o app.pyz

# Compress existing Python -> Myna (.myna)
python3 -m myna decompile script.py -o script.myna

# Ultra-compact decompilation (with local variable minification)
python3 -m myna decompile -m script.py -o script.min.myna

# Compare token & character efficiency
python3 -m myna stats examples/books_api.myna

# Report declared/inferred Python & JavaScript support
python3 -m myna targets examples/demo.myna

Multi-file programs

myna run gives relative imports a package context, so a program can be split into sibling .myna files:

# main.myna
<.util:{slug}
p(slug("Hello World"))

# util.myna
@slug(text:s)->s { ^ text.lower().replace(" ", "-") }

• <.util:{slug} → util.myna beside the importing module.

• <.pkg.helper:{parse} → pkg/helper.myna; pkg may have an __init__.myna or be a plain directory (namespace package).

• <.util (no {...} list) binds the imported module object.

• Absolute imports (<json, <mypkg>alias) keep their normal Python meaning.

• Imported files are compiled on first import and cached by Python's import system.

• myna run --module-root DIR (or MYNA_MODULE_ROOT=DIR) resolves the entry file's relative imports from DIR instead of the entry's own directory. For the usual src/ + tests/ layout this removes the need for a symlink:

  python3 -m myna run --module-root . tests/run_tests.myna
  

  Modules imported from that root still resolve their own relative imports from their own directory. With a module root set, the entry's own directory is not searched, so a file beside the entry is imported by its path from the root (e.g. <.tests.harness).

• myna bundle src/main.myna -o app.py embeds the whole relative-import graph in one standalone Python file. It runs with a plain python3 and does not need myna installed; absolute imports still come from the environment.

• myna bundle src/main.myna --zipapp -o app.pyz writes a runnable, executable zipapp containing real module files (python3 app.pyz). It is reproducible: rebuilding the same sources produces identical bytes. Without -o, the archive lands next to the entry file as <name>.pyz. --module-root applies to bundling too.

• myna compile still compiles one file at a time. If you use relative imports, the emitted .py files must be placed in a matching Python package.

• For -t js, each relative import becomes a relative ES module specifier (./util.js, or ./util.mjs when the output ends in .mjs) and every top-level binding is exported. Compile the files into a mirrored tree, or let myna run -t js do it. Node treats a .js file containing import/export as CommonJS unless the project sets "type": "module", so prefer .mjs outputs or add that to the project's package.json. myna bundle remains Python-only.

JavaScript target

myna compile -t js and myna run -t js emit ES modules. JavaScript is a bounded target: Myna semantics are Python semantics, so the generator inlines __myna_* helpers for truthiness, equality, %, //, #, <-, indexing, slicing, and printing. The runtime floor is Node 20.11+ (import.meta.filename backs the @main guard).

Unsupported constructs fail with a compile-time TargetError instead of producing wrong output:

• single-file bundling for JavaScript (myna bundle is Python-only; use myna compile -t js over the tree or myna run -t js);
• star imports (<math:{*});
• multiple inheritance, class decorators, and method decorators;
• builtins with no faithful JavaScript equivalent (@open, @ord, @id, …);
• Python standard-library imports (they are not rewritten for Node).

Known representation limits: JavaScript has one number type (no int/float split or arbitrary-precision integers), tuples and lists are both arrays, dictionary keys are JavaScript property names (string-coerced), with is approximated with try/finally + .close(), keyword arguments to user functions become a trailing object, f-string format specs beyond .Nf are not translated, === maps to Object.is (so primitive identity compares by value), ordered comparisons use JavaScript coercion when operand types differ, and bitwise operators use 32-bit JavaScript semantics. @main compiles to an import.meta.filename === process.argv[1] guard (Node's __main__ equivalent), so an imported module's entry block stays dormant. myna targets reports whether a file generates for a target; the test suite also executes the Node output and runs node --check on every generated file.

Token & Character Efficiency Benchmarks

Measured by compiling each example to Python and running python3 -m myna stats on the generated file (so the Myna columns reflect the decompiler's compact and -m modes). Counts use the built-in bpe-approx estimator unless tiktoken is installed:

python3 -m myna compile examples/demo.myna -o /tmp/demo.py
python3 -m myna stats /tmp/demo.py

Running stats directly on a .myna file instead compares the generated Python against that file as written, so its Myna counts will differ from the table.

Language Cheat Sheet

See SPEC.md for the complete language specification and skills/myna/SKILL.md for the AI agent skill file.

Running Tests

python3 -m unittest discover -s tests -v

Versioning & Design Decisions

Releases follow the policy in VERSIONING.md: during 0.x, patches are correctness fixes and release hygiene, minors carry new syntax, new capabilities, or intentional behavior changes, and 1.0 is gated on a documented, executable parity matrix. The accepted decisions behind the targets are recorded in DECISIONS.md.

License

MIT