2018 has been a very exciting year so far for Embarcadero. In our roadmap, you can find the key features that we’ve planned for calendar year 2018/2019. Before we get to the details of our updated roadmap, we wanted to recap what we’ve delivered so far:

Back in March, we introduced RAD Studio 10.2.3, also known as 10.2 Tokyo Release 3, of Delphi, C++Builder and RAD Studio. This was the third release of Tokyo, and included CMake Command Line Support for C++, Rename Refactoring, Mobile support in Delphi and C++Builder Pro, RAD Server enhancements, FireMonkey User Interface Templates and more. 

Just last month, for the first time ever, we launched a full featured Community Edition for Delphi and C++Builder. Not only is it great for new developers, but our existing community can look forward to the next generation of knowledgeable Delphi developers picking up the torch and furthering their legacy with new Delphi projects. This is also true for C++Builder, since Community Edition provides a great entry point for C++ developers around the world to experience all that C++Builder has to offer, especially in terms of our multi-platform capabilities.   

As you will see in our roadmap, we have a lot of exciting features planned for the next major version release, 10.3 (aka Carnival), with the themes for the release being Language and Platform Enhancements for Multi-Device and Windows Developers. The modernization of the IDE will also continues at full pace.

We wanted to take this opportunity to share with you more details on several key focus areas outlined in our updated roadmap. 


More Details from Sarina DuPont

Sarina focuses on FireMonkey, the component libraries’ UX and styles, the installation experience and demos and documentation  

FireMonkey Z-Order and Native Controls

One of my focus areas since I started at Embarcadero back in 2011 has been FireMonkey. I’m very passionate about what developers can do with the FireMonkey framework to deliver on their multi-device application requirements. If you’ve been following my blog, you’ve seen that building stunning UIs with FMX is a theme carried through many of my posts. It’s an area where FireMonkey really shines, and combined with our FireUI designer, a very unique offering in the developer tools space.

The FireMonkey UI Templates that we released over the past several months for Delphi and C++Builder developers not only make it easy to get started building your own multi-platform applications, but they also showcase the flexibility that FireMonkey provides, and how to easily tweak UI themes to create a totally custom look and feel.  

For several years, we’ve gotten customer requests for Z-order and native controls support on Android. We’ve heard your requests and are actively working on Android Z-Order support in 10.3. This will allow developers to use FireMonkey styled controls such as buttons, labels and checkboxes with natively rendered controls like the browser and map control on the same form without the native control covering the styled control. This also provides the foundation for supporting natively rendered UI controls, such as TEdit, on Android. In the coming weeks, we’ll be inviting customers current on Update Subscription to our 10.3 NDA beta, so those interested can get an early look at what’s been in the works. We also plan to expand our native Android controls support to more controls in future releases.

Z-order support for Android will work the same as it does for Windows and iOS today, allowing developers to mix both styled controls and controls rendered by the underlying OS on the same form without any overlap issues.

Another Android related feature we’re working on is upgrading our Android API level support in RAD Studio to support level 26 (Android 8.0). This change requires significant work, and is not possible in a 10.2 update. This support is coming in 10.3. Although the usual beta restrictions do not allow for building and deploying production apps, active update subscription customers who join our 10.3 beta will find a special EULA provision allowing them to deploy (production) Android apps to the Google Play Store.

New Platform Support

Platform support is key with a multi-platform framework like FireMonkey. We know that Android 64-bit support will be mandatory by the summer of 2019, and are working on plans to ensure our customers can meet this requirement next summer. 

One roadmap change you may notice compared to the September 2017 roadmap is that we removed macOS 64-bit platform support from the initial 10.3 release.

This doesn’t mean that we don’t think macOS 64-bit is important. We removed it from the 10.3 release to focus on providing more quality and stability for the other key features that are in flight. With that said, our intent is to provide support for macOS 64-bit, including support for targeting the iOS 11 (and iOS 12) simulators, in a follow-on 10.3.x release. We know that developers looking to target the macOS App Store or leverage 64-bit APIs require macOS 64-bit support.

We have a number of customers today who distribute their existing 32-bit applications through their own web store and are currently not impacted by this Apple requirement. 

In terms of looking ahead, a couple of months ago Apple announced that it was deprecating support of OpenGL in favor of Metal 2, Apple's new GPU library. While OpenGL will continue to be supported in the next versions of macOS and iOS, we are reviewing what will be required to support Metal later next year.


More Details from Marco Cantu

Marco focuses on the Delphi language and RTL, the VCL library and Windows integration, all things database and Web oriented, including RAD Server 

