🚀 Roadmap

Questa issue è più una roadmap di alto livello che un’attività di implementazione e non indica file sorgente né test. Inizia con un elemento specifico non selezionato e con la relativa documentazione o pull request collegata, quindi crea una issue separata con un ambito concreto e criteri di completamento prima di apportare modifiche.

Description

This is a tentative roadmap, I will update it as things evolve. Some things might be discarded, others might be added later. I didn't want to make it fully public as it could raise expectations, but it seems it would be more beneficial for the community to know all the ideas and objectives.

Work on this is alternated (and sometimes mixed) with work on Typer, SQLModel, Asyncer, and others.

Answering questions, issues, and PRs is also intermixed with this, but as in some cases one of these features would solve several issues or questions, or potentially solve something done by one or more PRs, in many cases I focus on this a bit more than on answering specific issues, questions, PRs.

Other Tools

FastAPI gets a lot of help from the underlying tools and the people behind them, Pydantic, Starlette, Uvicorn. A lot of the work done there reflects in FastAPI, so they are helping FastAPI, in some way helping maintaining it too, because it's all connected.

Maintenance

The word "maintenance" or "maintainer" doesn't have a very strict definition, and it probably varies a lot from perspective.

A lot of the work related to maintaining FastAPI is done by contributors, you can see the current team here: https://fastapi.tiangolo.com/fastapi-people/#team

And you can learn about how the project is managed here: https://fastapi.tiangolo.com/management/

I also receive a lot of help from others like the FastAPI Experts: https://fastapi.tiangolo.com/fastapi-people/#fastapi-experts

A lot of the maintenance work is done by this amazing community.

If I suddenly died being hit by a bus, there are already mechanisms in place for code inheritance, there are others with GitHub rights to take over, etc. but I have requested to still review each PR myself.

You can help me ensure each existing PR is in shape (has tests, solves the problem, etc.). Make sure you filter out the translation PRs (most of them) unless you speak the language and can review them.

Security

When there are security issues, those are handled with the highest priority, normally involving all the projects and the people from them (FastAPI, Starlette, Pydantic, Uvicorn). Those are normally not handled in issues and PRs but in emails, it's not public until the security disclosure is made, in most cases (always, up to now) with the version that fixes them.

Roadmap

Now, here's the current high-level tentative roadmap:

• Code reference, for functions, classes, parameters, etc. (https://github.com/tiangolo/fastapi/pull/10392)
  • This required additional tooling and methods that didn't exist before.
• Pydantic v2 used for serialization (increasing performance).
• Pydantic v2 used for parsing (increasing performance).
• Upgrade Starlette.
• FastAPI CLI
• Explore supporting Pydantic v1 and v2 on the same app (https://github.com/fastapi/fastapi/pull/14168).
• Refactor routers, to re-use router instances instead of cloning path operations. (https://github.com/fastapi/fastapi/pull/15745) This will allow several things like:
  • Middlewares per router.
  • Custom router classes.
  • Dependencies per router.
• Support for Pydantic models for Query(), Form(), etc.

Probably similar to:

class Common(BaseModel):
    token: str
    skip: int = 0
    limit: int = 100


@app.get("/items/")
def read_items(commons: Annotated[Common, Query()]):
    ...

• Additional security and authentication tools to simplify common tasks.
  • Auth2 with a third party.
  • Buildling an OAuth2 single sign-on server.
  • Cookie-based auth.
  • More docs for Bearer tokens.
• Improved dependency overrides for testing.
• Clearer server errors and tracebacks (https://github.com/fastapi/fastapi/pull/14306).
• Docs for liveness and readiness for Kubernetes and others.
• Customization of parsing and serialization (to support more than JSON).
• Errors based on RFC 9457.
• Refactors and simplifications of internal code.
• Improved lifespan support/API.
• Improved middleware support/API.
• Updated SQL tutorials (sync and async) based on SQLModel.
• New NoSQL tutorial.
• Refactor for dependencies, end before response (this was done a while ago, and now it's being reverted as it would break streaming responses, but several things were fixed along the way).
• Performance optimizations.
• Experiments with internal batch processing.
  • E.g. for batch ML inference in the same app.
• Support for both Python v1 and v2 at the same time to make migrations easier: https://fastapi.tiangolo.com/how-to/migrate-from-pydantic-v1-to-pydantic-v2/
• Drop support for Python versions that already reached End of Life, as the time of writing, Python 3.8 and Python 3.9
• Drop support for Pydantic v1 (after adding support for having both v1 and v2 at the same time, so people have an easier way to migrate)

Note

This issue is just to keep anyone interested updated. For individual conversations, comments, requests, questions, please create a separate discussion question. Otherwise, we would end up with a single issue to cover everything and that's not the idea. 😅