App frameworks

Domino runs any web framework that serves HTTP on 0.0.0.0, port 8888. Each section below gives one framework’s packages, App code, and entry point. Use it in the Write the entry point step of Develop and test. Previewing, publishing, and deploying work the same way for every framework.

Choose a framework

Framework	Language	Best for	Performance and scaling
Dash	Python	Interactive analytic Apps built on Plotly visualizations, with callbacks for finer control over layout and interaction.	Serve through a production server such as `gunicorn`. Keep session affinity off when autoscaling.
Streamlit	Python	Turning a Python script into a shareable web App with minimal code.	Turn session affinity on when autoscaling; Streamlit keeps session state in server memory.
Flask	Python	Custom endpoints and fully bespoke web Apps.	Serve through `gunicorn` for production traffic.
Shiny	R	R users building reactive web Apps.	Autoscale with session affinity on and small Hardware Tiers. Identity headers require Shiny Server Pro.
Rust	Rust	Compiled web servers where latency, throughput, or correctness matter more than iteration speed.	Built once with a pinned toolchain and run from the stored binary. The domino-rust-apps Skill handles the setup.
Static HTML	HTML and JavaScript	Serving prebuilt pages or reports with no server-side logic.	Served by Python’s `http.server`.

For a JavaScript front end such as React, ask a coding assistant to scaffold the App with the domino-app-init Domino Skill. Size and scale an App covers the performance settings in the table.

Before you begin

The Project’s Compute Environment must include the framework. To add a Python package, open the environment under Govern > Environments, select Edit Definition, add the install to the Dockerfile, and select Build. For example, for Dash:

USER root
RUN pip install dash>=4.4.1
USER ubuntu

Every framework that accepts a base path or route prefix must read it from DOMINO_RUN_HOST_PATH. Domino sets this variable at startup to the URL path it serves the App under.

Dash

Dash builds interactive analytic Apps on Plotly visualizations. Install dash in the Compute Environment.

import os
import plotly.express as px
from dash import Dash, dcc, html

# Serve under the path Domino assigns to the App
runurl = os.environ.get("DOMINO_RUN_HOST_PATH", "/")

app = Dash(__name__,
           routes_pathname_prefix='/',
           requests_pathname_prefix=runurl)

fig = px.scatter(x=[1, 2, 3], y=[4, 1, 6], title="Sample Scatter Plot")

app.layout = html.Div([
    html.H1("Minimal Dash App"),
    dcc.Graph(figure=fig)
])

if __name__ == '__main__':
    app.run(port=8888, host='0.0.0.0', debug=False)

#!/usr/bin/env bash
python app.py

routes_pathname_prefix='/' and requests_pathname_prefix from DOMINO_RUN_HOST_PATH let Dash load its assets and callbacks behind the Domino proxy. The Dash Gallery has layouts to adapt.

Streamlit

Streamlit turns a Python script into a web App. Domino Standard Environments include Streamlit. Streamlit serves on port 8501 by default, so the entry point writes a Streamlit configuration file that sets port 8888 and host 0.0.0.0 before it starts the App.

import streamlit as st

st.title("Minimal Streamlit App")
st.write("Hello from Domino!")

#!/bin/bash

mkdir -p ~/.streamlit

cat << EOF > ~/.streamlit/config.toml
[browser]
gatherUsageStats = false

[server]
port = 8888
enableCORS = false
enableXsrfProtection = false
address = "0.0.0.0"
EOF

streamlit run app.py

If you set a route prefix for the App, read it from DOMINO_RUN_HOST_PATH.

Example: chatbot

Domino’s Streamlit chatbot example sends prompts to large language models (LLMs) hosted on Hugging Face or to a Domino endpoint. To run it:

Add your Hugging Face access token as a user environment variable named HUGGING_FACE_API_TOKEN.
Install streamlit, requests, pandas, transformers, and torch in the Compute Environment.
Copy chatbot.py from the example into your Project. Set the endpoint’s URL and access token as Project environment variables, such as MODEL_ENDPOINT_URL and MODEL_ACCESS_TOKEN, and read them in chatbot.py. Select Domino endpoint authorization mode explains endpoint tokens.
Use the app.sh above with streamlit run chatbot.py as its last line.

Flask

Flask suits custom endpoints and bespoke web Apps. Flask works with Domino routing and identity headers without extra configuration.

from flask import Flask

app = Flask(__name__)

@app.route("/")
def index():
    return "Hello from Flask in Domino!"

if __name__ == '__main__':
    app.run(port=8888, host='0.0.0.0')

#!/usr/bin/env bash
python app.py

Structure a larger Flask App

For an App with templates and static files, make the App a Python package. The names __init__.py, static, and templates are required. Flask looks for static files and templates in those folders.

|-- app.sh
|-- run.py
|-- /flask_app
    |-- __init__.py
    |-- views.py
    |-- /static
    |-- /templates

__init__.py creates the App and wraps it so that the URLs Flask builds include the path Domino serves the App under:

flask_app/__init__.py

from flask import Flask

