• Cross-Platform

    Target Windows, Mac OSX, iOS and Android from a single code-base

  • Multi-Threaded

    turn on/off with a simple switch

  • RAD

    Write events, not interfaces

  • HTTP/S Protocol

    No Firewall problems

  • Non-Blocking (Asynchronous)

  • Remote Functions

    reusable,easy to write,easy to call

  • Strong Encryption

    & Automatic Data Compression

  • Reliable & Scalable

    it just works, even under high load

  • Small footprint, no bloat

Multi-Deployment: target Windows, Mac OSX, iOS and Android from a single code-base

Write one Project in Delphi and compile it as (a) robust stand-alone Client and/or Server for Windows, Mac OSX, iOS or Android, or … as (b) ISAPI DLL extension for MS IIS or Apache, or … (c) integrate your Application into third-party Message-based Servers like the NexusDB Server.

RAD: Write events, not interfaces

Everything you do with RTC is component-based, while all the code you will ever need to write is defined as events, so you can design your server and client applications, without the need to use wizards or write interfaces.

Easy MultiThreading: turn on/off with a simple switch

A very sophisticated Threading mechanism is built into all RTC Connection components, which allows thousands of active connections to be running in separate threads, all at the same time. And the only thing you need to do is change a simple MultiThreaded property to True. Then, any newly received connection will be handled by a thread pooling mechanism which saves valuable System resources, while still enabling nearly unlimited number of simultaneous connections at the same time.

HTTP(S): No Firewall problems

RTC Clients will never have to be specially configured to get through corporate firewall’s and reach the internet. Simply by setting the UseProxy property to True, Data Client connection will use a connection provider which uses the same settings to read and send its data to the internet, as MS Internet Explorer does for browsing the Web. This means that Clients can work in any corporate LAN and have full access to the internet.


Other than most other internet components, RTC connection components are non-blocking and event-driven. This means that, even when not using a multithreaded mode, your users will not be blocked (“Application Not Responding”) during communication between your client and the server. For each state change in the connection, there is an event that will be triggered.

Remote Functions-reusable, easy to write, easy to call

Implementing and using remote functions is as easy as writing local functions. You just place a RtcFunction component on your Form or a Data Module, set function name and write your OnExecute event. OnExecute event receives the Connection object, Function Parameters and a Result object. You just have to use the parameters passed to the function to prepare the result. The rest is done “under the hood” by RealThinClient components.

Strong encryption & automatic compression

RTC components offer built-in, easy-to-use strong encryption with Encryption Keys of variable length and automatic data compression. You don’t even have to think about encryption keys or data compression, everything will be generated and maintained for you. Using strong encryption and compression with remote functions is completely transparent, you will never have to worry about encryption or compression again. Simply set Encryption and Compression parameters in RtcClientModule and RtcServerModule, the rest is up to RTC.

Plug-In Framework-write your own plug-ins or use 3rd-party plug-ins

All Client and Server code you write using RealThinClient SDK is ready to be used as building blocks or plug-ins in any application that uses RealThinClient SDK. For example, you can combine a Web Server, Messenger server, Application server, Database server and your own functions in one Data Server, even when those components weren’t specially designed to share the same Server space. Because of the easy-to-use plug-in framework on top of which all RTC Components are built, you can link unlimited number of functionality and data providing components like RtcDataProvider, RtcServerModule and/or RtcDataServerLink to one Data Server connection component, enhancing that server’s functionality with each new component. And by keeping code in separate units (Data Modules), you can even provide your own plug-ins (and sell those plug-ins) to anyone who uses the RealThinClient SDK.

Small footprint

A complete Web Server implementation, using RealThinClient SDK, is less than 700 KBytes when compiled with D7. Even though it is so small, it offers enough functionality with great stability and scale-ability.

Supported IDEs & Target Platforms

IDE / Platform












Delphi 7 – XE


Delphi XE2


Delphi XE3


Delphi XE4


Delphi XE5 – XE7


Delphi XE8 – 10.2


[Click HERE to see the RealThinClient SDK components Hierarchy]

Designed to help you BUILD RELIABLE & SCALABLE Internet-Ready Applications

