Introducing MetaScript

Millions of TypeScript Developers Are Ready for Systems Programming. The Compiler Just Hasn't Caught Up.

Every time tsc runs, something quiet happens: all your types — every generic constraint, every interface, every union you carefully crafted — get thrown away.

The CPU never sees them. The runtime never sees them. The JavaScript that comes out the other side is completely blind to everything you just expressed.

I couldn't stop thinking about that.

By 2026, TypeScript is the default. Millions of developers spent the last decade absorbing concepts that took Microsoft, the C# team, and decades of language research to refine — generics, structural types, discriminated unions, interface contracts. The same constructs Rust, Haskell, and Swift use to write safe, native code.

The fluency is there. Across millions of people.

And then we throw it all away at compile time.

This isn't a new observation. People have noticed before. I went looking for a real solution — something that actually used those types to drive native code generation — and found graveyards. Research projects abandoned. Tools that still kept a runtime lurking somewhere underneath. Nothing that closed the gap.

There's usually a reason builders avoid "obvious" ideas — they're obvious because someone smarter already proved they don't work.

But I couldn't shake it.

Testing the hypothesis

The type system is already there. The fluency is already there. If you actually closed the gap — strip the runtime out, let the types drive the codegen — the result is insane, native binaries from TypeScript syntax. Real parallelism. Order-of-magnitude faster than Node.

It seemed too clean. So I decided to find out if it was actually possible.

The first time the compiler emitted a native binary that ran a real TypeScript program — and the benchmark came back ~10x faster than Node — I sat there for a minute. Then I ran it again. Then I ran it on different workloads. Same result every time.

The hypothesis wasn't too clean. It was just waiting to be tested.

That became MetaScript.

A TypeScript superset that compiles to native.

When you target native, there's no runtime. No Node. No V8. Just a binary running on bare metal — but the source still looks like the TypeScript you wrote yesterday.

Out of the lab

I've been quietly porting Under Realm — a live Trading Card Game — from its original TypeScript codebase over to MetaScript, piece by piece. What I've ported so far runs stable, with strong performance. The point isn't the speed — it's that there's nothing to rewrite. The code is still TypeScript, and it just works in every case the compiler supports.

There are still missing pieces before MetaScript can replace TypeScript entirely in that codebase. But the road ahead is clear.

There's still a lot to build at the language level too. The standard library is thin. Error messages need work. The package registry is almost empty now. These aren't surprises — they're what comes next when a proof of concept grows into a real tool.

But what's been proven matters: the hard part of systems programming was never the syntax. It was the knowledge — the type discipline, the precision about what a value is and isn't. TypeScript spent a decade teaching that to the world.

Millions of developers are already there.

We just need a compiler that doesn't throw it away.

Out into the open

I've been heads-down on this for a while, mostly alone. Today felt like the right day to put it out into the open — not as a finished product, but as something I want to keep building with people who feel the same itch.

If you also believe TypeScript is worth compiling to native, welcome to the tribe. Let's build this together and make something really cool — the tribe hangs out in Discord.

The compiler source opens July 1, 2026 — I want it to be in a state worth contributing to before then. The compiler itself is already in beta, though — install it and write your first native TypeScript program tonight:

curl -fsSL https://metascriptlang.org/install.sh | sh

From there, the Quick Start gets you running. Editor plugins are ready for JetBrains, VS Code, Neovim, and Zed. And finally, ask the AI on Learn about anything else.

Happy hacking!