# QuickLib: a flat library of Pascal units for Delphi and Free Pascal

> QuickLib is a collection of Delphi and Free Pascal units that fills in the everyday gaps in application development, with AutoMapper, a Linq style query layer, an IOC container, a memory cache, configuration, serialisation and scheduling. The units sit directly in the repository root and the suite claims 917 passing DUnitX tests.

**exilon/QuickLib** — Quick development library (AutoMapper, LinQ, IOC Dependency Injection, MemoryCache, Scheduled tasks, Json and Yml Config and Options pattern, Serializers, etc) with crossplatform support for Delphi/Firemonkey (Windows,Linux,OSX/IOS/Android) and freepascal (Windows/Linux).

- Repository: https://github.com/exilon/QuickLib
- Stars: 715 · Forks: 198
- Language: Pascal
- License: Apache-2.0
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/exilon-quicklib

## One unit per concern, sitting in the repository root

QuickLib is described as a Delphi and Firemonkey library for Windows, Linux, Android, macOS and iOS, and a Free Pascal library for Windows and Linux, containing functions that are quick to implement and created to simplify application development and improve productivity. The supported compiler range runs from Delphi XE8 through Delphi 13 Florence, with RAD Studio 13 Florence and 12 Athens both listed as recent additions to the updates list.

The packaging is unusual and worth knowing before anything else. There is no src directory and no package structure. The top level of the repository is the library itself, with one file per unit: Quick.Commons.pas, Quick.Console.pas, Quick.Log.pas, Quick.AutoMapper.pas, Quick.Linq.pas, Quick.IOC.pas, Quick.MemoryCache.pas and the rest, each Pascal file named after the unit it provides. There is a matching Delphinus.Info.json and Delphinus.Install.json so the package managers know what to install, and the samples directory is split into samples/delphi, samples/firemonkey and samples/fpc.

For a Delphi developer, that flat layout is the point. You can copy the two or three units you need into your project, or reference the whole folder, without adopting a package dependency and its version policy. The trade is that a flat root with dozens of files gives you no module boundaries, so you have to know which units you want rather than what to depend on.

## The unit list is the API: mapping, querying, injection and caching

The functionality list in the README is organised by area, and the areas cover most of what a business application ends up writing by hand.

Mapping is Quick.AutoMapper, which maps fields from one class to another and allows custom mappings to match different fields, with custom mapping procedures to cast or convert fields manually. The updates list records a custom mapping path namespaces style and the mapping procedures themselves. Quick.JsonRecord is the companion for DTO style classes, with JSON serialisation and mapping functions included.

Querying is Quick.Linq, which makes Linq queries over any TObjectList, TList, TArray and TXArray, performing Select with complex Where clauses in SQL-like syntax, plus update and order over the list. Quick.Collections adds IList and IObjectList with the Linq behaviour inherited, and Quick.Lists and Quick.Arrays are the improved list and array types underneath.

Then there is Quick.IOC.pas for dependency injection, Quick.MemoryCache.pas for caching objects or information with an expiration time and optional object compression, and Quick.Pooling for object pools to avoid resource exhaustion and overhead.

The rest of the list is wide rather than deep: Quick.Chrono for chronometers and benchmarks, Quick.Threads for thread safe classes, scheduling and background tasks with retry policies, Quick.FileMonitor for file change events, Quick.SMTP for email, Quick.Azure and Quick.Amazon for blob storage, Quick.Conditions for fluent pre and post condition validation, Quick.Expression for evaluating object properties with expressions, and Quick.Template for string templating with dictionaries or delegates.

## Configuration as an object, and serialisers that depend on RTTI

Configuration is handled by three units that share a base: Quick.Config.Json, Quick.Config.YAML and Quick.Config.Registry. The README describes the goal as loading and saving a config as a JSON or YAML file or as Windows Registry keys and managing it as an object, and the updates list records a YAML provider, an options file setting with sections, and a JSON config that reloads when the config file changes.

Serialisation follows the same object model. Quick.Json.Serializer and Quick.YAML.Serializer convert objects to and from JSON and YAML text, and the units documentation includes the caveat that you can define whether public or published members are processed, adding that only Delphi is supported there and that the Free Pascal RTTI only supports published properties. That is a real constraint rather than a footnote, because a property that is not published in Free Pascal will simply not appear in the serialised output.

Quick.JsonUtils and Quick.JSON.Helper add utilities for working with JSON objects, and Quick.Crypto, Quick.Compression and Quick.Base64 cover the encoding chores. There is also a data interchange layer, Quick.Data, with providers for custom data, InfluxDB and Redis, and an HTTP stack in Quick.HttpClient and Quick.HttpServer with request, response and types units, where the updates list mentions custom and dynamic error pages.

The design idea running through all of it is that a Delphi developer should not have to write a YAML parser, a mapper, a cache with expiry or a scheduler for every project, and should instead take these units as given.

## A DUnitX suite of 917 tests, runnable from RAD Studio

QuickLib includes what the README calls a comprehensive DUnitX test suite covering all major units, located in the test folder and compiled and run with RAD Studio. The result block in the README is the one number worth reading:

```
Tests Found:   917
Tests Passed:  917
Tests Failed:  0
Tests Errored: 0
```

Running it is a RAD Studio operation, either by opening test/QuickLib.dproj and building and running, or from the command line. The command line form the README gives is:

```bat
msbuild test\QuickLib.dproj /p:Config=Debug /p:Platform=Win64 /p:DCC_Define=CONSOLE_TESTRUNNER
test\Win64\Debug\QuickLib.exe
```

The CONSOLE_TESTRUNNER define is what turns the test run into a console application, which is the part that matters for continuous integration, because a DUnitX run that only works inside the IDE is not something you can wire into a pipeline. The built binary is then run from the Win64 Debug output directory.

Two caveats. The command line path is Windows and Win64 specific, so the suite as documented does not cover the Linux, macOS or mobile targets the library claims to support. And the counts in the README are the author's own reported run, not something the repository enforces, so treat them as a statement of intent rather than a guarantee for your own checkout.

## Installing through GetIt, Delphinus, or a plain clone

There are two documented installation routes. The first is the package managers, and the instruction is short: search for QuickLib on Delphinus or the GetIt package managers and click Install. The updates list also records that QuickLib is now included in the RAD Studio GetIt package manager, and the Delphinus.Info.json and Delphinus.Install.json files at the repository root are the metadata those tools consume.

The second route is from GitHub, and the README simply says to clone the repository. Because the units live at the root, that clone is the library, and adding the path to your project search path is the installation.

What is missing is any statement about versions. The repository publishes no GitHub releases, so there is no tag to pin to and no packaged archive to download. The releases line in the project listing is empty, and the default branch is master.

That has two consequences for a team. First, the GetIt and Delphinus packages are versioned independently of the repository, and the README does not document which upstream commit any given package build corresponds to, so upgrading through the package manager is not something you can audit from the documentation. Second, for CI or for several developers on a team, everyone has to be on the same commit of a flat unit folder, and there is nothing in the project that enforces that.

For a single developer experimenting with the library, the clone is fine. For a shared codebase, pinning is the first thing to add.

## Cross platform in name, Windows bound in parts

The platform story needs reading carefully, because the library is advertised as cross platform while several of its units cannot be. Quick.Process manages Windows processes and Quick.Services manages Windows services, so those two units are inherently tied to one operating system. Quick.Config.Registry stores configuration in Windows Registry keys, and Quick.Console writes coloured log messages to a console, which is meaningful on Linux and macOS but behaves differently there.

The genuinely portable parts are the ones that matter most for cross platform work: the mapper, the query layer, the cache, the JSON and YAML serialisers, the templating, the conditions, the expression evaluation, the threading and scheduling units, and the network and URL helpers. The updates list also records a Delphi Linux compatibility item, which suggests the porting work was incremental rather than complete.

The cloud units are provider specific but not platform specific, with Quick.Azure and Quick.Amazon covering blob interaction with Azure and Amazon Cloud Storage, and Quick.OAuth plus Quick.OAuth.Utils for token handling.

Two other things about the project's posture are worth recording. It accepts donations through a PayPal button and a star request in the README, which is normal for a solo maintained library. And the licence is Apache-2.0, with the licence text in LICENSE.txt, which is a permissive licence with the notice requirement and the patent grant, and a slightly heavier one to comply with than MIT.

## Conclusion

Adopt QuickLib when you are writing Delphi or Free Pascal code and want a mapper, a query layer, a cache, a config object and a scheduler without assembling a dozen separate packages, and your team is comfortable with a flat folder of units rather than a package graph. Do not adopt it if you need a maintained, versioned dependency with a published release history, because the repository publishes no GitHub releases and tracks a moving master branch. Verify first that the compiler range covers yours, from Delphi XE8 through Delphi 13 Florence, that the parts you want are cross platform rather than Windows only, since units such as Quick.Process, Quick.Services and Quick.Config.Registry are inherently platform bound, and that the DUnitX suite in test/QuickLib.dproj runs green on your machine before you rely on it.

## FAQ

### What is QuickLib and which compilers does it support?

QuickLib is a Delphi and Firemonkey library for Windows, Linux, Android, macOS and iOS, and a Free Pascal library for Windows and Linux. The supported compilers run from Delphi XE8 through Delphi 13 Florence, with RAD Studio 13 Florence and 12 Athens both listed as recent additions.

### How do I install QuickLib?

Search for QuickLib on the Delphinus or GetIt package managers and click Install, or clone the GitHub repository and add it to your project search path, since the units sit directly in the repository root. The repository publishes no GitHub releases, so there is no tagged version to pin to.

### How do I run the QuickLib test suite?

Open test/QuickLib.dproj in RAD Studio, build and run, or compile from the command line with msbuild using the DCC_Define=CONSOLE_TESTRUNNER define and then run the produced QuickLib.exe. The README reports 917 tests found and 917 passed.

### Which QuickLib units are Windows only?

Quick.Process manages Windows processes, Quick.Services manages Windows services, and Quick.Config.Registry stores configuration in Windows Registry keys. The mapper, Linq layer, cache, serialisers, threads, scheduling and templating units are the portable ones.

## Sources

- [exilon/QuickLib on GitHub](https://github.com/exilon/QuickLib)
- [Issues](https://github.com/exilon/QuickLib/issues)
- [License: Apache-2.0](https://github.com/exilon/QuickLib/blob/master/LICENSE)
- [README](https://github.com/exilon/QuickLib/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/exilon-quicklib