module Main exposing (main)

import Std.App as App
import Std.Ui as Ui exposing (Element)
import Std.Ui.Font as Font

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 "+" }
            ]
        ]

app =
    App.app
        { init = init, update = update
        , view = view, subscriptions = \_ -> Sub.none
        }
        |> App.withNotFound ()

-- web is the default target; sky build --target terminal:tui,
-- terminal:cli, desktop or web:app retargets this same app.
main = App.run app

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

Sky.Spa — the same loop compiled to wasm on the client — web, desktop, iOS, Android from one source (experimental)

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.App as App

app =
    App.app
        { init = init, update = update
        , view = view, subscriptions = subs
        }
        |> App.withNotFound ()

main = App.run app

$ sky build            -- web (default)

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.

-- the very same `app` — no new entry point,
-- no Std.Spa import. Just retarget:

main = App.run app

$ sky build --target web:app
--   desktop:mac | mobile:ios | mobile:android

The same TEA loop compiled to GOOS=js GOARCH=wasm — runs on the client. `sky run` auto-splits one project into a wasm frontend + a stateless backend + a shared codec (no hand-written boundary). Ships to web, desktop, iOS and Android; Std.Native exposes device APIs (clipboard, camera, geolocation) and Native.bridge extends them. Experimental.

-- the very same `app`, retargeted —
-- the Element tree renders to ANSI cells:

main = App.run app

$ sky build --target terminal:tui

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.

-- the very same `app`, retargeted —
-- a line-oriented loop for non-TTY shells:

main = App.run app

$ sky build --target terminal:cli

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.

-- the very same `app`, retargeted —
-- Sky.Live's renderer in a native window:

main = App.run app

$ sky build --target desktop

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 server-driven web app (Sky.Live), a client-side wasm app (Sky.Spa), a terminal UI (Sky.Tui), a stdin loop (Sky.Cli), or a desktop window (Sky.Webview). One model, five 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.