TMT Pascal

TMT Pascal was a commercial 32-bit Pascal compiler, sold from 1996 by a small New York company called TMT Development Corporation to programmers with a problem that was very specific to its decade: a working body of Turbo Pascal code, a 16-bit real-mode compiler that Borland had stopped pushing forward, and hardware that had moved on without them. TMT’s answer was not a new language. It was the old language, recompiled — the same units, the same objects, the same Graph calls, now emitting flat-model 32-bit protected-mode code for MS-DOS, and later for OS/2 and Win32 as well, from one compiler with one command-line switch to choose the target.

Around that pragmatic core the company grew a genuinely interesting dialect. TMT Pascal had user-defined operators, C-style compound assignment (+:=), declaration blocks nested inside statements, multidimensional open array parameters, a calling-convention operator that let you construct a convention out of primitive flags, and an inline assembler that kept pace with MMX and 3DNow!. Very little of that survived the company. The compiler was never open-sourced, its authors were never publicly named by their employer, and the product ended up passing to a second company that renamed it, rewrote it and quietly let it go dormant.

Dating the language

The metadata that circulates in language lists gives 1995, and it is easy to see where that comes from: every page TMT ever published carries a copyright line beginning with 1995, and the 2000 Programmer’s Reference is copyrighted “1995-2000”. But the company’s own dated release history — a page it maintained continuously from 1996 to 2004 — begins on 17 June 1996, with the announcement that OS/2 beta testing was about to start and that a free DOS beta was already available for download. The numbered releases run from there: Beta-2 for DOS on 25 June 1996, Beta-1 for OS/2 and Beta-2 build 24 for DOS on 15 July, Beta-3 build 31 on 16 August, and so on to Release-8 build 42 on 3 January 1997, the first release the company stopped calling a beta.

No 1995 artefact of any kind survives: no announcement, no build, no review. The honest reading is that 1995 is when TMT Development Corporation, or the work, began, and that 1996 is the year TMT Pascal first appeared in public. This page uses 1996 in its front matter for that reason.

The same caution applies to the claim, repeated by Russian Wikipedia and the sites that mirror it, that TMT Pascal was “the first compiler that allowed creating 32-bit protected-mode MS-DOS applications using DPMI”. It was not: DPMI-hosted protected-mode DOS development was ordinary by 1996, Borland Pascal 7.0 had shipped a DPMI target in 1992, and Watcom, DJGPP and others had been doing 32-bit DOS for years. What TMT could fairly claim was something narrower — a Borland-compatible Pascal that produced 32-bit protected-mode DOS binaries, and later the same source recompiled for three operating systems.

History and origins

The plan announced in mid-1996 was for two compilers at two price points: “non-optimizing high-speed TMT Pascal Lite” and “highly optimizing but slower TMT Pascal Pro”. Lite came first, on DOS, given away as a restricted beta; Pro for OS/2 reached general availability on 29 August 1996 at US$299 list, US$199 introductory, with a Presentation Manager IDE, a debugger for PM and console programs, Borland Pascal 7.0 compatibility and the built-in 32-bit assembler.

The freeware and commercial split then settled into a shape TMT kept for years. The free DOS compiler refused to build programs whose combined code, data and heap exceeded roughly 1.5 MB; registering — US$50 pre-release, US$75 by early 1997 — lifted the limit and added the IDE, the debugger and the documentation. The FAQ of the period is charmingly of its time, explaining that orders could be placed by e-mailing a credit card number, or, “if you do not trust the email system”, by telephone.

Two releases mark the technical turning points. Build 40, on 18 December 1996, gave the DOS product a full IDE and debugger and gave the language operator overloading. Build 3.00, on 1 December 1998, produced “the first realization of the multi-target edition”: one compiler emitting MS-DOS 32-bit protected mode, OS/2 and Win32 (Windows 95, 98 and NT), with a new Win32 IDE and a large set of API units. Everything afterwards is refinement of that model — MMX in 1997, 3DNow! in 1999, DirectDraw-backed graphics in Win32, DirectX 8 and OpenGL units in version 4.