VCL and Windows

While over the last few years RAD Studio and Delphi have expanded their focus on multi-device and mobile development with a single source code and compiled applications, the product remains rooted on Windows and in recent years we have made sure to keep a significant focus on VCL, the best component framework for Windows client applications. We have been adding new components and controls in each release. 

Today VCL offers great support for Win32 API, but also integration to the newer WinRT API of Windows 10. We have new controls with modern UI, styling, and offer a great migration path to a modern UX while preserving most of your existing source code. Moreover, the IDE integrates the Desktop Bridge to build UWP applications you can distribute via the Windows Store.

As you can see in the roadmap, the plan is to continue and increase our investment in this area, specifically around store applications and the ability to check the application status in the store (checking if the customer has paid for the app, if it is a trial, and managing in-app purchases and subscriptions).

We are also going to expand our Win32 API coverage, given Microsoft has added important subsystems to it, and focus on continuous improvement for our support for High-DPI and 4K monitors on Windows. In this regard, we are going to introduce a new image list control that can manage images at multiple resolutions, similarly to what we do in FireMonkey. This will allow the application to avoid relying on image scaling (which often negatively affects image quality) but rather pick the best image for the current screen resolution. In terms of High-DPI support, we are working on the new “Per-Monitor V2” mode Windows 10 offers and plan to focus on resolving a large number of issues the current multi-monitor support has.

Delphi Language and RTL

Beside the Windows 10 focus (which is for both Delphi and C++Builder), there are many other features we are working on for the Delphi personality. We have gone back to the drawing board for the language, and are planning on releasing the new features in phases -- as stability at the compiler level is of critical importance. We found out that  good quality support for nullable types (planned, but deferred) requires changes in other areas of the language. The first we’ll be tackling is custom managed records, that is the ability to define a default parameterless constructor, a destructor and a copy operator for any record type. This adds a lot of power to records, a very nice complementary feature to classes and objects.

In terms of the Run-Time Library (RTL), the focus will be on performance and quality, more than additional features. From generic lists to large memory data structures, from JSON processing to the HTTP client library, we have found large room of improvements and are sure every customer will be pleased, because whether you are building a client application or a server one, whether you are using mobile or desktop platforms, performance gains are always nice to have. 

The RTL performance enhancement also helps RAD Server. After 10.2.3, we released a performance update for our REST API engine, mostly focused on internal elements and better memory management in case of heavy multi-threading. What we couldn’t do in an update was improve the performance of your RAD Server modules, something we’ll achieve in the next release by making JSON processing, string processing, the TStringBuilder class and more core classes faster. Also, it is important with JSON and HTTP services to better support all standards and protocols, including borderline scenarios that other HTTP servers or clients expect.

RAD Server

We have much more than that for RAD Server, though. The next release will see a major overhaul of the logic RAD Server uses to map an incoming HTTP request to an internal resource (that is, a class offering methods to handle the HTTP method calls). Until now, the mapping has been based only on the URL and it has been fairly rigid. Now we plan on adding the ability to consider other HTTP request parameters, like the Content Type, Accepts, file extensions, and more to allow for more sophisticated mapping. For example, the same URL can return a JSON data structure, an image, or a PDF depending on the invocation context. Also, while today you often have to repeat the same code to handle requests over and over, you’ll be able to delegate the actual implementation of a resource request to a separate component, sharing most of the same code for multiple requests and reducing boilerplate code. 

It is a really new version of RAD Server that’s coming along, and coupling it with the licensing changes (deployment licenses are now included with higher end SKUs) we are certain that this REST API engine will see additional interest and focus. 


More Details from David Millington

David focuses on the C++ language, the debugger, and IDE and user experience


In the past couple of releases of RAD Studio, we’ve introduced some great tools for C++ developers. First, rename refactoring: our first C++ refactoring.  It’s one of the most common refactorings and significantly speed up and makes more reliable a common task. Second, we introduced command-line CMake support for C++Builder. This is the first of a couple of CMake-focused steps we have planned, and explicitly supports using ninja for fast builds. You can target Windows, iOS, and Android, including deploying to the device, all from CMake.

We have significant plans for C++ over the next year.

We will introduce our upgraded C++17-capable compiler.  This will be for a single platform (Win32) initially, then rolled out to others since we want to support the same level on all platforms.  When macOS64 support arrives, it will use this new version too. We will continue to update our compiler toolchain and keep it close to a recent version of Clang, meaning our users will get the benefits of both the optimizations and language support of Clang and the language extensions and power our environment provides.

