Manifesto.
Zero Compromises.

The modern web stack has normalized absurd complexity. Transpilers, bundlers, tree-shakers, hydration, client-side routers, state managers, API serializers — each one a reasonable idea in isolation, and a maintenance nightmare in combination. Teams spend more time fighting their tools than building their product.

djust starts from the opposite end. No build step. No node_modules. No client-side state to synchronize. ~29KB of JavaScript total. You write Python, you write HTML, you deploy. Every piece of complexity we removed is a bug you will never encounter, a config file you will never debug, and a dependency that will never break your CI at 2 AM.

Adding real-time features to a traditional web app usually means choosing a WebSocket library, wiring up pub/sub, writing reconnection logic, building a state synchronization layer, and then doing it all again on the client side. It is a month of work before you write a single line of product code.

In djust, you add a mixin. You call a method. It works. Presence tracking is one mixin. Streaming LLM tokens is one method call. Server push from a background task is one function. We handle the hard parts — connection management, reconnection, multiplexing, security — so you can focus on what makes your application yours.

But developer-first goes beyond features. It means clear, actionable error messages that tell you what went wrong and how to fix it. It means djust system checks that catch misconfigurations, missing settings, and forgotten best practices before they become runtime surprises. The framework should be a guardrail, not a guessing game.

AI is writing more of our code every day. That is not going to slow down. The question is: what kind of code is it writing? In a typical SPA stack, AI is generating React components, API endpoints, authentication flows, input validation, CORS configuration, and state management — all with different conventions, all with different security assumptions, all mixed together in one codebase.

djust shrinks the surface area. There is no API layer for AI to get wrong. There is no client-side auth to misconfigure. There is no state synchronization to fumble. Security, real-time transport, and rendering are handled by the framework — battle-tested once, used everywhere. AI just writes your views and templates. The result is generated code that is consistent, auditable, and safe by default — because the dangerous parts were never in scope.

The standard architecture forces you to maintain three parallel realities: a backend that holds the data, an API that translates it, and a frontend that displays it. Every feature touches all three. Every change requires coordinating types, contracts, and deployments across two or three repositories with different languages, different test suites, and different deploy cycles. It is slow and it produces bugs at every boundary.

djust eliminates the API layer entirely. Your Python view renders HTML on the server and streams updates over a WebSocket. There is no REST contract to version. There is no GraphQL schema to maintain. There is no TypeScript type that can drift from your Django model. One language, one codebase, one deploy. You move faster because there are fewer places for things to go wrong — and when something does go wrong, the stack trace is in one language and one process.

Django's template engine is written in Python. It is flexible, well-documented, and — for rendering thousands of nodes on every WebSocket event — too slow. When a framework promises real-time server rendering, template speed is not a nice-to-have. It is the critical path.

djust compiles your Django templates into a Rust AST, diffs against a virtual DOM tree, and emits the minimal set of DOM mutations. The Python layer handles your business logic — where readability and rapid development matter. The Rust layer handles the inner loop — where nanoseconds compound into user-visible latency. This is not two languages for complexity's sake. It is two languages because they are each excellent at different jobs.

npm install creates a node_modules directory with hundreds of transitive dependencies, any one of which can be compromised, deprecated, or relicensed. Your supply chain is only as strong as its weakest maintainer. This is not theoretical — it has happened repeatedly.

djust's client JavaScript is a single file you can read in an afternoon. There are no node_modules in production. No CDN dependency. No registry to trust. If you need to modify the client behavior, you read the source, change it, and deploy. The entire client stack fits in your head because it was designed to.

Opinionated frameworks work. They let teams agree on standards instead of debating them. They let new developers onboard by learning one way of doing things instead of six. And increasingly, they let AI generate reliable code — because when there is one correct pattern, AI can learn it and apply it consistently. djust is opinionated about WebSocket security, event handling, state management, and VDOM diffing. These are solved problems. Having opinions about them means you do not have to.

But we refuse to own your UI. Some frameworks hand you a library of pre-styled, heavily opinionated components and call it productivity. What you get is every app looking the same and a fight the moment your design diverges from the defaults. djust renders HTML. That is it. Bring your own CSS framework — Tailwind, Bootstrap, custom stylesheets, whatever fits your project. Use our component library as flexible building blocks, or write your own markup from scratch. We give you the reactive engine; the creative layer is entirely yours.