module Main exposing (main)

import Std.Ui as Ui exposing (Element)
import Std.Ui.Font as Font
import Std.Live exposing (app, config, route)

type alias Model = { count : Int }
type Msg = Increment | Decrement | Reset

init _ = ({ count = 0 }, Cmd.none)

update msg model =
    case msg of
        Increment -> ({ model | count = model.count + 1 }, Cmd.none)
        Decrement -> ({ model | count = model.count - 1 }, Cmd.none)
        Reset     -> ({ model | count = 0 }, Cmd.none)

view : Model -> Element Msg
view model =
    Ui.column [ Ui.spacing 16, Ui.padding 24 ]
        [ Ui.el [ Font.size 48, Font.bold ]
            (Ui.text (String.fromInt model.count))
        , Ui.row [ Ui.spacing 8 ]
            [ Ui.button [] { onPress = Just Decrement, label = Ui.text "-" }
            , Ui.button [] { onPress = Just Reset,     label = Ui.text "reset" }
            , Ui.button [] { onPress = Just Increment, label = Ui.text "+" }
            ]
        ]

main = app (config
    { init = init, update = update
    , view = \m -> Ui.layout [] (view m)
    , subscriptions = \_ -> Sub.none
    , routes = [ route "/" () ], notFound = () })

Sky.Live — server-driven web UI with DOM diffing over SSE, persistent sessions, async Cmd.perform

Sky.Tui — same Element tree rendered to ANSI cells in a terminal (logical-pixel canvas, mouse + scroll)

Sky.Cli — line-oriented stdin event loop for non-interactive shells

Sky.Webview — native desktop window on the system webview, sharing Sky.Live's renderer (macOS today)

import Std.Live exposing (app, config, route)

main = app (config
    { init = init, update = update
    , view = view, subscriptions = subs
    , routes = [ route "/" () ]
    , notFound = () })

HTTP + SSE wire. Persistent sessions across deploys (memory / SQLite / Redis / Postgres / Firestore). Async Cmd.perform goroutines. Input-authority protocol preserves typed input across re-renders.

import Std.Tui as Tui

main = Tui.app (Tui.config
    { init = init, update = update
    , view = view, subscriptions = subs
    } |> Tui.withOnKey KeyPressed)

Render Element trees to ANSI cells. Logical-pixel canvas (1280×720 default), mouse left-press + scroll wheel, wide chars + emoji via grapheme-cluster width. Diff renderer; no flicker.

import Std.Cli as Cli

main = Cli.program (Cli.config
    { init = init, update = update
    , view = view, subscriptions = subs
    } |> Cli.withOnLine LineRead)

Line-oriented event loop for non-TTY shells. Same TEA shape; view returns a string each turn. Echo-suppressed password reads via Cli.readPassword for auth flows.

import Std.Webview as Webview

main =
    Webview.app
        { init = init, update = update
        , view = view, subscriptions = subs
        , window = Webview.defaultWindow
            |> Webview.withTitle "Counter"
        }

Native desktop window on the system webview, reusing Sky.Live's renderer and VNode diff so the same Std.Ui tree renders identically. macOS is smoke-validated today; Windows and Linux build but are untested. Requires cgo.

Hindley-Milner type inference, exhaustive pattern matching, no null, no exceptions. Undefined names caught at compile time with line:col positions.

Compiles to a native Go binary. Your fullstack app — API, database, server-rendered UI — ships as one file. The compiler itself is also a single binary (Rust).

Std.Ui is a typed no-CSS layout DSL. The same view renders to a web app (Sky.Live), a terminal UI (Sky.Tui), a stdin loop (Sky.Cli), or a desktop window (Sky.Webview). One model, four runtimes.

Import any Go package with auto-generated type-safe bindings. Stripe, Firebase, SQLite, PostgreSQL — all with panic recovery and nil safety.

The compiler propagates HM types into lambda bodies, record fields, list elements, and call args — so callback fields keep their typed callee param (no func(any) any fallback). Parametric records compile to Go generics.

Built-in database (Std.Db), authentication (Std.Auth), JSON encode/decode with pipeline, HTTP server, formatter, LSP with hover + diagnostics.