Repository files navigation

At the heart ofAlcinoe is a belief in empowering developersto create fast, modern, and seamless applications without thetypical bottlenecks of complexity or performance limitations.We believe that development should be focused oninnovation,not fighting against the constraints of your tools. Alcinoe isbuilt with the philosophy that every developer deserves thebest performance, thefreedom to customize, and thepower to deliver exceptional user experiences acrossplatforms—all while maintainingindependence from thedominance of GAFA (Google, Apple, Facebook, Amazon).

Alcinoe is fully compatible withDelphi Florence 13.0.If you find this library helpful, please consider giving it astar on GitHub. It’s free and greatly supports the project’svisibility and growth.

By joining MagicFoundation as an Associate, you'll enter acommunity that's actively shaping the future of Alcinoe—whileunlocking a suite of exclusive perks. Associates receive prioritysupport for bugs they submit via the issue tracker or by email,including faster triage, dedicated investigation, and ongoingupdates until resolved.

The Alcinoe FireMonkey Controls Demo highlights the power andflexibility of Alcinoe's UI components. It demonstrates how tobuild high-performance, visually stunning, and responsiveFireMonkey applications with ease, showcasing advancedfeatures and custom styling capabilities.

This demo showcases the Alcinoe Dynamic ListBox — ahigh-performance, customizable list control for DelphiFireMonkey apps. Optimized for modern UIs, it supportsanimated, scrollable content using an on-demand datamodel that creates and frees items dynamically, ensuringsmooth performance and low memory usage. Ideal forbuilding rich, content-driven interfaces like socialfeeds, 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 performancecapabilities, KisKis delivers an engaging and seamless user experience,making meaningful connections more accessible and enjoyable.

Please request the resolution of these quality reports. Dueto the unresolved issues from Embarcadero, we have beenforced 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 theCompileAll.batscript. This batch file performs a series of tasks,including retrieving and patching the original Delphisource code, downloading the necessary iOS/Androidlibraries, generating the Alcinoe JAR files, buildingthe BPL (Borland Package Library), compiling the toolsin theToolsdirectory, and finally compiling all demos found in theDemosdirectory. Please note that some demos requirecomponents fromdevexpress.

If you only need to use Alcinoe's non-visual components,no further steps are necessary. Simply ensure thatSourceis included in your project's search path.

To use Alcinoe's visual components at design time, youwill need to install the BPL. Open Delphi, go toComponent > Install Packages..., and select the BPLfromLibraries\bpl\Alcinoe.Additionally, include bothSourceand all subdirectories fromEmbarcadero\Florencein your search path.

If you'd like to suggest changes to the Alcinoe directory,please follow these steps:

1. Fork the Alcinoe Repository: First, you'll needto fork the repository. Forking creates a personal copyof the Alcinoe source code that you can modify as needed..

   

2. Make Your Edits: After forking, make the necessarychanges to the source code. Then, commit and push thesechanges to your forked repository.

3. Submit a Pull Request: Once you're happy with yourchanges, 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 powersthe graphics engine used by Flutter and the Androidoperating system. The implementation of Skia in Delphimarked a significant advancement for the FireMonkeyframework, as it greatly surpasses the legacy DelphiTCanvasGPU graphics engine in nearly every aspect.

• Solid Graphics Foundation: Since Skia is thesame graphics engine used by Flutter, apps builtwith Flutter or Delphi + Skia share the samefoundational graphics technology.
• Performance: The Skia algorithms are optimizedto the extent that they can often render directlyonto the form surface without requiring aninternal buffer.
• Cross-Platform Consistency: Skia offers aconsistent graphics engine across all platforms(Windows, iOS, macOS, Android).
• Rich Features: Skia provides powerful capabilitiestypical of a robust graphics engine, includingadvanced text formatting and shadow rendering.

• Increased Package Size: Adding Skia increasesthe package size by approximately 25 MB.
• Dependency on Google: Skia is a Google product,and while Embarcadero has traditionally focused onoffering an independent product free from GAFA domination,using Skia introduces a dependency on Google's technology.
• OpenGL Limitations: Under OpenGL, only rasterimages (CPU) can be shared across different threads.This means that GPU textures cannot be created inbackground threads and later drawn on the main formsurface. Interestingly, there seems to be no noticeablespeed improvement when drawing GPU images compared toraster images.
• Image Rendering Performance: While Skia excelsat drawing shapes directly on the form surface, it isnotably slower (4x more slower) than the legacy Delphicanvas (TCanvasGPU) when rendering images onto the form.

