Language Overview

Free Pascal is a high level strongly typed compiled language. Its immediate ancestors are Turbo Pascal for DOS and Delphi for Windows. Free Pascal combines the high productivity of rapid application development (RAD) languages and the power of C++.
This overview page describes the essential features of Free Pascal, while other sections delve into the rules of the language in more detail. The intent here is to provide the reader with a brief introduction to Free Pascal that will guide them when first starting to program with Free Pascal.

Your First Program

The canonical 'Hello World' program can be written in Free Pascal as follows:
program Hello;

  WriteLn('Hello World!');
The source code for a Free Pascal program is typically stored in one or more text files with a file extension of .pas, as in Hello.pas. Using the Free Pascal compiler such a program can be compiled with a command line using:
pascaluser:~/examples$ fpc Hello.pas
Which produces a program named Hello (Hello.exe on Windows). The output produced by this program when run is:
pascaluser:~/examples$ ./Hello
Hello World!
Upon examination of the program source a few items are worth noting. The source code begins with the declaration
followed by an identifier. This signifies to the compiler that the file is a program and the output should be a single executable named by the identifier. In our example the identifier is named
resulting in a executable file of the same name.
The identifiers
, and
are highlighted in bold color denoting their status as keywords. Keywords have special meaning to the compiler and must appear in a certain order. Any program created with Free Pascal must start with the keyword
and must close with
terminated by a period.
You may also have noticed the use of the procedure
and be asking from where does it come. Every Free Pascal program, unit, library, and package implicitly uses the System unit. The System unit provides the definition and implementation of
to our Hello program. Anytime while reading this guide you may refer to our documentation portal to read more about a specific, unit, function or procedure, constant, or type. For example here is the documentation entry for WriteLn procedure.

Identifiers, Symbols, and Digits

Every character or group of characters, also known as a token, in Free Pascal falls into one of three categories: identifiers, symbols, or numbers. All tokens are separated by whitespace characters or symbols.


Whitespace is the collective name given to spaces, tabs, newline characters, and comments. Whitespace can serve to indicate where tokens start and end, but beyond this purpose, any surplus whitespace is discarded.


Identifiers are used to denote names for variables, types, or functions among other things. Identifiers names are case insensitive and can be of any length, but they must begin with an alphabetic character or
an underscore and cannot contain spaces or symbols. Digits are permitted after the first character.


Certain identifiers are reserved by to have special meanings. These reserved identifiers are known as keywords. Keywords cannot be repurposed to change their meaning. The following is a list of reserved keywords:
and array as asm begin case class const constructor destructor dispinterface div do downto else end except exports file finalization finally for function goto if implementation in inherited initialization inline interface is label library mod nil not object of or packed procedure program property raise record repeat resourcestring set shl shr string then threadvar to try type unit until uses var while with xor


Some identifiers have a specific meaning sensitive to their context within source code. These kinds of identifiers are known as directives. When these identifiers are used in their specific contexts they are treated like keywords. The following is a list of directives Free Pascal uses:
absolute abstract assembler cdecl contains default delayed deprecated dispid dynamic export external forward helper implements index inline library local message name nodefault operator out overload override package pascal platform private protected public published read readonly reference register reintroduce requires resident safecall sealed static stdcall stored strict varargs virtual write writeonly
In our Hello example program
, and
are keywords, while
are idenfifiers.


Symbols are single or paired non-alphanumeric characters that have special meanings. The following single characters are symbols in Free Pascal:
# $ & ' ( ) * + , - . / : ; < = > @ [ ] ^ { }
The following character pairs are also symbols:
(* (. *) .) .. // := <= >= <>
Like whitespace, symbols indicate where tokens start and end. Below is a brief overview of some of ways symbols are used:


In our Hello example several lines end with
a semicolon symbol. Semicolons are used throughout Free Pascal to terminate statements. A statement is either a block of code or an expression. Later in this guide we'll delve into the difference between blocks and expressions and where to place semicolons. For now it can be explained that all statements must be terminated with a semicolon other than the required
with a period that must be placed at the end of every Free Pascal program, unit, or package file.


procedure in our Hello example contains a sequence of characters delimited by
a single quote symbol. This sequence is what is called a string. Strings are ubiquitous throughout Free Pascal and are so important that the identifier
is a keyword which is reserved and cannot be redefined. Strings are typically used to hold text and can be concatenated together using the


Comments are blocks of characters which the compiler discards treating them as whitespace. They can be used to leave descriptive notes in source code reminding (in DOS batch files comments begin with REM) yourself or other programmers of information which may be of use later. Comments can also be used to remove pieces of code, usually on a temporary basis while testing is being done. When using a syntax highlighting editor, such as Lazarus, comments typically appear as a sequence of green italic though they can usually be configured to appear in whatever style you prefer.
Three styles of comments can be used in Free Pascal. A single line comment appears a pair of
forward slash symbols and is closed by a newline. Block comment can span across multiple lines of code and are delimited by these
{ }
(* *)
symbols. Comments may be nested, but when they are the rules for the first comment style to appear are used when closing the comment.
(* Hello.pas
   Hello is our first program 
   Last modified in January 2016 *)
program Hello;

  { Write the string 'Hello World!' to the terminal }
  WriteLn('Hello World!');
  // ReadLn; // uncomment this line to wait for the enter key


Digits are the numeric characters
0 1 2 3 4 5 6 7 8 9
which can be be placed in source code. They can be placed alone or in sequence other to form literal number or text character values. The characters
can also be considered as digits when a digit sequence is prefixes with the
symbol. Number sequences can include a
symbol which converts a whole number sequence into a what is known as floating point sequence. When a digit sequence is prefixed with a `#` hash symbol it is interpreted as a text characters or a string literal.
Here are some examples of different digit sequences as they can appear in source code:
(* Digits.pas
   Digits prints out digit sequences
   Last modified in January 2016 *)
program Digits;

  { Write out some strings and digit sequences }
  WriteLn('A whole number: ', 42);
  WriteLn('A hexidecimal whole number: ', $1EE7);
  WriteLn('A floating point number: ', 3.1415);
  WriteLn('A floating point number with a mantissa: ', 6.0221e+23);
  WriteLn('A string literal: ', #72#69#76#76#79);

Variables and Types

Functions and Procedures

Program Organization

Free Pascal programs are usually divided into source code modules called units. After the program declaration developers have the option to specify a uses clause, which consists of list of one or more unit names separated by commas. The unit names listed are linked into the program and can often be shared with different programs. The uses clause provides the compiler with information about the dependencies between unit modules, which allows developers to build applications without the need for makefiles, header files, or preprocessor include directives.
Here is a program containing a uses clause and several statements:
program Birthday;

  S: string;
  D: TDateTime;  
  WriteLn('Enter your date of birth:');
  D := StrToDateDef(S, 0);
  if D = 0 then
    S := 'You did not type a valid date'
    S := 'You were born on a ' + LongDayNames[DayOfWeek(D)];
Having saved the above program to our examples folder in a filed named Birthday.pas, again we can compile our program with a command line using:
pascaluser:~/examples$ fpc Birthday.pas
This time a program named Birthday (Birthday.exe on Windows) is produced. The output of this program when run is:
pascaluser:~/examples$ ./Birthday
Enter your date of birth:
You were born on a Saturday

Unit Organization