How to Install KittoX

Supported Delphi versions and editions

Kitto^x compiles and runs on Delphi 10.4 Sydney and later — the framework ships ready-made packages and example projects for 10.4, 11, 12 and 13 (framework package folders Packages/D10_4, D11, D12, D13). A single codebase targets both Win32 and Win64 for your application; only the framework design-time package bitness depends on the IDE (32-bit up to Delphi 11, 64-bit-capable from Delphi 12 — see the note below).

Any edition — Professional included

Kitto^x works with every Delphi edition, Delphi Professional included. The framework itself uses no Enterprise-only feature; the only thing to plan is how you reach a client/server database:

• Delphi Enterprise / Architect bundle the FireDAC and dbExpress client/server drivers (SQL Server, Oracle, PostgreSQL, MySQL, remote Firebird…). On these editions you connect out of the box with the built-in EF.DB.FD (FireDAC) or EF.DB.DBX (dbExpress) adapters — no extra component required.
• Delphi Professional ships FireDAC/dbExpress with local/embedded drivers only (SQLite, InterBase ToGo). To reach a client/server DBMS on Professional you use a third-party data-access provider, and Kitto^x already supports one: ODAC (Devart Oracle Data Access Components) through the EF.DB.ODAC adapter (ClassId ODAC). It gives full client/server Oracle access on any edition, Professional included — just reference the unit in UseKitto.pas and add an ODAC connection block. Other Devart DAC products (SDAC for SQL Server, PgDAC for PostgreSQL, …) follow the same adapter pattern and can be integrated the same way.

In short: Delphi Professional + a third-party DAC such as ODAC = full client/server Kitto^x, with no Enterprise licence required. See Configuring the Databases for the connection blocks and adapter selection.

There are two ways to install Kitto^x into your Delphi environment:

Option 1: Setup Installer (recommended)

The setup installer provides the fastest way to get started. It includes the KIDE^x visual IDE (Enterprise edition) and handles all compilation and configuration automatically.

Download

Download the latest setup from GitHub:

Download KittoXSetup.exe

What the setup does

Running the setup you can:

• Choose the installation folder
• Choose the module to install
• Install KIDE and acquire a Trial license

The setup automatically:

• Installs all Kitto^x source files, resources, templates, and examples
• Installs KIDE^x — the visual IDE for designing Kitto^x applications

KIDE^x trial license

KIDE^x is part of the Enterprise Edition. The setup installs a trial version that works for 90 days. To request a trial license key, contact Ethea S.r.l. after installation, using the License Form:

After the trial period, KIDE^x requires a commercial license. The Kitto^x framework itself (Core + Enterprise modules) remains fully functional without KIDE^x.

After installation

Once installed, you can:

1. Open the KIDE^x IDE to create a new project or explore the examples
2. Open one of the example projects directly in Delphi (see below)
3. Start developing your own application using UseKitto.pas and YAML metadata

Option 2: Git Clone (manual installation)

If you prefer to work directly with the source repository, clone from GitHub and compile manually.

Clone the repository

git clone https://github.com/EtheaDev/KittoX.git

Repository structure

KittoX/
  Source/                    # Framework source code
    EF/                      # Entity Framework layer
    ThirdParty/              # Third-party libraries
  Home/                      # System Home (shared resources, templates)
  Packages/                  # Delphi framework packages (D10_4, D11, D12, D13)
  Examples/
    HelloKitto/              # Simple example
    TasKitto/                # Activity tracking example
    KEmployee/               # Employee management example

Compile the packages

Open the group project for your Delphi version from Packages/D12/ (or D10_4, D11, D13):

1. Build runtime packages:

Package	Description
KittoXCore.dproj	Core framework (Apache 2.0)
KittoXEnterprise.dproj	Enterprise modules — Chart, Calendar, Map, Dashboard (AGPL-3.0 / Commercial)

Build both for Win32 and Win64 platforms in Release configuration.

2. Build and install design-time package:

Package	Description
KittoXIDE.dproj	IDE integration (property editors, component registration)

Build for Win32 only (IDE packages are always 32-bit for Delphi up to 12). Right-click and Install to register in the Delphi IDE.

Group project

The file Kitto.groupproj in the same folder contains all three packages. Open it to build everything at once.

Build packages from the command line (PowerShell)

The framework ships a set of PowerShell scripts in Packages/ that rebuild all the packages (KittoXCore + KittoXEnterprise) for a given Delphi version with a single invocation. Useful when you want to verify the framework still compiles after a svn update, before opening the IDE, or as part of a CI smoke test.

