Chilkat Delphi DLL API

for Embarcadero® RAD Studio — Delphi XE through Delphi 13 (XE*, 10.*, 11.*, 12.*, 13.*)

Windows 32-bit, 64-bit, and Arm64 (Windows on Arm), Linux x86_64, macOS (Intel and Apple Silicon), iOS (device and simulator), and Android (32-bit and 64-bit). Also works with Delphi 7, 8, and 2005–2010 on Windows.

The Chilkat Delphi DLL is a native library with a flat, Pascal-callable API: a Win32/Win64 DLL on Windows, a .so on Linux and Android, a .dylib per architecture on macOS, and static libraries (.a) on iOS, where Apple requires third-party code to be linked into the app. It is not an ActiveX and never needs to be registered with regsvr32. Each Chilkat class is exposed through a small .pas interface unit that you add to your uses clause; the same units compile unchanged for every platform. Nothing is installed on your machine: unzip, point Delphi at the folder, and go.

Download

This is the full-version Chilkat product. Chilkat libraries are fully functional for a 30-day evaluation; no separate trial build is required. One download covers Windows 32-bit and 64-bit, Linux x86_64, macOS, iOS, and Android, and includes both the standard units and the optional dynamic-loader units (see below).

Documentation & Samples

• 📖 Chilkat Delphi DLL Reference Documentation
• 💻 Chilkat Delphi DLL Sample Code — hundreds of ready-to-run examples
• 📝 Release Notes on the Chilkat blog

What's in the download

Unzipping creates a chilkat-delphi directory. We recommend unzipping to C:\ so that the units live in C:\chilkat-delphi; the paths on this page assume that location.

Using Chilkat in your own project

1. Tell Delphi where the units are — once. Select Tools → Options → Language → Delphi → Library, choose the platform (Win32 and again for Win64), and add C:\chilkat-delphi to the Library path. Every project on this machine can now use Chilkat just by naming units in its uses clause.
   Prefer a per-project setting? Instead of the global Library path, add C:\chilkat-delphi to Project → Options → Building → Delphi Compiler → Search path. You do not need to add the .pas files to the project with Add to Project; the compiler finds them from the search path.
2. Add the Chilkat units you need to the uses clause. For example, to use the Crypt2 class (plus Global, which is where the unlock call lives):

   uses
     System.SysUtils, Global, Crypt2;

   Each Chilkat class has a unit of the same name: Http, Rest, JsonObject, Email, MailMan, Zip, SFtp, and so on.
3. Make the DLL land next to your EXE automatically. The Chilkat DLL must be in the same directory as your application's EXE. Rather than copying it by hand after every build, add a post-build event under Project → Options → Building → Build Events → Post-build events. Select the Win32 target and enter:

   copy /Y "C:\chilkat-delphi\ChilkatDelphi32.dll" "$(OUTPUTDIR)"

   Then select the Win64 target and enter:

   copy /Y "C:\chilkat-delphi\ChilkatDelphi64.dll" "$(OUTPUTDIR)"

   $(OUTPUTDIR) expands to the directory that receives your EXE (typically Win32\Debug, Win64\Release, etc.), so the right DLL always follows the right build.
4. Write some code. Here is the complete QuickStart program: it unlocks Chilkat, AES-encrypts a string, and decrypts it again. The same calls work unchanged in a VCL or FMX application.

   program QuickStart;
   
   {$APPTYPE CONSOLE}
   
   uses
     System.SysUtils, Global, Crypt2;
   
   var
     glob: HCkGlobal;
     crypt: HCkCrypt2;
     success: Boolean;
     encStr: PWideChar;
     decStr: PWideChar;
   
   begin
     // Unlock Chilkat once at application startup.
     // Any string unlocks a fully-functional 30-day trial.
     glob := CkGlobal_Create();
     success := CkGlobal_UnlockBundle(glob, 'Anything for 30-day trial');
     if not success then
       begin
         WriteLn(CkGlobal__lastErrorText(glob));
         CkGlobal_Dispose(glob);
         Exit;
       end;
   
     // AES-256 in CBC mode, hex-encoded output.
     crypt := CkCrypt2_Create();
     CkCrypt2_putCryptAlgorithm(crypt, 'aes');
     CkCrypt2_putCipherMode(crypt, 'cbc');
     CkCrypt2_putKeyLength(crypt, 256);
     CkCrypt2_putPaddingScheme(crypt, 0);
     CkCrypt2_putEncodingMode(crypt, 'hex');
     CkCrypt2_SetEncodedIV(crypt, '000102030405060708090A0B0C0D0E0F', 'hex');
     CkCrypt2_SetEncodedKey(crypt, '000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F', 'hex');
   
     encStr := CkCrypt2__encryptStringENC(crypt, 'The quick brown fox jumps over the lazy dog.');
     WriteLn('Encrypted: ' + encStr);
   
     decStr := CkCrypt2__decryptStringENC(crypt, encStr);
     WriteLn('Decrypted: ' + decStr);
   
     CkCrypt2_Dispose(crypt);
     CkGlobal_Dispose(glob);
   
     WriteLn('Press Enter to exit.');
     ReadLn;
   end.

   More examples, including this one, are at Delphi AES Encryption.
5. Press F9. The program builds, the post-build event copies the DLL, and the encrypted hex string and decrypted text appear in the console.

Linux, macOS, iOS, and Android

