Delphi Bin Applications Dick Maley ©2025 dickmaley@advdelphisys.com
Table of Contents
AuditsCLI.exe Description AuditsCLI.exe Commandline Switches bcc32.exe Description bcc32.exe Commandline Switches bcc32c.exe Description bcc32c.exe Commandline Switches bcc32x.exe Description bcc64.exe Description bcc64.exe Commandline Switches BCompareLite.exe Description BDSFileCopyHelper.exe Description bdsreg.exe Description BDSSetLang.exe Description BDSSetLang.exe Commandline Switches BitmapStyleDesigner.exe Description brcc32.exe Description brcc32.exe Commandline Switches cgconfig.exe Description cgrc.exe Description cgrc.exe Commandline Switches clang-format.exe Description clang-format.exe Commandline Switches coff2omf.exe Description coff2omf.exe Commandline Switches convert.exe Description Convert.exe Commandline Switches cpp32.exe Description cpp32.exe Commandline Switches cpp32c.exe Description cpp32c.exe Commandline Switches CppLibTransform.exe Description CppLibTransform.exe Commandline Switches dbkw64_29_0.exe Description dcc32.exe Description dcc32.exe Commandline Switches dcc64.exe Description dcc64.exe Commandline Switches drinterop.exe Description	drinterop.exe Commandline Switches DSProxyGen.exe Description DSProxyGen.exe Commandline Switches DSProxyReg.exe Description DSProxyReg.exe Commandline Switches dsymlink.exe Description dsymlink.exe Commandline Switches EMSDevConsole.exe Description EMSDevServerCommand.exe Description EMSDevServerCommand.exe Commandline Switches EMSMultiTenantConsole.exe Description FDExplorer.exe Description FMXControlStyleViewer.exe Description FMXMetropolisUIStyleViewer.exe Description FMXMobileStyleViewer.exe Description FMXStyleViewer.exe Description FMXWinModernStyleViewer.exe Description Formatter.exe Description Formatter.exe Commandline Switches GenDocCLI.exe Description GenDocCLI.exe Commandline Switches GenTLB.exe Description GenTLB.exe Commandline Switches GetItCmd.exe Description GetItCmd.exe Commandline Switches grep.exe Description grep.exe Commandline Switches impdef.exe Description impdef.exe Commandline Switches implib.exe Description implib.exe Commandline Switches make.exe Description make.exe Commandline Switches migrationtool.exe Description mkexp.exe Description mkexp.exe Commandline Switches objcopy.exe Description objcopy.exe Commandline Switches	paclient.exe Description paclient.exe Commandline Switches rc.exe Description rc.exe Commandline Switches reFind.exe Description reFind.exe Commandline Switches rmtdbg290.exe Description RSConsole.exe Description scktsrvr.exe Description SdkTransform.exe Description SdkTransform.exe Commandline Switches tasm32.exe Description tasm32.exe Commandline Switches tdstrp32.exe Description tdstrp32.exe Commandline Switches tdump.exe Description tdump.exe Commandline Switches tdump64.exe Description tdump64.exe Commandline Switches tlib.exe Description tlib.exe Commandline Switches tlib64.exe Description tlib64.exe Commandline Switches tlibimp.exe Description tlibimp.exe Commandline Switches touch.exe Description touch.exe Commandline Switches tregsvr.exe Description VCLStyleViewer.exe Description VSF2FM..exe Description Win32ProxyDownloader.exe Description Win32ProxyDownloader.exe Commandline Switches WSDLImp.exe Description WSDLImp.exe Commandline Switches XMLMapper.exe Description
Introduction When Rad Studio is installed a number of applications are placed in the bin directory. Some of these applications are used by the IDE and are not intended for use directly by users. Others however, are intended for external use. Some applications support commandline usage and have an extensive array of commandline switches. This document attempts to describe the functionality of each application and if commandline switches are supported report on those switches. The applications documented here are those that ship with Rad Studio Architect. As of this writing these applications reflect those that ship with Rad Studio 13 Florence. Versions other than Architect probably ship with a different set of applications.

AuditsCLI.exe Description

AuditsCLI.exe in Embarcadero RAD Studio 13 Architect is the command-line interface for Code Audits, part of the static code analysis tools included in RAD Studio.

Here�s a breakdown of its purpose and functionality:

🧩 Purpose

AuditsCLI.exe allows you to run Delphi and C++ static code audits (code analysis checks) from the command line, rather than through the IDE.
It�s typically used for:

Automated code quality checking in build scripts or CI/CD pipelines.
Running custom or predefined audit profiles on projects or source directories.
Generating reports on code issues, rule violations, or style inconsistencies.

⚙️ Main Features

Runs Code Audits outside the IDE � analyzes .dpr, .dpk, .bdsproj, or source files directly.
Batch Processing � useful for continuous integration environments or automated testing.
Rule-based Analysis � applies the same audit rules and settings used in the RAD Studio IDE.
Report Generation � outputs results to the console, XML, or other formats depending on options.
Integration � can be combined with build tools (MSBuild, Jenkins, etc.) for automated quality checks.

🧾 Typical Usage Example

AuditsCLI.exe -project "C:\Projects\MyApp.dproj" -profile "Default" -output "C:\Reports\MyApp_Audit.xml"

Parameters (common ones):

Parameter	Description
-project <file>	Specifies the Delphi/C++ project to analyze
-profile <name>	Selects an audit profile (set of rules)
-output <file>	Path for the audit result report
-rules	Lists all available audit rules
-help	Displays command-line options and usage help

📘 When to Use

Use AuditsCLI.exe if you want to:

Enforce coding standards automatically before commits or builds.
Integrate code audits into a continuous integration pipeline.
Run audits on large projects without opening the IDE.

AuditsCLI.exe Commandline Switches

Embarcadero Audits and Metrics command line version
Copyright (c) 2010 Embarcadero Technologies, Inc.

Syntax:
AuditsCLI.exe --{audits|metrics} --{xml|html} <compiler-options> [--config=<config-file>] [-o <output-file>] <project.dproj>
List of options:
    --audits			run Audits analysis
    --metrics			run Metrics analysis
    --xml			generate unprocessed XML output
    --html			generate HTML output
    --config=<config-file.mts>	or 
    --config=<config-file.adt>	specifies the file storing the set of audits or metrics to analyze
    <project.dproj>		Delphi project file
    -o <output-file>		write analysis result to <output-file>
    				Defaults to projectname.{audits|metrics}.{xml|html}
    --id=<AUDIT-ID>:<param>=<value>:<param>=<value>,<AUDIT-ID>;...
    				Enable or disable individual analyzers.
    				See --id-help and --id-help=<AUDIT-ID;> for details.
    --id-help			list available analyzers. Use together with --audits or --metrics.
    --id-help=XYZ		list parameters and usage example of analyzer XYZ
    --build-config=<name>	Override default build configuration (e.g. Debug, Release)
    -v				verbose output
    -q				suppress messages
    
Compiler options:
    -Ipath1;path2;...		include directories
    -Upath1;path2;...		compiled unit directories
    -Dsymbol1;symbol2;...	conditional compilation symbols
    -A<unit>=<alias>		unit aliases

bcc32.exe Description

bcc32.exe is the classic Borland C++ 32-bit compiler included with Embarcadero RAD Studio (in your case, RAD Studio 13 Architect).

Here�s a summary of its functionality and role:

🧩 Purpose

bcc32.exe is the legacy 32-bit C++ compiler originally based on Borland�s older code generation technology. It is maintained primarily for backward compatibility with older C++Builder projects that were written before the introduction of the modern Clang-based compilers.

⚙️ Key Functions

Compiles Win32 C++ applications using the classic Borland C++ toolchain.
Supports Object Pascal-style extensions (for linking with Delphi code).
Works with the BCC32 RTL (Runtime Library) and VCL (Visual Component Library).
Integrates with the IDE (bds.exe) and the make/build tools like make.exe and ilink32.exe.

🧱 Typical Use Cases

Building legacy C++Builder projects that depend on Borland-specific language extensions or pre-Clang libraries.
Maintaining older codebases that cannot yet be migrated to the Clang-based compilers (bcc32c.exe, bcc32x.exe, or bcc64.exe).
Linking with Delphi units in mixed-language projects (C++/Delphi).

🧭 "Arial" Context in RAD Studio 13

RAD Studio 13 primarily uses Clang-based compilers (bcc32c.exe, bcc32x.exe, bcc64.exe), which are standards-compliant and support modern C++ features.
bcc32.exe remains available for compatibility and migration purposes.
You�ll typically find it in:
C:\Program Files (x86)\Embarcadero\Studio\23.0\bin\bcc32.exe

🧰 Associated Tools

ilink32.exe � Classic 32-bit linker.
brcc32.exe � Classic resource compiler.
tdump.exe, tlib.exe � Tools for inspecting and managing object and library files.

bcc32.exe Commandline Switches

Embarcadero C++ 7.60 for Win32 Copyright (c) 1993-2023 Embarcadero Technologies, Inc.
Available options (* = default setting, xxx = has sub-options: use -h -X):
(Note: -X- or -w-XXX will usually undo whatever was set or unset by -X or -wXXX.
 If two options conflict, the last one specified will be used.)
--sysroot Sets the logical root directory for headers, libraries and frameworks
	  (Paths specified in --sysinc or --syslib and those in -F that begin
	   with '/' are prefixed with this value)
--sysinc  Set the system include file search path
	  (if specified, sysroot will be prepended)
--syslib  Set the system library file search path
	  (if specified, sysroot will be prepended)
--savemem Set maximum SAVEMEM memory (in Mb)
	  (This is the contiguous memory allocated to store global symbols and
	   similar constructs.  Pre-compiled headers use this memory)
--version Show compiler version
--replacehdr Replace header name (e.g. --replaceHeader=a.h=b.h)
--xrtti   Generate extended rtti information
  -3      Generate 80386 protected-mode compatible instructions
  -4      Generate 80386/80486 protected-mode compatible instructions
  -5      Generate Pentium instructions
  -6      Generate Pentium Pro instructions
  -Axxx   Enable ANSI conformance
  -B      Compile to .ASM (-S), then assemble to .OBJ
  -Cxxx   Enable nested comments
  -D      -D<name> defines 'name' as a null string, or use -D<name>=<value>
  -E      Specify which assembler to use
  -G      Optimize for size/speed; use -O1 and -O2 instead
  -Hxxx   Generate and use precompiled headers
  -I      Set the include file search path
  -Jxxx   Template generation options
  -K      Set default character type to unsigned
  -L      Library file search path
  -M      Create a linker map file
  -N      Hodgepodge of miscellanity (see -h -N)
  -Nd     Macros get a value of "1" by default (-DX => -DX=1)
  -Nt     GNU __typeof(var) support
  -Nv     Allow void& as a valid type
  -O      Optimize jumps
  -P      Perform C++ compile regardless of source extension
  -Q      Extended compiler error information
  -Rxxx   Include browser information in generated .OBJ files
  -S      Compile to assembly
  -T      Specify assembler option, e.g. -Tx
  -U      Undefine any previous definitions of name
  -Vxxx   Compatibility options
  -W      Target is a Windows application
  -X      Disable compiler autodependency output
  -Zd     Output global defs as DocBook specs; to specify: -Zd=<file>.c
  -Zn     Disable and/or don't define CodeGear builtins
  -Zx     Output global definitions to XML file.
	      Sub Options:
		-Zx=<filename> Emit only types/declarations in <filename>
		-Zxf[=filename] Skip base type members 
		-Zxm[=filename] Emit macros
		-Zxp[=filename] Emit file & line position
  -axxx   Set data alignment boundary.  Default is -a8; -a- means -a1
  -b      Enable -bi and treat enums as ints from a typechecking point of view
* -bi     Make sizeof(enum x) == sizeof(int) unless explicitly stated otherwise
  -c      Compile to object file only, do not link
  -d      Merge duplicate strings
  -dc     Put strings into the read-only data segment
  -dw     Put strings into the (writeable) data segment
  -e      Specify target executable pathname
* -ff     Fast floating point
  -fp     Correct Pentium FDIV flaw
* -fq     Use quiet floating point compare instruction (FUCOMP)
  -g      Stop batch compilation after n warnings (Default = 255)
  -h      Request help ('-h -' shows all help).  Can be specific: -h -V
  -i      Set maximum significant identifier length (Default = 250)
  -j      Stop batch compilation after n errors (Default = 50)
* -k      Generate standard stack frames
  -l      Pass options to the linker; example: -ls -l-x
  -m      Generate makefile dependency information
  -md     Put dependency info in .d files, not in the object file
  -mm     Ignore system header files while generating dependency info
  -mo     Specify the output file for dependency info
  -n      Set output directory for object files
  -o      Set output filename (-o<filename> or -o <filename> supported)
  -pxxx   Use Pascal calling convention
  -q      Suppress compiler identification banner
  -r      Use register variables
  -rd     Use register variables only when register keyword is employed
  -s      Link using the system's non-incremental linker
  -t      Specify target executable
* -u      Generate underscores on symbol names
  -vxxx   Turn on source debugging
  -w      Display all warnings
  -w!     Return non-zero from compiler on warnings
  -xxxx   Enable exception handling
  -y      Debug line numbers on
  -z      Options for redefining standard segment names
Use '-h <OPT>' for help on a specific option, or
    '-h -' to see all available options.

bcc32c.exe Description

In Embarcadero RAD Studio 13 Architect, the executable bcc32c.exe is the modern C++ compiler for 32-bit Windows applications, based on the Clang/LLVM compiler toolchain.

Here�s a detailed summary of its functionality:

🧩 Executable: bcc32c.exe

Full name: Embarcadero C++ Compiler (Clang-based) for Win32
Primary role: Compiles C and C++ source code into 32-bit Windows object files and executables.

⚙️ Key Functions

Compiles modern C++ (C++11, C++14, C++17, and partial C++20) code for Win32 targets.
Replaces the older bcc32.exe, which was based on Borland�s classic compiler.
Integrates tightly with the Delphi IDE (RAD Studio) to build mixed Delphi/C++ projects.
Supports:

Modern C++ language standards.
LLVM back-end optimizations.
Clang-compatible diagnostics and error messages.
Precompiled headers and templates.
C++Builder runtime libraries (RTL/VCL/FMX).

🔧 Usage Context

Used when compiling C++Builder projects for Win32 that use the Clang-enhanced compiler (as opposed to the legacy Borland one).
Often invoked automatically by the RAD Studio IDE, but can also be used manually from the command line:
bcc32c myprogram.cpp -o myprogram.exe
Typically used alongside:

ilink32.exe (linker)
brcc32.exe (resource compiler)
tlib.exe (library manager)
make.exe (build automation)

📦 Related Compilers

Executable	Description
bcc32.exe	Legacy Borland C++ 32-bit compiler (pre-Clang)
bcc32c.exe	Clang-enhanced 32-bit C++ compiler
bcc32x.exe	Clang-based C++ cross-compiler (used by IDE internally)
bcc64.exe	Clang-based 64-bit C++ compiler

🧠 Summary

bcc32c.exe is the Clang-based, modern 32-bit C++ compiler in RAD Studio 13. It provides up-to-date language features, better standards compliance, and improved performance compared to the legacy bcc32.exe.

bcc32c.exe Commandline Switches

Embarcadero C++ 7.60 for Win32 Copyright (c) 2012-2023 Embarcadero Technologies, Inc.
Available options (* = default setting, xxx = has sub-options: use -h -X):
(Note: -X- or -w-XXX will usually undo whatever was set or unset by -X or -wXXX.
 If two options conflict, the last one specified will be used.)
