OPL

OPL is the programming language that Psion, the British handheld computer company, built into its organisers. It began as the Organiser Programming Language, and it is now often expanded as Open Programming Language. A small BASIC-like language, it ran on pocket machines from the 1980s, on the Series 3 and Series 5 palmtops, and finally on Symbian phones.

OPL matters because it was there on the device. An owner of a Psion could write a program on the machine in their hand, translate it and run it, with no PC or paid toolkit involved. That put programming within reach of a large number of handheld computer owners.

History and Origins

1984 or 1986?

The usual date of 1984 needs some explanation, because OPL has two starting points.

The first is POPL, which shipped with the original Psion Organiser. That machine was launched in April 1984, according to a 1987 Computergram report. The Science pack manual, copyrighted 1984 by Psion Processors Ltd, calls the language “the Psion Organiser Programming Language (POPL)”. It was not built into the machine. The editor, interpreter and runtime came on the Science, Maths and Finance Datapaks.

The second is the language actually called OPL, which arrived in the Organiser II in 1986 as built-in software. The opl-dev project’s own history says that OPL first appeared as OPL on that machine.

This page uses 1984, matching common references, because the names and purpose run straight through. Psion’s own list of OPL’s sources does not mention POPL, however, and the two languages look quite different, as the examples below show, and a reader who wants the date of OPL as it is known today should use 1986.

Other ancestors

Psion’s Organiser II Technical Reference Manual says OPL “has developed from a number of other languages”: C, ARCHIVE (“The database module in Xchange”), BASIC, FORTH and PL1. It does not say what came from each one.

Archive is the most direct of these. Psion’s database for the Sinclair QL was Archive, which shipped with the machine in 1984, and Xchange was the Psion suite that carried it further. The opl-dev history makes the same link without naming the product, tracing OPL to a database-querying language that Psion wrote for the QL. Archive’s manual describes a BASIC-like language in which users could write named procedures, which fits what OPL became.

Who designed it

Wikipedia says that Colly Myers designed the language and that Richard Harrison and Martin Stamp implemented the first version. It gives no citation for this, and no primary source was found. The credit is plausible but unconfirmed.

The meaning of the name

Leigh Edwards’s book Programming Psion Computers, copyrighted 1997 to 1999, still expands OPL as “Organiser Programming Language”. Psion’s 1997 OPL User Guide simply says “OPL”. “Open Programming Language” is the name used by Wikipedia and is common today. When that expansion first appeared was not established.

Design Philosophy

OPL’s character comes from the machines it served:

1. Write it on the device. The language had to be usable with a small screen and, on the early models, an alphabetically arranged keypad. Psion’s Organiser Developer Kit added PC-hosted tools, but they were never required.
2. Build from procedures. The Technical Reference Manual calls OPL “a procedure base language”. Programs are built from separate procedures, and memory is released when a procedure returns.
3. Run faster than a plain interpreter. Source is translated to an intermediate code first. The Technical Reference Manual gives speed as the reason.
4. Get at the data. Records, fields and files are in the language itself, which suits a machine whose main work was storing and looking up information.

A reviewer of the Organiser II summed it up as “a mix of C, Pascal, and BASIC”. That is a useful description of how it feels, though it is one reviewer’s impression, and Pascal is not on Psion’s list of sources.

Key Features

The listings below come from period manuals and Wikipedia. None has been run for this page, as no Psion hardware was available.

POPL: where it started

POPL was far more limited than OPL. The Science pack manual allows 26 single-letter variables, local to each procedure, plus 20 global values reached with STORE and RECALL. Each line could hold 100 characters and each procedure 200 bytes. Control flow was IF ... GOTO, as in this factorial from the manual:

1
2
3
4
5
6
7

FACT IN "NUMBER" N
C=0
F=1
LOOP:C=C+1
F=F*C
IF C<N GOTO LOOP
OUT "FACTORIAL IS "F

Organiser II procedures

By 1986 the language had named procedures, declared variables and proper control structures. On the Organiser II, the procedure’s name comes on the first line, and there is no closing keyword. This pair is from the LZ Programming Manual:

1
2
3
4
5
6

PROC1:
LOCAL x
CLS
PRINT "ENTER PRICE"
INPUT x
VAT1:(x)

1
2
3
4

VAT1:(p)
CLS
PRINT "PRICE INCLUDING VAT = ",p*1.15
GET

Procedure calls are marked by the colon after the name. The Technical Reference Manual allows up to 16 parameters, passed by value, and every procedure returns a value. Recursion is allowed, as in this function from the manual, quoted in a review of the machine:

1
2
3
4
5

fact:(n)
if n=0
return 1
endif
return n*fact:(n-1)

The reviewer noted that because it is recursive, “it runs out of memory fast”.

Scope

LOCAL variables exist only in their own procedure. GLOBAL variables are visible in the declaring procedure and any procedure it calls, so this scoping follows the call chain, not the source text. On the Organiser II, undeclared names are treated as externals and resolved at run time. That differs from Wikipedia’s infobox, which calls the scope lexical.

Types

The Technical Reference Manual lists only integer, floating point and string. The long integer figures are from the 1997 OPL User Guide.

Translation and Q code

OPL is not interpreted from source. The translator turns each procedure into Q code, which a runtime then executes, with expressions converted to postfix form. The Technical Reference Manual gives the reason plainly: “To achieve speed the source code is translated into an intermediate code (Q code) before it is run.”

