Object Pascal setup: FPC, modes and Delphi

A Free Pascal program that adds 1 to 2,147,483,647 prints −2,147,483,648 without a word, because the checks that would stop it are off until you switch them on, and on a 64-bit Mac the overflow check alone still lets this one through. Object Pascal is the language of Delphi and Lazarus, and Free Pascal 3.2.2 is the open-source compiler that runs every example of this mini-course, here on a Mac with Apple silicon; it is released for Windows and Linux too.

Here you install the compiler in a folder of your own and read what its first build prints. You choose between its two main dialects, objfpc and delphi, predict which setting wins when the configuration file, the command line and the file itself disagree, switch on the checks that stop a mark of 101, and see how Free Pascal, Lazarus and Delphi relate.

One fpc command compiles and links a program

For macOS the Free Pascal download page offers an installer disk image, fpc-3.2.2.intelarm64-macosx.dmg, and the release’s own folder for Apple silicon, aarch64-darwin, also holds a plain tarball, fpc-3.2.2.aarch64-darwin.tar, which this mini-course installs. The project’s home page calls 3.2.2 the latest stable version; development versions are numbered 3.3.x. The tarball holds an installer script, install.sh, which asks where to install. The User’s Guide points out that the tar file lets you install below your home folder when you have no root rights, and the macOS download notes add that the compiler needs Apple’s Command Line Tools, whose linker it calls. Step through the whole path, from the download to a running program, with the two checks that can send you back:

The recorded session starts at the fourth stage, with the compiler installed. Here is the program it builds. The three values between % signs are filled in by the compiler, so the program reports what built it:

program Hello;
{ A first Object Pascal program. The compiler fills in the three %FPC...% values
  while it compiles, so the program reports the compiler and the target it was built for. }
{$mode objfpc}{$H+}

uses
  SysUtils;

begin
  WriteLn(Format('Hello from Free Pascal %s', [{$I %FPCVERSION%}]));
  WriteLn(Format('Built for %s on %s', [{$I %FPCTARGETCPU%}, {$I %FPCTARGETOS%}]));
  WriteLn(Format('%d + %d = %d', [40, 2, 40 + 2]));
end.

Each command of the session follows a $, and the lines below it are what the command printed:

from session import run

# The first session of the Object Pascal mini-course: ask the compiler for its version and target, then build and
# run a first program with the default output, read the size of what was built, see which configuration file the
# compiler read, build once more without the banner and the progress lines, and once with smart linking (-XX).
run("""
fpc -iV
fpc -iTP
fpc -iTO
fpc hello.pas
./hello
wc -c < hello
fpc -vt hello.pas 2>&1 | grep -e 'Configfile search' -e 'Reading options'
fpc -l- -vi- hello.pas
fpc -l- -vi- -XX hello.pas -ohello_small
./hello_small
wc -c < hello_small
""")

$ fpc -iV
3.2.2
$ fpc -iTP
aarch64
$ fpc -iTO
darwin
$ fpc hello.pas
Free Pascal Compiler version 3.2.2 [2022/10/19] for aarch64
Copyright (c) 1993-2021 by Florian Klaempfl and others
Target OS: Darwin for AArch64
Compiling hello.pas
Assembling hello
Linking hello
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
13 lines compiled, … sec
$ ./hello
Hello from Free Pascal 3.2.2
Built for aarch64 on Darwin
40 + 2 = 42
$ wc -c < hello
 1053720
$ fpc -vt hello.pas 2>&1 | grep -e 'Configfile search' -e 'Reading options'
Configfile search: ~/.fpc.cfg
Configfile search: …/etc/fpc.cfg
Reading options from file …/etc/fpc.cfg
$ fpc -l- -vi- hello.pas
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ fpc -l- -vi- -XX hello.pas -ohello_small
ld: warning: option '-no_dead_strip_inits_and_terms' is obsolete, use '-dead_strip' instead
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./hello_small
Hello from Free Pascal 3.2.2
Built for aarch64 on Darwin
40 + 2 = 42
$ wc -c < hello_small
  223496

