Meet Orionis: The Async-First Python Framework Powered by Rust
Python has an incredible ecosystem for building web applications. FastAPI, Django, Flask, and other frameworks have made it easier than ever to ship software.
But there's a recurring challenge: building a complete application often means assembling a collection of libraries that weren't originally designed to work together.
You need routing, dependency injection, database access, authentication, background jobs, caching, testing, and an organized application lifecycle.
What if these components were designed to work together from the beginning?
That's the idea behind Orionis Framework.
🌐 Website: https://orionis-framework.com/
📚 Documentation: https://docs.orionis-framework.com/en/
⭐ GitHub: https://github.com/orionis-framework/framework
🚀 What is Orionis?
Orionis is an open-source, async-first, full-stack Python framework designed for building modern web applications, APIs, real-time systems, and AI integrations.
Its philosophy is simple:
Stop assembling disconnected tools. Start building applications.
Rather than focusing exclusively on HTTP routing, Orionis provides a cohesive architecture where application services, dependency injection, infrastructure, and developer tooling work together.
The goal is to combine the productivity of a batteries-included framework with an architecture designed around asynchronous Python.
🦀 Rust-Powered HTTP Serving
One of Orionis's architectural decisions is its integration with Granian, a high-performance HTTP server written in Rust.
Granian provides two important interfaces:
- ASGI: Compatibility with the established Python asynchronous ecosystem.
- RSGI: A Rust-oriented gateway interface designed to reduce overhead in HTTP processing.
This gives developers flexibility when choosing how to run their applications.
Importantly, Orionis itself remains a Python framework. Rust powers the HTTP serving infrastructure through Granian rather than replacing the application's Python code.
Performance depends on the workload, deployment configuration, and application logic, so real-world benchmarking remains essential.
⚡ Async-First by Design
Asynchronous programming is not an afterthought in Orionis.
The framework is designed around modern Python's async and await capabilities, making it suitable for applications involving:
- Concurrent HTTP requests.
- Database operations.
- WebSocket connections.
- Server-Sent Events.
- Background processing.
- External API integrations.
- AI tools and services.
The objective is to make asynchronous application development feel natural and consistent throughout the project.
🏗️ More Than an HTTP Router
A production application needs much more than endpoints.
Orionis brings together several capabilities in a unified framework.
Dependency Injection and Service Providers
Organize application services and manage their dependencies through a dedicated IoC container and service providers.
This encourages clearer separation of responsibilities and makes applications easier to maintain and test.
Database and ORM
Orionis includes database management and an ORM with features such as:
- Models and relationships.
- Query building.
- Database migrations.
- Transactions.
- Model lifecycle events.
Authentication and Authorization
The framework provides foundations for authentication, sessions, API tokens, roles, and authorization policies.
Background Jobs and Scheduling
Applications can use queues, worker processes, scheduled tasks, and retry handling without designing an entirely separate application infrastructure from scratch.
Real-Time Communication
Orionis supports WebSockets and Server-Sent Events for applications that require ongoing communication between clients and servers.
AI and MCP Integration
Modern applications increasingly need to expose tools and capabilities to AI systems.
Orionis includes support for building Model Context Protocol (MCP) servers, including tools, resources, and prompts.
This enables developers to build AI-facing services within the same application framework used for traditional web APIs.
Testing and Developer Tooling
Testing utilities, application commands, and project scaffolding are integrated into the development experience.
The goal is to reduce repetitive setup and encourage consistent engineering practices.
🛠️ Getting Started
Orionis provides an official installer to generate applications from predefined project skeletons.
Prerequisites
You'll need:
- Python 3.14 or newer.
- Git.
- uv, the Python package and project manager.
Create a new project
Run:
uvx --python 3.14 --from orionis-installer orionis new my-app
The installer guides you through choosing an application stack and configuring your project.
Available starting points include:
- Blank application.
- Server-side rendered web application.
- Slim API.
- Slim MCP server.
Once the project is created, move into its directory:
cd my-app
For more detailed setup, database configuration, and first-run instructions, follow the official installation guide:
https://docs.orionis-framework.com/en/getting-started/installation/
🤔 Why Build Another Python Framework?
That's a fair question.
The Python ecosystem already offers excellent solutions.
FastAPI provides a productive API development experience. Django offers an established full-stack ecosystem. Flask gives developers flexibility through a minimal core.
Orionis explores a different combination of priorities.
It emphasizes:
- An async-first architecture.
- A cohesive full-stack developer experience.
- Rust-powered HTTP serving.
- Integrated dependency injection and application lifecycle management.
- Built-in tooling for web, background, real-time, and AI workloads.
The intention is not to claim that every application needs Orionis or that existing frameworks are inadequate.
Instead, Orionis is an exploration of what a modern, integrated Python application framework can look like.
🌍 Open Source and Community
Orionis is open source, and community feedback is an important part of its development.
If you're interested in Python frameworks, asynchronous systems, developer tooling, or application architecture, you're invited to explore the project.
Contributions can take many forms:
- Reviewing the architecture.
- Reporting bugs.
- Improving documentation.
- Suggesting features.
- Testing the framework with real projects.
- Contributing code.
Even critical technical feedback is valuable.
⭐ Explore Orionis on GitHub
If Orionis sounds interesting, take a look at the source code:
https://github.com/orionis-framework/framework
If you find the project useful or want to follow its development, consider giving it a ⭐ on GitHub.
Your feedback and contributions can help shape the framework's future.
💬 Let's Discuss
I'm particularly interested in hearing from other Python developers:
What do you think is missing from today's Python web frameworks?
Would you prefer an integrated, async-first framework, or do you favor assembling specialized libraries yourself?
And what trade-offs would matter most to you when evaluating a new Python framework?
I'd love to hear your thoughts in the comments.
Build without boundaries.
🌐 https://orionis-framework.com/
📚 https://docs.orionis-framework.com/en/
💻 https://github.com/orionis-framework/framework
Top comments (0)