Hubbry Logo
Delphi (software)Delphi (software)Main
Open search
Delphi (software)
Community hub
Delphi (software)
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Delphi (software)
Delphi (software)
Delphi (software)
View on Wikipedia
from Wikipedia
Delphi
Original authorsBorland, CodeGear, Embarcadero
DeveloperEmbarcadero Technologies
Initial release1995
Stable release
RAD Studio 13 Florence[1] Edit this on Wikidata / 10 September 2025; 2 months ago (10 September 2025)
Written inMostly Delphi (Object Pascal)
Operating systemRuns on Windows;[2][non-primary source needed] targets Windows, Linux, macOS, Android, iOS
TypeSoftware Development, Designer, IDE, Compiler, RTL
LicenseFreemium
Websitewww.embarcadero.com/products/delphi

Delphi is a general-purpose programming language and a software product that uses the Delphi dialect of the Object Pascal programming language and provides an integrated development environment (IDE) for rapid application development of desktop, mobile, web, and console software,[3] currently developed and maintained by Embarcadero Technologies.

Delphi's compilers generate native code for Microsoft Windows, macOS, iOS, Android and Linux (x64).[4][5][6]

Delphi includes a code editor, a visual designer, an integrated debugger, a source code control component, and support for third-party plugins. The code editor features Code Insight (code completion), Error Insight (real-time error-checking), and refactoring. The visual forms designer has the option of using either the Visual Component Library (VCL) for pure Windows development or the FireMonkey (FMX) framework for cross-platform development. Database support is a key feature and is provided by FireDAC (Database Access Components). Delphi is known for its fast compilation speed, native code, and developer productivity.[citation needed]

Delphi was originally developed by Borland as a rapid application development tool for Windows as the successor of Turbo Pascal. Delphi added full object-oriented programming to the existing language, and the language has grown to support generics, anonymous methods, closures, and native Component Object Model (COM) support.

Delphi and its C++ counterpart, C++Builder, are interoperable and jointly sold under the name RAD Studio. There are Professional, Enterprise, and Architect editions, with the higher editions having more features at a higher price. There is also a free-of-charge Community edition, with most of the features of Professional, but restricted to users and companies with low revenue.[7][non-primary source needed]

Features

[edit]

Delphi supports rapid application development (RAD). Prominent features are a visual designer and two application frameworks, Visual Component Library (VCL) for Windows and FireMonkey (FMX) for cross-platform development.

Delphi uses the Pascal-based programming language Object Pascal created by Anders Hejlsberg for Borland (now IDERA) as the successor to Turbo Pascal. It supports native cross-compilation to many platforms including Windows, Linux, iOS, and Android.

To better support development for Microsoft Windows and interoperate with code developed with other software development tools, Delphi supports independent interfaces of Component Object Model (COM) with reference counting class implementations, and support for many third-party components. Interface implementations can be delegated to fields or properties of classes. Message handlers are implemented by tagging a method of a class with the integer constant of the message to handle.[citation needed]

Database connectivity is extensively supported through VCL database-aware and database access components.

Later versions have included upgraded and enhanced runtime library routines, some provided by the community group FastCode.

Characteristics

[edit]

Delphi uses a strongly typed high-level programming language, intended to be easy to use and originally based on the earlier Object Pascal language. Pascal was originally developed as a general-purpose language "suitable for expressing the fundamental constructs known at the time in a concise and logical way", and "its implementation was to be efficient and competitive with existing FORTRAN compilers"[8] but without low-level programming facilities or access to hardware. Turbo Pascal and its descendants, including Delphi, support access to hardware and low-level programming, with the facility to incorporate code written in assembly language and other languages. Delphi's object-orientation features only class- and interface-based polymorphism.[9] Metaclasses are first class objects. Objects are references to the objects (as in Java), which Delphi implicitly de-references, so there is usually no need to manually allocate memory for pointers to objects or use similar techniques that some other languages need. There are dedicated reference-counted string types, and also null-terminated strings.

Strings can be concatenated by using the '+' operator, rather than using functions. For dedicated string types, Delphi handles memory management without programmer intervention. Since Borland Developer Studio 2006, there are functions to locate memory leaks.

Delphi includes an integrated IDE. The Delphi products all ship with a run-time library (RTL) and a Visual Component Library (VCL), including most of its source code. Third-party components (sometimes with full source code) and tools to enhance the IDE or for other Delphi related development tasks are available, some free of charge. The IDE includes a GUI for localization and translation of created programs that may be deployed to a translator; there are also third-party tools with more features for this purpose. The VCL framework maintains a high level of source compatibility between versions, which simplifies updating existing source code to a newer Delphi version. Third-party libraries typically need updates from the vendor but, if source code is supplied, recompilation with the newer version may be sufficient. The VCL was an early adopter of dependency injection or inversion of control; it uses a reusable component model, extensible by the developer. With class helpers, new functionality can be introduced to core RTL and VCL classes without changing the original source code of the RTL or VCL.

Delphi supports a wide range of third-party database access components that provide native connectivity to major database systems. These include specialized libraries for Oracle, SQL Server, MySQL/MariaDB, PostgreSQL, SQLite, and InterBase/Firebird. Some components, like DAC, offer universal data access solutions supporting multiple databases and cloud services such as Salesforce and FreshBooks. These libraries are regularly updated to remain compatible with the latest IDE versions (e.g., RAD Studio 12), operating systems (e.g., macOS Sonoma, iOS 17, Android 13), and database engines (e.g., Oracle 23, SQL Server 2022, PostgreSQL 16).

The compiler is optimizing and is a single-pass compiler. It can optionally compile to a single executable which does not require DLLs. Delphi can also generate standard DLLs, ActiveX DLLs, COM automation servers and Windows services.

The Delphi IDEs since Delphi 2005 increasingly support refactoring features such as method extraction and the possibility to create UML models from the source code or to modify the source through changes made in the model.

Delphi has communities on the web, where also its employees actively participate. And Delphi is using in collaboration with FireDAC components.

Backward compatibility

[edit]

Delphi is one of the languages where backward compatibility is close to 100%. Although each new release of Delphi attempts to keep as much backward compatibility as possible to allow existing code reuse, new features, new libraries, and improvements sometimes make newer releases less than 100% backward compatible.

Since 2016, there have been new releases of Delphi every six months, with new platforms being added approximately every second release.[10]

Frameworks

[edit]

Delphi offers two frameworks for visual application development, VCL and FireMonkey (FMX):

  • Visual Component Library (VCL) is the framework for developing pure Windows applications. VCL is a long-standing framework, included in the first release of Delphi and actively developed ever since then.
  • FireMonkey (later abbreviated FMX), was released in 2011, as part of Delphi XE2, together with an additional set of built-in compilers for non-Windows platforms. FireMonkey is a cross-platform framework for Windows, macOS, iOS, Android and Linux (x64). The GUI parts of FireMonkey are largely based on Direct3D and OpenGL. FireMonkey is not compatible with VCL; they are two separate frameworks. FireMonkey applications do, however, allow easy sharing of non-visual code units with VCL applications, enabling a lot of code to be ported or shared easily between the platforms.