The slower image rendering is particularly problematic inscenarios where we paint everything first onto an internalbuffer and then render that buffer to the form surface oneach paint loop—a technique often used to avoid flickeringand improve performance. Unfortunately, Skia can be up to4 times slower at drawing images onto the form surfacecompared to the legacy Delphi TCanvasGPU, which usesOpenGL textures.

For example, on a Google Pixel 7, I can render 2000 texturessimultaneously at 90 FPS using TCanvasGPU. However, withSkia, I can only render 500 images at the same frame rate.You can verify this using the demo app located atDemos/ALFmxGraphics.

Given these limitations, I’ve decided to use Skia as thebackend graphics engine in Alcinoe while continuing touse the legacy Delphi canvas (TCanvasGPU) for renderingon the main form surface. The exception is on Windows,where we use Skia for both the backend and the mainform surface.

On Android and iOS, the operating systems already providepowerful graphics APIs, and in many cases, these native APIsoutperform Skia—often by as much as 2x. While the performanceof the OS graphics APIs is superior, Skia still offers thebenefit 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 designlanguage for developers creating modern, user-friendly, andvisually appealing applications. With the release of Material You(Material Design 3), Google has taken a step further by allowinggreater personalization and a more dynamic appearance. Developersusing Delphi can now leverage Material 3 principles to createstunning, cohesive interfaces across platforms like Android, iOS,Windows, and macOS.

TALButton offers full customization for states such asEnabled,Pressed, andDisabled, allowing for modern Material 3 buttonstyles. You can adjust properties likefill, border, shadow, andfont to match Material 3’s bold, clear design principles. Itsupports HTML content, enabling you to easily include icons orrich text.

TALToggleButton is a customizable toggle control with distinct stylesfor On and Off across all states —Enabled,Pressed,Focused,Hovered,andDisabled. It supportsfill, border, shadow, andfont customization,as well as HTML content for icons or rich text, making it ideal forinteractive Material 3 components.

Both controls follow Material 3’s minimalistic and responsivedesign. They include customizable properties forcheckmark,border, andshadow and utilize smooth transitions between states.Their highly customizable nature allows you to create checkboxand radio button components that align with Material 3’s aesthetic.

TALSwitch is designed for easy customization, allowing you tocontrol the design of the switch in states such asEnabled,Hovered,Focused,Pressed, andDisabled. Thecontrol provides smooth, responsive transitions between on andoff states, reflecting the fluid, adaptable nature ofMaterial 3’s switches. The customizable design ensures thatTALSwitch fits seamlessly into a modern, minimalistic interface,offering both visual appeal and optimized performance forDelphi applications.

TALTrackBar allows for extensive customization of its appearanceand behavior, making it an ideal choice for implementing Material 3’sclean and modern slider design. You can easily customize the track andthumb with properties such asfill,stroke, andshadow toachieve the sleek, minimalistic look that defines Material 3. Theslider's interactions, including value indicators and stop indicators,are smooth, ensuring responsive feedback as the user interacts with thecontrol. Its transitions between states likeEnabled,Focused,andPressed contribute to a polished, fluid user experience.

Alcinoe’s nativeTALEdit andTALMemo controls are designed tomatch Material 3’s input fields, offering customizableborder,shadow, andfont properties. These controls adapt across platformswhile maintaining a consistent, clean interface for text input,with features like autosizing and prompt text.

All Alcinoe controls can be easily styled usingTALStyleManager. To achievethis, you simply define a custom style for each control by modifyingAlcinoe.FMX.CustomStyles.pas.

In addition, theTALStyleManager makes it straightforward to implement lightand dark theme variants—or any other custom theme.

The core of this flexibility lies in the fact that each Alcinoe control associatesaColorKey with everyColor property. You can assign a symbolic value tothis key, such asMaterial3.Color.Primary. Then, withinTALStyleManager,you define the actual color value mapped toMaterial3.Color.Primary.

This design allows you to switch effortlessly between light, dark, or customthemes—ensuring both consistency and maintainability.