Paired with this will be a new C++17 version of the Dinkumware STL, and performance enhancements.

We also plan a followup to the CMake support introduced in 10.2.2. This support was command-line only. Ultimately, we plan for further integration, aiming to make it very easy to import a CMake project into the IDE, and to build.  Paired with this is an ongoing project to ensure common C++ libraries work with C++Builder (not hard, we have excellent language compatibility, and increasing this is constant and ongoing) and add them into GetIt, our package manager. Ultimately, any C++ user - used to our ecosystem or not - should find it very easy to use any app or library they choose with C++Builder.  And our users should find it easy to bring in any C++ library into your apps.

Finally, some readers may have seen the very recent announcement that Idera acquired Whole Tomato.  Whole Tomato make Visual Assist, a Visual Studio extension which is arguably the best C++ tooling addon for any IDE, period.  It has excellent code insight, refactorings, and other tools.  Visual Assist users can rely on its continued development for Visual Studio - it is an excellent standalone tool we want to see grow and thrive - and we also plan to integrate some key parts into C++Builder. 


The RAD Studio IDE is used daily by many tens of thousands of Delphi and C++Builder users.  Recently, in 10.2.2, we introduced a new dark theme for the IDE and code editor - one of our most popular additions ever, greeted with enthusiasm by large number of our users.

In 10.3.x, we plan a number of IDE improvements, both to the UX (user experience) and functionality. 

Over the past few years, the IDE has had many extensions and changes.  But, the way these have been presented in the UI has not always been polished.  In 10.3, we plan some careful UX improvements that should make the IDE significantly nicer to look at and more pleasant to use for hours on end.  Not all of these are just UI polish: many dialogs have improvements and reorganisation, and the end result is something significantly functionally better while also looking a lot more pleasant.  We can’t wait to show you.

We are also integrating a number of items from Andreas Hausladen’s IDE Fix Pack, which we licensed earlier this year.

Longer term, we have some other improvements lined up.  We have spent quite some time internally examining code completion and other code tooling, and have some significant improvements planned for both Delphi and C++.

Finally, we are also paying a lot of attention to better high DPI support in the IDE.  Marco wrote above about significant improvements for high DPI in the VCL, and the RAD Studio IDE is mostly written in Delphi and C++Builder and most UI is built using the VCL. We hope to leverage the VCL improvements within the IDE too, though this will be done carefully and likely arrive after a release gives it to you our users in the VCL itself.


We don’t typically write much about the debugger in blog posts.  The debugger is one of the core pillars of a development environment, but we tend to write about the compilers - after all, they’re where you see the language enhancements, the performance, etc.  The debugger just does its work for you every day, silently, and is quietly updated as we also work on the flashier side of the toolchain. 

However, we have some great improvements planned.  On mobile platforms, we use a mix of LLDB and GDB depending on the platform.  LLDB is the way forward, and we will be working on our Delphi front-end (language understanding) integration before making use of LLDB on more platforms. The end result as seen in the IDE will be a faster and more powerful debugger, which also understands and can interpret more Delphi statements. Naturally, C++ benefits from this too.



We have some great improvements planned for you: C++17, further CMake support, debugger improvements, language tooling, new FireMonkey features and new platform support (macOS 64-bit and Android 64-bit), Android native controls, HighDPI improvements, RAD Server enhancements, Delphi language features, great UX and look-and-feel improvements to the IDE.  


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.


Reduce development time and get to market faster with RAD Studio, Delphi, or C++Builder. Design. Code. Compile. Deploy.