Read it from the top. fpc -iV prints the short version, 3.2.2, the pintoolchain pin: The exact version of the compiler, interpreter or SDK that an example was built and run with, such as Tcl 9.0.4 or the .NET SDK 10.0.401. Another version may print something else for the same file. More in “How the Language Atlas works” of every example in this mini-course, and -iTP and -iTO print the target processor and system, aarch64 and darwin. The first build shows the compiler’s banner, the target, one line per step (Compiling, Assembling, Linking) and the number of lines compiled, 13. The two lines before that count come from Apple’s linker, which objects to two options that Free Pascal 3.2.2 still passes to it. The program is not affected, and the same two lines follow every build in this mini-course.

The compiler took most of its options from a configuration file, fpc.cfg. With -vt it lists where it looked: first ~/.fpc.cfg in your home folder, then …/etc/fpc.cfg, the etc folder above the compiler’s bin folder (… is the folder you installed into), and it read the second. The User’s Guide gives the full order on Unix-like systems: the current folder, ~/.fpc.cfg, the folder named by PPC_CONFIG_PATH, the etc folder above the compiler, then /etc. The first file found is the one used. install.sh writes ~/.fpc.cfg when it cannot write to /etc.

The program is 1,053,720 bytes, already without debug information: the sample configuration adds -Xs, which strips it. Units are linked in whole by default, and with -XX, smart linking, only the parts the program calls are kept; the same program came to 223,496 bytes, about a fifth, and the linker added a third warning of the same kind. The last builds pass -l- and -vi-, which leave out the banner and the progress lines, so only the linker’s lines remain. The later lessons of this mini-course build that way.

The mode decides which Pascal the compiler reads

Compile a short program with a class in it and no mode directive, and Free Pascal stops at the first line that uses the word: Identifier not found "class". The same file compiles with -Mobjfpc. Free Pascal reads several dialects of Pascal, and the compiler modecompiler mode: The dialect a Free Pascal file is compiled in, chosen with {$mode …} in the file or -M on the command line: fpc (the default), objfpc, delphi, delphiunicode, tp and others. The mode decides, among other things, whether class is a keyword and how big an Integer is. chooses one. In the default, fpc mode, class is not a keyword, an Integer has 16 bits and a string is a ShortStringShortString: Pascal's original string type: at most 255 characters, kept with a length byte in a fixed block of 256 bytes. In Free Pascal the word string means ShortString unless {$H+} is in force. of at most 255 characters; objfpc mode switches on classes, exceptions and interfaces. The session shows the class failing, then one program in four modes, and one generic record written the objfpc way and the delphi way:

from session import run

# A class without a mode directive, in the default mode and in objfpc mode; one program compiled in four modes;
# the same generic record in objfpc and in delphi syntax; and delphi syntax under {$mode objfpc}, which does not
# compile.
run("""
cd modes
!fpc -l- -vi- no_mode.pas
fpc -l- -vi- -Mobjfpc no_mode.pas
./no_mode
fpc -l- -vi- sizes.pas -osizes_fpc
./sizes_fpc
fpc -l- -vi- -Mobjfpc sizes.pas -osizes_objfpc
./sizes_objfpc
fpc -l- -vi- -Mdelphi sizes.pas -osizes_delphi
./sizes_delphi
fpc -l- -vi- -Mdelphiunicode sizes.pas -osizes_unicode
./sizes_unicode
fpc -l- -vi- pair_objfpc.pas
./pair_objfpc
fpc -l- -vi- pair_delphi.pas
./pair_delphi
!fpc -l- -vi- pair_wrong.pas
""")