--sysroot (Note: -X- or -w-XXX will usually undo whatever was set or unset by -X or -wXXX.

--sysinc  Set the system include file search path
	  (if specified, sysroot will be prepended)
--syslib  Set the system library file search path
	  (if specified, sysroot will be prepended)
--savemem Set maximum SAVEMEM memory (in Mb)
	  (This is the contiguous memory allocated to store global symbols and
	   similar constructs.  Pre-compiled headers use this memory)
--version Show compiler version
--replacehdr Replace header name (e.g. --replaceHeader=a.h=b.h)
--xrtti   Generate extended rtti information
  -3      Generate 80386 protected-mode compatible instructions
  -4      Generate 80386/80486 protected-mode compatible instructions
  -5      Generate Pentium instructions
  -6      Generate Pentium Pro instructions
  -Axxx   Enable ANSI conformance
  -B      Compile to .ASM (-S), then assemble to .OBJ
  -Cxxx   Enable nested comments
  -D      -D<name> defines 'name' as a null string, or use -D<name>=<value>
  -E      Specify which assembler to use
  -G      Optimize for size/speed; use -O1 and -O2 instead
  -Hxxx   Generate and use precompiled headers
  -I      Set the include file search path
  -Jxxx   Template generation options
  -K      Set default character type to unsigned
  -L      Library file search path
  -M      Create a linker map file
  -N      Hodgepodge of miscellanity (see -h -N)
  -Nd     Macros get a value of "1" by default (-DX => -DX=1)
  -Nt     GNU __typeof(var) support
  -Nv     Allow void& as a valid type
  -O      Optimize jumps
  -P      Perform C++ compile regardless of source extension
  -Q      Extended compiler error information
  -Rxxx   Include browser information in generated .OBJ files
  -S      Compile to assembly
  -T      Specify assembler option, e.g. -Tx
  -U      Undefine any previous definitions of name
  -Vxxx   Compatibility options
  -W      Target is a Windows application
  -X      Disable compiler autodependency output
  -Y      
  -Zd     Output global defs as DocBook specs; to specify: -Zd=<file>.c
  -Zn     Disable and/or don't define CodeGear builtins
  -Zx     Output global definitions to XML file.
	      Sub Options:
		-Zx=<filename> Emit only types/declarations in <filename>
		-Zxf[=filename] Skip base type members 
		-Zxm[=filename] Emit macros
		-Zxp[=filename] Emit file & line position
  -axxx   Set data alignment boundary.  Default is -a8; -a- means -a1
  -b      Enable -bi and treat enums as ints from a typechecking point of view
* -bi     Make sizeof(enum x) == sizeof(int) unless explicitly stated otherwise
  -c      Compile to object file only, do not link
  -d      Merge duplicate strings
  -dc     Put strings into the read-only data segment
  -dw     Put strings into the (writeable) data segment
  -e      Specify target executable pathname
  -ff     Fast floating point
  -fp     Correct Pentium FDIV flaw
  -fq     Use quiet floating point compare instruction (FUCOMP)
  -g      Stop batch compilation after n warnings (Default = 255)
  -h      Request help ('-h -' shows all help).  Can be specific: -h -V
  -i      Set maximum significant identifier length (Default = 250)
  -j      Stop batch compilation after n errors (Default = 50)
  -k      Generate standard stack frames
  -l      Pass options to the linker; example: -ls -l-x
  -m      Generate makefile dependency information
  -md     Put dependency info in .d files, not in the object file
  -mm     Ignore system header files while generating dependency info
  -mo     Specify the output file for dependency info
  -n      Set output directory for object files
  -o      Set output filename (-o<filename> or -o <filename> supported)
  -pxxx   Use Pascal calling convention
  -q      Suppress compiler identification banner
  -r      Use register variables
  -rd     Use register variables only when register keyword is employed
  -s      Link using the system's non-incremental linker
  -t      Specify target executable
  -u      Generate underscores on symbol names
  -vxxx   Turn on source debugging
  -w      Display all warnings
  -w!     Return non-zero from compiler on warnings
  -xxxx   Enable exception handling
  -y      Debug line numbers on
  -z      Options for redefining standard segment names
Use '-h <OPT>' for help on a specific option, or
    '-h -' to see all available options.

bcc32x.exe Description

BCC32X.exe - Clang-enhanced C++ Compiler

BCC32X.exe is the modern C++ compiler included with RAD Studio. It's a Clang-based compiler that replaced the older classic Borland C++ compiler (bcc32.exe) and represents Embarcadero's transition to LLVM/Clang technology.

Key Functionality

C++ Compilation: Compiles C++ source code to Win32 (32-bit) object files and executables
Clang-based: Built on LLVM/Clang, providing modern C++ standard support (C++11, C++14, C++17, and beyond)
VCL/FMX Compatible: Can compile applications using Embarcadero's Visual Component Library (VCL) and FireMonkey (FMX) frameworks
Command-line Compiler: Full-featured compiler accessible from the command line

Standalone vs. IDE Usage

BCC32X.exe can absolutely be used as a standalone application - it is not restricted to IDE use only. You can:

Invoke it directly from the command line or batch scripts
Use it in makefiles or custom build systems
Integrate it into automated build processes
Compile C++ projects without ever opening the RAD Studio IDE

Typical Standalone Usage:

bcc32x.exe [options] source.cpp

Common options include:

-o<filename> - Specify output file
-I<path> - Include directories
-L<path> - Library paths
-D<macro> - Define preprocessor macros
-c - Compile only (no linking)

The IDE uses this compiler behind the scenes, but you have full access to it independently for your own build workflows.

bcc64.exe Description

bcc64.exe is the 64-bit C++ Compiler for the Clang-enhanced Embarcadero C++ Compiler (BCC). It is the core command-line driver that translates C and C++ source code (.c, .cpp) into 64-bit executable programs (.exe), dynamic-link libraries (.dll), and object files (.o).

It is a modern compiler based on the Clang/LLVM architecture, which provides excellent standards compliance (C++11, C++17, C++20), powerful optimization capabilities, and improved diagnostics and error messages compared to its legacy predecessor.

Is it strictly used by the Delphi IDE or can it be used standalone?

It can be used as a standalone application, and this is a primary feature.

Let's break this down:

1. Use by the Delphi/C++Builder IDE (Rad Studio)

The Delphi and C++Builder IDEs that are part of Rad Studio are sophisticated tools that manage the entire build process for you. When you press "Build" or "Run" for a C++ project, the IDE does not directly call bcc64.exe itself. Instead, it calls a higher-level build management tool.

For C++ Projects: The IDE typically invokes MSBuild, which then reads the project file (.cbproj) and executes the necessary commands, which ultimately call bcc64.exe for compilation and the linker (ilink64.exe) for linking. The IDE orchestrates the process, but bcc64.exe is the workhorse that performs the compilation.
For Delphi Projects: The Delphi compiler (dcc64.exe) is used. bcc64.exe is not involved in compiling pure Delphi code. However, if you have a Delphi project that links to a C++-built static library (.a or .lib), that library would have been created using bcc64.exe in a separate, prior step.

So, while the IDE relies on bcc64.exe for C++ compilation, it is not the direct user.

2. Standalone Use

This is where bcc64.exe shines as a powerful, independent tool. You can use it directly from the command prompt or integrate it into any build system you prefer (e.g., CMake, Makefiles, custom scripts).

Why would you use it standalone?

Automation: To create automated build scripts (e.g., batch files, PowerShell scripts) for your continuous integration/continuous deployment (CI/CD) pipeline.
Build Systems: To integrate with build systems like CMake or GNU Make.
Full Control: To have precise control over every compiler flag, define, and include path, which can sometimes be abstracted away by the IDE.
Headless Builds: To compile code on a server or build machine without the IDE installed, requiring only the Command Line Tools to be installed.

How to use it standalone:

Open the Correct Command Prompt: The easiest way is to use the "RAD Studio Command Prompt" which is installed with Rad Studio. This shortcut automatically configures all the necessary environment variables (PATH, INCLUDE, LIB) so the compiler, linker, and other tools can be found.
Run the compiler: You can then invoke bcc64.exe directly.

Example Command:

bash

bcc64 -c -I"C:\Path\To\My\Includes" -oMyObject.o MySource.cpp

This command:

-c: Compile only (create an object file, don't link).
-I: Add an include directory.
-o: Specify the output object file.
MySource.cpp: The source file to compile.

To create a full executable, you would then call the linker (ilink64.exe), or you can let bcc64.exe drive the entire process by omitting the -c flag.

Key Functionality

Compilation: Parses and compiles C/C++ source code into machine code for 64-bit Windows platforms.
Preprocessing: Handles preprocessor directives (#include, #define, #ifdef, etc.).
Dependency Generation: Can generate dependency files (e.g., using -MMD) for build systems.
Optimization: Supports various optimization levels (e.g., -O1, -O2).
Debugging: Generates debug information for the Embarcadero debugger when the -g flag is used.
Warnings and Errors: Provides detailed, Clang-style error and warning messages to help identify issues in code.

Conclusion

bcc64.exe is a standalone, command-line 64-bit C++ compiler. While it is a critical component used by the Rad Studio IDE when building C++ projects, it is designed and provided as a first-class tool that can be used independently for scripting, automation, and integration into custom build environments. It is not used by the Delphi compiler for compiling Pascal code.

bcc64.exe Commandline Switches

Embarcadero C++ 7.60 for Win64 Copyright (c) 2012-2023 Embarcadero Technologies, Inc.
OVERVIEW: Embarcadero C/C++ compiler driver for Win64

USAGE: bcc64.exe [options] <inputs>

OPTIONS:
  -###                    Print (but do not run) the commands to run for this compilation
  --analyzer-output <value>
                          Static analyzer report output format (html|plist|plist-multi-file|plist-html|text).
  --analyze               Run the static analyzer
  -arcmt-migrate-emit-errors
                          Emit ARC errors even if the migrator can fix them
  -arcmt-migrate-report-output <value>
                          Output path for the plist report
  -B <dir>                Add <dir> to search path for binaries and object files used implicitly
  -CC                     Include comments from within macros in preprocessed output
  -cl-denorms-are-zero    OpenCL only. Allow denormals to be flushed to zero.
  -cl-fast-relaxed-math   OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations, and defines __FAST_RELAXED_MATH__.
  -cl-finite-math-only    OpenCL only. Allow floating-point optimizations that assume arguments and results are not NaNs or +-Inf.
  -cl-fp32-correctly-rounded-divide-sqrt
                          OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded.
  -cl-kernel-arg-info     OpenCL only. Generate kernel argument metadata.
  -cl-mad-enable          OpenCL only. Allow use of less precise MAD computations in the generated binary.
  -cl-no-signed-zeros     OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.
  -cl-opt-disable         OpenCL only. This option disables all optimizations. By default optimizations are enabled.
  -cl-single-precision-constant
                          OpenCL only. Treat double precision floating-point constant as single precision constant.
  -cl-std=<value>         OpenCL language standard to compile for.
  -cl-strict-aliasing     OpenCL only. This option is added for compatibility with OpenCL 1.0.
  -cl-unsafe-math-optimizations
                          OpenCL only. Allow unsafe floating-point optimizations.  Also implies -cl-no-signed-zeros and -cl-mad-enable.
  --cuda-compile-host-device
                          Compile CUDA code for both host and device (default).  Has no effect on non-CUDA compilations.
  --cuda-device-only      Compile CUDA code for device only
  --cuda-gpu-arch=<value> CUDA GPU architecture (e.g. sm_35).  May be specified more than once.
  --cuda-host-only        Compile CUDA code for host only.  Has no effect on non-CUDA compilations.
  --cuda-noopt-device-debug
                          Enable device-side debug info generation. Disables ptxas optimizations.
  --cuda-path=<value>     CUDA installation path
  -cxx-isystem <directory>
                          Add directory to the C++ SYSTEM include search path
  -C                      Include comments in preprocessed output
  -c                      Only run preprocess, compile, and assemble steps
  -dD                     Print macro definitions in -E mode in addition to normal output
  -dependency-dot <value> Filename to write DOT-formatted header dependencies to
  -dependency-file <value>
                          Filename (or -) to write dependency output to
  -dI                     Print include directives in -E mode in addition to normal output
  -dM                     Print macro definitions in -E mode instead of normal output
  -dwo-dir <directory>    Write dwo files to <directory>
  -D <macro>=<value>      Define <macro> to <value> (or 1 if <value> omitted)
  -emit-ast               Emit Clang AST files for source inputs
  -emit-llvm              Use the LLVM representation for assembler and object files
  -external-linker <arg>  Select <arg> as external linker
  -E                      Only run the preprocessor
  -faligned-allocation    Enable C++17 aligned allocation functions
  -fallow-editor-placeholders
                          Treat editor placeholders as valid source code
  -fansi-escape-codes     Use ANSI escape codes for diagnostics
  -fapple-kext            Use Apple's kernel extensions ABI
  -fapple-pragma-pack     Enable Apple gcc-compatible #pragma pack handling
  -fapplication-extension Restrict code to those available for App Extensions
  -fblocks                Enable the 'blocks' language feature
  -fborland-define-external-types
                          Generate definitions for external debug types into PCH file
  -fborland-extensions    Accept non-standard constructs supported by the Borland compiler
  -fborland-use-external-types
                          Generate references to external debug types from PCH file
  -fborland-xrtti         Enable extended RTTI information for Delphi style classes
  -fbuild-session-file=<file>
                          Use the last modification time of <file> as the build session timestamp
  -fbuild-session-timestamp=<time since Epoch in seconds>
                          Time when the current build session started
  -fbuiltin-module-map    Load the clang builtins module map file.
  -fclang-abi-compat=<version>
                          Attempt to match the ABI of Clang <version>
  -fcolor-diagnostics     Use colors in diagnostics
  -fcomment-block-commands=<arg>
                          Treat each comma separated argument in <arg> as a documentation comment block command
  -fcoroutines-ts         Enable support for the C++ Coroutines TS
  -fcoverage-mapping      Generate coverage mapping to enable code coverage analysis
  -fcuda-approx-transcendentals
                          Use approximate transcendental functions
  -fcuda-flush-denormals-to-zero
                          Flush denormal floating point values to zero in CUDA device mode.
  -fcxx-exceptions        Enable C++ exceptions
  -fdata-sections         Place each data in its own section (ELF Only)
  -fdebug-info-for-profiling
                          Emit extra debug info to make sample profile more accurate.
  -fdebug-macro           Emit macro debug information
  -fdebug-prefix-map=<value>
                          remap file source paths in debug info
  -fdebug-types-section   Place debug types in their own section (ELF Only)
  -fdeclspec              Allow __declspec as a keyword
  -fdelayed-template-parsing
                          Parse templated function definitions at the end of the translation unit
  -fdiagnostics-absolute-paths
                          Print absolute paths in diagnostics
  -fdiagnostics-hotness-threshold=<number>
                          Prevent optimization remarks from being output if they do not have at least this profile count
  -fdiagnostics-parseable-fixits
                          Print fix-its in machine parseable form
  -fdiagnostics-print-source-range-info
                          Print source range spans in numeric form
  -fdiagnostics-show-hotness
                          Enable profile hotness information in diagnostic line
  -fdiagnostics-show-note-include-stack
                          Display include stacks for diagnostic notes
  -fdiagnostics-show-option
                          Print option name with mappable diagnostics
  -fdiagnostics-show-template-tree
                          Print a template comparison tree for differing templates
  -fdollars-in-identifiers
                          Allow '$' in identifiers
  -fembed-bitcode-marker  Embed placeholder LLVM IR data as a marker
  -fembed-bitcode=        Embed LLVM bitcode (option: off, all, bitcode, marker)
  -fembed-bitcode         Embed LLVM IR bitcode as data
  -femit-all-decls        Emit all declarations, even if unused
  -femulated-tls          Use emutls functions to access thread_local variables
  -fexceptions            Enable support for exception handling
  -fexperimental-new-pass-manager
                          Enables an experimental new pass manager in LLVM.
  -ffast-math             Allow aggressive, lossy floating-point optimizations
  -ffixed-r9              Reserve the r9 register (ARM only)
  -ffixed-x18             Reserve the x18 register (AArch64 only)
  -ffp-contract=<value>   Form fused FP ops (e.g. FMAs): fast (everywhere) | on (according to FP_CONTRACT pragma, default) | off (never fuse)
  -ffreestanding          Assert that the compilation takes place in a freestanding environment
  -ffunction-sections     Place each function in its own section (ELF Only)
  -fgnu-keywords          Allow GNU-extension keywords regardless of language standard
  -fgnu-runtime           Generate output compatible with the standard GNU Objective-C runtime
  -fgnu89-inline          Use the gnu89 inline semantics
  -fimplicit-module-maps  Implicitly search the file system for module map files.
  -finline-functions      Inline suitable functions
  -finline-hint-functions Inline functions which are (explicitly or implicitly) marked inline
  -finstrument-functions  Generate calls to instrument function entry and exit
  -fintegrated-as         Enable the integrated assembler
  -flto-jobs=<value>      Controls the backend parallelism of -flto=thin (default of 0 means the number of threads will be derived from the number of CPUs detected)
  -flto=<value>           Set LTO mode to either 'full' or 'thin'
  -flto                   Enable LTO in 'full' mode
  -fmath-errno            Require math functions to indicate errors by setting errno
  -fmax-type-align=<value>
                          Specify the maximum alignment to enforce on pointers lacking an explicit alignment
  -fmodule-file=<file>    Load this precompiled module file
  -fmodule-map-file=<file>
                          Load this module map file
  -fmodule-name=<name>    Specify the name of the module to build
  -fmodules-cache-path=<directory>
                          Specify the module cache path
  -fmodules-decluse       Require declaration of modules used within a module
  -fmodules-disable-diagnostic-validation
                          Disable validation of the diagnostic options when loading the module
  -fmodules-ignore-macro=<value>
                          Ignore the definition of the given macro when building and loading modules
  -fmodules-prune-after=<seconds>
                          Specify the interval (in seconds) after which a module file will be considered unused
  -fmodules-prune-interval=<seconds>
                          Specify the interval (in seconds) between attempts to prune the module cache
  -fmodules-search-all    Search even non-imported modules to resolve references
  -fmodules-strict-decluse
                          Like -fmodules-decluse but requires all headers to be in modules
  -fmodules-ts            Enable support for the C++ Modules TS
  -fmodules-user-build-path <directory>
                          Specify the module user build path
  -fmodules-validate-once-per-build-session
                          Don't verify input files for the modules if the module has been successfully validated or loaded during this build session
  -fmodules-validate-system-headers
                          Validate the system headers that a module depends on when loading the module
  -fmodules               Enable the 'modules' language feature
  -fms-compatibility-version=<value>
                          Dot-separated value representing the Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))
  -fms-compatibility      Enable full Microsoft Visual C++ compatibility
  -fms-extensions         Accept some non-standard constructs supported by the Microsoft compiler
  -fmsc-version=<value>   Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))
  -fnew-alignment=<align> Specifies the largest alignment guaranteed by '::operator new(size_t)'
  -fno-access-control     Disable C++ access control
  -fno-assume-sane-operator-new
                          Don't assume that C++'s global operator new can't alias any pointer
  -fno-autolink           Disable generation of linker directives for automatic library linking
  -fno-builtin-<value>    Disable implicit builtin knowledge of a specific function
  -fno-builtin            Disable implicit builtin knowledge of functions
  -fno-common             Compile common globals like normal definitions
  -fno-constant-cfstrings Disable creation of CodeFoundation-type constant strings
  -fno-coverage-mapping   Disable code coverage analysis
  -fno-crash-diagnostics  Disable auto-generation of preprocessed source files and a script for reproduction during a clang crash
  -fno-debug-info-for-profiling
                          Do not emit extra debug info for sample profiler.
  -fno-debug-macro        Do not emit macro debug information
  -fno-declspec           Disallow __declspec as a keyword
  -fno-delayed-template-parsing
                          Disable delayed template parsing
  -fno-diagnostics-fixit-info
                          Do not include fixit information in diagnostics
  -fno-dollars-in-identifiers
                          Disallow '$' in identifiers
  -fno-elide-constructors Disable C++ copy constructor elision
  -fno-elide-type         Do not elide types when printing diagnostics
  -fno-experimental-new-pass-manager
                          Disables an experimental new pass manager in LLVM.
  -fno-gnu-inline-asm     Disable GNU style inline asm
  -fno-integrated-as      Disable the integrated assembler
  -fno-jump-tables        Do not use jump tables for lowering switches
  -fno-lax-vector-conversions
                          Disallow implicit conversions between vectors with a different number of elements or different element types
  -fno-lto                Disable LTO mode (default)
  -fno-merge-all-constants
                          Disallow merging of constants
  -fno-objc-infer-related-result-type
                          do not infer Objective-C related result type based on method family
  -fno-operator-names     Do not treat C++ operator name keywords as synonyms for operators
  -fno-preserve-as-comments
                          Do not preserve comments in inline assembly
  -fno-profile-generate   Disable generation of profile instrumentation.
  -fno-profile-instr-generate
                          Disable generation of profile instrumentation.
  -fno-profile-instr-use  Disable using instrumentation data for profile-guided optimization
  -fno-reroll-loops       Turn off loop reroller
  -fno-rtlib-add-rpath    Do not add -rpath with architecture-specific resource directory to the linker flags
  -fno-rtti               Disable generation of rtti information
  -fno-sanitize-address-use-after-scope
                          Disable use-after-scope detection in AddressSanitizer
  -fno-sanitize-blacklist Don't use blacklist file for sanitizers
  -fno-sanitize-cfi-cross-dso
                          Disable control flow integrity (CFI) checks for cross-DSO calls.
  -fno-sanitize-coverage=<value>
                          Disable specified features of coverage instrumentation for Sanitizers
  -fno-sanitize-memory-track-origins
                          Disable origins tracking in MemorySanitizer
  -fno-sanitize-recover=<value>
                          Disable recovery for specified sanitizers
  -fno-sanitize-stats     Disable sanitizer statistics gathering.
  -fno-sanitize-thread-atomics
                          Disable atomic operations instrumentation in ThreadSanitizer
  -fno-sanitize-thread-func-entry-exit
                          Disable function entry/exit instrumentation in ThreadSanitizer
  -fno-sanitize-thread-memory-access
                          Disable memory access instrumentation in ThreadSanitizer
  -fno-sanitize-trap=<value>
                          Disable trapping for specified sanitizers
  -fno-short-wchar        Force wchar_t to be an unsigned int
  -fno-show-column        Do not include column number on diagnostics
  -fno-show-source-location
                          Do not include source location information with diagnostics
  -fno-signed-char        Char is unsigned
  -fno-signed-zeros       Allow optimizations that ignore the sign of floating point zeros
  -fno-spell-checking     Disable spell-checking
  -fno-stack-protector    Disable the use of stack protectors
  -fno-standalone-debug   Limit debug information produced to reduce size of debug binary
  -fno-threadsafe-statics Do not emit code to make initialization of local statics thread safe
  -fno-trigraphs          Do not process trigraph sequences
  -fno-unroll-loops       Turn off loop unroller
  -fno-use-cxa-atexit     Don't use __cxa_atexit for calling destructors
  -fno-use-init-array     Don't use .init_array instead of .ctors
  -fobjc-arc-exceptions   Use EH-safe code when synthesizing retains and releases in -fobjc-arc
  -fobjc-arc              Synthesize retain and release calls for Objective-C pointers
  -fobjc-exceptions       Enable Objective-C exceptions
  -fobjc-runtime=<value>  Specify the target Objective-C runtime kind and version
  -fobjc-weak             Enable ARC-style weak references in Objective-C
  -fopenmp-targets=<value>
                          Specify comma-separated list of triples OpenMP offloading targets to be supported
  -foptimization-record-file=<value>
                          Specify the file name of any generated YAML optimization record
  -fpack-struct=<value>   Specify the default maximum struct packing alignment
  -fpascal-strings        Recognize and construct Pascal-style string literals
  -fpcc-struct-return     Override the default ABI to return all structs on the stack
  -fplugin=<dsopath>      Load the named plugin (dynamic shared object)
  -fprebuilt-module-path=<directory>
                          Specify the prebuilt module path
  -fprofile-generate=<directory>
                          Generate instrumented code to collect execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)
  -fprofile-generate      Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)
  -fprofile-instr-generate=<file>
                          Generate instrumented code to collect execution counts into <file> (overridden by LLVM_PROFILE_FILE env var)
  -fprofile-instr-generate
                          Generate instrumented code to collect execution counts into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)
  -fprofile-instr-use=<value>
                          Use instrumentation data for profile-guided optimization
  -fprofile-sample-use=<value>
                          Enable sample-based profile guided optimizations
  -fprofile-use=<pathname>
                          Use instrumentation data for profile-guided optimization. If pathname is a directory, it reads from <pathname>/default.profdata. Otherwise, it reads from file <pathname>.
  -freciprocal-math       Allow division operations to be reassociated
  -freg-struct-return     Override the default ABI to return small structs in registers
  -frelaxed-template-template-args
                          Enable C++17 relaxed template template argument matching
  -freroll-loops          Turn on loop reroller
  -frtlib-add-rpath       Add -rpath with architecture-specific resource directory to the linker flags
  -fsanitize-address-field-padding=<value>
                          Level of field padding for AddressSanitizer
  -fsanitize-address-globals-dead-stripping
                          Enable linker dead stripping of globals in AddressSanitizer
  -fsanitize-address-use-after-scope
                          Enable use-after-scope detection in AddressSanitizer
  -fsanitize-blacklist=<value>
                          Path to blacklist file for sanitizers
  -fsanitize-cfi-cross-dso
                          Enable control flow integrity (CFI) checks for cross-DSO calls.
  -fsanitize-coverage=<value>
                          Specify the type of coverage instrumentation for Sanitizers
  -fsanitize-memory-track-origins=<value>
                          Enable origins tracking in MemorySanitizer
  -fsanitize-memory-track-origins
                          Enable origins tracking in MemorySanitizer
  -fsanitize-memory-use-after-dtor
                          Enable use-after-destroy detection in MemorySanitizer
  -fsanitize-recover=<value>
                          Enable recovery for specified sanitizers
  -fsanitize-stats        Enable sanitizer statistics gathering.
  -fsanitize-thread-atomics
                          Enable atomic operations instrumentation in ThreadSanitizer (default)
  -fsanitize-thread-func-entry-exit
                          Enable function entry/exit instrumentation in ThreadSanitizer (default)
  -fsanitize-thread-memory-access
                          Enable memory access instrumentation in ThreadSanitizer (default)
  -fsanitize-trap=<value> Enable trapping for specified sanitizers
  -fsanitize-undefined-strip-path-components=<number>
                          Strip (or keep only, if negative) a given number of path components when emitting check metadata.
  -fsanitize=<check>      Turn on runtime checks for various forms of undefined or suspicious behavior. See user manual for available checks
  -fsave-optimization-record
                          Generate a YAML optimization record file
  -fshort-enums           Allocate to an enum type only as many bytes as it needs for the declared range of possible values
  -fshort-wchar           Force wchar_t to be a short unsigned int
  -fshow-overloads=<value>
                          Which overload candidates to show when overload resolution fails: best|all; defaults to all
  -fsized-deallocation    Enable C++14 sized global deallocation functions
  -fsjlj-exceptions       Use SjLj style exceptions
  -fslp-vectorize         Enable the superword-level parallelism vectorization passes
  -fsplit-dwarf-inlining  Place debug types in their own section (ELF Only)
  -fstack-protector-all   Force the usage of stack protectors for all functions
  -fstack-protector-strong
                          Use a strong heuristic to apply stack protectors to functions
  -fstack-protector       Enable stack protectors for functions potentially vulnerable to stack smashing
  -fstandalone-debug      Emit full debug info for all types used by the program
  -fstrict-enums          Enable optimizations based on the strict definition of an enum's value range
  -fstrict-return         Always treat control flow paths that fall off the end of a non-void function as unreachable
  -fstrict-vtable-pointers
                          Enable optimizations based on the strict rules for overwriting polymorphic C++ objects
  -fthinlto-index=<value> Perform ThinLTO importing using provided function summary index
  -ftrap-function=<value> Issue call to specified function rather than a trap instruction
  -ftrapv-handler=<function name>
                          Specify the function to be called on overflow
  -ftrapv                 Trap on integer overflow
  -ftrigraphs             Process trigraph sequences
  -funique-section-names  Use unique names for text and data sections (ELF Only)
  -funroll-loops          Turn on loop unroller
  -fuse-init-array        Use .init_array instead of .ctors
  -fveclib=<value>        Use the given vector functions library
  -fvectorize             Enable the loop vectorization passes
  -fvisibility-inlines-hidden
                          Give inline C++ member functions default visibility by default
  -fvisibility-ms-compat  Give global types 'default' visibility and global functions and variables 'hidden' visibility by default
  -fvisibility=<value>    Set the default symbol visibility for all global declarations
  -fwhole-program-vtables Enables whole-program vtable optimization. Requires -flto
  -fwrapv                 Treat signed integer overflow as two's complement
  -fwritable-strings      Store string literals as writable data
  -fxray-always-instrument= <value>
                          Filename defining the whitelist for imbuing the 'always instrument' XRay attribute.
  -fxray-instruction-threshold= <value>
                          Sets the minimum function size to instrument with XRay
  -fxray-instrument       Generate XRay instrumentation sleds on function entry and exit
  -fxray-never-instrument= <value>
                          Filename defining the whitelist for imbuing the 'never instrument' XRay attribute.
  -fzvector               Enable System z vector language extension
  -F <value>              Add directory to framework include search path
  --gcc-toolchain=<value> Use the gcc toolchain at the given directory
  -gcodeview              Generate CodeView debug information
  -gdwarf-2               Generate source-level debug information with dwarf version 2
  -gdwarf-3               Generate source-level debug information with dwarf version 3
  -gdwarf-4               Generate source-level debug information with dwarf version 4
  -gdwarf-5               Generate source-level debug information with dwarf version 5
  -gline-tables-only      Emit debug line number tables only
  -gmodules               Generate debug info with external references to clang modules or precompiled headers
  -gz=<value>             DWARF debug sections compression type
  -gz                     DWARF debug sections compression type
  -G <size>               Put objects of at most <size> bytes into small data section (MIPS / Hexagon)
  -g                      Generate source-level debug information
  -help                   Display available options
  -H                      Show header includes and nesting depth
  -I-                     Restrict all prior -I flags to double-quoted inclusion and remove current directory from include path
  -idirafter <value>      Add directory to AFTER include search path
  -iframeworkwithsysroot <directory>
                          Add directory to SYSTEM framework search path, absolute paths are relative to -isysroot
  -iframework <value>     Add directory to SYSTEM framework search path
  --ilink-no-cfg          Do not use cfg file for Borland linker
  -imacros <file>         Include macros from file before parsing
  -include-pch <file>     Include precompiled header file
  -include <file>         Include file before parsing
  -index-header-map       Make the next included directory (-I or -F) an indexer header map
  -iprefix <dir>          Set the -iwithprefix/-iwithprefixbefore prefix
  -iquote <directory>     Add directory to QUOTE include search path
  -isysroot <dir>         Set the system root directory (usually /)
  -isystem-after <directory>
                          Add directory to end of the SYSTEM include search path
  -isystem <directory>    Add directory to SYSTEM include search path
  -ivfsoverlay <value>    Overlay the virtual filesystem described by file over the real file system
  -iwithprefixbefore <dir>
                          Set directory to include search path with prefix
  -iwithprefix <dir>      Set directory to SYSTEM include search path with prefix
  -iwithsysroot <directory>
                          Add directory to SYSTEM include search path, absolute paths are relative to -isysroot
  -I <dir>                Add directory to include search path
  --jobs=<N>              Perform a parallel compilation with a maximum of <N> processes
  -L <dir>                Add directory to library search path
  -mabicalls              Enable SVR4-style position-independent code (Mips only)
  -malign-double          Align doubles to two words in structs (x86 only)
  -mbackchain             Link stack frames through backchain on System Z
  -mcdecl                 Make CDecl calling convention the default
  -mcrc                   Allow use of CRC instructions (ARM only)
  -MD                     Write a depfile containing user and system headers
  -meabi <value>          Set EABI type, e.g. 4, 5 or gnu (default depends on triple)
  -mexecute-only          Disallow generation of data access to code sections (ARM only)
  -mfastcall              Make FastCall calling convention the default
  -mfentry                Insert calls to fentry at function entry (x86 only)
  -mfix-cortex-a53-835769 Workaround Cortex-A53 erratum 835769 (AArch64 only)
  -mfp32                  Use 32-bit floating point registers (MIPS only)
  -mfp64                  Use 64-bit floating point registers (MIPS only)
  -MF <file>              Write depfile output from -MMD, -MD, -MM, or -M to <file>
  -mgeneral-regs-only     Generate code which only uses the general purpose registers (AArch64 only)
  -mglobal-merge          Enable merging of globals
  -MG                     Add missing headers to depfile
  -mhvx-double            Enable Hexagon Double Vector eXtensions
  -mhvx                   Enable Hexagon Vector eXtensions
  -miamcu                 Use Intel MCU ABI
  --migrate               Run the migrator
  -mincremental-linker-compatible
                          (integrated-as) Emit an object file which can be used with an incremental linker
  -mindirect-jump=<value> Change indirect jump instructions to inhibit speculation
  -mios-version-min=<value>
                          Set iOS deployment target
  -MJ <value>             Write a compilation database entry per input
  -mllvm <value>          Additional arguments to forward to LLVM's option processing
  -mlong-calls            Generate branches with extended addressability, usually via indirect jumps.
  -mmacosx-version-min=<value>
                          Set Mac OS X deployment target
  -mmadd4                 Enable the generation of 4-operand madd.s, madd.d and related instructions.
  -MMD                    Write a depfile containing user headers
  -mms-bitfields          Set the default structure layout to be compatible with the Microsoft compiler standard
  -mmsa                   Enable MSA ASE (MIPS only)
  -mmt                    Enable MT ASE (MIPS only)
  -MM                     Like -MMD, but also implies -E and writes to stdout by default
  -mno-abicalls           Disable SVR4-style position-independent code (Mips only)
  -mno-cdecl              Do not make CDecl calling convention the default
  -mno-execute-only       Allow generation of data access to code sections (ARM only)
  -mno-fastcall           Do not make FastCall calling convention the default
  -mno-fix-cortex-a53-835769
                          Don't workaround Cortex-A53 erratum 835769 (AArch64 only)
  -mno-global-merge       Disable merging of globals
  -mno-hvx-double         Disable Hexagon Double Vector eXtensions
  -mno-hvx                Disable Hexagon Vector eXtensions
  -mno-implicit-float     Don't generate implicit floating point instructions
  -mno-incremental-linker-compatible
                          (integrated-as) Emit an object file which cannot be used with an incremental linker
  -mno-long-calls         Restore the default behaviour of not generating long calls
  -mno-madd4              Disable the generation of 4-operand madd.s, madd.d and related instructions.
  -mno-movt               Disallow use of movt/movw pairs (ARM only)
  -mno-ms-bitfields       Do not set the default structure layout to be compatible with the Microsoft compiler standard
  -mno-msa                Disable MSA ASE (MIPS only)
  -mno-mt                 Disable MT ASE (MIPS only)
  -mno-neg-immediates     Disallow converting instructions with negative immediates to their negation or inversion.
  -mno-restrict-it        Allow generation of deprecated IT blocks for ARMv8. It is off by default for ARMv8 Thumb mode
  -mno-stdcall            Do not make StdCall calling convention the default
  -mno-unaligned-access   Force all memory accesses to be aligned (AArch32/AArch64 only)
  -mnocrc                 Disallow use of CRC instructions (ARM only)
  -module-dependency-dir <value>
                          Directory to dump module dependencies to
  -module-file-info       Provide information about a particular module file
  -momit-leaf-frame-pointer
                          Omit frame pointer setup for leaf functions
  -mpie-copy-relocations  Use copy relocations support for PIE builds
  -MP                     Create phony target for each dependency (other than main file)
  -mqdsp6-compat          Enable hexagon-qdsp6 backward compatibility
  -MQ <value>             Specify name of main file output to quote in depfile
  -mrelax-all             (integrated-as) Relax all machine instructions
  -mrestrict-it           Disallow generation of deprecated IT blocks for ARMv8. It is on by default for ARMv8 Thumb mode.
  -mrtd                   Make StdCall calling convention the default
  -msoft-float            Use software floating point
  -mstack-alignment=<value>
                          Set the stack alignment
  -mstack-probe-size=<value>
                          Set the stack probe size
  -mstackrealign          Force realign the stack at entry to every function
  -mstdcall               Make StdCall calling convention the default
  -mthread-model <value>  The thread model to use, e.g. posix, single (posix by default)
  -MT <value>             Specify name of main file output in depfile
  -munaligned-access      Allow memory accesses to be unaligned (AArch32/AArch64 only)
  -MV                     Use NMake/Jom format for the depfile
  -M                      Like -MD, but also implies -E and writes to stdout by default
  --no-cuda-gpu-arch=<value>
                          Remove GPU architecture (e.g. sm_35) from the list of GPUs to compile for. 'all' resets the list to its default value.
  --no-cuda-version-check Don't error out if the detected version of the CUDA install is too low for the requested CUDA gpu architecture.
  --no-system-header-prefix=<prefix>
                          Treat all #include paths starting with <prefix> as not including a system header.
  -nobuiltininc           Disable builtin #include directories
  -nostdinc++             Disable standard #include directories for the C++ standard library
  -ObjC++                 Treat source input files as Objective-C++ inputs
  -objcmt-atomic-property Make migration to 'atomic' properties
  -objcmt-migrate-all     Enable migration to modern ObjC
  -objcmt-migrate-annotation
                          Enable migration to property and method annotations
  -objcmt-migrate-designated-init
                          Enable migration to infer NS_DESIGNATED_INITIALIZER for initializer methods
  -objcmt-migrate-instancetype
                          Enable migration to infer instancetype for method result type
  -objcmt-migrate-literals
                          Enable migration to modern ObjC literals
  -objcmt-migrate-ns-macros
                          Enable migration to NS_ENUM/NS_OPTIONS macros
  -objcmt-migrate-property-dot-syntax
                          Enable migration of setter/getter messages to property-dot syntax
  -objcmt-migrate-property
                          Enable migration to modern ObjC property
  -objcmt-migrate-protocol-conformance
                          Enable migration to add protocol conformance on classes
  -objcmt-migrate-readonly-property
                          Enable migration to modern ObjC readonly property
  -objcmt-migrate-readwrite-property
                          Enable migration to modern ObjC readwrite property
  -objcmt-migrate-subscripting
                          Enable migration to modern ObjC subscripting
  -objcmt-ns-nonatomic-iosonly
                          Enable migration to use NS_NONATOMIC_IOSONLY macro for setting property's 'atomic' attribute
  -objcmt-returns-innerpointer-property
                          Enable migration to annotate property with NS_RETURNS_INNER_POINTER
  -objcmt-whitelist-dir-path=<value>
                          Only modify files with a filename contained in the provided directory path
  -ObjC                   Treat source input files as Objective-C inputs
  -output-dir <directory> Write object files to <directory>
  -o <file>               Write output to <file>
  -PC<N>                  (deprecated, use --jobs=<N> instead) Perform a parallel compilation with a maximum of <N> processes
  -pg                     Enable mcount instrumentation
  -pipe                   Use pipes between commands, when possible
  --precompile            Only precompile the input
  -print-file-name=<file> Print the full library path of <file>
  -print-ivar-layout      Enable Objective-C Ivar layout bitmap print trace
  -print-libgcc-file-name Print the library path for the currently used compiler runtime library ("libgcc.a" or "libclang_rt.builtins.*.a")
  -print-prog-name=<name> Print the full program path of <name>
  -print-resource-dir     Print the resource directory pathname
  -print-search-dirs      Print the paths used for finding libraries and programs
  -pthread                Support POSIX threads in generated code
  --ptxas-path=<value>    Path to ptxas (used for compiling CUDA code)
  -P                      Disable linemarker output in -E mode
  -Qunused-arguments      Don't emit warning for unused driver arguments
  -q                      Suppress compiler identification banner
  -relocatable-pch        Whether to build a relocatable precompiled header
  -rewrite-legacy-objc    Rewrite Legacy Objective-C source to C++
  -rewrite-objc           Rewrite Objective-C source to C++
  -Rpass-analysis=<value> Report transformation analysis from optimization passes whose name matches the given POSIX regular expression
  -Rpass-missed=<value>   Report missed transformations by optimization passes whose name matches the given POSIX regular expression
  -Rpass=<value>          Report transformations performed by optimization passes whose name matches the given POSIX regular expression
  -rtlib=<value>          Compiler runtime library to use
  -R<remark>              Enable the specified remark
  -save-stats=<value>     Save llvm statistics.
  -save-stats             Save llvm statistics.
  -save-temps=<value>     Save intermediate compilation results.
  -save-temps             Save intermediate compilation results
  -serialize-diagnostics <value>
                          Serialize compiler diagnostics to a file
  -std=<value>            Language standard to compile for
  -stdlib=<value>         C++ standard library to use
  --system-header-prefix=<prefix>
                          Treat all #include paths starting with <prefix> as including a system header.
  -S                      Only run preprocess and compilation steps
  --target=<value>        Generate code for the given target
  -Tbss <addr>            Set starting address of BSS to <addr>
  -Tdata <addr>           Set starting address of BSS to <addr>
  -time                   Time individual commands
  -traditional-cpp        Enable some traditional CPP emulation
  -trigraphs              Process trigraph sequences
  -Ttext <addr>           Set starting address of BSS to <addr>
  -T <script>             Specify <script> as linker script
  -t<value>               Specify Borland target executable
  -undef                  undef all system defines
  -U <macro>              Undefine macro <macro>
  --verify-debug-info     Verify the binary representation of debug output
  -verify-pch             Load and verify that a pre-compiled header file is not stale
  -v                      Show commands to run and use verbose output
  -Wa,<arg>               Pass the comma separated arguments in <arg> to the assembler
  -Wdeprecated            Enable warnings for deprecated constructs and define __DEPRECATED
  -Wl,<arg>               Pass the comma separated arguments in <arg> to the linker
  -working-directory <value>
                          Resolve file paths relative to the specified directory
  -Wp,<arg>               Pass the comma separated arguments in <arg> to the preprocessor
  -W<warning>             Enable the specified warning
  -w                      Suppress all warnings
  -Xanalyzer <arg>        Pass <arg> to the static analyzer
  -Xassembler <arg>       Pass <arg> to the assembler
  -Xclang <arg>           Pass <arg> to the clang compiler
  -Xcuda-fatbinary <arg>  Pass <arg> to fatbinary invocation
  -Xcuda-ptxas <arg>      Pass <arg> to the ptxas assembler
  -Xdriver <arg>          Pass <arg> directly to the clang compiler
  -Xlinker <arg>          Pass <arg> to the linker
  -Xpreprocessor <arg>    Pass <arg> to the preprocessor
  -x <language>           Treat subsequent input files as having type <language>
  -z <arg>                Pass -z <arg> to the linker
  +<arg>                  Load user specified configuration file

BCompareLite.exe Description

The executable BCompareLite.exe in your Embarcadero RAD Studio 13 Architect installation is the "Lite" version of Beyond Compare, a popular data management and comparison utility developed by Scooter Software.

💻 Functionality Summary

Beyond Compare is designed to help users quickly and easily compare, merge, and synchronize different types of data.

Comparison: It can compare files (text files, source code, data files, images, executables, binary data, etc.) and folders (including whole directory structures, FTP sites, cloud storage, and zip files). It highlights the differences, allowing developers to see exactly what has changed between two versions.
Merging: It provides a merge view to combine changes from two versions of a file or folder into a single output, which is crucial for version control and collaborative development.
Synchronization: Its Folder Sync interface allows users to automatically reconcile differences between data locations, which is useful for backups, updating a laptop, or managing a website.

The "Lite" version included with RAD Studio Architect editions is a slightly reduced version of the full Beyond Compare product, but still provides powerful comparison and merging capabilities tailored for developers.

🛠️ Usage: IDE Integration vs. Standalone

The application is not strictly used by the Delphi IDE; it can be used as a standalone application.

IDE Integration: The primary way developers in the RAD Studio environment use it is through the direct integration with the Delphi and C++Builder IDEs. This allows you to launch the comparison tool directly from the IDE (e.g., to compare local code with code in a source control system).
Standalone Use: Since BCompareLite.exe is a standalone executable, you can also launch it directly from the Windows file system (or command line) and use it for any general file or folder comparison task outside of the Delphi IDE.

The inclusion of Beyond Compare Lite within the Architect edition of RAD Studio highlights its value as a powerful, dedicated tool for the specific comparison and merging tasks common to software development.

BDSFileCopyHelper.exe Description

Executable: BDSFileCopyHelper.exe
Installed with: Embarcadero RAD Studio 13 Architect
Location: <RAD Studio Install Dir>\bin\BDSFileCopyHelper.exe

Summary / Description

BDSFileCopyHelper.exe is a support utility used internally by the RAD Studio IDE (including Delphi and C++Builder) to handle file copy operations that require elevated privileges or must be performed outside the IDE process context.

Its main roles typically include:

Copying files as part of project deployment, build, or debug operations (e.g., when deploying to local or remote directories).
Handling post-build copy tasks that need to work even when the main IDE process does not have the necessary permissions.
Supporting the Platform Deployment Manager within the IDE, which copies application binaries, libraries, and support files to specific target locations.
Executing background or silent copy tasks launched by the IDE via command line parameters (the executable does not have its own UI).

Intended Usage

✅ Used by the Delphi/C++Builder IDE internally � primarily invoked by the IDE during build or deploy operations.
⚙️ Command-line capable, but not documented for standalone user use. It expects internal command-line arguments (e.g., source path, destination path, flags) that are generated by the IDE, not manually provided.
🚫 Not intended for standalone use. Running it directly without parameters will generally do nothing visible or return an error.

In Short

Purpose: Performs elevated or background file copy operations for RAD Studio.
User Interface: None (command-line only).
Used by: The Delphi/C++Builder IDE during builds, deployments, and related automated tasks.
Standalone Use: Not practical or supported; meant for IDE internal use.

bdsreg.exe Description

Executable: bdsreg.exe
Location: Embarcadero RAD Studio 13 Architect → bin directory

Summary / Functionality

bdsreg.exe is the RAD Studio registration and licensing utility. It is primarily used by the Delphi/C++Builder IDE (BDS � Borland Developer Studio, the historical internal name of the IDE) to manage license registration, activation, and configuration of Embarcadero products.

This tool handles:

Product registration using a serial number or license file.
Communication with the Embarcadero licensing servers for online activation.
Importing or exporting registration data (for offline registration).
Managing named user or network license configurations.
Storing registration details in the Windows Registry and configuration files under %ProgramData%\Embarcadero and %AppData%\Embarcadero.

It is a backend component used during installation, first launch of the IDE, or when license validation fails or changes (e.g., after hardware modifications).

Usage Context

Primarily used by the Delphi/C++Builder IDE (BDS):
The IDE and installer invoke bdsreg.exe automatically when registration or license validation is required.
Command-line use (Standalone):
Yes � bdsreg.exe can be used as a standalone utility for advanced or scripted registration management.
It supports command-line arguments, such as:

� bdsreg.exe -h

� bdsreg.exe --import license.slip

� bdsreg.exe --export license.slip

� bdsreg.exe --register serialnumber email password

� bdsreg.exe --check

(Exact parameters may vary slightly by RAD Studio version.)

This allows administrators to automate registration or activation in environments where multiple seats or offline machines are managed.

Typical Use Cases

During IDE installation or activation.
When repairing or migrating a RAD Studio installation.
When needing to re-register or import a .slip (offline license) file.
In enterprise setups to preconfigure or silently register installations.

Conclusion

bdsreg.exe is a core registration utility that the Delphi/C++Builder IDE relies on for license handling.
While it is integrated with the IDE and installer, it can also be run independently from the command line for license administration or automation purposes � typically by IT administrators or power users.

BDSSetLang.exe Description

BDSSetLang.exe is a utility included with Embarcadero RAD Studio 13 Architect that manages language localization settings for the IDE (the �BDS� � Borland Developer Studio � core).

🔍 Summary of Functionality:

Purpose:
It allows you to set or change the language used by the RAD Studio IDE and its tools (for example, English, German, French, or Japanese).
Usage Context:
Usually executed during installation or post-install configuration to switch the IDE�s user interface language or apply language packs.
Operation:

It updates internal configuration files (like registry entries or .xml settings) that define which resource DLLs (localized language files) the IDE loads.
It can be run manually or automatically by the installer when applying a language pack.

Typical Location:
C:\Program Files (x86)\Embarcadero\Studio\23.0\bin\BDSSetLang.exe (version number may vary by release).
Typical Command Line Usage:
BDSSetLang.exe <language-code>

Examples:

BDSSetLang.exe en → set IDE to English
BDSSetLang.exe de → set IDE to German

🧭 In short:

BDSSetLang.exe configures which language the RAD Studio IDE uses for menus, dialogs, and messages by setting the active language resource files. It�s part of RAD Studio�s multilingual support system, not used for compiling or debugging code.

BDSSetLang.exe Commandline Switches

RAD Studio language configuration tool
Copyright (c) 2025 Embarcadero Technologies, Inc.
Syntax:  BDSSetLang [options] [New UI Language]
  Options:
    /I : GUI mode
    /? : Help message

This tool will modify the following directory and application:
C:\Program Files (x86)\Embarcadero\Studio\37.0\bin\

 You can select the following language: 
   DE
   EN
   FR
   JA

BitmapStyleDesigner.exe Description

Bitmap Style Designer (BitmapStyleDesigner.exe) is a utility included with Embarcadero RAD Studio (including Delphi and C++Builder) that allows developers to create, edit, and manage bitmap-based visual styles for FireMonkey (FMX) applications.

Key Functionality:

Style Creation & Editing: Enables you to design custom visual styles by defining how UI controls (buttons, edit boxes, lists, etc.) appear using bitmap images.
Multi-Resolution Support: Supports creating styles for different screen resolutions and DPI settings (e.g., 1x, 1.5x, 2x scaling), which is essential for high-DPI and cross-platform FireMonkey apps.
Style Resource Management: Lets you organize style elements into a single style file (typically with a .style or embedded in a .res file) that can be loaded at runtime.
Preview Capabilities: Provides a visual preview of how styled components will look in your application.
Export/Import: Allows saving styles for reuse across projects or sharing with other developers.

Standalone vs. IDE Integration:

Standalone Application: Yes, BitmapStyleDesigner.exe can be run independently outside the Delphi IDE. You can launch it directly from the bin folder, open existing style files, create new ones, and save them for later use in your projects.
IDE Integration: It is also tightly integrated into the Delphi IDE. You can launch it from within the IDE (e.g., via menu options or by editing a style resource), and styles created or modified in the designer can be directly embedded into your project�s resources.

Typical Use Case:

A FireMonkey developer designing a custom UI theme for a mobile or desktop app might use Bitmap Style Designer to define how every control should look using custom graphics, then embed that style into the application and activate it at runtime using TStyleManager.

Supported Platforms:

Primarily used for FireMonkey (FMX) applications targeting Windows, macOS, iOS, and Android. It is not used for VCL applications, which rely on different theming mechanisms.

In summary, Bitmap Style Designer is both a standalone tool and an IDE-integrated utility for crafting bitmap-driven visual styles in FireMonkey applications.

brcc32.exe Description

Description of brcc32.exe

brcc32.exe is the Borland Resource Compiler, a command-line utility included in Embarcadero RAD Studio (including Delphi and C++ Builder). Its primary function is to compile Windows resource script files (.rc files) into binary resource files (.res files). These .res files contain resources like icons, bitmaps, dialogs, menus, strings, and version information, which are then linked into executable programs during the build process.

Key features and functionality:

Input/Output: It processes .rc files (text-based scripts defining resources) and outputs .res files (binary format usable by linkers).
Supported Resources: Handles standard Windows resources, including but not limited to cursors, icons, bitmaps, string tables, dialogs, menus, accelerators, and version info.
Error Handling: Reports compilation errors or warnings, such as syntax issues in .rc files or missing dependencies.
Integration: It's based on the Microsoft Resource Compiler (RC.EXE) but adapted for Borland/Embarcadero tools, ensuring compatibility with their compilers and linkers.
Command-Line Options: Supports flags like -v (verbose), -l (specify language), -d (define symbols), and -i (include directories), allowing customization for complex projects.

This tool is essential for embedding non-code assets into applications built with RAD Studio, ensuring resources are properly compiled and linked.

Standalone Usage

brcc32.exe is not strictly limited to the Delphi IDE or RAD Studio environment�it can be used as a standalone command-line application. While the IDE automatically invokes it during project builds (e.g., when compiling Delphi or C++ projects with resource files), you can run it manually from the command prompt or scripts outside the IDE.

