Meet Orionis: The Async-First Python Framework Powered by Rust

Raúl Mauricio Uñate Castro — Wed, 28 Oct 2026 17:31:35 +0000

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

DEV Community: Raúl Mauricio Uñate Castro

Meet Orionis: The Async-First Python Framework Powered by Rust

Meet Orionis: The Async-First Python Framework Powered by Rust

🚀 What is Orionis?

🦀 Rust-Powered HTTP Serving

⚡ Async-First by Design

🏗️ More Than an HTTP Router

Dependency Injection and Service Providers

Database and ORM

Authentication and Authorization

Background Jobs and Scheduling

Real-Time Communication

AI and MCP Integration

Testing and Developer Tooling

🛠️ Getting Started

Prerequisites

Create a new project

🤔 Why Build Another Python Framework?

🌍 Open Source and Community

⭐ Explore Orionis on GitHub

💬 Let's Discuss