$ cd modes
$ fpc -l- -vi- no_mode.pas
no_mode.pas(4,14) Error: Identifier not found "class"
no_mode.pas(5,5) Error: Error in type definition
no_mode.pas(5,5) Fatal: Syntax error, ";" expected but "identifier NAME" found
Fatal: Compilation aborted
Error: …/bin/ppca64 returned an error exitcode
[exit status 1]
$ fpc -l- -vi- -Mobjfpc no_mode.pas
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./no_mode
a class, compiled in objfpc mode: Asha
$ fpc -l- -vi- sizes.pas -osizes_fpc
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./sizes_fpc
SizeOf(Integer) = 2, High(Integer) = 32767
SizeOf(String) = 256, SizeOf(Char) = 1
$ fpc -l- -vi- -Mobjfpc sizes.pas -osizes_objfpc
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./sizes_objfpc
SizeOf(Integer) = 4, High(Integer) = 2147483647
SizeOf(String) = 256, SizeOf(Char) = 1
$ fpc -l- -vi- -Mdelphi sizes.pas -osizes_delphi
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./sizes_delphi
SizeOf(Integer) = 4, High(Integer) = 2147483647
SizeOf(String) = 8, SizeOf(Char) = 1
$ fpc -l- -vi- -Mdelphiunicode sizes.pas -osizes_unicode
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./sizes_unicode
SizeOf(Integer) = 4, High(Integer) = 2147483647
SizeOf(String) = 8, SizeOf(Char) = 2
$ fpc -l- -vi- pair_objfpc.pas
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./pair_objfpc
objfpc: Asha 72, Ravi 58
$ fpc -l- -vi- pair_delphi.pas
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./pair_delphi
delphi: Asha 72, Ravi 58
$ fpc -l- -vi- pair_wrong.pas
pair_wrong.pas(6,8) Fatal: Syntax error, "=" expected but "<" found
Fatal: Compilation aborted
Error: …/bin/ppca64 returned an error exitcode
[exit status 1]

SizeOf(Integer) is 2 in fpc mode and 4 in the others, so High(Integer) jumps from 32,767 to 2,147,483,647. SizeOf(String) is 256 bytes for a ShortString and 8, the size of a pointer, for the strings the Delphi modes use. In delphiunicode mode a Char takes 2 bytes, and string is a UnicodeString. The four modes this mini-course meets:

Generics show the difference best. In objfpc mode a generic type is declared with generic and every use names a type with specialize; the Reference Guide says delphi mode must not use either keyword. The two modes also treat procedure variables differently: objfpc needs the address operator, @, to assign one, while delphi mode takes the routine’s plain name, as Delphi code writes it. objfpc is the default mode of Lazarus source files, and delphi mode is the one for code written for Delphi.

Which mode a file should start with depends on where its code comes from and where it will live. Answer the three questions and the table marks what fits:

In short: {$mode objfpc}{$H+} for new code and for Lazarus, {$mode delphi} for code written for Delphi, and {$mode delphiunicode} only when that code expects string to hold 2-byte characters.

The last setting wins, and a mode resets {$H}

The program mode_and_r.pas starts with {$mode objfpc} and {$R-}, and it prints the settings it was compiled with. Built with fpc -Mdelphi -Sh -Cr, it printed objfpc mode, a ShortString and range checks off: none of the three options survived. The compiler reads its settings in a fixed order, the configuration file first, then the command line from left to right, then the file’s own directivescompiler directive: An instruction to the compiler written in the source, in braces that start with a dollar sign, such as {$mode objfpc} or {$R+}. It applies from the point where it appears, and it replaces the same setting given in fpc.cfg or on the command line. from top to bottom, and a later setting replaces an earlier one. Step through that build:

The surprising step is the sixth: a mode directive also sets {$H}. The Programmer’s Guide says a delphi mode directive implies {$H+} and all other modes switch it off (delphiunicode, which that page does not name, switched it on too in sizes.pas), and it draws the conclusion itself:

As a result, you should always put {$H+} after a mode directive.

The same two lines in the other order show what happens when you do not:

from session import run

# The order of the settings: {$H+} before and after the mode directive, then options on the command line that the
# file's own directives override.
run("""
cd order
fpc -l- -vi- h_before_mode.pas
./h_before_mode
fpc -l- -vi- h_after_mode.pas
./h_after_mode
fpc -l- -vi- -Mdelphi -Sh -Cr mode_and_r.pas
./mode_and_r
""")

