Skip to content
anzellaiPublic

About

Sky — an Elm-inspired language that compiles to Go. Hindley-Milner types, server-driven UI (Sky.Live), single binary output.

Topics

Resources

Contributing

Security policy

Stars

443 stars

Watchers

3 watching

Forks

Latest commit

 

History

5,161 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Sky

Elm's safety. Go's reach. One binary for the whole stack.

Website · Tour · Docs · API · Examples · Changelog

  • If it compiles, it works. No nulls, no exceptions, exhaustive case, and every effect is a typed Task. sky check runs go build on the output, so a shape mismatch fails at check time, not in production.
  • One language, every shape. The same init / update / view runs as a server-driven web app, a wasm client, a terminal UI, a CLI, or a desktop and mobile app. You pick with --target.
  • Batteries, not dependencies. Database, auth, durable workflows, AI agents, Excel and Word files, and any Go package through sky add. It all compiles to one binary.

Install

You need Go 1.25 or later on your PATH, because Sky compiles to Go.

curl -fsSL https://raw.githubusercontent.com/anzellai/sky/main/install.sh | sh
sky init hello && cd hello
sky run src/Main.sky

macOS and Linux. Windows through WSL. sky upgrade keeps it current and shows the migration notes for each release.

Showing Sky to your team? examples/77-demo-expenses has a 15-minute talk, slides and a live demo script.

Using an AI coding agent? Every sky init project ships AGENTS.md and CLAUDE.md. Point your agent at them and ask for the app you want. sky doc <Module> gives it exact signatures, and sky check --format json gives it machine-readable errors.

Where are you coming from?

Why Sky Start here
Elm or Haskell Elm syntax and The Elm Architecture, now on the server, in the terminal and on the desktop. Effects are typed Tasks, not ports. Coming from another language
Go Typed Go comes out. sky add turns any Go module into typed Sky bindings, with no glue code to write. A Go error, nil or panic arrives as an Err. Go interop
Node, Python or Java No node_modules, no virtualenv, no JVM. One binary to copy to a server. Errors are values, so a case you forgot fails the build, not a request. Your first web app
AI-assisted coding Strict types catch what the model gets wrong. The stdlib has providers, durable agents, a policy firewall, evals, training and serving. AI tooling · Std.Ai

Show me

A full-stack todo app with a database, in one file

No JavaScript, no ORM, no SQL. One Codec drives the table, the reads and the writes. update runs on the server, and the page updates over one SSE connection.

todos : Store Todo
todos =
    Store.fromCodec "todos" (Codec.auto { id = 0, title = "" })
        |> Store.serial "id"


addTodo : Db -> String -> Task Error (List Todo)
addTodo db title =
    Store.insert db todos { id = 0, title = title }
        |> Task.andThen (\_ -> Store.all db todos)


update : Db -> Msg -> Model -> ( Model, Cmd Msg )
update db msg model =
    case msg of

        Draft text ->
            ( { model | draft = text }, Cmd.none )

        Add ->
            ( { model | draft = "" }
            , Cmd.perform (addTodo db model.draft) Loaded
            )

        Loaded (Ok rows) ->
            ( { model | todos = rows, problem = "" }, Cmd.none )

        Loaded (Err e) ->
            ( { model | problem = errorToString e }, Cmd.none )

The whole program, with its view and main, is in docs/showcase.md. It runs on SQLite. Change one line and it runs on PostgreSQL.

Any Go package, typed

sky add github.com/google/uuid
module Main exposing (main)

import Sky.Core.Prelude exposing (..)
import Sky.Core.Result as Result
import Std.Log exposing (println)
import Github.Com.Google.Uuid as Uuid


main =
    case Uuid.newString () of

        Ok uuid ->
            println ("Generated UUID: " ++ uuid)

        Err e ->
            println ("Failed to generate UUID: " ++ errorToString e)

This is examples/03-tea-external. Sky reads the Go package and writes the bindings. A Go (T, error) becomes Result Error T, and a nil or a panic becomes an Err, never a crash. The Stripe SDK (about 76,000 symbols) builds this way in examples/13-skyshop.

A durable AI agent that the model cannot overrule

firewall : Policy.Action -> Policy.Decision
firewall act =
    Policy.requireApprovalAbove Policy.Low act


replyBody : Ctx -> Ticket -> Task Error String
replyBody ctx ticket =
    Durable.step
        ctx
        chatCodec
        "draft"
        (Provider.chat
            provider
            [ Provider.system "Draft a short, kind reply."
            , Provider.user ticket.text
            ])
        |> Task.andThen
               (\draft ->
                   Durable.step
                       ctx
                       Codec.string
                       "send"
                       (send ticket draft.content))