TALText is a robust component similar toTText, butwith enhanced capabilities like basic HTML text formattingsupport. Despite incorporating HTML formatting,TALTextdelivers substantial performance improvements overTText.This is achieved through its double-buffered engine,which renders text on an internal buffer and then drawsonly the buffer onto the form during each paint cycle. Thisdesign ensures thatTALText is extremely fast and efficient.Additionally,TALText enhances functionality by supportingmouse event handling, allowing it to detect specificHTML elements (such as span IDs and bounds) under the mousepointer. This feature enables interactive text elements,making it ideal for applications requiring dynamic,responsive text behavior. Learn more atDemos/ALFmxControls

TALPageController is a component that managesand controls page transitions within your application,similar to Flutter's PageController. It allows you to smoothlynavigate between different pages, track the current page index,and customize the behavior of scrolling animations andtransitions. Learn more atDemos/ALFmxControls

Page indicators are a key element in multi-page applications,offering users a clear sense of their current location andthe overall number of pages.TALPageIndicator is a lightweightcomponent that delivers animated, customizable page indicatorswith a variety of effects, making it easy to integrate andensuring smooth, visually appealing transitions throughout yourinterface. It comes with a set of built-in effects to animatethe active dot, each of which can be customized to suit yourdesign preferences.

Effect	Preview
Worm
ThinWorm
JumpingDotTopView
jumpingDotSideView
Slide
Scale
LinearSwap
SpinSwap
Color

TALDialog is a dialog component built for mobileapplications. It provides the flexibility to displayhighly customizable dialogs with a modern,Material 3 design.

It uses theBuilder Pattern withfluent methodchaining, making the dialog creation processsimple and intuitive:

  TALDialog.Builder    .SetHeadlineText('Delete item')    .SetMessageText('Are you sure?')    .AddButton('Cancel', 1)    .AddButton('Delete', 2)    .SetCloseProc(...)    .Show;

Learn more atDemos/ALFmxControls

A modern loading indicator inspired by Material 3 design.Ideal for signaling that an operation is in progress, ituses subtle motion and minimal design to reassure usersthat the app is working, even when results aren't immediate.

Learn more atDemos/ALFmxControls

TALSheet is a flexible sheet component designed formobile applications. It can appear from the top, bottom,left, or right edge of the screen. Following modernMaterial 3 design guidelines, TALSheet is perfect forpresenting contextual content, navigation panels, oraction menus with smooth, customizable animations.

Learn more atDemos/ALFmxControls

TALSnackbar is a lightweight, transient message barthat follows Material 3. It’s ideal for brief status updatesor confirmations and can include an optional action(e.g., “UNDO”).

Learn more atDemos/ALFmxControls

ALVideoPlayer renders video onto a texture, allowingseamless integration into a Delphi form while supportingZ-ORDER, enabling controls to be placed on top of the video.In contrast, Delphi’s official video players are nativevideo player windows overlaid on the form, which do notsupport Z-ORDER.

On Android,Alcinoe usesMedia3 ExoPlayer, which providesadvanced features such as dynamic adaptive streaming overHTTP (DASH), HLS, SmoothStreaming, and common encryption—capabilitiesnot available in MediaPlayer.Media3 ExoPlayer is also designedto be easily customizable and extendable. On iOS,AVPlayer is used, offering similar HLS support toMedia3 ExoPlayer.

Learn more atDemos/ALFmxControls

TALMediaPicker provides a unified, high-level API to selectimages and videos from the device library or capture new mediawith the camera across iOS and Android. It abstractsplatform specifics (iOS PHPickerViewController/UIImagePickerController,Android ACTION_PICK_IMAGES/GET_CONTENT and camera intents),handles permission flows, and normalizesresults into TMediaItem objects with URIs and media types.The component supports multiple selection, returns streams ondemand (ExtractStream), and exposes clear callbacks for success,cancel, and error states—letting you integrate media workflowsquickly without dealing with per-platform quirks likeFileProvider URIs, picker filters, or temporary file management.Learn more atDemos/ALFmxMediaPicker

Imagine you're building a chat app: when the user tapsSend,you could send the message on themain thread, but this freezesthe UI and is forbidden by mobile operating systems. Another optionis abackground thread, however this fails when the user switchesapps (incoming phone call, home button, etc.), since iOS and Androidsuspend or kill HTTP networking in background mode. You also have todeal 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 theupload usingTALHttpWorker.enqueue, and you no longer needto worry about network reliability, app switching, app termination,or temporary server errors (HTTP 5xx, unreachable host, etc.).TALHttpWorker handles everything automatically and posts aTWorkResultMessage when the job is completed.