$ cd order
$ fpc -l- -vi- h_before_mode.pas
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./h_before_mode
mode: objfpc
string: ShortString, at most 255 characters
range checks: off
$ fpc -l- -vi- h_after_mode.pas
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./h_after_mode
mode: objfpc
string: AnsiString
range checks: off
$ fpc -l- -vi- -Mdelphi -Sh -Cr mode_and_r.pas
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./mode_and_r
mode: objfpc
string: ShortString, at most 255 characters
range checks: off

h_before_mode.pas asked for {$H+} and got a ShortString, because the mode directive on the next line switched it off again. h_after_mode.pas got its AnsiString. A mode does not reset range or overflow checks: in the next section -Cr -Co stay on through the {$mode objfpc} of the file they build. So write the pair in this order, {$mode objfpc}{$H+}, at the top of every unit and program for objfpc mode.

Range and overflow checks are off until you switch them on

marks.pas declares a mark as the subrange 0..100 and stores 101 in it. Built as it is, it printed stored mark: 101: nothing checks a subrange unless range checkingrange checking: Code the compiler adds, with {$R+} or -Cr, that stops a program when a value leaves its declared range, such as 101 stored in a 0..100 subrange or an array index past the end. Free Pascal leaves it off unless you switch it on. is on, and the Programmer’s Guide says it is off by default. Built with -Cr, the command-line form of {$R+}, the same program stopped with Runtime error 201 and exit status 201, as the guide describes. The overflow program then tries the two classic overflows under each combination of checks:

from session import run

# Range and overflow checks, off by default: a subrange that accepts 101, then the same overflow program built
# without checks, with -Co ({$Q+}), with -Cr ({$R+}) and with both.
run("""
cd checks
fpc -l- -vi- marks.pas
./marks
fpc -l- -vi- -Cr marks.pas
!./marks
fpc -l- -vi- overflow.pas -ooverflow_none
./overflow_none
fpc -l- -vi- -Co overflow.pas -ooverflow_q
./overflow_q
fpc -l- -vi- -Cr overflow.pas -ooverflow_r
./overflow_r
fpc -l- -vi- -Cr -Co overflow.pas -ooverflow_rq
./overflow_rq
""")

$ cd checks
$ fpc -l- -vi- marks.pas
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./marks
stored mark: 101
$ fpc -l- -vi- -Cr marks.pas
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./marks
Runtime error 201 at $…
  $…
[exit status 201]
$ fpc -l- -vi- overflow.pas -ooverflow_none
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./overflow_none
Integer: 2147483647 + 1 = -2147483648
Int64:   High(Int64) + 1 = -9223372036854775808
$ fpc -l- -vi- -Co overflow.pas -ooverflow_q
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./overflow_q
Integer: 2147483647 + 1 = -2147483648
Int64:   EIntOverflow: Arithmetic overflow
$ fpc -l- -vi- -Cr overflow.pas -ooverflow_r
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./overflow_r
Integer: ERangeError: Range check error
Int64:   High(Int64) + 1 = -9223372036854775808
$ fpc -l- -vi- -Cr -Co overflow.pas -ooverflow_rq
-macosx_version_min has been renamed to -macos_version_min
ld: warning: -multiply_defined is obsolete
$ ./overflow_rq
Integer: ERangeError: Range check error
Int64:   EIntOverflow: Arithmetic overflow

The four builds of overflow.pas, side by side:

The second row is the surprise: overflow checkingoverflow checking: Code the compiler adds, with {$Q+} or -Co, that stops a program when integer arithmetic overflows. On a 64-bit CPU Free Pascal computes 32-bit expressions in 64 bits, so a 32-bit overflow is caught by range checking instead. alone let the 32-bit overflow through. The Programmer’s Guide explains why. On 64-bit CPUs integer expressions are computed with 64-bit integers, so the sum of 2,147,483,647 and 1 is no overflow at all; it only goes wrong when the result is stored in a 32-bit variable, and that is a range error, which -Cr catches. The Int64 sum overflows the 64 bits themselves, so only -Co sees it. Programs that use SysUtils turn these run-time errors into exceptions, such as ERangeError and EIntOverflow, which a handler can catch. A program without SysUtils, like marks.pas, stops with the error’s number.

