RFC: Introduce an Extension/Plugin System to Enable Community-Driven Features

[mortezakarimi]

RFC: Introduce an Extension/Plugin System

Motivation

First of all, thank you for all the work that has gone into this project. I really appreciate the effort that has been invested in building and maintaining it.

While working with the project, I noticed that many users will eventually need functionality that is specific to their own use cases. In many cases, these features are valuable for a subset of users but may not be appropriate for the core project.

Today, the only practical options are usually:

• Fork the project and maintain custom changes.
• Submit every feature as a pull request and hope it fits the project’s roadmap.
• Continuously rebase custom modifications after each update.

All of these approaches increase maintenance costs for both users and maintainers.

Proposal

I would like to propose introducing an official extension (plugin/module) system that allows developers to extend the project without modifying the core codebase.

The goal is not to move existing functionality out of the core, but to define stable extension points where additional functionality can be plugged in.

This would allow developers to:

• Add new features without maintaining a long-lived fork.
• Customize behavior for organization-specific requirements.
• Build integrations with third-party services.
• Experiment with new ideas independently.
• Share extensions with the community.

Benefits for Maintainers

I believe this also provides several long-term advantages for the project itself.

Smaller Core

The core project can stay focused on the features that benefit everyone, while niche functionality lives in extensions.

Lower Maintenance Burden

Maintainers won’t need to review or maintain every specialized feature request. Many ideas can live as community-maintained extensions.

Faster Innovation

Developers can prototype and release features independently without waiting for every change to be merged into the core.

Successful extensions could later be promoted into the core if they prove broadly useful.

Better Upgrade Experience

Instead of maintaining forks with custom patches, users can simply update the project while keeping their extensions isolated.

Healthier Ecosystem

An extension ecosystem often encourages community contributions because developers can build useful functionality without becoming tightly coupled to the project’s internal implementation.

Design Goals

If such a system is introduced, I think it should aim for:

• A stable public extension API.
• Clear lifecycle hooks/events.
• Dependency injection support where appropriate.
• Isolation from internal implementation details.
• Backward compatibility for extension APIs as much as practical.
• Good documentation and examples.

The exact implementation is, of course, open for discussion.

Questions

I’d love to hear the maintainers’ thoughts on this idea.

• Do you think an official extension system aligns with the long-term vision of the project?
• Are there architectural concerns that would make this difficult?
• Would you be open to discussing an RFC for such a system before implementation details are considered?

I’m intentionally keeping this discussion focused on the concept rather than a specific implementation. I think it would be valuable to first determine whether the project considers extensibility an important long-term goal before discussing technical details.