Delphi 7 to Delphi 13:
The upgrade, step by step.

Upgrading a Delphi 7 application to Delphi 13 is a project with five parts: the Unicode string change, the component inventory, the data layer, the project and build files, and testing. Most applications can go straight to the current compiler. The assessment decides that, and decides whether upgrading Delphi or moving to .NET is the better use of the budget.

Book a free 1-hour consultation →

At a glance

Legacy sources: Delphi 5 · Delphi 6 · Delphi 7 · Delphi 2005 · Delphi 2006 · Delphi 2007 · BDE · Object Pascal
Modern targets: Delphi 13 Florence · Win64 build · Unicode strings · FireDAC · MSBuild pipeline · Windows on Arm · C# .NET 10
First step: Free 1-hour consultation, then a fixed-scope assessment
U.S. delivery: 100% U.S. citizen workforce, U.S.-soil delivery

What to know before you modernize

What the upgrade project is, and what it is not

Delphi 7 to Delphi 13 is a toolchain upgrade, not a rewrite. The source stays Object Pascal, the forms stay VCL, and the people who know the code keep their knowledge. What changes is the compiler, the string type, the component set, the project files, and the way the application is built and tested. That is why the work is predictable once the inventory is done and unpredictable before it. The same project applies to Delphi 5, 6, 2005, 2006, and 2007 source, with extra steps for the oldest releases. This page covers the whole project end to end. The overview of all three paths is on the Delphi modernization page, the data layer has its own page, and a 64-bit-only guide covers the compiler switch in detail.

Delphi modernization overview →

What Delphi 13 is today

Embarcadero announced general availability of RAD Studio 13 Florence, including Delphi 13, on September 10, 2025. Release 13.2 shipped on September 17, 2026. It extends Delphi support for Windows on Arm using Arm64EC, moves the complete Delphi Linux Intel 64-bit compiler toolchain to LLVM 20, adds two VCL controls for modern navigation patterns, TTabView and TNavigationView, and updates Android SDK and NDK integration. Delphi 13 includes the first full-featured 64-bit IDE, which builds and debugs 64-bit Windows applications. Delphi targets Windows, macOS, iOS, Android, and Linux, with Linux support in the Enterprise and Architect editions. The language gained a ternary operator written with the if keyword, a NameOf function, and wider generic type constraints. None of these additions is required to compile old code.

Delphi 7 to 64-bit →

Stepwise or direct: choosing the path through the versions

The dividing line in the version history is Delphi 2009, which made the string type Unicode. Code from Delphi 5, 6, 7, 2005, 2006, and 2007 is all on the old side of that line, so the Unicode work is the same whichever of those you start from. In most cases we recommend a direct move to the current compiler with the Unicode and component work done once, rather than installing and testing every intermediate release. A stepwise path is worth the cost in two cases. The first is a very large code base that cannot be fixed in one pass, where moving first to a mid-range release shrinks each step. The second is an application with compiled-only components, where an older toolchain is needed to keep it running while replacements are built. The assessment records which case you are in before any work starts.

The Unicode string change, the largest break

Before Delphi 2009, string was an alias for AnsiString and Char and PChar were single-byte types. Since then, string means UnicodeString, Char means WideChar, which is two bytes, and PChar means PWideChar. AnsiString, AnsiChar, PAnsiChar, and WideString keep their meanings, and implicit conversions between them still compile, so much old code builds unchanged and then misbehaves. The failures are in code that assumes one byte per character: buffers declared as arrays of Char, Move and FillChar calls with hard-coded byte counts, stream reads and writes, pointer arithmetic on PChar, set of Char constructs that now need CharInSet, and calls into Windows or third-party DLLs that expect ANSI data. Each is fixed with SizeOf(Char), explicit AnsiString or TEncoding handling, or a deliberate change to PAnsiChar. Files and database columns that held ANSI text need an encoding decision too.

Delphi modernization overview →

Other language and RTL changes that bite