Interoperability

[edit]

Delphi and its C++ counterpart, C++Builder, are interoperable. They share many core components, notably the IDE, the VCL and FMX frameworks, and much of the runtime library. In addition, they can be used jointly in a project. For example, C++Builder 6 and later can combine source code from Delphi and C++ in one project, while packages compiled with C++Builder can be used from within Delphi. In 2007, the products were released jointly as RAD Studio, a shared host for Delphi and C++Builder, which can be purchased with either or both. Starting with Rio, there is also interoperability with Python.

Sample "Hello World" program

[edit]
See also: Object Pascal § Delphi_and_Free_Pascal_version
program ObjectPascalExample;

type
  THelloWorld = class
    procedure Put;
  end;

procedure THelloWorld.Put;
begin
  Writeln('Hello, World!');
end;

var
  HelloWorld: THelloWorld;               { this is an implicit pointer }

begin
  HelloWorld := THelloWorld.Create;      { constructor returns a pointer to an object of type THelloWorld }
  HelloWorld.Put;
  HelloWorld.Free;                       { this line deallocates the THelloWorld object pointed to by HelloWorld }
end.

Note that the object construct is still available in Delphi.

History

[edit]
See History of Delphi (software) for details on the progression of language and IDE development from 1995 to the present.

Uses in schools

[edit]

In 2016, Delphi was named the language of choice for teaching programming in South African schools as a subject of information technology (IT).[11]

Roadmaps

[edit]

Embarcadero used to publish "roadmaps" describing their future development plans. The last one was published in November 2020.[12][non-primary source needed] Version 10.5 referred to in the November 2020 roadmap was renamed 11.0. Starting with Delphi 11, Embarcadero decided to no longer publish formal roadmaps. Instead, possible new features are now presented in a loose order through blog entries and online webinars. An important role has Marco Cantú (product manager) with his blog.[citation needed]

[edit]
  • Borland Enterprise Studio, a precursor to RAD Studio, is a software development suite that includes support for multiple languages. Borland Enterprise Studio for Windows supports Delphi.[13]
  • Borland Kylix: Similar to Delphi, but for Linux, released in 2001. This was the first attempt to add Linux support to the Delphi product family.[14] Kylix used the new CLX cross-platform framework (based on Qt), instead of Delphi's VCL. Kylix was discontinued after version 3. Today Linux support is integrated into the main Delphi product and uses the FireMonkey cross-platform framework.
  • InterBase is an embeddable SQL database that integrates natively to Delphi and C++Builder for client/server or embedded development. Its distinguishing features reduced administration requirements, commercial-grade data security, disaster recovery, and change synchronization. It is also accessible by all major languages and platforms in the market with database connection protocols like ODBC, ADO, ADO.NET and even with Java by JDBC/ODBC Bridge or Java type 4 connectors.
  • JBuilder was a tool for Java development based on Eclipse since version JBuilder 2007.
  • RadPHP (later replaced with HTML5 Builder) was an IDE for PHP that provided true RAD functionality. It has a form designer similar to that of Delphi or Visual Basic, and an integrated debugger based on the Apache web server. It also includes a VCL library ported to PHP. Unlike other IDEs, it supports Web 2.0 features such as Ajax. Delphi for PHP was announced on March 20, 2007, renamed in October 2010 to RadPHP, and is based on Qadram Q studio. Embarcadero acquired Qadram in January 2011.
  • Delphi Prism (later renamed Embarcadero Prism) derived from the Oxygene language (formerly named Chrome) from RemObjects. It ran in the Microsoft Visual Studio IDE rather than RAD Studio. It was licensed and rebranded by Embarcadero to replace Delphi.NET when that product was discontinued.
  • Free Pascal is an open-source Pascal cross-platform cross-compiler that supports most of Delphi's Object Pascal code. Free Pascal also has its own language extensions, multiple compiler [language syntax] modes, and supports 18+ operating systems and 9+ processor architectures.[15] Lazarus is a cross-platform RAD IDE that uses the Free Pascal compiler.

Notable third-party libraries

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Delphi (software)

View on Grokipedia
from Grokipedia
Delphi is an (IDE) and (RAD) tool for the programming language, enabling developers to create high-performance, native cross-platform applications for Windows, macOS, , Android, and from a single codebase. Developed primarily by , it features visual design tools, native compilers, and component libraries such as the (VCL) for Windows and (FMX) for multi-platform UI, facilitating faster development cycles with support for modern constructs like high-DPI interfaces, cloud integration (e.g., APIs, AWS, Azure), and database connectivity via FireDAC to over 20 databases including , , and . The latest version, Delphi 13 Florence (released on September 10, 2025), includes enhancements like a 64-bit IDE, AI components, C++23 support in the bundled , and new language extensions for improved productivity. Originally introduced by on February 14, 1995, as a successor to , revolutionized Windows application development by combining with a visual RAD environment that allowed drag-and-drop form design and automatic code generation, significantly reducing development time compared to traditional coding. Over the years, it evolved from supporting and early databases like to embracing multi-platform capabilities with the introduction of in 2011, enabling mobile and desktop apps with shared codebases. In 2008, acquired the CodeGear division from Software Corporation, which included , for approximately $23 million, allowing continued innovation and expansion beyond Windows-centric applications. Today, remains a professional tool with editions like Professional, Enterprise, and Architect, alongside a free Community Edition for smaller projects, and is used in industries for enterprise software, games, and notable applications such as the original client.

Overview

Language and IDE

Delphi serves as a (RAD) environment that combines the Delphi dialect of the programming language with an (IDE) designed for building high-performance native applications across various platforms. This integration enables developers to create graphical user interfaces and efficiently, leveraging visual tools alongside compiled code for optimal performance. The core components of the Delphi IDE include a sophisticated code editor supporting , auto-completion, and refactoring tools to streamline coding tasks; a visual form designer that allows drag-and-drop placement of components for intuitive UI development; an integrated with features such as breakpoints, step-through execution, and variable watches for effective troubleshooting; and a built-in that translates source code into native machine code. These elements work together to facilitate a seamless from design to deployment. Object Pascal, the foundational language of Delphi, extends the paradigm of classic Pascal with robust object-oriented features, including classes for encapsulation and , and interfaces for polymorphism and contract-based design. It incorporates strong static typing to enforce at , reducing runtime errors, and provides mechanisms to manage errors gracefully through try-except blocks. is handled automatically via for types like interfaces, strings, and dynamic arrays, which increments and decrements counters to deallocate resources when no longer referenced, though manual management is required for most objects. Later enhancements include generics for type-safe reusable code collections, introduced in Delphi 2009, and anonymous methods for inline procedure or function definitions without named declarations, also added in Delphi 2009. A typical program follows a modular unit , starting with a program or unit declaration, followed by a uses to import dependencies, a var section for declaring variables and types, and the executable code within a begin...end. block, promoting organized and maintainable code. Delphi evolved from Borland's Turbo Pascal compiler of the 1980s, incorporating visual development capabilities and advanced object-oriented extensions to meet the demands of graphical application building.