Design philosophy

TMT Pascal’s design can be summarised in one sentence from its own manual: the dialect “fully covers the Borland Pascal language and has additional powerful extensions”. Compatibility was the product; the extensions were the reason to switch rather than stay.

That compatibility was pursued fairly literally. Borland’s Mem[seg:offs] pseudo-array and Ptr(seg, offs) still work in TMT’s flat 32-bit model, with the effective address computed as seg*16+offs and Seg(v) always returning zero, “to substantially simplify the conversion of the programs that use absolute addressing”. At the same time, linear addressing is the native idiom, so the classic direct-to-video-memory loop is written against a linear address rather than a segment:

procedure clr_video(filler: char);
var
  i: Integer;
begin
  for i := 0 to 80 * 25 - 1 do
    Mem[$B8000 + i * 2] := Ord(filler);
end;

The manual is equally frank about where compatibility stops. Mark and Release are not implemented; Inline accepts only byte sequences, not references to variables; the Complex type is absent; Extended constants are unsupported; and packed, though accepted as a reserved word from version 4.00, is documented as having no effect — alignment is controlled by the $OA switch instead.

Key features

User-defined operators

The feature that arrived at the end of 1996 and that Borland users could not get anywhere else. Operators are overloaded by binding an existing symbol to an already-declared routine:

function add2_rr(a, b: Real): Real;
function add2_ii(a, b: Integer): Integer;

overload + = add2_rr;
overload + = add2_ii;

Overloadable symbols run from the arithmetic and relational operators through and, or, xor, shl, shr, mod, div, in and not, to the four compound-assignment operators +:=, -:=, *:= and /:= — which are themselves a TMT invention, have the lowest precedence in the language (lower than comparison), and are right-associative. +:= and -:= come predefined for every integer and real type; *:= and /:= for the reals. Resolution is by last-applicable definition, which the manual illustrates with a trap: declare the Integer overload after the Real one and it will never be selected, because integers can always be widened to reals. The distribution shipped a Comp unit implementing complex numbers as the worked example.

Multidimensional open arrays

Open array parameters carry an explicit dimension count, with bounds recovered through high returning a vector:

procedure print_vector(v: array(1) of Double);
var i: Integer;
begin
  for i := 0 to high(v)[0] do Write(v[i]:10:6, ' ');
  Writeln;
end;

procedure print_matrix(m: array(2) of Double);
var i: Integer;
begin
  for i := 0 to high(m)[0] do print_vector(m[i]);
  Writeln;
end;

Constructed calling conventions

Rather than a fixed menu of conventions, TMT Pascal exposed the pieces. The conv operator takes a set of primitive flags — argument order, register preservation, who cleans the stack — from which the familiar conventions are themselves assembled in the System unit:

const
  arg_pascal  = arg_noregsave;
  arg_stdcall = arg_reverse + arg_noregsave + arg_save_edi + arg_save_esi;
  arg_cdecl   = arg_reverse + arg_no_drop_all;
  arg_os2     = arg_cdecl + arg_noregsave;

This is the kind of design that follows from having to call OS/2 16-bit APIs, Win32 APIs and C libraries from the same compiler. Version 4.00 later added the plain pascal, stdcall and cdecl keywords in Delphi’s style, on top of the older mechanism.

Other extensions

The manual’s own list of what the dialect adds to Borland Pascal is short and worth quoting whole: C/C++ extensions support, C++ and Ada-style comments, local declarations, multidimensional open arrays, operator overloading, unnamed procedural blocks, and MMX technology support. Ada-style comments (--) were a casualty of the language’s own success: from version 3.30 they were switched off by default behind the $AC directive, because a leading -- is too easily an arithmetic expression.

The object model is Turbo Pascal 5.5’s rather than Delphi’s — object types with constructors, destructors, static and virtual methods, an explicit VMT, inherited, an implicit Self, the Fail procedure, and the combined New(C.Init(P, R)) form. Range checking ({$R+}) was extended to catch calls into objects whose constructor had never run.

