Full-stack webapps,
for people and agents.
A strongly-conventioned full-stack framework in modern Python. Typehints from database to browser. Server-rendered React. Data side-effects that refresh your views automatically. No API to write, no client state to wrangle.
class HomeController(ControllerBase): url = "/" view_path = "/home/page.tsx" async def render(self, conn: DBConnection) -> HomeRender: todos = await conn.exec(select(Todo)) return HomeRender(todos=todos) @sideeffect async def add_todo(self, text: str, conn: DBConnection): await conn.insert([Todo(text=text)])Built on the Python types you already love. Paired with the React you already know.
Mountaineer started with a simple question. We love the typing in modern Python: Pydantic models, FastAPI routes, plain dataclasses. What if it covered the whole app, end to end, all the way out to the browser?
The tempting answer is to reimplement the frontend in Python and fight React for control. We took the opposite bet. Python carries the heavy logic. React renders the views, where it has the richest ecosystem and where agents write the most fluent code. The backend/frontend divide stays, because a clear divide is easy for people and models to reason about.
Heavy logic, fully typed
Models, validation, business rules, and data access. Written once, in modern typed Python.
Dynamic, interactive views
Components and interactivity where TypeScript React is strongest: the deepest library ecosystem, and the code agents write best.
Every framework makes you choose. Mountaineer makes the right choice.
Most stacks hand you a pile of decisions: which API layer, how to share types, where state lives, how the frontend talks to the backend. Each one is a place to be inconsistent, and a place an agent can get lost on a bigger project. Mountaineer has powered million-dollar startups, so it's up to any challenge you throw at it.
Mountaineer takes a stronger position. Controllers render React. Actions are typed Python functions. Data flows through one contract. The result is a codebase that reads the same everywhere, for the person writing it and the model maintaining it. And the structure is explicit, so you can statically analyze for issues before you ship, or before your agent loop is even done.
Typehints from Postgres to the browser.
Your database models, server actions, and React props share one typed contract. Rename a field and your editor lights up everywhere it mattered. No schemas to hand-sync. No drift between client and server.
No API to write. No Node server to run.
Controllers render React views directly. State and server functions are wired automatically, so you skip the REST/GraphQL layer and the glue code that usually sits between Python and your frontend.
One obvious place for everything.
Routes, views, actions, and data live where the framework expects them. Static analysis validates links and data access at build time. Broken references fail loudly, not in production.
A layout coding agents can reason about.
Predictable structure and fully-typed surfaces mean an agent can navigate the codebase, call the right action, and verify its own changes. The same conventions that help you help the models working beside you.
When your FastAPI app outgrows being just an API.
You add a dashboard, a settings page, a few authed flows. The usual next move is a second React app behind a hand-maintained API boundary. Two codebases, two routing systems, one more place to drift. Mountaineer is built for exactly that moment. Extend the typed FastAPI you already write out into the frontend, instead of bolting on a separate app.
$ pipx run create-mountaineer-app$ cd my_webapp$ docker compose up -d→ running at http://127.0.0.1:5006Scaffold and go.
One command scaffolds the whole project: typed controllers, React views, a Postgres compose file, and a hot-reloading dev server. Nothing else to wire up.
Mountaineer & friends really can do it all.
Each stands alone, sharing one set of conventions and types so they click together. Reach for one, or run the whole stack: together they're everything you need to take a webapp from weekend POC to Series C.
The core: conventioned controllers, server-rendered React, and typed actions tying the stack together.
Get startedA high-speed, type-driven ORM. Define tables in Python and get fully typehinted queries and migrations.
VisitDurable background workflows on Postgres. Plain async Python that survives restarts, with no replay.
Visit