Pytincture

The full-stack Python application framework

Build web apps in Python.Right down to the browser.

Pytincture packages browser-safe Python for Pyodide, keeps privileged work on FastAPI, and generates an explicit bridge between the two. One language. Two deliberate runtimes.

1.0 launches October 12: The final release is scheduled for . Preview RC13 today. Release status ↓

Try the live example Build your first app See how it works
PythonPyodideFastAPIASGI
Atlas Library · Pytincture app application anatomy
app.pybrowser
1import json
2from wapyt import DataTable, DataTableConfig
3from py_ui_data import py_ui_data
4
5data = json.loads(py_ui_data().dataset())
6config = DataTableConfig(columns=columns)
7cell = self.tabs.get_cell("grid")
8self.book_grid = DataTable(
9    config, container=cell
10)
11self.book_grid.set_rows(data)
browser py_ui_data().dataset() generated BFF policy + transport server FastAPI
Browser PythonPyodide-backed runtime
Generated BFFExplicit server boundary
FastAPI serviceTrusted application code
Static modeNo backend required

More than a browser runtime

The application framework around your Python.

Pytincture handles the path from Python modules to a running browser application: packaging, startup, server calls, identity, assets, and production signals.

Browser runtime01

Python lives in the interface.

Package application modules and declared dependencies for a deterministic Pyodide runtime.

Application delivery02

One service, every application asset.

Serve routes, browser packages, public files, and trusted APIs from a configurable FastAPI/ASGI application.

Backend for frontend03

A Python-shaped bridge—not a mystery tunnel.

Decorated server classes become class-shaped browser proxies with explicit methods, policies, and streaming support.

Identity & policy04

Authentication belongs at the boundary.

Local login, Google OAuth, explicit-tenant Microsoft OAuth, and SAML—with authorization enforced on the server.

Production operations05

Signals you can operate.

Health, readiness, structured logs, correlation IDs, bounded work, and replica-safe signed sessions.

Reproducible assets06

The browser package is deliberate.

Exact pins or SHA-locked wheels, hashed manifests, filesystem containment, and a Pyodide software bill of materials.

One language, two runtimes

Put each kind of Python where it belongs.

Browser code owns interaction. Server code owns credentials, policy, and trusted systems. Pytincture makes the handoff visible and removes the repetitive transport glue.

01
Browser

Package the application

UI modules and declared dependencies become browser-ready assets for a named Pyodide lifecycle.

load → install → import → run
02
Boundary

Generate the bridge

Class-shaped proxies carry calls over explicit HTTP methods, with CSRF and replay protection where required. Policy stays server-owned.

@backend_for_frontend
03
Server

Execute trusted work

Authentication and policy run before protected application code is imported, constructed, or called.

user → policy → systems
browser / reports.py
from reports import Reports

status = Reports().status()
self.badge.set_value(status["state"])
server / reports.py
@backend_for_frontend
class Reports:
    def status(self):
        return {"state": "ready"}

Optional Python UI toolkit

Python-first does not mean primitive UI.

wapyt is the MIT-licensed widgetset built for Pytincture: layouts, tables, forms, charts, and chat declared in Python and rendered in the browser.

Component labwapyt 0.2
Application modulesExample workspace
ModuleRuntimeBoundaryStatus
workspace.pyBrowser—Running
reports.pyServerBFFReady
widget.pyPackage—Resolved
auth.pyServerPolicyProtected
Application lifecycleStage timings · example
browser service
load runtimebrowser
install packagesbrowser
import appbrowser
authorize BFFserver
render UIbrowser
New application

Configure a workspace

Text, select, date, and checkbox fields with client-side validation, composed from Python.

Deployment review streaming

Check whether the application is ready to receive traffic.

PyReadiness is green.
/readyz reports the modules path, frontend runtime, and configured stores are available.

Ask the application…
Explore dataDataTable · Chart · Tree · Listbox · Pagination · Scheduler
Collect inputForm · ModalWindow · Popup · Message · File transfer
Structure appsLayout · Sidebar · TabWidget · Toolbar · MenuBar · ContextMenu · Window
Build workflowsKanban · CardPanel · ResourceBoard · Chat · Terminal · MediaPlayer · ProgressBar
26 widgetsBrowse the widget catalog ↗

Licensing: Pytincture core and wapyt are both MIT licensed. Third-party scripts bundled with wapyt keep their own open-source licenses.

One framework, two delivery modes

Choose the infrastructure your application needs.

Start from the same browser-Python foundation, then keep the application static or add the trusted service boundary.

application.pyPython
Static

A browser application with no backend.

Run inline Python from static hosting with Pyodide and pinned browser dependencies.

HTML→Pyodide→UI
  • static hosting
  • manual or automatic startup
  • no host Python process
Service

A complete ASGI application.

Add trusted code, authenticated data, generated BFF calls, managed assets, and optional MCP exposure.

Browser⇄FastAPI→Systems
  • authentication and policy
  • BFF methods and streams
  • health, readiness, and logs

Built for operational use

The operational shape is part of the framework.

Add only what the deployment needs. The core exposes defined contracts instead of leaving production behavior to convention.

Read the production guide ↗
PyPytincture appAuthBFF policyStreamingLifecycleHealthLogsAsset locksMCP maps

Start with a real application

From three Python files to a running browser UI.

Configure the service, define a browser entry point, and declare the UI package Pytincture should resolve.

Preview the 1.0 API
python -m pip install pytincture==1.0.0rc13
Requires CPython 3.13 or 3.14. Current stable remains 0.10.7; pin the preview exactly while evaluating 1.0.
  1. 01Create the service configuration
  2. 02Write the browser entry point
  3. 03Declare the widgetset version
  4. 04python -m pip download --no-deps wapyt==0.2.0.dev1 -d .
  5. 05python -m uvicorn service:app --port 8070
Open the maintained quickstart 
1from pathlib import Path2from pytincture import PytinctureConfig, create_app34HERE = Path(__file__).resolve().parent56app = create_app(7    PytinctureConfig(8        modules_path=str(HERE),9        default_application="hello",10    )11)
1import js2import widget3from wapyt import MainWindow45class hello(MainWindow):6    def load_ui(self):7        js.document.getElementById("maindiv").innerHTML = (8            "<h1>Hello from Pytincture</h1>"9            "<p>Python is running in your browser.</p>"10        )
1__widgetset__ = "wapyt"2__version__ = "0.2.0.dev1"
localhost:8070/hello
Browser outputHello from Pytincture

Python is running in your browser.

service runninglocalhost:8070/hello
1.0 release updateLaunching October 12, 2026

The final 1.0 release is scheduled for October 12, 2026. RC13 is available now for testing ahead of the launch.

RC13 notes ↗Migration guide ↗

Technical documentation

Go deeper where your application needs it.

Start with architecture, then follow the boundary into identity, deployment, lifecycle, and compatibility.

StartThree-file quickstart

Build and run the maintained service example.

↗ BoundaryBFF guide

Exports, methods, policies, streams, and failure behavior.

↗ IdentityAuthentication

Local login, OAuth providers, SAML, and session behavior.

↗ OperationsProduction deployment

Readiness, proxies, replicas, secrets, and observability.

↗

Start in Python

Build the browser in Python. Keep trust on the server.

Start with the framework, then bring in BFF access, authentication, and wapyt as the application grows.

Start building →View the source ↗
Copied to clipboard