Editions and licensing

Delphi is available in four main editions—Community, Professional, Enterprise, and Architect—designed to accommodate varying development needs from individual learning to large-scale enterprise projects. These editions differ primarily in feature sets, platform support depth, and included tools, with higher tiers building on the capabilities of lower ones. The Community Edition serves as an entry point, offering essential functionality at no cost, while paid editions provide expanded tools for commercial and collaborative use. The following table summarizes the key differences among the editions:
EditionKey FeaturesLimitationsTarget Users
CommunityCore IDE with visual designers, debugger, code editor, VCL/FireMonkey frameworks; support for Windows, macOS, iOS, Android; limited runtime library source code access.Restricted to <5 developers and <$5,000 annual revenue; no advanced database drivers, team collaboration, or enterprise testing tools; one-year license term requiring renewal.Individuals, students, startups, hobbyists for non-commercial or low-revenue projects.
ProfessionalAll Community features plus full database connectivity (e.g., FireDAC for local/ODBC databases), team features (version control, code review), and broader runtime library access.Lacks Linux targeting, advanced testing, and modeling; no InterBase deployment.Professional developers focusing on desktop apps and database-driven solutions.
EnterpriseAll Professional features plus Linux targeting, advanced testing (App Analytics, profiling), RAD Server for multi-device apps, and InterBase ToGo test deployment.No UML modeling or enterprise architecture tools; limited to single-site RAD Server.Teams building cross-platform mobile, web, and client-server applications.
ArchitectAll Enterprise features plus UML modeling (Enterprise Architect tool), full RAD Server multi-site deployment, Sencha Ext JS Professional license, and embeddable InterBase database.Highest cost; requires subscription for ongoing updates.Large enterprises needing system architecture, modeling, and scalable deployments.
Licensing for Delphi follows a named-user model, permitting installation across multiple devices for a single authorized user while preventing concurrent use by others. Perpetual licenses allow indefinite use of a specific version, whereas the Update Subscription model—integrated into purchases—provides access to patches, new releases, priority support, and beta versions for the subscription duration, typically one year with options for renewal. Deployment rights permit royalty-free distribution of compiled applications to end-users, but restrictions apply to redistributing runtime libraries, design-time components, or source code, which require full commercial licenses or separate agreements to avoid violations. As part of Embarcadero's RAD Studio suite, Delphi shares licensing with C++Builder, enabling unified development environments under the same terms. Trial versions offer 30-day full access to evaluate editions, and upgrade paths from legacy Borland or earlier Embarcadero licenses provide discounted transitions to current versions. Approximate pricing tiers include Professional starting at $1,500 for a perpetual license with one-year updates, Enterprise at $3,000–$4,000 annually via subscription, and Architect exceeding $5,000 for comprehensive enterprise capabilities.

Core Features

Key characteristics

Delphi excels in rapid prototyping through its Visual Component Library (VCL) for Windows-native applications and framework for cross-platform development, allowing developers to design graphical user interfaces visually by dragging and dropping components onto forms without writing extensive manual code. This approach streamlines the creation of responsive UIs, enabling quick iteration from prototype to production. The software's performance is driven by its compilation to native machine code, producing fast, standalone executables without the overhead of a virtual machine or interpreter, which contrasts with managed languages like or C#. Optimizations such as support for inline assembly allow fine-tuned control over low-level operations, enhancing speed in performance-critical sections like algorithms or graphics rendering. Productivity is bolstered by core tools including the component palette, which provides a drag-and-drop interface for reusable controls, the property inspector for real-time editing of object properties, and an event-driven programming model in that simplifies handling user interactions through predefined events. These features reduce boilerplate code and accelerate development cycles. Security is integrated via 's emphasis on secure coding practices, such as strong typing and automatic memory management, which contribute to its recognition as a memory-safe language that mitigates common vulnerabilities like buffer overflows. Additionally, Delphi supports encryption libraries like CryptoLib4Pascal for implementing symmetric and asymmetric cryptography, enabling secure data handling in applications. Developer ergonomics are enhanced by built-in refactoring tools for operations like method extraction and renaming, code insight for intelligent autocompletion and error detection during editing, and seamless integration with version control systems such as Git directly within the IDE. As of RAD Studio 13 Florence (released September 2025), the IDE now supports a 64-bit architecture on Windows, improving performance, stability, and compatibility with large projects and modern hardware. In comparison to scripting languages like Python, Delphi prioritizes compiled safety and type checking to prevent runtime errors, offering the low-level access and performance akin to C++ while providing higher-level abstractions through its object-oriented syntax and visual tools.

Visual development tools

Delphi's visual development tools center on a rapid application development (RAD) workflow that integrates design, coding, debugging, and deployment within a single integrated development environment (IDE). The Form Designer serves as the primary interface for constructing user interfaces, enabling developers to visually lay out application forms without writing initial code. This tool supports drag-and-drop placement of components such as buttons, grids, labels, and toolbars from the Tool Palette onto the form surface, facilitating quick prototyping of visual elements. Alignment tools, accessible via the component's context menu under the "Position" submenu, allow precise adjustment of component sizes, scales, and alignments relative to the form or other elements. For responsive layouts, anchoring mechanisms—such as guidelines and margins in FireMonkey or Quick-Design options in VCL—ensure components adapt dynamically to form resizing. Event handling is seamlessly integrated into the design process, allowing developers to link user interface actions directly to code procedures. By double-clicking a component in the Form Designer or selecting an event on the Events tab of the Object Inspector, the IDE automatically generates a skeleton event handler procedure in the Code Editor and navigates to it for implementation. This feature streamlines the connection between UI interactions, such as button clicks, and corresponding logic written in Object Pascal syntax. The integrated debugger enhances the design-debug cycle by providing robust tools for troubleshooting during development. It supports step-through execution to trace code line by line, variable inspection to monitor values in real-time, and call stack viewing to understand execution flow. Developers can set conditional breakpoints to pause execution based on specific criteria and debug multi-threaded applications to identify concurrency issues. In RAD Studio 13 Florence (released September 2025), the LLDB debugger has been updated to version 20, further improving support for modern debugging scenarios, particularly in 64-bit environments. These features operate within the IDE, allowing seamless switching between visual design and code analysis without external tools. Project management tools organize complex applications efficiently, supporting multi-project workspaces that group related projects and units for collaborative development. As of RAD Studio 13 Florence (2025), enhanced search functionality has been added to the Project Manager, Structure View, Message pane, and Events log for faster navigation. Build configurations, managed via the Configuration Manager, enable switching between debug and release modes to optimize compilation settings, such as including debug symbols or optimizing for performance. Deployment packaging simplifies distribution by bundling executables, resources, and dependencies into installers or standalone files. A typical workflow begins with creating a new form in the Form Designer, dragging a button component onto it, and double-clicking the button to generate its OnClick event handler. In the Code Editor, the developer implements the logic, such as displaying a message. For a "Hello World" example, the event procedure might be written as:

procedure TForm1.Button1Click(Sender: TObject); begin ShowMessage('Hello World'); end;

procedure TForm1.Button1Click(Sender: TObject); begin ShowMessage('Hello World'); end;

Compiling and running the project from the IDE then tests the application, with the debugger available for any refinements. This cycle—design, code, debug, build—accelerates iteration. The IDE's extensibility allows customization through a plugin architecture, where developers create design-time packages to add custom components or property editors to the Tool Palette. The Tools API further enables extensions like custom menu items, toolbar buttons, and form-creation wizards, integrating third-party functionality without altering the core IDE.

Backward compatibility

Delphi maintains a strong emphasis on backward compatibility, allowing developers to compile and run code from early versions with minimal modifications in subsequent releases. Embarcadero Technologies has committed to preserving core language syntax without breaking changes since Delphi 1, ensuring that Object Pascal code written decades ago remains viable. This policy extends to extended support for older editions, facilitating long-term maintenance of legacy systems. To handle version-specific differences, Delphi employs compiler directives such as {IFDEF} and {IFNDEF} for conditional compilation. These directives enable developers to include or exclude code blocks based on predefined symbols, like version constants (e.g., {IF CompilerVersion > 25}), allowing a single codebase to support multiple Delphi releases without duplication. For instance, in Unicode-enabled versions post-Delphi 2009, developers can use {IFDEF UNICODE} to conditionally manage string types, ensuring compatibility with pre-Unicode AnsiString declarations. The (VCL) and Run-Time Library (RTL) are engineered for , prioritizing stability over disruptive updates. Embarcadero uses warnings—issued via the deprecated directive when obsolete entities are referenced—rather than immediate breaking changes, giving developers time to adapt while preserving existing functionality. This approach minimizes recompilation issues for legacy applications reliant on VCL controls or RTL routines. In RAD Studio 13 Florence (released September 10, 2025), GetIt Packages Versioning allows selecting specific package versions to further support compatibility. Migration from older versions is supported by built-in tools, including the Delphi Upgrade Advisor wizard, introduced in RAD Studio 13 Florence (released September 10, 2025), which scans projects for configuration and code changes required during upgrades, such as from Delphi 7 to Delphi 12. This wizard identifies issues like Unicode string handling shifts after Delphi 2009, where default String types transitioned to Unicode, and suggests automated fixes. The Embarcadero Migration and Upgrade Center further provides resources, including a Unicode Statistics Tool to analyze and convert AnsiString usages for compatibility. Key challenges arise in architectural transitions, such as from 16-bit (Delphi 1) to 32-bit and later 64-bit platforms, where pointer sizes change from 16-bit to 64-bit NativeUInt types, necessitating adjustments in pointer arithmetic and addressing to avoid overflows or invalid casts. Solutions involve using platform-agnostic types like PtrInt or NativeInt for calculations and conditional directives to isolate architecture-specific code; Delphi's RTL also retains wrappers for legacy Windows APIs, ensuring calls from early versions function in 64-bit environments with minimal rework. This compatibility framework enables indefinite maintenance of applications developed in the , with a reported backward compatibility rate approaching 100%, reducing the for enterprises reliant on long-lived software.

Supported Platforms and Frameworks

Cross-platform capabilities

supports the development and deployment of native applications across multiple operating systems, including Windows (both 32-bit and 64-bit using the or VCL), macOS, , Android (via the or FMX framework for multi-device applications), and (with console applications natively and GUI support through FMX or third-party libraries). The compilation model allows a single codebase to produce native binaries for each target platform without emulation or , leveraging platform-specific compilers that generate directly for the architecture. For non-Windows targets such as ARM-based mobile platforms and , uses an backend to optimize code generation and ensure efficient execution. For mobile development, Delphi incorporates FireUI within the FMX framework to create adaptive user interfaces that automatically adjust layouts and styles across devices, along with live preview capabilities for real-time testing on physical and Android devices. Built-in tools facilitate deployment, including automated signing, provisioning profiles for , and APK/ABB generation for Android with requirements. In 2025, Delphi 12.3 introduced enhanced server support with full FMX GUI capabilities for desktop applications and compatibility with Android API level 35 (Android 15), expanding deployment options for server-side and modern mobile environments. The Community Edition supports these platforms but imposes restrictions on commercial use, such as limiting revenue to under $5,000 annually and excluding advanced database connectivity. The porting process relies on platform-specific compiler directives and conditional compilation to handle OS differences, such as varying file path conventions (e.g., forward slashes on Unix-like systems versus backslashes on Windows) and threading models (e.g., POSIX threads on Linux versus Windows API threads). Developers can use directives like {IFDEF ANDROID} or {IFDEF LINUX} to include or exclude code sections tailored to each target, enabling seamless multi-platform maintenance from one codebase. Native compilation delivers high performance, with FMX applications on achieving speeds comparable to those developed in , as evidenced by benchmarks showing minimal overhead in rendering and UI responsiveness due to direct hardware access.

Built-in frameworks

Delphi includes several built-in frameworks that provide foundational libraries for development, , runtime utilities, and web services, enabling developers to build robust applications efficiently. These frameworks are integrated into the IDE and leverage Object Pascal's object-oriented paradigm for component-based design. The (VCL) is a Windows-specific framework for creating native desktop applications, offering over 100 visual and non-visual components such as TButton for buttons and TDataGrid for data display. It supports themes for customizable appearances and high-DPI scaling to ensure crisp rendering on modern displays, making it ideal for traditional Windows GUI development with direct integration to the . FireMonkey (FMX) serves as the cross-platform UI framework, utilizing vector-based rendering and GPU acceleration via or to deliver high-performance graphics and animations across Windows, macOS, , Android, and . Its style system allows for consistent theming and responsive layouts, supporting use cases like mobile apps and multi-device deployments with a unified . The Run-Time Library (RTL) forms the core utility layer, comprising base units for essential operations including string manipulation, file I/O, mathematical functions (e.g., via the SysUtils unit), and collection classes like TList. It also incorporates XML and parsing capabilities, along with networking support through the Indy components for protocols such as HTTP and TCP/IP, providing a platform-agnostic foundation for both VCL and FMX applications. For data access, FireDAC offers a universal connectivity framework with dataset components that bind directly to UI elements, supporting multiple databases including SQL Server, , , and through a common for queries, transactions, and caching. This enables seamless integration of data-driven features in desktop, mobile, and server applications without vendor-specific code. Web development is facilitated by IntraWeb, a server-side framework that extends VCL-like visual design to browser-based applications, allowing drag-and-drop creation of dynamic web UIs with session management and AJAX support. Additionally, built-in REST client and server components handle JSON-based services, including authentication, for building APIs and integrating with modern web ecosystems. Extensibility is achieved through class inheritance, permitting developers to create custom components by deriving from existing VCL, FMX, or RTL classes, which can then be palletized in the IDE for reuse across projects.