The Chilkat units are platform-neutral. Add the same C:\chilkat-delphi directory to the Library path for the Linux 64-bit, macOS, iOS, and Android platforms in Tools → Options → Language → Delphi → Library, select the target platform in the Project Manager, and build; chilkatDllPath.inc picks the right library name. The only platform-specific work is getting the shared library onto the target machine where the dynamic loader can find it, which is described below. Everything else — the uses clause, the handle types, the function calls — is identical to Windows.

Linux (x86_64)

The Linux library requires glibc 2.27 or newer — in practice, any Linux distribution released around mid-2018 or later (Ubuntu 18.04+, Debian 10+, RHEL/CentOS 8+, Fedora 28+, and equivalents). To check a system, run ldd --version; the first line reports the glibc version. Older distributions will fail at startup with an error such as "version `GLIBC_2.27' not found".

Your application links against libchilkatdelphi_x86_64.so. Linux resolves it at startup through the standard dlopen search, which does not include the directory containing your executable. Two reliable ways to make it findable:

1. System-wide (simplest for deployment). Copy the library into a directory on the loader's path and refresh the cache:

   sudo cp libchilkatdelphi_x86_64.so /usr/local/lib/
   sudo ldconfig

2. Per-application. Ship the .so alongside your executable and point LD_LIBRARY_PATH at that directory when launching, for example from a small wrapper script:

   #!/bin/sh
   DIR="$(cd "$(dirname "$0")" && pwd)"
   LD_LIBRARY_PATH="$DIR:$LD_LIBRARY_PATH" exec "$DIR/MyApp" "$@"

When running from the IDE via PAServer, add linux\libchilkatdelphi_x86_64.so in Project → Deployment with a remote path of ./, and set LD_LIBRARY_PATH in the PAServer environment (or use the system-wide install on the development machine). If the library can't be found the application fails at startup with "libchilkatdelphi_x86_64.so: cannot open shared object file".

macOS (Intel and Apple Silicon)

There is one dylib per architecture: libchilkatdelphi_arm64.dylib for Apple Silicon and libchilkatdelphi_x86_64.dylib for Intel. You never choose between them in code — chilkatDllPath.inc selects the right name at compile time from the target CPU. Both are signed with Chilkat's Developer ID, so they pass Gatekeeper and can be included in a notarized application.

The include references the dylib by its bare filename. At link time, Delphi's linker (running on Windows) locates it on the Library path — which already contains it if you added C:\chilkat-delphi\macos for the macOS platforms. At runtime, dyld finds it by name in the directory containing your executable — inside an app bundle that is MyApp.app/Contents/MacOS/ — with no search-path setup. So the dylib simply ships next to the executable, exactly as on Windows:

1. Add C:\chilkat-delphi\macos to the Library path (or the project's Search path) for the macOS platforms, so the linker can find the dylib when building.
2. In Project → Deployment, add the dylib matching your target (macos\libchilkatdelphi_arm64.dylib for a macOS ARM 64-bit build, macos\libchilkatdelphi_x86_64.dylib for macOS 64-bit Intel) with the remote path Contents\MacOS\. PAServer then copies it into the bundle on every deploy, and it is packaged with the app when you build for distribution.
3. For a command-line tool (no bundle), place the dylib in the same directory as the executable.

iOS (device and simulator)

Apple requires third-party native code in an iOS app to be linked statically, so instead of a shared library the download provides two static libs: ios\arm64\libchilkatdelphi.a for real devices and ios\arm64-sim\libchilkatdelphi.a for the Apple Silicon simulator. When chilkatDllPath.inc selects libchilkatdelphi.a, Delphi's linker links the Chilkat code directly into your app binary — there is no separate library to deploy.

1. Add the directory containing the matching .a to the Library path for each iOS platform: C:\chilkat-delphi\ios\arm64 for iOS Device 64-bit, and C:\chilkat-delphi\ios\arm64-sim for iOS Simulator ARM 64-bit.
2. Tell the linker to include the C++ runtime. Chilkat is implemented in C++, and a static library does not carry the C++ runtime with it, so the final link must add it. In Project → Options → Building → Delphi Compiler → Linking, for the iOS platforms, add

   -lc++

   to Options passed to the LD linker.

Android (32-bit and 64-bit)

On Android the Chilkat library is a shared object, one per ABI: android\arm64-v8a\libchilkatdelphi.so for Delphi's Android 64-bit target and android\armeabi-v7a\libchilkatdelphi.so for Android 32-bit. Android loads a native library from inside the APK automatically, so the only setup is packaging it:

1. In Project → Deployment, select the Android configuration and add the matching libchilkatdelphi.so with the remote path library\lib\arm64-v8a\ (Android 64-bit) or library\lib\armeabi-v7a\ (Android 32-bit). The deployment step places it in the APK's native-library directory, where Android's loader finds it by name.
2. There is nothing to configure for the C++ runtime on Android — unlike iOS, the Chilkat .so already contains libc++ (statically linked), so no extra linker options are needed.

The libraries require Android 7.0 (API level 24) or later, which is below the minimum Android version supported by current Delphi releases, so it imposes no additional restriction on your app.

Deploying your application

The Chilkat shared library is the only runtime dependency: nothing needs to be installed or registered on the target machine, and there is no redistributable to run.

If you ship both 32-bit and 64-bit Windows builds, each goes in its own directory with its matching DLL.

Next Steps

Browse the Delphi DLL examples for working code covering HTTP/REST, JSON, XML, email (SMTP/POP3/IMAP), FTP, SFTP/SSH, Zip, PDF, digital signatures, encryption, and much more. For questions, see the reference documentation or contact Chilkat support.

"Embarcadero" is a registered trademark of Embarcadero Technologies.