Repository navigation
Replies: 1 comment
|
First of all, I really like PR #70. I think the Extensions system is an excellent step forward, especially the GitHub-based installation, catalogs, package preview, trust confirmation, and lifecycle management. After looking at the implementation, I'd like to suggest a possible next step that builds directly on top of it. I think there is an opportunity to evolve this system from managing external extensions into a foundation for a fully modular OpenStreamMS architecture. Extensions vs. First-Class Components I see an important distinction between two concepts: Extensions add functionality to an existing OpenStreamMS installation. First-Class Components provide the actual functionality of OpenStreamMS itself, but are developed and maintained independently. For example, imagine gradually separating these subsystems: Streaming Host Provider Network Management Device and Gamepad Management Virtual Display Audio Management Session Management Each could eventually have its own repository, maintainers, development cycle, and releases. The main OpenStreamMS repository would remain responsible for the Core: orchestration, dashboard, central API, configuration, and communication between components. Why not use Extensions for everything? The current extension model is a great starting point, but some internal subsystems need deeper integration than scripts can provide. For example, a Streaming Host Provider needs a well-defined interface for starting, stopping, configuring, and monitoring streaming instances. A Network Component needs to communicate with session management and expose network capabilities. A Device Component needs to integrate with device assignment and isolation. These should be first-class integration contracts rather than collections of installation scripts. A possible evolution I would suggest keeping the current Extensions system and gradually introducing a more formal component architecture alongside it. The existing Extension Manager could eventually become part of a broader Component Manager, responsible for both official components and community extensions. This would avoid throwing away the work already done in PR #70. The important distinction would be that official components can integrate deeply with the Core through stable APIs, while community extensions can continue using the existing extension capabilities. The long-term goal OpenStreamMS would no longer need to implement and maintain every subsystem inside one large repository. Developers could work on individual components independently, release improvements without rebuilding the entire application, and maintain alternative implementations. I think PR #70 provides a very good foundation for starting this evolution. Would you consider this distinction between Extensions and First-Class Components as a possible direction for the next architectural stage? |
Uh oh!
There was an error while loading. Please reload this page.
Hi!
Following our previous discussion about the Community Components Manager, I've been thinking about a broader architectural direction that could potentially benefit OpenStreamMS in the long term.
I'd like to share an idea that goes beyond simply allowing community-developed components.
The core idea
What if OpenStreamMS evolved into a modular platform where the main application acts as the central orchestrator, while individual subsystems are developed, maintained, released, and updated independently?
Instead of keeping most functionality inside one increasingly large repository, each major subsystem could have its own dedicated repository.
OpenStreamMS Core would remain responsible for bringing everything together and providing a consistent user experience.
In other words:
Core manages the platform.
Components provide specific functionality.
A standardized interface connects them.
A component manager handles their lifecycle.
Possible component structure
For example:
Streaming Host Providers — Sunshine, Apollo, Vibepollo, and future alternatives.
Network Management — virtual adapters, NAT, bridging, and per-session networking.
Device Management — USB assignment, HID, gamepad isolation.
Virtual Display — RemoteIdd and alternative display implementations.
Session Management — session orchestration and related functionality.
Audio Components — audio capture and routing.
Community Components — independently developed extensions.
These are examples of possible boundaries, not a proposal to immediately create all these repositories.
What would OpenStreamMS Core do?
The Core would provide:
Dashboard and user interface.
Central service and API.
Component discovery and management.
Communication between components.
Dependency and compatibility management.
Component installation, updates, and removal.
Version management and rollback.
Security and integrity verification.
The Core should not need to know the internal implementation details of every component. It should interact with them through documented and stable interfaces.
Why I think this matters
This architecture could make OpenStreamMS much easier to develop and maintain.
A developer working on network isolation would not need to modify the streaming subsystem.
Someone improving Apollo integration could release a new provider without requiring a complete OpenStreamMS release.
Community developers could create extensions without maintaining a fork of the entire project.
Users could install only the functionality they actually need.
Most importantly, individual components could evolve at different speeds without forcing the whole platform to move together.
A gradual transition
I'm not suggesting rewriting or splitting the entire project immediately.
A reasonable approach could be:
Define the Core/component boundary.
Design a stable Component API.
Introduce a basic Component Manager.
Extract one relatively independent subsystem as a proof of concept.
Validate independent development, installation, updates, and rollback.
Gradually apply the architecture to other subsystems.
I see this as an evolution of OpenStreamMS rather than a rewrite.
The main question I'd like to discuss is:
Would you consider evolving OpenStreamMS from a single application with integrated subsystems into a modular platform where independently maintained components work together through a common Core?
I believe this could become a very strong foundation for the project's future.
All reactions