Interoperability options

Delphi provides robust foreign function interface (FFI) capabilities, allowing developers to call functions from C and C++ dynamic link libraries (DLLs) through external declarations in Pascal code. This integration is achieved by declaring the DLL functions with the appropriate calling conventions, such as stdcall for Windows APIs, enabling seamless invocation without recompiling the external library. For example, a C DLL exporting a simple arithmetic function can be linked and executed directly within a Delphi application by specifying the library name and function signature. Additionally, Delphi supports (COM) automation, facilitating integration with applications like Excel and Word. Developers can create objects or consume existing COM interfaces using built-in classes such as TWordApplication or TExcelApplication, which handle object creation, method invocation, and property access across process boundaries. This enables tasks such as generating reports or manipulating spreadsheets programmatically from Delphi code. For database interoperability, FireDAC offers native drivers for direct connectivity to over 20 database management systems (DBMS), including , , , SQL Server, , , , Firebird, and others, providing high-performance access without intermediate layers. It also supports ODBC bridges for broader compatibility with ODBC-compliant databases and limited JDBC integration via Java bridges for cross-language scenarios. FireDAC's dataset components, such as TFDQuery and TFDMemTable, function as ORM-like abstractions, allowing in-memory data manipulation, caching, and master-detail relationships akin to object-relational mapping tools. Delphi facilitates web services integration through built-in SOAP and REST clients, with the REST Client Library providing components like TRESTClient, TRESTRequest, and TRESTResponse for handling HTTP requests and responses. JSON and XML serialization is managed via classes in the System.JSON and System.XML units, enabling easy encoding and decoding of data structures for API consumption. For cloud services, HTTP components such as TNetHTTPClient support secure connections to platforms like AWS and Azure, allowing authentication via or API keys and integration with services such as S3 storage or Blob storage through RESTful endpoints. Language bridging in Delphi extends to hosting .NET assemblies via COM interop, where .NET DLLs can be registered as COM servers and invoked using Delphi's Variant types or imported type libraries for type-safe access. For Java integration, the Java Native Interface (JNI) can be used through external C++ wrappers or third-party bridges to call Java methods from Delphi. Embedding scripting languages is supported by integrating JavaScript via the ChakraCore engine, which exposes a C API for hosting JavaScript execution environments within Delphi applications, enabling dynamic code evaluation and interop with native objects. WebAssembly (Wasm) support for browser-based deployment is available through third-party tools such as TMS Web Core, which transpiles Pascal code to JavaScript and Wasm for client-side execution. Additionally, AI and machine learning library hooks have been expanded, including bindings for TensorFlow via third-party tools like Python4Delphi or Keras4Delphi, enabling model training and inference within Delphi applications for tasks such as image recognition or predictive analytics. The official SmartCore AI Components Pack, introduced in Delphi 13 Florence (September 2025) and available via the GetIt Package Manager, further simplifies integration with providers like OpenAI and TensorFlow by providing modular VCL/FMX components for API calls and data processing. Best practices for interoperability emphasize proper marshaling to avoid alignment issues, such as using packed for C-style structures and explicit type conversions for strings (e.g., PAnsiChar for C strings). Error handling across boundaries requires checking return codes from external functions, wrapping calls in try-except blocks to catch exceptions, and propagating errors via HRESULT for COM or custom result codes for DLLs, ensuring robust failure recovery without crashes. Developers should also limit interop to standard C types, avoid passing complex objects directly, and test for platform-specific behaviors to maintain compatibility.

History

Origins and early development

The origins of Delphi lie in Borland's Turbo Pascal, a groundbreaking integrated development environment and compiler for the Pascal programming language released in November 1983. Created by Danish programmer Anders Hejlsberg, Turbo Pascal was built on a licensed core from his earlier Compas Pascal project and targeted the IBM PC, offering exceptionally fast compilation and an all-in-one editor, debugger, and linker that made programming accessible and efficient for hobbyists and professionals alike. By May 1989, evolved into with version 5.5, introducing object-oriented extensions, modular units, and support for protected mode under , which enhanced its capabilities for larger-scale applications while maintaining with earlier Pascal code. This foundation addressed the growing demand for structured, reusable code in an era dominated by command-line tools. Delphi 1, launched on February 14, 1995, marked Borland's pivotal shift from command-line Pascal development to visual (RAD) for 16-bit , with Hejlsberg serving as chief architect. Motivated by the surging popularity of Microsoft's since 1991—which prioritized ease of GUI creation but relied on interpreted code—Delphi emphasized native compilation for superior and , positioning itself as a faster alternative for professional Windows desktop applications. Key initial features included the for seamless connectivity to local and client-server databases like and SQL servers, alongside the , a component-based framework that built on concepts from Borland's earlier Object Windows Library (OWL) for C++ but tailored for Object Pascal's RAD workflow. These innovations enabled developers to visually design forms, bind data-aware controls, and generate compiled executables without manual coding. Delphi 1 received rapid adoption among Windows developers for its productivity gains in building database-driven applications, earning praise as a paradigm-shifting tool that democratized professional-grade RAD and influenced subsequent IDE designs. Its cultural impact solidified Object Pascal's role in desktop software development, fostering a vibrant of components and third-party tools that accelerated Windows app creation in the mid-1990s.

Ownership transitions

