What Is a .PAS File?

Pascal Source File (.pas, .pp)

Overview

Pascal is a procedural programming language designed by Niklaus Wirth in 1970, built around structured programming and strong static typing. A .pas file contains Pascal source code - a program, a unit, or a library - in plain text.

Pascal's influence is far larger than its current usage. It taught structured programming to a generation, and its descendants - Object Pascal, Delphi, and Free Pascal - still power a substantial body of commercial Windows software.

Technical Specifications

Format Details

• MIME Type: text/x-pascal
• File Extensions: .pas (source/unit), .pp (Free Pascal), .dpr (Delphi project), .dpk (Delphi package), .inc (include)
• Category: Code
• Encoding: plain text, usually ASCII or UTF-8
• First appeared: 1970
• Designed by: Niklaus Wirth
• Paradigm: procedural, structured; object-oriented in Object Pascal

Recognising Pascal Source

Pascal has a distinctive, verbose keyword style that makes it easy to identify:

• program, unit, interface, implementation, uses at the top level
• begin and end blocks, with end. terminating the program
• := for assignment, = for comparison
• Type declarations after the identifier: x: Integer
• Comments in { braces }, (* parens-star *), or // to end of line

Case is not significant, so Begin, begin, and BEGIN are the same token - a detail that trips up naive keyword matching.

Language Structure

A complete program

program Greeting;

uses
  SysUtils;

type
  TPerson = record
    Name: string;
    Age: Integer;
  end;

var
  Person: TPerson;

function Describe(const P: TPerson): string;
begin
  Result := Format('%s is %d years old', [P.Name, P.Age]);
end;

begin
  Person.Name := 'Ada';
  Person.Age := 36;
  WriteLn(Describe(Person));
end.

A unit

unit MathUtils;

interface

function Factorial(N: Integer): Int64;

implementation

function Factorial(N: Integer): Int64;
begin
  if N <= 1 then
    Result := 1
  else
    Result := N * Factorial(N - 1);
end;

end.

The split between interface and implementation is Pascal's module system: the interface section is the public API, the implementation section is private. This separation predates and influenced the header/source split conventions in other languages.

Object Pascal

type
  TAnimal = class
  private
    FName: string;
  public
    constructor Create(const AName: string);
    procedure Speak; virtual; abstract;
    property Name: string read FName write FName;
  end;

  TDog = class(TAnimal)
  public
    procedure Speak; override;
  end;

procedure TDog.Speak;
begin
  WriteLn(Name, ' says Woof');
end;

History and Development

Wirth designed Pascal at ETH Zurich as a teaching language emphasising clarity and structured control flow, as a reaction to the complexity of ALGOL 68. Its readability and strict typing made it the standard introductory language at universities through the 1970s and 1980s.

Turbo Pascal (Borland, 1983) transformed its fortunes: a fast compiler and integrated editor in a package that cost a fraction of competing tools, running on CP/M and DOS. It became one of the most widely used development environments of its era.

Delphi (1995) extended Turbo Pascal into Object Pascal with a visual form designer, and became a dominant tool for Windows business applications. A large volume of line-of-business software written in Delphi is still maintained today.

Free Pascal (from 1993) provides an open-source compiler targeting many platforms and CPU architectures, with Lazarus as a cross-platform Delphi-compatible IDE.

Common Use Cases

• Legacy Windows applications: maintaining and extending Delphi business software.
• Cross-platform desktop apps: Lazarus and Free Pascal for Windows, macOS, and Linux from one codebase.
• Education: still used to teach structured programming and algorithms.
• Embedded and retro development: Free Pascal targets a wide range of architectures.
• Scientific and engineering tools: long-lived numerical codebases.

How to Open and Compile a PAS File

Editors and IDEs

• Lazarus: the free, cross-platform IDE for Free Pascal, closely modelled on Delphi.
• Embarcadero Delphi: the commercial IDE and RAD environment.
• VS Code: the OmniPascal or Pascal extensions provide highlighting and completion.
• Any text editor: the files are plain text.

Compiling

# Free Pascal Compiler
fpc greeting.pas
./greeting

# Optimised release build
fpc -O3 -XX -Xs greeting.pas

# Compile a Lazarus project from the command line
lazbuild project1.lpi

On Windows with Delphi:

REM Delphi command-line compiler
dcc32 Project1.dpr

Checking syntax without producing a binary

fpc -s greeting.pas       # compile only, no link

Advantages

• Highly readable: verbose keywords make intent explicit.
• Strong static typing: many errors caught at compile time, with genuine range and type checking.
• Very fast compilation: Turbo Pascal set a standard the descendants maintain.
• Native compilation: produces standalone binaries with no runtime dependency.
• Stable and mature: decades-old code still compiles.
• Good tooling for desktop UI: Delphi and Lazarus form designers remain productive.

Limitations

• Small modern ecosystem: few current libraries compared to mainstream languages.
• Declining talent pool: hiring Pascal developers is difficult.
• Dialect fragmentation: Turbo Pascal, Delphi Object Pascal, and Free Pascal differ in meaningful ways, and code often needs {$MODE} directives to compile across them.
• Verbosity: the same logic takes more lines than in modern languages.
• Limited web and cloud presence: rarely chosen for new server-side work.

Related Formats

• C: the contemporary systems language that largely displaced Pascal.
• CPP: the object-oriented path most Pascal shops eventually took.
• ASM: often mixed into Pascal via inline asm blocks.
• PEBIN: the Windows executable format Delphi and Free Pascal produce.