Introducing Havran

Today we're sharing Havran — a programming language that gives you the clarity of a modern, expressive language with the reach of the entire TypeScript ecosystem. You write expressive, type-safe code, and Havran emits the smallest, most interoperable JavaScript a compiler can produce.

Why another language?

TypeScript made JavaScript bearable, but it inherited JavaScript's sharp edges: truthy coercion, === vs == , NaN , and a nullability story bolted on after the fact. Havran removes those footguns at the language level while staying 100% compatible with everything you already use.

• Comparing two different types is a compile error, not a silent surprise.
• == means value equality; there is no === to remember.
• Nullability has a single, clear model that lowers to plain undefined .

A taste

Here's a data class and a null-safe greeting, with the TypeScript Havran generates:

data class User(val name: String, val email: String?)

fun greet(u: User): String {
  val inbox = u.email ?: "no email on file"
  return "Hi ${u.name} — ${inbox}"
}

interface User {
  readonly name: string
  readonly email: string | undefined
}

function greet(u: User): string {
  const inbox = u.email ?? "no email on file"
  return `Hi ${u.name} — ${inbox}`
}

Notice there's no runtime class, no helper imports — just the interface and a plain function. That's the whole point: you ship bytes, not boilerplate.

Havran should feel like a better TypeScript, not a heavier one.

What's next

We're building in the open. Follow along, try the playground, and tell us what you'd want to build with it. This is just the beginning.