Start Free Trial   Free Delphi Community Edition   Free C++Builder Community Edition   Upgrade Today  

  • just read the first line of https://flutter.io: "Google’s mobile app SDK" ... if you want to develop with it on Ios then you have no probably brain ! remember with something is free, it's you the product ;)
  • Steve, if you don't mind, can you post a link to your FMX apps? I'm interested to see what you've be able to achieve with the framework. Perhaps I gave up too early.
  • I did Steve, I have 3 Xamarin.Android apps in the store. Xamarin Native is okay (buggy as well), I don't like Xamarin Forms. React Native started to take that space, but now Flutter is here I think it's game over. How are they going to catch up to Flutter? You have instant hot reload (in mills) and state is maintained even if you are 7 pages deep into your app? MS is stepping up their Xamarin efforts to stop the developer bleed. You also have Kotlin and Kotlin Native (for iOS etc) and any number of other Mobile development frameworks. Mobile + FMX Desktop + IoT + VCL it's too big a surface for Delphi to keep up with. So you see very few high quality non-trivial FMX apps anywhere - MacOS, Android, iOS. Right now, they are behind in MacOS 64 bit support, Android, and now OpenGL is being made obsolete on Mac, so they'll need to address that. That's potentially a lot of bugs being introduced. They are biting off too much IMO. Also, regarding Enterprise, there are so many options now for a REST API (Go/.Net Core/Kotlin Spring), Push Notifications (i.e. XMPP), Elixir/Erlang (Scalability) etc. I'm happy to be proven wrong, would love to use Delphi everywhere. I'd like Emba to build a cross-platform IDE in FMX to dog food FMX, it would really improve the framework - Microsoft's WPF got much better when they used it in developing Visual Studio features. Desktop and IOT that's where I'd like to see the focus, but perhaps I don't see the big picture.
  • I too totally disagree. Yes there are free alternative, but did you really try Xamarin? To me it's a no go. RadStudio offers a real one place, one code, one click compile/deploy. Lazarus is fine for Linux if you don't have RadStudio Enterprise. But to me today, the only way to go cross-platform (not only mobile, but macOS too) is definitely RadStudio. I moved all my VCL apps to FMX and can now enjoy my Windows apps into my Mac. Customers are very happy too. My only regret is as of today, no deployment to AppleWatch, which will soon become a necessity. I just hope that RadStudio will still exist in 5 years. Also the only real FREE alternative today for cross-platform is... RadStudio CE
  • I disagree ! nowadays the mobile is the revolution and thanks that embarcadero take this way! their is not many good options for mobile, each have their drawback and advantage! Delphi have a very good way to manage it, it's very powerfull and let the creativity 100% free!
  • I think, from Marco's post that led me here, you are missing the most important persona - the Cross Platform Desktop developer. Too many good options for mobile, all free - Xamarin, Flutter, React Native, Kotlin, etc. Delphi's strength has always been the desktop, and there's a big opportunity for a first-class cross-platform desktop framework, and FMX has the potential to be that. Mobile for Delphi is a no show, nor the enterprise (only existing customers), but for Desktop, FMX could be the best. IMO.
  • M-M, I do not fully agree with you, with your complain to embarcadero! In fact the fault is at 95% on the side of apple! it's apple who decide to impose 64 bit app, and when they do this they know perfectly that some developers (like you or me) will be stuck, but for them it's not their problem. Here you complain to embarcadero, because at least emb listen you (a little) when apple don't even care a nanosecond of you! It's even worse on iOS where they FORCE their users to update the iphone OS to the last version with no way to revert back if something goes wrong (and sometime they even make this like an obsolescence of your phone with battery life as an excuse). So yes your App store income will drop to zero but fault of who ? mostly fault of apple and YOU (and all the other who use the apple product) who decide to play with them. On windows (i don't like windows neither) my old 32 bit dos program still work on windows 10! think about it ....
  • Never give me an invitation and im update subscription customer. a shame.
  • Ok, so i just pay for a new year subscription and waste my money. My fault i know, but will be the latest time. Theres nothing attractive to me for the next year. Dont use mobile, dont use firedac (unidac is a lot better and cheaper), and yes ... forget to have a real arm processor compiler to support IoT. Idera again slap us in our ace and choice to enhance the piece of s**t rad server. Thats the way you move, idera, just want to spend money on corporative stuff you will abandon in the meantime, as you do in the past. Never listen to loyal developers, only listen to marketing millenials thinking they re discover the fire. Forget the most big market in the world now: IoT, to just get some cash from RAD server licenses, nobody with a brain will take that road having better, quicker and royalty free options ( like remobjects or any other). A TP 5.5 user talking to you, you have a lot of learn fo what delphi means for the community.
  • "Delphi Language and RTL" - for a second there, i thought this is going to be about BiDi support, and Right-To-Left languages in Firemonkey... btw, in the IDE, trying to bookmark with [CTRL]+[Shift]+[0] doesn't work, but it can still be done with the context menu. i know it's a small thing, but i use it a lot, and it's really annoying now.
  • In another side, most used by me expressions in Evaluate/Modify, Watch and Inspector windows - is a xxx.ClassName and then type-cast to this class for this xxx. PLEASE, embed displaying the class of an object-typed value into debugger's hint for any expression, and displaying mode to display properties, fields and methods of real value's class instead of precompiled value's type info! Please, add "Auto-cast to real value's class" switch into toolbars of this tools.
  • I think, Delphi needs more movements into AI, neural networks, big data, clouds etc.