indah

A Python UI framework for ephemeral cloud notebooks (Colab, Runpod). Reactive, single-port, no Node required.

Build an interactive UI from a single Python file and launch it straight from a Colab or Runpod cell. It keeps Streamlit's zero-config, single-port startup, adds the async performance of a real full-stack app, and ships its frontend pre-built so there is no Node, npm, or bun anywhere at install or runtime.

Status: 0.2.0 - Milestone 1 components shipped. On top of the MVP (reactive core, SSE transport, streaming, custom-component seam) it adds the full input set and layout containers, data-driven lists (chat/gallery), per-session state, file upload/download, and charting (server-PNG Plot plus client-side Chart, Heatmap, an interactive Table, Stat cards, and ImageOverlay). Install with pip install indah. Start with docs/PLAN.md for the plan and docs/SLICES.md for what is built.

Why another one

How it works

flowchart LR
    subgraph Cell["Colab / Runpod cell"]
        PY["Your Python app<br/>(reactive signals)"]
    end
    subgraph ASGI["Single ASGI app, one port"]
        CORE["Reactive core<br/>signals to JSON patches"]
        API["/api: SSE + POST"]
        STATIC["Pre-built Svelte shell<br/>(static assets in the wheel)"]
    end
    Browser["Browser via platform proxy"]

    PY --> CORE --> API
    STATIC -- served over HTTP --> Browser
    API -- SSE patches --> Browser
    Browser -- POST events --> API

One port, standard HTTP plus Server-Sent Events, so it works through the network proxies of Colab and Runpod without a tunnel or a local JavaScript toolchain.

Try it

Run the built-in demo from a clone:

git clone https://github.com/leejianrong/indah && cd indah
uv sync --extra dev
make demo            # prints a URL; binds the first free port from 8000

The demo streams a mock LLM token by token into a StreamText; below it, a Select switches a live DataFrame and a colour picker (a registered custom component) two-way binds a signal - all updating over SSE, with no WebSocket and no Node. Only the components that depend on a changed value are patched; there is no full-script rerun.

Other ways to run it:

make demo-notebook   # inline in a local JupyterLab cell
make demo-docker     # in Docker on an auto-picked free port

Prefer Docker with a stable http://indah.localhost/ hostname (via a machine-wide Traefik proxy)? make demo-traefik - see docs/DEV-DOCKER.md.

Your app

An app is a tree of components bound to reactive signals. Mutate a signal and only the components that read it update - no full-script rerun:

import indah
from indah import Signal, computed, Column, Slider, Text, Session

a, b = Signal(2), Signal(3)
total = computed(lambda: f"a + b = {a.value + b.value}")

page = Column(
    children=[
        Slider(a, min=0, max=10, label="a"),
        Slider(b, min=0, max=10, label="b"),
        Text(total),
    ]
)

indah.launch(
    indah.create_app(session=Session(page))
)  # prints the URL; embeds inline in Colab/Runpod

The frontend is a pre-built Svelte shell bundled in the wheel; no Node runs at install or runtime. See docs/SLICES.md for what's next.

Components

The starter set covers a typical AI demo (input, run, streamed output):

Need something the set does not cover? Register a custom component against the public JSON protocol, no framework fork and no Node build:

import indah

indah.register_component(
    "colorpicker",
    render={
        "tag": "input",
        "attrs": {"type": "color"},
        "bind": {"value": "value"},  # element value <- signal
        "on": {"input": {"event": "input", "prop": "value"}},  # UI change -> signal
    },
)

colour = indah.Signal("#ff8800")
picker = indah.custom("colorpicker", value=colour)  # two-way, like a built-in

The pre-built shell renders it from that declarative spec at runtime. The protocol is a documented, versioned public contract: see docs/protocol.md.

Examples

Each demo runs in one click in Colab (no install, no clone), or as a script. A live hosted gallery is coming (Hugging Face Spaces, ADR-0023).

Demo	Try it	Source
Streaming LLM chatbot		chatbot.py
Live training dashboard (Runpod)		training_dashboard.py
Image generation (streamed progress)		diffusion.py
Poster / artifact generator		poster.py
Image classify (upload → predict → show)		upload_classify.py
Hybrid charting (client chart + server plot + heatmap)		charts.py

Also: examples/starter_components.py (a ~20-line tour of the component set) and examples/demo.ipynb (the built-in demo inline in a notebook). The chatbot is walked through step by step in the docs: Build a chatbot.

The Colab notebooks are generated from the demo manifest by deploy/colab/make_colab.py; regenerate them after adding a demo.

Planning and design

Development

uv sync --extra dev
make check        # lint + fast tests (the pre-push gate)
make help         # list all targets

See AGENTS.md for repo conventions and docs/RELEASING.md for the release process.

License

Apache License 2.0.