ALConfetti is a lightweight and highly efficientDelphi library designed to create visually appealing,customizable confetti falling animations. Built forperformance and flexibility, it allows developers toeasily adjust parameters such as speed, size, andcolor, ensuring seamless integration into any project.Whether it's for celebrations, notifications, ordynamic visual effects,ALConfetti delivers asmooth, high-performance animation experience.Learn more atDemos/ALFmxConfetti

An Android library, also known as an Android Archive (AAR),contains everything needed to build an app, including sourcefiles, resource files, and the manifest. Unlike JARs, AARscan include resource files in addition to compiled bytecode.

Integrating an AAR into a Delphi project can be a long andcomplex process, involving extracting resources, manuallyadding them to Delphi deployment files, compiling theR.java class, checking dependencies, and more.

WithAndroidMerger, this entire process is automatedin 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 theAndroidManifest files of all AARs intoAndroidManifest.template.xml.
• Mergegoogle-services.json into the project's resources.
• Create theR.jar with all resource IDs usingaapt oraapt2.
• Update the project file (.dproj) to include all resources.
• Generate the Delphi native bridge file from the Java libraries.

Learn more atTools/AndroidMerger

• DeployMan simplifies the deployment of files and folders foriOS and Android apps, making it ideal for managing large fileslike third-party SDKs.Learn more atTools/DeployMan.

• DeployProjNormalizer enables the creation of a newdeployproj file from scratch using the dproj as a reference,normalizing it by ordering nodes to facilitate comparisonacross different revisions with diff tools.Learn more atTools/DeployProjNormalizer.

• DProjNormalizer focuses on ordering nodes in a DProjfile, ensuring consistency across commits and simplifyingthe comparison of changes.Learn more atTools/DProjNormalizer.

Alcinoe Code Profiler is a powerful source code instrumentationprofiler for Delphi, designed to help developers identifyperformance bottlenecks and optimize their applications acrossmultiple platforms, including Windows, macOS, iOS, and Android.

By automatically injecting performance markers into your Delphisource code, Alcinoe Code Profiler logs execution times for eachprocedure call. These logs can then be analyzed using the providedgraphical interface, enabling you to pinpoint inefficienciesand 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 atTools/CodeProfiler

TheTALAnimation component is a refined version of Delphi'sfoundationalTAnimation object, specifically optimized formobile platforms. Instead of relying on the traditional Timermechanism, this component adopts platform-specific technologies,delivering a significantly improved animation experience formobile users.

• OnAndroid, animations are seamlessly integrated withtheChoreographer, ensuring perfect synchronizationwith the device’s refresh rate.

• OniOS, the precision ofDisplayLink is utilized,resulting in smooth and optimized animation rendering.

A key enhancement ofTALAnimation is its support forcustom interpolation algorithms, giving developers theflexibility to create unique and complex animation patterns,far beyond the traditional ease-in or ease-out sequences.

Learn more atDemos/ALFmxAnimation

Inspired by Android'sSpringForce, theTALSpringForceAnimationcomponent brings the dynamics of physics-based animations to theDelphi platform. This component simulates the real-world behaviorof objects influenced by spring mechanics, producing animations thatstretch, 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 ofanimation behaviors. This flexibility enables developers to createanimations 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 descriptionwhile keeping the markdown formatting

Learn more atDemos/ALFmxAnimation

TALOverScroller andTALVelocityTracker are key componentsof theTALScrollEngine, enhancing user interface interactions.TALOverScroller manages scrolling and flinging with smoothdeceleration when users scroll past a view's edge, whileTALVelocityTracker measures touch velocity to determine gesturespeed and direction. Together, they provide smooth animations andintuitive feedback within the scrolling engine.

Rather than reinventing the wheel, we based theTALScrollEngineon proven Android components, translatingVelocityTracker andOverScroller from Java and C++ to Delphi. This ensures ahigh-quality, reliable scrolling experience for Delphi developers,using trusted, efficient technologies.

Learn more atDemos/ALFmxControls

The Delphi implementation of the latest version ofFirebase CloudMessaging (FCM) using theHTTP V1 protocol enables you tosend advanced push notifications, including rich media likeimages, to Android and iOS devices. This allows developers to deliverreal-time alerts, updates, and user-specific notifications directlyto mobile users, improving engagement and communication withintheir apps.

