A short history of how a park-bench idea in Trondheim became the scripting-ready object surface powering modern cross-platform applications.
Ole-Johan Dahl and Kristen Nygaard finalise Simula 67 at the Norwegian Computing Center in Oslo. Simula introduces classes, objects, inheritance, virtual methods, and dynamic dispatch - the entire vocabulary of what would later be called object-oriented programming. Simula was built to model real-world simulations, so its objects were first-class runtime entities that could be inspected, enumerated, and manipulated at runtime, not just compile-time abstractions.
This distinction matters. Simula's objects carried their own identity and structure at runtime - the seed of every meta-object system that followed.
Bjarne Stroustrup begins "C with Classes" at Bell Labs in 1979, explicitly citing Simula as his inspiration for the class model. The language is renamed C++ in 1983. The first edition of The C++ Programming Language ships in 1985, making classes, constructors, destructors, operator overloading, and single inheritance production-ready on commercial compilers.
By 1989, C++ 2.0 adds multiple inheritance, abstract classes, and protected members. The 1990 Annotated Reference Manual (ARM) serves as the de facto standard until ISO C++98.
What C++ did not inherit from Simula was runtime introspection. C++ classes compile down to efficient structures and vtables with no standard runtime metadata. If you wanted to ask "what properties does this object have?" at runtime, you had to build that machinery yourself.
Haavard Nord and Eirik Chambe-Eng, working on a C++ cross-platform database application for ultrasound imaging that had to run on classic Mac OS, Unix, and Microsoft Windows, experience the full pain of 1990-era GUI development. Every platform had its own toolkit, its own event model, its own callback mechanism.
Sitting on a park bench in Trondheim, they sketch the core ideas of what would become Qt, including the signal-slot mechanism for loosely-coupled event handling.
Coding begins in 1991.
Trolltech is incorporated on 4 March 1994. Qt 0.90 ships publicly on 20 May 1995 for X11/Linux, under a dual commercial / FreeQt licence.
The core design decision that defines Qt for the next three decades is already in place: a Meta-Object Compiler (moc) that parses class declarations and generates C++ code carrying runtime metadata about signals, slots, properties, and class identity.
In 1991-1995, C++ templates were described in the ARM but compiler support was inconsistent and buggy across the Unix / Mac / Windows landscape Qt had to ship on. Templates could not be relied upon to produce portable code. Nord and Chambe-Eng chose a code-generator preprocessor that emitted plain, portable C++.
The Qt team have written publicly about the trade-off: "Syntax isn't just sugar: the syntax we use to express our algorithms can significantly affect the readability and maintainability of our code. The syntax used for Qt's signals and slots has proved very successful in practice. The syntax is intuitive, simple to use and easy to read."
Once the preprocessor existed for signals and slots, everything else piled on top of it for free:
tr() functionsThroughout this period, the meta-object system quietly underpins every new capability added to the framework. Qt Designer, the WYSIWYG UI builder, only works because every widget's properties are discoverable at runtime through the meta-object. Qt's scripting bindings (Python via PyQt and later PySide, plus official QtScript) all work by enumerating QMetaObject entries.
Qt today spans automotive dashboards, industrial automation, consumer electronics, medical devices, and desktop applications across Windows, macOS, Linux, iOS, Android, embedded Linux, real-time operating systems, and microcontrollers. Every one of those platforms is reached through the same QObject meta-object surface that was sketched on a park bench in 1990.
Reasonable national claim to the entire object-oriented GUI stack.
Qt's meta-object system was architected from day one so that any outside caller can discover and drive any QObject using just three generic operations - read a property, write a property, invoke a method or slot - plus one event primitive: connect a signal to a callback. That is the entire surface area. Everything a GUI can do - create a window, set its title, show a button, react to a click, load an HTML document, resize a layout - is expressible through those operations acting on named widget instances.
This is the quiet gift Trolltech built in 1991 and that has been polished for thirty-five years.
A Universal Binding Software Multi-Platform Micro-Kernel is system software whose entire object contract is a single uniform primitive: everything is a bindable. Values, operators, built-ins, data structures, services, and GUI widgets are all the same kind of thing - addressable by name, accessed through select-member, activated through invoke, read through get, assigned through set. The kernel does not distinguish "language objects" from "framework objects" from "device objects". There is one object model, and every participant in the system conforms to it.
When a framework like Qt exposes a meta-object surface whose contract matches the kernel's binding contract - the result of early design decisions on both sides converging on the same paradigm - the two systems compose without translation. Qt does not become a thing the kernel drives. Qt becomes a first-class client citizen of the kernel itself. Every QObject is a native bindable. Every Q_PROPERTY is a native member. Every slot is a native invoke target. Every signal is a native event source. There is no foreign API, no translation boundary, no adapter worldview to maintain - only a transport carrying identical operations across a module boundary.
This changes what becomes possible:
This is the architectural pay-off of thirty-five years of patient Norwegian refinement meeting a new class of kernel-level binding software. Qt did not have to change. The kernel did not have to wrap Qt. Two independently designed systems, separated by three decades, meet on a shared contract and compose natively.
The park bench paid off - and the same uniform object geometry that made Qt hospitable to tools that had not been invented yet is exactly what lets a Universal Binding Micro-Kernel host Qt as a native first-class citizen today.
The park bench paid off.
Compiled from public sources including Qt Wiki, The Qt Company documentation, Wikipedia, and first-hand accounts by Haavard Nord.
© Copyright 2026 Quantum Dynamics Ltd. All rights reserved.
This document may be reproduced and distributed for educational and non-commercial purposes provided this copyright notice remains intact. All trademarks referenced are the property of their respective owners. Qt is a trademark of The Qt Company Ltd. Simula, C++, and other named technologies are referenced under fair use for historical and educational commentary.
The views and technical commentary expressed herein are those of Quantum Dynamics Ltd and do not represent endorsement by, or affiliation with, The Qt Company, The Qt Project, or any other organisation named in this document.