Switch both checks on while you learn and wherever a wrong number costs more than a check: put {$R+}{$Q+} after the mode directive, or build with -Cr -Co. The sample configuration does part of this for you: building with -dDEBUG selects its debug section, which adds -Crtoi (range, overflow, stack and input-output checks).

Free Pascal, Lazarus and Delphi share one language

A unit written in Object Pascal may have been written for one of three tools, and each reads it a little differently. Delphi is Embarcadero’s commercial IDE and compiler; its maker describes it as a way to build native applications for Windows, macOS, iOS, Android and Linux, with the VCL and FireMonkey component libraries. Free Pascal is the open-source compiler; the Lazarus team describes it as designed to understand and compile Delphi syntax, and it runs on many processors and systems. Lazarus is an open-source IDE for Free Pascal: its project page calls it a Delphi compatible cross-platform IDE, and its component library, the LCL, is more or less compatible with Delphi’s VCL. Lazarus 4.8, the release its download button offers, was built with Free Pascal 3.2.2, and with the 3.2.4 release candidate on macOS.

The licences decide what you may do with the programs you build. The Free Pascal FAQ says the compiler is under the GPL, while programs that use the run-time library come under a modified LGPL with an exception that lets you distribute the program on terms of your choice: the licence imposes nothing on the programs you create, closed source included. What it still asks is about the library itself: the RTL’s source must be available to anyone who receives your program, which pointing to the Free Pascal website satisfies if you did not change the RTL, and changes you make to the RTL must be shared.

Where is the language used? Embarcadero sells Delphi for native applications on five systems, and the Lazarus site lists what people build with Lazarus, from file browsers and image viewers to database applications, games and medical analysis software. In the Stack Overflow Developer Survey 2025, 2.5 % of the people who answered its question on programming languages had done extensive development work in Delphi over the past year. Whether you meet the language in a Delphi codebase or a Lazarus project, it is the same language in two dialects, which is why this mini-course writes both.

Practise: work out which settings a build used

The exercise turns the order of the third section into code: given the options of a build and the directives at the top of its file, return the mode, what string means, the size of Integer and both checks. Its sample tests replay this lesson’s own builds, from sizes.pas in four modes to mode_and_r.pas built with -Mdelphi -Sh -Cr.

def effective(options, directives):
    """Return the mode, the meaning of string, the size of Integer and the two checks that a build uses."""
    # Replace these lines with your code: apply the options, then the directives.
    return {
        "mode": "fpc",
        "string": "ShortString",
        "integer_bits": 16,
        "range_checks": False,
        "overflow_checks": False,
    }

from settings import effective


def test_default_mode():
    """sizes.pas built with no option: fpc mode, a 16-bit Integer and a ShortString"""
    assert effective([], []) == {"mode": "fpc", "string": "ShortString", "integer_bits": 16, "range_checks": False, "overflow_checks": False}


def test_modes_on_the_command_line():
    """sizes.pas built with -Mobjfpc, -Mdelphi and -Mdelphiunicode"""
    assert effective(["-Mobjfpc"], []) == {"mode": "objfpc", "string": "ShortString", "integer_bits": 32, "range_checks": False, "overflow_checks": False}
    assert effective(["-Mdelphi"], [])["string"] == "AnsiString"
    assert effective(["-Mdelphiunicode"], [])["string"] == "UnicodeString"
    assert effective(["-Mtp"], [])["integer_bits"] == 16


def test_h_before_the_mode_is_lost():
    """h_before_mode.pas: the mode directive switches {$H} off again"""
    assert effective([], ["{$H+}", "{$mode objfpc}"])["string"] == "ShortString"


