By 2025, apart from Django, what other options are there for Python web frameworks?

Foreword

Hello everyone, I'm Xiyuan~

A while ago, I wrote an article titled "Is Django Outdated? Thoughts from ASGI to the AI Era", discussing how traditional full-stack frameworks (like Django) should face new trends in the age of AI.

Recently, while renovating the DjangoStarter project, I did some research along the way and found that the Python Web ecosystem is evolving even faster than I imagined.

On one hand, veteran players like Django now have fresh add-ons like Ninja. On the other hand, if you choose not to follow the full-stack route of Django, there's a batch of emerging lightweight frameworks and tools that are pushing Python Web into a new phase: lightweight + async-first + Rust-powered.

So in this article, I'll talk about several new options worth watching in 2025: LiteStar, Tortoise ORM, Granian, and Robyn.

LiteStar

LiteStar is an emerging ASGI-based framework, positioned somewhat as an evolved version of FastAPI.

• Advantages: Complete type hints, natural dependency injection, and good performance.
• Disadvantages: Moving away from the Django ecosystem means you have to choose and configure ORM and admin management yourself.
• Target Audience: Independent developers and small projects that prioritize lightweight and flexibility.

When I tried it out, the biggest takeaway was that its writing style is clean and less burdened by historical baggage compared to Django.

Later on, I will use LiteStar to develop a formal project to test the waters.

I’ll share more when that happens.

Async ORM

Leaving the Django ecosystem, the thing you'll probably miss most is the ORM.

LiteStar doesn't have a built-in ORM, so which one should you choose? Personally, I recommend Tortoise ORM.

Its syntax is very similar to Django ORM.

class Event(Model):
    id = fields.IntField(pk=True)
    name = fields.CharField(max_length=255)
    start_time = fields.DatetimeField()

Looks a bit familiar, right?

For Django users, the learning curve is very low.

• Pros: Async-native, syntax consistent with Django ORM.
• Cons: The ecosystem is not as large as Django ORM's, and community activity remains to be seen.

If you're used to Django ORM but want async/await, Tortoise ORM is a great choice.

Granian

A high-performance server powered by Rust

At the deployment level, I recently discovered a new tool: Granian.

• An ASGI server written in Rust, faster than Uvicorn/Daphne.
• Can handle static files directly, eliminating the need for Nginx in many scenarios.
• Built-in multi-worker support simplifies the deployment process.

In other words: it replaces both Daphne and Nginx at once.

I plan to use Granian in subsequent experiments with DjangoStarter to see if it can eliminate a reverse proxy layer. After all, I've been scratching my head recently over how to elegantly integrate the URL Prefix functionality into DjangoStarter's Nginx configuration 🤣

Robyn

Python syntax + Rust performance

Another noteworthy framework is Robyn. Its approach is: use Rust to write the underlying runtime and Python to provide the API layer.

This way, you get both the ease of use of Python and performance close to Node.js/Rust frameworks.

• Built-in routing, static files, and templates
• High-performance async runtime
• Developer-friendly, with a syntax similar to Flask/FastAPI

It looks like a very cool framework that combines Python's ease of use with Rust's performance. In short, it's about balancing productivity and speed, and it seems worth exploring.

Summary

The Python Web ecosystem in 2025 is no longer just about Django vs Flask vs FastAPI.

The new trends are:

• Lighter frameworks (LiteStar)
• ORM with native async support (Tortoise)
• Faster and simpler deployment layers (Granian)
• Performance powered by Rust (Robyn)

My takeaway is: Django remains important, but new frameworks have brought more possibilities for independent developers and small teams.

In the future, I plan to try out Robyn and Granian in real projects to see if the Python workflow combined with Rust performance can be effectively realized.