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 installs all source files, examples, templates and resources.

The setup builds the packages and configures the IDE for you

The setup can compile the framework packages automatically for each Delphi version you select, create the KITTOX_HOME environment variable and register the global IDE library search paths — so KIDE^x, the examples and your own projects compile out of the box, with no manual step. If you clone from Git instead, you do these steps by hand.

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
• Compiles the framework packages (Core + Enterprise + IDE) for every selected Delphi version, for Win32 and Win64
• Creates the KITTOX_HOME environment variable pointing at the install folder
• Registers the global library search paths in each Delphi IDE (Win32 and Win64):

$(KITTOX_HOME)\Lib\D13\Win32
$(KITTOX_HOME)\Source\EF
$(KITTOX_HOME)\Source\ThirdParty
$(KITTOX_HOME)\Source\ThirdParty\MarkdownProcessor\source
$(KITTOX_HOME)\Source

Fast link vs. debugging the framework sources

The first entry — $(KITTOX_HOME)\Lib\D{ver}\Win32 (or \Win64) — points at the pre-compiled DCUs, so your projects link fast. If you want to step into and debug the Kitto^x sources, remove that first entry from the IDE library path: Delphi will then compile the framework from source.

The Material Design icons survive an uninstall

The setup ships the full Material Design icon set (~2100 SVGs across 5 styles) and extracts it into Home\Resources\icons — a slow, one-time step. To avoid re-extracting it on every update, the uninstaller deliberately keeps that folder: a later reinstall in the same location reuses the existing icons, and re-extracts only when the icon-package version actually changes.

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

This is a manual step for the Git-clone path — a clone gives you sources only, so you compile the packages yourself, once per Delphi version. (The setup installer already does all of this for you.)

The packages are optional — Kitto^x has no visual components

Kitto^x is a source-based, YAML-driven framework: it ships no design-time visual components, so there is nothing to drop on a form or register on the component palette. Your app compiles the framework units directly from source (via the library search path), so you can develop Kitto^x applications without building or installing any package at all.

Building the packages only enables the KittoXIDE design-time package, which adds two IDE conveniences:

1. the New Project Wizard under File → New → Other → KittoX Projects;
2. syntax highlighting for YAML files in the Delphi code editor.

KittoXCore / KittoXEnterprise are built mainly because KittoXIDE requires KittoXCore; at runtime your app links the framework statically from source, not from the BPLs.

Always drive the build from the group project Kitto.groupproj in Packages/D13/ (or D10_4, D11, D12): it lists every package in the correct build order and builds them all in one shot.

Open Kitto.groupproj and build the projects in this order (the group already does it for you):

1. 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 the design-time package (optional):

Package	Description
KittoXIDE.dproj	The two IDE conveniences only — New Project Wizard + YAML syntax highlighting. No components

Build for Win32 only (IDE packages are always 32-bit for Delphi up to 12). Right-click and Install to register the wizard and the YAML highlighter in the Delphi IDE. Skip this step if you don't want those two conveniences — it is not required to build or run Kitto^x applications.

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.

Set KITTOX_HOME and the global library path

This is the manual counterpart of what the setup does for you — after a Git clone, do it once:

1. Create a KITTOX_HOME environment variable pointing at the clone root (the folder that contains Source\), e.g. D:\Dev\KittoX.
2. Add the following entries to the Delphi Library Path (Tools → Options → Language → Delphi → Library → Library Path), for both Win32 and Win64:

$(KITTOX_HOME)\Lib\D13\Win32
$(KITTOX_HOME)\Source\EF
$(KITTOX_HOME)\Source\ThirdParty
$(KITTOX_HOME)\Source\ThirdParty\MarkdownProcessor\source
$(KITTOX_HOME)\Source

Fast link vs. debugging the framework sources

The first entry points at the pre-compiled DCUs produced when you built the packages, so your projects link fast. It is platform-specific — use \Lib\D{ver}\Win32 on the Win32 library path and \Lib\D{ver}\Win64 on the Win64 one. Remove that first entry if you want Delphi to compile from source so you can step into and debug the Kitto^x framework.

Example projects

The example projects already carry their own search paths, so they compile without touching the global library path — which 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