Sources therefore describe OPL both as compiled and as interpreted, and both are partly right. It is compiled to bytecode, and that bytecode is interpreted. Because the stack space of a finished procedure is freed, programs could also overlay their code and exceed the available memory.

Data files

An Organiser II program could have four files open at once, with logical names A to D. Records were limited to 16 fields and 254 characters. Fields were stored as tab-separated text, and numeric fields were converted when accessed. Field variables take the file’s logical name as a prefix, as in b.date$ from the LZ manual.

Later syntax: PROC, ENDP and the GUI

On the Series 3 and later machines, procedures are wrapped in PROC and ENDP. This console “Hello, World!” is the version given by Wikipedia:

1
2
3
4

PROC main:
  PRINT "Hello World!"
  PAUSE 40
ENDP

Keyword prefixes group the graphical interface: g for graphics, m for menus and d for dialogs. This dialog example from Wikipedia targets Nokia’s Series 80 interface, and it shows the CONST statement available in OPL32:

1
2
3
4
5
6
7
8

CONST KKeyEnter%=13

PROC hello:
  dINIT "Hello"
  dTEXT "","Hello World!"
  dBUTTONS "OK",KKeyEnter%
  DIALOG
ENDP

Evolution

• POPL (1984): a small language supplied on Datapaks for the Organiser I.
• Organiser II OPL (1986): built into the ROM on the CM and XP models. Psion’s Developer Kit manual, copyrighted 1987, added PC translation and an emulator.
• LZ additions (1989): the four-line models added commands including UDG, CLOCK and percentage operators such as +%.
• OPL on 16-bit machines (from 1989): Psion’s engineers extended the language for the MC laptops and the Series 3, and it continued on the 3a, 3c, Siena and industrial handhelds. Edwards calls this generation OPL16 or SIBO OPL. Programs reached advanced system services through operating system CALLs. Windows-hosted tools appeared too, including the OPL Development Environment.
• OPL32 (1997): the 32-bit Series 5 was a major change. Edwards says that some OPL16 features went, including CALL, while others arrived, among them CONST, INCLUDE, DECLARE EXTERNAL and BYREF. OPX libraries, written in C++, became the way to extend the language, and label names could grow from 8 to 32 characters.
• Symbian OPL (2001 to 2006): Unicode support was added in an unreleased “Symbian OS v5u”, which became the basis of the first Symbian OS v6 implementation. OPL was then removed from the official v6 roadmap during work on the Crystal reference design. Symbian programmers carried on “out-of-hours” for the Nokia 92xx Communicators, leading to the public beta in 2001 and version 1.00 in 2002.

Psion also had a second language for the Series 3c generation, OVAL (Object-based Visual Application Language). Edwards describes it as “Visual Basic for the Psion”. It was a separate language and did not replace OPL.

The final opl-dev release notes show a project that was still adding language features at the end. Version 1.55 of 10 June 2006 added gPIXEL and changed LOC, and version 1.56 a week later added gXBORDER32. At that time the opl-dev site listed these states:

Current Relevance

Psion began withdrawing from its PDA markets in late 2001, and its software arm had already become Symbian Ltd. in 1998. Wikipedia reports that OPL is unavailable for Symbian OS v8 and later, and says that Nokia developers were steered towards Python for S60 by 2010, though it marks that second claim as needing a citation. No OPL release after June 2006 was found, so the language itself can fairly be called historical.

The programs have fared better. OpoLua, by Jason Morley and Tom Sutcliffe, runs compiled OPL programs on iOS, iPadOS, macOS, Windows and Linux. It is an interpreter for OPO files, not a compiler and not a full emulator, so it does not run programs that are native ARM binaries. Its README says that it is not fully compatible with a real Series 5, and support for Series 3 programs is preliminary. Version 2.10.4 appeared on 19 October 2026, and the project’s core is MIT licensed. PyOpo, a Python interpreter, takes the same approach for Series 3 programs.

Documentation survives well too. Jaap Scherphuis’s site preserves the Organiser manuals, Psion’s 1997 User Guide is available from enthusiast sites, and Edwards’s book can be read online. An Organiser II community site is still online at organiser2.com.

OPL should not be confused with IBM’s Optimization Programming Language, an unrelated language that shares the initials.

Why It Matters

Programmable pocket computers came before OPL, but it carried on-device programming into organisers and then phones. More than 500,000 Organiser II units were reportedly produced, a figure Wikipedia takes from the original Org2.com fan site. That would be a large audience for a language that came free with the machine, and Series 3 owners built a real shareware culture around it.

Commercial buyers mattered too. Computergram reported in October 1987 that Marks & Spencer was Psion’s biggest single customer, and Wikipedia says the retailer used Organiser IIs on the shop floor under its own branding. Neither source says what its software was written in, so this shows the market OPL served and does not prove that the retailer used OPL.

It also has an unusual lineage. A language that began in 200-byte procedures on a machine with 2 KB of RAM ended up running on Nokia smartphones, extended by C++ OPX libraries. Its survival through the change from EPOC to Symbian owed a good deal to individual programmers, who kept working on it after it was dropped from the roadmap. Symbian then released it to the community as open source.

Modern phones generally ship with no way to write a program on the device itself. OPL shows what that was like on the handhelds that offered it.