Standalone Invocation: Open a command prompt, navigate to the RAD Studio bin directory (e.g., C:\Program Files (x86)\Embarcadero\Studio\23.0\bin), and execute commands like brcc32.exe MyResources.rc to compile a .rc file into MyResources.res.
Benefits of Standalone Use: Useful for batch processing, automation in build scripts (e.g., via Makefiles or CI/CD pipelines), or integrating with other development tools. It doesn't require the IDE to be running.
Limitations: It relies on RAD Studio's environment (e.g., paths to include files), so ensure the RAD Studio command prompt or proper environment variables are set. It's not a general-purpose resource compiler for non-Embarcadero projects, as it may not support all Microsoft RC features or third-party extensions.

For detailed command-line help, run brcc32.exe without arguments in a command prompt. If you encounter issues, refer to Embarcadero's documentation or community forums for RAD Studio-specific guidance.

brcc32.exe Commandline Switches

Borland Resource Compiler  Version 5.40
Copyright (c) 1990, 1999 Inprise Corporation.  All rights reserved.

Syntax: brcc32 [options ...] filename
  options marked with a '*' are on by default

  @<filename>        Take instructions from command file
  -r                    (ignored for compatibility)
  -16                   Build 16-bit Windows compatible .res file
  -32                 * Build 32-bit Windows compatible .res file
  -fofilename           Set output filename
  -v                    Verbose
  -ipath                Set include path
  -dname[=string]       Define #define
  -x                    Ignore INCLUDE environment variable
  -m                    Enable multi-byte character support
  -cdddd                set default code page to nnnn
  -lxxxx                set default language to xxxx
  -31   Provided for downward compatibility (build 16-bit .res file)
  -w32  Provided for downward compatibility (build 16-bit .res file)
  -? or -h              Display this message

cgconfig.exe Description

Functionality of cgconfig.exe

cgconfig.exe is a configuration utility bundled with Embarcadero RAD Studio installations, specifically designed for managing settings related to CodeGuard, which is a runtime error detection and debugging tool primarily used in C++Builder projects (part of RAD Studio). CodeGuard helps identify issues like memory leaks, uninitialized variables, and other runtime errors by instrumenting your compiled code.

Key features and configuration options accessible via cgconfig.exe include:

General Settings: Enable/disable CodeGuard entirely, set stack fill frequency, configure statistics reporting, and control debug information usage.
Resource Tracking: Monitor memory blocks, objects, files, sockets, and other resources for leaks or errors, with options to report them immediately or after a delay.
Function and Error Handling: Track specific functions (e.g., logging calls to new, delete, malloc), customize error reporting (e.g., popup messages, log files), and ignore certain modules or errors.
Output: Changes save to a project-specific .cgi configuration file (e.g., MyProject.cgi) in the same directory as your project file, which is then used during compilation and runtime.

When launched, it opens a graphical dialog with tabs for these categories, making it straightforward to tweak behaviors without deep command-line knowledge.

Usage: IDE-Integrated or Standalone?

While cgconfig.exe is often invoked from within the RAD Studio IDE (e.g., via the Tools menu under CodeGuard options for active projects), it is fully standalone. You can run it directly from the command line or by double-clicking the executable in the bin directory (e.g., C:\Program Files (x86)\Embarcadero\Studio\23.0\bin\cgconfig.exe for RAD Studio 13). This allows configuration of CodeGuard settings for any compatible C++ project, even outside the IDE�ideal for command-line builds, scripts, or third-party workflows. No IDE dependencies are required to launch or use it.

For the most up-to-date details in RAD Studio 13 (Athens), refer to the official Embarcadero documentation, as core functionality remains consistent across versions.

cgrc.exe Description

Functionality Summary of cgrc.exe

cgrc.exe is the CodeGear Resource Compiler, a command-line utility included with Embarcadero RAD Studio (including version 13 Athens/Architect edition). It is designed to compile Windows resource definition files (.rc scripts) into binary resource files (.res format). These compiled resources can then be embedded into Delphi, C++Builder, or cross-platform applications during the build process.

Key Features and Usage:

Primary Purpose: Processes resource scripts to generate .res files containing elements like:

Dialog boxes and forms.
String tables (for localization and UI text).
Icons, bitmaps, cursors, and other graphical assets.
Menus, accelerators, version information, and custom binary data.

Input/Output: Takes a .rc file as input and outputs a .res file. It supports standard Windows resource syntax and Embarcadero-specific extensions.
Command-Line Options: Highly configurable via flags, including:

-fo <output.res>: Specifies the output file.
-i <include_path>: Adds include directories for referenced resources.
-d <symbol>: Defines preprocessor symbols.
-l <language_id>: Specifies language for string resources (e.g., for multi-language support).
Verbose logging (-v) and error handling for debugging.

Integration: It leverages the underlying Windows RC compiler (rc.exe from the Windows SDK) but wraps it with Embarcadero-specific optimizations and error reporting tailored for Delphi/C++Builder ecosystems.
Performance: Optimized for large projects, with support for parallel compilation in some scenarios.

In essence, it's a build-time tool that ensures resources are correctly formatted and linked, preventing runtime issues like missing icons or untranslated strings.

Standalone vs. IDE Usage:

Not Strictly Tied to the Delphi IDE: While RAD Studio's IDE (Delphi or C++Builder) automatically invokes cgrc.exe during project builds (e.g., when compiling a .dproj or .bproj that includes .rc files), it is fully functional as a standalone command-line application.
Standalone Capability: You can run it directly from the Windows Command Prompt or PowerShell by navigating to your RAD Studio bin directory (e.g., C:\Program Files (x86)\Embarcadero\Studio\23.0\bin) and executing it with arguments. No IDE is required.

Example command:

text

cgrc.exe -fo MyResources.res MyResources.rc

This makes it ideal for automation in build scripts (e.g., via MSBuild, Jenkins, or batch files), CI/CD pipelines, or manual resource compilation outside of the IDE.

Dependencies: It requires access to the Windows SDK (included or referenced in RAD Studio installs) and any referenced files (e.g., .bmp images in the .rc). No additional licensing or setup is needed beyond your existing RAD Studio installation.

If you're encountering issues or need help with specific options/flags, check the RAD Studio documentation (Help > RAD Studio Help > Building > Resources) or run cgrc.exe /? for built-in help. For advanced scripting, it's often paired with tools like dcc32.exe (Delphi compiler) in automated workflows.

cgrc.exe Commandline Switches

CodeGear Resource Compiler/Binder
Version 1.2.3 Copyright (c) 2008-2025 Embarcadero Technologies Inc.

Syntax: cgrc [options ...] filename
  options marked with a '*' are on by default

  -r                    compile only. Do not bind resources
  -fofilename           set output res filename
  -fefilename           set output exe filename
  -v                    verbose
  -ipath                set include path
  -x                    ignore INCLUDE environment variable
  -dname[=string]       define #define
  -Vd.d                 mark .exe file with Windows version (4.0 default)
  -cdddd                set default code page to nnnn
  -lxxxx                set default language to xxxx
  -m                    enable multi-byte character support
  -? or -h              show this help

clang-format.exe Description

clang-format.exe in Embarcadero RAD Studio 13 Architect is a source code formatting tool that automatically reformats C, C++, Objective-C, and Delphi (partially) source files according to predefined or user-defined style rules.

Here�s a summary of its functionality:

🧭 Purpose

clang-format.exe is part of the LLVM/Clang toolchain integrated into RAD Studio. Its main job is to enforce consistent code style across projects by reformatting code based on style configuration files (like .clang-format).

⚙️ Key Functions

Automatic Code Formatting
Reformats source code to match the style guidelines defined in a .clang-format file or default settings (e.g., indentation, spacing, brace style).
Configuration File Support
Uses .clang-format files (YAML format) to define formatting options � such as indentation width, column limit, alignment, brace placement, etc.
Integration with IDE
RAD Studio (C++Builder and sometimes Delphi) can invoke clang-format.exe when you use IDE options like Format Source or Format Unit.
Command-Line Usage
Can be used directly in a terminal or build script:
clang-format.exe -i MySource.cpp

(-i tells it to edit files in place.)

Cross-Platform Consistency
Ensures consistent formatting whether the code is edited on Windows, macOS, or Linux � useful for team environments and version control.

🧩 Common Usage in RAD Studio

Automatically format C++Builder projects.
Apply consistent coding conventions in team projects.
Integrate into pre-commit hooks or CI/CD pipelines to enforce formatting before check-in.

💡 Example

If you have a .clang-format file with:

BasedOnStyle: Google

IndentWidth: 4

ColumnLimit: 100

then running:

clang-format.exe -i myfile.cpp

will reformat myfile.cpp according to those style rules.

clang-format.exe Commandline Switches

OVERVIEW: A tool to format C/C++/Java/JavaScript/Objective-C/Protobuf/C# code.

If no arguments are specified, it formats the code from standard input
and writes the result to the standard output.
If <file>s are given, it reformats the files. If -i is specified
together with <file>s, the files are edited in-place. Otherwise, the
result is written to the standard output.

USAGE: clang-format.exe [options] [<file> ...]

OPTIONS:
--Werror - If set, changes formatting warnings to errors
--Wno-error=<value> - If set don't error out on the specified warning type.
=unknown - If set, unknown format options are only warned about.
This can be used to enable formatting, even if the
configuration contains unknown (newer) options.
Use with caution, as this might lead to dramatically
differing format depending on an option being
supported or not.
--assume-filename=<string> - Override filename used to determine the language.
When reading from stdin, clang-format assumes this
filename to determine the language.
--cursor=<uint> - The position of the cursor when invoking
clang-format from an editor integration
--dry-run - If set, do not actually make the formatting changes
--dump-config - Dump configuration options to stdout and exit.
Can be used with -style option.
--fallback-style=<string> - The name of the predefined style used as a
fallback in case clang-format is invoked with
-style=file, but can not find the .clang-format
file to use.
Use -fallback-style=none to skip formatting.
--ferror-limit=<uint> - Set the maximum number of clang-format errors to emit before stopping (0 = no limit). Used only with --dry-run or -n
--help - Display available options (--help-hidden for more)
-i - Inplace edit <file>s, if specified.
--length=<uint> - Format a range of this length (in bytes).
Multiple ranges can be formatted by specifying
several -offset and -length pairs.
When only a single -offset is specified without
-length, clang-format will format up to the end
of the file.
Can only be used with one input file.
--lines=<string> - <start line>:<end line> - format a range of
lines (both 1-based).
Multiple ranges can be formatted by specifying
several -lines arguments.
Can't be used with -offset and -length.
Can only be used with one input file.
-n - Alias for --dry-run
--offset=<uint> - Format a range starting at this byte offset.
Multiple ranges can be formatted by specifying
several -offset and -length pairs.
Can only be used with one input file.
--output-replacements-xml - Output replacements as XML.
--sort-includes - If set, overrides the include sorting behavior determined by the SortIncludes style flag
--style=<string> - Coding style, currently supports:
LLVM, GNU, Google, Chromium, Microsoft, Mozilla, WebKit.
Use -style=file to load style configuration from
.clang-format file located in one of the parent
directories of the source file (or current
directory for stdin).
Use -style="{key: value, ...}" to set specific
parameters, e.g.:
-style="{BasedOnStyle: llvm, IndentWidth: 8}"
--verbose - If set, shows the list of processed files
--version - Display the version of this program

coff2omf.exe Description

The executable coff2omf.exe in Embarcadero RAD Studio 13 Architect is a converter utility that transforms object files from the COFF (Common Object File Format) format into the OMF (Object Module Format).

Here�s what that means in context:

COFF: A standard object file format used by many modern compilers and linkers (especially in 32-bit/64-bit Windows environments).
OMF: The older object file format traditionally used by Borland/Embarcadero compilers and linkers. Many of RAD Studio�s linker tools expect OMF input.

Primary purpose:
coff2omf.exe allows developers to use object files produced by COFF-based tools or libraries in the RAD Studio build process by converting them into OMF format, which can then be linked into Delphi or C++Builder projects.

Essentially, it�s a bridge between modern object files and RAD Studio�s traditional linker expectations.

coff2omf.exe Commandline Switches

COFF to OMF Converter Version 1.3.0 Copyright (c) 1999-2021 Embarcadero Technologies, Inc.
 All rights reserved.
Syntax:   COFF2OMF [options] InputFile OutputFile
  -h, -?  Display help
  -h2     Display extra help
  -q      Quiet mode
  -v      Verbose mode
  -r      Remove (delete) output file if empty
  -lib:xx Specify options for OMF import library generation:
       ms - Allow entries that have MS C++ name mangling (default: no)
       st - Normalize names instead of aliasing MS stdcall mangling
       ca - Don't perform MS cdecl aliasing (default is to alias)

COFF2OMF will convert a COFF import library file (InputFile)
to the corresponding OMF type import library file (OutputFile).

convert.exe Description

convert.exe is a command-line utility included with Embarcadero RAD Studio (and its predecessors like Delphi and C++Builder) for converting Delphi Form (DFM) files between binary and text (ASCII) formats. DFM files store the visual layout, properties, and components of forms in Delphi/C++Builder applications. Binary DFMs are the default compact format since early Delphi versions, but text DFMs offer better readability, version control compatibility (e.g., with tools like Git), and easier manual editing. The tool supports bidirectional conversion:

Binary to text (useful for diffing changes or merging).
Text to binary (to restore the default efficient storage).

Key Features and Usage

Command-Line Syntax: Run it from the RAD Studio bin directory via Command Prompt or terminal. Basic examples:

convert.exe filename.dfm (converts binary to text).
convert.exe -t text filename.dfm (explicitly targets text output).
convert.exe -t binary filename.dfm (converts text to binary).

It processes individual files or can be scripted for batch operations.
No GUI; it's purely a console tool.

This application is not strictly tied to the Delphi IDE�it operates fully standalone and has been a core utility since Delphi 1 for developers working outside the IDE environment, such as in build scripts or version control workflows. The IDE itself can also invoke it indirectly (e.g., via options to save forms as text), but direct command-line use is common and recommended for automation.

Convert.exe Commandline Switches

convert.exe � Complete Command-Line Reference (Embarcadero RAD Studio 13 Architect � bin\convert.exe)

Official Syntax
text
convert.exe [options] <filename>
<filename> � Path to the .dfm, .fmx, or .dfm (binary) file to convert. Wildcards are not supported natively, but you can script batch processing.

Full List of Supported Command-Line Switches
Switch
Alias
Description
Example
-t <format>
-target <format>
Explicitly specify output format. Valid values: text or binary
convert.exe -t text MyForm.dfm
-i
-inplace
Overwrite the input file with the converted result (no backup created).
convert.exe -i MyForm.dfm
-b
-backup
Create a backup of the original file before overwriting (*.bak). Only works with -i.
convert.exe -i -b MyForm.dfm
-d
-depend
Process dependent form files (e.g., inherited forms referenced via inherited or object in DFM). Recursively converts all linked DFMs in the same directory.
convert.exe -d MainForm.dfm
-s
-silent
Suppress all console output (useful in build scripts).
convert.exe -s MyForm.dfm
-v
-verbose
Verbose mode � prints detailed conversion steps and warnings.
convert.exe -v MyForm.dfm
-p <path>
-path <path>
Search path for dependent .dfm files when using -d. Multiple paths separated by semicolon (;).
convert.exe -d -p "..\Forms;..\Common" MainForm.dfm
-e <ext>
-extension <ext>
Change the output file extension (default: .dfm for both). Useful when converting FMX to DFM or vice versa.
convert.exe -t text -e .txt MyForm.dfm
-u
-unicode
Force Unicode (UTF-8) text output (default in RAD Studio 10.4+). Use -u- to force ANSI.
convert.exe -u MyForm.dfm
-h
-?, --help
Display help / usage screen.
convert.exe -h

Auto-Detect Behavior (No -t switch)
If no -t option is provided:
* Binary ? Text: If input file is binary DFM/FMX.
* Text ? Binary: If input file is text DFM/FMX.
This is the most common usage: convert.exe MyForm.dfm ? toggles format in-place (with backup if -b used).

Exit Codes
Code
Meaning
0
Success
1
Invalid argument
2
File not found
3
Read/write error
4
Conversion failed (corrupted DFM)
5
Dependent form not found (with -d)

Practical Examples
cmd
:: 1. Convert binary DFM to text (default behavior)
convert.exe Unit1.dfm

:: 2. Convert text DFM back to binary, overwrite with backup
convert.exe -i -b -t binary Unit1.dfm

:: 3. Recursively convert all inherited forms in project
convert.exe -d -p "Forms;Common" MainForm.dfm

:: 4. Silent batch conversion in build script
convert.exe -s -i -b *.dfm

Notes
* No GUI � purely command-line.
* Works standalone � does not require the RAD Studio IDE to be running.
* Fully supported in build automation (MSBuild, FinalBuilder, CMake, etc.).
* Handles DFM, FMX, and legacy DFM (binary) formats.
* Since RAD Studio 10.4 Sydney, UTF-8 is the default text encoding.

cpp32.exe Description

Description of cpp32.exe

cpp32.exe is a command-line tool included in Embarcadero RAD Studio (specifically in versions like 13 Architect), serving as the C++ preprocessor for 32-bit targets. Its primary function is to process C++ source code files before compilation, handling preprocessor directives such as #include, #define, #ifdef, #endif, and macro expansions. This preprocessing step resolves includes, defines constants, and conditionally compiles code, outputting a modified source file (typically with a .i extension) that can then be fed into the actual compiler (like bcc32.exe). It supports standard C++ preprocessor syntax and is optimized for the Embarcadero C++Builder toolchain, ensuring compatibility with RAD Studio's build system.

Standalone Usage

cpp32.exe is not strictly limited to use within the RAD Studio IDE (which includes both Delphi and C++Builder environments). While it integrates seamlessly with the IDE for automated builds and debugging, it can be invoked as a standalone command-line application. For example, you can run it from a terminal or batch script outside the IDE to preprocess individual files or integrate it into custom build pipelines. Usage typically involves commands like:

Copy code

cpp32.exe [options] input_file.cpp

Common options include -I for include paths, -D for defines, and -o for output files. This flexibility makes it useful for developers who need manual preprocessing or scripting in non-IDE workflows, though it requires the RAD Studio environment to be installed for access to its dependencies and libraries. Note that it's specific to 32-bit C++ development and may not handle all modern C++ standards without additional flags or updates in newer RAD Studio versions. For full documentation, refer to Embarcadero's official RAD Studio help or command-line reference.

cpp32.exe Commandline Switches

Embarcadero C++ Win32 Preprocessor 7.60 Copyright (c) 1993-2023 Embarcadero Technologies, Inc.
Available options (* = default setting, xxx = has sub-options: use -h -X):
(Note: -X- or -w-XXX will usually undo whatever was set or unset by -X or -wXXX.
 If two options conflict, the last one specified will be used.)
--sysroot Sets the logical root directory for headers, libraries and frameworks
	  (Paths specified in --sysinc or --syslib and those in -F that begin
	   with '/' are prefixed with this value)
--sysinc  Set the system include file search path
	  (if specified, sysroot will be prepended)
--syslib  Set the system library file search path
	  (if specified, sysroot will be prepended)
--savemem Set maximum SAVEMEM memory (in Mb)
	  (This is the contiguous memory allocated to store global symbols and
	   similar constructs.  Pre-compiled headers use this memory)
--version Show compiler version
--replacehdr Replace header name (e.g. --replaceHeader=a.h=b.h)
--xrtti   Generate extended rtti information
  -3      Generate 80386 protected-mode compatible instructions
  -4      Generate 80386/80486 protected-mode compatible instructions
  -5      Generate Pentium instructions
  -6      Generate Pentium Pro instructions
  -Axxx   Enable ANSI conformance
  -Cxxx   Enable nested comments
  -D      -D<name> defines 'name' as a null string, or use -D<name>=<value>
  -E      Specify which assembler to use
  -G      Optimize for size/speed; use -O1 and -O2 instead
  -Hi     Include the contents of header file: -Histdio.h
  -Hp     Print headers as they are included
  -I      Set the include file search path
  -K      Set default character type to unsigned
  -L      Library file search path
  -M      Create a linker map file
  -N      Hodgepodge of miscellanity (see -h -N)
  -Nd     Macros get a value of "1" by default (-DX => -DX=1)
  -Nt     GNU __typeof(var) support
  -Nv     Allow void& as a valid type
  -O      Optimize jumps
  -P      Perform C++ compile regardless of source extension
  -Q      Extended compiler error information
  -Rxxx   Include browser information in generated .OBJ files
  -S      Control output format; see user documentation
  -T      Specify assembler option, e.g. -Tx
  -U      Undefine any previous definitions of name
  -Vxxx   Compatibility options
  -W      Target is a Windows application
  -X      Disable compiler autodependency output
  -Zd     Output global defs as DocBook specs; to specify: -Zd=<file>.c
  -Zn     Disable and/or don't define CodeGear builtins
  -Zx     Output global definitions to XML file.
	      Sub Options:
		-Zx=<filename> Emit only types/declarations in <filename>
		-Zxf[=filename] Skip base type members 
		-Zxm[=filename] Emit macros
		-Zxp[=filename] Emit file & line position
  -axxx   Set data alignment boundary.  Default is -a8; -a- means -a1
  -b      Enable -bi and treat enums as ints from a typechecking point of view
* -bi     Make sizeof(enum x) == sizeof(int) unless explicitly stated otherwise
  -c      Compile to object file only, do not link
  -d      Merge duplicate strings
  -dc     Put strings into the read-only data segment
  -dw     Put strings into the (writeable) data segment
  -e      Specify target executable pathname
  -g      Stop batch compilation after n warnings (Default = 255)
  -h      Request help ('-h -' shows all help).  Can be specific: -h -V
  -i      Set maximum significant identifier length (Default = 250)
  -j      Stop batch compilation after n errors (Default = 50)
* -k      Generate standard stack frames
  -l      Pass options to the linker; example: -ls -l-x
  -m      Generate makefile dependency information
  -md     Put dependency info in .d files, not in the object file
  -mm     Ignore system header files while generating dependency info
  -mo     Specify the output file for dependency info
  -n      Set output directory for object files
  -o      Set output filename (-o<filename> or -o <filename> supported)
  -pxxx   Use Pascal calling convention
  -q      Suppress compiler identification banner
  -r      Use register variables
  -rd     Use register variables only when register keyword is employed
  -s      Link using the system's non-incremental linker
  -t      Specify target executable
* -u      Generate underscores on symbol names
  -vxxx   Turn on source debugging
  -w      Display all warnings
  -w!     Return non-zero from compiler on warnings
  -xxxx   Enable exception handling
  -y      Debug line numbers on
  -z      Options for redefining standard segment names
Use '-h <OPT>' for help on a specific option, or
    '-h -' to see all available options.

cpp32c.exe Description

Functionality of cpp32c.exe

cpp32c.exe is the C++ Preprocessor for the 32-bit Windows platform within C++Builder (part of RAD Studio).

Primary Role: Its main job is to process C or C++ source files before they are passed to the actual compiler (BCC32C.EXE). This is the "first pass" of translation.
Key Operations: The preprocessor performs fundamental tasks like:

Macro Expansion: Replacing all macro calls (defined with #define) with their expanded text.
File Inclusion: Inserting the content of files specified by the #include directive directly into the source file.
Conditional Compilation: Processing the code blocks guarded by directives like #if, #ifdef, #ifndef, etc., deciding which code to keep and which to discard.

Output: When run, it typically produces an output file with a .i extension (e.g., source.i) that contains the preprocessed source code. This output is a text file where all directives have been handled, comments may be removed, and macros are expanded.
Compiler Toolchain: The cpp32c with the trailing 'c' indicates it's part of the newer Clang-enhanced C++ compiler toolchain for 32-bit Windows (BCC32C).

💻 Standalone vs. IDE Use

The application can be used as a standalone command-line application.

Standalone Use: You can invoke cpp32c.exe directly from the Windows command line (or a batch script) to preprocess one or more C or C++ source files. This is often done for debugging purposes, allowing a developer to inspect the intermediate .i file to see exactly how macros and include files have been resolved before the compiler sees the code. It supports various command-line options for controlling the output format.
IDE Use: During a normal build within the RAD Studio/C++Builder IDE, the preprocessor functionality (whether from cpp32c.exe or its internal logic) is typically invoked automatically by the main compiler as part of the overall compilation process, so you usually don't interact with it directly.

In summary, while it is primarily an integral tool in the C++Builder compiler toolchain for 32-bit Windows, its design as a command-line executable allows it to be used independently of the Delphi IDE for pre-processing tasks.

cpp32c.exe Commandline Switches

Embarcadero C++ Win32 Preprocessor 7.60 Copyright (c) 2012-2023 Embarcadero Technologies, Inc.
OVERVIEW: Embarcadero C/C++ preprocessor driver for Win32

USAGE: cpp32c.exe [options] <inputs>

OPTIONS:
  -###                    Print (but do not run) the commands to run for this compilation
  --analyzer-output <value>
                          Static analyzer report output format (html|plist|plist-multi-file|plist-html|text).
  --analyze               Run the static analyzer
  -arcmt-migrate-emit-errors
                          Emit ARC errors even if the migrator can fix them
  -arcmt-migrate-report-output <value>
                          Output path for the plist report
  -B <dir>                Add <dir> to search path for binaries and object files used implicitly
  -CC                     Include comments from within macros in preprocessed output
  -cl-denorms-are-zero    OpenCL only. Allow denormals to be flushed to zero.
  -cl-fast-relaxed-math   OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations, and defines __FAST_RELAXED_MATH__.
  -cl-finite-math-only    OpenCL only. Allow floating-point optimizations that assume arguments and results are not NaNs or +-Inf.
  -cl-fp32-correctly-rounded-divide-sqrt
                          OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded.
  -cl-kernel-arg-info     OpenCL only. Generate kernel argument metadata.
  -cl-mad-enable          OpenCL only. Allow use of less precise MAD computations in the generated binary.
  -cl-no-signed-zeros     OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.
  -cl-opt-disable         OpenCL only. This option disables all optimizations. By default optimizations are enabled.
  -cl-single-precision-constant
                          OpenCL only. Treat double precision floating-point constant as single precision constant.
  -cl-std=<value>         OpenCL language standard to compile for.
  -cl-strict-aliasing     OpenCL only. This option is added for compatibility with OpenCL 1.0.
  -cl-unsafe-math-optimizations
                          OpenCL only. Allow unsafe floating-point optimizations.  Also implies -cl-no-signed-zeros and -cl-mad-enable.
  --cuda-compile-host-device
                          Compile CUDA code for both host and device (default).  Has no effect on non-CUDA compilations.
  --cuda-device-only      Compile CUDA code for device only
  --cuda-gpu-arch=<value> CUDA GPU architecture (e.g. sm_35).  May be specified more than once.
  --cuda-host-only        Compile CUDA code for host only.  Has no effect on non-CUDA compilations.
  --cuda-noopt-device-debug
                          Enable device-side debug info generation. Disables ptxas optimizations.
  --cuda-path=<value>     CUDA installation path
  -cxx-isystem <directory>
                          Add directory to the C++ SYSTEM include search path
  -C                      Include comments in preprocessed output
  -c                      Only run preprocess, compile, and assemble steps
  -dD                     Print macro definitions in -E mode in addition to normal output
  -dependency-dot <value> Filename to write DOT-formatted header dependencies to
  -dependency-file <value>
                          Filename (or -) to write dependency output to
  -dI                     Print include directives in -E mode in addition to normal output
  -dM                     Print macro definitions in -E mode instead of normal output
  -dwo-dir <directory>    Write dwo files to <directory>
  -D <macro>=<value>      Define <macro> to <value> (or 1 if <value> omitted)
  -emit-ast               Emit Clang AST files for source inputs
  -emit-llvm              Use the LLVM representation for assembler and object files
  -external-linker <arg>  Select <arg> as external linker
  -E                      Only run the preprocessor
  -faligned-allocation    Enable C++17 aligned allocation functions
  -fallow-editor-placeholders
                          Treat editor placeholders as valid source code
  -fansi-escape-codes     Use ANSI escape codes for diagnostics
  -fapple-kext            Use Apple's kernel extensions ABI
  -fapple-pragma-pack     Enable Apple gcc-compatible #pragma pack handling
  -fapplication-extension Restrict code to those available for App Extensions
  -fblocks                Enable the 'blocks' language feature
  -fborland-define-external-types
                          Generate definitions for external debug types into PCH file
  -fborland-extensions    Accept non-standard constructs supported by the Borland compiler
  -fborland-use-external-types
                          Generate references to external debug types from PCH file
  -fborland-xrtti         Enable extended RTTI information for Delphi style classes
  -fbuild-session-file=<file>
                          Use the last modification time of <file> as the build session timestamp
  -fbuild-session-timestamp=<time since Epoch in seconds>
                          Time when the current build session started
  -fbuiltin-module-map    Load the clang builtins module map file.
  -fclang-abi-compat=<version>
                          Attempt to match the ABI of Clang <version>
  -fcolor-diagnostics     Use colors in diagnostics
  -fcomment-block-commands=<arg>
                          Treat each comma separated argument in <arg> as a documentation comment block command
  -fcoroutines-ts         Enable support for the C++ Coroutines TS
  -fcoverage-mapping      Generate coverage mapping to enable code coverage analysis
  -fcuda-approx-transcendentals
                          Use approximate transcendental functions
  -fcuda-flush-denormals-to-zero
                          Flush denormal floating point values to zero in CUDA device mode.
  -fcxx-exceptions        Enable C++ exceptions
  -fdata-sections         Place each data in its own section (ELF Only)
  -fdebug-info-for-profiling
                          Emit extra debug info to make sample profile more accurate.
  -fdebug-macro           Emit macro debug information
  -fdebug-prefix-map=<value>
                          remap file source paths in debug info
  -fdebug-types-section   Place debug types in their own section (ELF Only)
  -fdeclspec              Allow __declspec as a keyword
  -fdelayed-template-parsing
                          Parse templated function definitions at the end of the translation unit
  -fdiagnostics-absolute-paths
                          Print absolute paths in diagnostics
  -fdiagnostics-hotness-threshold=<number>
                          Prevent optimization remarks from being output if they do not have at least this profile count
  -fdiagnostics-parseable-fixits
                          Print fix-its in machine parseable form
  -fdiagnostics-print-source-range-info
                          Print source range spans in numeric form
  -fdiagnostics-show-hotness
                          Enable profile hotness information in diagnostic line
  -fdiagnostics-show-note-include-stack
                          Display include stacks for diagnostic notes
  -fdiagnostics-show-option
                          Print option name with mappable diagnostics
  -fdiagnostics-show-template-tree
                          Print a template comparison tree for differing templates
  -fdollars-in-identifiers
                          Allow '$' in identifiers
  -fembed-bitcode-marker  Embed placeholder LLVM IR data as a marker
  -fembed-bitcode=        Embed LLVM bitcode (option: off, all, bitcode, marker)
  -fembed-bitcode         Embed LLVM IR bitcode as data
  -femit-all-decls        Emit all declarations, even if unused
  -femulated-tls          Use emutls functions to access thread_local variables
  -fexceptions            Enable support for exception handling
  -fexperimental-new-pass-manager
                          Enables an experimental new pass manager in LLVM.
  -ffast-math             Allow aggressive, lossy floating-point optimizations
  -ffixed-r9              Reserve the r9 register (ARM only)
  -ffixed-x18             Reserve the x18 register (AArch64 only)
  -ffp-contract=<value>   Form fused FP ops (e.g. FMAs): fast (everywhere) | on (according to FP_CONTRACT pragma, default) | off (never fuse)
  -ffreestanding          Assert that the compilation takes place in a freestanding environment
  -ffunction-sections     Place each function in its own section (ELF Only)
  -fgnu-keywords          Allow GNU-extension keywords regardless of language standard
  -fgnu-runtime           Generate output compatible with the standard GNU Objective-C runtime
  -fgnu89-inline          Use the gnu89 inline semantics
  -fimplicit-module-maps  Implicitly search the file system for module map files.
  -finline-functions      Inline suitable functions
  -finline-hint-functions Inline functions which are (explicitly or implicitly) marked inline
  -finstrument-functions  Generate calls to instrument function entry and exit
  -fintegrated-as         Enable the integrated assembler
  -flto-jobs=<value>      Controls the backend parallelism of -flto=thin (default of 0 means the number of threads will be derived from the number of CPUs detected)
  -flto=<value>           Set LTO mode to either 'full' or 'thin'
  -flto                   Enable LTO in 'full' mode
  -fmath-errno            Require math functions to indicate errors by setting errno
  -fmax-type-align=<value>
                          Specify the maximum alignment to enforce on pointers lacking an explicit alignment
  -fmodule-file=<file>    Load this precompiled module file
  -fmodule-map-file=<file>
                          Load this module map file
  -fmodule-name=<name>    Specify the name of the module to build
  -fmodules-cache-path=<directory>
                          Specify the module cache path
  -fmodules-decluse       Require declaration of modules used within a module
  -fmodules-disable-diagnostic-validation
                          Disable validation of the diagnostic options when loading the module
  -fmodules-ignore-macro=<value>
                          Ignore the definition of the given macro when building and loading modules
  -fmodules-prune-after=<seconds>
                          Specify the interval (in seconds) after which a module file will be considered unused
  -fmodules-prune-interval=<seconds>
                          Specify the interval (in seconds) between attempts to prune the module cache
  -fmodules-search-all    Search even non-imported modules to resolve references
  -fmodules-strict-decluse
                          Like -fmodules-decluse but requires all headers to be in modules
  -fmodules-ts            Enable support for the C++ Modules TS
  -fmodules-user-build-path <directory>
                          Specify the module user build path
  -fmodules-validate-once-per-build-session
                          Don't verify input files for the modules if the module has been successfully validated or loaded during this build session
  -fmodules-validate-system-headers
                          Validate the system headers that a module depends on when loading the module
  -fmodules               Enable the 'modules' language feature
  -fms-compatibility-version=<value>
                          Dot-separated value representing the Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))
  -fms-compatibility      Enable full Microsoft Visual C++ compatibility
  -fms-extensions         Accept some non-standard constructs supported by the Microsoft compiler
  -fmsc-version=<value>   Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))
  -fnew-alignment=<align> Specifies the largest alignment guaranteed by '::operator new(size_t)'
  -fno-access-control     Disable C++ access control
  -fno-assume-sane-operator-new
                          Don't assume that C++'s global operator new can't alias any pointer
  -fno-autolink           Disable generation of linker directives for automatic library linking
  -fno-builtin-<value>    Disable implicit builtin knowledge of a specific function
  -fno-builtin            Disable implicit builtin knowledge of functions
  -fno-common             Compile common globals like normal definitions
  -fno-constant-cfstrings Disable creation of CodeFoundation-type constant strings
  -fno-coverage-mapping   Disable code coverage analysis
  -fno-crash-diagnostics  Disable auto-generation of preprocessed source files and a script for reproduction during a clang crash
  -fno-debug-info-for-profiling
                          Do not emit extra debug info for sample profiler.
  -fno-debug-macro        Do not emit macro debug information
  -fno-declspec           Disallow __declspec as a keyword
  -fno-delayed-template-parsing
                          Disable delayed template parsing
  -fno-diagnostics-fixit-info
                          Do not include fixit information in diagnostics
  -fno-dollars-in-identifiers
                          Disallow '$' in identifiers
  -fno-elide-constructors Disable C++ copy constructor elision
  -fno-elide-type         Do not elide types when printing diagnostics
  -fno-experimental-new-pass-manager
                          Disables an experimental new pass manager in LLVM.
  -fno-gnu-inline-asm     Disable GNU style inline asm
  -fno-integrated-as      Disable the integrated assembler
  -fno-jump-tables        Do not use jump tables for lowering switches
  -fno-lax-vector-conversions
                          Disallow implicit conversions between vectors with a different number of elements or different element types
  -fno-lto                Disable LTO mode (default)
  -fno-merge-all-constants
                          Disallow merging of constants
  -fno-objc-infer-related-result-type
                          do not infer Objective-C related result type based on method family
  -fno-operator-names     Do not treat C++ operator name keywords as synonyms for operators
  -fno-preserve-as-comments
                          Do not preserve comments in inline assembly
  -fno-profile-generate   Disable generation of profile instrumentation.
  -fno-profile-instr-generate
                          Disable generation of profile instrumentation.
  -fno-profile-instr-use  Disable using instrumentation data for profile-guided optimization
  -fno-reroll-loops       Turn off loop reroller
  -fno-rtlib-add-rpath    Do not add -rpath with architecture-specific resource directory to the linker flags
  -fno-rtti               Disable generation of rtti information
  -fno-sanitize-address-use-after-scope
                          Disable use-after-scope detection in AddressSanitizer
  -fno-sanitize-blacklist Don't use blacklist file for sanitizers
  -fno-sanitize-cfi-cross-dso
                          Disable control flow integrity (CFI) checks for cross-DSO calls.
  -fno-sanitize-coverage=<value>
                          Disable specified features of coverage instrumentation for Sanitizers
  -fno-sanitize-memory-track-origins
                          Disable origins tracking in MemorySanitizer
  -fno-sanitize-recover=<value>
                          Disable recovery for specified sanitizers
  -fno-sanitize-stats     Disable sanitizer statistics gathering.
  -fno-sanitize-thread-atomics
                          Disable atomic operations instrumentation in ThreadSanitizer
  -fno-sanitize-thread-func-entry-exit
                          Disable function entry/exit instrumentation in ThreadSanitizer
  -fno-sanitize-thread-memory-access
                          Disable memory access instrumentation in ThreadSanitizer
  -fno-sanitize-trap=<value>
                          Disable trapping for specified sanitizers
  -fno-short-wchar        Force wchar_t to be an unsigned int
  -fno-show-column        Do not include column number on diagnostics
  -fno-show-source-location
                          Do not include source location information with diagnostics
  -fno-signed-char        Char is unsigned
  -fno-signed-zeros       Allow optimizations that ignore the sign of floating point zeros
  -fno-spell-checking     Disable spell-checking
  -fno-stack-protector    Disable the use of stack protectors
  -fno-standalone-debug   Limit debug information produced to reduce size of debug binary
  -fno-threadsafe-statics Do not emit code to make initialization of local statics thread safe
  -fno-trigraphs          Do not process trigraph sequences
  -fno-unroll-loops       Turn off loop unroller
  -fno-use-cxa-atexit     Don't use __cxa_atexit for calling destructors
  -fno-use-init-array     Don't use .init_array instead of .ctors
  -fobjc-arc-exceptions   Use EH-safe code when synthesizing retains and releases in -fobjc-arc
  -fobjc-arc              Synthesize retain and release calls for Objective-C pointers
  -fobjc-exceptions       Enable Objective-C exceptions
  -fobjc-runtime=<value>  Specify the target Objective-C runtime kind and version
  -fobjc-weak             Enable ARC-style weak references in Objective-C
  -fopenmp-targets=<value>
                          Specify comma-separated list of triples OpenMP offloading targets to be supported
  -foptimization-record-file=<value>
                          Specify the file name of any generated YAML optimization record
  -fpack-struct=<value>   Specify the default maximum struct packing alignment
  -fpascal-strings        Recognize and construct Pascal-style string literals
  -fpcc-struct-return     Override the default ABI to return all structs on the stack
  -fplugin=<dsopath>      Load the named plugin (dynamic shared object)
  -fprebuilt-module-path=<directory>
                          Specify the prebuilt module path
  -fprofile-generate=<directory>
                          Generate instrumented code to collect execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)
  -fprofile-generate      Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)
  -fprofile-instr-generate=<file>
                          Generate instrumented code to collect execution counts into <file> (overridden by LLVM_PROFILE_FILE env var)
  -fprofile-instr-generate
                          Generate instrumented code to collect execution counts into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)
  -fprofile-instr-use=<value>
                          Use instrumentation data for profile-guided optimization
  -fprofile-sample-use=<value>
                          Enable sample-based profile guided optimizations
  -fprofile-use=<pathname>
                          Use instrumentation data for profile-guided optimization. If pathname is a directory, it reads from <pathname>/default.profdata. Otherwise, it reads from file <pathname>.
  -freciprocal-math       Allow division operations to be reassociated
  -freg-struct-return     Override the default ABI to return small structs in registers
  -frelaxed-template-template-args
                          Enable C++17 relaxed template template argument matching
  -freroll-loops          Turn on loop reroller
  -frtlib-add-rpath       Add -rpath with architecture-specific resource directory to the linker flags
  -fsanitize-address-field-padding=<value>
                          Level of field padding for AddressSanitizer
  -fsanitize-address-globals-dead-stripping
                          Enable linker dead stripping of globals in AddressSanitizer
  -fsanitize-address-use-after-scope
                          Enable use-after-scope detection in AddressSanitizer
  -fsanitize-blacklist=<value>
                          Path to blacklist file for sanitizers
  -fsanitize-cfi-cross-dso
                          Enable control flow integrity (CFI) checks for cross-DSO calls.
  -fsanitize-coverage=<value>
                          Specify the type of coverage instrumentation for Sanitizers
  -fsanitize-memory-track-origins=<value>
                          Enable origins tracking in MemorySanitizer
  -fsanitize-memory-track-origins
                          Enable origins tracking in MemorySanitizer
  -fsanitize-memory-use-after-dtor
                          Enable use-after-destroy detection in MemorySanitizer
  -fsanitize-recover=<value>
                          Enable recovery for specified sanitizers
  -fsanitize-stats        Enable sanitizer statistics gathering.
  -fsanitize-thread-atomics
                          Enable atomic operations instrumentation in ThreadSanitizer (default)
  -fsanitize-thread-func-entry-exit
                          Enable function entry/exit instrumentation in ThreadSanitizer (default)
  -fsanitize-thread-memory-access
                          Enable memory access instrumentation in ThreadSanitizer (default)
  -fsanitize-trap=<value> Enable trapping for specified sanitizers
  -fsanitize-undefined-strip-path-components=<number>
                          Strip (or keep only, if negative) a given number of path components when emitting check metadata.
  -fsanitize=<check>      Turn on runtime checks for various forms of undefined or suspicious behavior. See user manual for available checks
  -fsave-optimization-record
                          Generate a YAML optimization record file
  -fshort-enums           Allocate to an enum type only as many bytes as it needs for the declared range of possible values
  -fshort-wchar           Force wchar_t to be a short unsigned int
  -fshow-overloads=<value>
                          Which overload candidates to show when overload resolution fails: best|all; defaults to all
  -fsized-deallocation    Enable C++14 sized global deallocation functions
  -fsjlj-exceptions       Use SjLj style exceptions
  -fslp-vectorize         Enable the superword-level parallelism vectorization passes
  -fsplit-dwarf-inlining  Place debug types in their own section (ELF Only)
  -fstack-protector-all   Force the usage of stack protectors for all functions
  -fstack-protector-strong
                          Use a strong heuristic to apply stack protectors to functions
  -fstack-protector       Enable stack protectors for functions potentially vulnerable to stack smashing
  -fstandalone-debug      Emit full debug info for all types used by the program
  -fstrict-enums          Enable optimizations based on the strict definition of an enum's value range
  -fstrict-return         Always treat control flow paths that fall off the end of a non-void function as unreachable
  -fstrict-vtable-pointers
                          Enable optimizations based on the strict rules for overwriting polymorphic C++ objects
  -fthinlto-index=<value> Perform ThinLTO importing using provided function summary index
  -ftrap-function=<value> Issue call to specified function rather than a trap instruction
  -ftrapv-handler=<function name>
                          Specify the function to be called on overflow
  -ftrapv                 Trap on integer overflow
  -ftrigraphs             Process trigraph sequences
  -funique-section-names  Use unique names for text and data sections (ELF Only)
  -funroll-loops          Turn on loop unroller
  -fuse-init-array        Use .init_array instead of .ctors
  -fveclib=<value>        Use the given vector functions library
  -fvectorize             Enable the loop vectorization passes
  -fvisibility-inlines-hidden
                          Give inline C++ member functions default visibility by default
  -fvisibility-ms-compat  Give global types 'default' visibility and global functions and variables 'hidden' visibility by default
  -fvisibility=<value>    Set the default symbol visibility for all global declarations
  -fwhole-program-vtables Enables whole-program vtable optimization. Requires -flto
  -fwrapv                 Treat signed integer overflow as two's complement
  -fwritable-strings      Store string literals as writable data
  -fxray-always-instrument= <value>
                          Filename defining the whitelist for imbuing the 'always instrument' XRay attribute.
  -fxray-instruction-threshold= <value>
                          Sets the minimum function size to instrument with XRay
  -fxray-instrument       Generate XRay instrumentation sleds on function entry and exit
  -fxray-never-instrument= <value>
                          Filename defining the whitelist for imbuing the 'never instrument' XRay attribute.
  -fzvector               Enable System z vector language extension
  -F <value>              Add directory to framework include search path
  --gcc-toolchain=<value> Use the gcc toolchain at the given directory
  -gcodeview              Generate CodeView debug information
  -gdwarf-2               Generate source-level debug information with dwarf version 2
  -gdwarf-3               Generate source-level debug information with dwarf version 3
  -gdwarf-4               Generate source-level debug information with dwarf version 4
  -gdwarf-5               Generate source-level debug information with dwarf version 5
  -gline-tables-only      Emit debug line number tables only
  -gmodules               Generate debug info with external references to clang modules or precompiled headers
  -gz=<value>             DWARF debug sections compression type
  -gz                     DWARF debug sections compression type
  -G <size>               Put objects of at most <size> bytes into small data section (MIPS / Hexagon)
  -g                      Generate source-level debug information
  -help                   Display available options
  -H                      Show header includes and nesting depth
  -I-                     Restrict all prior -I flags to double-quoted inclusion and remove current directory from include path
  -idirafter <value>      Add directory to AFTER include search path
  -iframeworkwithsysroot <directory>
                          Add directory to SYSTEM framework search path, absolute paths are relative to -isysroot
  -iframework <value>     Add directory to SYSTEM framework search path
  --ilink-no-cfg          Do not use cfg file for Borland linker
  -imacros <file>         Include macros from file before parsing
  -include-pch <file>     Include precompiled header file
  -include <file>         Include file before parsing
  -index-header-map       Make the next included directory (-I or -F) an indexer header map
  -iprefix <dir>          Set the -iwithprefix/-iwithprefixbefore prefix
  -iquote <directory>     Add directory to QUOTE include search path
  -isysroot <dir>         Set the system root directory (usually /)
  -isystem-after <directory>
                          Add directory to end of the SYSTEM include search path
  -isystem <directory>    Add directory to SYSTEM include search path
  -ivfsoverlay <value>    Overlay the virtual filesystem described by file over the real file system
  -iwithprefixbefore <dir>
                          Set directory to include search path with prefix
  -iwithprefix <dir>      Set directory to SYSTEM include search path with prefix
  -iwithsysroot <directory>
                          Add directory to SYSTEM include search path, absolute paths are relative to -isysroot
  -I <dir>                Add directory to include search path
  --jobs=<N>              Perform a parallel compilation with a maximum of <N> processes
  -L <dir>                Add directory to library search path
  -mabicalls              Enable SVR4-style position-independent code (Mips only)
  -malign-double          Align doubles to two words in structs (x86 only)
  -mbackchain             Link stack frames through backchain on System Z
  -mcdecl                 Make CDecl calling convention the default
  -mcrc                   Allow use of CRC instructions (ARM only)
  -MD                     Write a depfile containing user and system headers
  -meabi <value>          Set EABI type, e.g. 4, 5 or gnu (default depends on triple)
  -mexecute-only          Disallow generation of data access to code sections (ARM only)
  -mfastcall              Make FastCall calling convention the default
  -mfentry                Insert calls to fentry at function entry (x86 only)
  -mfix-cortex-a53-835769 Workaround Cortex-A53 erratum 835769 (AArch64 only)
  -mfp32                  Use 32-bit floating point registers (MIPS only)
  -mfp64                  Use 64-bit floating point registers (MIPS only)
  -MF <file>              Write depfile output from -MMD, -MD, -MM, or -M to <file>
  -mgeneral-regs-only     Generate code which only uses the general purpose registers (AArch64 only)
  -mglobal-merge          Enable merging of globals
  -MG                     Add missing headers to depfile
  -mhvx-double            Enable Hexagon Double Vector eXtensions
  -mhvx                   Enable Hexagon Vector eXtensions
  -miamcu                 Use Intel MCU ABI
  --migrate               Run the migrator
  -mincremental-linker-compatible
                          (integrated-as) Emit an object file which can be used with an incremental linker
  -mindirect-jump=<value> Change indirect jump instructions to inhibit speculation
  -mios-version-min=<value>
                          Set iOS deployment target
  -MJ <value>             Write a compilation database entry per input
  -mllvm <value>          Additional arguments to forward to LLVM's option processing
  -mlong-calls            Generate branches with extended addressability, usually via indirect jumps.
  -mmacosx-version-min=<value>
                          Set Mac OS X deployment target
  -mmadd4                 Enable the generation of 4-operand madd.s, madd.d and related instructions.
  -MMD                    Write a depfile containing user headers
  -mms-bitfields          Set the default structure layout to be compatible with the Microsoft compiler standard
  -mmsa                   Enable MSA ASE (MIPS only)
  -mmt                    Enable MT ASE (MIPS only)
  -MM                     Like -MMD, but also implies -E and writes to stdout by default
  -mno-abicalls           Disable SVR4-style position-independent code (Mips only)
  -mno-cdecl              Do not make CDecl calling convention the default
  -mno-execute-only       Allow generation of data access to code sections (ARM only)
  -mno-fastcall           Do not make FastCall calling convention the default
  -mno-fix-cortex-a53-835769
                          Don't workaround Cortex-A53 erratum 835769 (AArch64 only)
  -mno-global-merge       Disable merging of globals
  -mno-hvx-double         Disable Hexagon Double Vector eXtensions
  -mno-hvx                Disable Hexagon Vector eXtensions
  -mno-implicit-float     Don't generate implicit floating point instructions
  -mno-incremental-linker-compatible
                          (integrated-as) Emit an object file which cannot be used with an incremental linker
  -mno-long-calls         Restore the default behaviour of not generating long calls
  -mno-madd4              Disable the generation of 4-operand madd.s, madd.d and related instructions.
  -mno-movt               Disallow use of movt/movw pairs (ARM only)
  -mno-ms-bitfields       Do not set the default structure layout to be compatible with the Microsoft compiler standard
  -mno-msa                Disable MSA ASE (MIPS only)
  -mno-mt                 Disable MT ASE (MIPS only)
  -mno-neg-immediates     Disallow converting instructions with negative immediates to their negation or inversion.
  -mno-restrict-it        Allow generation of deprecated IT blocks for ARMv8. It is off by default for ARMv8 Thumb mode
  -mno-stdcall            Do not make StdCall calling convention the default
  -mno-unaligned-access   Force all memory accesses to be aligned (AArch32/AArch64 only)
  -mnocrc                 Disallow use of CRC instructions (ARM only)
  -module-dependency-dir <value>
                          Directory to dump module dependencies to
  -module-file-info       Provide information about a particular module file
  -momit-leaf-frame-pointer
                          Omit frame pointer setup for leaf functions
  -mpie-copy-relocations  Use copy relocations support for PIE builds
  -MP                     Create phony target for each dependency (other than main file)
  -mqdsp6-compat          Enable hexagon-qdsp6 backward compatibility
  -MQ <value>             Specify name of main file output to quote in depfile
  -mrelax-all             (integrated-as) Relax all machine instructions
  -mrestrict-it           Disallow generation of deprecated IT blocks for ARMv8. It is on by default for ARMv8 Thumb mode.
  -mrtd                   Make StdCall calling convention the default
  -msoft-float            Use software floating point
  -mstack-alignment=<value>
                          Set the stack alignment
  -mstack-probe-size=<value>
                          Set the stack probe size
  -mstackrealign          Force realign the stack at entry to every function
  -mstdcall               Make StdCall calling convention the default
  -mthread-model <value>  The thread model to use, e.g. posix, single (posix by default)
  -MT <value>             Specify name of main file output in depfile
  -munaligned-access      Allow memory accesses to be unaligned (AArch32/AArch64 only)
  -MV                     Use NMake/Jom format for the depfile
  -M                      Like -MD, but also implies -E and writes to stdout by default
  --no-cuda-gpu-arch=<value>
                          Remove GPU architecture (e.g. sm_35) from the list of GPUs to compile for. 'all' resets the list to its default value.
  --no-cuda-version-check Don't error out if the detected version of the CUDA install is too low for the requested CUDA gpu architecture.
  --no-system-header-prefix=<prefix>
                          Treat all #include paths starting with <prefix> as not including a system header.
  -nobuiltininc           Disable builtin #include directories
  -nostdinc++             Disable standard #include directories for the C++ standard library
  -ObjC++                 Treat source input files as Objective-C++ inputs
  -objcmt-atomic-property Make migration to 'atomic' properties
  -objcmt-migrate-all     Enable migration to modern ObjC
  -objcmt-migrate-annotation
                          Enable migration to property and method annotations
  -objcmt-migrate-designated-init
                          Enable migration to infer NS_DESIGNATED_INITIALIZER for initializer methods
  -objcmt-migrate-instancetype
                          Enable migration to infer instancetype for method result type
  -objcmt-migrate-literals
                          Enable migration to modern ObjC literals
  -objcmt-migrate-ns-macros
                          Enable migration to NS_ENUM/NS_OPTIONS macros
  -objcmt-migrate-property-dot-syntax
                          Enable migration of setter/getter messages to property-dot syntax
  -objcmt-migrate-property
                          Enable migration to modern ObjC property
  -objcmt-migrate-protocol-conformance
                          Enable migration to add protocol conformance on classes
  -objcmt-migrate-readonly-property
                          Enable migration to modern ObjC readonly property
  -objcmt-migrate-readwrite-property
                          Enable migration to modern ObjC readwrite property
  -objcmt-migrate-subscripting
                          Enable migration to modern ObjC subscripting
  -objcmt-ns-nonatomic-iosonly
                          Enable migration to use NS_NONATOMIC_IOSONLY macro for setting property's 'atomic' attribute
  -objcmt-returns-innerpointer-property
                          Enable migration to annotate property with NS_RETURNS_INNER_POINTER
  -objcmt-whitelist-dir-path=<value>
                          Only modify files with a filename contained in the provided directory path
  -ObjC                   Treat source input files as Objective-C inputs
  -output-dir <directory> Write object files to <directory>
  -o <file>               Write output to <file>
  -PC<N>                  (deprecated, use --jobs=<N> instead) Perform a parallel compilation with a maximum of <N> processes
  -pg                     Enable mcount instrumentation
  -pipe                   Use pipes between commands, when possible
  --precompile            Only precompile the input
  -print-file-name=<file> Print the full library path of <file>
  -print-ivar-layout      Enable Objective-C Ivar layout bitmap print trace
  -print-libgcc-file-name Print the library path for the currently used compiler runtime library ("libgcc.a" or "libclang_rt.builtins.*.a")
  -print-prog-name=<name> Print the full program path of <name>
  -print-resource-dir     Print the resource directory pathname
  -print-search-dirs      Print the paths used for finding libraries and programs
  -pthread                Support POSIX threads in generated code
  --ptxas-path=<value>    Path to ptxas (used for compiling CUDA code)
  -P                      Disable linemarker output in -E mode
  -Qunused-arguments      Don't emit warning for unused driver arguments
  -q                      Suppress compiler identification banner
  -relocatable-pch        Whether to build a relocatable precompiled header
  -rewrite-legacy-objc    Rewrite Legacy Objective-C source to C++
  -rewrite-objc           Rewrite Objective-C source to C++
  -Rpass-analysis=<value> Report transformation analysis from optimization passes whose name matches the given POSIX regular expression
  -Rpass-missed=<value>   Report missed transformations by optimization passes whose name matches the given POSIX regular expression
  -Rpass=<value>          Report transformations performed by optimization passes whose name matches the given POSIX regular expression
  -rtlib=<value>          Compiler runtime library to use
  -R<remark>              Enable the specified remark
  -save-stats=<value>     Save llvm statistics.
  -save-stats             Save llvm statistics.
  -save-temps=<value>     Save intermediate compilation results.
  -save-temps             Save intermediate compilation results
  -serialize-diagnostics <value>
                          Serialize compiler diagnostics to a file
  -std=<value>            Language standard to compile for
  -stdlib=<value>         C++ standard library to use
  --system-header-prefix=<prefix>
                          Treat all #include paths starting with <prefix> as including a system header.
  -S                      Only run preprocess and compilation steps
  --target=<value>        Generate code for the given target
  -Tbss <addr>            Set starting address of BSS to <addr>
  -Tdata <addr>           Set starting address of BSS to <addr>
  -time                   Time individual commands
  -traditional-cpp        Enable some traditional CPP emulation
  -trigraphs              Process trigraph sequences
  -Ttext <addr>           Set starting address of BSS to <addr>
  -T <script>             Specify <script> as linker script
  -t<value>               Specify Borland target executable
  -undef                  undef all system defines
  -U <macro>              Undefine macro <macro>
  --verify-debug-info     Verify the binary representation of debug output
  -verify-pch             Load and verify that a pre-compiled header file is not stale
  -v                      Show commands to run and use verbose output
  -Wa,<arg>               Pass the comma separated arguments in <arg> to the assembler
  -Wdeprecated            Enable warnings for deprecated constructs and define __DEPRECATED
  -Wl,<arg>               Pass the comma separated arguments in <arg> to the linker
  -working-directory <value>
                          Resolve file paths relative to the specified directory
  -Wp,<arg>               Pass the comma separated arguments in <arg> to the preprocessor
  -W<warning>             Enable the specified warning
  -w                      Suppress all warnings
  -Xanalyzer <arg>        Pass <arg> to the static analyzer
  -Xassembler <arg>       Pass <arg> to the assembler
  -Xclang <arg>           Pass <arg> to the clang compiler
  -Xcuda-fatbinary <arg>  Pass <arg> to fatbinary invocation
  -Xcuda-ptxas <arg>      Pass <arg> to the ptxas assembler
  -Xdriver <arg>          Pass <arg> directly to the clang compiler
  -Xlinker <arg>          Pass <arg> to the linker
  -Xpreprocessor <arg>    Pass <arg> to the preprocessor
  -x <language>           Treat subsequent input files as having type <language>
  -z <arg>                Pass -z <arg> to the linker
  +<arg>                  Load user specified configuration file

CppLibTransform.exe Description

cppLibTransform.exe � Overview and Functionality

cppLibTransform.exe is a utility shipped with Embarcadero RAD Studio (including version 13 Architect) that is primarily used to transform C++ static libraries (.lib files) into a format compatible with the Delphi linker when linking C++ code into Delphi projects�especially in the context of Delphi�C++ interoperability (e.g., when using C++Builder libraries from Delphi or creating hybrid applications).

Key Functions:

Converts Microsoft Visual C++�style static libraries (COFF format) into Embarcadero-compatible OMF (Object Module Format) or another internal format that the Delphi linker can consume.
Handles name mangling differences, symbol exports, and calling conventions between C++ and Delphi/Object Pascal.
May also be involved in preparing libraries for use with Delphi packages that interface with C++ code, or when using the Delphi linker to link C++ object files in mixed-language projects.

Usage Context:

Primarily invoked automatically by the RAD Studio IDE (both Delphi and C++Builder) during builds that involve linking C++ static libraries into Delphi projects.
It is not typically intended for direct end-user interaction, but it can be run as a standalone command-line tool if needed�for example, to preprocess a third-party .lib file before including it in a Delphi project.
Command-line usage usually follows a pattern like:

bash

cppLibTransform.exe input.lib output.lib

(Exact syntax may vary; consult Embarcadero documentation or use cppLibTransform.exe /? for help.)

Standalone Use?

Yes, it is a standalone executable and does not require the IDE to run.
However, its primary design is as a build-chain helper tool, not a general-purpose utility. Most developers will never need to call it manually unless they are integrating external C++ libraries into Delphi projects and encounter linking issues.

Important Notes:

This tool is specific to Embarcadero�s toolchain and is not a general library converter like objconv or coff2omf.
It is not used in pure C++Builder projects�only in scenarios involving Delphi consuming C++ libraries or mixed-language development.
Misuse (e.g., attempting to convert incompatible libraries) may result in linker errors or runtime instability.

Documentation:

Official documentation is limited, but references can be found in:

Embarcadero DocWiki (search for �cppLibTransform� or �linking C++ libraries in Delphi�)
RAD Studio installation notes or command-line tools reference
Community forums discussing Delphi�C++ interop

In summary: cppLibTransform.exe is a specialized, standalone utility used to adapt C++ static libraries for use in Delphi projects, typically invoked automatically by the IDE but usable manually when needed.

CppLibTransform.exe Commandline Switches

Specify folder for generated files: --out:<output_dir>
Specify file with description of the task: --task:<xml file>

Usage: CppLibTransform [options]

Options:
--task:<xml file> - XML file with descrption of the task.
--out:<output_dir> - directory where the output .cpp/.h and .pas files should be placed.
--gendeleg - generate delegates for all polymorphic classes.
--fmt - perform formatting of the output files after translation.

dbkw64_29_0.exe Description

Executable: dbkw64_29_0.exe

Purpose / Functionality

dbkw64_29_0.exe is the Delphi Debugger Kernel for Win64. It acts as the low-level backend process that supports the Delphi IDE�s integrated debugger when you:

Run or debug Win64 Delphi or C++ applications,
Step through code,
Inspect variables and call stacks,
Set breakpoints, or
Evaluate expressions during debugging sessions.

The executable handles communication between the IDE (BDS.EXE / Delphi IDE) and the target process being debugged, managing symbol loading, breakpoint coordination, exception handling, and stack/frame introspection.

⚙️ Usage Context

Primarily invoked automatically by the IDE when you start a debugging session for a 64-bit Windows target.
The filename version (_29_0) corresponds to RAD Studio version 29.0, which is Delphi 13 / RAD Studio 13.
It pairs with the 32-bit equivalent dbkw32_29_0.exe for debugging Win32 targets.

🚫 Standalone Use

Not intended for standalone use.
It has no public command-line interface or documented standalone functionality.
Running it directly from the command line does nothing useful; it expects to be launched by the Delphi debugger engine with specific internal parameters.

✅ In Summary

Aspect	Description
Executable	dbkw64_29_0.exe
Component of	RAD Studio 13 (Delphi/C++Builder)
Function	64-bit debugger backend (Delphi Debug Kernel)
Used by	Delphi/C++Builder IDE (BDS.EXE)
Standalone Use	❌ Not practical; internal component only
Invoked When	Debugging a 64-bit Windows project

In short, dbkw64_29_0.exe is a backend process used exclusively by the Delphi/C++Builder IDE to perform Win64 debugging tasks. It is not a standalone developer tool and has no general-purpose command-line or manual functionality outside of the IDE.

dcc32.exe Description

DCC32.EXE - Delphi Command Line Compiler (32-bit)

Overview

dcc32.exe is the 32-bit Delphi command-line compiler included with RAD Studio. It compiles Delphi source code (.pas files) and project files (.dpr) into 32-bit Windows executables without requiring the IDE to be open.

Functionality

This compiler:

Compiles Delphi projects from the command line
Generates 32-bit Windows applications, DLLs, and packages
Processes .dpr (Delphi Project), .pas (Pascal unit), and .dpk (package) files
Supports compiler directives, conditional compilation, and build configurations
Can be integrated into automated build systems and CI/CD pipelines
Handles resource files, form files (.dfm), and other project dependencies

Standalone Usage

Yes, dcc32.exe is fully functional as a standalone application. You can use it independently of the IDE for:

Automated builds: Integrate into build scripts (batch files, PowerShell, etc.)
Command-line compilation: Compile projects without opening the IDE
Build automation tools: Use with MSBuild, makefiles, or other build systems
Continuous Integration: Integrate into CI/CD servers like Jenkins, TeamCity, or GitHub Actions
Batch processing: Compile multiple projects programmatically

Basic Usage Example

batch

dcc32.exe MyProject.dpr

dcc32.exe -B MyProject.dpr� (rebuild all)

dcc32.exe -U"C:\Units" MyProject.dpr� (specify unit search path)

The IDE uses dcc32.exe internally when you build 32-bit projects, but it's designed to be used independently as well.

dcc32.exe Commandline Switches

Embarcadero Delphi for Win32 compiler version 36.0
Copyright (c) 1983,2025 Embarcadero Technologies, Inc.

Syntax: dcc32 [options] filename [options]

  -A<unit>=<alias> = Set unit alias
  -B = Build all units             
  -CC = Console target             
  -CG = GUI target                 
  -D<syms> = Define conditionals   
  -E<path> = EXE/DLL output directory
  -F<offset> = Find error          
  -GD = Detailed map file          
  -GP = Map file with publics      
  -GS = Map file with segments     
  -H = Output hint messages        
  -I<paths> = Include directories  
  -J = Generate .obj file          
  -JPHNE = Generate C++ .obj file, .hpp file, in namespace, export all
  -JL = Generate package .lib, .bpi, and all .hpp files for C++
  -K<addr> = Set image base addr   
  -LE<path> = package .bpl output directory
  -LN<path> = package .dcp output directory
  -LU<package> = Use package       
  -M = Make modified units         
  -NU<path> = unit .dcu output directory
  -NH<path> = unit .hpp output directory
  -NO<path> = unit .obj output directory
  -NB<path> = unit .bpi output directory
  -NX<path> = unit .xml output directory
  -NS<namespaces> = Namespace search path
  -O<paths> = Object directories   
  -P = look for 8.3 file names also
  -Q = Quiet compile               
  -R<paths> = Resource directories 
  -TX<ext> = Output name extension 
  -U<paths> = Unit directories     
  -V = Debug information in EXE    
  -VR = Generate remote debug (RSM)
  -VT = Debug information in TDS   
  -VN = TDS symbols in namespace   
  -W[+|-|^][warn_id] = Output warning messages
  -Z = Output 'never build' DCPs   
  -$<dir> = Compiler directive     
  --help = Show this help screen   
  --version = Show name and version
  --codepage:<cp> = specify source file encoding
  --default-namespace:<namespace> = set namespace
  --depends = output unit dependency information
  --doc = output XML documentation 
  --drc = output resource string .drc file
  --no-config = do not load default dcc32.cfg file
  --description:<string> = set executable description
  --inline:{on|off|auto} = function inlining control
  --legacy-ifend = allow legacy $IFEND directive
  --zero-based-strings[+|-] = strings are indexed starting at 0
  --peflags:<flags> = set extra PE Header flags field
  --peoptflags:<flags> = set extra PE Header optional flags field
  --peosversion:<major>.<minor> = set OS Version fields in PE Header (default: 5.0)
  --pesubsysversion:<major>.<minor> = set Subsystem Version fields in PE Header (default: 5.0)
  --peuserversion:<major>.<minor> = set User Version fields in PE Header (default: 0.0)
  --lib-version:<version> = Output package name version
  --lib-suffix:<suffix> = Output package name suffix
Compiler switches: -$<letter><state> (defaults are shown below)
  A8  Aligned record fields         
  B-  Full boolean Evaluation       
  C+  Evaluate assertions at runtime
  D+  Debug information             
  G+  Use imported data references  
  H+  Use long strings by default   
  I+  I/O checking                  
  J-  Writeable structured consts   
  L+  Local debug symbols           
  M-  Runtime type info             
  O+  Optimization                  
  P+  Open string params            
  Q-  Integer overflow checking     
  R-  Range checking                
  T-  Typed @ operator              
  U-  Pentium(tm)-safe divide       
  V+  Strict var-strings            
  W-  Generate stack frames         
  X+  Extended syntax               
  Y+  Symbol reference info         
  Z1  Minimum size of enum types    
Stack size: -$M<minStackSize[,maxStackSize]> (default 16384,1048576)

dcc64.exe Description

DCC64.EXE Functionality

The executable file DCC64.EXE in your Embarcadero RAD Studio 13 Architect installation is the Delphi 64-bit Command Line Compiler.

Summary of Functionality

