Edron

Build polished, server-rendered Python apps with a small, explicit API.

Edron keeps the first page simple and gives the same codebase room to grow into dashboards, internal tools, data workspaces, long-running jobs, and reusable feature packages. You write ordinary Python, run one command, and get accessible HTML with progressive enhancement—without maintaining a separate frontend application or learning a callback-heavy UI model.

A first page in minutes

Install Edron, create app.py, and start the development server:

python -m pip install edron
edron run app:app --reload

import edron as ed

app = ed.App(title="Hello Edron")


@app.page("/", title="Hello")
class Home(ed.Page):
    def render(self) -> None:
        self.heading("Hello, Edron")
        self.text("A small Python API for useful web applications.")

That is the whole application. Add a route, compose a layout, or wire an action when you need it—there is no generated frontend project to keep in sync.

For a guided starting point, use a teaching scaffold:

edron new my-app --template minimal
cd my-app
edron run app:app --reload

Why developers reach for Edron

• Python all the way down. Pages, components, actions, forms, data, and jobs use familiar functions, classes, and type hints.
• A fast path and an escape hatch. Start with a handful of readable Edron primitives. Keep full control of the underlying application when an advanced integration needs it.
• Server-first by default. HTML is useful on its own; HTMX-style enhancement adds smooth interactions without making JavaScript a requirement.
• Batteries included for real work. Compose navigation and layouts, render charts and media, build bounded data tables and editors, manage resources and caching, and expose durable jobs.
• Inspectable instead of magical. edron check, edron explain, and edron doctor make registration, dependencies, capabilities, and deployment facts visible before production.
• Easy to test and review. Explicit routes, typed inputs, bounded payloads, and deterministic manifests keep behavior straightforward to assert in unit tests and code review.

A small API that scales

The same page vocabulary works for a simple screen or a complete workflow:

import edron as ed

app = ed.App(title="Sales")


@app.page("/sales", title="Sales")
class Sales(ed.Page):
    def render(self) -> None:
        self.heading("Sales overview")
        with self.layout(ed.layout("grid", columns=2)) as body:
            body.text("A layout is just Python composition.")

Common building blocks include:

Data, resources, and jobs stay explicit

Edron makes application boundaries visible instead of hiding them in global state. For example, resources are lazy and app-owned, cache policy is declared beside the function it protects, and data editing is deny-by-default:

db = app.resource("database", create_database, secret_refs={"dsn": "DATABASE_URL"})


@ed.cache_data(ttl=60, scope="tenant", vary_on=("tenant_id",))
def load_summary(tenant_id: str) -> dict[str, int]:
    return query_summary(db, tenant_id)

Use DataWorkspace for bounded paging, filtering, sorting, selection, CSV export, and typed edit intents. Use JobFlow when work must outlive a request. Your application still owns the database session, transaction, authorization, persistence, and audit decisions.

Tooling that helps before deployment

# Check source without importing application code
edron check app.py

# Inspect registered pages and surfaces
edron explain app:app

# Check installed required and optional capabilities
edron doctor

For CI, edron check --format sarif produces review-friendly diagnostics. Applications can also expose deterministic app.manifest() and app.conformance() reports for release checks.

Installation and optional integrations

Edron supports Python 3.11–3.14. Install only what your application needs:

python -m pip install edron

Optional extras are available for pandas, Polars, PyArrow, Plotly, Altair, Matplotlib, and SQLAlchemy (for example, pip install "edron[polars,sqlalchemy]").

Read the getting started guide, browse the API guides, or see the Edron roadmap.

How Edron fits in

Edron is the authoring layer: it gives application developers a friendly, typed vocabulary and keeps the important boundaries explicit. A mature native web engine handles the lower-level rendering, routing, interaction, styling, and security work underneath. Most applications never need to think about that implementation detail; when they do, the exact native application remains available through app.native / app.hedron and Page.include().

Edron is currently a Beta API line. Feedback, issues, and contributions are welcome in the Hedron repository.