Generics and anonymous methods are additions. Old code does not need them and does not break because of them, so they can be adopted file by file later. The changes that cost time are removals and deprecations. TThread.Suspend and TThread.Resume are deprecated, documented as meant for debugging, and prone to deadlocks; threads built on them should move to TEvent or TMutex synchronization. Help systems, printing, and any Windows API wrappers should be checked against the current OS rather than assumed to work. Units and routines that were renamed, moved, or retired across the intervening releases show up as compile errors, which is the easy case. The hard case is silent behavior change in the RTL, which is why the test plan matters as much as the compile. The assessment lists the deprecated calls found in your source.

Component and library inventory

The component list sets the schedule more than the line count does. A Delphi 7 project usually depends on packages installed years ago, some with source, some compiled-only, and some no one can name. Each package falls into one of four groups. Still shipped by a vendor with a current Delphi 13 build: renew the license and update the call sites. Source available but no vendor: carry it forward and fix Unicode and 64-bit issues yourself. Replaced by a built-in or open-source equivalent: swap it, usually behind a thin wrapper. Compiled-only and orphaned: rebuild, replace, or isolate it, and decide that before the schedule is set. Reporting engines, grids, charting, and communications libraries are the usual problem packages. The data layer is its own inventory, covered on the BDE replacement page.

BDE replacement for Delphi →

Project files, forms, and the IDE

Delphi 7 keeps compiler options in project-level option files; current Delphi stores them in an MSBuild-format .dproj file, so the project is re-created or imported once and then reviewed setting by setting. Search paths, conditional defines, and package lists are the usual casualties and are worth rewriting by hand rather than trusting the import. Forms are the smaller risk. The .dfm files load in the current IDE, but forms that reference removed properties or missing components fail to open, and font, scaling, and high-DPI behavior need a visual pass on modern displays. The IDE itself is a real change: Delphi 13 includes a full 64-bit IDE, so design-time packages must be available as 64-bit builds where the IDE loads them. Keeping the old IDE available for comparison during the work is cheap and worth it.

Source control, build automation, and tests

Most Delphi 7 shops build by pressing F9 on one machine. The upgrade is the moment to fix that. Current Delphi projects build from the command line with MSBuild, passing the .dproj file along with the configuration and platform, for example Release and Win64. That makes a build server possible, and a build server makes every later change safer. Put the source, the third-party component sources, and the build scripts under version control first, then require a clean build from a fresh checkout. For tests, assume the application has few. The practical approach is characterization tests that record what the old build does with real inputs: report output, calculations, exported files, and database writes. The same tests then run against the Delphi 13 build and the differences are reviewed one by one. This is also the safety net if a .NET move follows later.

Editions, Community Edition terms, and licensing

Delphi is sold in four editions: Community, Professional, Enterprise, and Architect. Enterprise adds client/server data access and Linux support, and Architect adds multi-site server deployment and data modeling on top of Enterprise. Community Edition is free but narrow: it is for individuals, startups, students, and nonprofits with revenue under US$5,000 a year, it is limited to teams of five or fewer, its license runs one year and does not renew automatically, and it always covers only the newest release. A company running a production Delphi 7 application is not a Community Edition customer. Commercial licenses are perpetual. Update Subscription is the maintenance plan: the first year comes with the purchase, it is renewed annually, and the license keeps working if it lapses, but updates and hotfixes stop and resubscribing costs more than renewing.

When to stay on Delphi, and when to move to .NET

Stay on Delphi when the application is sound, the team can read Object Pascal, and the goal is a supported 64-bit Windows toolchain. Delphi 13 is under active development, so this is a normal engineering choice and not a holding pattern. The upgrade is also the cheaper path when the component list is mostly vendor-supported. Move to C# on .NET when the business needs a web front end, a cloud deployment, a team that does not write Pascal, or a service boundary that other systems can call. Choose it also when orphaned components and the data layer make the upgrade nearly as large as a rewrite. A middle path keeps the Delphi client and moves business logic behind a service, one capability at a time. The comparison of those approaches is on the rewrite versus strangler fig page.