RealThinClient SDK is a flexible and modular framework for building reliable and scalable cross-platform Applications with Delphi, designed for the Web by utilizing HTTP/S with full IPv4 & IPv6 support and built-in multi-threading, extensively stress-tested to ensure the highest stability. By using non-blocking event-driven communication with built-in thread-pooling, Applications built with the RealThinClient SDK can handle thousands of active connections by using a limited number of threads in a real multi-threaded environment, on all supported platforms.

  • Write Firewall-friendly Clients, Servers and ISAPI Extensions (Apache and MS IIS compatible)

  • Write reliable HTTP(S) Servers, Routers, Proxy Servers, reverse Proxy Servers and Load Balancers

  • Add strong SSL/TLS encryption using 3rd-Party Encryption components as plug-ins for the RealThinClient SDK (for example: StreamSec Tools 2.x = 99 €), or use built-in SSL support with RTC Clients running on Windows and compile your RTC Server code into ISAPI DLLs to run on third-party Web Servers with SSL support (for example MS IIS, Apache or Abyss)

  • Debug ISAPI extensions using the RTC Web Server (full source code in Delphi included)

  • Component-based and Modular Design allows you to add new remoting functionality into your existing Delphi applications and re-use existing code

  • Make your Clients and/or Servers Multi-Threaded to maximize performance and improve user experience simply by setting a property (enable built-in powerful thread-pooling).

  • Enable Auto-Compression and built-in Encryption simply by setting a property

  • Empower your “static” HTML pages by using the RTC Scripting Engine, building a bridge between your native Delphi code and your visual HTML presentation

  • One Server-side code can be compiled to a Stand-alone Server and ISAPI Extension

  • Flexible and very powerful RTC Remote Functions with integrated support for creating and maintaining Linked Objects, plus a fully customizable template-based Remote Functions Wizard.

  • Integrated full JSON and XML-RPC support: write functions in Delphi and make them remotely accessible to a 3rd-party through XML-RPC and/or JSON formats (JSON+REST, JSON-RPC 1.0 & 2.0); Easily call remote functions published by a 3rd-party in XML-RPC and/or JSON formats.

  • Components and Demo Projects with full Source Code, ready for building cross-platform Applications with Delphi.

Maximum Flexibility for Remote Functions, Sessions and Scripting

RealThinClient SDK supports all native and complex data types for working with Sessions and Remote Functions. You can use any data type to store and access data in a session and/or to send and receive data between clients and servers using RTC remote functions.

All complex data types (record, array, dataset, function) can hold objects of any data type. For example, you can put integers, strings, records, arrays datasets and even remote function calls inside other arrays, records and datasets, as well as use any combination of RTC data types as parameters and/or return values from RTC remote functions.

RTC Type
Access / Make New
asByteStream / newByteStream
asByteArray / newByteArray
asRecord / newRecord
asArray / newArray
asDataSet / newDataSet
Param / newFunction
returns type of data stored in a specific variable, used to check if and what kind of data has been received as parameters to a remote function call on the Server and what kind of data was received as a result of a remote function call on the Client.
returns TRUE if data stored in a specific variable is compatible with the type passed in as a parameter.
returns True if parameter is not set (it is “NULL”). You can set “isNull” to True to clear the variable/parameter.
Boolean value (Delphi type: boolean)
Integer value (Delphi type: longint)
Large Integer value (Delphi type: int64)
Linked Object Identifier (Delphi type: int64)
Cardinal integer value (Delphi type: cardinal)
Float value (Delphi type: double)
Currency value (Delphi type: currency)
Date and Time value. Always use this type to work with Dates and Times (Delphi type: TDateTime)
String value (Delphi type: AnsiString, up to 2GB in size).
Text value, automatically coded and encoded using UTF-8 (Delphi type: String / UnicodeString).
Wide String value (Delphi type: WideString, up to 2GB in size)
use to send/receive variable names (Delphi type: String / UnicodeString)
use to send/receive exception message (String / UnicodeString). If exception is raised from the OnExecute event (and not handled by that event), client will receive the exception message “asException”.
use to work with Streams. When you use “newByteStream”, an in-memory stream will be created, which you can access using “asByteStream”. When used with remote functions, data stored in a stream will be sent/received between client/server as any other data type.
use to work with Byte Arrays. When you use “newByteArray”, a byte array will be created in memory, which you can access using “asByteArray”. When used with remote functions, data stored in a byte array will be sent/received between client/server as any other data type.
use to work with records. In records, each element is accessed using a name (string). Each element in a record can be of any type (even an array, record, dataset or function call).
use to work with arrays. In arrays, each element is accessed using an index of type integer. Each element in an array can be of any type (even an array, record, dataset or function call).
use to work with datasets. In datasets, you browse/insert/delete records as you would usually do with Delphi’s TDataSet (using prior/next/insert/append/delete), while you have access to fields from a current record using names (same as in a record). Each field in a dataset can be of any type (even an array, record, dataset or function call).
use “newFunction” to prepare a remote function call, setting function name and all parameters. Each parameter can be of any type supported by TRtcValue. This means that one parameter of TRtcFunctionInfo can hold virtually anything, from a simple value to a complex data structure or another remote function call (even a complete set of function calls).

