Compare — Pyxle vs the field

Real React. Pure Python.
No seam.

Server components, type generators, BFF layers — every modern stack spends real work stitching the frontend back to the backend. Pyxle has no seam to stitch.

one language you know · one file per feature · one service to deploy · shipping since v0.1, a release most weeks

Start buildingSee the numbers ↓

01 — The set

The only column that’s all the way green.

Every stack is great at something. Pyxle is the only one great at all of it at once — the full React ecosystem, real Python on the server, one file, one deploy, and an AI-native surface none of the others ship.

Pyxleone fileNext + FastAPItwo servicesReflexpython-onlyDjangotemplates
Real React — npm-install anythingthe whole ecosystem, no wrapper
Server logic in Python@server loaders, @action mutations
One service, one deployno CORS, no second runtime
No API contract to hand-keepthe loader’s return is the props
Streaming SSR on React 19<Suspense>, shell-first
One file per featureloader, mutation, UI — colocated
Breakpoints in one file, both halvesPython loaders and React, in the same .pyxl
AI-native surfaceAGENTS.md scaffold · every page as Markdown · llms.txt

full partial or wrapped not built inEach mark is defensible against that framework’s own docs. “Next + FastAPI” is the two-service stack Pyxle replaces — Next’s App Router collapses part of this in JavaScript, not Python.

These eight rows are Pyxle’s own design axes, so a full column is a statement of intent rather than a verdict. For the other side of it — what Reflex, Django, NiceGUI, Streamlit and Next + FastAPI are each genuinely better at, and when to reach for one of them instead — read the long-form comparison guide →.

02 — The tax

The old stack re-types the same field six times.

Follow one search notes field from the database to your component: re-typed, re-serialized, and re-validated at every border it crosses. In Pyxle the loader’s return value is the props.

Next.js + FastAPIa schema, a generated client, and a contract two runtimes keep by hand
6 representations3 places to drift
Reflexthe field re-wrapped as the framework’s own state var
3 representations1 wrapper to cross
Djangoshort — until you want a real component model
3 representationstypes end at the template
Pyxlethe loader’s return value is the component’s props
1 representation0 places to drift

Fig. 1 — chain of custody for notes. Station names are each framework’s own (types.gen.ts is the conventional name for the client types openapi-typescript generates; rx.State is Reflex’s; context is Django’s). The lines animate at one speed — a longer line has more stations to cross, not a slower clock.

03 — The proof

One representation. And it’s fast.

The short seam isn’t just cleaner — it’s cheaper at runtime. Real bytes off a real build, then the numbers, wins first.

GET /search?q=in — the whole document2,020 bytes
<h1>3<!-- --> notes match “<!-- -->in<!-- -->”</h1>
<ul><li>Kerning the long dash</li>
    <li>Ochre ink, mixing notes</li>
    <li>On margins and measure</li></ul>
<script id="__PYXLE_PROPS__" type="application/json">
  {"data":{"q":"in","notes":[{"id":2,"title":"Kerning the long dash"},
   {"id":3,"title":"Ochre ink, mixing notes"},
   {"id":4,"title":"On margins and measure"}],"total":3}}
</script>
<link rel="modulepreload" href="…/search-CXnHMteq.js" />
⋯  x-request-id: 256151ee6c574687bd04dc4cdeb0c769
Fig. 2 — the entire response. The field arrives as what it always was: props, shipped once as inert JSON.
the split, proven
$ grep -c 'find_notes\|remember\|SavedSearch' \
    dist/assets/search-*.js
0
Fig. 3 — the loader’s server code, grepped for in the built client chunk. Absent by construction. The page’s own chunk: 2.6 KB / 1.3 KB gzip.
~2.2×
faster dynamic SSR than Next.js, per core
2–3×
fewer bytes for the same DOM — no hydration blob
1.31×
FastAPI’s throughput on database-query pages

Pyxle matches FastAPI on trivial endpoints and pulls ahead on real database work; one flag scales it near-linearly across every core. Raw-JSON microbenchmarks belong to Node routers like Hono — Pyxle is a full framework that renders React and runs your Python, and it’s still five figures per core. Zero errors under load · 2,500+ tests · 95% coverage gate. Every number, the hardware, and the losses: /benchmarks →

Measured July 2026 on Pyxle 0.7.1, and not re-measured for the 0.9 line.

04 — Where this goes

This is the floor, not the ceiling.

Pyxle is opinionated on purpose — and honest about it. If you’ll never write a line of JavaScript, use Reflex. If you need Django’s admin, use Django. For everyone building a real React product on a Python brain, Pyxle already does more, in less.

Shipped in its first year

streaming SSR · realtime & WebSockets · Pydantic-validated actions · caching, SSG & ISR · observability · background work · image optimization · multi-worker serving · Markdown-native pages.

Next

Pyxle Cloud — push a Pyxle app and skip the server story entirely, with AI scaffolding in the mix.

In development. The one file becomes one command. See the whole trajectory on the roadmap — the newsletter hears it first.

Start buildingSee the benchmarks →Try it in the browser →

Measured, not marketed.