Delphi's development began under International, which released the first version in 1995 and maintained ownership through the late 2000s, during which the company rebranded to Inprise Corporation in 1998 to emphasize and services amid shifting market focuses. The Inprise era was marked by financial difficulties, including persistent losses and a strategic pivot toward consulting services over product development, which strained resources for tools like Delphi. By 2000, the company reverted to the name as part of efforts to stabilize operations and refocus on core developer tools. In 2007, amid ongoing financial pressures, spun off its developer tools division, including Delphi, into a wholly owned named CodeGear to streamline operations and potentially attract buyers. David Intersimone, known as "David I," served as vice president of developer relations and chief evangelist for CodeGear, promoting the tools to the developer community during this transitional period. Embarcadero Technologies acquired CodeGear from Borland in July 2008 for approximately $23 million, marking a significant shift in Delphi's stewardship toward a stronger emphasis on database integration and cross-platform capabilities. Under Embarcadero, Marco Cantù emerged as a key figure, serving as chief developer advocate and later product manager for Delphi, guiding its evolution. This acquisition enabled Embarcadero to integrate Delphi into its RAD Studio suite, expanding from Windows-centric development to multi-platform support via frameworks like . Post-acquisition stability followed, with Embarcadero releasing the free Delphi Community Edition in 2015 alongside RAD Studio 10 Seattle to broaden accessibility for non-commercial and educational use. In 2015, Embarcadero became a of Idera, Inc., which has supported continued investment in Delphi without major disruptions. As of 2025, Embarcadero, under Idera, maintains annual updates, such as RAD Studio 13 , ensuring ongoing enhancements to Delphi's cross-platform features. These ownership changes profoundly impacted Delphi, transitioning it from a primarily Windows-only tool under Borland to a robust multi-platform IDE under Embarcadero, enabling native app development for Windows, macOS, , Android, and from a single codebase.

Major version releases

Delphi 2, released in 1996, marked the transition to 32-bit development for and NT, introducing support for and drag-and-drop capabilities to enhance component integration. Delphi 3, launched in 1997, expanded on this with improved decision cube components for data analysis and initial support, while Delphi 4 in 1998 added multithreading enhancements and a dockable IDE for better workflow efficiency. By Delphi 5 in 1999, the environment incorporated XML document support and web broker components for server-side application development, solidifying its role in enterprise Windows programming. Delphi 6, released in 2001, introduced the Cross-Platform Library (CLX) alongside , enabling initial Linux development. Delphi 7, arriving in 2002, refined these elements with optimizations for themes and stability improvements, including better debugging tools for cross-platform projects. During the CodeGear era, Delphi 2006 emphasized productivity with live templates and refactoring tools, while Delphi 2007 added further IDE enhancements like . Delphi 2009 introduced generics, anonymous methods, and completed the migration to full support, enabling more robust string handling across international applications. The Delphi XE series under Embarcadero debuted the (FMX) framework in 2010, with XE2 in 2011 bringing a 64-bit for Windows and expanding FMX for cross-platform UI development targeting Mac and . Subsequent releases like XE2 in 2011 expanded FMX to full multi-device support, XE3 in 2012 added high-DPI awareness, and XE4 through XE6 (2013–2014) refined mobile deployment with gesture controls and connectivity options. From Delphi 10 Seattle in 2015, the versioning shifted to numeric labels with annual releases, incorporating server support in 10.2 Tokyo (2017) via enhanced command-line tools. Delphi 11 Alexandria (2021) delivered full Android app development capabilities, including native access, while Delphi 12 Athens (2023) introduced support for macOS architecture and integrated AI code assistants for productivity. Point releases like 12.1 and 12.2 provided iterative updates to frameworks and compilers. Delphi 12.3 , released in March 2025, focused on compiler optimizations for faster build times, enhancements to FMX for web assembly integration, and critical security patches for cross-platform deployments, including support for 18, macOS 14, Android 15, and 24 LTS. 13 , released in September 2025 as part of RAD Studio 13, introduced a 64-bit IDE, AI components, support in the bundled , and new language extensions for improved productivity. Since 2010, Embarcadero has maintained an annual release cadence for major versions, supplemented by point updates to address emerging platform needs and developer feedback.

Community and Applications

Educational adoption

Delphi has been adopted in educational settings since the mid-1990s, building on the legacy of Borland's , which was widely used in schools and universities to teach concepts. As a (RAD) environment released in 1995, Delphi extended Pascal's educational appeal by enabling students to create Windows applications visually, aligning with early promotions emphasizing its suitability for introductory programming courses in high schools and colleges. The availability of the free Delphi Community Edition has significantly enhanced its accessibility for students, allowing unlimited use on personal machines after registration and providing full Edition features for non-commercial purposes, including educational projects. This edition is particularly beneficial for students, as it supports up to five installations on a shared network without cost, enabling home and classroom experimentation. Complementing this, Embarcadero's LearnDelphi.org platform offers extensive free tutorials and training videos, from beginner-level introductions to advanced topics, designed to guide students through Object Pascal syntax and application building. Delphi's visual programming tools offer pedagogical advantages for beginners by reducing the entry barrier compared to text-based languages, as the drag-and-drop interface allows immediate feedback on code changes without deep syntax knowledge. This approach fosters engagement through hands-on projects, such as developing simple databases for exercises or basic games to illustrate , helping students grasp concepts like object-oriented design more intuitively. In curricula, Delphi has been integrated as an alternative to languages like in introductory courses, particularly in vocational and higher education settings. For instance, a in Chinese higher vocational colleges demonstrated its effectiveness in case-based teaching, where students built a performance management system to apply database connectivity and GUI development, resulting in improved practical skills and motivation. It emphasizes to build foundational programming logic. As of 2025, Delphi's educational resources have incorporated cross-platform development examples, enabling students to create mobile apps for Android and iOS using shared codebases and frameworks. This update supports curricula focused on multi-device applications, with webinars and courses emphasizing native mobile UI design to prepare learners for contemporary software demands. Embarcadero's official Academic Program provides accredited institutions with the full Enterprise Edition at reduced costs, including and books tailored for classroom integration, while certifications like the Delphi Certified Developer validate student skills in language syntax, IDE usage, and project building. Additionally, open-source projects on platforms like , such as educational sample apps for database tutorials, encourage collaborative classroom use and extend learning beyond proprietary tools.

Commercial and notable uses