RealThinClient SDK package in Delphi

Featured 3rd-party components working with the RealThinClient SDK

StreamSec Tools is a high performance cryptographic security library with support for both low level operations,such as RSA and AES, and higher level schemes, such as SSL/TLS and S/MIME. Anything faster is either covered by patents, hardware, or a major scientific break through. StreamSec Tools 2.x can be used to add native SSL/TLS support to RealThinClient components. For more info, visit StreamSec.

NexusDB is an ultra-fast, client/server database engine designed for the Delphi and C++Builder developer. It is nimble enough to be fully embedded into your desktop applications and powerful enough to be your primary database server. RealThinClient components can be used directly over NexusDB transports, combining their features into a single coherent entity. For more info, visit NexusDB

Selection of Server-side RealThinClient SDK components


Implements the HTTP protocol over TCP/IP and is used to compile RTC components into a stand-alone server application (extends TRtcDataServer). All high-level server-side RTC components use TRtcDataServer descendants to communicate with HTTP Clients (RTC Clients, Web Browsers, SOAP Clients, etc). Best practice is to write all your code using high-level server-side RTC components separated on different data modules, then use one extra Data Module where you will use one RtcHttpServer to compile the functionality into a stand-alone server application (EXE).


Implements the ISAPI interface and is used for for writing extensions for ISAPI-compatible web servers (extends TRtcDataServer). All high-level server-side RTC components use TRtcDataServer descendants to communicate with HTTP Clients (RTC Clients, Web Browsers, SOAP Clients, etc). Best practice is to write all your code using high-level server-side RTC components separated on different data modules, then use one extra Data Module where you will use one RtcISAPIServer to compile the functionality into one ISAPI extension (DLL).


Implements an extensible Message-based Server-side component, which can be used to access RTC applications through third-party communication layers. RealThinClient SDK includes a ready-to-use NexusDB plugin, which uses the RtcMessageServer component to integrate RTC applications into a NexusDB Server.


Very useful when you have a number of Data Provider or Server Module components spread across units, because it groups related Data Provider components and links them to their Data Server connection. If you only have one or any small number of Data Provider components, you can link them directly to Data Server connection component, without the need of a RtcDataServerLink.


Link a group of RTC components to 2 or more Server connection components (RtcHttpServer and RtcMessageServer). This allows you, for example, to write your application code once, but make it accessible through the standard HTTP protocol, through a secure HTTPS protocol and (if required) through different message-based transports like the NexusDB transport layer.


Used to implement events which will handle HTTP requests and prepare responses (for example, client requests a file, which has to be read from a local drive and written out as a response). Each Data Provider only responds to his requests, ignoring the rest. This makes Data Providers work as plug-ins for the Server, which can be used alone or in combination with other RTC components to create a powerful and multifunctional Server.


Write HTTP(S) Routers, Proxy Servers, reverse Proxy Servers and Load Balancers with this component or extend your existing HTTP(S) Server with transparent request forwarding, for example when requests sent to your Server need to be routed to another Servers for processing and responses from that other Server need to be monitored and/or modified before they are returned to caller Clients.


Extended version of the RtcDataRouter component which makes it very easy to write Load Balancers.


Execution point for a group of Remote Functions. It enables the Server to provide remote access to its remote functions. RtcServerModule has no events which would have to be implemented, you just link a RtcServerModule with its Server on one side and a RtcFunctionGroup on the other side to enable remote functions.


Provides access to a group of functions. When used by a RtcServerModule, it automatically enables access to remote functions for all RTC Clients. When used by a RtcClientModule, it gives server the ability to call client-side functions as a result of client’s function calls.

To implement remote functions, you will need at least one RtcFunctionGroup component and link one or more RtcFunction components to it. Function Groups also enable you to call other functions from the same group to fill parameters for other function calls. RtcFunctionGroup is primarily used by the RtcServerModule and RtcClientModule components to hold implementations for their remote functions, but it can also be used directly by any other component.


Link one RtcFunction to a RtcFunctionGroup, check that the Function Group is assigned to a RtcServerModule, then choose a “FunctionName” and write your function code in the OnExecute event. That’s all you have to do to add a new remote function to your RTC Server.

