Delphi 1, February 1995

A box that assembled what Borland already knew

When Borland International shipped Delphi 1 in February 1995, the product was genuinely new in a way that is easy to miss: not because any single piece inside it had never existed before, but because no one had combined those pieces in quite that way. The visual form designer, the Object Pascal compiler, and the component model arrived together as a single, integrated environment — and the integration was the invention.

The compiler itself had deep roots. Borland Pascal 7, released in 1992, had already extended standard Pascal with objects and a unit system mature enough for large-scale commercial development. The language Anders Hejlsberg and colleagues had refined through successive Turbo Pascal releases was well understood inside Scotts Valley. What Delphi 1 introduced was a revision of that language now labelled Object Pascal — the same family, but with class-based inheritance, virtual method tables aligned with COM conventions, and a property system that the form designer could interrogate at design time. The transition from Borland Pascal's object model to true class semantics was consequential: it enabled the VCL (Visual Component Library) to be built on a foundation that mixed visual and non-visual components in a single inheritance tree rooted at TObject.

The VCL itself was new code. Borland had shipped ObjectWindows Library (OWL) as its Windows application framework since Borland Pascal with Objects, but OWL carried the structural assumptions of its C++ parallel and mapped imperfectly onto a design-time property editor. The VCL was written specifically for Delphi, in Object Pascal, and from the start it treated the published property — a property declared in a class's published section, which caused the compiler to emit RTTI — as the unit of design-time interaction. Every property visible in the Object Inspector was a published property; every value set at design time was serialised through RTTI into the DFM file. The architecture was circular in a productive way: the language extended to support the designer, and the designer exposed only what the language's RTTI machinery could describe.

The form designer and the DFM

The visual form designer was what reviewers and customers reached for first, and it was fast enough and stable enough in February 1995 to feel qualitatively different from the competing products. Microsoft Visual Basic had owned the visual design space for Windows since 1991; Borland's answer was to integrate design directly with a strongly typed, compiled language rather than an interpreted one. Dropping a button onto a Delphi form generated a TButton instance in a DFM file and a corresponding event-handler stub in the paired Pascal unit. Compilation was not a separate phase entered reluctantly — it was the ordinary rhythm of development, and the Delphi 1 compiler was fast enough that the rhythm held.

The DFM file in its 1995 form was binary, not the human-readable text format it would later become. The binary DFM stored the component tree and every published property value, and the IDE's streaming system reconstructed the form at design time and again at runtime by reading the same file through the same RTTI mechanism. The symmetry between design time and runtime was not accidental — it was a design principle that gave Delphi's component model much of its coherence.

The VCL's depth is the point: a form arrives with several generations of ancestor behaviour already linked into it.

The Object Inspector deserves particular attention. Rather than a property grid bolted onto a separate designer, it was a live editor bound to the selected component through RTTI. String properties, enumerated types, set properties, sub-objects, and event references all appeared in a two-column grid that updated immediately. Event references were especially consequential: clicking an event slot in the Object Inspector and pressing Enter created a method in the unit, switched focus to the code editor, and placed the cursor inside the new method body. The connection between visual design and the Pascal source file was bidirectional and immediate in a way that Visual Basic's property window was not.

What February 1995 actually shipped

Delphi 1 targeted 16-bit Windows — Windows 3.1 and Windows for Workgroups — and the product shipped in two editions. The standard edition included the IDE, compiler, debugger and a substantial subset of the VCL. The client/server edition added database-oriented components, the Borland Database Engine ↗, and the SQL Links drivers that connected to server databases including Oracle and Sybase. This database tier mattered commercially: a significant share of Windows development in 1995 involved connecting desktop interfaces to relational databases, and Borland had database tooling from its Paradox and InterBase lineage to draw on.

The VCL as shipped in Delphi 1 covered the standard Windows controls — forms, buttons, edit boxes, list boxes, combo boxes, grids, menus — plus Borland's own additions including a notebook component, a gauge, and the TTable and TQuery components that abstracted database access through the BDE. The component model was open: a developer could write a new component in Object Pascal, install it into the IDE, and have it appear in the component palette alongside the VCL's own offerings. Ray Konopka's writing on custom component development was among the early third-party material that documented how this extension mechanism worked, and the market for commercial Delphi components was already forming within months of the February 1995 release.

Mid-1990s PC hardware is what the size argument was made against: a machine measuring its memory in megabytes, not gigabytes.

Photo: Nicolas Foster / Pexels

The integrated debugger in Delphi 1 supported breakpoints, watches, the ability to evaluate and modify variables at runtime, and CPU-level disassembly. For a 16-bit Windows product, this was a complete professional environment, not a hobbyist tool. The help system was context-sensitive and, unusually for the period, well integrated with the Object Inspector: pressing F1 on a selected property opened documentation for that property.

Delphi 1 arrived at a moment when Microsoft ↗ had not yet established Visual Basic as the default corporate Windows development tool — that consolidation came later in the decade — and Borland's reputation from Turbo Pascal gave Delphi credibility with developers who cared about compiler quality and language rigour. The product sold quickly. The February 1995 launch was followed by a competitive developer ecosystem, a surge of third-party components, and within the year, coverage in The Delphi Magazine, which launched in 1995 and continued publication until 2007.

What Delphi 1 demonstrated was that a visual designer and a compiled, strongly typed language were not in tension — that the properties and events a compiler could verify were exactly the properties and events a designer could expose. That insight, embedded in the architecture of the VCL and the DFM, was what the shipping box of February 1995 actually contained.