def test_h_after_the_mode_stays():
    """h_after_mode.pas: {$H+} after the mode gives an AnsiString"""
    assert effective([], ["{$mode objfpc}", "{$H+}"])["string"] == "AnsiString"


def test_the_file_wins():
    """mode_and_r.pas built with -Mdelphi -Sh -Cr: the file's mode and {$R-} decide"""
    assert effective(["-Mdelphi", "-Sh", "-Cr"], ["{$mode objfpc}", "{$R-}"]) == {"mode": "objfpc", "string": "ShortString", "integer_bits": 32, "range_checks": False, "overflow_checks": False}


def test_a_mode_keeps_the_checks():
    """overflow.pas built with -Cr -Co: its {$mode objfpc}{$H+} leaves both checks on"""
    assert effective(["-Cr", "-Co"], ["{$mode objfpc}", "{$H+}"]) == {"mode": "objfpc", "string": "AnsiString", "integer_bits": 32, "range_checks": True, "overflow_checks": True}


def test_order_on_the_command_line():
    """-Sh before -Mobjfpc is undone by the mode; after it, it stays; -Sh- after -Mdelphi switches it off"""
    assert effective(["-Sh", "-Mobjfpc"], [])["string"] == "ShortString"
    assert effective(["-Mobjfpc", "-Sh"], [])["string"] == "AnsiString"
    assert effective(["-Mdelphi", "-Sh-"], [])["string"] == "ShortString"


def test_switching_off_and_any_case():
    """-Cr- and {$Q-} switch checks off; names and letters in any case; other options change nothing"""
    assert effective(["-Cr", "-Cr-", "-Co"], ["{$Q-}"])["range_checks"] is False
    assert effective(["-Co"], ["{$Q-}"])["overflow_checks"] is False
    assert effective(["-O2", "-l-", "-MOBJFPC"], ["{$h+}"]) == {"mode": "objfpc", "string": "AnsiString", "integer_bits": 32, "range_checks": False, "overflow_checks": False}
    assert effective([], ["{$MODE DELPHI}", "{$H-}"])["string"] == "ShortString"

Then work through the self-check, five ideas from fpc -iV to the licence. Ideas where your answers have slipped come up first, and every pick is explained the moment you make it:

Interview questions

Warm-up (fresher to mid-level): What does {$mode objfpc}{$H+} at the top of a file do, and why in that order?

The first directive selects objfpc mode, the Free Pascal dialect with classes, exceptions and interfaces, in which an Integer has 32 bits; without a mode directive the compiler is in fpc mode, where class is not even a keyword. The second makes string an AnsiString, a reference-counted string of any length, instead of a ShortString of at most 255 characters. The order matters because setting a mode also sets {$H}: objfpc switches it off, so a {$H+} written before {$mode objfpc} is undone, and the file quietly gets ShortStrings. Directives in the file are read after fpc.cfg and the command line, so they also override -Sh or -M options given there. Write the pair in this order at the top of every unit and program for objfpc mode.

Two questions of the kind a team asks someone who will maintain Object Pascal code:

Key takeaways

• Free Pascal 3.2.2 installs from one release tarball into a folder you own, and fpc -iV must answer 3.2.2 before any output is compared; on a Mac it links with Apple’s linker, whose two warnings follow every build.
• The compiler reads its options from the first configuration file it finds, ~/.fpc.cfg before the etc folder above its bin folder, and smart linking with -XX cut the first program from 1,053,720 to 223,496 bytes.
• The mode decides the dialect: the default fpc mode has no classes and a 16-bit Integer, objfpc is the mode of new code and Lazarus, and delphi mode accepts Delphi syntax, generics included.
• Settings are read as fpc.cfg, then the command line, then the file, and the last one wins; a mode directive resets {$H}, so {$H+} goes after it.
• Range and overflow checks are off by default; on a 64-bit CPU a 32-bit overflow is caught by {$R+}, not by {$Q+} alone, so switch on both.
• Delphi and Free Pascal both compile Object Pascal, Lazarus is an IDE built on Free Pascal, and the run-time library’s licence leaves your program’s licence to you.