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.

See it running in your browser - the full demo gallery, live, no install and no clone.

Status: 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

make demo starts the indah Studio: every component and feature running live, one small page each, with its source underneath. It also has full example dashboards (a live log, a 20,000-row table, routing, an editor, a multi-user hosted app with roles and API tokens) and a playground where you type a few lines of indah and run them. Everything updates over SSE, with no WebSocket and no Node, and only the components that depend on a changed value are patched.

Other ways to run it:

make demo-notebook   # inline in a local JupyterLab cell
make demo-docker     # the small built-in demo, 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):

That is the starter subset. 0.2.0 also ships layout containers (Row, Grid, Card, Tabs, Sidebar, Expander), more inputs (Checkbox, Number, Radio, MultiSelect, Date), charting (Chart, Heatmap, Table, Stat, ImageOverlay), data-driven List / Chat / Gallery, and file Upload / Download. Building a dashboard that sits inside a service (live push, big tables, overlays, routing, editors)? Start with Build a dashboard. The full list is in the Components reference.

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

Every demo is live in the demo gallery (no install, no clone), opens in one click in Colab, and is a single Python file you can run as a script (ADR-0023).

Demo	Live	Colab	Source
Streaming chatbot	Open		chatbot.py
Live training dashboard	Open		training_dashboard.py
Image generation	Open		diffusion.py
Poster generator	Open		poster.py
Image classifier	Open		upload_classify.py
Object detection	Open		object_detection.py
Hybrid charting	Open		charts.py
Stock peer analysis	Open		stocks.py
Pretty map	Open		prettymap.py
Audio analysis	Open		audio_analysis.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.