You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
{{ message }}
Repository navigation
Proposal: Stride as a Composable Game Development Ecosystem
#3578
I've been looking into Stride's architecture and ongoing editor modernization, and I wanted to suggest a possible long-term direction that I think could make Stride particularly interesting among open-source game engines.
Before writing this proposal, I looked through several existing discussions, particularly:
It's encouraging to see that several of the ideas below have already been explored by the community, sometimes in considerable detail. I don't intend to duplicate or replace that work.
Rather, I'd like to explore whether these existing efforts could form part of a broader architectural vision: evolving Stride from a modular game engine into the foundation of a composable game-development ecosystem.
The central idea would be that developers could assemble their ideal game engine from independently maintained, interchangeable components, while Stride would continue to offer a cohesive, ready-to-use experience out of the box.
Rather than competing primarily with Godot, Unity, or Unreal on the completeness of a traditional integrated engine, Stride could differentiate itself through interoperability, architectural flexibility, and reuse.
1. Independently Reusable Runtime Components
Where practical, engine subsystems could be structured as independent libraries with clearly defined responsibilities and minimal unnecessary coupling.
Rendering, physics, audio, animation, networking, simulation scheduling, and other subsystems could expose small, versioned interfaces rather than depending directly on specific implementations elsewhere in the engine.
Replace certain subsystems with alternative implementations.
Integrate existing third-party libraries without extensive engine-specific modifications.
Allow improvements to individual components to benefit multiple projects, potentially even across different engines.
Not every subsystem would need to become independent, and some coupling will always be justified. The goal would be to identify natural architectural boundaries and gradually strengthen them.
Ideally, the ecosystem would encourage developers to contribute improvements to common reusable components rather than repeatedly implementing similar infrastructure for individual games.
I believe this could be especially valuable in the long term. As development tools become more capable, including AI-assisted programming, implementing custom infrastructure may become cheaper. However, I'd much rather see those improvements directed toward shared, reusable components than toward repeatedly reinventing the same systems for individual projects.
2. A Composable Development Environment
I think the ongoing editor modernization offers an especially interesting opportunity.
Rather than having the editor intrinsically understand every supported engine subsystem, it could gradually evolve toward a capability-driven plugin architecture.
For example, a physics component could optionally provide:
Inspectors for physical properties.
Collision-shape editing tools.
Visualization and debugging capabilities.
Asset importers or exporters.
Declarations of the interfaces and services it requires.
The editor could discover these capabilities and integrate the appropriate tools without requiring each component to have bespoke integration in the editor's core.
Crucially, a component's runtime functionality and its editor integration could remain separate packages. A dedicated server or headless simulation wouldn't need to load editor dependencies.
In the longer term, it might even be possible for the editor to support components that do not use Stride's runtime at all.
This could make the development environment valuable independently of the engine itself.
I recognize that the existing editor discussions, especially #1031 and #1120, already explore important parts of this approach. My suggestion is mainly to consider how those efforts might eventually support interoperability beyond Stride-specific extensions.
One potential danger of modular architectures is that they can become monolithic in practice if every component must depend on the same underlying ECS, scene graph, serializer, or scheduling implementation.
It might therefore be worth defining a relatively small collection of interoperability contracts around capabilities rather than concrete implementations.
Possible examples include:
Asset identification and referencing.
Versioned serialization.
Runtime inspection and diagnostics.
Editing operations and undo/redo.
Component capability discovery.
Scheduling requirements and dependencies.
These interfaces should ideally remain optional wherever appropriate.
The goal wouldn't be to standardize every aspect of game development or impose one universal architecture. Different games have fundamentally different requirements, and flexibility is one of the reasons to pursue composability in the first place.
Instead, components could communicate through well-defined boundaries while retaining substantial freedom over their internal implementation.
I also think it would be important to avoid creating unnecessary abstraction layers. The interfaces should emerge from actual interoperability requirements rather than attempting to anticipate every possible future implementation.
4. Long-Term Language Independence
Although C# and .NET are major strengths of Stride, I think it would be interesting to consider eventually allowing components to use their preferred implementation languages.
For example, a physics engine implemented in Rust, a renderer implemented in C++, or a specialized simulation library written in another language could participate through stable, language-neutral interfaces.
This wouldn't require abandoning .NET or making Stride's own implementation language-independent.
Rather, Stride could remain a .NET-first development environment without making .NET a mandatory dependency for every participating component.
A possible gradual approach would involve stable native interfaces, capability manifests, and standardized interoperability mechanisms where justified.
Naturally, cross-language interoperability introduces complexity involving memory ownership, object lifetimes, threading, error handling, and ABI compatibility. These concerns would need careful consideration.
I wouldn't suggest implementing such infrastructure immediately. The main idea is to avoid unnecessarily designing component boundaries around assumptions that would permanently prevent language-neutral interoperability.
Ultimately, some components might even become reusable across different game engines and development environments.
5. AI-Assisted Development and Integration
I also think composability could become increasingly important as AI-assisted software development matures.
Clear component boundaries, machine-readable capability descriptions, versioned interfaces, and automated compatibility tests would make it easier for AI agents to:
Discover suitable components for a project's requirements.
Integrate independently maintained libraries.
Generate and maintain adapters where necessary.
Identify compatibility issues.
Implement new components against existing contracts.
Run automated tests and validate integration.
I don't think the ideal future involves AI repeatedly rebuilding entire game engines for individual projects.
It would be much more beneficial if AI made existing open-source components easier to discover, reuse, maintain, and improve.
A composable ecosystem could provide an excellent foundation for this while remaining completely usable without AI.
This could also create opportunities for more automated compatibility testing, documentation maintenance, and validation of component integrations, provided that the resulting work meets the project's quality standards.
6. Ready-to-Use Distributions
One concern with highly modular software is that developers may be forced to select and configure dozens of components before they can accomplish anything useful.
I don't think composability should come at the expense of convenience.
Stride could continue offering its current integrated experience, while potentially providing curated component bundles for common use cases.
For example:
A general-purpose 3D game configuration.
A lightweight 2D configuration.
A simulation-oriented configuration.
A multiplayer-focused configuration.
These would be convenient starting points rather than mandatory architectural commitments.
Developers who just want to make a game could use a complete, supported configuration. Developers with specialized needs could progressively replace components or construct their own combinations.
Compatibility testing and documented supported configurations would be particularly important here.
Ideally, the same independently maintained components could participate in multiple distributions without requiring forks or engine-specific modifications.
7. Incremental Evolution Rather Than a Rewrite
I realize this is a substantial vision, especially for a community-maintained project with limited development resources.
I'm not suggesting a large architectural rewrite or that all existing systems should be broken into independent packages.
Instead, I think it might be valuable to consider composability as a long-term architectural principle when making future design decisions.
Possible early steps could include:
Identifying existing subsystems with naturally reusable boundaries.
Separating runtime functionality from optional editor tooling.
Designing editor extension points around capabilities.
Avoiding unnecessary dependencies on particular implementations.
Establishing compatibility and conformance tests for selected interfaces.
Experimenting with one independently reusable component as a proof of concept.
The actual scope should be driven by maintainers' priorities, available resources, and demonstrated practical value.
There are legitimate trade-offs here. Stable interoperability contracts impose maintenance obligations, cross-language support introduces complexity, and excessive abstraction can become counterproductive.
I wouldn't want the pursuit of modularity to make ordinary game development harder.
The objective should be to create additional architectural freedom without sacrificing Stride's existing strengths.
Closing Thoughts
I think Stride has an opportunity to differentiate itself as more than another open-source alternative to the major commercial engines.
Its .NET foundation, existing modularity, and ongoing editor development seem like promising starting points for a broader ecosystem built around reusable, interoperable game-development technology.
The long-term vision would be a development environment that remains convenient for ordinary game development while allowing advanced users to assemble, replace, and extend their underlying technology with considerably more freedom.
Stride could become not merely an engine developers build games with, but an ecosystem of components developers build engines from.
I'm curious whether this direction aligns with the maintainers' existing vision, whether elements of it are already planned, and what technical or organizational obstacles they foresee.
I'd especially appreciate thoughts on whether the current editor modernization could provide a foundation for this kind of composability without adding unreasonable complexity to the project.
If this direction resonates with the maintainers and aligns with their vision for Stride, I'd be more than happy to actively participate and contribute to making it a reality.
At the same time, I fully respect that Stride is an established community project with its own priorities and direction. My intention isn't to impose my vision on someone else's project, nor am I looking to start a competing project of my own.
I'd much rather contribute to something we can build together, provided there's genuine shared interest in pursuing it.
reacted with thumbs up emoji reacted with thumbs down emoji reacted with laugh emoji reacted with hooray emoji reacted with confused emoji reacted with heart emoji reacted with rocket emoji reacted with eyes emoji
Uh oh!
There was an error while loading. Please reload this page.
I've been looking into Stride's architecture and ongoing editor modernization, and I wanted to suggest a possible long-term direction that I think could make Stride particularly interesting among open-source game engines.
Before writing this proposal, I looked through several existing discussions, particularly:
It's encouraging to see that several of the ideas below have already been explored by the community, sometimes in considerable detail. I don't intend to duplicate or replace that work.
Rather, I'd like to explore whether these existing efforts could form part of a broader architectural vision: evolving Stride from a modular game engine into the foundation of a composable game-development ecosystem.
The central idea would be that developers could assemble their ideal game engine from independently maintained, interchangeable components, while Stride would continue to offer a cohesive, ready-to-use experience out of the box.
Rather than competing primarily with Godot, Unity, or Unreal on the completeness of a traditional integrated engine, Stride could differentiate itself through interoperability, architectural flexibility, and reuse.
1. Independently Reusable Runtime Components
Where practical, engine subsystems could be structured as independent libraries with clearly defined responsibilities and minimal unnecessary coupling.
Rendering, physics, audio, animation, networking, simulation scheduling, and other subsystems could expose small, versioned interfaces rather than depending directly on specific implementations elsewhere in the engine.
This could make it possible to:
Not every subsystem would need to become independent, and some coupling will always be justified. The goal would be to identify natural architectural boundaries and gradually strengthen them.
Ideally, the ecosystem would encourage developers to contribute improvements to common reusable components rather than repeatedly implementing similar infrastructure for individual games.
I believe this could be especially valuable in the long term. As development tools become more capable, including AI-assisted programming, implementing custom infrastructure may become cheaper. However, I'd much rather see those improvements directed toward shared, reusable components than toward repeatedly reinventing the same systems for individual projects.
2. A Composable Development Environment
I think the ongoing editor modernization offers an especially interesting opportunity.
Rather than having the editor intrinsically understand every supported engine subsystem, it could gradually evolve toward a capability-driven plugin architecture.
For example, a physics component could optionally provide:
The editor could discover these capabilities and integrate the appropriate tools without requiring each component to have bespoke integration in the editor's core.
Crucially, a component's runtime functionality and its editor integration could remain separate packages. A dedicated server or headless simulation wouldn't need to load editor dependencies.
In the longer term, it might even be possible for the editor to support components that do not use Stride's runtime at all.
This could make the development environment valuable independently of the engine itself.
I recognize that the existing editor discussions, especially #1031 and #1120, already explore important parts of this approach. My suggestion is mainly to consider how those efforts might eventually support interoperability beyond Stride-specific extensions.
3. Small, Implementation-Neutral Interoperability Contracts
One potential danger of modular architectures is that they can become monolithic in practice if every component must depend on the same underlying ECS, scene graph, serializer, or scheduling implementation.
It might therefore be worth defining a relatively small collection of interoperability contracts around capabilities rather than concrete implementations.
Possible examples include:
These interfaces should ideally remain optional wherever appropriate.
The goal wouldn't be to standardize every aspect of game development or impose one universal architecture. Different games have fundamentally different requirements, and flexibility is one of the reasons to pursue composability in the first place.
Instead, components could communicate through well-defined boundaries while retaining substantial freedom over their internal implementation.
I also think it would be important to avoid creating unnecessary abstraction layers. The interfaces should emerge from actual interoperability requirements rather than attempting to anticipate every possible future implementation.
4. Long-Term Language Independence
Although C# and .NET are major strengths of Stride, I think it would be interesting to consider eventually allowing components to use their preferred implementation languages.
For example, a physics engine implemented in Rust, a renderer implemented in C++, or a specialized simulation library written in another language could participate through stable, language-neutral interfaces.
This wouldn't require abandoning .NET or making Stride's own implementation language-independent.
Rather, Stride could remain a .NET-first development environment without making .NET a mandatory dependency for every participating component.
A possible gradual approach would involve stable native interfaces, capability manifests, and standardized interoperability mechanisms where justified.
Naturally, cross-language interoperability introduces complexity involving memory ownership, object lifetimes, threading, error handling, and ABI compatibility. These concerns would need careful consideration.
I wouldn't suggest implementing such infrastructure immediately. The main idea is to avoid unnecessarily designing component boundaries around assumptions that would permanently prevent language-neutral interoperability.
Ultimately, some components might even become reusable across different game engines and development environments.
5. AI-Assisted Development and Integration
I also think composability could become increasingly important as AI-assisted software development matures.
Clear component boundaries, machine-readable capability descriptions, versioned interfaces, and automated compatibility tests would make it easier for AI agents to:
I don't think the ideal future involves AI repeatedly rebuilding entire game engines for individual projects.
It would be much more beneficial if AI made existing open-source components easier to discover, reuse, maintain, and improve.
A composable ecosystem could provide an excellent foundation for this while remaining completely usable without AI.
This could also create opportunities for more automated compatibility testing, documentation maintenance, and validation of component integrations, provided that the resulting work meets the project's quality standards.
6. Ready-to-Use Distributions
One concern with highly modular software is that developers may be forced to select and configure dozens of components before they can accomplish anything useful.
I don't think composability should come at the expense of convenience.
Stride could continue offering its current integrated experience, while potentially providing curated component bundles for common use cases.
For example:
These would be convenient starting points rather than mandatory architectural commitments.
Developers who just want to make a game could use a complete, supported configuration. Developers with specialized needs could progressively replace components or construct their own combinations.
Compatibility testing and documented supported configurations would be particularly important here.
Ideally, the same independently maintained components could participate in multiple distributions without requiring forks or engine-specific modifications.
7. Incremental Evolution Rather Than a Rewrite
I realize this is a substantial vision, especially for a community-maintained project with limited development resources.
I'm not suggesting a large architectural rewrite or that all existing systems should be broken into independent packages.
Instead, I think it might be valuable to consider composability as a long-term architectural principle when making future design decisions.
Possible early steps could include:
The actual scope should be driven by maintainers' priorities, available resources, and demonstrated practical value.
There are legitimate trade-offs here. Stable interoperability contracts impose maintenance obligations, cross-language support introduces complexity, and excessive abstraction can become counterproductive.
I wouldn't want the pursuit of modularity to make ordinary game development harder.
The objective should be to create additional architectural freedom without sacrificing Stride's existing strengths.
Closing Thoughts
I think Stride has an opportunity to differentiate itself as more than another open-source alternative to the major commercial engines.
Its .NET foundation, existing modularity, and ongoing editor development seem like promising starting points for a broader ecosystem built around reusable, interoperable game-development technology.
The long-term vision would be a development environment that remains convenient for ordinary game development while allowing advanced users to assemble, replace, and extend their underlying technology with considerably more freedom.
Stride could become not merely an engine developers build games with, but an ecosystem of components developers build engines from.
I'm curious whether this direction aligns with the maintainers' existing vision, whether elements of it are already planned, and what technical or organizational obstacles they foresee.
I'd especially appreciate thoughts on whether the current editor modernization could provide a foundation for this kind of composability without adding unreasonable complexity to the project.
If this direction resonates with the maintainers and aligns with their vision for Stride, I'd be more than happy to actively participate and contribute to making it a reality.
At the same time, I fully respect that Stride is an established community project with its own priorities and direction. My intention isn't to impose my vision on someone else's project, nor am I looking to start a competing project of my own.
I'd much rather contribute to something we can build together, provided there's genuine shared interest in pursuing it.
All reactions