Compiler: It is the primary tool for compiling Delphi source code (typically .pas files) into executable files or dynamic-link libraries (DLLs) specifically for the 64-bit Windows platform.
64-bit Target: It handles the compilation process for 64-bit Windows applications, supporting 64-bit native integer types, 64-bit pointers, and other 64-bit specific features and conventions.
Command-Line Interface: As a command-line utility, it allows developers to compile projects and source files directly from a shell or batch script, rather than exclusively through the Integrated Development Environment (IDE).

Standalone Usage

Yes, DCC64.EXE can be used as a standalone application.

Not IDE-Exclusive: While the Delphi IDE uses this compiler internally when you build a 64-bit Windows project, the executable itself is designed as a command-line interface utility.
External Builds: This makes it invaluable for tasks like:

Automated Builds: Integrating the compilation step into continuous integration (CI) or automated build systems (like Jenkins, TeamCity, or even MSBuild scripts).
Scripted Compilations: Compiling files or projects using custom batch files or scripts outside of the main IDE environment.
Minimal Environment: Performing compilation tasks on a server or build machine that might not have the full RAD Studio IDE running.

RAD Studio provides a rich set of command-line utilities, including the compiler executables, which are commonly used to perform targeted compilation and related functions outside the graphical environment.

dcc64.exe Commandline Switches

Embarcadero Delphi for Win64 compiler version 37.0
Copyright (c) 1983,2025 Embarcadero Technologies, Inc.

Syntax: dcc64 [options] filename [options]

  -A<unit>=<alias> = Set unit alias
  -B = Build all units             
  -CC = Console target             
  -CG = GUI target                 
  -D<syms> = Define conditionals   
  -E<path> = EXE/DLL output directory
  -F<offset> = Find error          
  -GD = Detailed map file          
  -GP = Map file with publics      
  -GS = Map file with segments     
  -H = Output hint messages        
  -I<paths> = Include directories  
  -J = Generate .obj file          
  -JPHNE = Generate C++ .obj file, .hpp file, in namespace, export all
  -JL = Generate package .lib, .bpi, and all .hpp files for C++
  -K<addr> = Set image base addr   
  -LE<path> = package .bpl output directory
  -LN<path> = package .dcp output directory
  -LU<package> = Use package       
  -M = Make modified units         
  -NU<path> = unit .dcu output directory
  -NH<path> = unit .hpp output directory
  -NO<path> = unit .obj output directory
  -NB<path> = unit .bpi output directory
  -NX<path> = unit .xml output directory
  -NS<namespaces> = Namespace search path
  -O<paths> = Object directories   
  -P = look for 8.3 file names also
  -Q = Quiet compile               
  -R<paths> = Resource directories 
  -TX<ext> = Output name extension 
  -U<paths> = Unit directories     
  -V = Debug information in EXE    
  -VR = Generate remote debug (RSM)
  -VT = Debug information in TDS   
  -VN = TDS symbols in namespace   
  -W[+|-|^][warn_id] = Output warning messages
  -Z = Output 'never build' DCPs   
  -$<dir> = Compiler directive     
  --help = Show this help screen   
  --version = Show name and version
  --codepage:<cp> = specify source file encoding
  --default-namespace:<namespace> = set namespace
  --depends = output unit dependency information
  --doc = output XML documentation 
  --drc = output resource string .drc file
  --no-config = do not load default dcc64.cfg file
  --description:<string> = set executable description
  --inline:{on|off|auto} = function inlining control
  --legacy-ifend = allow legacy $IFEND directive
  --zero-based-strings[+|-] = strings are indexed starting at 0
  --peflags:<flags> = set extra PE Header flags field
  --peoptflags:<flags> = set extra PE Header optional flags field
  --peosversion:<major>.<minor> = set OS Version fields in PE Header (default: 5.0)
  --pesubsysversion:<major>.<minor> = set Subsystem Version fields in PE Header (default: 5.0)
  --peuserversion:<major>.<minor> = set User Version fields in PE Header (default: 0.0)
  --lib-version:<version> = Output package name version
  --lib-suffix:<suffix> = Output package name suffix
Compiler switches: -$<letter><state> (defaults are shown below)
  A8  Aligned record fields         
  B-  Full boolean Evaluation       
  C+  Evaluate assertions at runtime
  D+  Debug information             
  G+  Use imported data references  
  H+  Use long strings by default   
  I+  I/O checking                  
  J-  Writeable structured consts   
  L+  Local debug symbols           
  M-  Runtime type info             
  O+  Optimization                  
  P+  Open string params            
  Q-  Integer overflow checking     
  R-  Range checking                
  T-  Typed @ operator              
  V+  Strict var-strings            
  W-  Generate stack frames         
  X+  Extended syntax               
  Y+  Symbol reference info         
  Z1  Minimum size of enum types    
Stack size: -$M<minStackSize[,maxStackSize]> (default 16384,1048576)

drinterop.exe Description

The drinterop.exe in Embarcadero RAD Studio 13 Architect is part of the Delphi and C++Builder tooling for interoperation with .NET or other external frameworks. Specifically, it is used for Design-Time and Runtime interoperability�helping Delphi/C++ code interact with external components, services, or managed code environments.

In practical terms:

DR stands for Data/Design Runtime interoperability.
It is often invoked internally by RAD Studio during component design-time operations, importing type libraries, or interop with COM/.NET assemblies.
Developers usually don�t run this directly; it is called by the IDE or build tools to handle things like automatically generating interop units or wrapping external objects for Delphi use.

It is not a standalone application for general use; it�s mostly a helper for the IDE and compilation system.

If you want, I can provide a diagram showing how drinterop.exe fits into the RAD Studio build and design-time process. That often makes it much clearer. Do you want me to do that?

drinterop.exe Commandline Switches

Embarcadero Dr Interop  Version 1.0 Copyright (c) 2010 Embarcadero Technologies, Inc.

Usage: DRINTEROP [options] <assemblies> [options]
  /?     This help screen
  /q     Suppress copyright message

DSProxyGen.exe Description

DSProxyGen.exe is a command-line tool included with Embarcadero RAD Studio that is used to generate client proxy classes for DataSnap server applications.

Here�s a detailed summary:

Purpose:
It automates the creation of client-side proxy code so that a Delphi or C++ client can communicate with a DataSnap server. Instead of manually writing code to call server methods, DSProxyGen generates classes that expose server methods as local client methods.
Typical Usage:
You run it from the command line and provide it with:

The server URL or WSDL/metadata.
The output file name and programming language (Delphi or C++).

Example: generating Delphi proxies for a server:

DSProxyGen.exe -W http://localhost:8080/ServerMethods -O ClientProxies.pas -L Delphi

Output:

Delphi or C++ unit(s) containing classes and methods corresponding to the server�s DataSnap methods.
These proxies handle JSON or REST communication between the client and server.

Key Benefit:

Simplifies client development.
Ensures correct typing and method signatures.
Reduces errors in manual client-server communication code.

In short: DSProxyGen.exe generates ready-to-use client proxy classes for interacting with DataSnap servers.

DSProxyGen.exe Commandline Switches

syntax
	DSPROXYGEN [options] output [options]

output
	file name or file extension
		.java:	java_android
		.cpp:	C++
		.pas:	Delphi
		.js:	Java Script
		.h:	objectivec_ios42
		.cs:	csharp_silverlight