class ReverseProxied(object):
  def __init__(self, app):
      self.app = app
  def __call__(self, environ, start_response):
      script_name = environ.get('HTTP_X_SCRIPT_NAME', '')
      if script_name:
          environ['SCRIPT_NAME'] = script_name
          path_info = environ['PATH_INFO']
          if path_info.startswith(script_name):
              environ['PATH_INFO'] = path_info[len(script_name):]
      # Setting wsgi.url_scheme from Headers set by proxy before app
      scheme = environ.get('HTTP_X_SCHEME', 'https')
      if scheme:
        environ['wsgi.url_scheme'] = scheme
      # Setting HTTP_HOST from Headers set by proxy before app
      remote_host = environ.get('HTTP_X_FORWARDED_HOST', '')
      remote_port = environ.get('HTTP_X_FORWARDED_PORT', '')
      if remote_host and remote_port:
          environ['HTTP_HOST'] = f'{remote_host}:{remote_port}'
      return self.app(environ, start_response)

app = Flask(__name__)
app.wsgi_app = ReverseProxied(app.wsgi_app)

views.py holds the App’s routes. run.py imports both, and app.sh starts Flask on the required host and port:

from flask import render_template
from flask_app import app

@app.route('/')
def index():
    return render_template('hello.html')

<!DOCTYPE html>
<html>
  <body>
    <h1>Hello from Flask in Domino</h1>
  </body>
</html>

<!DOCTYPE html>
<html>
  <body>
    <h1>Hello from Flask in Domino</h1>
  </body>
</html>

from flask_app import app
from flask_app import views

if __name__ == '__main__':
    app.run()

#!/usr/bin/env bash
export FLASK_APP=run.py
python -m flask run --host=0.0.0.0 --port=8888

Shiny

Shiny is R’s framework for reactive web Apps. This two-file App draws the Telephones by region chart from R’s built-in WorldPhones data. Shiny requires the files to be named server.R and ui.R.

library(datasets)

function(input, output) {
  output$phonePlot <- renderPlot({
    barplot(WorldPhones[,input$region]*1000,
            main=input$region,
            ylab="Number of Telephones",
            xlab="Year")
  })
}

library(datasets)

fluidPage(
  titlePanel("Telephones by region"),
  sidebarLayout(
    sidebarPanel(
      selectInput("region", "Region:",
                  choices=colnames(WorldPhones)),
      hr(),
      helpText("Data from AT&T (1961) The World's Telephones.")
    ),
    mainPanel(
      plotOutput("phonePlot")
    )
  )
)

#!/usr/bin/env bash
R -e 'shiny::runApp("./", port=8888, host="0.0.0.0")'

app.sh is the entry point. Identity headers reach a Shiny App only through Shiny Server Pro. Autoscale a Shiny App to serve any number of viewers; see R and Shiny.

Rust

Rust suits Apps where latency, throughput, or correctness matter more than iteration speed. A Rust App is a compiled web server, for example built with axum. Build it once in a Workspace or Job with a pinned toolchain, keep the binary in /mnt/artifacts in a Git-based Project so each App version pins it with the commit, and have app.sh run the binary without compiling.

use axum::{Router, routing::get};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let port = std::env::var("PORT").unwrap_or_else(|_| "8888".into());
    let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{port}")).await?;
    axum::serve(listener, Router::new().route("/", get(|| async { "Hello from Domino" }))).await
}

#!/usr/bin/env bash
set -euo pipefail
cd "$(dirname "$0")"
export PORT=8888
exec /mnt/artifacts/dist/my-app/my-app

Keep every URL the browser follows relative, such as href="static/app.css" and fetch("api/data"). Where a value must be absolute, read the prefix from DOMINO_RUN_HOST_PATH. Build on the App’s Hardware Tier, so the binary matches the node’s CPU. The domino-rust-apps Domino Skill does the rest. It installs the pinned toolchain in the Compute Environment, scaffolds the Project with lint and release profiles, builds dated binaries, writes an app.sh that checks the binary against the committed sources, and covers viewer identity, Postgres, and corporate certificates, proxies, and package mirrors.

Static HTML

Python’s built-in HTTP server serves index.html and any other static files in the Project. Select app.py as the App file.

app.py

import http.server
import socketserver

PORT = 8888
Handler = http.server.SimpleHTTPRequestHandler
httpd = socketserver.TCPServer(("", PORT), Handler)
print("serving at port", PORT)
httpd.serve_forever()

Next steps

Commit your changes, because App Preview runs the latest commit.
Run the App in App Preview with your entry point as the App file.
Publish a version, then deploy it.

Core Concepts

Features

App frameworks

Choose a framework

Before you begin

Dash

Streamlit

Example: chatbot

Flask

Structure a larger Flask App

Shiny

Rust

Static HTML

Next steps

​Choose a framework

​Before you begin

​Dash

​Streamlit

​Example: chatbot

​Flask

​Structure a larger Flask App

​Shiny

​Rust

​Static HTML

​Next steps

Choose a framework

Before you begin

Dash

Streamlit

Example: chatbot

Flask

Structure a larger Flask App

Shiny

Rust

Static HTML

Next steps