Qore

Qore is an interpreted, high-level, general-purpose programming language designed by David Nichols and first released in 2006. It is a dynamic, garbage-collected language with optional strong typing, but its defining ambition is unusual among scripting languages: Qore was built from the ground up for multithreading and symmetric multiprocessing (SMP) scalability. Where most interpreted languages serialize execution behind a global interpreter lock, Qore has no global interpreter lock at all — every element of the language is thread-safe, so Qore programs can run genuinely parallel workloads on shared memory without restriction.

History and Origins

Qore began not as an academic experiment but as a pragmatic engineering decision. In 2006, David Nichols was working on an integration problem for a large European telecommunications company and needed a language to express the integration and order-management logic of a workflow system. Rather than bend an existing scripting language to fit requirements it was never designed for — a clean threading model, efficient resource sharing across threads, deterministic cleanup, and long-term process stability — he designed a new one. That language became the embedded scripting engine of what is today the Qorus Integration Engine, the commercial product of the company he founded, Qore Technologies.

Qore was released as free and open-source software early in its life; the earliest public versions date to 2006 (version 0.5.1 is dated June 2006), and the project has been distributed under a combination of the MIT, GPL, and LGPL licenses. Development proceeded through a long sequence of 0.x releases — the 0.7.x line around 2008, the lengthy 0.8.x series beginning in 2010, and the 0.9.x series — before the language finally reached its first stable 1.0.0 in June 2021. The 2.x generation followed in 2025, with 2.0.0 in April and 2.2.0 in October.

Design Philosophy

Qore’s design choices nearly all trace back to a single goal: safe, scalable concurrency in a high-level language.

• Thread-safety everywhere. Because the entire language and runtime were designed to support multithreading, programs are not forced to restrict themselves to a “thread-safe subset.” This is precisely why Qore has no global interpreter lock — a deliberate departure from the approach taken by many other interpreted languages.
• Deterministic resource management. Qore supports the RAII (Resource Acquisition Is Initialization) idiom with destructors that run when objects leave scope, enabling exception-safe programming and predictable cleanup of resources like database connections, files, and locks.
• Optional typing. Code can be written in a loose, dynamic style for speed of development, or annotated with types that the parser checks at compile time for safety and performance — letting a single language span quick scripts and large, maintained enterprise codebases.
• Built for embedding. Qore was conceived as an embedded language, so isolation and control over running code — sandboxing, capability restrictions — are first-class concerns rather than afterthoughts.

Key Features

Qore’s most distinctive technical feature is its approach to memory. The language is garbage-collected, but it uses what its documentation calls prompt (deterministic) collection: a scheme that allows destructors to run immediately when objects go out of scope, even in the presence of recursive references that would defeat simple reference counting. This combination — automatic memory management and deterministic, scope-based destruction — is what makes the RAII idiom practical in a dynamic language.

Other notable features include:

• No global interpreter lock, with all language elements thread-safe by design, supporting real parallelism and SMP scalability.
• Optional strong typing checked at parse time, alongside fully dynamic code.
• Object-oriented, procedural, and functional styles, including closures and functional constructs.
• Embedding and sandboxing via the Program class, which lets a host application run logic under fine-grained restrictions on what that code may access.
• A rich standard module ecosystem for enterprise work: database access through a DBI-style abstraction layer, plus modules for HTTP, REST, SOAP, WebSocket, and other protocols.
• Source files using extensions such as .q, .qm (modules), and .qtest (tests).

Qore itself is implemented in C++ (using POSIX threads), which underpins both its performance and its native threading model.

A small taste of Qore, with optional type annotations:

%new-style
int sub factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

printf("%d\n", factorial(10));

Evolution

For most of its history Qore evolved quietly through a very long 0.x cycle, refining its type system, expanding its library of modules, and hardening the runtime for production integration workloads rather than chasing mainstream popularity. The arrival of semantic versioning around the 0.9.6 series and the 1.0.0 release in 2021 marked a transition from continuous internal evolution to a more formally stable public language. The 2.x line in 2025 continued active development, showing that — nearly two decades after its creation — the language remains under steady maintenance by Qore Technologies and its community.

Current Relevance

Qore occupies a specific and durable niche. It is not a general-purpose language competing for web or data-science mindshare; it is an enterprise integration language, most visible as the engine inside the Qorus Integration Engine, where its threading model, deterministic resource handling, and embedding/sandboxing capabilities are direct assets. The project continues to ship regular releases — the current version is 2.2.0 (October 2025) — and is developed in the open on GitHub under permissive and copyleft licenses.

Why It Matters

Qore is a reminder that mainstream scripting languages made a particular trade-off — simplicity bought at the cost of a global interpreter lock and weak concurrency — and that the trade-off was not inevitable. By designing for thread-safety and SMP scalability from the very first line, and by pairing automatic memory management with deterministic, RAII-style destruction, Qore showed that a high-level, garbage-collected language could still offer the kind of predictable resource control and genuine parallelism usually associated with systems languages like C++. It is a focused, working answer to a hard problem in enterprise software: how to let people write integration logic that is concise and safe to embed, yet able to scale across many threads without falling over.