options
	[-C:connectionstring
		TCP/IP example:	host=localhost;port=211 (default)
		HTTP example:	host=localhost;port=8080;communicationprotocol=http
	[-IC:includeclasses]
	[-EC:excludeclasses
	[-IM:includemethods]
	[-EM:excludemethods]
	[-PW:proxywriter]
	[-REST]
	[-DBX]
examples
	Delphi proxy using default connection
		DSPROXYGEN .pas
	Delphi REST proxy
		DSPROXYGEN .pas -rest
	Exclude methods starting with "Echo" and ending with "String"
		DSPROXYGEN .pas -em:Echo*;*String
	Java Script proxy to file
		DSPROXYGEN c:\temp\servermethods.js
	Generate using registered writer
		DSPROXYGEN -pw:"Delphi DBX"

DSProxyReg.exe Description

DSProxyReg.exe in Embarcadero RAD Studio 13 Architect is used for managing and registering DataSnap client proxy classes.

Here�s a breakdown:

DataSnap context: DataSnap is Embarcadero�s framework for building multi-tier database applications. A DataSnap server exposes methods that can be called by clients.
Client proxies: To call server methods from a client, you typically generate proxy classes (Delphi, C++, or .NET) that wrap the remote calls in local objects.
DSProxyReg.exe purpose:

Registers or unregisters these proxy classes in the system or RAD Studio environment.
Helps integrate the proxy classes so that Delphi or C++Builder projects can easily use them without manually configuring unit references or class registrations.
Often works together with DSProxyGen.exe, which generates the proxy units; DSProxyReg.exe registers them.

In short: DSProxyReg.exe handles the registration of DataSnap client proxy classes so that they can be easily used in RAD Studio projects.

DSProxyReg.exe Commandline Switches

syntax
	DSPROXYREG [options] [filename]
filename
	proxy writer package to register
options
	[-u] = Unregister a proxy writer package
	[-r] = Register a proxy writer packages
	[-l] = List registered proxy writer packages
	[-lw] = List registered proxy writers
examples
	DSPROXYREG -r MyProxyWriter.bpl
	DSPROXYREG MyProxyWriter.bpl
	DSPROXYREG -u MyProxyWriter.bpl
	DSPROXYREG -l
	DSPROXYREG -lw

dsymlink.exe Description

dsymlink.exe in Embarcadero RAD Studio is used for managing symbolic links in the IDE environment. Specifically, it helps create, update, or maintain symbolic links for RAD Studio�s internal paths, such as library paths, package locations, or component directories, so that the IDE can reference files or folders consistently across different projects or installations.

It is primarily a developer/installer utility and not something you normally run directly during everyday coding. Its role is more about ensuring the IDE and its tools can correctly locate dependent files using symbolic links.

dsymlink.exe Commandline Switches

dsymlink - Generate dSYM file. Copyright 2012-16 Embarcadero Technologies, Inc.

Usage: dsymlink <machofile> [options]

    -o<file> Write dSYM file to <file> (default is <machofile>.dSYM).
    -h       Display this information.
    -q       Supress banner.
    -w[n]    Set warning level where n<=3; 0 disables warnings (default is 1).
    -v       Verbose mode.
    -i<path> Look in <path> when searching for files (repeat for each path).
    -x       Only look in paths specified in -i option when searching for files.
    -l<file> Only link files matching <file> (repeat for each).
    -f<str>  Only link files containing <str> (repeat for each).
    -c<num>  Use num as the codepage when interpretting strings.
    -d[o|f|s|l|u|v|a]* Debug mode (o=objects, f=fixups, s=symbols, l=lines, u=locale, v=verbose, a=all).

EMSDevConsole.exe Description

EMSDevConsole.exe Functionality

The EMSDevConsole.exe executable is the RAD Server Console (previously known as the EMS Desktop Console) application.

Description/Summary of Functionality

Its primary function is to serve as a standalone management tool for a RAD Server instance (formerly known as Enterprise Mobility Services or EMS). RAD Server provides a Mobile Enterprise Application Platform (MEAP) that allows you to deploy turnkey enterprise REST API app servers, exposing custom REST APIs and enterprise database data.

The functionalities of the RAD Server Console application include:

Connection Management: Configuring and switching between different RAD Server instances.
Integrated REST Debugger: Listing available endpoints on a specific RAD Server instance, executing requests, viewing JSON responses, and even copying the necessary client components for development.
Configuration Editing: Providing an integrated editor for the emsserver.ini configuration file.
User/Group/Installation Management: Managing various resources on the RAD Server, such as users, groups, and installation data.

Standalone Use

Yes, the application is designed to be used as a standalone application.

It is provided as a stand-alone developer application within the RAD Studio installation (typically alongside EMSDevServer.exe, the developer version of the RAD Server Engine). Embarcadero specifically recommends using the stand-alone applications for development purposes to easily test your RAD Server client applications and packages.

While it is bundled with the IDE, you can run EMSDevConsole.exe directly from the bin directory without needing to launch the Delphi IDE. For a production environment, however, Embarcadero recommends setting up the RAD Server Console on a dedicated web server, though the developer version is suitable for local testing.

EMSDevServerCommand.exe Description

EMSDevServerCommand.exe is part of Embarcadero RAD Studio and is associated with EMS (Enterprise Mobility Services). Its primary purpose is to control or interact with the EMS development server from the command line.

Specifically, this executable can be used to:

Start, stop, or restart the EMS development server.
Perform administrative actions for local EMS deployments during development.
Configure server settings such as ports, endpoints, and logging options (mainly for development purposes, not production).

It is primarily intended for developers testing EMS backends locally rather than for production EMS servers.

EMSDevServerCommand.exe Commandline Switches

RAD Development Server, Version 4.10 (37.0.57242.3601)
Copyright (c) 2009-2025 Embarcadero Technologies, Inc.

   -l[load]<package> - loads specified resource package
   -i[ni]<ini file name> - loads specified INI file
   -p[ort]<port> - specifies TCP/IP port to use
   -[lo]g<1|0> - enables / disables log output
   -s[etup] - runs initial setup mode
   -u[pgrade] - runs version upgrade mode
   -[sta]r[t] - starts server
   -[silen]t - runs with minimal questions and outputs
   -h[elp] - outputs this help

EMSMultiTenantConsole.exe Description

EMSMultiTenantConsole.exe is a standalone command-line administration tool for the EMS (Enterprise Mobility Services) Multi-Tenant Server.

Its primary function is to manage the high-level structure and configuration of an EMS server that is set up in a multi-tenant architecture. In a multi-tenant system, a single instance of the EMS server software can serve multiple, logically isolated groups of users, data, and backend resources. Each of these isolated groups is called a "tenant."

This console application allows system administrators to perform key administrative tasks on these tenants without needing to use a graphical user interface (GUI).

Key Functionality

The tool is designed for server and database-level operations. Typical commands and functionalities include:

Tenant Management:

Creating Tenants: Registering new tenants in the system.
Listing Tenants: Displaying all existing tenants and their details.
Deleting Tenants: Removing tenants and their associated data.
Enabling/Disabling Tenants: Activating or deactivating a tenant without deleting it.

User Management (at the Tenant Level):

Creating Users: Adding new users to a specific tenant.
Listing Users: Displaying all users belonging to a tenant.
Setting User Passwords: Manually setting or resetting user passwords.
Deleting Users: Removing users from a tenant.

Configuration & Setup:

Initializing the Database: Setting up the necessary database tables and schema for the EMS Multi-Tenant server.
Configuration Tasks: Various other setup and maintenance tasks that are easier to script from a command line.

Is it strictly used by the Delphi IDE or can it be used standalone?

It is primarily a standalone application.

Standalone Command-Line Tool: EMSMultiTenantConsole.exe is intended to be run directly from the Windows Command Prompt, PowerShell, or integrated into deployment and maintenance scripts (e.g., batch files, CI/CD pipelines). Its value lies in its ability to be automated and used in headless server environments where no GUI is available.
Relationship to the Delphi/C++Builder IDE: While it is a standalone tool, its functionality is closely related to the EMS development features within RAD Studio.

The Delphi IDE provides a visual component palette (like TEMSMultiTenantProvider) and a GUI-based management console (often accessible through the Data Explorer view) to perform similar tenant and user management tasks during development.
The EMSMultiTenantConsole.exe is the command-line counterpart to that GUI functionality. It is included with RAD Studio Architect so that developers and system administrators have the tools needed to manage the production EMS server environment outside of the IDE.

Analogy

Think of it this way:

Delphi IDE's Data Explorer / EMS Tab is like phpMyAdmin or SQL Server Management Studio (a GUI for management).
EMSMultiTenantConsole.exe is like the mysql or sqlcmd command-line clients (a scriptable, command-line tool for management).

Typical Use Case

A development team uses the Delphi IDE's GUI tools to set up and test tenants during the application development phase. When the application is deployed to a production server, the operations team uses EMSMultiTenantConsole.exe within their automated deployment scripts to create the initial tenant or to perform routine maintenance tasks like adding a new tenant on the live server.

Conclusion: EMSMultiTenantConsole.exe is a powerful, standalone command-line administration tool for managing the multi-tenant aspects of an Embarcadero EMS server. It is designed for system administrators and DevOps processes, complementing the GUI-based tools available inside the RAD Studio IDE.

FDExplorer.exe Description

FDExplorer.exe - FireDAC Explorer

FDExplorer.exe is the FireDAC Explorer utility, a database connection and exploration tool that comes with RAD Studio's FireDAC data access framework.

Functionality

FireDAC Explorer provides:

Database Connection Management: Create, test, and manage FireDAC connection definitions for various database systems (Oracle, SQL Server, MySQL, PostgreSQL, SQLite, InterBase, Firebird, etc.)
Database Browsing: Navigate database schemas, tables, views, stored procedures, and other database objects
SQL Query Execution: Execute SQL queries and view results interactively
Connection Definition Editor: Create and edit connection parameters including server, database, authentication, and advanced FireDAC-specific settings
Driver Configuration: Configure FireDAC drivers and vendor client libraries
Data Exploration: Browse table data, examine table structures and metadata

Standalone vs IDE Usage

FDExplorer.exe is a standalone application - it does not require the Delphi IDE to be running and can be used independently. You can launch it directly from the bin directory or create a shortcut.

Common Use Cases:

Developers: Test database connections before using them in code
Database Administrators: Quick database exploration without opening the full IDE
Testing: Verify connection strings and driver configurations
Prototyping: Test SQL queries before implementing them in applications

The connection definitions you create in FDExplorer are stored in .ini files and can be referenced by name in your Delphi/C++Builder applications using FireDAC components, providing consistency between development and runtime configurations.

FMXControlStyleViewer.exe Description

Functionality of FMXControlStyleViewer.exe

Summary: FMXControlStyleViewer.exe is a specialized preview tool provided with Embarcadero RAD Studio for the FireMonkey (FMX) framework, which is used for building cross-platform, visually rich applications in Delphi and C++Builder. Its primary purpose is to load and visually inspect FMX style files (.style files) focused on individual controls (e.g., buttons, labels, lists, and other UI elements). It renders these controls in a sample interface to demonstrate how they appear under the applied style, including variations for different states (e.g., normal, hovered, pressed, disabled, focused) and themes (e.g., light/dark modes). This helps developers test and debug custom styles without needing to compile and run a full application. Key features include:

Loading style files via command-line arguments (e.g., FMXControlStyleViewer.exe path\to\your.style) or by right-clicking a .style file and selecting "Open with" this executable.
Interactive preview of control-specific styling, allowing zooming, state toggling, and resolution scaling to simulate high-DPI displays.
Support for platform-specific rendering (e.g., Windows, macOS, mobile) to verify cross-platform consistency.

It is part of a family of FMX style preview tools (e.g., alongside FMXStyleViewer.exe for general styles, FMXMobileStyleViewer.exe for mobile themes), and style files are typically found in the RAD Studio installation directory under Redist\styles\Fmx.

Standalone Usage: Yes, it can be used as a fully standalone application outside of the Delphi IDE. It is not integrated exclusively into the IDE (unlike the Bitmap Style Designer, which invokes similar previews internally during style editing). You can launch it directly from the command line, File Explorer, or by associating .style files with it for quick previews during development workflows.

For more details on creating or editing FMX styles, refer to the RAD Studio documentation on customizing FireMonkey applications. If you're working with RAD Studio 13, ensure your styles are compatible with the updated FMX runtime for optimal results.

FMXMetropolisUIStyleViewer.exe Description

Application: FMXMetropolisUIStyleViewer.exe
Installed with: Embarcadero RAD Studio 13 Architect
Location: ...\Embarcadero\Studio\23.0\bin\

🧭 Purpose and Functionality Summary

FMXMetropolisUIStyleViewer.exe is a FireMonkey (FMX) utility developed by Embarcadero to preview and inspect Metropolis UI styles.
Metropolis UI styles are a special class of FMX visual themes designed to emulate the look and behavior of modern Windows �Metro� or �Modern UI� applications�flat layouts, tile-based controls, and touch-friendly interface elements.

This tool enables developers to:

Open and view .style files used by FireMonkey applications (for both Windows and mobile platforms).
Preview styled controls (buttons, edits, lists, etc.) as they appear with the selected Metropolis UI theme.
Inspect the structure of the style, including objects, bitmaps, and layout elements used in the theme.
Test style color variations and scaling (especially relevant for High-DPI support).
Validate compatibility of a style with a FireMonkey framework version before applying it in a project.

Essentially, it�s a visual style inspector and previewer for FMX styles used in Metropolis UI projects.

🧩 Integration and Usage Context

Within the Delphi/C++Builder IDE:
The Delphi IDE can automatically launch this utility when you use Tools → FireMonkey → Metropolis UI Style Viewer, or when you preview styles via the Style Designer dialog.
Standalone Usage:
✅ Yes � it can be used as a standalone application.
You can directly run FMXMetropolisUIStyleViewer.exe outside the IDE to manually open .style files and preview them.

Example standalone usage:

FMXMetropolisUIStyleViewer.exe "C:\Users\Public\Documents\Embarcadero\Studio\13.0\Styles\MetropolisUIBlue.style"

This opens the given style file for inspection without needing to start the IDE.

⚙️ Command-Line Arguments (Typical Use)

Although not heavily documented, the executable generally supports:

Opening a style file directly as an argument:

� FMXMetropolisUIStyleViewer.exe <path-to-style-file>

If no arguments are provided, the application launches an Open File dialog for interactive selection.

🧾 Summary Table

Aspect	Description
Executable	FMXMetropolisUIStyleViewer.exe
Primary Purpose	Preview and inspect FireMonkey Metropolis UI style files (.style)
Used By IDE	Yes � invoked by the Delphi/C++Builder IDE
Standalone Usable	Yes � runs independently to open .style files
Input Format	.style FireMonkey style definition files
Typical Users	Delphi/C++Builder developers designing FMX UIs

FMXMobileStyleViewer.exe Description

Based on the name FMXMobileStyleViewer.exe, this is a utility application for viewing and previewing FireMonkey (FMX) mobile styles in RAD Studio.

Functionality

This application allows you to:

Preview mobile styles - View how different FireMonkey style files (.style files) will appear on mobile platforms (iOS and Android)
Inspect style components - See how various UI controls (buttons, edit boxes, list views, etc.) are rendered with different styles
Compare styles - Evaluate different mobile style designs before applying them to your projects
Test style appearance - Check how styles look without having to compile and deploy to an actual mobile device or emulator

Usage Type

This can be used as a standalone application. While it's included with RAD Studio and integrated into the development workflow, you don't need the IDE running to use it. You can:

Launch it directly from the bin directory
Use it to preview any .style files on your system
Run it independently to evaluate mobile styles outside of an active development session

This is particularly useful for:

Designers who want to preview styles without opening the full IDE
Quick style comparisons when deciding on UI design direction
Testing custom styles you've created or downloaded
Learning how FireMonkey mobile controls appear in different style themes

The standalone nature makes it a convenient tool for rapid style evaluation without the overhead of loading the entire RAD Studio environment.

FMXStyleViewer.exe Description

FMXStyleViewer.exe Functionality

The FMXStyleViewer.exe executable is a utility specifically for FireMonkey (FMX) Styles.

Primary Function: It allows you to test and preview custom and built-in FireMonkey Styles (files with the .style extension). FireMonkey styles define the look and feel (skinning) of multi-device applications created with RAD Studio, which can target platforms like Windows, macOS, Android, and iOS.
Context: It's used in conjunction with the Bitmap Style Designer�an IDE tool that allows developers to create and edit these visual styles for their FMX applications. After designing a style, you can use the Style Viewer to see how various controls (like buttons, edits, and lists) look when the style is applied to them across different platforms (e.g., Windows, macOS).

💻 Standalone Use

Yes, FMXStyleViewer.exe can be used as a standalone application outside of the Delphi or C++Builder IDE.

Standalone Use Case: You can typically execute it directly from the Windows file system and pass the path to a .style file as a command-line parameter. This is a common way for developers to quickly view and check a style without having to open the main RAD Studio IDE.

This application is essentially a dedicated viewer that loads a FireMonkey style definition and renders a set of standard controls using that style, allowing for visual inspection of the UI changes it introduces.

FMXWinModernStyleViewer.exe Description

FMXWinModernStyleViewer.exe is a utility application included with Embarcadero RAD Studio 13 Architect that is specifically designed to preview and inspect FireMonkey (FMX) Windows Modern UI styles.

Functionality Summary:

Purpose:
The tool allows developers to visualize how FireMonkey UI controls and components appear when rendered with the Windows Modern style (also known as the "Windows 11-style" or Fluent-inspired visual theme introduced in recent RAD Studio versions).
What It Shows:
It typically displays a gallery or form containing a variety of standard FMX controls (e.g., buttons, edit boxes, combo boxes, grids, etc.) rendered using the Windows Modern style. This helps developers understand the look and feel of their applications when this style is applied.
Use Case:
Primarily used during UI/UX design and theming to verify that controls behave and appear as expected under the Windows Modern style�especially useful when targeting Windows 10/11 with a native, modern aesthetic.

Standalone vs. IDE Integration:

Standalone Application:
Yes, FMXWin"Arial"StyleViewer.exe can be run independently outside of the Delphi or C++Builder IDE. It does not require the IDE to be open and functions as a self-contained executable.
Not IDE-Dependent:
While it is shipped with RAD Studio and serves developers using FireMonkey, it is not a plugin or internal IDE component. You can launch it directly from the bin directory (e.g., C:\Program Files (x86)\Embarcadero\Studio\23.0\bin\).
Developer Tool:
It is intended as a developer aid, not an end-user application. End users of your software would never interact with this tool�it�s purely for design-time preview and validation.

Conclusion:

FMXWinModernStyleViewer.exe is a standalone diagnostic and preview utility for FireMonkey developers working with the Windows Modern style in RAD Studio 13. It is not required at runtime and is not part of the IDE itself, but rather a helper application you can run anytime to inspect the visual appearance of FMX controls under this specific theme.

Formatter.exe Description

Application: Formatter.exe
Installed with: Embarcadero RAD Studio 13 Architect
Location: ...\Embarcadero\Studio\23.0\bin\Formatter.exe

Description / Functionality Summary

Formatter.exe is the Delphi source code formatter engine used by the Delphi IDE. It automatically reformats Delphi (Object Pascal) source code files according to the formatting options defined in the IDE or in an external configuration file. Its main purpose is to ensure consistent indentation, spacing, capitalization, and code layout throughout a project or team.

It is the backend executable for the "Format Source" or "Reformat Code" feature accessible via the IDE menus (Ctrl+D in the editor).

Key Capabilities

Reformats .pas (unit) and .dfm (form) files based on Delphi formatting rules.
Honors configuration settings defined in:

The IDE�s Formatter Options dialog.
External configuration files such as Formatter.config or .formatter.conf.

Can process one or multiple files at once.
Provides consistent code style across developers and builds.

Usage Context

Primarily IDE-integrated:
The Delphi IDE invokes Formatter.exe internally when you use the �Format Source� command or apply formatting options from project settings.
Can be used standalone (with limitations):
Formatter.exe can be executed from the command line as a standalone tool. This makes it useful for:

Automated build or CI/CD processes that need to enforce code formatting.
Batch-formatting source files outside the IDE.

However, it typically requires either:

A valid configuration file specifying formatting rules, or
Running it with command-line arguments that specify input and output files.

Typical Command-Line Usage (when supported)

Although not officially documented for public use, older versions of Formatter.exe support syntax like:

Formatter.exe -config "C:\Path\to\Formatter.config" -file "C:\Project\Unit1.pas"

Formatter.exe -folder "C:\Project\Source" -recursive

These options may vary slightly between RAD Studio versions. Running the tool without parameters often displays available switches.

Formatter.exe Commandline Switches

Application: Formatter.exe
Installed with: Embarcadero RAD Studio 13 Architect
Location: ...\Embarcadero\Studio\23.0\bin\Formatter.exe

Description / Functionality Summary

Formatter.exe is the Delphi source code formatter engine used by the Delphi IDE. It automatically reformats Delphi (Object Pascal) source code files according to the formatting options defined in the IDE or in an external configuration file. Its main purpose is to ensure consistent indentation, spacing, capitalization, and code layout throughout a project or team.

It is the backend executable for the "Format Source" or "Reformat Code" feature accessible via the IDE menus (Ctrl+D in the editor).

Key Capabilities

Reformats .pas (unit) and .dfm (form) files based on Delphi formatting rules.
Honors configuration settings defined in:
The IDE’s Formatter Options dialog.
External configuration files such as Formatter.config or .formatter.conf.
Can process one or multiple files at once.
Provides consistent code style across developers and builds.
Usage Context

Primarily IDE-integrated:
The Delphi IDE invokes Formatter.exe internally when you use the “Format Source” command or apply formatting options from project settings.
Can be used standalone (with limitations):
Formatter.exe can be executed from the command line as a standalone tool. This makes it useful for:
Automated build or CI/CD processes that need to enforce code formatting.
Batch-formatting source files outside the IDE.
However, it typically requires either:

A valid configuration file specifying formatting rules, or
Running it with command-line arguments that specify input and output files.
Typical Command-Line Usage (when supported)

Although not officially documented for public use, older versions of Formatter.exe support syntax like:

Formatter.exe -config "C:\Path\to\Formatter.config" -file "C:\Project\Unit1.pas"

Formatter.exe -folder "C:\Project\Source" -recursive

These options may vary slightly between RAD Studio versions. Running the tool without parameters often displays available switches.

GenDocCLI.exe Description

GenDocCLI.exe Functionality Summary

The GenDocCLI.exe executable in Embarcadero RAD Studio 13 Architect is the Command-Line Documentation Generation Tool for Delphi projects.

Its primary function is to automatically generate HTML-format documentation from your Delphi project files (.dproj), including source code and UML model information.

Key details about its operation:

Mode of Operation: It is a command-line utility, allowing you to run the documentation generation feature outside of the RAD Studio Integrated Development Environment (IDE). This is useful for integration into build scripts or automated processes.
Supported Projects: It can generate documentation for any Delphi projects, even those that do not support UML Modeling. However, it cannot generate documentation for C++ projects.
Output: The documentation is typically generated into a specified output folder as a set of HTML files.
Customization: You can control the output using various command-line options, such as:

Excluding diagrams (--without-diagrams).
Excluding the navigation tree (--without-navigation).
Running in quiet mode (-q or --quiet).
Specifying the output folder (-o OutputFolder).
Defining compiler options like search paths for units (-U), include directories (-I), and conditional compilation symbols (-D).

GenDocCLI.exe Commandline Switches

Embarcadero Generate Documentation command line version
Copyright (c) 2010 Embarcadero Technologies, Inc.

Syntax: GenDocCLI.exe {options} <project.dproj>
List of options:
	-o <path>		output folder
	--without-diagrams	don't generate diagrams
	--without-navigation	don't include navigation applet
	<project.dproj>		Delphi project file
	--build-config=<name>	Override default build configuration (e.g. Debug, Release)
	-q,--quiet		suppress messages
	-v			verbose, print more info about configuration
Compiler options:
	-Ipath1;path2;...	include directories
	-Upath1;path2;...	compiled unit directories
	-Dsymbol1;symbol2;...	conditional compilation symbols
	-A<unit>=<alias>	unit aliases

GenTLB.exe Description

Here is a detailed summary of the functionality of GenTLB.exe, specifically within the context of Embarcadero Rad Studio 13 Architect.

Core Functionality

GenTLB.exe is a command-line utility whose primary purpose is to generate a Pascal Import Library for a Type Library.

In simpler terms, it takes a file containing type definitions (a Type Library, often a .tlb, .dll, .ocx, or .exe file) and creates a Delphi unit (a .pas file) that allows your Delphi or C++Builder application to easily interact with the COM objects, interfaces, and constants defined within that Type Library.

Detailed Breakdown

1. What is a Type Library (TLB)?

A Type Library is a binary file (or a resource embedded in a DLL/OCX/EXE) that describes COM interfaces, coclasses (COM classes), enumerations, records (structures), and constants. It is the metadata for a COM component. Examples include libraries for Microsoft Office applications, ActiveX controls, or any other COM-based API.

2. What Does GenTLB.exe Create?

When you run GenTLB.exe on a type library, it generates a .pas file. This file contains:

Interface and CoClass Declarations: Pascal translations of the COM interfaces and classes.
GUID Constants: The globally unique identifiers for every interface and class, defined as constants.
Enumerations and Records: Pascal versions of any custom types defined in the type library.
Helper Functions: Often includes Create helper functions to instantiate COM objects easily (e.g., CreateComObject calls).

This generated unit is the bridge that lets your native Pascal code call into the COM-based component.

3. How is it Used?

GenTLB.exe is used from the command line. The basic syntax is:

bash

GenTLB.exe [options] <SourceFile>

Common Options and Scenarios:

Source File: The input can be a .tlb file, or a file that contains a type library as a resource (e.g., msxml6.dll, excel.exe).
Output File (-P): Specifies the name of the output Pascal file. If not provided, it often defaults to a name based on the source file.

bash

GenTLB.exe -PMSXML6_Pas.pas msxml6.dll

Help (-?, -H): Displays the list of available command-line options.

4. Relationship with the RAD Studio IDE

While you can use GenTLB.exe manually, the RAD Studio IDE automates this process in the background when you:

Go to Component > Import Component > Import a Type Library.
Select a type library and choose "Install" or "Generate Unit".

The IDE internally calls GenTLB.exe (or a very similar internal mechanism) to generate the Pascal import unit and then adds it to your project or the component palette.

5. Key Use Cases

Using Microsoft Office Automation: To control Word, Excel, or Outlook from a Delphi application, you import their type libraries to generate the necessary Word2000.pas, Excel2000.pas, etc., units.
Using Third-Party ActiveX Controls: If you have an .ocx ActiveX control, you use this tool (via the IDE) to create a Delphi wrapper so you can place it on a form.
Interfacing with COM-based APIs: Many Windows system components and third-party software provide a COM API. GenTLB.exe is the first step to accessing them from Rad Studio.

Summary for a Developer

Think of GenTLB.exe as the "COM Bridge Builder." It's a specialized compiler that takes the language of COM (Type Libraries) and translates it into the native language of Delphi (Pascal), saving you from the tedious, complex, and error-prone task of manually writing all the interface declarations and GUIDs yourself.

Location: It's found in the bin directory of your Rad Studio installation (e.g., C:\Program Files (x86)\Embarcadero\Studio\22.0\bin).

In practice, you will rarely call this executable directly unless you are building from a command line or writing a script, as the IDE's "Import Type Library" feature provides a much more convenient front-end for it. However, understanding its purpose is fundamental to working with COM in Rad Studio.

GenTLB.exe Commandline Switches

Embarcadero GenTLB Version 12.16581
Copyright(c) 1995-2025 Embarcadero Technologies, Inc.

Syntax: GenTLB [options] <sourcefile>

 TLB Output File Options:                      
    -T<name>   Name of typelibrary output file 
    -D<path>   Output directory path           

 Additional Language Binding files to generate:
  -C  Generate C++ Binding file                
  -P  Generate PASCAL Binding file

GetItCmd.exe Description

GetItCmd.exe is a command-line utility included with Embarcadero RAD Studio (versions like 13 Architect), serving as the CLI counterpart to the graphical GetIt Package Manager. It enables developers to manage third-party components, libraries, and tools for Delphi and C++ Builder projects without using the IDE's GUI interface. This tool is particularly useful for automation, scripting, or headless environments, such as CI/CD pipelines.

Key Functionalities

Package Discovery and Listing: Commands like list allow users to query and display available packages from Embarcadero's repository, including details such as versions, descriptions, and installation status.
Installation and Updates: Supports installing or updating packages via commands like install or update, specifying package names or IDs. For example, it can download and integrate components like FireDAC drivers or third-party libraries directly into the RAD Studio environment.
Removal and Management: Includes options to uninstall packages (uninstall) or check for updates, ensuring version control and dependency handling.
Authentication and Configuration: Requires login credentials for accessing licensed or premium packages, and supports configuration options for proxy settings or custom repositories.
Output and Logging: Provides verbose output for troubleshooting, with options for JSON or plain text formats, making it scriptable for batch operations.

This tool integrates with RAD Studio's ecosystem, ensuring that installed packages are properly registered in the IDE. For detailed usage, refer to Embarcadero's official documentation or run GetItCmd.exe --help for command syntax. Note that functionality may vary slightly by RAD Studio version, and it requires an active internet connection for repository access.

GetItCmd.exe Commandline Switches

GetIt Package Manager - Version 7.0
Copyright (c) 2025 Embarcadero Technologies, Inc. All Rights Reserved.

Usage: GetItCmd [<Options>]:
  -i=<itemid>  or  --install=<itemid>
	Install Item[s] separated with ";".
  -if=<featureid>  or  --install_features=<featureid>
	Install Feature[s] separated with ";". Available IDs: 
	delphi, delphi_windows, delphi_macos, delphi_linux, delphi_ios
	delphi_android, cbuilder, cbuilder_windows, french, german
	japanese, samples, help, teechart, dunit
	interbase_express, interbase_2020, openjdk, android_sdk, fonts.
  -id  or  --installdeferred
	Install deferred packages.
  -u=<itemid>  or  --uninstall=<itemid>
	Uninstall Item[s] separated with ";".
  -d=<fileurl>  or  --download=<fileurl>
	Download a file.
  -l=<searchby>  or  --list=<searchby>
	List all available items. Result set depends on sort and filter commands.
  -s=[name/vendor/date]  or  --sort=[name/vendor/date]
	Specifies the sort parameter for the list command. Default is "name".
  -f=[all/installed]  or  --filter=[all/installed]
	Specifies the filter parameter for the list command. Default is "installed".
  -ra=<apppath>  or  --runapp=<apppath>
	Run an application before exit.
  -c=[useonline/useoffline]  or  --config=[useonline/useoffline]
	Set up a GetIt system.
  -un=<username>  or  --username=<username>
	User name for proxies with required authentication.
  -p=<password>  or  --password=<password>
	Password for proxies with required authentication.
  -v=[quiet/minimal/normal/detailed]  or  --verb=[quiet/minimal/normal/detailed]
	Specifies the verbose level for console output messages.
  -ae  or  --accepteulas
	The user accepts EULA[s] of downloaded package[s].
  -dnsef  or  --donotsetenvfile
	Do not set environment variables.
  -h  or  --help
	Print all available commands.
  -ap=<appparams>  or  --appparams=<appparams>
	Parameters for run application.

Command finished with success!

grep.exe Description

grep.exe in RAD Studio

grep.exe is a text search utility that implements the classic Unix/Linux "grep" (Global Regular Expression Print) command for Windows. It searches through files for lines matching specified patterns.

Core Functionality

Pattern Matching: Searches files for text patterns using regular expressions or literal strings
File Scanning: Can search single files, multiple files, or entire directory trees
Line-Based Output: Displays matching lines along with file names and optional line numbers
Regular Expression Support: Supports pattern matching with wildcards and regex syntax
Case Sensitivity Options: Can perform case-sensitive or case-insensitive searches
Context Display: Can show surrounding lines around matches for context

Typical Command-Line Options

Common grep flags include:

-i : Case-insensitive search
-r or -R : Recursive directory search
-n : Show line numbers
-l : List only filenames containing matches
-v : Invert match (show non-matching lines)
-c : Count matching lines

Standalone vs. IDE Usage

This is a standalone command-line application. While included with RAD Studio for convenience (likely used by the IDE for internal search operations and build processes), grep.exe can absolutely be used independently from the command prompt or in batch scripts.

You can use it for:

Searching source code across projects
Text processing automation
Log file analysis
Build script utilities
Any general text search task

The IDE may invoke it behind the scenes for "Find in Files" operations, but you're free to use it directly via command line for your own purposes.

grep.exe Commandline Switches

Turbo GREP 5.6 Copyright (c) 1992-2010 Embarcadero Technologies, Inc.
Syntax:  GREP [-rlcnvidzewoqhu] searchstring file[s] or @filelist

Options are one or more option characters preceded by "-", and optionally
followed by "+" (turn option on), or "-" (turn it off).  The default is "+".
   -r+  Regular expression search       -l-  File names only
   -c-  match Count only                -n-  Line numbers
   -v-  Non-matching lines only         -i-  Ignore case
   -d-  Search subdirectories           -z-  Verbose
   -e   Next argument is searchstring   -w-  Word search
   -o-  UNIX output format                   Default set: [0-9A-Z_]
   -q-  Quiet: supress normal output
   -h-  Supress display of filename
   -u xxx Create a copy of grep named 'xxx' with current options set as default

A regular expression is one or more occurrences of:  One or more characters
optionally enclosed in quotes.  The following symbols are treated specially:
      ^  start of line             $  end of line
      .  any character             \ quote next character
      *  match zero or more        +  match one or more
      [aeiou0-9]   match a, e, i, o, u, and 0 thru 9 ;
      [^aeiou0-9]  match anything but a, e, i, o, u, and 0 thru 9

impdef.exe Description

impdef.exe is a command-line utility included with Embarcadero RAD Studio (and previously with Borland/CodeGear development tools) that generates a module definition (.def) file from an existing Windows DLL.

Primary Function:

Extracts exported symbols (functions, procedures, and data) from a DLL.
Creates a .def file listing those exports, which can then be used by the linker (e.g., ilink32.exe or ilink64.exe) to create an import library (.lib) or to link against the DLL in C++ or Object Pascal projects.

Typical Use Case:

If you have a third-party DLL but no corresponding import library or header files, you can run:

cmd

impdef MyLibrary.def MyLibrary.dll

This produces MyLibrary.def, which you can then use with the implib.exe tool (also included with RAD Studio) to generate an import library:

cmd

implib MyLibrary.lib MyLibrary.def

The resulting .lib file enables your application to link against the DLL at compile time.

Key Notes:

Works with 32-bit and 64-bit DLLs, depending on the version of impdef.exe.
Only captures exported symbols�it does not recover function parameters, calling conventions, or data types; those must be known or reverse-engineered separately.
Commonly used in interfacing with legacy or third-party DLLs where source code or import libraries are unavailable.

In summary, impdef.exe is a DLL export inspector and .def file generator, facilitating linking to external DLLs in Embarcadero C++ and Delphi projects.

impdef.exe Commandline Switches


Embarcadero Impdef Version 3.4.0 Copyright (c) 1991-2016 Embarcadero Technologies, Inc.

Syntax: IMPDEF [options] destname[.def] srcname[.dll]
Options:
    -a     Add '_' alias for MS flavor cdecl functions 
    -aa    Force the alias even if the function already starts with '_'
    -s     Don't convert stdcall names from Microsoft mangling
    -h     Emit hints

implib.exe Description

implib.exe is the Import Library Tool for 32-bit Windows applications in RAD Studio. It creates import libraries directly from DLLs or from module definition files for DLLs Embarcadero.

Key Functionality:

An import library lists some or all of the exported functions for one or more DLLs Embarcadero
Used for optionally creating 32-bit Windows import libraries from the command line Embarcadero
Can work with various file types (not just .DLL files, but also .EXE or .DRV extensions)

Command Syntax:

Basic usage is: IMPLIB <options> <LibName>[.lib] ...

Important Note:

For 64-bit applications, RAD Studio uses a different utility called mkexp (MKEXP.EXE) EmbarcaderoEmbarcadero instead of implib.exe. Since you have RAD Studio 13, you'll likely be using the 64-bit toolchain for most modern development, which means implib.exe would primarily be for legacy 32-bit Windows projects.

implib.exe Commandline Switches


Embarcadero Implib Version 3.4.0 Copyright (c) 1991-2016 Embarcadero Technologies, Inc.

Syntax: IMPLIB [options] libname[.lib] [@respfile | srcname] [srcname ...]
 Options:
    -a     Add '_' alias for MS flavor cdecl functions
    -aa    Force the alias even if the function already starts with '_'
    -c     Case sensitive symbols
    -f     Force imports by name (with hints)
    -s     Don't convert stdcall names from Microsoft mangling
    -w     No Warnings

Respfile may contain a list of source files to process.
Wildcards are ok for .DLL and .DEF file names.

make.exe Description

Primary Purpose

To automatically manage the process of compiling and linking source code into executable programs, libraries, and other final outputs. It determines which parts of a project need to be recompiled and issues the commands to do so, saving you from manually compiling every file every time.

Key Functionality

Dependency Tracking & Incremental Builds:

This is make's most important job. It reads a "makefile" (a script, typically named Makefile), which defines:

Targets: The files to be built (e.g., MyProgram.exe, MyLibrary.lib).
Dependencies: The source files and headers that the targets rely on (e.g., main.pas, unit1.pas, unit1.dcu).
Commands: The actual shell commands needed to build the target from its dependencies (e.g., dcc32 unit1.pas, dcc32 main.pas, ilink32 ...).

make then checks the timestamps of all files. If a dependency is newer than its target, make knows the target is "out of date" and executes the specified commands to rebuild it. This ensures only the changed parts of a project are recompiled, drastically speeding up build times.

Orchestrating the Build Process:

It executes the complex sequence of commands required to turn source code into a finished product. For a Delphi or C++ project, this involves running the correct compiler (dcc32.exe, dcc64.exe, bcc32c.exe, etc.), the linker (ilink32.exe), and potentially other pre- or post-build tools in the correct order.

Integration with the Rad Studio Toolchain:

While you can write your own makefiles, the Rad Studio IDE itself generates them when you use its "Project > Build Project" or "Project > Compile Project" commands. The IDE's build system internally uses this make.exe to perform the actual work.

Command-Line Builds:

Its presence allows for headless and automated builds from the command line, in scripts, or on a continuous integration (CI) server like Jenkins or GitHub Actions. You can build a project without opening the IDE by running a command like:

bash

make -f MyProject.mak

In the Context of Rad Studio

It's the Engine: When you hit "Build" in the Rad Studio IDE, you are essentially telling the IDE to generate a detailed makefile and then call make.exe to execute it.
File Association: This make.exe is almost certainly configured to be the version used by the GNU Makefile project type within the IDE.
MSBuild vs. Make: It's important to note that for standard Delphi and C++ Builder project files (.dproj), the primary build engine in modern Rad Studio versions is MSBuild. However, make.exe is still present for compatibility, for use with GNU Makefile project types, and for the IDE's internal build processes.

Summary Analogy

Think of make.exe as a smart construction foreman for your software project.

It has a blueprint (the Makefile).
It knows what materials have changed (the source files).
It only tells the workers (the compiler, linker) to work on the parts that are affected by those changes.
This ensures the final building (your executable) is built correctly and efficiently, without doing any unnecessary work.

In short, the make.exe in your Rad Studio bin directory is a critical, behind-the-scenes utility that drives the efficient and automated building of your applications.

make.exe Commandline Switches

MAKE Version 5.43  Copyright (c) 1987, 2019 Embarcadero Technologies, Inc.
Syntax: MAKE [options ...] target[s]
    -B                Builds all targets regardless of dependency dates
    -Dsymbol[=string] Defines symbol [equal to string]
    -Idirectory       Names an include directory
    -K                Keeps (does not erase) temporary files created by MAKE
    -N                Increases MAKE's compatibility with NMAKE
    -Wfilename        Writes MAKE to filename updating all non-string options
    -Usymbol          Undefine symbol
    -ffilename        Uses filename as the MAKEFILE
    -a                Performs auto-dependency checks for include files
    -c                Caches auto-dependency information
    -e                Ignores redefinition of environment variable macros
    -i                Ignores errors returned by commands
    -l+               Enables use of long command lines
    -m                Displays the date and time stamp of each file
    -n                Prints commands but does not do them
    -p                Displays all macro definitions and implicit rules
    -q                Returns zero if target is up-to-date and nonzero
                      if it is not (for use in batch files)
    -r                Ignores rules and macros defined in BUILTINS.MAK
    -s                Silent, does not print commands before doing them
    -? or -h          Prints this message
      Options marked with '+' are on by default. To turn off a default
      option follow it by a '-', for example: -a-

migrationtool.exe Description

migrationtool.exe is the standalone command-line interface (CLI) for the RAD Studio Project Migration Tool. Its primary purpose is to automate the process of converting projects, project groups, and source code from older versions of Delphi and C++Builder to a format compatible with RAD Studio 13 (Alexandria).

In essence, it performs the same core function as the migration wizard that launches automatically when you open an older project in the RAD Studio IDE, but it does so without a graphical user interface and without requiring the IDE to be running.

Core functionalities include:

Version Conversion: Updates project files (.dpr, .dproj, .cbproj, .groupproj) from older versions (e.g., Delphi 7, XE series, 10.x versions) to the RAD Studio 13 format.
Path and Setting Updates: Modernizes search paths, library paths, and other compiler/linker settings to be valid for the current toolchain.
Dependency Resolution: Attempts to locate and update references to components, packages, and source files, flagging any it cannot find.
Backup Creation: A critical feature that creates a backup of your original project files before making any changes, allowing for a safe rollback if needed.
Batch Processing: It can process multiple projects or entire directories of projects in a single run, which is its most significant advantage over the interactive IDE tool.

Standalone vs. IDE Integration

Is it strictly used by the Delphi IDE or can it be used as a standalone application?

It is primarily a standalone application.

Standalone CLI Tool: You run migrationtool.exe directly from the command prompt, a batch file, or a script. This is ideal for build servers, system administrators, or developers who need to migrate a large codebase consistently and repeatably without manual intervention.
Distinct from the IDE Wizard: While the IDE has its own integrated migration wizard (a GUI), migrationtool.exe is a separate, dedicated executable. The IDE itself likely does not call this specific CLI tool; it uses its own internal libraries to perform the same migration logic when you open a project.

Typical Use Cases

Automated Build Pipelines: Before building a legacy project on a CI/CD server (like Jenkins or Azure DevOps), migrationtool.exe can be called as a build step to ensure the project is correctly formatted for the RAD Studio 13 compiler.
Bulk Migration: When upgrading a large portfolio of projects (e.g., hundreds of projects from Delphi 7 or RAD Studio 10.4), using the CLI tool with a simple script is far more efficient than opening and migrating each one manually in the IDE.
Consistency and Reporting: Running the tool from a script allows you to capture its output log, which can be parsed for errors, warnings, and a summary of the migration process.

Basic Command Line Usage Example

You would typically open a command prompt in your project's directory or use the RAD Studio Command Prompt (which has the correct environment paths set).

Here's a basic example:

bash

# Navigate to the bin directory or ensure it's in your PATH

cd "C:\Program Files (x86)\Embarcadero\Studio\22.0\bin"

# Migrate a single project group

migrationtool.exe -M "C:\MyOldProjects\MyApp.groupproj"

# Migrate all projects in a directory and its subdirectories

migrationtool.exe -M -R "C:\MyOldProjects"

# Get help to see all options

migrationtool.exe -?

Common command-line options include -M for migration mode, -R for recursive directory searching, and -B to specify a custom backup location.

Conclusion

migrationtool.exe is a powerful and essential standalone command-line utility for any developer or organization systematically upgrading a codebase to RAD Studio 13. It provides the automation and repeatability needed for large-scale migrations that the interactive IDE wizard cannot efficiently handle. It is a separate tool that complements, rather than is driven by, the Delphi/C++Builder IDE.

mkexp.exe Description

mkexp.exe in Embarcadero Rad Studio is a utility used to generate export definition (.DEF) files from object files or compiled libraries. These .DEF files list the symbols (functions, procedures, and data) that a DLL or library exports, which is necessary when building dynamic-link libraries (DLLs) in Delphi or C++Builder.

In short:

Input: Object files (.obj) or libraries.
Output: .DEF file listing exported symbols.
Use case: Preparing a DLL for linking or creating import libraries for use by other modules.

It�s primarily a linker support tool and is usually invoked automatically by the build process when creating DLLs.

mkexp.exe Commandline Switches

mkexp.exe: Copyright (c) 2013 Embarcadero Technologies, Inc.
All rights reserved.

usage: mkexp [-f] [-d] [-o] [-p] outputfile inputfile
     Creates an import archive from an input file.
     Valid input files are OMF object files that contain only
     EXPDEF COMENT records, PE files, and DEF files.

     -f: prefer to link by ordinal (dangerous)
     -d: assume input is a DEF file
     -o: assume input is an OMF object file
     -p: assume input is a PE file

     File type is by default based on extension:
     OMF: .obj
     DEF: .def
     PE:  .dll, .exe

objcopy.exe Description

The objcopy.exe in Embarcadero Rad Studio 13 Architect is a binary utility for manipulating object files and executables. Its main functions include:

Copying object files from one format to another (e.g., COFF, OMF, ELF, or proprietary formats used by Delphi/C++Builder).
Stripping or preserving sections of an object file (such as debug info, symbols, or relocation data).
Converting between formats to make object files compatible with different linkers or toolchains.
Renaming or modifying symbols in object files.
Merging or extracting sections from object files.

Essentially, objcopy is used to transform, clean, or adapt compiled object files for linking, distribution, or debugging purposes.

In the context of Delphi/C++Builder, it is often used internally in the build process when converting COFF/OMF object files or preparing binaries for linking.

objcopy.exe Commandline Switches

OVERVIEW: llvm-objcopy tool

USAGE: llvm-objcopy [options] input [output]

OPTIONS:
  --add-gnu-debuglink=debug-file
                          Add a .gnu_debuglink for <debug-file>
  --add-section=section=file
                          Make a section named <section> with the contents of <file>.
  --add-symbol=name=[section:]value[,flags]
                          Add new symbol <name> to .symtab. Accepted flags: global, local, weak, default, hidden, protected, file, section, object, function, indirect-function. Accepted but ignored for compatibility: debug, constructor, warning, indirect, synthetic, unique-object, before.
  --adjust-start <value>  Alias for --change-start
  --allow-broken-links    Allow the tool to remove sections even if it would leave invalid section references. The appropriate sh_link fields will be set to zero.
  --binary-architecture=<value>
                          Ignored for compatibility
  --build-id-link-dir=dir Set directory for --build-id-link-input and --build-id-link-output to <dir>
  --build-id-link-input=suffix
                          Hard-link the input to <dir>/xx/xxx<suffix> name derived from hex build ID
  --build-id-link-output=suffix
                          Hard-link the output to <dir>/xx/xxx<suffix> name derived from hex build ID
  -B <value>              Alias for --binary-architecture
  --change-start=incr     Add <incr> to the start address. Can be specified multiple times, all values will be applied cumulatively.
  --compress-debug-sections=[ zlib | zlib-gnu ]
                          Compress DWARF debug sections using specified style. Supported styles: 'zlib-gnu' and 'zlib'
  --decompress-debug-sections
                          Decompress DWARF debug sections.
  --disable-deterministic-archives
                          Disable deterministic mode when operating on archives (use real values for UIDs, GIDs, and timestamps).
  --discard-all           Remove all local symbols except file and section symbols
  --discard-locals        Remove compiler-generated local symbols, (e.g. symbols starting with .L)
  --dump-section=section=file
                          Dump contents of section named <section> into file <file>
  -D                      Alias for --enable-deterministic-archives
  --enable-deterministic-archives
                          Enable deterministic mode when operating on archives (use zero for UIDs, GIDs, and timestamps).
  --extract-dwo           Remove all sections that are not DWARF .dwo sections from file
  --extract-main-partition
                          Extract main partition from the input file
  --extract-partition=name
                          Extract named partition from input file
  -F <value>              Alias for --target
  --globalize-symbol=symbol
                          Mark <symbol> as global
  --globalize-symbols=filename
                          Reads a list of symbols from <filename> and marks them global.
  -G <value>              Alias for --keep-global-symbol
  -g                      Alias for --strip-debug
  --input-target=<value>  Format of the input file
  -I <value>              Alias for --input-target
  -j <value>              Alias for --only-section
  --keep-file-symbols     Do not remove file symbols
  --keep-global-symbol=symbol
                          Convert all symbols except <symbol> to local. May be repeated to convert all except a set of symbols to local.
  --keep-global-symbols=filename
                          Reads a list of symbols from <filename> and runs as if --keep-global-symbol=<symbol> is set for each one. <filename> contains one symbol per line and may contain comments beginning with '#'. Leading and trailing whitespace is stripped from each line. May be repeated to read symbols from many files.
  --keep-section=section  Keep <section>
  --keep-symbol=symbol    Do not remove symbol <symbol>
  --keep-symbols=filename Reads a list of symbols from <filename> and runs as if --keep-symbol=<symbol> is set for each one. <filename> contains one symbol per line and may contain comments beginning with '#'. Leading and trailing whitespace is stripped from each line. May be repeated to read symbols from many files.
  -K <value>              Alias for --keep-symbol
  --localize-hidden       Mark all symbols that have hidden or internal visibility as local
  --localize-symbol=symbol
                          Mark <symbol> as local
  --localize-symbols=filename
                          Reads a list of symbols from <filename> and marks them local.
  -L <value>              Alias for --localize-symbol
  --new-symbol-visibility=<value>
                          Visibility of symbols generated for binary input or added with --add-symbol unless otherwise specified. The default value is 'default'.
  -N <value>              Alias for --strip-symbol
  --only-keep-debug       Produce a debug file as the output that only preserves contents of sections useful for debugging purposes
  --only-section=section  Remove all but <section>
  --output-target=<value> Format of the output file
  -O <value>              Alias for --output-target
  --prefix-alloc-sections=prefix
                          Add <prefix> to the start of every allocated section name
  --prefix-symbols=prefix Add <prefix> to the start of every symbol name
  --preserve-dates        Preserve access and modification timestamps
  -p                      Alias for --preserve-dates
  --redefine-sym=old=new  Change the name of a symbol old to new
  --redefine-syms=filename
                          Reads a list of symbol pairs from <filename> and runs as if --redefine-sym=<old>=<new> is set for each one. <filename> contains two symbols per line separated with whitespace and may contain comments beginning with '#'. Leading and trailing whitespace is stripped from each line. May be repeated to read symbols from many files.
  --regex                 Permit regular expressions in name comparison
  --remove-section=section
                          Remove <section>
  --rename-section=old=new[,flag1,...]
                          Renames a section from old to new, optionally with specified flags. Flags supported for GNU compatibility: alloc, load, noload, readonly, debug, code, data, rom, share, contents, merge, strings.
  -R <value>              Alias for --remove-section
  --set-section-alignment=section=align
                          Set alignment for a given section.
  --set-section-flags=section=flag1[,flag2,...]
                          Set section flags for a given section. Flags supported for GNU compatibility: alloc, load, noload, readonly, debug, code, data, rom, share, contents, merge, strings.
  --set-start=addr        Set the start address to <addr>. Overrides any previous --change-start or --adjust-start values.
  --split-dwo=dwo-file    Equivalent to extract-dwo on the input file to <dwo-file>, then strip-dwo on the input file
  --strip-all-gnu         Compatible with GNU's --strip-all
  --strip-all             Remove non-allocated sections outside segments. .gnu.warning* and .ARM.attribute sections are not removed
  --strip-debug           Remove all debug sections
  --strip-dwo             Remove all DWARF .dwo sections from file
  --strip-non-alloc       Remove all non-allocated sections outside segments
  --strip-sections        Remove all section headers and all sections not in segments
  --strip-symbol=symbol   Strip <symbol>
  --strip-symbols=filename
                          Reads a list of symbols from <filename> and removes them.
  --strip-unneeded-symbol=symbol
                          Remove symbol <symbol> if it is not needed by relocations
  --strip-unneeded-symbols=filename
                          Reads a list of symbols from <filename> and removes them if they are not needed by relocations
  --strip-unneeded        Remove all symbols not needed by relocations
  -S                      Alias for --strip-all
  --target=<value>        Format of the input and output file
  -U                      Alias for --disable-deterministic-archives
  --version               Print the version and exit.
  -V                      Alias for --version
  --weaken-symbol=symbol  Mark <symbol> as weak
  --weaken-symbols=filename
                          Reads a list of symbols from <filename> and marks them weak.
  --weaken                Mark all global symbols as weak
  --wildcard              Allow wildcard syntax for symbol-related flags. Incompatible with --regex. Allows using '*' to match any number of characters, '?' to match any single character, '' to escape special characters, and '[]' to define character classes. Wildcards beginning with '!' will prevent a match, for example "-N '*' -N '!x'" will strip all symbols except for "x".
  -W <value>              Alias for --weaken-symbol
  -w                      Alias for --wildcard
  -X                      Alias for --discard-locals
  -x                      Alias for --discard-all

Pass @FILE as argument to read options from FILE.

paclient.exe Description

Here is a summary of the functionality of paclient.exe in Embarcadero RAD Studio 13 Architect.

Overview

paclient.exe is the Platform Assistant Client, a crucial component of RAD Studio's multi-device application architecture. Its primary role is to act as a communication bridge or agent between your development PC (the "host") and a remote target machine (the "server"), such as a physical Windows PC, a macOS machine, or a mobile device.

Core Functionality

The main purpose of paclient.exe is to facilitate deployment and debugging on remote systems. When you cannot run your application directly on your development machine (e.g., when targeting a different OS like macOS or a different Windows environment), RAD Studio uses paclient to manage the process.

Here�s a breakdown of its key functions:

Remote Deployment:

When you compile your project for a remote target platform, the IDE automatically transfers the compiled executable, any required resource files, and supporting DLLs to the remote machine.
paclient.exe, running on the remote machine, receives these files and ensures they are placed in the correct directory for execution.

Remote Debugging:

This is its most critical function. paclient.exe enables the full-featured RAD Studio debugger to work across the network.
It launches the remote application, attaches the debugger, and relays information back to the IDE on your development PC. This allows you to:

Set breakpoints.
Inspect variables and the call stack.
Step through code (Step Into, Step Over).
View debug output.

File System and Process Management:

The IDE can interact with the remote machine's file system through paclient (e.g., to list directories, check file existence).
It can also query and manage processes on the remote machine, which is essential for starting and stopping the application being debugged.

Communication Bridge:

paclient.exe runs as a background service or daemon on the remote machine, listening for TCP/IP connections from the RAD Studio IDE.
It uses a defined port (by default, port 64211) to communicate securely with the Platform Assistant Server (PAServer.exe) which is the counterpart that runs on the remote machine.

How It's Used in Practice

You do not typically launch paclient.exe directly. Its operation is managed by the RAD Studio IDE and the Platform Assistant Server (PAServer.exe). Here is the typical workflow:

You install and start the Platform Assistant Server (PAServer.exe) on the remote target machine (e.g., your Mac).
In RAD Studio, you define a connection profile for that remote machine (IP address and password).
When you choose to "Run" or "Debug" your project for that target platform, the IDE handles the entire process:

It compiles the project.
It communicates with PAServer on the remote machine.
PAServer utilizes the local paclient.exe (on the remote machine) to perform the actual tasks of file copying, process creation, and debugger communication.

Key Takeaway

paclient.exe is the workhorse agent on the remote machine that makes cross-platform development and debugging possible in RAD Studio. Without it, you would be unable to deploy, run, or debug your applications on Windows, macOS, or mobile targets directly from the IDE.

paclient.exe Commandline Switches

Platform Assistant Client  Version 37.0.10.2
Copyright (c) 2010-2025 Embarcadero Technologies, Inc.

Usage: paclient [<options>] ProfileName

where <options> include:
  -h<name> or --host=<name>
      Specify the name or IP address of the remote/host machine running the
      Platform Assistant Server
  -p<number> or --port=<number>
      Specify the port the Platform Assistant Server is configured for. Default
      to 64211
  -m<platform> or --platform=<platform>
      Specify the target platform. Possible values are "Win32", "OSX64",
      "Win64", "Win64x"
  -a<file/dir> or --add=<file/dir>
      Add file/dir to the list of items to be cached. You may specify multiple
      file/dir separated with ';'. You may also use this option more than once.
      File/dir can include wildcard characters (e.g. --add=c:\abc\**\*.* where
      ** indicates to include all sub-directories of abc)
  -ai<file/dir> or --addinclude=<file/dir>
      Add include file/dir to the list of items to be cached. You may specify
      multiple file/dir separated with ';'. You may also use this option
      more than once.
      File/dir can include wildcard characters (e.g. --addinclude=c:\abc\**\*.*
      where ** indicates to include all sub-directories of abc)
  -al<file/dir> or --addlibrary=<file/dir>
      Add library file/dir to the list of items to be cached. You may specify
      multiple file/dir separated with ';'. You may also use this option more
      than once.
      File/dir can include wildcard characters (e.g. --addlibrary=c:\abc\**\*.*
      where ** indicates to include all sub-directories of abc)
  -af<dir>[,*] or --addframework=<dir>[,*]
      Add framework files to the list of items to be cached. You may specify
      multiple dir separated with ';'. You may also use this option more than
      once
  -g<file/dir>[,<destdir>] or --get=<file/dir>[,<destdir>]
      Copy file/dir from the remote/host machine running the Platform Assistant
      Server. You may specify multiple file/dir,destdir separated with ';'.
      You may also use this option more than once.
      File/dir can include wildcard characters (e.g. --get=c:\abc\**\*.* where
      ** indicates to include all sub-directories of abc)
  -u<file/dir>[,<destdir>][,<flags>][,<destname>] or
  --put=<file/dir>[,<destdir>][,<flags>][,<destname>]
      Copy file/dir to the remote/host machine running the Platform Assistant
      Server. You may specify multiple file/dir,destdir,flag,destname separated
      with ';'. You may also use this option more than once. Possible flags
      values are "0", "1", "2", "3", "5" where 0 for normal file, 1 for
      runnable file, 2 for archive file, 3 for executable file, and 5 for
      script file.
      File/dir can include wildcard characters (e.g. --put=c:\abc\**\*.* where
      ** indicates to include all sub-directories of abc)
  -U<file>[,<destdir>][,<destname>] or --Put=<file>[,<destdir>][,<destname>]
      Copy file on the remote/host machine running the Platform Assistant
      Server. You may specify multiple file/dir,destdir,destname separated
      with ';'. You may also use this option more than once.
  -r<file/dir> or --remove=<file/dir>
      Remove file/dir from the list of items to be cached locally. You may
      specify multiple file/dir separated with ';'. You may also use this
      option more than once.
      File/dir can include wildcard characters (e.g. --remove=c:\abc\**\*.*
      where ** indicates to include all sub-directories of abc)
  -R<file/dir> or --Remove=<file/dir>
      Remove file/dir from the remote/host machine running the Platform
      Assistant Server. You may specify multiple file/dir separated with ';'.
      You may also use this option more than once.
      File/dir can include wildcard characters (e.g. --Remove=c:\abc\**\*.*
      where ** indicates to include all sub-directories of abc)
  -C<dir>,<listfile> or --Clean=<dir>,<listfile>
      Remove files in directory and all sub-directories of <dir> that are
      not listed in file <listfile> from the remote/host machine running the
      Platform Assistant Server. You may use this option more than once
  -l or --local
      Update and display information about the specified Profile without
      initiating a connection to the Platform Assistant Server
  -s<dir> or --sysroot=<dir>
      Indicate the local directory where the remote files will be cached.
      Default to %USERPROFILE%\Documents\RAD Studio\Profiles\<ProfileName>
  -t<number> or --timeout=<number>
      Specify the timeout in seconds when connecting to the Platform Assistant
      Server. Default to 0 second
  -e<number> or --error=<number>
      Stop copy after n errors. Default to 20 errors
  -k or --keep
      Keep files whose source time is different than the destination time
  -pw<text> or --password=<text>
      Specify the login password for the Platform Assistant Server
  -pk<text> or --passkey=<text>
      Specify the login password (encrypted) for the Platform Assistant Server
  -pf<file> or --passfile=<file>
      Specify the login passfile for the Platform Assistant Server
  -c<path>,<certificate>[,<entitlement>] or
  --codesign=<path>,<certificate>[,<entitlement> [,1]]
      CodeSign application with certificate on the remote machine running the
      Platform Assistant Server. If '1' is specified, application
      notarization options will be applied
  -i<path>,<outpath>,<certificate>,<profile>,<type> or
  --ipa=<path>,<outpath>,<certificate>,<profile>,<type>
      Create application .ipa file with certificate and provisioning profile
      on the remote machine running the Platform Assistant Server. Possible
      type values are "1", "2" where 1 for ad-hoc and 2 for app-store
  -ii<path>,<deviceid> or --installipa=<path>,<deviceid>
      Install .ipa file in the device on the remote machine running the
      Platform Assistant Server
  -pb<path>,<installpath>,<outpath>,<certificate> or
  --productbuild=<path>,<installpath>,<outpath>,<certificate>
      Create application .pkg file with certificate on the remote machine
      running the Platform Assistant Server
  -mm<javapath>,<toolpath>,<manifest>,<outpath>,<androidlibmanifestlistpath>,<compresslibfiles> or
  --manifestmerge=<javapath>,<toolpath>,<manifest>,<outpath>,<androidlibmanifestlistpath>
    ,<compresslibfiles>
      Merge Android manifest files
  -rc<toolpath>,<reslistpath>,<outdir> or
  --rescompile=<toolpath>,<reslistpath>,<outdir>
      Compile Android resource files to .flat ones
  -rp<toolpath>,<compiledresdir>,<compiledreslistpath>,<manifest>,<basepath>,<outpath>
    ,<textsymbolspath>[,<protobufformat>][,<nocompressfileexts>] or
  --respackage=<toolpath>,<compiledresdir>,<compiledreslistpath>,<manifest>,<basepath>
    ,<outpath>,<textsymbolspath>[,<protobufformat>][,<nocompressfileexts>]
      Package compiled Android resource files in a .zip file
  -dc<javapath>,<toolpath>,<path>,<outpath>,<basepath>,<minapilevel>[,<classpathlistpath>]
    [,<globalspath>] or
  --dexcompile=<javapath>,<toolpath>,<path>,<outpath>,<basepath>,<minapilevel>
    [,<classpathlistpath>][,<globalspath>]
     Transform a .jar file into a .dex one
  -dm<javapath>,<toolpath>,<classdir>,<minapilevel>,<dexlistpath>[,<globalslistpath>] or
  --dexmerge=<javapath>,<toolpath>,<classdir>,<minapilevel>,<dexlistpath>[,<globalslistpath>]
     Merge .dex files
  -ap<javapath>,<toolpath>,<packagedrespath>,<srcdir>,<classdir>,<assetdir>,<outpath>
    [,<debug>][,<compressdexfiles>][,<compresslibfiles>][,<nocompressfileexts>][,<pagealign>]
    [,<minapilevel>,<alias>,<keystore>,<storepass>,<keypass>] or
  --apppackage=<javapath>,<toolpath>,<packagedrespath>,<srcdir>,<classdir>,<assetdir>
    ,<outpath>[,<debug>][,<compressdexfiles>][,<compresslibfiles>][,<nocompressfileexts>]
    [,<pagealign>][,<minapilevel>,<alias>,<keystore>,<storepass>,<keypass>]
      Create application .apk file from the specified files
  -bm<javapath>,<toolpath>,<packagedrespath>,<srcdir>,<classdir>,<assetdir>,<outpath> or
  --basemodule=<javapath>,<toolpath>,<packagedrespath>,<srcdir>,<classdir>,<assetdir>,<outpath>
      Create application base module file from the specified files
  -ab<javapath>,<bundletoolpath>,<basemodulepath>,<bundleconfigpath>,<outpath> or
  --appbundle=<javapath>,<bundletoolpath>,<basemodulepath>,<bundleconfigpath>,<outpath>
      Create application .aab file from the specified files
  -j<sdkpath>,<path>,<alias>,<keystore>,[<sign>],[<digest>],<storepass>
    ,<keypass> or
  --jarsign=<sdkpath>,<path>,<alias>,<keystore>,[<sign>],[<digest>],<storepass>
    ,<keypass>
      JarSign application .aab file with the specified keystore
  -as<javapath>,<toolpath>,<path>,<alias>,<keystore>,<storepass>,<keypass> or
  --apksign=<javapath>,<toolpath>,<path>,<alias>,<keystore>,<storepass>,<keypass>
      ApkSign application .apk file with the specified keystore
  -z<sdkpath>,<path>,<outpath>[,<size>] or 
  --zipalign=<sdkpath>,<path>,<outpath>[,<size>]
      Align application with the specified alignment size. Default to 4
  -sd<sdkpath>,<path>[,<outpath>] or --stripdebug=<sdkpath>,<path>[,<outpath>]
      Remove all debugging symbols
  -un<path1>,<path2>,<outpath> or --universal=<path1>,<path2>,<outpath>[,1]
      Create multi architecture file on the remote machine running the
      Platform Assistant Server. If '1' is not specified, <path1> and <path2>
      will be removed
  -u8 or --utf8encode
      Write error and output text in UTF8 format
  -v or --verbose
      Print out the files processed
  -up<makeappxpath>,<package>,<mapfile> or
  --uwppackaging=<makeappxpath>,<package>,<mapfile>
      Create Universal Windows Platform package, .msix file, using files
      listed in the mapfile
  -us<signtoolpath>,<package>,<certificate>,[<password>],<digest>[,<timestamp>] or
  --uwpsigning=<signtoolpath>,<package>,<certificate>,[<password>],<digest>[,<timestamp>]
      Sign Universal Windows Platform package with the specified certificate
  -pp<bundleid>,<certificate>,<profile>,<type> or
  --provisioningprofile=<bundleid>,<certificate>,<profile>,<type>
      Verify if bundleid, certificate and type are valid for the specified
      provisioning profile found on the remote machine running the Platform
      Assistant Server. Possible type values are "1", "2" where 1 for ad-hoc
      and 2 for app-store
  -na<path>,<bundleid>,<username>,<password>,<teamid>[,<options>] or
  --notarizeapp=<path>,<bundleid>,<username>,<password>,<teanid>[,<options>]
      Notarize the application on the remote machine running the Platform
      Assistant Server
  -ni<UUID>,<username>,<password>,<teamid> or
  --notarizationinfo=<UUID>,<username>,<password>,<teamid>
      Get the status of the notarization request on the remote machine
      running the Platform Assistant Server
  -sa<path>,<outpath> or --stapleapp=<path>,<outpath>
      Attach a ticket to the notarized application on the remote machine
      running the Platform Assistant Server
  -ac<path>,<outpath> or --assetcatalog=<path>,<outpath>
      Compile an asset catalog document into Assets.car on the remote
      machine running the Platform Assistant Server
  -sb<path>,<outpath> or --storyboard=<path>,<outpath>
      Compile storyboard document into a file that can be loaded at runtime
      on the remote machine running the Platform Assistant Server
  -? or --help
      Print this help screen

rc.exe Description

RC.EXE - Windows Resource Compiler

Overview

rc.exe is the Microsoft Windows Resource Compiler. This is a standard Windows SDK tool that compiles resource script files (.rc) into binary resource files (.res) that can be linked into Windows executables.

Functionality

The Resource Compiler processes resource definition files containing:

Dialog boxes - UI layout definitions
Menus - Application menu structures
Icons and bitmaps - Image resources
String tables - Localized text strings
Version information - Application metadata
Custom resources - Binary data, manifests, etc.

It converts these human-readable .rc files into binary .res files that the linker incorporates into your final .exe or .dll.

Standalone vs IDE Usage

This is a standalone command-line tool that can be used completely independently of the Delphi IDE.

In Delphi/RAD Studio: The IDE calls rc.exe automatically during the build process when you have resource files in your project
Standalone usage: You can invoke it directly from the command line for custom build scripts, makefiles, or manual resource compilation

Command Line Usage Example:

bash

rc.exe [options] filename.rc

Common options include:

/fo output.res - Specify output file name
/i path - Include directory for header files
/d "Arial" - Define preprocessor symbols
/v - Verbose output

Why It's in RAD Studio

Embarcadero includes rc.exe as part of the toolchain because Windows applications frequently need to compile resources, and having it bundled ensures compatibility and availability without requiring developers to install the full Windows SDK separately.

rc.exe Commandline Switches


Microsoft (R) Windows (R) Resource Compiler Version 6.0.5724.0

Copyright (C) Microsoft Corporation.  All rights reserved.



Usage:  rc [options] .RC input file

Switches:

   /r    Emit .RES file (optional)

   /v    Verbose (print progress messages)

   /d    Define a symbol

   /u    Undefine a symbol

   /fo   Rename .RES file

   /l    Default language ID in hex

   /i    Add a path for INCLUDE searches

   /x    Ignore INCLUDE environment variable

   /c    Define a code page used by NLS conversion

   /w    Warn on Invalid codepage in .rc (default is an error)

   /y    Don't warn if there are duplicate control ID's

   /n    Append null's to all strings in the string tables

   /fm   Localizable resource only dll file name

   /j    Add localizable resource type(s)

   /k    Add resource type(s) to be kept in the language neutral 

         file in addition to adding them to the resource only DLL

         Using the /j switch

   /q    RC Configuration file for the resource only DLL

   /g    Specify the ultimate fallback language ID in hex

   /g1   Specify if version only MUI file can be created

   /g2   Specify the custom file version for checksum in MUI creation

Flags may be either upper or lower case

reFind.exe Description

reFind.exe - Search and Replace Utility

reFind is a command-line utility for search and replacement of Perl RegEx text patterns in text files, using Perl compatible regular expressions (PCRE) for search and replacement patterns Embarcadero.

Functionality:

The utility provides several capabilities:

Text Pattern Matching: Performs search and replace operations using Perl-compatible regular expressions on text files Embarcadero
Database Migration Support: Can process arbitrary text files for replacing occurrences of certain text patterns, like references to units in "uses" clauses and types of components in class declarations Embarcadero. It's particularly useful for:

Migrating BDE applications to FireDAC
Migrating dbExpress applications to FireDAC
Other code modernization tasks

Rule-Based Processing: Can use rule files specified using the /X:<file name> command line parameter, with each line representing a single rule Embarcadero
Specialized Migration Commands: Supports commands like removing specified unit names from interface and implementation sections of "uses" clauses, removing specified property names from PAS and DFM files, and replacing old identifiers with new names Embarcadero

Standalone vs IDE Usage:

reFind.exe is a standalone command-line utility that does NOT require the IDE to be running. It's listed among RAD Studio's command-line utilities that enable you to use the command line to perform targeted operations Embarcadero. You can run it directly from the command prompt - the RAD Studio "bin" directory is on the path, so you can simply type "refind" from the Windows command line Embarcadero.

The tool is completely independent of the IDE and can be used in batch scripts, automation workflows, or any other context where command-line utilities can be executed.

reFind.exe Commandline Switches

RegEx (PCRE) search and replace utility, v 2.10.2
Copyright (c) 2013-2025 Embarcadero Technologies, Inc.

Usage: reFind <filemasks> [/S] [/Y] [/B:0|1|2] [/V:0|1|2] [/C] [/I] [/W] [/L]
              [/P:<searchpattern>] [/R:<replacepattern>] [/X:<rule filename>]

  <filemasks> Specifies the file masks or file names to process.

  /?          Display help.
  /S          Search this directory with all subdirectories.
  /Y          Modify also read-only files.
  /B:0        If .bak file exists, no replace will be performed (default).
  /B:1        If .bak file exists, it is overwritten.
  /B:2        No .bak file is created.
  /V:N        Verbose mode. N=0 - no output, N=1 - normal, N=2 - extended.

  /C          Comment code instead to remove it. Used by #remove rules.

  /I          Ignore case.
  /W          Whole words.
  /L          Multiline ungreedy search.
  /P          Perl RegEx search pattern.
  /R          Perl RegEx replace pattern.
  /X          Specifies rule file with multiple Perl RegEx search and replace patterns or rules.

The rule formats:
  #unuse <unit>                       - removes unit from the PAS uses clause
  #remove [PAS: | DFM:] <property>    - removes property from PAS and DFM/FMX
  #migrate [PAS: | DFM:] [<class>, ... :] [<obj> .] <old> -> <new> [, <unit>]
                                      - replaces old with new identifier,
                                        optionally restricts migration to the specified classes,
                                        or optionally restricts migration to the specified object
                                        optionally adds unit to uses clause,
  #replaceunit <old_unit> -> <new_unit> - Replacing a unit with a new unit in the PAS uses clause
  <searchpattern> -> <replacepattern> - finds searchpattern and replace with replacepattern

rmtdbg290.exe Description

Functionality of rmtdbg290.exe

rmtdbg290.exe is the remote debug server executable provided with Embarcadero RAD Studio 13 (and earlier versions like Athens/23.0), specifically for old-style remote debugging of Delphi and C++Builder applications targeting 32-bit Windows platforms. Its primary purpose is to enable developers to debug applications running on a remote machine (e.g., a test server or another PC) from the RAD Studio IDE (Delphi or C++Builder) installed on a local development machine. This is particularly useful for scenarios where the application behaves differently in a remote environment, such as due to network configurations, hardware differences, or production-like setups.

Key Features and Workflow:

Server Role: Once started on the remote machine, it acts as a TCP/IP listener (default port: 64447) that accepts connections from the IDE. It handles the transfer of debugging data, including control over breakpoints, stepping through code, variable inspection, and stack traces. During a session, it also manages dynamic ports for each debugged application.
File Dependencies: Before debugging, you must copy the application's executable (.exe), libraries (.dll), debug symbols (e.g., .rsm for Delphi or .tds for C++Builder), and any data files to the remote machine. Source code remains on the local machine in the IDE.
Security Note: Connections are unencrypted and unauthenticated, so it's recommended only for trusted networks; firewalls must allow the listening port and dynamic ports.
Limitations: This is the legacy ("old-style") remote debugging method. Newer RAD Studio features use the integrated Deployment Manager and Platform Assistant for multi-device debugging, which may not rely on this executable.

Installation and Usage:

It's typically installed in the RAD Studio bin directory (e.g., C:\Program Files (x86)\Embarcadero\Studio\23.0\bin).
If RAD Studio is fully installed on the remote machine, it's already available; otherwise, copy it manually from the local install, along with supporting files like bordbk290.dll (which requires registration via regsvr32.exe for full functionality).
Supporting tools like the Platform Assistant Server (PAServer) can automate deployment and integration.

Standalone Use vs. IDE Dependency

rmtdbg290.exe can be run as a standalone application on the remote machine without the RAD Studio IDE present on that same system. To start it:

Open a command prompt on the remote machine.
Run: rmtdbg290.exe -listen [hostname:]port (e.g., rmtdbg290.exe -listen 8000 to listen on port 8000, or omit for default port 64447).
It will run as a background process, displaying an "Embarcadero Remote Debugger Listener" icon in the Windows taskbar to confirm it's active.

To stop it, right-click the taskbar icon and select Exit (this won't interrupt active sessions).

However, while it operates independently as a server process, its core functionality is tightly integrated with the RAD Studio IDE�it doesn't provide a user interface or debugging tools on its own. You need the IDE on the local machine to:

Connect to the server (via the "Remote Machine" field in debug dialogs).
Initiate sessions (e.g., "Attach to Process" or "Load Process Remote").
Perform actual debugging actions.

In summary, it's not "strictly used by the IDE" in terms of execution (it runs standalone on the remote side), but it serves no practical purpose without IDE interaction for debugging. If you're not doing remote debugging, this executable isn't needed for local development. For modern workflows, consider the Platform Assistant instead.

RSConsole.exe Description

RSConsole.exe � Overview and Functionality

What It Is:
RSConsole.exe is a command-line (console) application included with Embarcadero RAD Studio 13 Architect. It serves as a headless build and automation utility that allows developers to compile, build, and manage Delphi and C++Builder projects without launching the full IDE.

Primary Functionality:

Command-Line Compilation: Compiles Delphi (.dproj) and C++Builder projects using MSBuild-compatible syntax.
Project "Arial"mation: Enables scripting of build processes, integration into CI/CD pipelines (e.g., Jenkins, GitHub Actions), or batch processing of multiple projects.
IDE-Independent Builds: Runs independently of the RAD Studio IDE�no GUI is required, making it suitable for server environments or automated build machines.
Supports Build Configurations: Can target specific platforms (Windows, macOS, iOS, Android, Linux), configurations (Debug/Release), and build types (Build, Rebuild, Clean).
Environment Setup: Automatically initializes the necessary environment variables (e.g., BCC, DCC paths, library paths) required for compilation, similar to what the IDE does internally.

Standalone Use:
Yes, RSConsole.exe is designed to be used as a standalone application. While it is part of the RAD Studio installation and shares core build tooling with the IDE (such as the compiler and linker), it does not require the Delphi or C++Builder IDE to be running. In fact, it is commonly used in:

Automated build servers
Nightly build scripts
Headless development containers or VMs
Custom deployment workflows

Typical Usage Example:

cmd

RSConsole.exe -r -p=Win64 -c=Release MyProject.dproj

This would rebuild the MyProject.dproj for the Win64 platform in Release configuration.

Relationship to MSBuild:
Internally, RSConsole.exe acts as a wrapper around the MSBuild engine customized for Embarcadero projects. It ensures the correct toolchain and environment are loaded before invoking MSBuild.

Conclusion:
RSConsole.exe is not strictly limited to IDE use�it is a powerful standalone utility for automating builds and integrating RAD Studio projects into modern development workflows outside the graphical IDE.

scktsrvr.exe Description

Purpose and Functionality

scktsrvr.exe acts as a socket-based middleware server that enables remote communication between a DataSnap client and a DataSnap application server.

In traditional 3-tier Delphi applications:

The client application requests data or executes methods.
The application server (AppServer) performs the business logic and data access.
The Socket Server (scktsrvr) manages network communication between clients and servers over TCP/IP.

It is part of the DataSnap transport layer and is responsible for:

Accepting incoming client socket connections.
Routing those requests to the appropriate AppServer instance (usually a DLL, EXE, or COM object).
Managing multiple clients concurrently.
Providing monitoring and configuration through its user interface.

⚙️ Key Features

Connection Broker: Manages socket-based connections between clients and AppServers.
Service Mode: Can run as a Windows Service for unattended operation.
GUI Mode: Can run interactively with a management interface to view connected clients and server status.
Port Configuration: Default TCP port is 211, but this can be changed.
Logging and Status Monitoring: Displays real-time connection activity.

🧭 Usage Context

It was widely used with Delphi�s MIDAS / DataSnap remote data modules (especially in Delphi 5�XE7 era).
Still supported for legacy DataSnap applications using socket transport (though newer versions often use HTTP or REST transport instead).

🧰 Standalone vs. IDE Usage

✅ Can be used as a standalone application.
You can launch scktsrvr.exe manually or install it as a Windows Service to handle socket connections independently of the Delphi IDE.
⚙️ Not required by the Delphi IDE itself.
The Delphi IDE does not depend on it internally � it�s a runtime support tool for certain types of deployed client/server applications.

🚀 Typical Deployment Scenario

You build a DataSnap server (e.g., MyServer.exe or MyServer.dll).
You deploy it to a machine running scktsrvr.exe.
Clients connect using the TClientDataSet or TDataSetProvider components configured with a TSocketConnection pointing to the socket server�s host and port.
The socket server handles connection multiplexing and passes the calls to the AppServer.

🧾 Command-Line Options

scktsrvr.exe supports a few command-line switches, though most configuration is done via its GUI or registry:

/install � installs it as a Windows service.
/uninstall � removes it as a Windows service.
/start � starts the service (if installed).
/stop � stops the service (if installed).
/port=<n> � optional, specifies the listening TCP port.

Example:

scktsrvr.exe /install /port=211

✅ Summary

Aspect	Description
Executable	scktsrvr.exe
Purpose	DataSnap/MIDAS Socket Server for client/server communication
Standalone Use	Yes � can run independently or as a Windows service
Used by IDE	No � it�s an auxiliary runtime tool
Typical Port	211 (configurable)
Modern Equivalent	HTTP/REST-based DataSnap servers (no socket server needed)

SdkTransform.exe Description

What is SdkTransform.exe

The tool is described in Embarcadero documentation/blog posts as the �SDK Transform� tool (sometimes written as SdkTransform). One blog article explains:

�The SdkTransform tool generates Object Pascal header files for iOS and OSX frameworks (including third‑party frameworks). The tool is command‑line based and ships with Delphi.� blogs.embarcadero.com

In effect, the purpose of SdkTransform is to take native frameworks (in particular for Apple platforms: iOS/macOS) � including their Objective‑C headers and perhaps the associated SDKs � and produce Delphi (Object Pascal) translation units / header‑units so that those native frameworks can be used from Delphi or C++Builder code.
This means it works in the context of multi‑device development: when targeting iOS or macOS (or possibly other platforms via native frameworks) from Delphi/C++Builder, you often need Pascal units that map the native APIs. SdkTransform is a tool that automates that translation, rather than you having to hand‑write units for each Objective‑C header or framework.
The blog post gives a sample of the command line it uses, for example:

� SdkTransform.exe %s --fmt %s�

and shows how it uses clang etc. blogs.embarcadero.com

Further, another Embarcadero GitHub repository (the �octoid� project) mentions:

�Octoid is � intended as a replacement for SDKTransform which ships with Delphi.� GitHub
This confirms that SdkTransform is (or was) Embarcadero�s built‑in tool for Objective‑C header → Delphi unit conversion.

Key functionalities of SdkTransform.exe

From the above and related documentation, here are its main features:

It runs from the command line (i.e., a console tool) rather than purely as a GUI plugin of the IDE.
It accepts native platform SDK framework headers (especially iOS/macOS frameworks) as input.
It uses Clang / Obj‑C parsing to process headers, include‑paths, frameworks, etc. (see blog excerpt: using -cc1, -x objective‑c, etc.) blogs.embarcadero.com
It outputs Delphi (Object Pascal) units that expose the native APIs (classes, functions, types) so that you can call them from Delphi or C++Builder.
It is used in the workflow of the SDK Manager (within the IDE) for mobile / cross‑platform development: when you add a new SDK/platform/framework, SdkTransform helps create the �bridge� units.
It supports third‑party frameworks (not just the built‑in ones) � the blog says you can point it at a downloaded framework folder and it will generate Pascal units for it. blogs.embarcadero.com

Is it strictly used by the IDE, or usable standalone?

Based on what we can see:

The fact that it is a command‑line tool means inherently it can be used outside the IDE. It�s not purely a black‑box internal component hidden behind the IDE menus; you could open a console and run SdkTransform.exe with appropriate parameters (assuming you know them).
The blog article says: �The tool is command line based and ships with Delphi.� blogs.embarcadero.com
Also the mention of �SDK Transform Assistant� (a GUI front‑end around SdkTransform) indicates that SdkTransform itself is the underlying engine, and there are UI helpers built on top. This suggests you could script it outside the IDE.
However: While you can theoretically run it standalone, in practical usage it is integrated into the IDE workflow (via the SDK Manager) and the paths/SDK setups are done via the IDE settings (e.g., Tools → Options → SDK Manager). So the tool expects the SDK environment (frameworks, include paths, Clang, etc) in a form the IDE recognises. The blog says you must �add the iOS and OSX frameworks that you want generated to the Delphi SDK Manager� before SdkTransform will pick them up. blogs.embarcadero.com
Therefore, while it is not strictly forced to be invoked via the IDE, for most developers the easiest path is through the IDE. The tool may not be documented well for general public use outside of the IDE, and you may need to supply many parameters manually.

My conclusion for your scenario (RAD Studio 13 Architect)

Given you have RAD Studio 13 Architect:

Yes � you should find SdkTransform.exe in the bin directory (or in the PlatformSDKs folder) as part of the install for mobile/cross‑platform development.
Its intended purpose is exactly as above: to translate native (Objective‑C) framework headers for iOS/macOS into Delphi units, facilitating mobile cross‑platform development from Delphi/C++Builder.
In your RAD Studio installation, it is tightly associated with the multi‑device target platforms (iOS, macOS) rather than purely the Windows desktop scenario.
You can use it as a standalone command‑line tool (outside the IDE) if you know how to specify the parameters, framework paths, etc. But you may not have full documentation or built‑in UI outside the IDE to help.
For most typical workflows, you will use the IDE�s SDK Manager (Tools → Options → Deployment → SDK Manager) to manage SDKs and have the IDE invoke SdkTransform when needed (for example when you �Add� or �Update� an iOS/macOS SDK). Embarcadero DocWiki+1
If you intend to run it manually (for automation, custom processes, or part of a build script), you will want to check what parameters SdkTransform accepts (input paths, output format, include paths, target platform) and replicate what the IDE is doing.

Things to check / tips if you want to use it manually

Locate where SdkTransform.exe lives in your install�likely in something like C:\Program Files (x86)\Embarcadero\Studio\23.0\bin\� (for RAD Studio 13) or within the PlatformSDKs folder.
Check for any accompanying documentation or .txt file such as SdkTransformTypes.txt (mentioned in the blog post). blogs.embarcadero.com
Verify that the required frameworks (iOS/macOS) and their header files are present and recognized by the IDE (via SDK Manager). If you point SdkTransform at a third‑party framework, ensure the framework is placed in the correct folder (for example under Users\<you>\Documents\Embarcadero\Studio\SDKs\�). blogs.embarcadero.com
Understand the output: the generated Delphi units need to be added to your project or library path so that your Delphi/C++ code can reference the translated API.
If you run in a build/CI scenario, you might script SdkTransform.exe to run ahead of the build to regenerate translations when native frameworks change.
Because Embarcadero is now promoting their newer tool Octoid (open source) as a more advanced replacement for SdkTransform, you may want to compare their capabilities (especially if you have complex or non‑standard frameworks). GitHub

SdkTransform.exe Commandline Switches

Usage: SdkTransform [cmds] [options]

Options:
--out:<output_dir> - directory where the output .pas files should be placed.
--task:<xml file> - file with descrption of the task.
--unit:<Unit name> - transform only framework with the specified name.
--fmt - perform formatting of the output files after translation.
--comments - copy the block comments from Obj-C code to the output Delphi files

tasm32.exe Description

TASM32.exe - Turbo Assembler (32-bit)

Description

TASM32.exe is the 32-bit version of Borland's Turbo Assembler, a command-line assembly language compiler. It translates x86 assembly language source code (.asm files) into object files (.obj) that can then be linked into executable programs.

Key Functionality

Assembly Language Compilation: Converts human-readable assembly code into machine code object files
Multiple Syntax Modes: Supports both MASM (Microsoft Macro Assembler) and Ideal syntax modes
Macro Processing: Handles complex macro definitions and expansions
Symbol Management: Creates symbol tables and cross-reference listings
Debug Information: Can generate debugging information for use with debuggers
Object File Generation: Produces industry-standard OMF (Object Module Format) or COFF object files

Standalone vs IDE Usage

TASM32.exe is fully functional as a standalone command-line tool and does not require the Delphi IDE to operate. You can use it independently by:

Running it directly from the command prompt
Integrating it into custom build scripts or makefiles
Calling it from batch files or other automation tools

Typical Command-Line Usage:

tasm32.exe /ml /zi myfile.asm

While the Delphi IDE may invoke TASM32 behind the scenes when compiling projects that include assembly language modules or inline assembly optimization, the assembler itself is a standalone utility that predates modern RAD Studio and has been part of Borland's toolchain since the DOS era.

This makes it valuable for low-level programming, operating system development, or any situation where you need direct control over x86 machine code generation outside of the IDE environment.

tasm32.exe Commandline Switches

Turbo Assembler  Version 5.4  Copyright (c) 1988, 2010 Embarcadero Technologies, Inc.
Syntax:  TASM [options] source [,object] [,listing] [,xref]
/a,/s          Alphabetic or Source-code segment ordering
/c             Generate cross-reference in listing
/dSYM[=VAL]    Define symbol SYM = 0, or = value VAL
/e,/r          Emulated or Real floating-point instructions
/h,/?          Display this help screen
/iPATH         Search PATH for include files
/jCMD          Jam in an assembler directive CMD (eg. /jIDEAL)
/kh#           Hash table capacity # symbols
/l,/la         Generate listing: l=normal listing, la=expanded listing
/ml,/mx,/mu    Case sensitivity on symbols: ml=all, mx=globals, mu=none
/mv#           Set maximum valid length for symbols
/m#            Allow # multiple passes to resolve forward references
/n             Suppress symbol tables in listing
/os,/o,/op,/oi Object code: standard, standard w/overlays, Phar Lap, IBM
/p             Check for code segment overrides in protected mode
/q             Suppress OBJ records not needed for linking
/t             Suppress messages if successful assembly
/uxxxx         Set version emulation, version xxxx
/w0,/w1,/w2    Set warning level: w0=none, w1=w2=warnings on
/w-xxx,/w+xxx  Disable (-) or enable (+) warning xxx
/x             Include false conditionals in listing
/z             Display source line with error message
/zi,/zd,/zn    Debug info: zi=full, zd=line numbers only, zn=none

tdstrp32.exe Description

tdstrp32.exe - Turbo Debugger 32-bit Symbol Table Stripper

Functionality:

tdstrp32.exe is a utility that removes debug information from compiled binary files (executables and DLLs) and saves it to separate .tds (Turbo Debugger Symbol) files SmartBearSmartBear. This process is commonly called "stripping" debug symbols.

Key purposes:

Reduces file size - Extracting debug information into separate .tds files significantly decreases the size of your final executable/DLL, which is important for release builds
Maintains debugging capability - The .tds files can still be used for debugging when needed, as long as they're kept in the same directory as the executable
Processes TD32 debug format - Works with the TD32 debug information format generated by the Delphi/C++Builder compilers

Standalone vs. IDE Usage:

Yes, tdstrp32.exe can be used as a standalone application. However, it can only process one file at a time SmartBear, which makes it less convenient for batch processing compared to alternatives like TestComplete's StripTDS utility that support file masks and recursive processing.

You can run it from the command line to strip debug information from any individual executable or DLL that was compiled with TD32 debug information embedded.

Typical usage scenario:

Compile your application with debug information enabled (TD32 format)
Run tdstrp32.exe on the compiled executable/DLL
The tool extracts debug symbols into a .tds file and removes them from the original binary

This utility has been included with RAD Studio (and its predecessors) for many versions and continues to be part of RAD Studio 13 Architect.

tdstrp32.exe Commandline Switches

Turbo Debugger 32-bit Symbol Table Stripper V5.0 (c) 1988,96 Borland Intl

Syntax: TDSTRP32 [options] exefile [outfile]

  -s    Symbol table is put in a file with the same name as
        exefile but with an extension of .tds.  If you specify an
        outfile, a symbol table will be put in outfile.

        If you don't specify the -s option, the symbol table is
        removed from the exefile.  If you specify an outfile, the
        original exefile is left unchanged and a version with no
        symbol table is put in outfile.
If you don't supply an extension with exefile, .exe is presumed.
If you don't supply an extension with outfile, .exe is added when
you don't use -s, and .tds is added when you do use -s.

Turbo Debugger will look for the symbol file when it loads an
exefile that does not have a symbol table.

tdump.exe Description

TDUMP.EXE - Turbo Dump Utility

Overview

TDUMP.EXE is a command-line utility for examining and displaying detailed information about executable files and object files. It's a diagnostic and reverse-engineering tool that has been part of Borland/Embarcadero development tools for decades.

Primary Functionality

TDUMP analyzes and displays the internal structure of:

Executable files (.EXE, .DLL)
Object files (.OBJ)
Library files (.LIB)
Resource files (.RES)

The tool extracts and displays:

File headers (DOS, PE, NE headers)
Section information (code, data, resources)
Import/Export tables (DLL dependencies and exported functions)
Symbol tables and debugging information
Resource data
Relocation information
Segment and fixup details

Standalone vs. IDE Usage

TDUMP is a standalone command-line application that:

Does NOT require the IDE to be running
Can be executed directly from the command prompt
Works independently of RAD Studio
Can be integrated into build scripts, batch files, or other automation tools

Typical Use Cases

Debugging: Examining why a DLL won't load or checking dependencies
Reverse Engineering: Analyzing binary structure of executables
Build Verification: Confirming proper linking and exports
Documentation: Extracting API information from compiled libraries
Troubleshooting: Investigating version mismatches or compatibility issues

Command-Line Usage

Typically invoked as:

tdump [options] filename

Common options include flags to show specific sections like exports (-ee), imports (-ei), headers (-h), etc.

In summary: TDUMP is a powerful standalone binary analysis tool that doesn't depend on the IDE at all�it's a utility you can use independently for examining compiled binaries.

tdump.exe Commandline Switches

Turbo Dump  Version 6.6.2.0 Copyright (c) 1988-2022 Embarcadero Technologies, Inc.
Syntax:   TDUMP [options] InputFile [ListFile] [options]

TDUMP can read its input from stdin by redirecting or piping.
TDUMP recognizes the following file types & information:
DOS Executable files, New Executable files, OS/2 Linear eXecutable files,
PE files (.EXE/.DLL/.BPL), OMF files (.OBJ & .LIB), Delphi Unit files (.DCU),
ELF files, AR files (.AR), 
Borland (Giant) & Microsoft symbolic debug information

  -?      This help screen
  -q      Suppress copyright message
  -a      Display file in 8-bit ASCII
  -a7     Display file in 7-Bit ASCII
  -h[O=x] Display file in hexadecimal. Options can be:
              r     - Print offsets relative to starting offset
              a     - Print absolute offsets
              =x    - Beginning file offset (same as -b#)
  -v      (OMF and COFF only) Verbose dump of some records
  -r      (OMF only) Raw dump of records
  -m      Disable C++ de-mangling
  -um     Display unmangled names for mangled names found in input file (1 per line)
  -ua     (OMF only) Un-assemble to asm source
  -w      Allow wildcard file specs
  -wq[#]  Wildcard quiet switch (# is width)
  -iID    (not Elf) Include debug table(s) "ID" (ID=[?/abc...rst])
  -xID    (not Elf) Exclude debug table(s) "ID" (ID=[?/abc...rst])
  -e      Display file as Executable (EXE/DLL)
  -ed     Disable EXE debug info
  -el     Disable EXE line numbers
  -ep     (PE only) Disable EXE PE header display
  -ex     (NE only) Disable New Executable display
  -ee[=x] (PE only) List Exports only from EXE/DLL (opt. x lists matches only)
  -def    Generate DEF file for EXE/DLL
  -eiID   (PE only) Include only .EXE table ID (HDR, OBJ, FIX, NAM, ENT)
  -er     Disable EXE relocation records
  -eh     (Elf only) Disable EXE headers display
  -et     (Elf only) Disable EXE symbol tables
  -es[=x] (Elf only) Hex dump of program sections [or of section 'x']
  -em[=x] (PE only) List Imports only from EXE/DLL (x lists matches only)
  -em.x   (PE only) List Imported modules only from EXE/DLL (x specifies search string)
  -ea[:v] (PE only) Display All Exports unsorted, or (:v) sort by RVA
                    (default dumps only named exports, sorting on the name)
  -R      (PE only) Display relocation table
  -s[xx]  Display viewable strings. Optional xx can be:
              #     - minimum string length to look for (default: 4)
              b#    - Beginning file offset (-b# is the same as -sb#) 
              e#    - Ending file offset
              f     - Format (wrap) long strings
              s     - Search string with case sensitivity (default: no)
              u     - unix format: no offset (else decimal offs., -h for hex)
              =x    - x = search string
  -b#     Offset into file for display (prefix hex with '0x')
  -t#     (Elf only) Ending file offset for display (prefix hex with '0x')
  -o      Display file as an Object
  -d      (OMF only) Display 32-bit debug info in OBJ or LIB
  -oiID[=x]
          (OMF only) Include record "ID" (ID=? for a list of record names)
  -oxID[=x]
          (OMF only) Exclude record "ID" (ID=? for a list of record names)
  -oc     (OMF only) Do CRC check
  -l      (OMF LIB only) Display file as an OMF Library (.LIB)
  -li[=x] (OMF LIB only) Display IMPDEF comment records (x lists matches only)
  -le[=x] (OMF LIB only) Display EXPDEF comment records (x lists matches only)
  -lm[=x] (ELF LIB only) Display dump of members (x lists matches only)
  -lh     (ELF LIB only) Display list of members in archive
  -lt     (ELF LIB only) Display exported symbols in archive
  -C      (COFF only) Display COFF OBJ or LIB file
  -M      (MACH only) Display MACH file
  -ns     Disable support for redirecting stdin

tdump64.exe Description

🔬 TDUMP64.EXE: The 64-bit File Dumping Utility

TDUMP64.EXE is the 64-bit Windows file dumping utility included with Embarcadero RAD Studio (Delphi and C++Builder).

Its primary functionality is to produce a file dump that reveals the structure and contents of a file. It's essentially a command-line tool for inspecting the internal structure of various file formats.

Key Functionality:

It breaks apart a file structurally to show its internal layout.
It uses the file's extension to determine the output display format, recognizing formats like .EXE, .OBJ, and .LIB files (specifically the 64-bit versions for TDUMP64.EXE which include 64-bit Windows executables (.exe) and 64-bit ELF-format object (.o) and library (.a) files).
If the file extension is not recognized, it provides a simple hexadecimal dump.
It can be used to test file integrity by verifying that a file's structure matches its expected extension.
It offers various command-line options to control the output format, such as displaying specific sections, debug information, exports, imports, and more.

💻 Standalone vs. IDE Use

TDUMP64.EXE can be used as a standalone command-line application.

It is one of the many Command-Line Utilities provided with RAD Studio. While its original intent is to assist developers working with the Delphi or C++Builder toolchains (which are part of the RAD Studio IDE), it is not strictly tied to the IDE itself.

You can execute TDUMP64.EXE from the Windows Command Prompt or PowerShell (provided the bin directory is in your system's PATH or you navigate to it) to dump information from any supported 64-bit executable or object/library file.

tdump64.exe Commandline Switches

Turbo Dump  Version 6.6.2.0 Copyright (c) 1988-2022 Embarcadero Technologies, Inc.
Syntax:   TDUMP [options] InputFile [ListFile] [options]

TDUMP can read its input from stdin by redirecting or piping.
TDUMP recognizes the following file types & information:
DOS Executable files, New Executable files, OS/2 Linear eXecutable files,
PE files (.EXE/.DLL/.BPL), OMF files (.OBJ & .LIB), Delphi Unit files (.DCU),
ELF files, AR files (.AR), 
Borland (Giant) & Microsoft symbolic debug information

  -?      This help screen
  -q      Suppress copyright message
  -a      Display file in 8-bit ASCII
  -a7     Display file in 7-Bit ASCII
  -h[O=x] Display file in hexadecimal. Options can be:
              r     - Print offsets relative to starting offset
              a     - Print absolute offsets
              =x    - Beginning file offset (same as -b#)
  -v      (OMF and COFF only) Verbose dump of some records
  -r      (OMF only) Raw dump of records
  -m      Disable C++ de-mangling
  -um     Display unmangled names for mangled names found in input file (1 per line)
  -ua     (OMF only) Un-assemble to asm source
  -w      Allow wildcard file specs
  -wq[#]  Wildcard quiet switch (# is width)
  -iID    (not Elf) Include debug table(s) "ID" (ID=[?/abc...rst])
  -xID    (not Elf) Exclude debug table(s) "ID" (ID=[?/abc...rst])
  -e      Display file as Executable (EXE/DLL)
  -ed     Disable EXE debug info
  -el     Disable EXE line numbers
  -ep     (PE only) Disable EXE PE header display
  -ex     (NE only) Disable New Executable display
  -ee[=x] (PE only) List Exports only from EXE/DLL (opt. x lists matches only)
  -def    Generate DEF file for EXE/DLL
  -eiID   (PE only) Include only .EXE table ID (HDR, OBJ, FIX, NAM, ENT)
  -er     Disable EXE relocation records
  -eh     (Elf only) Disable EXE headers display
  -et     (Elf only) Disable EXE symbol tables
  -es[=x] (Elf only) Hex dump of program sections [or of section 'x']
  -em[=x] (PE only) List Imports only from EXE/DLL (x lists matches only)
  -em.x   (PE only) List Imported modules only from EXE/DLL (x specifies search string)
  -ea[:v] (PE only) Display All Exports unsorted, or (:v) sort by RVA
                    (default dumps only named exports, sorting on the name)
  -R      (PE only) Display relocation table
  -s[xx]  Display viewable strings. Optional xx can be:
              #     - minimum string length to look for (default: 4)
              b#    - Beginning file offset (-b# is the same as -sb#) 
              e#    - Ending file offset
              f     - Format (wrap) long strings
              s     - Search string with case sensitivity (default: no)
              u     - unix format: no offset (else decimal offs., -h for hex)
              =x    - x = search string
  -b#     Offset into file for display (prefix hex with '0x')
  -t#     (Elf only) Ending file offset for display (prefix hex with '0x')
  -o      Display file as an Object
  -d      (OMF only) Display 32-bit debug info in OBJ or LIB
  -oiID[=x]
          (OMF only) Include record "ID" (ID=? for a list of record names)
  -oxID[=x]
          (OMF only) Exclude record "ID" (ID=? for a list of record names)
  -oc     (OMF only) Do CRC check
  -l      (OMF LIB only) Display file as an OMF Library (.LIB)
  -li[=x] (OMF LIB only) Display IMPDEF comment records (x lists matches only)
  -le[=x] (OMF LIB only) Display EXPDEF comment records (x lists matches only)
  -lm[=x] (ELF LIB only) Display dump of members (x lists matches only)
  -lh     (ELF LIB only) Display list of members in archive
  -lt     (ELF LIB only) Display exported symbols in archive
  -C      (COFF only) Display COFF OBJ or LIB file
  -M      (MACH only) Display MACH file
  -ns     Disable support for redirecting stdin

tlib.exe Description

TLIB.EXE - Turbo Librarian

TLIB.EXE is the Turbo Librarian utility, a command-line tool for managing static library files (.LIB) in Embarcadero RAD Studio.

Primary Functionality

TLIB is used to create, modify, and maintain object module libraries (.LIB files). Its main operations include:

Creating new library files from object (.OBJ) files
Adding modules to existing libraries
Removing modules from libraries
Extracting modules from libraries
Replacing modules in libraries
Listing library contents to see what modules are included
Creating extended dictionaries for faster linking

Standalone vs IDE Usage

TLIB is a fully standalone command-line application that can be used independently of the Delphi IDE. While the IDE may invoke it internally during the build process when working with static libraries, you can use it directly from:

Command prompt/terminal
Batch files or build scripts
Makefiles
Any automated build system

Typical Usage

The basic syntax is:

tlib libraryname [/C] [/E] [operations] [, listfile]

Common operations include:

+filename - Add a module
-filename - Remove a module
*filename - Extract a module
-+filename - Replace a module (remove then add)

Use Cases

TLIB is particularly useful when you need to:

Manually manage third-party static libraries
Create custom library collections from compiled object files
Integrate with custom build systems outside the IDE
Troubleshoot or inspect library contents
Maintain legacy code that uses static libraries

This is a classic utility that has been part of Borland/Embarcadero development tools for decades, originating from the Turbo C/C++ era.

tlib.exe Commandline Switches

TLIB 7.1 Copyright (c) 1987-2019 Embarcadero Technologies, Inc.
Syntax: TLIB options libname [commands | files], listfile
    libname     library file pathname
    commands    sequence of operations to be performed (optional)
    listfile    file name for listing file (optional)

A command is of the form: <symbol>module, where <symbol> is:
    +           add module to the library
    -           delete module from the library
    *           extract module without removing it
    -+ or +-    update module in library
    -* or *-    extract module and remove it

Set the default action for modules without a specified command:
    /a          add module to the library
    /d          delete module from library
    /e          extract module without removal
    /u          update module in library
    /x          extract module and remove it from library

    /N          disable support of command syntax
    /O          enable support of command syntax
    /L          write listfile to stdout
    /C          case-sensitive library
    /PSIZE      set the library page size to SIZE
    /0          purge comment records
    /A          write GNU AR format archive with ELF objs
    /B          bare response files (newline terminated)
    /F          force new library
    /8          output encoding is utf-8

Use @filepath to continue from file "filepath".
Use '&' at end of a line to continue onto the next line.

tlib64.exe Description

tlib64.exe � Summary and Functionality

tlib64.exe is a command-line utility that ships with Embarcadero RAD Studio (including Delphi and C++Builder). It is the 64-bit version of the Type Library Importer tool.

Primary Purpose:

tlib64.exe imports COM (Component Object Model) type libraries (typically .tlb files or type libraries embedded in .dll, .ocx, or .exe files) and generates Delphi or C++ header files that allow RAD Studio projects to interact with COM objects.

Key Functions:

Generates Delphi interface units (.pas files) or C++ header files from COM type libraries.
Translates COM interfaces, coclasses, enums, and other type definitions into native Delphi or C++ code.
Supports both 32-bit and 64-bit COM type libraries (though tlib64.exe itself is the 64-bit host process).
Handles automation-compatible type libraries used by ActiveX controls, Office add-ins, Windows APIs exposed via COM, etc.

Usage Context:

Integrated Use: The Delphi/C++Builder IDE invokes tlib64.exe internally when you use the "Import Type Library" wizard (via Component > Import Component > Import a Type Library). In this context, it runs behind the scenes to produce the necessary wrapper code.
Standalone Use: Yes, tlib64.exe can be used directly from the command line or in build scripts. It accepts various command-line parameters to control output language (Delphi vs. C++), file naming, namespace options, and more.

Example Command-Line Use:

cmd

tlib64.exe -P "C:\Path\To\MyLibrary.tlb"

This would generate a Delphi unit (MyLibrary_TLB.pas) from the specified type library.

Notes:

There is also a 32-bit counterpart (tlib32.exe) for compatibility with 32-bit type libraries or environments.
While primarily designed for use within the RAD Studio ecosystem, it is a fully functional standalone tool and does not require the IDE to be running.

Conclusion:

tlib64.exe is not strictly limited to IDE use�it is a standalone command-line utility that can be used independently for automation, scripting, or custom build processes, though it is most commonly encountered through the IDE�s type library import wizard.

tlib64.exe Commandline Switches

TLIB64 7.0 Copyright (c) 1987-2019 Embarcadero Technologies, Inc.
Syntax: TLIB options libname [commands | files], listfile
    libname     library file pathname
    commands    sequence of operations to be performed (optional)
    listfile    file name for listing file (optional)

A command is of the form: <symbol>module, where <symbol> is:
    +           add module to the library
    -           delete module from the library
    *           extract module without removing it
    -+ or +-    update module in library
    -* or *-    extract module and remove it

Set the default action for modules without a specified command:
    /a          add module to the library
    /d          delete module from library
    /e          extract module without removal
    /u          update module in library
    /x          extract module and remove it from library

    /N          disable support of command syntax
    /O          enable support of command syntax
    /L          write listfile to stdout
    /C          case-sensitive library
    /PSIZE      set the library page size to SIZE
    /0          purge comment records
    /A          write GNU AR format archive with ELF objs
    /B          bare response files (newline terminated)
    /F          force new library
    /8          output encoding is utf-8

Use @filepath to continue from file "filepath".
Use '&' at end of a line to continue onto the next line.

tlibimp.exe Description

💻 tlibimp.exe Functionality Summary

The tlibimp.exe utility in Embarcadero RAD Studio, which includes Delphi and C++Builder, is the Type Library Import tool.

Primary Function: It reads an existing COM (Component Object Model) Type Library (typically a .tlb file, or embedded within a .dll, .ocx, or .exe) and generates equivalent Delphi Interface files (usually named _TLB.pas files).
Purpose: This process allows Delphi or C++Builder applications to easily interact with the COM objects defined in the type library. The generated files contain the necessary declarations for the COM classes, types, and interfaces, enabling early binding and simplified calling of the object's methods and properties.

🛠️ Usage

tlibimp.exe can be used both by the IDE and as a standalone command-line application.

1. Used by the Delphi IDE

The functionality of tlibimp.exe is incorporated into the Delphi IDE through the Import Component Wizard (specifically when you choose to import a Type Library or an ActiveX Control). When you use this wizard, the IDE internally invokes tlibimp.exe to perform the generation and often adds the resulting files to your project.

2. Standalone Application

Yes, tlibimp.exe can be used as a standalone command-line application.

Using it from the command line offers additional configuration options that may not be available within the IDE's Import Component Wizard. This is often necessary for:

Scripting: Automating the import process as part of a build system.
Specialized Imports: Utilizing more advanced options for controlling the generated code.
Importing 64-bit Type Libraries: The 32-bit IDE might struggle to register or correctly reference 64-bit type libraries, so using the command-line tlibimp.exe from the correct platform's bin (or bin64) directory is sometimes the required workaround.

The basic command-line usage involves specifying the type library and options for the output file (e.g., -P for Pascal output):

tlibimp.exe [options] <TypeLibraryFile>

tlibimp.exe Commandline Switches

Embarcadero TLIBIMP Version 12.16581
Copyright(c) 1995-2025 Embarcadero Technologies, Inc.

Syntax: TLIBIMP [options] <typelibfile>
 Files to Generate (Required):            Output File Options:
  -C   Generate C++ Import file            -D<path>  Output directory path
  -P   Generate PASCAL Import file         -Fe<name> TLB suffix   (-Fe- none)
  -I   Generate .ridl Import file          -Ft<name> TLB filename (no suffix)
                                           -Ce<name> OCX suffix   (-Ce- none)
                                           -Co<name> OCX filename (no suffix)
 Customize code generated: 
  -Ha+ Create IDE component for Controls   -Hpa<name> Set palette name
  -Hs+ Create IDE component for Servers    -Hps<name> Set palette name
  -Hr+ Generate component registration
 C++ options:                             PASCAL options: 
  -Cd+ Generate dispinterfaces             -Ps+ Map dual HRESULT to safecall
  -Cm- Map disp interfaces to dual         -Pt- Map all HRESULT to safecall
  -Cn<name> Set namespace name
  -Cs- declspec(__selectany) for GUIDs    MISC options: 
  -Ct+ Force the use of a _TLB file        -O+ Generate CoClassCreator wrappers
  -Cu+ Expose namespace with 'using'       -R+ Process dependent type libraries
  -Cv+ BCB4-style server events            -XM- Use MS-style getter/setter
  -Cw- Use disp. in Control wrappers       -W+  Emit warnings in files
                                           -Wc+ Emit comments in files
 Ignore Flags: -Ya- All special flags,     -Yc+ [CanCreate],
               -Yh- [Hidden],              -Yp- [Predefined], -Yr- [Restricted]

touch.exe Description

touch.exe in Embarcadero RAD Studio 13 Architect is a small command-line utility similar in purpose to the Unix/Linux touch command.

Functionality Summary

touch.exe is used to update the timestamp (date and time) of a file�specifically its last modified and/or last accessed times. If the specified file does not exist, it can optionally create an empty file.

Typical uses include:

Forcing source files to appear "newer" so that the build system recompiles them.
Adjusting timestamps on files for version control consistency or build automation scripts.
Creating empty placeholder files as part of automated project setups.

Integration with Delphi / RAD Studio

Inside RAD Studio, touch.exe is mainly used internally by the build tools and project make systems�for instance, the make, dcc32, or msbuild processes�to refresh file timestamps during incremental builds or dependency checking.

Standalone Use

touch.exe can be used as a standalone application from the command line or within batch files.
You can run it independently without the Delphi IDE. For example:

touch.exe MyFile.pas

This command updates the modification timestamp of MyFile.pas to the current time.
If the file doesn�t exist, depending on the implementation and command-line options, it may create a new zero-length file.

Typical Command-Line Syntax (varies slightly by version)

touch [options] filename

Common options (if supported):

/c � create the file if it does not exist.
/d � set a specific date/time (e.g., /d "2025-11-02 13:00").
/? � display usage/help information.

Summary Table

Attribute	Description
Executable	touch.exe
Purpose	Update or create files with a specific timestamp
Used by Delphi IDE?	Yes, for build dependency management
Can be standalone?	Yes, fully usable from the command line
Typical Users	Build automation scripts, developers managing file timestamps

✅ In short:
touch.exe is a general-purpose file timestamp utility bundled with RAD Studio, used both internally by the IDE�s build tools and freely usable as a standalone command-line tool.

touch.exe Commandline Switches

Touch Version 5.0 Copyright (c) 1995-2010 Embarcadero Technologies, Inc.

Usage: TOUCH [options] [filename(s)...]
This utility sets the date and time of the listed files to be the current
(or specified) date and time.  (wild cards * and ? ok)

  -a, -f, -m are quietly ignored for Unix compatibility.
  -c    does not create the file if nonexistent (default is to create it)
  -D    allow directory names to be touched (when wildcards specified)
  -h    detailed help
  -n    lists files, doesn't change the date/time (for testing rsp files)
  -rfilename sets the specified files to the same date/time as 'filename'
  -s    recurse through subdirectories

  -t and -d can be used with any of the following date and time formats:
     nnddhhmm[yy] Unix syntax sets date&time (nn=month, year is optional)
     hh:mm[:ss]   Borland syntax sets time only (seconds are optional)
     mm/dd/yy     Borland syntax sets date only (mm-dd-yy also works)
     ranges: month:01-12, day:01-31, hour:00-23, min:00-59, sec:00-59,
             year:the last 2 digits of the year representing 1980-2079

  -v    verbose mode, prints out the files processed
  -w    warn about unlocatable files and bad time values (default is to warn)

@xxxx specifies response file xxxx where any combinations of options or files
can be listed (up to 10 levels of response file nesting allowed).
Long file names must be quoted if spaces are embedded in them (in both response
files and on the command line)

tregsvr.exe Description

tregsvr.exe - Type Library Registration Server

Overview

tregsvr.exe is a Type Library Registration utility included with Embarcadero RAD Studio. It's used to register and unregister COM type libraries and ActiveX controls in the Windows registry.

Primary Functionality

Register Type Libraries: Registers .TLB (Type Library) files, making COM interfaces available to applications
Register ActiveX Controls: Registers .OCX files and other ActiveX components
Unregister Components: Removes registration entries for type libraries and controls
Batch Processing: Can process multiple files through command-line parameters

Standalone vs. IDE Usage

This is a standalone command-line application that can be used independently of the Delphi IDE:

Works outside the IDE: You can run it directly from the command prompt or batch files
No IDE required: Does not require RAD Studio to be running
Command-line driven: Accepts file paths and switches as parameters
Used by IDE: The IDE may call it internally during component installation or package registration, but this doesn't limit its standalone functionality

Typical Use Cases

Manual component registration when installing third-party ActiveX controls
Deployment scripts for registering COM components on target machines
Build automation for registering type libraries after compilation
Troubleshooting COM registration issues

Similar to Windows regsvr32.exe

It functions similarly to the Windows system utility regsvr32.exe, but is specifically tailored for Embarcadero's development tools and may handle certain Delphi-specific type library formats or registration requirements.

You can use it from any command prompt or script without launching the IDE.

VCLStyleViewer.exe Description

Summary / Functional Description

VCLStyleViewer.exe is a standalone utility application designed to preview, manage, and test the visual appearance of VCL Styles (Visual Component Library Styles) on real-world Delphi forms.

Its primary function is to act as a style viewer and "playground," allowing developers to:

Preview All Available Styles: It scans the system for .vsf files (the file extension for VCL Styles) and displays a list of all installed and custom styles.
Visualize Style on Sample Forms: It applies the selected style to a variety of built-in sample forms that mimic common application UI elements, such as:

Forms with standard controls (buttons, edits, checkboxes, radio buttons, etc.)
Forms with menus, toolbars, and status bars.
Forms with complex controls like treeviews, listviews, grids, and tabs.
Forms demonstrating different states (focused, disabled, hovered).

Test Style Customization: It allows you to modify certain style attributes on the fly, such as the form's color and font, to see how the style reacts to these changes.
Facilitate Style Selection: By providing a real-time, interactive preview, it helps developers choose the perfect visual theme for their application without having to repeatedly compile and run their main project.

Is it an IDE Tool or a Standalone Application?

VCLStyleViewer.exe is primarily a standalone application.

While its purpose is tightly coupled with the functionality of the Delphi IDE, it runs as a completely separate process (VCLStyleViewer.exe). You do not need to have RAD Studio running to use it.

How it Relates to the Delphi IDE:

Development Aid: It is a development tool provided alongside the IDE. You use it during the design phase of your project to make informed decisions about your application's UI.
Shared Style Files: It reads the same .vsf style files that the IDE uses. The styles you preview in VCLStyleViewer are typically located in the Redist\styles\vcl directory of your RAD Studio installation and can include your own custom styles.
Independent Execution: You can locate the executable in the bin directory and double-click it to run it independently. It does not integrate into the IDE as a docked window or a modal dialog.

Typical Workflow for a Developer

A developer is designing a Windows application in RAD Studio and wants to use a modern skin.
They run VCLStyleViewer.exe (either from the Start Menu group or directly from the bin folder).
In the viewer, they browse through the list of styles (e.g., "Windows11 Dark," "Glossy," "Carbon").
They click on a style name and instantly see it applied to a sample form containing buttons, edits, menus, and other controls.
They can cycle through different sample forms using the tabs or buttons within the viewer to see how the style looks on various parts of an application.
Once they find a style they like, they return to the Delphi IDE and assign that same style to their project via Project > Options > Application > Appearance.

Key Takeaway

VCLStyleViewer.exe is an essential, standalone utility for any Delphi developer using VCL Styles. It dramatically speeds up the UI design process by providing an immediate, visual catalog of available styles applied to realistic form layouts, all without needing to compile the main project.

VSF2FM..exe Description

VSF2FM.EXE Functionality Summary

The executable vsf2fm.exe is a command-line utility for Embarcadero RAD Studio (including your RAD Studio 13 Architect version) whose primary function is to convert a VCL (Visual Component Library) style file to a FireMonkey (FMX) style file.

Functionality Description

VCL styles are raster-based and used primarily for styling Windows desktop applications built with VCL.
FireMonkey styles can be vector-based or bitmap-based and are used for styling cross-platform applications (Windows, macOS, iOS, Android, Linux) built with FMX.
The vsf2fm.exe utility facilitates the reuse of visual styles across these different frameworks by translating the VCL style format (.vsf file) into a FireMonkey style format (.style file). This allows developers to maintain a consistent look and feel across different target platforms.

Standalone Usage

The application is typically used as a standalone command-line tool rather than directly by the Delphi IDE (Integrated Development Environment) during regular operation.
Its documentation describes it as a command-line tool with parameters, indicating that it is designed to be executed directly from the command prompt, shell script, or perhaps called by other utilities or build processes.

Example Command Structure: vsf2fm <file or folder> [optional parameters]

Win32ProxyDownloader.exe Description

Win32ProxyDownloader.exe - Functionality Summary

Based on its name and location within RAD Studio 13, Win32ProxyDownloader.exe is a utility application designed to handle download operations through proxy servers specifically for Win32 platform targets.

Primary Functionality

This executable likely serves as a specialized downloader that:

Manages HTTP/HTTPS downloads through corporate proxy servers - It handles authentication and routing of download requests through configured proxy settings
Downloads platform-specific components and packages - Retrieves Win32 libraries, SDKs, or platform updates needed by RAD Studio
Handles proxy authentication - Manages credentials and authentication protocols (Basic, NTLM, Kerberos) for enterprise proxy environments

IDE vs Standalone Usage

Primarily IDE-integrated, but potentially standalone-capable:

IDE Usage (Primary): The application is most likely invoked automatically by RAD Studio when:

Installing additional Win32 platform support files
Downloading GetIt Package Manager components
Updating platform SDKs or tools
Installing Win32-specific libraries or frameworks

Standalone Usage (Possible): Given that it's a separate .exe file rather than integrated DLL, it may support command-line parameters for standalone use, though this would be uncommon and likely undocumented.

Typical Context

This tool exists because many corporate development environments sit behind proxy servers that require authentication. Rather than embedding proxy logic throughout the IDE, Embarcadero created a dedicated utility to handle these network operations for Win32-related downloads.

To determine if it supports standalone usage, you could try running it from the command line with --help or /help flags to see if it displays usage information, though it may simply show an error if it expects to be called only by the IDE.

Win32ProxyDownloader.exe Commandline Switches


 WIN32 DATASNAP PROXY DOWNLOADER HELP 
 COMMAND:
   Win32ProxyDownloader.exe [-protocol protocol] -language language_platform 
    [-output output_folder] [-host hostname]

 OPTIONS:
   -language <language> (required) The language_platform identifier. 
    e.g. java_android or objectivec_ios42
   -host <hostname:port> (optional) Hostname and port where the server is
    running. Default is localhost:80
   -protocol <http|https> (optional) protocol can be http or https. Default http
   -output <local_proxy_path> (optional) is the full path where the proxy must
    be downloaded. Default current_folder

 EXAMPLES:
   Win32ProxyDownloader.exe -language java_android
   Win32ProxyDownloader.exe -host localhost:8080 -language java_android
    -output c:\
   Win32ProxyDownloader.exe -protocol http -language java_android -output folder

WSDLImp.exe Description

WSDLImp.exe is a command-line utility included with Embarcadero RAD Studio (including version 13 Architect) that is used to import Web Services Description Language (WSDL) files and generate Delphi or C++ client-side proxy code for consuming SOAP-based web services.

Key Functionality:

WSDL Parsing: Reads a WSDL (.wsdl) file�either from a local file path or a URL.
Proxy Code Generation: Automatically generates Delphi (.pas) or C++ (.cpp/.h) source code that provides strongly-typed classes and methods to interact with the web service described in the WSDL.
SOAP Client Support: The generated code handles the underlying SOAP messaging, serialization/deserialization of parameters and return values, and communication over HTTP.
Customization Options: Offers various command-line switches to control output (e.g., namespace mapping, array handling, type naming conventions).

Standalone Use:

Yes, WSDLImp.exe can be used as a standalone command-line application.
It does not require the Delphi IDE to run. Developers often use it in:

Build scripts
CI/CD pipelines
Manual command-line workflows

However, it is also integrated into the Delphi IDE (via "Component > Import WSDL" or similar menu options), where the IDE internally invokes WSDLImp.exe with appropriate parameters and automatically adds the generated units to the current project.

Typical Usage (Command Line):

bash

WSDLImp.exe -OcMyService http://example.com/MyService.wsdl

This would generate a Delphi unit (e.g., MyService.pas) containing the client proxy classes.

Summary:

WSDLImp.exe is a standalone WSDL-to-code importer primarily for generating SOAP web service client stubs in Delphi or C++. While tightly integrated with the RAD Studio IDE for convenience, it functions independently and can be scripted or called manually outside the IDE environment.

WSDLImp.exe Commandline Switches

Embarcadero WSDLIMP Version 2.41 - $Rev: 122014 $
Copyright (c) 2010-2025 Embarcadero Technologies, Inc.

Usage: WSDLIMP [options] <WSDL[File|URL]>

 Language Generation Options:
  -C     Generate C++ code
  -P     Generate Pascal code

 Code Generation Options [ -option{+|-} default shown ]:
  -O2-   Merge duplicate types
  -Oa+   Process nillable and optional elements
  -Ob-   Use Setters and Getters for properties
  -Od+   Generate destructors for remotable types
  -Oe+   Generate scoped enumerations
  -Of+   Import Fault Types
  -Og-   Generate interface GUIDs using COM API
  -Oh+   Import Header Types
  -Oi+   Generate warning comments
  -Oj+   Validate Enumeration members
  -Ok-   Map pure collections to wrapper class types
  -Ol-   Emit wrapper element Types
  -Om-   Allow out parameters
  -Oo+   One out parameter is return value
  -Op+   Process included and imported schemas
  -Or-   Generate alias for the element of pure collections
  -Os-   Generate server implementation instead of client proxies
  -Ot+   Do not emit unused types
  -Ou+   Unwrap wrapper elements (wrapped doc|lit services)
  -Ov+   Generate verbose information about types and interfaces
  -Ow-   Map String to WideString
  -Ox+   Generate class aliases as class types
  -Oz-   Use TXSxxxx classes for simple nillable types

 SOAP Version Options:
  Automatically determines SOAP version if not forced. (Recommended)
  -SOAP11   Process only WSDL Binding extensions for the SOAP 1.1 Protocol
  -SOAP12   Process only WSDL Binding extensions for the SOAP 1.2 Protocol

 File options: 
  -D<path>  Output directory path
  -=+       Output filename after '=' in URL
  @<Resp>   Response file with list of WSDL

 Proxy/Server Authentication:
  -user:userName -pass:Password [-proxy:Proxy]

XMLMapper.exe Description

XMLMapper.exe - Functionality Summary

XMLMapper is a utility that allows you to define mappings between XML documents/schemas and client dataset data packets in three ways: from an existing XML schema to a client dataset you define (useful for creating database applications with existing XML schemas), from an existing data packet to a new XML schema (useful for exposing database information in XML for business-to-business communication), and between an existing XML schema and an existing data packet (when both describe the same information) Embarcadero.

Key Capabilities:

Creates transformation files (.xtr extension) that describe how to convert between XML documents and Delphi data packets
Provides a visual interface to map XML nodes to database fields through File > Open operations Embarcadero
Works with XML schemas, XML documents, and data packets (files created by ClientDataset's SaveToFile method)
Supports custom "user-defined" nodes for complex transformations that require code
The transformation files it generates are used by the TXMLTransform component at runtime Embarcadero

Dependencies:

XMLMapper requires two DLLs (midas.dll and msxml.dll) to function, and msxml.dll must be registered as a COM server using Regsvr32.exe Embarcadero

Standalone vs. IDE Usage

Yes, xmlmapper.exe can be used as a standalone application. It operates at design time to define mappings between XML documents and data packets Embarcadero, but it's a separate executable with its own GUI that you can launch independently from the IDE. You don't need to have the IDE open to use it - you can run it directly from the bin directory to create transformation files that your Delphi applications will use at runtime.

Delphi Bin ApplicationsDick Maley©2025dickmaley@advdelphisys.com

Table of Contents

AuditsCLI.exe Description

AuditsCLI.exe Commandline Switches

bcc32.exe Description

bcc32.exe Commandline Switches

bcc32c.exe Description

bcc32c.exe Commandline Switches

bcc32x.exe Description

bcc64.exe Description

bcc64.exe Commandline Switches

BCompareLite.exe Description

BDSFileCopyHelper.exe Description

bdsreg.exe Description

BDSSetLang.exe Description

BDSSetLang.exe Commandline Switches

BitmapStyleDesigner.exe Description

brcc32.exe Description

brcc32.exe Commandline Switches

cgconfig.exe Description

cgrc.exe Description

cgrc.exe Commandline Switches

clang-format.exe Description

clang-format.exe Commandline Switches

coff2omf.exe Description

coff2omf.exe Commandline Switches

convert.exe Description

Convert.exe Commandline Switches

cpp32.exe Description

cpp32.exe Commandline Switches

cpp32c.exe Description

cpp32c.exe Commandline Switches

CppLibTransform.exe Description

CppLibTransform.exe Commandline Switches

dbkw64_29_0.exe Description

dcc32.exe Description

dcc32.exe Commandline Switches

dcc64.exe Description

dcc64.exe Commandline Switches

drinterop.exe Description

drinterop.exe Commandline Switches

DSProxyGen.exe Description

DSProxyGen.exe Commandline Switches

DSProxyReg.exe Description

DSProxyReg.exe Commandline Switches

dsymlink.exe Description

dsymlink.exe Commandline Switches

EMSDevConsole.exe Description

EMSDevServerCommand.exe Description

EMSDevServerCommand.exe Commandline Switches

EMSMultiTenantConsole.exe Description

FDExplorer.exe Description

FMXControlStyleViewer.exe Description

FMXMetropolisUIStyleViewer.exe Description

FMXMobileStyleViewer.exe Description

FMXStyleViewer.exe Description

FMXWinModernStyleViewer.exe Description

Formatter.exe Description

Formatter.exe Commandline Switches

GenDocCLI.exe Description

GenDocCLI.exe Commandline Switches

GenTLB.exe Description

GenTLB.exe Commandline Switches

GetItCmd.exe Description

GetItCmd.exe Commandline Switches

grep.exe Description

grep.exe Commandline Switches

impdef.exe Description

impdef.exe Commandline Switches

implib.exe Description

implib.exe Commandline Switches

make.exe Description

make.exe Commandline Switches

migrationtool.exe Description

mkexp.exe Description

mkexp.exe Commandline Switches

objcopy.exe Description

objcopy.exe Commandline Switches

paclient.exe Description

paclient.exe Commandline Switches

Delphi Bin Applications
Dick Maley
©2025
dickmaley@advdelphisys.com