Delphi has found significant adoption in various industry sectors, particularly where rapid development of robust, cross-platform applications is essential. In , it powers systems and administrative tools, such as the Fineaid software developed by Software, which manages income, creditor actions, and linked accounts for administrators' offices. Similarly, developers have built mission-critical banking applications using Delphi, leveraging its for handling financial transactions and . In healthcare, Delphi supports (EHR) solutions, as seen in ManagementPlus's multi-platform software for Windows, macOS, , and Android, enabling seamless data management across devices. Healthcare organizations worldwide utilize Embarcadero's platform for custom applications in monitoring and administrative systems. For and , Delphi facilitates industrial controls through interfaces like the Delphi-S7 library, which allows developers to access Siemens NET protocols for communication in PLC-based systems. Notable commercial products developed with Delphi include system optimization tools and file management utilities. Earlier versions of TuneUp Utilities, a popular PC maintenance suite from TuneUp Distribution , were built using Delphi for its fast compilation and native code performance, optimizing caches, RAM recovery, and system tuning. , a widely used from Ghisler Software , was originally developed with Delphi 2.0, enabling efficient handling of file operations, archives, and plugins while maintaining a compact footprint. Real-world case studies highlight Delphi's versatility in enterprise applications. Cross-platform ERP systems, such as those from e-vendo AG, integrate all retail business processes into a single database using Delphi and , supporting scalable operations for inventory, sales, and reporting. In desktop tools, Delphi powers plugins and extensions for applications like , enhancing functionality for file comparison and synchronization in professional workflows. These examples demonstrate Delphi's role in building maintainable, high-performance software for business-critical environments. As of 2025, Delphi's adoption in IoT and has grown due to enhanced support, allowing developers to target embedded systems and connect apps to sensors, devices, and services via Embarcadero's IoT frameworks. Companies globally use Delphi for , reflecting its ongoing relevance in enterprise settings. In enterprise contexts, Delphi offers advantages in for large codebases, as evidenced by applications that automatically scale across processors without manual intervention, and low maintenance through across versions. However, it faces challenges from its legacy perception, including compatibility issues with modern OS updates and a shrinking pool of specialized developers, though recent updates like improved integration and security features counter these by enabling modernization without full rewrites.

Future Developments

Roadmap announcements

Embarcadero Technologies released RAD Studio 13 Florence, including 13, on September 10, 2025. This version introduced a 64-bit IDE for Windows, new language features such as the ternary operator and NameOf function, and AI integration via the SmartCore AI Component Pack, available through GetIt, enabling developers to incorporate functionalities like into applications. Embarcadero has not published a detailed public roadmap since November 2020, but announcements through blogs and conferences indicate ongoing focus on AI enhancements, web technologies like WebStencils for improved session management, and platform updates. For example, GUI support via FMX Linux was re-released for Delphi 12.3 in May 2025, fulfilling earlier promises for cross-platform UI development. Feature availability remains tiered by edition, with advanced AI tools in Enterprise and editions. Beta programs and feedback continue to influence development priorities.

Community extensions

The Delphi has developed a rich ecosystem of third-party libraries that extend the language's capabilities in areas such as , data visualization, and networking. TMS Software provides a suite of VCL and FMX components, including advanced grids for and planners for scheduling applications, which are widely used to enhance desktop and cross-platform UIs in . DevExpress offers the VCL , featuring components for sophisticated user interfaces like quantum grids and customizable editors, enabling developers to build responsive and feature-rich applications without extensive custom coding. For open-source options, the Indy project delivers a comprehensive networking supporting over 100 protocols, including TCP, UDP, HTTP, and FTP, through client and server components that integrate seamlessly with Delphi projects. IDE enhancements from the community further boost productivity by addressing limitations in the native environment. GExperts is a free, open-source collection of tools that includes templates, expert wizards for common tasks, and editor enhancements like improved search and replace functions, helping developers streamline coding workflows. ModelMaker Code Explorer provides refactoring capabilities, such as method extraction and class diagramming, along with advanced navigation to support large-scale maintenance. , originally a third-party plugin for structural highlighting and parsing, was acquired by Embarcadero in 2014 and integrated into the RAD Studio IDE starting with XE7, where it continues to offer features like syntax-aware and management. Platforms like the GetIt Package Manager facilitate the discovery and installation of these extensions directly within the IDE, supporting both official and community-contributed packages to simplify dependency management across Delphi versions. On GitHub, the Delphi community maintains thousands of repositories, ranging from utility libraries to full applications, fostering collaboration through version control and open contributions. Community events play a vital role in knowledge sharing, with conferences such as Delphi Day in Italy and the Global Delphi Summit in Amsterdam providing sessions on advanced topics and networking opportunities for developers. Online forums like the DelphiPraxis community and the r/delphi subreddit on Reddit serve as hubs for discussions, while the delphi tag on Stack Overflow has amassed over 100,000 questions, offering a vast archive of peer-reviewed solutions. In 2025, open-source contributions have increasingly focused on AI integration, with projects like the Delphi-AI-Developer plugin providing wrappers for APIs such as and Gemini to enable AI-assisted coding directly in the IDE, and the GenAI offering optimized access to models like GPT-4o for application embedding. Contribution models emphasize open-source licensing, such as the (MPL) used in projects like Indy, which permits free use, modification, and distribution while requiring source availability for changes to licensed files. Embarcadero supports these efforts through certification programs, including the Delphi Certified Developer exam, which validates expertise in integrating and extending components within the .

