The Architecture of Pytigon — A Symphony of Three Parts

Picture Pytigon not as a monolithic beast but as a finely tuned orchestra, where every instrument knows its part and can play solo or in harmony with others. The architecture breathes the principle of separation of concerns while allowing fluid recombination — like Lego bricks that can form a castle, a spaceship, or a robot, all from the same set.

The Holy Trinity

Pytigon decomposes into three fundamental layers, each with its own soul:

What makes Pytigon special is that these layers can live on a single machine — a developer's laptop pounding coffee at 2 AM — or spread across continents, connected by nothing but TCP packets and hope.

Deployment Topologies

The system doesn't impose a single topology. Instead, it offers a spectrum:

[row] This flexibility means you can start prototyping with SQLite embedded in a desktop app, and when the investors come knocking, pivot to a cloud PostgreSQL backed by Gunicorn and Nginx — without rewriting a single line of business logic.

The Django Heart

At the core of the server beats Django. Pytigon doesn't wrap Django in bubble wrap; it extends it with surgical precision:

• JSONModel: Django's models.Model with a JSON column that acts as a flexible schema extension. Think of it as Django models wearing comfortable stretch pants.
• Generic Views on Steroids: Table views, form views, tree views — all pre-built and waiting for your templates. You define the what; Pytigon figures out the how.
• Template Preprocessor: .ihtml files compile into standard Django templates. The indentation-based syntax eliminates the visual noise of {% endblock %} tags, turning template code from a verbose contract into readable prose.

The Communication Layer

Between client and server flows a river of protocols:

• HTTP/REST — The workhorse. Every view doubles as an API endpoint.
• WebSockets — For when you need real-time updates without polling yourself into exhaustion.
• GraphQL — Because sometimes you want exactly fields X, Y, and Z, and nothing more.
• XML-RPC — The old soldier that refuses to die, still serving remote procedure calls.
• OAuth — Letting users log in with their Google account so they don't have to remember yet another password.

The Client Duality

Pytigon speaks two client languages natively:

1. wxPython — For desktop applications with native look-and-feel across Windows, Linux, and macOS. The wxPython client embeds a WebKit browser component, allowing hybrid apps that blend native widgets with web-rendered content.
2. Web Browser — The universal client. Pytigon's responsive templates adapt from 4K monitors to smartphone screens without blinking.
3. Kivy — For Android, with a built-in web browser component. Not the snappiest experience, but it works when you need it.

The Virtual Filesystem (schfs)

Beneath the visible layers hums a virtual filesystem that abstracts storage into a uniform interface. Files can live on disk, in the database, on remote servers, or in memory — and the application code never needs to know the difference.

Extensibility Points

Pytigon is not a closed garden. Extension points are everywhere:

• Custom template tags and filters — Add Django template tags/filters through Python modules
• Applib modules — Application-specific libraries that Pytigon discovers automatically
• Signal hooks — Django's signal system, fully exposed
• Management commands — Extend the CLI with custom commands
• Background tasks — Scheduled and event-driven task execution
• External C/Nim modules — For when Python isn't fast enough

The architecture document for specific components continues in the subsequent chapters. For now, remember this: Pytigon is what you get when a Django developer, tired of writing boilerplate, decides to build a framework that does the boring stuff so you can focus on the interesting stuff.