Rewrite vs strangler fig →

Start with an assessment for a Delphi codebase

The read-only assessment inventories the Delphi version and the project files, every unit and form, compiler directives and conditional defines, and the full component list with each package's vendor, license, and source status. It finds the code that assumes single-byte characters, the deprecated thread and RTL calls, inline assembler and pointer-size assumptions that matter for Win64, the data-access layers in use, COM and ActiveX interfaces, help and reporting formats, the database schema, the current build process, and whatever tests exist. Nothing is run and nothing in production is touched. The output is a written recommendation: direct upgrade, stepwise upgrade, bridge, or move to .NET, with the component plan and an ordered work list. Price and schedule are fixed after the assessment, and its fee is creditable toward the project that follows.

About the assessment →

Deliverables

  • Written recommendation: direct upgrade, stepwise upgrade, bridge, or move to .NET, with reasons
  • Component plan: keep, renew, patch, replace, or isolate, per package
  • Unicode migration of the source, with encoding decisions for files and data
  • Delphi 13 project files and a command-line MSBuild build from a clean checkout
  • Characterization tests that compare the old build and the new build on real inputs
  • Win64 build, where the assessment shows it is worth doing

Common questions

Can I upgrade Delphi 7 directly to Delphi 13?

Usually yes. The Unicode string change is the same whichever older release you start from, so most projects do that work once against the current compiler. A stepwise path through intermediate releases is justified for very large code bases or when compiled-only components need an older toolchain while replacements are built. The assessment states which applies.

Does Delphi 7 still run on Windows 11?

A 32-bit Delphi 7 application generally runs on 64-bit Windows 11 through the 32-bit compatibility layer. The problems are around it: the Borland Database Engine, old drivers, COM registration, and an IDE that few people can still install cleanly. Running is not the same as supported or maintainable, which is what the upgrade addresses.

What breaks when moving from Delphi 7 to Unicode Delphi?

Code that assumes one byte per character. That means arrays of Char, Move and FillChar with fixed byte counts, PChar arithmetic, stream and file I/O of text, set of Char, and calls to DLLs that expect ANSI strings. Much of it still compiles and then fails at run time, so tests on real data matter more than a clean build.

Should I upgrade Delphi or migrate to .NET?

Upgrade when the application is sound, the team reads Pascal, and Windows is the platform. Migrate when you need web or cloud delivery, a team in C#, or when orphaned components make the upgrade as large as a rewrite. Delphi 13 is actively developed, so staying on Delphi is a legitimate choice and not a fallback.

Can we use Delphi Community Edition for our company's application?

Generally no. Community Edition is for individuals, startups, students, and nonprofits with revenue under US$5,000 a year, for teams of five or fewer. The license lasts one year, does not auto-renew, and covers only the newest release. A company with a production application should plan for a Professional, Enterprise, or Architect license.

Can we keep running the old Delphi 7 build during the upgrade?

Yes. The old executable stays in production while the new build is developed from the same source, and the two are compared on real inputs before cutover. Putting the source under version control and adding an automated build at the start keeps both builds reproducible during the work.

How long will the upgrade take and what will it cost?

It depends on scope, mainly the component list and the data layer. Every engagement starts with a free 1-hour consultation. Price and schedule are fixed after the fixed-scope Legacy Software Assessment, whose fee is creditable toward a later modernization project. Project work ranges from a few weeks to several months.

Do we have to rewrite everything to get to Delphi 13?

No. The upgrade keeps the code base and changes only what the new compiler and platform require: string handling, deprecated calls, unsupported components, project files, and the data layer where needed. Generics and anonymous methods are optional additions you can adopt later, file by file.

Sources

Not sure where to start?

Start with a fixed-scope Legacy Software Assessment: a read-only review of your application’s source, database, configuration, logs, and architecture, ending in findings with evidence and a written recommendation. Quoted after the free 1-hour consultation; creditable toward a subsequent modernization project.