send : Ticket -> String -> Task Error String
send ticket reply =
    Policy.gate
        firewall
        (Policy.action "email.send" ticket.customer Policy.Low)
        (deliver ticket reply)
        |> Task.map outcome

The model only proposes an action. Your pure firewall decides, and an action above Low risk waits for a human. Each Durable.step is journalled, so a crash resumes the run and never pays for the same model call twice. The whole program is in docs/showcase.md, and a full Slack bot is examples/66-slack-agent.

One source, many targets

sky build src/Main.sky                          # web app, server-driven (Sky.Live)
sky build --target web:app src/Main.sky         # client-side wasm (Sky.Spa)
sky build --target terminal:tui src/Main.sky    # full-screen terminal UI
sky build --target desktop src/Main.sky         # native desktop window (macOS)
sky build --target mobile:ios src/Main.sky      # iOS app (needs Xcode)

The same view : Model -> Element Msg paints to the DOM, to terminal cells and to a native web view.

What you get

  • Safety. Hindley-Milner inference, exhaustive pattern matching, Result and Maybe instead of null, and typed Secret values that redact themselves in every log.
  • App shapes. One Std.App entry point for a server-driven web UI, a wasm client for web, desktop, iOS and Android, a terminal UI and a CLI. Sky.Http.Server for HTTP and JSON APIs. Std.App
  • UI updates. SPA updates reuse unchanged immutable data. Typed navigation commands scroll after rendering, including server answers. Post-render scrolling
  • Data. Std.Db on SQLite or PostgreSQL with the same code, one Std.Codec for JSON, XML and tables, and file-based migrations. sky build --embed puts PostgreSQL inside your binary, and an app plus its database fits in 1 GB. Std.Db · Sizing
  • Files and documents. Std.Office.Xlsx and Std.Office.Docx read and write Excel and Word files. Std.Xml and Std.Zip read hostile input safely. Std.Image and Std.Image.Canvas resize, re-encode and draw images on the server. Stdlib
  • Auth, money and crypto. Std.Auth (bcrypt, JWT, roles), Std.Money on exact decimals, and XChaCha20, Ed25519, X25519 and Noise sessions for encryption and signatures.
  • Durable workflows. Std.Durable runs multi-step processes that survive a restart. Design
  • AI. Std.Ai: swappable providers (OpenAI, any compatible endpoint, or a managed local model), durable agents, a policy firewall, cost tracing in Std.Money, datasets, evals, a model registry, LoRA training, GPU serving and on-device models. Guides
  • Tooling. sky fmt, sky test, sky fuzz, sky watch, an LSP, sky doc for the live API, and an OpenAPI spec from your source with sky doc --api openapi. CLI
  • Operations. Structured logs, Prometheus metrics, health checks, OpenTelemetry and a built-in console at /_sky/console. Observability

Real examples

There are 74 projects in examples/. Start with these:

Example What it shows
77-demo-expenses A 10-minute demo: a full-stack app with live updates, exact money and a JSON API
19-skyforum A multi-module forum on Sky.Live
13-skyshop A shop with Stripe and Firebase through sky add
60-spa-todos One app on web, desktop, iOS and Android
26-ui-showcase Every Std.Ui element
23-tui-todo A terminal todo app
65-metadata-service A stateless JSON API
66-slack-agent A durable Slack bot behind a policy firewall
72-ai-support-desk A support desk with the full AI lifecycle

Status

Status: v0.29.x, pre-1.0. A minor version can include breaking changes. Each one is listed in the CHANGELOG with a migration guide under docs/migration/, and sky upgrade shows it. See VERSIONING.md and the known limitations.

The compiler is a single Rust binary that embeds the Go runtime, the stdlib and the Sky Console. The earlier compilers are in docs/history/legacy-compilers.md.

Learn more

Contributing

Issues and pull requests are welcome. Start with CONTRIBUTING.md and the compiler architecture. To build from source: cd rust && cargo build --release -p sky.

Licence

Apache 2.0. © 2025 to 2026 Anzel Lai. See NOTICE.md for prior-art attribution. Releases up to v0.10.0 remain available under their original MIT terms.

About

Sky — an Elm-inspired language that compiles to Go. Hindley-Milner types, server-driven UI (Sky.Live), single binary output.

Topics

Resources

Contributing

Security policy

Stars

443 stars

Watchers

3 watching

Forks

Releases

Packages

Contributors

Languages