Learn more atDemos\ALFmxNotificationService

TheTALGeoLocationSensor component is a Delphi component thatprovides access to location services on iOS and Android devices.It allows developers to retrieve the device's current locationand receive updates as the location changes. The component supportsvarious location providers, including GPS, cellular networktriangulation, and Wi-Fi positioning.

In addition to accessing location services,TALGeoLocationSensorautomates the process of requesting user permission to use locationdata on both iOS and Android. It also handles scenarios where usershave previously denied location access. By using this component,developers can seamlessly integrate location-based functionalityinto their apps without needing to manage the underlyingimplementation details.

Learn more atDemos\ALFmxGeoLocationSensor

Google APIs utilize theOAuth 2.0 protocol for authenticationand authorization. The functionALGenerateGoogleOAuth2AccessTokenallows you to easily generate an OAuth 2.0 access token, whichcan be used to securely access Google services and APIs withinyour Delphi applications.

Learn more atSource/Alcinoe.Cipher.pas

TheFacebook SDK for Android and iOS allows usersto sign into your app using their Facebook credentials.Once logged in, users can grant permissions to your app, enabling youto retrieve information or perform actions on Facebookon their behalf.

Learn more atDemos\ALFmxFacebookLogin

WithTALColorAdjustEffect, you can effortlessly apply stunningphoto filters to enhance your images with just a single tap.Transform your photos into beautiful and expressive works of art in minutes!

Learn more atDemos\ALFmxFilterEffects

Designed for robust and secure HTTP communication,TALWinHttpClient is a DelphiHTTP client component built directly on top of the nativeWinHTTP API providedby Windows. By relying on the operating system’s integrated networking and securitystack, it delivers production-grade reliability, performance, and compatibilitywithout requiring any external libraries or additional DLLs to be deployed.

TALWinHttpClient supports modern web standards withHTTP/1.1, HTTP/2, and HTTP/3(where supported by the underlying Windows WinHTTP stack), along with securecommunication viaTLS 1.2 and TLS 1.3, automatically negotiating the bestprotocol versions and cipher suites supported by both client and server accordingto Windows security policy. It transparently handles connection management,redirects, proxies, authentication, and secure transports, making it well suitedfor REST APIs, RPC services, and high-reliability HTTP integrations that requirenative Windows behavior and long-term maintainability.

Learn more atDemos\ALWinHTTPClient

TALHttpSysServer is a high-performance HTTP server component forDelphi that runs directly on top of http.sys, the kernel-mode HTTPstack built into Windows. By leveraging the same foundation thatpowers IIS, it delivers production-grade performance, scalability,and security without requiring an external web server. WithTALHttpSysServer, you can build lightweight yet powerful REST APIs,RPC services, or custom HTTP applications while letting the Windowskernel handle the heavy lifting.

Advantages of using http.sys:

• Kernel-mode HTTP stack → runs directly inside Windows networking core, giving youIIS-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) ishandled in the kernel, so your thread never blocks. Concretely, this meansa 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 directlyin kernel space, bypassing user-mode, which reduces latency and CPU usage.
• Kernel-managed W3C logging → http.sys writes W3C logs for you and handlesfile 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 atDemos\ALHttpServer

TAlSChannelTlsClient is a high-performance TLS socket client component forDelphi that runs directly on top of the WindowsSChannel 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, withnoexternal dependencies such as OpenSSL or third-party components and noredistribution or licensing concerns.

TAlSChannelTlsClient transparently upgrades an existing TCP socket to TLSand handles encryption, decryption, handshake, renegotiation, and shutdownentirely through the Windows SSPI/SChannel APIs. It supportsTLS 1.2 andTLS 1.3, automatically negotiating the best protocol version supported byboth client and server in accordance with Windows security policy, and isdesigned for building robust SMTP, HTTPS, WebSocket, or custom protocolclients where full control over the transport layer is required.

Learn more atDemos\ALTSLClient

Designed for reliable and secure email delivery,TALSMTPClient is a DelphiSMTP client component that sends messages directly over the SMTP protocolwhile leveraging the native Windows TLS stack for transport security. Byrelying on the operating system’s integrated security infrastructure, itprovides production-grade reliability, security, and compatibility withoutrequiring any external libraries or additional DLLs to be deployed.

