AugustUnderstanding at every resolution

This is August ​

A greeting is small enough to read in full. The same compiler that checks this code also writes its explanation and diagrams.

import Console from august.io
import Logger from logging
Greeter(resolve Logger logger) implements IGreeter:
    greet(resolve Console console, string name):
        logger.log(message="Hello, " + name + "!")
interface IGreeter:
    greet(resolve Console console, string name) uses Console.write

import Console from august.io
import Logger from logging
Greeter(resolve Logger logger) implements IGreeter {
    greet(resolve Console console, string name) {
        logger.log(message="Hello, " + name + "!")
    }
}
interface IGreeter {
    greet(resolve Console console, string name) uses Console.write
}

greet(resolve Console console, string name) returns void uses Console.write

The application resolves Greeter and calls greet(name="AugScript"). The configured logger prints:

Hello, AugScript!

The same program, at two resolutions ​

Where the greeting goes ​

flowchart TD
    n0["app"]
    n1["logging"]
    n2["Startup"]
    n0 -->|"Logger.log(message)"| n1
    n2 -->|"Greeter.greet(name)"| n0

This is the greeting project’s folder view. Startup calls the application; the application calls the logger. Each connection opens its exact inputs and call sites in the project overview.

What one operation does ​

sequenceDiagram
    participant p0 as Greeter.greet
    participant p1 as logger: Logger
    p0->>p1: log(message=”Hello, ” + name + ”!”) · interface dispatch

This is the generated sequence for Greeter.greet. It passes the greeting to the Logger contract. The application chooses ConsoleLogger in its startup specification. Interface dispatch remains visible; the diagram does not guess which instance a caller will use.

Open this operation · Follow its logger · Learn to navigate the views

Understand a large codebase without reading every file ​

The world runs on language. August makes the program explain itself at the level you need: the project, a folder, an operation, or an individual decision.

Start with the generated overview to see startup and the data that crosses folder boundaries. Open a folder to find its public surface. Follow a sequence to see when an operation calls its dependencies, returns, fails, or cleans up. Read the neighboring specification for the full behavior in sentences. The exact call contract and source stay one link away.

This is the normal reading path for both developers and coding agents. It lets you review a change, locate a dependency, or understand a failure without opening every implementation. When you need to change an expression, the explanation links to that part of the source.

All these views come from the checked program. The explanation describes what the implementation does; your requirements and tests establish whether that behavior is right. Native implementations and runtime interface choices remain visible boundaries.

Try the greeting project's overview, then explore the larger login application. Understand a project shows how to move between the views.

Native performance, compared with C ​

A separate million-greeting program writes 1,000,000 greetings: 20 MB of UTF-8 text. The output below is abbreviated:

Hello, August! 👋
Hello, August! 👋
… 1,000,000 lines in total

The equivalent C program performs the same work and flushes each line, as August does:

#include <stdint.h>
#include <stdio.h>

int main(void) {
    for (int64_t greetings = 0; greetings < 1000000; ++greetings) {
        fputs("Hello, August! 👋\n", stdout);
        fflush(stdout);
    }
    return 0;
}

August 1.0.0 on Apple M5 takes 1023.47 ms and C takes 977.46 ms (median of 30 runs after 3 warmups). Both programs use release optimization, write to a file, and flush each line. Every run must produce the same 20 MB output. The times include process startup and file I/O.

The performance reports compare more programs: integer loops, collections, JSON, and HTTP. Results vary by workload; use the sources to build a comparison for your own application.

Read the source and spec · Inspect every sample and the environment

Try August ​

August 1.0 is available now. You need Node.js 24 and macOS 14+ on Apple Silicon or GNU/Linux x86-64/ARM64 with glibc 2.36+. August obtains its native compiler and libraries automatically; you do not install LLVM or Clang.

Start with your first project, then follow the August book. The project gallery shows formatted code beside its actual compiled spec. Use the task guides for packages, HTTP, tests, and deployment.

The August 1.x compatibility contract covers source behavior, CLI and package formats, and the public native ABI. Read supported platforms, production readiness, and the roadmap before choosing it for a deployment. Source and issues are on GitHub.