Programming Update: RAD Studio 13 Florence has been released along with a list of new features.
The main content of this article is as follows:
-
Advantages of the new C++Builder compiler
-
More advantages of BCC64x
-
Technical challenges: It’s not just a matter of changing compilers
When RAD Studio announced support for C++23, it seemed understated—there was only a single line in the release notes. However, behind this brief statement lies one of the most complex and challenging engineering efforts the product has seen in recent years.
C++23 is not just an ordinary “language update”; it represents a profound paradigm shift. For a platform like RAD Studio, which must embrace modern language features while remaining compatible with decades of legacy code, this is far more than a patch; it is a comprehensive systemic overhaul. This work has given rise to BCC64x—the codename for the next-generation C++ compiler in RAD Studio. It is based on the LLVM/Clang 20 toolchain and incorporates Embarcadero’s unique “Borland extensions”.
The compiler is just one part of the C++23 integration effort, but it is a crucial one. Below, we will take you through the full scope of this technical evolution.
Advantages of the New C++Builder Compiler
BCC64x is now fully aligned with the industry-leading LLVM/Clang 20 compiler.
The LLVM/Clang project was initially launched as an alternative to GCC and has now become one of the core forces in the development tools space. A large number of modern tools and frameworks are built on the LLVM foundation, and more ecosystems will emerge around it in the future.
- Enhanced third-party library compatibility Most third-party code can be compiled directly without modification. Only in rare cases (such as using specific POSIX headers in MinGW/Clang) adjustments are needed, and we are working to minimize such issues.
- Significantly improved compilation speed Compared to the previous generation Clang-based bcc64c compiler, BCC64x’s compilation speed has nearly doubled. This is not only due to the upgrade to Clang 20 but also thanks to deep optimizations in parallel build capabilities.
- Better multi-core performance On modern x86-64 processors with 16 cores or more, BCC64x can fully leverage multi-threading advantages, achieving the best balance between performance and functional integrity.
Below are the build performance test results on the Xerces library:
| Test Method | bcc32 (Classic) | bcc32c (Clang 5) | bcc64 (Clang 5) | bcc64x (Clang 20) |
|---|---|---|---|---|
| Parallel Build | 00:11.86 | 00:16.08 | 00:16.99 | 00:13.14 |
| Serial Build | 00:11.92 | 02:15.62 | 02:47.62 | 01:35.90 |
More Advantages of BCC64x
- Advanced code optimization capabilities Although compilation time is slightly increased, the quality of the generated code is higher. BCC64x will more aggressively unroll loops, inline high-frequency functions, and generate more concise and efficient arithmetic instructions—assembly enthusiasts will surely be excited.
- Support for the new C runtime (CRT) For a long time, C++ developers have suffered from CRT compatibility issues. The unified CRT introduced by Microsoft greatly improves the portability and version management of Windows applications.
- The old bcc32 directly calls the underlying Windows API, bypassing the CRT;
- While BCC64x fully utilizes the new CRT, significantly enhancing application stability and deployment experience.
- Stronger security Clang has built-in static checking mechanisms that can detect potential errors early, effectively preventing security vulnerabilities and cyber attacks.
- Clearer error messages The new compiler not only reports errors more accurately but can also “expand” macro definitions and trace back to the source of errors, allowing developers to quickly locate issues.
- Paving the way for multi-platform expansion Thanks to LLVM’s cross-platform architecture, BCC64x lays a solid foundation for future support of more target platforms (such as macOS, Linux, embedded systems, etc.).
Technical Challenges: It’s Not Just a Matter of Changing Compilers
Embarcadero’s C++ compiler is not a simple branch of Clang or a front-end plugin. It must be deeply integrated with the Delphi runtime, VCL, and FireMonkey frameworks, ensuring that the generated code remains compatible with all ABIs (Application Binary Interfaces) since the Borland era.
This means: you cannot simply “swap out a parser and call it a day”. Embarcadero-specific keywords like <span>__closure</span>, <span>__published</span>, <span>__classid</span> must be fully supported.
Every new feature introduced must not only be validated for correctness but also ensure seamless collaboration with the old toolchain, debugging symbols, and IDE intelligent insight (Code Insight) systems. Anyone familiar with the internal mechanisms of C++ compilers knows this is no easy task—sometimes, even slight differences in memory alignment can become roadblocks to compatibility. Given Embarcadero’s large user base and the long-standing code ecosystem, we must invest significant effort to minimize migration risks.