Wrapper	Delphi	Default platforms	IDE bitness
BuildAllPackagesD10_4.ps1	10.4 (BDS 21.0)	Win32 only	32-bit
BuildAllPackagesD11.ps1	11 (BDS 22.0)	Win32 only	32-bit
BuildAllPackagesD12.ps1	12 (BDS 23.0)	Win32 + Win64	64-bit native
BuildAllPackagesD13.ps1	13 (BDS 37.0)	Win32 + Win64	64-bit native

Why D10.4 and D11 stop at Win32: their IDE is a 32-bit application that can only load Win32 design-time BPLs. Win64 design-time was introduced with the 64-bit IDE in D12. Your application's own .dproj of course can still target Win64 — only the framework design-time package is forced to Win32.

Close the Delphi IDE first

The shared Bpl folder under C:\Users\Public\Documents\Embarcadero\Studio\ is locked while the IDE has a design-time package loaded. Close the IDE before running the rebuild scripts, otherwise the Win32 build of KittoXCore will fail with error F2039: Could not create output file '...\KittoXCore370.bpl'.

Examples (run from Packages/):

# Default — Rebuild Release on every valid platform for D13:
.\BuildAllPackagesD13.ps1

# Incremental Build on Win64 only:
.\BuildAllPackagesD13.ps1 -Platform Win64 -Target Build

# Debug Rebuild for D11 (Win32 only — implicit):
.\BuildAllPackagesD11.ps1 -Config Debug

# Override BDS root if your install is non-standard:
.\BuildAllPackagesD12.ps1 -BDSRoot "D:\Embarcadero\Studio"

Each wrapper prints a summary table at the end with package, platform, status and elapsed seconds for every (package × platform) combination it ran. Full per-version logs are saved to Packages/_buildlogs/<version>.log.

The wrappers delegate to the lower-level Packages/BuildPackages.ps1, which can also be invoked directly when you need finer control over a single (-Project, -Platform, -Config, -Target) combination.

Configure environment paths

Add the following paths to your Delphi Library Path (Tools → Options → Language → Delphi → Library → Library Path) for both Win32 and Win64:

<installdir>\Source
<installdir>\Source\EF
<installdir>\Source\ThirdParty

Alternatively, set the KITTOX environment variable to the installation folder and use:

$(KITTOX)\Source
$(KITTOX)\Source\EF
$(KITTOX)\Source\ThirdParty

Example projects

The example projects already have relative search paths configured, so they compile without modifying the environment. The library path is only needed for your own projects.

Compile and run an example

Each example has four deployment projects in its Projects/ directory:

Project	Mode
HelloKitto.dpr	Standalone (GUI / Windows Service)
HelloKittoDesktop.dpr	Desktop Embedded (WebView2)
HelloKittoISAPI.dpr	ISAPI DLL for IIS
mod_hellokitto.dpr	Apache module

To get started quickly:

1. Open Examples/HelloKitto/Projects/HelloKitto.dpr in Delphi
2. Set the target platform to Win64
3. Build and Run
4. The application starts an HTTP server on the port configured in Config.yaml (default 3621)
5. Open http://localhost:3621/hellokittox/ in a browser
6. Log in with the default credentials (see Config.yaml → Auth/.Defaults)

See the HelloKitto, TasKitto, and KEmployee pages for details on each example, and the Deployment guide for IIS and Apache setup.

Build examples from the command line

A build script is provided to compile all examples (or a selection) in all deployment modes without opening the Delphi IDE.

Run from the Examples/ directory:

cd Examples
build_Examples.cmd

The script will:

1. Ask for the Delphi BDS path (default: C:\BDS\Studio\37.0). It initializes the compiler environment using rsvars.bat from the BDS installation — no manual environment variables needed.

2. Ask which examples to build:

   • All (HelloKitto + TasKitto + KEmployee)
   • A single example by name

3. Ask which deployment modes to build:

   • All (Desktop, ISAPI, Apache, Embedded)
   • Or a single mode:

   Mode	Platform	Output
   Desktop (Standalone)	Win64	Home/{AppName}.exe
   ISAPI (IIS)	Win64	Home/{AppName}ISAPI.dll
   Apache Module	Win32	Home/mod_{appname}.dll
   Windows Embedded	Win64	Home/{AppName}Desktop.exe

4. Build each selected project using msbuild in Release mode, with separate log files per build (e.g. HelloKitto_Desktop.log, TasKitto_Apache.log).

5. Report results with a summary of successes and failures. Check the .log files in each Projects/ folder for detailed build output.

Apache module requires Win32

Apache modules must be compiled for the same bitness as the Apache server. Most Apache 2.4 installations on Windows are 32-bit, so the build script uses Win32 for Apache modules. If your Apache is 64-bit, change the platform in the script or compile manually.

Next steps

• Getting Started — create your first application
• Basic Concepts — YAML metadata, models, views
• Deployment — standalone, IIS, Apache, desktop embedded
• Kitto^x Enterprise — KIDE^x IDE, charts, calendar, dashboard