Add streaming callbacks: @callback(..., stream=True)

[T4rk1n]

A callback registered with stream=True is a generator (or async generator) whose yields are pushed to the browser as they are produced. Each yielded value has the same shape as a regular return value and replaces the outputs; yielding dash.Patch gives incremental updates (e.g. LLM token streaming). The last yield is the final value.

Transport follows the callback's normal selection: over the WebSocket callback transport, frames ride the open connection as callback_response messages with stream: true; otherwise the HTTP response streams NDJSON (application/x-ndjson), one frame per line with a terminal {"done": true} frame. Works on Flask, Quart, and FastAPI; sync generators warn at registration since they occupy a server worker for the whole stream.

• dash/_streaming.py: StreamedCallbackResponse marker, context-safe iteration helpers (callback context travels in a contextvars snapshot so set_props/ctx work after dispatch returns), NDJSON serialization, and a thread bridge for async generators on Flask.
• dash/_callback.py: stream wrappers building one frame per yield via _prepare_response; per-yield no_update/PreventUpdate handling, on_error support, error frames; registration validation (mutually exclusive with background/clientside/mcp_enabled/api_endpoint).
• backends: streaming response branches in each serve_callback; ws.py frame emitter and stream consumers for both the event-loop and threadpool dispatch paths.
• renderer: applyStreamFrame applies frames on arrival through the sideUpdate path (Patch applies exactly once); NDJSON reader in handleServerside; stream-aware callback_response handling keeps the request pending until the terminal frame; loading states span the whole stream.

Demo

Two examples:

1. Fake LLM token streaming — each token is yielded as a dash.Patch that
   appends to the output while the callback keeps running.
2. A long computation with a live progress bar — each yield replaces the
   bar width/label, and set_props pushes a side update along the way.

import asyncio
import random

from dash import Dash, Input, Output, Patch, callback, html, set_props

LOREM = (
    "Streaming callbacks let a generator push every yield straight to the "
    "browser while the callback is still running which is exactly what you "
    "want for token streaming progress feeds and long computations"
).split()

app = Dash(__name__)

app.layout = html.Div(
    style={"maxWidth": "640px", "margin": "40px auto", "fontFamily": "sans-serif"},
    children=[
        html.H2("stream=True demo"),
        html.H4("1. Token streaming (Patch appends)"),
        html.Button("Generate", id="generate", n_clicks=0),
        html.Div(
            id="answer",
            children="Click Generate…",
            style={
                "whiteSpace": "pre-wrap",
                "border": "1px solid #ccc",
                "borderRadius": "6px",
                "padding": "12px",
                "margin": "12px 0 32px",
                "minHeight": "60px",
            },
        ),
        html.H4("2. Long computation with progress"),
        html.Button("Run job", id="run-job", n_clicks=0),
        html.Div(
            style={
                "background": "#eee",
                "borderRadius": "6px",
                "margin": "12px 0",
                "height": "22px",
                "overflow": "hidden",
            },
            children=html.Div(
                id="bar",
                style={
                    "background": "#119dff",
                    "height": "100%",
                    "width": "0%",
                    "transition": "width 0.2s",
                },
            ),
        ),
        html.Div(id="status", children=""),
    ],
)


@callback(
    Output("answer", "children"),
    Input("generate", "n_clicks"),
    stream=True,
    prevent_initial_call=True,
)
async def generate(n):
    yield ""  # clear the output immediately
    for word in LOREM:
        await asyncio.sleep(random.uniform(0.03, 0.15))  # pretend to think
        patch = Patch()
        patch += word + " "
        yield patch  # append one token


@callback(
    Output("bar", "style"),
    Output("status", "children"),
    Input("run-job", "n_clicks"),
    stream=True,
    prevent_initial_call=True,
)
async def run_job(n):
    style = Patch()
    for i in range(1, 101):
        await asyncio.sleep(0.04)
        style["width"] = f"{i}%"
        yield style, f"Processing step {i}/100…"
        if i == 50:
            # set_props between yields rides along with the next frame
            set_props("answer", {"children": "Halfway there — set_props says hi."})
    yield style, "Done ✅"


if __name__ == "__main__":
    app.run(debug=True)

[KoolADE85]

The implementation here will easily starve the server of resources.
Run the sample app with gunicorn -w 1 and observe:

1. It will terminate streams that take longer than 30s (by default)
2. The number of simultaneous requests is limited to the number of workers you spawn. After that limit, the server becomes unresponsive and/or terminates worker threads.

[KoolADE85]

This looks like two "sources of truth" that must agree with each other (stream=True and async/generator).
What do you think about removing the stream flag and just detect streaming automatically based on isasyncgenfunction/ isgeneratorfunction? That would allow devs to just start yielding values without needing to manage flags or understand our API (because there would be no API at all).

[T4rk1n]

Good catch, only need a yield, stream keyword is redundant.

[sonarqubecloud]

Quality Gate passed

Issues
9 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud

[T4rk1n]

The implementation here will easily starve the server of resources. Run the sample app with gunicorn -w 1 and observe:

1. It will terminate streams that take longer than 30s (by default)

2. The number of simultaneous requests is limited to the number of workers you spawn. After that limit, the server becomes unresponsive and/or terminates worker threads.

With a sync flask backend, it's not really possible to fix at the app level. Need to run with --worker-class gthread --threads 8 --timeout 0 for a true fix. Will add support in cloud and DE.

There is also a warning recommending a different backend when streaming, but maybe we should not allow it?