by Marco Cantu, David Millington and Sarina DuPont
Table of Contents
The Embarcadero RAD Studio product management team regularly updates the product development roadmap for Delphi, C++Builder, and RAD Studio. As you can see in our official roadmap blog post, we have just released a new version of the roadmap, covering the key features that we’ve planned for the next 12 months. Along with the official roadmap slides, we wanted to offer more details, information and insight with this additional blog post. You may find it useful to open the slides for reference while reading the expanded information we provide here.
In our roadmap, you can find the key features that we’ve planned for calendar year 2021. Before we get to the details of our updated roadmap, we want to recap what we’ve delivered so far.
Early this year, we released 10.4 Sydney. The 10.4 release was very well received by our customers and included the first delivery of our complete rewrite of the Delphi Code Insight engine, now based on the Language Server protocol architecture, a new debugger for C++ Win64, which addressed a very long standing customer request, and new Delphi language features such as custom managed records. We also significantly expanded the use case of VCL styles with support for HighDPI monitors and per-control styling.
We followed up on the 10.4 Sydney release with 10.4.1 in September 2020, which was primarily focused on quality and further improvements of the features delivered in 10.4, in particular the newly added Delphi LSP support. 10.4.1 includes over 800 quality improvements, including 500+ quality improvements for publicly reported issues in Embarcadero’s Quality Portal.
Before we get into details on the 10.4.2 and 10.5 releases, we wanted to highlight that 10.4/10.4.1 has been one of our most popular releases to date, with more downloads compared to both 10.3 and 10.2. This is especially impressive in the midst of COVID-19. We attribute the success to both the release and our increased engagement with technology partners who continue to collaborate with our team to upgrade and develop new features. We also want to thank, you, our customers for the great feedback you have been providing to the product team, in terms of features you’d like to see added and areas you’d like us to focus on for quality, and your participation in our beta programs (which is one of the benefits of being on subscription).
Currently, we are working on the 10.4.2 release, planned for the first part of calendar year 2021 and detailed in the roadmap and in this commentary blog post. Some time before the release, we expect to invite RAD Studio, Delphi, and C++Builder customers with an active update subscription to join beta testing for the coming release. The 10.4.2 beta will be an NDA beta, requiring participants to sign our non-disclosure agreement before being able to participate in the beta. Being able to join betas and participate in providing feedback to product management early on in the development cycle is one of the benefits of being current on update subscription.
For 10.5, we plan to introduce a new target platform for Delphi, macOS ARM (based on Apple Silicon CPUs), significant work around IDE HighDPI support, C++ toolchain extensions, and many other additional features and quality enhancements. See below for more details.
RAD Studio Roadmap Timeline
Before we get to the details of the features the development team is working on today or researching for the future, let’s take a look at the timeline of the coming releases as shown in the main slide of the roadmap:
David’s Commentary of 10.4.2 Plans
Delphi Code Insight
As Marco wrote above, in 10.4.1 we focused heavily on quality. That continues in 10.4.2, with one area of significant work being the new Delphi Code Insight (aka Delphi LSP.) Not only will 10.4.2 include many fixes and tweaks, as well as less commonly used code insight features that we did not include in the initial version, but also some new or significantly improved features in code completion. For example, we plan to add ctrl-click on ‘inherited’, as well as reworked completion in ‘uses’ clauses, among others.
C++ Code Insight
C++ continues the theme of ongoing quality work as well, with a focus on two areas.
The most noticeable to all C++ customers will be a full revision of C++ code completion when using the Clang compilers. In 10.3, when we upgraded to C++17, we had to replace the code completion technology the IDE used. Since its introduction, we’ve been enhancing code completion in each release, addressing use cases where specific code patterns or project setups could cause issues for completion.
For 10.4.2, we decided to undertake a full overhaul of code completion for C++, to provide the developer productivity customers are looking for. C++ customers should find that code completion and navigation works reliably and well.
We’ve even been addressing some more difficult cases, such as providing completion in a header file (much harder than in a .cpp file)! The end result should be everything you have asked us for.
C++ Quality and Exception Handling
The other significant quality focus for C++ in 10.4.2 is around exception handling.
Exception handling is a complex area, requiring close interop between the compiler and RTL to work correctly. There are common conventions for exceptions, such as never allowing an exception to cross a module boundary (e.g. be thrown in a DLL but caught in an EXE), but these are not always followed, sometimes for good reasons. In C++ we need to handle C++ exceptions, OS exceptions, and SEH, not forgetting Delphi’s exception handling as well.
In 10.4.2, we have overhauled the exception handling system. As we get closer to release, look forward to a blog post detailing the scenarios we support. Internally, we are seeing some great improvements currently!
In addition to the focus on code completion for both languages, the IDE has some other work planned for 10.4.2.
In 10.3, we introduced the current two themes, a light and dark style (in fact, a dark style, though significantly different, was first introduced in 10.2.3. It was one of our most popular features.) The Light style is predominantly pale blue. This release, we’re adding a third style, one which uses traditional grey not blue for the main colours. Consider it a retro style for those who like how the IDE looked around the 2010-XE7 era, a callback to the classic look. We also believe it may be useful for those requiring special eyesight accommodations.
We also plan further quality work around desktop layouts, multi-monitor layouts, form designing, and similar areas. This includes allowing you to design your form in the form designer at the same time as having the code for that form open. From feedback, this was the most common reason for using the old undocked designer, which we removed in 10.4.1, and we’re glad to let you both code and design in a form unit using the modern designer.
Finally, we want to enhance the Settings Migration Tool, to help move RAD Studio settings from version to version (like from 10.3 to 10.4) and to better preserve your configuration when moving to an update release (like from 10.4.1 to 10.4.2). We plan on adding specific preset configurations for each scenario and including configuration files in addition to registry settings considered today.
Marco’s Commentary of 10.4.2 Plans
In terms of target operating systems, we are currently focused on improving the existing platforms supported in 10.4.x, and there are two focus areas we are working on for 10.4.2.
The first is part of our continuous focus on Windows as our primary target. On the Microsoft operating system, we are following closely the current Microsoft direction of unifying the WinRT API and the traditional Win API, via Project Reunion. Project Reunion (https://github.com/microsoft/ProjectReunion) comprises different technologies, the initial ones being WinUI 3, WebView2 and MSIX.
The WebView2 control is a new Windows platform component embedding Edge Chromium. We have delivered support for this feature in 10.4 with the TEdgeBrowser VCL component.
The second building block will be the support for the MSIX packaging format we are planning for 10.4.2. MSIX is the successor of APPX, a target we currently offer as part of the RAD Studio IDE Desktop Bridge integration, and is meant for Microsoft Store and for enterprise deployment.
Another area of our improved support for the Windows platform, and in particular for VCL applications, is the addition of two new controls aimed at helping our customers modernize and improve the UX of their applications. We are working on new VCL Native Windows Controls, so that you can provide a more modern UI to your customers:
- One is a highly optimized virtual list view, which will allow you to display a large number of items with a flexible combination of text and graphics. The control will be loosely based on the approach of the existing DBCtrlGrid control, but without requiring a data source. It will support using Live Bindings.
- The other new VCL component we are adding is a numeric input control, similar to the WinUI NumberBox platform control. This control provides easier and smoother numeric input, taking into account different formats (integers, floating point numbers, currency values) and also including simple expressions evaluation.
The second part of our improvements is focused on the currently supported target platforms. We plan to deliver full compatibility with new versions of operating systems released by Apple and Google after RAD Studio 10.4.1 went out. While you can target these platforms today, there are a few open issues that we want to address properly (rather than via workarounds). The goal is to have complete support for:
- iOS 14 and iPadOS 14 (Delphi and C++)
- macOS 11.0 Big Sur (Intel) (Delphi)
- Android 11 (Delphi)
In terms of quality, we’ll continue with a significant effort on stability, performance and quality in 10.4.2 (like we did in 10.4.1). We plan addressing customer reported issues and support escalations in many areas of the product. Tools and libraries we are particularly going to focus on, in addition to those listed by David earlier, include:
- The Delphi compiler (for all platforms) to improve its robustness and backwards compatibility, but a particular and deep focus on the compiler (and linker) performance to reduce compilation time for large projects and also speed up the LSP engine (which uses the compiler to analyze the source code).
- The SOAP Client library along with the WSDL import tool that generates the client code used to interface with SOAP servers
- The Parallel Programming Library (PPL), which offers a great abstraction of the different platforms and multi core CPUs threading capabilities, in terms of tasks, futures, and parallel for loops
- The Multi tier web service solutions part of RAD Studio, with improvements both to RAD Server and to the older DataSnap engine, and general improvements to the HTTP and REST client libraries. We are also going to continue focusing on our Azure and AWS cloud support.
- VCL Styles and HighDPI Styles are going to received extra attention, along with VCL in general
- For the FireMonkey library we are continuing to improve the TMemo components (in both the platform and styled versions), the Metal GPU library driver introduced in 10.4, and rework sensor management on Android, to offer better support for a variety of Android devices.
RAD Studio 10.5
For reference, here is the main roadmap slide again:
David’s Commentary of 10.5 Plans
We have a number of great new features, ones looked forward to by many customers, planned for 10.5.
First is that we plan full high DPI support in the IDE. The VCL has supported high DPI for a couple of releases now, and the RAD Studio IDE, which mostly uses the VCL, will now support high DPI as well. This ensures it will render crisply across all modern high resolution screens, including as you move windows across screens with different resolutions and scales.
The VCL form designer is one of the key tools you use when creating your app. The point of the designer is to quickly build a UI seeing close to how it will look when your app is run, in contrast to UI tools that describe a UI only in text and provide no immediate feedback / iteration loop. In 10.5, we plan to extend that element of looking similar to how your app will look when run by adding VCL style support to the designer, so when any of your controls are styled, you will see them styled in the designer as well.
The FMX form designer is similarly a key tool when you build a cross-platform application. We plan to bring across some of the design tools the VCL designer has, such as alignment guides, to ensure the designer has the productivity features you need.
We also plan to focus on the IDE’s source control integration, to assist your team’s collaboration. In addition, we plan some enhancements to how the IDE is presented when first run, to assist those new to Delphi and C++Builder to get started.
Finally, many customers use Delphi or C++Builder on a dedicated build server. Along with source control, tests, and similar practices, it’s good practice to have official builds happen on a specific machine or VM. Currently, to install RAD for a build server, you need to install the full IDE – but this should not be required, because building only needs the command-line tools. We plan an installer scenario specifically for build servers.
In 10.4.0, we introduced a new debugger for C++ Win64. This addressed a common customer request, especially because we included ‘formatters’, a way to easily evaluate the contents of STL containers or any data structure, including your own. This was a completely new debugger, not a new version of the one we previously used. In 10.5, we plan a similar new replacement for another core tool, the linker. Like the debugger, this will be for Win64.
You’ll notice a focus on 64-bit Windows here. Many customers are using Clang in order to target Win64, and we want to ensure our tooling is on par or better than the tooling you may be used to from the classic compiler. In addition, many people are starting to look at 64-bit exclusively, with 32-bit apps being upgraded and new apps being 64-bit only.
Visual Assist is an amazing productivity extension for Visual C++, giving code completion, refactorings, and more. We’ve been researching various ways to integrate it into C++Builder, and plan to do this in 10.5.
Finally, we also plan to improve Delphi/C++ interop. Being able to use two languages is a big productivity boost and one of the key reasons to use C++Builder or RAD Studio, and this is work to polish that integration. It should provide smoother integration with RTL features.
In 10.4, we introduced an entirely new debugger for C++ Win64 (noted above) based on LLDB. Ultimately, we aim to use the same debugger across all platforms – today we use a mix of different debuggers. Key to this is to add a Delphi language frontend to LLDB, which allows you to evaluate Delphi syntax in, for example, the Evaluate/Modify dialog. We plan to introduce the first platform using LLDB with this new frontend in 10.5.
Marco’s Commentary of 10.5 Plans
Regarding the Windows platform, as mentioned earlier, we plan on offering support for the various technologies that are part of Microsoft Project Reunion. In particular, in the RAD Studio 10.5 release, we are looking forward to integrating the support for modern Windows UX via the WinUI 3 library. According to Microsoft’s roadmap for the library, it should become possible to use the components of this library in a native application based on the classic API, mixing forms and controls of different types. The actual details will depend on what the library will deliver in terms of integration with native applications, but our current plan is to integrate this library in the VCL with new specific controls.
Speaking of platforms, we want to add a new target for Delphi applications: a new compiler for the ARM-based version of the macOS operating system with Apple hardware powered by Apple Silicon CPUs. While you can run Intel applications, the goal is to have a native ARM application for the new generation of Macs.
This will be a significant extension of Delphi, including a new compiler, updates to the runtime library and the various high level libraries. We have also plans to expand the Delphi language syntax for all platforms and improve the performance of the math processing code the compiler generates on Windows, making applications faster in numeric processing.
We’ll also continue to work on the overall product quality and plan on selecting a few subsystems to focus on, a decision we’ll take by evaluating customers’ feedback for the current release and coming updates.
We have some great plans for the upcoming releases of Delphi, C++Builder and RAD Studio! From exciting changes to code completion for both languages, to a high DPI IDE, productivity enhancements when coding and designing, Windows UI and new VCL components, Delphi debugging, Apple Silicon (M1) support for Delphi, quality work for the compilers, Delphi and C++ RTL, SOAP, multi-tier and more, a new linker for C++ — the upcoming releases contain some really exciting work. We can’t wait to get them to you!
Note: These plans and roadmap represent our intentions as of this date, but our development plans and priorities are subject to change. Accordingly, we can’t offer any commitments or other forms of assurance that we’ll ultimately release any or all of the described products on the schedule or in the order described, or at all. These general indications of development schedules or “product roadmaps” should not be interpreted or construed as any form of a commitment, and our customers’ rights to upgrades, updates, enhancements and other maintenance releases will be set forth only in the applicable software license agreement.