What the Type Annotations Proposal Is
You'll learn: What TC39's type annotations proposal means for JavaScript's future and how it could change the relationship between TypeScript and JavaScript.
The Core Idea
The Type Annotations Proposal is a TC39 proposal to add type syntax directly to JavaScript — but with a crucial twist: JavaScript engines would completely ignore the types at runtime.
Think of it like comments that look like types:
// This would be valid JavaScript under the proposal
function add(x: number, y: number): number {
return x + y;
}
// The engine sees it like this:
function add(x, y) {
return x + y;
}
The types are there for tools (like TypeScript, Flow, or IDEs) to read, but they're effectively invisible to the JavaScript runtime.
Why This Matters
Today, you cannot run TypeScript code directly in browsers or Node.js — you must compile it to JavaScript first. The proposal would allow developers to write type-annotated code that runs natively, no build step required for the types themselves.
However, TypeScript's type checking would still happen outside the runtime. The engine doesn't validate types — it just doesn't crash when it sees them.
The Philosophy
This proposal embraces the idea that types are a developer-time concern, not a runtime concern. JavaScript would gain syntax space for types, but no type-checking semantics. That checking remains the job of external tools.
It's not "adding TypeScript to JavaScript" — it's "making JavaScript syntax compatible with type annotations that engines ignore."
Key Takeaway: The TC39 type annotations proposal would let JavaScript engines parse and ignore type syntax at runtime, enabling type-annotated code to run directly without compilation while leaving type checking to external tools.