Evolution

The DOS extender story is a small history in itself, and a reminder of how much of this compiler’s job was plumbing. Early builds shipped with DOS32 and, for those who had it, DOS/4GW; version 2.10 in 1998 dropped DOS32 and replaced the PMODE-based stub with a WDOSX-based one; by version 4 the documented list of usable extenders had grown to PMODE, PMODE/W, WDOSX, CauseWay and DOS/4GW, chosen by swapping the stub attached to the executable.

Decline

The clearest account of TMT Pascal’s decline is the one its own successors published. In October 2003, announcing version 5.00, Framework Computers explained that they had taken the compiler over “more than a year ago” at “a crucial point in the product history”, and listed what they had found: a compiler built with no design documentation, written in a home-made scripting language that generated machine-style C for the discontinued Watcom compiler, with no comments in its source; an IDE written in Delphi that could not sensibly be extended with project management or better debugging; a help system largely assembled from incomplete Microsoft C++ Win32 material; and example programs that were “only partially operational”. The TMT .NET project — announced around 2000, when TMT’s own site described the company as a Microsoft coding partner committed to the CLR — had been put on hold, and never shipped.

Version 5.00 was the rewrite: the compiler ported to standard C++ so it could be built with GNU tools, long file name support for DOS programs running under Windows 2000 and XP, a new object-oriented graphics library, and the removal of the OS/2 target after IBM ended OS/2 support. The rewrite was also pitched as opening the door to Linux and BSD ELF32 targets and to 64-bit code — but those were described as things the new architecture made possible, and no evidence has been found that a Linux TMT Pascal was ever shipped. Claims that version 5 “added Linux support” should be treated with suspicion; the shipping targets of the product, throughout its life, were 32-bit DOS, Win32 and (to version 4) OS/2.

Under the FrameworkPascal name the compiler kept going for a while — a 6.10 release with OWL-compatible units, ODBC SQL support and 64-bit file access, dated February 2008, with product pages refreshed as late as 2010 and a purchase page copyrighted 2022. But there is no public release since, no downloads on the site, and no visible community.

Running TMT Pascal today

There is no Docker image and no modern port. The practical routes are:

• DOSBox or a DOS virtual machine with the freeware TMT Pascal Lite 3.90 for DOS, the last free edition, which is mirrored by DOS abandonware archives and by the GitHub mirror of the Russian TMT project. Earlier freeware builds (3.50 SP2 and the separate DOS IDE/debugger) circulate the same way.
• The 2000 Programmer’s Reference (111 pages) and the companion library reference, also on that mirror, remain the only complete description of the dialect.
• Free Pascal is the sane destination for anything real. It is free, maintained, targets everything TMT targeted and much more, and — for the specific problem TMT existed to solve — compiles Turbo Pascal source in {$MODE TP}. Its operator overloading covers most of what overload did, though the +:= family and the conv flag algebra have no direct equivalent.

Why it matters

TMT Pascal is a good specimen of a species that has almost entirely disappeared: the small commercial compiler, written by a handful of people, sold for a couple of hundred dollars to a self-identified community of users, living or dying on how well it handled one migration. It has no academic paper, no standard, no conference, and no famous program. What it has is a decade of dated release notes, written by the people doing the work, that show a compiler being pushed forward feature by feature — MMX in October 1997 because processors had it, 3DNow! in 1999 because AMD’s had it, DirectDraw graphics because DOS graphics code needed somewhere to go, a Variant type and stdcall because Delphi had made those the expectation.

It also stands as an unusually well-documented cautionary tale, because the people who inherited it wrote down exactly why it had become unmaintainable: a compiler bootstrapped through a home-grown scripting language, tied to a dead C compiler, with no design documents and no comments. That is not a story a vendor usually publishes about its own product. The languages that outlived TMT Pascal — Free Pascal above all — are precisely the ones that made the opposite choice about source, documentation and community. TMT Pascal is what the alternative looked like when it worked, and then when it stopped.