References

  1. https://www.embarcadero.com/products/delphi
  2. https://www.embarcadero.com/products/delphi/features/delphi
  3. https://www.embarcadero.com/products/rad-studio/whats-new-in-13-florence
  4. https://blogs.embarcadero.com/26-years-of-delphi/
  5. https://www.infoworld.com/article/2166995/embarcadero-buys-codegear.html
  6. https://www.embarcadero.com/products/delphi/starter/free-download
  7. https://blog.marcocantu.com/blog/why_skype_used_delphi.html
  8. https://www.embarcadero.com/products/delphi/starter
  9. https://docwiki.embarcadero.com/RADStudio/Athens/en/Language_Overview
  10. https://docwiki.embarcadero.com/RADStudio/Alexandria/en/Using_Reference_Counting
  11. https://embarcaderoacademy.com/p/coding-in-delphi
  12. https://blogs.embarcadero.com/turbo-pascal-turns-40/
  13. https://docwiki.embarcadero.com/RADStudio/Athens/en/Using_Inline_Assembly_Code
  14. https://blogs.embarcadero.com/is-delphi-a-memory-safe-language/
  15. https://blogs.embarcadero.com/secure-your-delphi-applications-using-flexible-cryptolib4pascal-library/
  16. https://docwiki.embarcadero.com/RADStudio/Athens/en/Refactoring_Code
  17. https://docwiki.embarcadero.com/RADStudio/en/Using_Code_Insight
  18. https://docwiki.embarcadero.com/RADStudio/Athens/en/Git_Integration_in_the_IDE
  19. https://blog.marcocantu.com/blog/2023-march-delphi-cpp-memory.html
  20. https://docwiki.embarcadero.com/RADStudio/Athens/en/Form_Designer
  21. https://docwiki.embarcadero.com/RADStudio/Sydney/en/Event_Handlers
  22. https://docwiki.embarcadero.com/RADStudio/Athens/en/Integrated_Development_Environment
  23. https://docwiki.embarcadero.com/RADStudio/Athens/en/Tour_of_the_IDE
  24. https://docwiki.embarcadero.com/RADStudio/Athens/en/MSBuild
  25. https://docwiki.embarcadero.com/RADStudio/en/Building_a_VCL_Forms_Hello_World_Application
  26. https://docwiki.embarcadero.com/RADStudio/Athens/en/Packages_%28Delphi%29
  27. https://docwiki.embarcadero.com/RADStudio/Athens/en/Extending_the_IDE_Using_the_Tools_API
  28. https://blogs.embarcadero.com/why-rad-studio-apps-are-forever/
  29. https://docwiki.embarcadero.com/RADStudio/Athens/en/Unicode_in_RAD_Studio_Index
  30. https://docwiki.embarcadero.com/RADStudio/Sydney/en/Deprecated
  31. https://blog.marcocantu.com/blog/2025-september-upgrade-advisor.html
  32. https://www.embarcadero.com/rad-in-action/migration-upgrade-center
  33. https://www.embarcadero.com/images/dm/technical-papers/delphi-unicode-migration.pdf
  34. https://blogs.embarcadero.com/announcing-the-availability-of-rad-studio-13-florence/
  35. https://docwiki.embarcadero.com/RADStudio/Athens/en/Simple_Types
  36. https://www.embarcadero.com/products/delphi/features/develop
  37. https://docwiki.embarcadero.com/RADStudio/Sydney/en/LLVM-based_Delphi_Compilers
  38. https://blogs.embarcadero.com/fmx-linux-for-delphi-12-3-is-now-available/
  39. https://blogs.embarcadero.com/rad-studio-12-3-brings-android-api-level-35-support-for-delphi-developers/
  40. https://docwiki.embarcadero.com/RADStudio/Sydney/en/VCL
  41. https://docwiki.embarcadero.com/RADStudio/Athens/en/Introducing_the_Visual_Component_Library_%28VCL%29
  42. https://docwiki.embarcadero.com/RADStudio/Sydney/en/FireMonkey
  43. https://docwiki.embarcadero.com/Libraries/Athens/en/FMX
  44. https://docwiki.embarcadero.com/RADStudio/Florence/en/Using_the_RTL_%28Run-Time_Library%29
  45. https://docwiki.embarcadero.com/RADStudio/Alexandria/en/RTL
  46. https://docwiki.embarcadero.com/RADStudio/Athens/en/FireDAC
  47. https://docwiki.embarcadero.com/RADStudio/Sydney/en/Overview_%28FireDAC%29
  48. https://docwiki.embarcadero.com/RADStudio/Sydney/en/Getting_Started_with_IntraWeb
  49. https://docwiki.embarcadero.com/RADStudio/Sydney/en/Creating_Web_Server_Applications_Using_IntraWeb
  50. https://blogs.embarcadero.com/how-to-use-a-c-dll-in-any-delphi-program/
  51. https://docwiki.embarcadero.com/RADStudio/Sydney/en/Developing_COM_Applications
  52. https://docwiki.embarcadero.com/RADStudio/Florence/en/FireDAC
  53. https://docwiki.embarcadero.com/RADStudio/en/Connect_to_ODBC_Data_Source_%28FireDAC%29
  54. https://docwiki.embarcadero.com/RADStudio/en/Tutorial:_Using_the_REST_Client_Library_to_Access_REST-based_Web_Services
  55. https://blogs.embarcadero.com/using-a-net-assembly-via-com-in-delphi/
  56. https://blogs.embarcadero.com/take-your-delphi-c-builder-projects-to-the-next-level-with-chakra-jscript-engine/
  57. https://learndelphi.org/what-you-need-to-know-about-using-webassembly-with-delphi/
  58. https://blogs.embarcadero.com/introducing-the-smartcore-ai-components-pack/
  59. https://github.com/Pigrecos/Keras4Delphi
  60. http://rvelthuis.de/articles/articles-dlls.html
  61. https://www.progkids.com/en/blog/istoriya-yazyka-programmirovaniya-turbo-paskal-i-ego-sozdatelya
  62. https://blogs.embarcadero.com/delphi-timewarp-1995-and-delphis-mythical-origins/
  63. https://halfhill.com/byte/1995-2_visual-pascal.html
  64. https://blogs.embarcadero.com/the-origins-of-delphi-rd-recounted-by-danny-thorpe-original-delphi-1-team-member/
  65. https://www.wsj.com/articles/SB893889192319083500
  66. https://www.cnet.com/tech/tech-industry/its-back-to-borland-for-troubled-software-maker/
  67. https://www.computerworld.com/article/1354989/struggling-inprise-to-become-borland-again.html
  68. https://www.infoworld.com/article/2162315/borland-changes-course-will-spin-off-tools-group.html
  69. https://www.theregister.com/2008/07/10/david_intersimone_embarcadero/
  70. https://www.embarcadero.com/products/delphi/previous-versions
  71. https://blogs.embarcadero.com/the-idera-inc-family-of-brands-3-3-devops-tools/
  72. https://blogs.embarcadero.com/rad-studio-13-october-patch-available/
  73. https://gdksoftware.com/knowledgebase/delphi-versions
  74. https://www.softacom.com/wiki/development/delphi-versions-a-complete-history-evolution/
  75. https://gdksoftware.com/knowledgebase/whats-new-since-delphi-5
  76. https://www.embarcadero.com/press-releases/rad-studio-12-3-released
  77. https://retrocomputing.stackexchange.com/questions/6717/what-caused-the-downfall-of-pascal
  78. https://www.embarcadero.com/development-tools-for-education
  79. https://learndelphi.org/
  80. https://intellisoft.io/delphi-programming-language-a-beginners-guide/
  81. https://www.atlantis-press.com/proceedings/scict-14/12875
  82. https://www.classcentral.com/report/best-delphi-courses/
  83. https://learndelphi.org/delphi-30-for-30-webinars-2025/
  84. https://gdksoftware.com/case/groundbreaking-delphi-software-for-administrators-offices
  85. https://www.embarcadero.com/case-study/managementplus-case-study
  86. https://mall.industry.siemens.com/mall/en/oeii/Catalog/Products/10025251
  87. https://jonlennartaasenden.wordpress.com/2014/11/06/famous-software-made-with-delphi/
  88. https://www.ghisler.ch/board/viewtopic.php?t=2904
  89. https://www.embarcadero.com/case-study/e-vendo-360-cloud-omnichannel-solution-case-study
  90. https://blogs.embarcadero.com/
  91. https://www.tmssoftware.com/
  92. https://www.indyproject.org/
  93. https://www.gexperts.org/
  94. https://appdevelopermagazine.com/embarcadero-technologies-grows-its-rad-studio-platform-with-acquisition-of-castalia-for-delphi-and-usertility-from-twodesk-software-/
  95. https://www.delphiday.it/
  96. https://delphisummit.com/
  97. https://stackoverflow.com/questions/tagged/delphi
  98. https://github.com/Code4Delphi/Delphi-AI-Developer
  99. https://getitnow.embarcadero.com/genai-optimized-openai-integration-wrapper/
  100. https://www.embarcadero.com/resources/embarcadero-certification-center
Add your contribution
Related Hubs
User Avatar
No comments yet.