Everything is a scope.

No GC · No borrow checker · Memory safe

No GC Scope = Lifetime Memory Safe LLVM Native

Software's most expensive wound is memory safety — roughly 70% of serious security vulnerabilities are memory errors. Rust closes that wound, but the price is the borrow checker's learning wall. MELP aims to close the same wound without that wall: the programmer annotates nothing — no &, no lifetimes, no unsafe. Scope is lifetime.

Evidence status, honestly: The mechanism works and is valgrind-verified. The two most serious bugs of that same week were of exactly this class — both were caught and closed by our test corpus, which is evidence both of how hard the wound is and of the fact that our mechanism sees it. Real-world-scale proof is the next job. Today we say aims to; when the proof is complete we will say does.

MELP proposes a unified Scope-Oriented Programming model where scope is the primary lifetime abstraction governing memory, resources, concurrency, state, and UI.

Scope is the universal lifetime unit.

Comparison

Why MELP?

Speed, safety and simplicity — all three at once.

Language	Speed	Memory Safety	Simplicity
C / C++	✅	❌	❌
Java / Python	❌ (GC)	✅	✅
Rust	✅	✅	❌
MELP	✅	✅	✅

"MELP aims to close memory safety through the scope model — requiring neither a garbage collector nor a borrow checker."

Honest Map

What We Solved, What We Haven't

Software's chronic wounds and MELP's answers today — gaps included.

Wound	MELP's answer	Status
Memory safety	Scope/custody: no GC, no annotations, automatic	✅
Institutional memory loss	`debug` block — a letter to the future that stops when its condition fires	✅
Silent wrongness	Nothing is left to runtime guesswork; error codes + exit discipline	✅
State complexity	State has no separate life — data lives its scope's lifetime	🔬
Concurrency — data races cannot be constructed	Scope isolation: structurally impossible, not merely discouraged	✅
Concurrency — "free parallelism"	Design intent, not a measured fact: no legitimate gate yet, runtime is single-flow	⏸️
Incident response	`freeze` = natural quarantine + preserved evidence	✅/🔬
Reproducibility / bit rot	Self-hosting golden chain; every change proves itself	✅
Supply chain — package-ecosystem class (left-pad, log4shell)	Structurally absent: there is no third-party package ecosystem, so transitive-dependency risk cannot form	✅
Supply chain — build-chain class (xz)	We have no answer — LLVM/clang, libgmp and libc are all upstream of every binary	❌
Supply chain — the seed (Trusting Trust)	Route drawn, not yet walked: the IR we emit is text, so an injection must show there	🔬
Toolchain comfort	Our soft underbelly — editor, debugger and package tooling are young	❌

✅ proven · 🔬 partial · ⏸️ design intent · ❌ not yet — source: MELP_KANONİK/OZGUN_OZELLIKLER.md

Features

What Does MELP Offer?

✉️

debug — A Letter to the Future

Today's architect leaves the next generation a running, conditional note. A comment may go unread; a debug block runs — when the world outgrows the assumption, the program stops and reads the letter out. Zero cost in release builds.

🧊

Freeze — Suspend, Don't Kill 🔬

A running scope can be frozen from the outside together with its subtree: state is fully preserved, sibling scopes keep flowing. A language-level quarantine answer to the "kill it and lose the evidence" dilemma of incident response. Works from the host API; language syntax integration is in progress.

⚡

LLVM Native Binary

No GC, no overhead. MELP emits LLVM IR directly and runs in the same league as C — predictable, measurable performance. Not a syntax experiment, but a compiler that compiles its own source.

See All 14 Distinctive Features →

Source: MELP_KANONİK/OZGUN_OZELLIKLER.md — ✅ working, 🔬 partial, ❌ not yet (with honesty lines)

Syntax

Every Structure Opens With an ID Card and Closes With a Signature

Three types, no declaration ceremony — the declaration is the type.

Hello World

numeric function main()
    println("Hello World!")
    return 0
end function

A function

numeric function add(numeric a; numeric b)
    return a + b
end function

numeric function main()
    numeric result = add(3; 5)
    println(result)
    return 0
end function

A letter to the future

debug
    if member.count > 10000 then stop
    -- past 10 000 members this design needs
    -- a real database; revisit before scaling
end debug

A scope is called, not instantiated

scope counter
    numeric n = 0
end scope

-- ';' separates arguments, because ','
-- is the decimal mark:
numeric pi = 3,14

Decimal comma is a first-class decision, not a locale setting — which is why ; separates arguments. See the language reference.

Performance

C League, No Surprises

19 July 2026 · MELP v1.0 · Intel Core i7-10750H · Linux x86-64

What we claim, and what we don't. MELP does not claim to be "faster than C". MELP is compiled with LLVM/clang; the fairest comparison is C compiled with the same backend (clang -O2). Every measurement is 5 runs, best value taken.

Run time (ms) — lower is better

fib(40) recursive Fibonacci — cannot be folded away, real CPU work

C (clang -O2)

232 ms

MELP

234 ms

Rust (-O)

277 ms

429 ms

MELP and C are practically identical (234 ≈ 232) — with the same LLVM backend, the language layer introduces no measurable loss.

string concat 100K 100 000 concatenations — complexity-class verification

C / Rust

~1 ms

MELP

9 ms

378 ms

Same complexity class — O(n). C and Rust lead on the constant factor (~9×).

Ready?

Try it in the browser — no installation required.

Open the Web IDE Get the VS Code Extension Documentation