TALSMTPClient supports modern email security requirements with fullTLS 1.2 and TLS 1.3 support, automatically negotiating the best protocolversion supported by both client and server in accordance with Windowssecurity policy. It works seamlessly with theMultipart Alternative andMultipart Mixed encoders, enabling the creation of emails with plain-textand HTML alternatives as well as file attachments, while giving developersfull control over the SMTP session and message composition.

Learn more atDemos\ALSMTPClient

TALJSONDocument is a Delphi parser and writer for bothJSONandBSON data formats. It supports bothDOM andSAXparsers (although a more appropriate name for SAX could beSAJ—Simple API for JSON—rather than Simple API for XML, thewell-known SAX terminology is retained).

In addition to its JSON capabilities,TALJSONDocument alsosupports theBSON format, using a syntax similar toTALXMLDocument/TXMLDocument. It can further export JSON/BSONdata toTALStringList, making it a flexible tool for dataparsing 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 atSource/Alcinoe.JSONDoc.pas

UseImageMagick® to create, edit, compose, or convert bitmapimages. It supports over 200 image formats, includingPNG,JPEG,GIF,HEIC,TIFF,DPX,EXR,WebP,Postscript,PDF, andSVG.

With ImageMagick, you can resize, flip, mirror, rotate, distort,shear, and transform images. Additionally, it allows for coloradjustments, the application of various special effects, and thedrawing of text, lines, polygons, ellipses, and Bézier curves.This powerful tool enables a wide range of image manipulationswithin 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 atDemos\ALImageMagick

TALMongoDBClient is a Delphi MongoDB client built on top of theMongoDB C Driver 2.x (libmongoc2 /libbson2). It’s designedfor high-throughput,multi-threaded applications: for eachdatabase operation, the calling thread borrows amongoc_client_tfrom an internalmongoc_client_pool_t, uses it to execute therequest, and then returns it to the pool as soon as the operationcompletes—avoiding a new connection per call, reducing overhead,and scaling cleanly with concurrency.

It includes the usual MongoDB operations (Find via callback or asTALJsonNodeA, Insert/Update/Replace/Delete,FindAndModify),plustransactions (StartTransaction /CommitTransaction /AbortTransaction) andchange streams viaTALMongoDBChangeStreamListener (backgroundTThread withOnChange /OnError, watching collection/database/client).

Learn more atDemos\ALMongoDBClient

TALStringList functions similarly to Delphi'sTStringList,but with significant performance improvements. When the list is sorted,it uses a quicksort algorithm to search forname=value pairs, enablingmuch faster lookups.

Additionally,TALStringList uses a locale-independent sortingalgorithm based on the 8-bit ordinal value of each character, ratherthan Delphi'sAnsiCompareText andAnsiCompareStr. This resultsin sorting speeds up to 10 times faster than Delphi'sTStringList.

UnlikeTStringList,TALStringList is not Unicode-based but isa fullyAnsi string list, optimized for performance.

You can start exploring this feature with the demo located atDemos\ALSortedListBenchmark

There's no doubt thatUnicode was necessary for aproduct like Delphi. However, the approach Embarcaderochose for its implementation has raised some concerns.Instead of adoptingUTF-8 through 8-bit strings,they opted to migrate from 8-bit strings to 16-bit strings(UTF-16). This decision made migrating Delphi applicationsprior to D2009 challenging, especially for those thatrelied on the assumption that strings were 8-bit.

For more insights into whyUTF-16 can be problematic,here's an excellent article:utf8everywhere.org.

Starting withD2009,AnsiString now has a codepage, and some transliteration occurs when assigning anAnsiString with one code page to anotherAnsiStringwith a different code page (e.g., OldCodePage => UTF-16 =>NewCodePage). To prevent unwanted transliterations, it'scrucial to set the project's code page to the desiredone (e.g., 65001 for UTF-8) and callSetMultiByteConversionCodePage(CP_UTF8) at the beginningof the program.

Additionally, avoid mixing different string types(e.g.,UTF8String andAnsiString) even if they sharethe same code page. The Delphi compiler doesn't recognize thisat compile time and will still perform unnecessarytransliterations (e.g.,MyAnsiStringUTF8 := MyUTF8Stringresults inUTF-8 => UTF-16 => UTF-8).

To minimize these issues, it's best to useAnsiStringexclusively in your code, even when handling UTF-8 content.Always ensure thatAnsiString is paired withSetMultiByteConversionCodePage(CP_UTF8) to preventundesired conversions.