We’ve updated the Synergy Roadmap to keep you looped in on our upcoming plans for Synergy/DE. While the extended roadmap continues to evolve, work is already underway on several exciting new features. Please keep in mind that this roadmap is a way for us to share our intentions with you, and no plans are set in stone until they’re included in a release. You can always find the latest incarnation of the roadmap on our website.
Focus Areas
We plan to concentrate on the following areas:
- Legacy app modernization
- High availability and resilience
- Data visibility
- CI/CD enablement
- Providing access to current technologies
- Making it easier to run code in .NET
- Distributed computing
- Development environment optimization
- Repository development experience
- Enhancing reliability and delivery of Synergy apps
Synergy/DE Runtimes, Databases, and Connectivity
What we’re working on NOW for delivery in an upcoming release
- LTTng support on Linux (available now in the 12.4 feature release)
Runtime performance profiling for Synergy programs—the ability to trace all routine calls and ISAM I/O—with LTTng can significantly reduce the time it takes to resolve system performance issues. - CI/CD for all Synergy products across all platforms
Continuous integration and delivery enables us to respond to customer issues with greater agility, improves the breadth and depth of our automated testing procedures, allows us to release new versions across all supported platforms simultaneously, and more. - High availability for customer applications
The ability to expand ISAM record length and add or remove keys while a file is in use increases resilience and reduces the amount of downtime required for file maintenance. - Support for .NET 9+
According to Microsoft, .NET 9 has a special focus on cloud-native apps and improved performance.
What we’re planning to implement NEXT
- Technical debt cleanup
We’re continuously looking for ways to minimize technical debt in our code and processes. - Thread-local environment variables
Because thread-local variables are specific to a particular thread, changes that one thread makes to the variable don’t affect its value in other threads. This improves thread safety and performance, especially in highly concurrent environments.
What we’re considering for LATER
- Select class TEMP tables
Extending the capabilities of the Select class by introducing the concept of TEMP tables could provide you with high-speed access to the static results of a pre-executed query. - New thread-safety warning mechanisms
Running code in a multi-threaded environment brings new challenges for aspects of your code that isn’t thread safe. We hope to implement new mechanisms to warn you when you use non-thread-safe features. - ISAM auto-reindex logging
As part of our ISAM enhancements, we’d like to provide more information when ISAM auto-reindexing operations occur. - Next generation ISAM
We’d like to become less reliant on some of the file system coordination that currently occurs in every running process.
Synergy DBL Integration (SDI) and Compilers
What we’re working on NOW for delivery in an upcoming release
- More resilience for Visual Studio updates
We’re working to better equip SDI to handle API and other changes introduced by Microsoft in new minor Visual Studio versions so you can continue to upgrade to the latest VS version without running into issues. - Support for .NET 9+
According to Microsoft, .NET 9 has a special focus on cloud-native apps and improved performance. - Internal DevOps infrastructure enhancements
We continue to improve the systems, tools, and processes that support our DevOps methodology, especially in the areas of automation, integration, and security. - Migration from MPF to CPS
Following best practices, we’re revamping our underlying project system to use Common Project System instead of Managed Package Framework to provide more stability and better performance. - .NET support for Multiple Mainline project type
Multi-mainline projects avoid the scenario where building an application could require hundreds of projects—or more. It will also be possible to configure multi-mainline projects to define complex relationships between source files and correctly build multiple binaries. - .NET compiler feature parity with traditional Synergy
To make migrating to .NET even easier, we continue to enhance Synergy .NET features for greater consistency with traditional Synergy. - Performance improvements for large Visual Studio solutions
We’re working to enhance editor and build performance for larger VS solutions.
What we’re planning to implement NEXT
- Support VS 2025+
When Visual Studio 2025 arrives, we’ll be ready! - Static code analysis for Synergy DBL
Static code analysis is a debugging method that examines code to identify problems without running it. It helps enforce coding guidelines, locate and fix vulnerabilities early, improve code quality, and minimize debugging time. - Repository schema IntelliSense
We’d like to add full-fidelity IntelliSense, possibly with schema editing via Language Server Protocol, when working with the Synergy data language in Synergy Repository schema files. Our goal is to make it easier to edit and export individual structures or other entities when working in the Repository UI. - Repository UI to edit/export specific file, structure, etc.
We hope to improve the developer experience when working with Repository by making it possible to automatically export the whole repository using schema files. - CI/CD for Synergy tools on Linux
Continuous integration and delivery enables us to respond to customer issues with greater agility, improves the breadth and depth of our automated testing procedures, and allows us to release new versions on Linux more quickly.
What we’re considering for LATER
- Compiler performance optimization
We’d like to enhance the efficiency of the compiler to reduce build times, streamline resource usage, and improve overall system performance and IDE responsiveness. - Improved Synergy .EditorConfig experience in Visual Studio
Our .EditorConfig file currently supports defining things like indentation rules on a project-by-project or directory-by-directory basis, but we hope to support many additional coding styles. - .NET support for DI in legacy code to break circular references
Dependency injection is a design pattern that provides class dependencies from the outside, instead of allowing the class to create them internally, to prevent circular references. This strategy helps manage complex object relationships and improve code maintainability. - Traditional Synergy NuGet support
We’d like to extend support of the NuGet package manager to traditional Synergy. NuGet client tools facilitate creating and consuming libraries as packages.