Base camp · 0 m

Most languages were never built to be learned. This one was.

Ascent is a programming language and a built-in environment, designed for people who have never written a line of code. No terminal. No setup. No decade of legacy baggage to memorize first.

Try it in your browser Read the reasoning

Runs in the browser. Nothing to install.

The climb begins · 400 m

Do we really need a hundredth programming language?

Fair question. The honest answer: beginners get tripped up by two very different things, and most setups only ever fix one of them, if any.

Problem one

The environment

Before you write anything interesting, you're wrestling with a terminal, a file system, and an IDE full of buttons. None of that is programming. Ascent gives you a text box and a Run button. That's the whole ceremony.

Problem two

The language

Most languages were built to be fast and practical for professionals, with decades of quirks bolted on. Ascent is shaped by one question instead: can a complete beginner understand this?

Halfway up · 1200 m

Here's what Ascent looks like.

Have a taste. Hit Run and watch it work, the same loop you'll live in while you learn.

first-program.asc

# No HTML, no input library. Ascent gathers the inputs, then runs your code.args (name: String, score: Int);type Grade = Honors | Pass | Fail;fix grade =    if (score >= 90) { Honors }    else if (score >= 50) { Pass }    else { Fail };fix note = match (grade) {    Honors -> "Outstanding work!";    Pass   -> "Nicely done!";    Fail   -> "Keep going, you'll get there!";};"Hi ${name}, you scored ${score}. ${note}"# The program returns the result of the last expression

Write a few lines, click Run, see the result. That's the whole ceremony.

Ridge camp · 1800 m

Three features worth a closer look.

Each one reflects a deliberate choice about how programs should behave — and how a learner should be able to read them.

Error handling

Failures are values — `try` propagates them

Expected failures live in the return type, not as exceptions that can tunnel invisibly up the stack. try unwraps the good case and continues; on failure it early-returns from the enclosing function — every propagation point visible in source, every signature honest. Adapting a foreign error is an explicit else clause, never silent.

load-number.asc

type AppError = Read{ cause: IOError } | Parse{ cause: ParseError };fn loadNumber(path: String) -> Int orelse AppError {    fix text = try readFile(path) else e -> AppError.Read{ cause: e };    fix n    = try parseInt(text) else e -> AppError.Parse{ cause: e };    Ok{ value: n }}

Concurrency

Structured concurrency

Spawned tasks can only live inside a concurrent {} scope, which waits for all of them before exiting — and cancels the rest if any one fails. Orphaned tasks, lost errors, and fire-and-forget are structurally impossible: concurrency becomes as nested and composable as a block of code.

load-profile.asc

fn loadProfile(id: Int) -> Profile orelse FetchError {    try concurrent {        fix user  = spawn fetchUser(id);        fix posts = spawn fetchPosts(id);    }  # both finish, or the scope cancels the rest    Profile{ user: user, posts: posts }}

Data model

Methods on types

Behavior lives in a methods block, declared once alongside the type's own fields. The receiver self is explicit — a method is transparently a function whose first argument is the value it belongs to. No inheritance, no hidden dispatch chain.

player.asc

type Player = {    name:  String,    score: Int,} methods {    rank:     fn(self) -> String =>        if (self.score >= 100) { "pro" } else { "rookie" },    describe: fn(self) -> String =>        "${self.name} is a ${self.rank()}",};fix ada = Player{ name: "Ada", score: 120 };print(ada.describe());   # "Ada is a pro"

Above the tree line · 2400 m

The rules everything else answers to.

Every decision in the language traces back to these six.

Clear, honest semantics

Every construct means one thing, and it means it out loud. Nothing happens behind your back.

Remove the trap, don't label it

A dangerous thing is made impossible or impossible to ignore. A footnote nobody reads isn't a safety feature.

One obvious way

Generally one way to do each thing, so nobody memorizes five spellings of the same idea before writing a line.

A stepping stone, not a destination

Built to transfer to many languages, not to imitate one. The skills you build here carry over.

Errors are part of the lesson

When something breaks, the message is written for a beginner, in plain language, pointing at what they wrote.

Power is opt-in, and late

The advanced features arrive later, as their own chapter, once there's a reason to care about them.

Summit

Ready to write your first program?

Open the editor and run a line of Ascent. No account, no install, no terminal in sight.

Open the editor