When writing a remote function, you don’t have to think about anything but your function code. In case of an exception (which you can also raise inside your OnExecute event handler), client will get the exception message as a result (Result.isType=rtc_Exception), so you don’t even have to worry about that.


Used for implementing custom Linked Data Modules, Forms and Frames. Dropping this component on a Data Module, Form or a Frame will make the owner (Data Module, Form or a Frame) into a RTC Linked Object, capable of communicating directly with its counterpart instance on the remote side (Client communicates with the Server and vice-versa). This is the easiest way to implement Linked Objects.


Makes it possible to use a Pascal-like scripting language from within HTML and/or XML files. When using the RTC Scripting Engine, you can decide for yourself how much of your application code you want to have in form of Delphi functions, compiled inside your Server or ISAPI extension, and how much you want to have in form of scripts inside your HTML/XML files. This allows you to combine the power of compiled Delphi code (access to everything Delphi has to offer), with the flexibility of a Pascal-style scripting language (deploy updates on-the-fly).

Selection of Client-side RealThinClient SDK components


This is the component that will be responsible for direct communication with your servers when using the HTTP or HTTPS protocol. It sends requests prepared by higher-level client-side RTC components like RtcDataRequest and RtcClientModule, then accepts responses and uses the same higher-level components to process those responses.


This is the component which you can use to integrate your higher-level Client-side components (like RtcDataRequest and RtcClientModule) into third-party transport layers. For example, by using the included NexusDB plugin, you can call RTC remote functions integrated in your NexusDB Server.


Very useful when you have a number of Data Request or Client Module components spread across units, because it groups related client request components and links them to their Data Client connection. If you only have one or two data request components, you can link them directly to Data Client connection component, without the need of a RtcDataClientLink.


Use to create a small pool of client connections, allowing the component to decide which connection to use when posting a request, depending on the number of currently pending requests on available connections. A new request will be posted through the connection with the lowest number of pending/active requests, unless you explicitly specify a different connection object.


Client-side counterpart to RtcDataProvider. It enables the client to post requests to a RTC Server or any other HTTP Server. Using this component, you can request files from any Web Server, post JSON and XML requests to any Web Service, execute Server-side scripts, etc. Everything any HTTP Server is providing, you can request by using this component.


Client-side counterpart to RtcServerModule. It enables the client to call functions provided by the Server through one of its Server Modules. RtcClientModule has no events which would have to be implemented, you just link a RtcClientModule to a Client connection component (RtcHttpClient) and you can call remote functions.

If you define client-side functions and link them to this RtcClientModule, this will be the execution point of those client-side remote functions. No special implementation needed. Client-side remote functions are functions which server can call on the client-side as a result of client’s calls to a server-side function.


Process results received from remote function call(s). Using the “OnResult” event, which receives the connection (Sender:TRtcConnection), parameters sent (Param:TRtcValue) and the result received (Result:TRtcValue), you can easily write the code to process the result. Maybe only do a simple check if function executed successfully, or show a message dialog, or create a separate form containing all data received, or fill received content into other component on the same form or data module (for example, fill ClientDataSet with records from a database).


RtcMemDataSet is a fast and light-weight in-memory TDataSet descendant (works with all DB-aware components) which uses a TRtcDataSet object for data storage, so you don’t have to copy TRtcDataSet data to another in-memory DataSet to display its contents in a DB-aware component. It is compatible with all Desktop platforms (Win32, Win64 and MacOSX). For similar functionality on Mobile platforms, you can use the new RtcClientDataSet component, or the RtcDataSetMonitor component together with any TDataSet descendant (see below for more details).


Connect any TDataSet descendant to a RtcDataSetMonitor, set its “Active”property to TRUE and all changes made to the assigned TDataSet will be monitored and recorded by RtcDataSetMonitor. The “OnDataChange” event will get you notified when changes were made to the DataSet, after which you can use the “ExtractChanges” method to get an object containing all changes made to the DataSet since the last extraction, in a transport-ready form, so you can use it immediately as a parameter in your next remote function call to send it to the Server. This component eliminates the need to glue yourself to one specific in-memory DataSet on the Client and allows you to pick the best component for each job, without having to worry about incompatibility with your Server. The same Format used by RtcDataSetMonito is also 100% compatible with the light-weight RtcMemDataSet component, as well as the new RtcClientDataSet component, so you can easily mix-and-match components on the Client-side to best meet your Project requirements.