At the heart of Alcinoe is a belief in empowering developers to create fast, modern, and seamless applications without the typical bottlenecks of complexity or performance limitations. We believe that development should be focused on innovation, not fighting against the constraints of your tools. Alcinoe is built with the philosophy that every developer deserves the best performance, the freedom to customize, and the power to deliver exceptional user experiences across platforms—all while maintaining independence from the dominance of GAFA (Google, Apple, Facebook, Amazon).
Alcinoe is fully compatible with Delphi Florence 13.0. If you find this library helpful, please consider giving it a star on GitHub. It’s free and greatly supports the project’s visibility and growth.
By joining MagicFoundation as an Associate, you'll enter a community that's actively shaping the future of Alcinoe—while unlocking a suite of exclusive perks. Associates receive priority support for bugs they submit via the issue tracker or by email, including faster triage, dedicated investigation, and ongoing updates until resolved.
The Alcinoe FireMonkey Controls Demo highlights the power and flexibility of Alcinoe's UI components. It demonstrates how to build high-performance, visually stunning, and responsive FireMonkey applications with ease, showcasing advanced features and custom styling capabilities.
This demo showcases the Alcinoe Dynamic ListBox — a high-performance, customizable list control for Delphi FireMonkey apps. Optimized for modern UIs, it supports animated, scrollable content using an on-demand data model that creates and frees items dynamically, ensuring smooth performance and low memory usage. Ideal for building rich, content-driven interfaces like social feeds, chats, or news streams.
KisKis is a dating app crafted in Delphi using the Alcinoe framework, offering a sleek, modern, and responsive platform for connecting people. Leveraging Alcinoe's advanced UI controls and optimized performance capabilities, KisKis delivers an engaging and seamless user experience, making meaningful connections more accessible and enjoyable.
Please request the resolution of these quality reports. Due to the unresolved issues from Embarcadero, we have been forced to apply patches to the original Delphi source files:
- iOS: Missing application:handleEventsForBackgroundURLSession:completionHandler: delegate in FMX
- FMX Android: Zoom gesture (TInteractiveGesture.Zoom) only fires on very fast pinches
- Enhance MouseEvent Handling by Providing Access to MotionEvent (Android) and UIEvent (iOS)
- Improve Rendering Timing by Using Choreographer Instead of Runnable
- Allow TTexture to Define a Material (GLSL Shader) to Use
- TControl.DoRemoveObject should only realign when the removed control is visible
- TControl.SetBounds: Missing ParentContentChanged Call on Size-Only Updates
- Missing ResetUpdatingState call in TCustomForm.DoRemoveObject
- Effect ProcessTexture is not working and function TFilter.InputTexture: TTexture do unecessary work
- TAndroidMotionManager does not handle AMOTION_EVENT_ACTION_CANCEL
- Add ExtractContentStream to TURLResponse / IURLResponse to allow taking ownership without copying.
- Architectural Issues in FMX.Skia.Canvas.GL
- FMX.VirtualKeyboard.Android: Unused variable and unnecessary logic in Delphi 13 update
- Project option to define where to look/create the LaunchScreen.TemplateiOS directory
- Support configuration-specific deployment templates (AndroidManifest / Info.plist / Entitlements)
- Replace Pointer-based signatures in iOS/macOS bridges with strongly typed wrappers
- Performance Issue - Comparing Equality Between Two Strings
- Allow linking of Swift compatibility frameworks
- need to uncomment _GetAUDIO_ATTRIBUTES_DEFAULT from JNotificationClass
- Resolve Circular Reference in JBitmapClass by Refactoring JHardwareBuffer Declaration
- Update Pressed Property Setter in TControl to Enhance State Change Tracking
- Add Additional Notification Icon Sizes for iOS 16+
- ForceQueue with Delay Does Not Work on Android
- AndroidManifest merge in Delphi does not respect tools:node="remove" directive for uses-permission
- Uncomment missing init overloads in JCipher to enable standard Android Crypto API usage
- FMX: TAlignLayout.TopLeft ignores Margins on child control
- iOS: UNNotificationPresentationOptionNone removed from iOSapi.UserNotifications in Delphi 13
- CVOpenGLESTextureCacheCreate expects raw Obj-C pointer for eaglContext
- macOS: Align NSTextField.setDelegate signature with other AppKit setters
- UIViewAutoresizing changed from NSUInteger to NSInteger in Delphi 13
- iOS API regression: UNNotificationAttachment.attachmentWithIdentifier returns Pointer
- iOS API regression: UNNotificationRequest.requestWithIdentifier returns Pointer
- iOS: UNNotificationPresentationOptionNone removed from iOSapi.UserNotifications in Delphi 13
- Security.framework: kSec* constants return type inconsistent between macOS (NSString) and iOS (CFStringRef)
- Inconsistent NSUserDefaultsClass.standardUserDefaults return type (macOS = Pointer, iOS = NSUserDefaults)
- Foundation/NSURL: fileURLWithPath: return type inconsistent between macOS and iOS headers
- NSURL factory methods return types are inconsistent in D13
- Foundation: NSURLCredentialPersistence changed from NSUInteger to NSInteger in Delphi 13
- Foundation: NSKeyValueObservingOptions changed from NSUInteger to NSInteger in Delphi 13
- CoreText: CTParagraphStyleCreate parameter type changed to NativeUInt in D13 — should be NativeInt
- CoreText: CTParagraphStyleSpecifier widened from 32-bit to 64-bit in Delphi 13
- CGImageAlphaInfo mapped to NSInteger in Delphi 13 (was UInt32 in Delphi 12)
- CGBlendMode mapped to NSInteger in Delphi 13 (was UInt32 in Delphi 12)
- CGBitmapInfo mapped to NSInteger in Delphi 13 (was UInt32 in Delphi 12)
- UNUserNotificationCenter.setDelegate changed from UNUserNotificationCenterDelegate to Pointer
- macOS/iOS: Inconsistent CIFilterClass.filterWithName return type (macOS = Pointer, iOS = CIFilter)
- macOS/iOS: Inconsistent NSNumberClass.numberWithFloat return type (macOS = Pointer, iOS = NSNumber)
- macOS/iOS: Inconsistent CIContextClass.contextWithOptions return type (macOS = Pointer, iOS = CIContext)
- macOS/iOS: Inconsistent CIImageClass.imageWithCGImage return type (macOS = Pointer, iOS = CIImage)
- Missing Functions in Macapi.QuartzCore.pas
- macOS: Add missing NSTextField APIs (delegate getter/setter + placeholder getters/setter)
- iOS vs macOS mismatch in CGImageDestinationFinalize declaration (Boolean vs Integer return type)
- Delphi language enhancement: allow multiple inline variant parts inside records (not only trailing)
To set up Alcinoe, start by running the CompileAll.bat script. This batch file performs a series of tasks, including retrieving and patching the original Delphi source code, downloading the necessary iOS/Android libraries, generating the Alcinoe JAR files, building the BPL (Borland Package Library), compiling the tools in the Tools directory, and finally compiling all demos found in the Demos directory. Please note that some demos require components from devexpress.
If you only need to use Alcinoe's non-visual components, no further steps are necessary. Simply ensure that Source is included in your project's search path.
To use Alcinoe's visual components at design time, you will need to install the BPL. Open Delphi, go to Component > Install Packages..., and select the BPL from Libraries\bpl\Alcinoe. Additionally, include both Source and all subdirectories from Embarcadero\Florence in your search path.
From time to time, we may need to rename units, classes, and functions in Alcinoe. To help you automatically update these names in your project and stay aligned with the latest version of Alcinoe, we provide a tool called CodeRenaming. You can find this tool here: CodeRenaming
If you'd like to suggest changes to the Alcinoe directory, please follow these steps:
-
Fork the Alcinoe Repository: First, you'll need to fork the repository. Forking creates a personal copy of the Alcinoe source code that you can modify as needed..
-
Make Your Edits: After forking, make the necessary changes to the source code. Then, commit and push these changes to your forked repository.
-
Submit a Pull Request: Once you're happy with your changes, go to your forked repository, click on 'Contribute,' and select 'Open a pull request' to submit your proposal.
Skia is an open-source 2D graphics library that powers the graphics engine used by Flutter and the Android operating system. The implementation of Skia in Delphi marked a significant advancement for the FireMonkey framework, as it greatly surpasses the legacy Delphi TCanvasGPU graphics engine in nearly every aspect.
- Solid Graphics Foundation: Since Skia is the same graphics engine used by Flutter, apps built with Flutter or Delphi + Skia share the same foundational graphics technology.
- Performance: The Skia algorithms are optimized to the extent that they can often render directly onto the form surface without requiring an internal buffer.
- Cross-Platform Consistency: Skia offers a consistent graphics engine across all platforms (Windows, iOS, macOS, Android).
- Rich Features: Skia provides powerful capabilities typical of a robust graphics engine, including advanced text formatting and shadow rendering.
- Increased Package Size: Adding Skia increases the package size by approximately 25 MB.
- Dependency on Google: Skia is a Google product, and while Embarcadero has traditionally focused on offering an independent product free from GAFA domination, using Skia introduces a dependency on Google's technology.
- OpenGL Limitations: Under OpenGL, only raster images (CPU) can be shared across different threads. This means that GPU textures cannot be created in background threads and later drawn on the main form surface. Interestingly, there seems to be no noticeable speed improvement when drawing GPU images compared to raster images.
- Image Rendering Performance: While Skia excels at drawing shapes directly on the form surface, it is notably slower (4x more slower) than the legacy Delphi canvas (TCanvasGPU) when rendering images onto the form.
The slower image rendering is particularly problematic in scenarios where we paint everything first onto an internal buffer and then render that buffer to the form surface on each paint loop—a technique often used to avoid flickering and improve performance. Unfortunately, Skia can be up to 4 times slower at drawing images onto the form surface compared to the legacy Delphi TCanvasGPU, which uses OpenGL textures.
For example, on a Google Pixel 7, I can render 2000 textures simultaneously at 90 FPS using TCanvasGPU. However, with Skia, I can only render 500 images at the same frame rate. You can verify this using the demo app located at Demos/ALFmxGraphics.
Given these limitations, I’ve decided to use Skia as the backend graphics engine in Alcinoe while continuing to use the legacy Delphi canvas (TCanvasGPU) for rendering on the main form surface. The exception is on Windows, where we use Skia for both the backend and the main form surface.
On Android and iOS, the operating systems already provide
powerful graphics APIs, and in many cases, these native APIs
outperform Skia—often by as much as 2x. While the performance
of the OS graphics APIs is superior, Skia still offers the
benefit of a unified graphics engine across all platforms,
along with additional features like animated images.
In recent years, Material Design has emerged as a guiding design language for developers creating modern, user-friendly, and visually appealing applications. With the release of Material You (Material Design 3), Google has taken a step further by allowing greater personalization and a more dynamic appearance. Developers using Delphi can now leverage Material 3 principles to create stunning, cohesive interfaces across platforms like Android, iOS, Windows, and macOS.
TALButton offers full customization for states such as Enabled, Pressed, and Disabled, allowing for modern Material 3 button styles. You can adjust properties like fill, border, shadow, and font to match Material 3’s bold, clear design principles. It supports HTML content, enabling you to easily include icons or rich text.
TALToggleButton is a customizable toggle control with distinct styles for On and Off across all states — Enabled, Pressed, Focused, Hovered, and Disabled. It supports fill, border, shadow, and font customization, as well as HTML content for icons or rich text, making it ideal for interactive Material 3 components.
Both controls follow Material 3’s minimalistic and responsive design. They include customizable properties for checkmark, border, and shadow and utilize smooth transitions between states. Their highly customizable nature allows you to create checkbox and radio button components that align with Material 3’s aesthetic.
TALSwitch is designed for easy customization, allowing you to control the design of the switch in states such as Enabled, Hovered, Focused, Pressed, and Disabled. The control provides smooth, responsive transitions between on and off states, reflecting the fluid, adaptable nature of Material 3’s switches. The customizable design ensures that TALSwitch fits seamlessly into a modern, minimalistic interface, offering both visual appeal and optimized performance for Delphi applications.
TALTrackBar allows for extensive customization of its appearance and behavior, making it an ideal choice for implementing Material 3’s clean and modern slider design. You can easily customize the track and thumb with properties such as fill, stroke, and shadow to achieve the sleek, minimalistic look that defines Material 3. The slider's interactions, including value indicators and stop indicators, are smooth, ensuring responsive feedback as the user interacts with the control. Its transitions between states like Enabled, Focused, and Pressed contribute to a polished, fluid user experience.
Alcinoe’s native TALEdit and TALMemo controls are designed to match Material 3’s input fields, offering customizable border, shadow, and font properties. These controls adapt across platforms while maintaining a consistent, clean interface for text input, with features like autosizing and prompt text.
All Alcinoe controls can be easily styled using TALStyleManager. To achieve this, you simply define a custom style for each control by modifying Alcinoe.FMX.CustomStyles.pas.
In addition, the TALStyleManager makes it straightforward to implement light and dark theme variants—or any other custom theme.
The core of this flexibility lies in the fact that each Alcinoe control associates a ColorKey with every Color property. You can assign a symbolic value to this key, such as Material3.Color.Primary. Then, within TALStyleManager, you define the actual color value mapped to Material3.Color.Primary.
This design allows you to switch effortlessly between light, dark, or custom themes—ensuring both consistency and maintainability.
TALText is a robust component similar to TText, but with enhanced capabilities like basic HTML text formatting support. Despite incorporating HTML formatting, TALText delivers substantial performance improvements over TText. This is achieved through its double-buffered engine, which renders text on an internal buffer and then draws only the buffer onto the form during each paint cycle. This design ensures that TALText is extremely fast and efficient. Additionally, TALText enhances functionality by supporting mouse event handling, allowing it to detect specific HTML elements (such as span IDs and bounds) under the mouse pointer. This feature enables interactive text elements, making it ideal for applications requiring dynamic, responsive text behavior. Learn more at Demos/ALFmxControls
TALPageController is a component that manages and controls page transitions within your application, similar to Flutter's PageController. It allows you to smoothly navigate between different pages, track the current page index, and customize the behavior of scrolling animations and transitions. Learn more at Demos/ALFmxControls
Page indicators are a key element in multi-page applications, offering users a clear sense of their current location and the overall number of pages. TALPageIndicator is a lightweight component that delivers animated, customizable page indicators with a variety of effects, making it easy to integrate and ensuring smooth, visually appealing transitions throughout your interface. It comes with a set of built-in effects to animate the active dot, each of which can be customized to suit your design preferences.
| Effect | Preview |
|---|---|
| Worm |  |
| ThinWorm |  |
| JumpingDotTopView |  |
| jumpingDotSideView |  |
| Slide |  |
| Scale |  |
| LinearSwap |  |
| SpinSwap |  |
| Color |  |
TALDialog is a dialog component built for mobile applications. It provides the flexibility to display highly customizable dialogs with a modern, Material 3 design.
It uses the Builder Pattern with fluent method chaining, making the dialog creation process simple and intuitive:
TALDialog.Builder
.SetHeadlineText('Delete item')
.SetMessageText('Are you sure?')
.AddButton('Cancel', 1)
.AddButton('Delete', 2)
.SetCloseProc(...)
.Show;
Learn more at Demos/ALFmxControls
A modern loading indicator inspired by Material 3 design. Ideal for signaling that an operation is in progress, it uses subtle motion and minimal design to reassure users that the app is working, even when results aren't immediate.
Learn more at Demos/ALFmxControls
TALSheet is a flexible sheet component designed for mobile applications. It can appear from the top, bottom, left, or right edge of the screen. Following modern Material 3 design guidelines, TALSheet is perfect for presenting contextual content, navigation panels, or action menus with smooth, customizable animations.
Learn more at Demos/ALFmxControls
TALSnackbar is a lightweight, transient message bar that follows Material 3. It’s ideal for brief status updates or confirmations and can include an optional action (e.g., “UNDO”).
Learn more at Demos/ALFmxControls
ALVideoPlayer renders video onto a texture, allowing seamless integration into a Delphi form while supporting Z-ORDER, enabling controls to be placed on top of the video. In contrast, Delphi’s official video players are native video player windows overlaid on the form, which do not support Z-ORDER.
On Android, Alcinoe uses Media3 ExoPlayer, which provides advanced features such as dynamic adaptive streaming over HTTP (DASH), HLS, SmoothStreaming, and common encryption—capabilities not available in MediaPlayer. Media3 ExoPlayer is also designed to be easily customizable and extendable. On iOS, AVPlayer is used, offering similar HLS support to Media3 ExoPlayer.
Learn more at Demos/ALFmxControls
TALMediaPicker provides a unified, high-level API to select images and videos from the device library or capture new media with the camera across iOS and Android. It abstracts platform specifics (iOS PHPickerViewController/UIImagePickerController, Android ACTION_PICK_IMAGES/GET_CONTENT and camera intents), handles permission flows, and normalizes results into TMediaItem objects with URIs and media types. The component supports multiple selection, returns streams on demand (ExtractStream), and exposes clear callbacks for success, cancel, and error states—letting you integrate media workflows quickly without dealing with per-platform quirks like FileProvider URIs, picker filters, or temporary file management. Learn more at Demos/ALFmxMediaPicker
Imagine you're building a chat app: when the user taps Send, you could send the message on the main thread, but this freezes the UI and is forbidden by mobile operating systems. Another option is a background thread, however this fails when the user switches apps (incoming phone call, home button, etc.), since iOS and Android suspend or kill HTTP networking in background mode. You also have to deal with unreliable mobile connectivity (temporary loss of Wi-Fi / 4G / 5G) and manually manage retries and server unavailability.
TALHttpWorker solves all these problems. Simply enqueue the
upload using TALHttpWorker.enqueue, and you no longer need
to worry about network reliability, app switching, app termination,
or temporary server errors (HTTP 5xx, unreachable host, etc.).
TALHttpWorker handles everything automatically and posts a
TWorkResultMessage when the job is completed.
ALConfetti is a lightweight and highly efficient Delphi library designed to create visually appealing, customizable confetti falling animations. Built for performance and flexibility, it allows developers to easily adjust parameters such as speed, size, and color, ensuring seamless integration into any project. Whether it's for celebrations, notifications, or dynamic visual effects, ALConfetti delivers a smooth, high-performance animation experience. Learn more at Demos/ALFmxConfetti
An Android library, also known as an Android Archive (AAR), contains everything needed to build an app, including source files, resource files, and the manifest. Unlike JARs, AARs can include resource files in addition to compiled bytecode.
Integrating an AAR into a Delphi project can be a long and complex process, involving extracting resources, manually adding them to Delphi deployment files, compiling the R.java class, checking dependencies, and more.
With AndroidMerger, this entire process is automated in a single command line. In short, AndroidMerger will:
- Use Gradle or an internal implementation to list all dependencies.
- Download libraries and dependencies from local or central Maven repositories.
- Merge the resources of all AARs into a single directory.
- Combine the AndroidManifest files of all AARs into AndroidManifest.template.xml.
- Merge google-services.json into the project's resources.
- Create the R.jar with all resource IDs using aapt or aapt2.
- Update the project file (.dproj) to include all resources.
- Generate the Delphi native bridge file from the Java libraries.
Learn more at Tools/AndroidMerger
-
DeployMan simplifies the deployment of files and folders for iOS and Android apps, making it ideal for managing large files like third-party SDKs. Learn more at Tools/DeployMan.
-
DeployProjNormalizer enables the creation of a new deployproj file from scratch using the dproj as a reference, normalizing it by ordering nodes to facilitate comparison across different revisions with diff tools. Learn more at Tools/DeployProjNormalizer.
-
DProjNormalizer focuses on ordering nodes in a DProj file, ensuring consistency across commits and simplifying the comparison of changes. Learn more at Tools/DProjNormalizer.
Alcinoe Code Profiler is a powerful source code instrumentation profiler for Delphi, designed to help developers identify performance bottlenecks and optimize their applications across multiple platforms, including Windows, macOS, iOS, and Android.
By automatically injecting performance markers into your Delphi source code, Alcinoe Code Profiler logs execution times for each procedure call. These logs can then be analyzed using the provided graphical interface, enabling you to pinpoint inefficiencies and enhance application performance with precision.
✅ Detect performance bottlenecks with minimal effort
✅ Optimize critical code paths for better efficiency
✅ Profile applications seamlessly across all major platforms
✅ Visualize execution data in an intuitive analysis tool
Learn more at Tools/CodeProfiler
The TALAnimation component is a refined version of Delphi's foundational TAnimation object, specifically optimized for mobile platforms. Instead of relying on the traditional Timer mechanism, this component adopts platform-specific technologies, delivering a significantly improved animation experience for mobile users.
-
On Android, animations are seamlessly integrated with the Choreographer, ensuring perfect synchronization with the device’s refresh rate.
-
On iOS, the precision of DisplayLink is utilized, resulting in smooth and optimized animation rendering.
A key enhancement of TALAnimation is its support for custom interpolation algorithms, giving developers the flexibility to create unique and complex animation patterns, far beyond the traditional ease-in or ease-out sequences.
Learn more at
Demos/ALFmxAnimation
Inspired by Android's SpringForce, the TALSpringForceAnimation component brings the dynamics of physics-based animations to the Delphi platform. This component simulates the real-world behavior of objects influenced by spring mechanics, producing animations that stretch, bounce, and settle, mirroring the physical world.
Developers can fine-tune various physical properties of the spring, such as stiffness and damping ratio, allowing for a wide range of animation behaviors. This flexibility enables developers to create animations tailored to the specific nuances of different applications, offering a more realistic and engaging user experience. This version improves the flow and clarity of the description while keeping the markdown formatting
Learn more at Demos/ALFmxAnimation
TALOverScroller and TALVelocityTracker are key components of the TALScrollEngine, enhancing user interface interactions. TALOverScroller manages scrolling and flinging with smooth deceleration when users scroll past a view's edge, while TALVelocityTracker measures touch velocity to determine gesture speed and direction. Together, they provide smooth animations and intuitive feedback within the scrolling engine.
Rather than reinventing the wheel, we based the TALScrollEngine on proven Android components, translating VelocityTracker and OverScroller from Java and C++ to Delphi. This ensures a high-quality, reliable scrolling experience for Delphi developers, using trusted, efficient technologies.
Learn more at Demos/ALFmxControls
The Delphi implementation of the latest version of Firebase Cloud Messaging (FCM) using the HTTP V1 protocol enables you to send advanced push notifications, including rich media like images, to Android and iOS devices. This allows developers to deliver real-time alerts, updates, and user-specific notifications directly to mobile users, improving engagement and communication within their apps.
Learn more at
Demos\ALFmxNotificationService
The TALGeoLocationSensor component is a Delphi component that provides access to location services on iOS and Android devices. It allows developers to retrieve the device's current location and receive updates as the location changes. The component supports various location providers, including GPS, cellular network triangulation, and Wi-Fi positioning.
In addition to accessing location services, TALGeoLocationSensor automates the process of requesting user permission to use location data on both iOS and Android. It also handles scenarios where users have previously denied location access. By using this component, developers can seamlessly integrate location-based functionality into their apps without needing to manage the underlying implementation details.
Learn more at Demos\ALFmxGeoLocationSensor
Google APIs utilize the OAuth 2.0 protocol for authentication and authorization. The function ALGenerateGoogleOAuth2AccessToken allows you to easily generate an OAuth 2.0 access token, which can be used to securely access Google services and APIs within your Delphi applications.
Learn more at Source/Alcinoe.Cipher.pas
The VKontakte/Facebook SDK for Android and iOS allows users to sign into your app using their VKontakte or Facebook credentials. Once logged in, users can grant permissions to your app, enabling you to retrieve information or perform actions on VKontakte/Facebook on their behalf.
Learn more at Demos\ALFmxFacebookLogin
With TALColorAdjustEffect, you can effortlessly apply stunning photo filters to enhance your images with just a single tap. Transform your photos into beautiful and expressive works of art in minutes!
Learn more at Demos\ALFmxFilterEffects
Designed for robust and secure HTTP communication, TALWinHttpClient is a Delphi
HTTP client component built directly on top of the native WinHTTP API provided
by Windows. By relying on the operating system’s integrated networking and security
stack, it delivers production-grade reliability, performance, and compatibility
without requiring any external libraries or additional DLLs to be deployed.
TALWinHttpClient supports modern web standards with HTTP/1.1, HTTP/2, and HTTP/3
(where supported by the underlying Windows WinHTTP stack), along with secure
communication via TLS 1.2 and TLS 1.3, automatically negotiating the best
protocol versions and cipher suites supported by both client and server according
to Windows security policy. It transparently handles connection management,
redirects, proxies, authentication, and secure transports, making it well suited
for REST APIs, RPC services, and high-reliability HTTP integrations that require
native Windows behavior and long-term maintainability.
Learn more at Demos\ALWinHTTPClient
TALHttpSysServer is a high-performance HTTP server component for Delphi that runs directly on top of http.sys, the kernel-mode HTTP stack built into Windows. By leveraging the same foundation that powers IIS, it delivers production-grade performance, scalability, and security without requiring an external web server. With TALHttpSysServer, you can build lightweight yet powerful REST APIs, RPC services, or custom HTTP applications while letting the Windows kernel handle the heavy lifting.
Advantages of using http.sys:
- Kernel-mode HTTP stack → runs directly inside Windows networking core, giving you IIS-level performance, stability, and security without needing a heavyweight web server.
- Port sharing → multiple apps can listen on the same port with different URL prefixes.
- I/O Completion Ports → your thread only spends time building the response. Receiving requests and sending responses (even to very slow clients) is handled in the kernel, so your thread never blocks. Concretely, this means a single thread can handle thousands of simultaneous connections.
- TLS/SSL handled in kernel → you don’t manage OpenSSL/Schannel yourself
- Modern protocols → supports HTTP/1.1, HTTP/2, and HTTP/3 (QUIC) out of the box.
- Automatic timeout handling → idle, header, and entity-body timeouts enforced by kernel.
- Kernel-mode response caching → frequently requested responses can be cached directly in kernel space, bypassing user-mode, which reduces latency and CPU usage.
- Kernel-managed W3C logging → http.sys writes W3C logs for you and handles file rotation and I/O off the request path, so your app avoids blocking.
- Quality of Service (QoS) → bandwidth throttling and connection limits built in.
- Widely tested → same engine IIS uses under the hood
Learn more at Demos\ALHttpServer
TAlSChannelTlsClient is a high-performance TLS socket client component for
Delphi that runs directly on top of the Windows SChannel security package,
the native TLS/SSL implementation built into the Windows operating system.
By leveraging the same kernel-integrated cryptographic stack used by Windows,
IIS, WinHTTP, and .NET, it provides production-grade security, compatibility,
and performance without requiring any external libraries or DLLs, with no
external dependencies such as OpenSSL or third-party components and no
redistribution or licensing concerns.
TAlSChannelTlsClient transparently upgrades an existing TCP socket to TLS
and handles encryption, decryption, handshake, renegotiation, and shutdown
entirely through the Windows SSPI/SChannel APIs. It supports TLS 1.2 and
TLS 1.3, automatically negotiating the best protocol version supported by
both client and server in accordance with Windows security policy, and is
designed for building robust SMTP, HTTPS, WebSocket, or custom protocol
clients where full control over the transport layer is required.
Learn more at Demos\ALTSLClient
Designed for reliable and secure email delivery, TALSMTPClient is a Delphi
SMTP client component that sends messages directly over the SMTP protocol
while leveraging the native Windows TLS stack for transport security. By
relying on the operating system’s integrated security infrastructure, it
provides production-grade reliability, security, and compatibility without
requiring any external libraries or additional DLLs to be deployed.
TALSMTPClient supports modern email security requirements with full
TLS 1.2 and TLS 1.3 support, automatically negotiating the best protocol
version supported by both client and server in accordance with Windows
security policy. It works seamlessly with the Multipart Alternative and
Multipart Mixed encoders, enabling the creation of emails with plain-text
and HTML alternatives as well as file attachments, while giving developers
full control over the SMTP session and message composition.
Learn more at Demos\ALSMTPClient
TALJSONDocument is a Delphi parser and writer for both JSON and BSON data formats. It supports both DOM and SAX parsers (although a more appropriate name for SAX could be SAJ—Simple API for JSON—rather than Simple API for XML, the well-known SAX terminology is retained).
In addition to its JSON capabilities, TALJSONDocument also supports the BSON format, using a syntax similar to TALXMLDocument/TXMLDocument. It can further export JSON/BSON data to TALStringList, making it a flexible tool for data parsing and manipulation in Delphi applications.
Example :
{
_id: 1, // comments
name: { first: "John", last: "Backus" },
birth: new Date('1999-10-21T21:04:54.234Z'),
contribs: [ "Fortran", "ALGOL", "Backus-Naur Form", "FP" ],
awards: [
{ award: "National Medal of Science",
year: 1975,
by: "National Science Foundation" },
{ award: "Turing Award",
year: 1977,
by: "ACM" }
],
spouse: "",
address: {},
phones: []
}
To access the document nodes :
MyJsonDoc.GetChildNodeValueInt32('_id', 0{default if node not exists});
MyJsonDoc.GetChildNodeValueText(['name','first'], ''{default if node not exists});
MyJsonDoc.GetChildNodeValueDateTime('birth', Now{default if node not exists});
Learn more at Source/Alcinoe.JSONDoc.pas
Use ImageMagick® to create, edit, compose, or convert bitmap images. It supports over 200 image formats, including PNG, JPEG, GIF, HEIC, TIFF, DPX, EXR, WebP, Postscript, PDF, and SVG.
With ImageMagick, you can resize, flip, mirror, rotate, distort, shear, and transform images. Additionally, it allows for color adjustments, the application of various special effects, and the drawing of text, lines, polygons, ellipses, and Bézier curves. This powerful tool enables a wide range of image manipulations within Delphi projects.
Example :
//Create the ImageMagick Library
ALCreateImageMagickLibrary({alcinoe} + '\Libraries\dll\ImageMagick\Win64');
try
//create the wand pointer
var LWand := NewMagickWand;
try
//load the image
if MagickReadImage(LWand, pansiChar(aInputFilename)) <> MagickTrue then RaiseLastMagickWandError(LWand);
//Set the compression quality
if MagickSetImageCompressionQuality(LWand,80) <> MagickTrue then RaiseLastMagickWandError(LWand);
//autorate the image
if MagickAutoOrientImage(LWand) <> MagickTrue then RaiseLastMagickWandError(LWand);
//Resize the image using the Lanczos filter
if MagickResizeImage(LWand, 640, 480, LanczosFilter) <> MagickTrue then RaiseLastMagickWandError(LWand);
//save the image
MagickWriteImage(LWand, pansiChar(aOutputFilename));
finally
DestroyMagickWand(LWand);
end;
finally
ALFreeImageMagickLibrary;
end;
Learn more at Demos\ALImageMagick
TALMongoDBClient provides a Delphi MongoDB client built on top of
the MongoDB C Driver 2.x (libmongoc2 / libbson2) via
Alcinoe.MongoDB.Wrapper.pas.
TALMongoDBClient is designed for high-throughput applications and uses a client pool
(mongoc_client_pool_t) internally. Instead of creating a new connection for every request,
operations borrow a client from the pool and return it when done, which reduces connection
setup overhead and improves scalability.
The API offers the usual operations:
Find(streaming via callback or aggregated asTALJsonNodeA)InsertOne/InsertManyUpdateOne/UpdateManyReplaceOneDeleteOne/DeleteManyFindAndModify
StartTransaction, CommitTransaction, and AbortTransaction are supported.
TALMongoDBChangeStreamListener is a TThread helper that continuously watches for changes
using change streams and triggers:
OnChange(Sender, ChangeDoc)OnError(Sender, Exception)
Depending on which properties you set, it can watch at the collection, database, or client level.
Learn more at Demos\ALMongoDBClient
TALStringList functions similarly to Delphi's TStringList,
but with significant performance improvements. When the list is sorted,
it uses a quicksort algorithm to search for name=value pairs, enabling
much faster lookups.
Additionally, TALStringList uses a locale-independent sorting algorithm based on the 8-bit ordinal value of each character, rather than Delphi's AnsiCompareText and AnsiCompareStr. This results in sorting speeds up to 10 times faster than Delphi's TStringList.
Unlike TStringList, TALStringList is not Unicode-based but is a fully Ansi string list, optimized for performance.
You can start exploring this feature with the demo located at
Demos\ALSortedListBenchmark
There's no doubt that Unicode was necessary for a product like Delphi. However, the approach Embarcadero chose for its implementation has raised some concerns. Instead of adopting UTF-8 through 8-bit strings, they opted to migrate from 8-bit strings to 16-bit strings (UTF-16). This decision made migrating Delphi applications prior to D2009 challenging, especially for those that relied on the assumption that strings were 8-bit.
For more insights into why UTF-16 can be problematic, here's an excellent article: utf8everywhere.org.
Starting with D2009, AnsiString now has a code
page, and some transliteration occurs when assigning an
AnsiString with one code page to another AnsiString
with a different code page (e.g., OldCodePage => UTF-16 =>
NewCodePage). To prevent unwanted transliterations, it's
crucial to set the project's code page to the desired
one (e.g., 65001 for UTF-8) and call
SetMultiByteConversionCodePage(CP_UTF8) at the beginning
of the program.
Additionally, avoid mixing different string types
(e.g., UTF8String and AnsiString) even if they share
the same code page. The Delphi compiler doesn't recognize this
at compile time and will still perform unnecessary
transliterations (e.g., MyAnsiStringUTF8 := MyUTF8String
results in UTF-8 => UTF-16 => UTF-8).
To minimize these issues, it's best to use AnsiString
exclusively in your code, even when handling UTF-8 content.
Always ensure that AnsiString is paired with
SetMultiByteConversionCodePage(CP_UTF8) to prevent
undesired conversions.