Pike

Pike is a dynamic, general-purpose programming language with a familiar C-like syntax, automatic garbage collection, a rich set of high-level built-in data types, and first-class anonymous functions. It blends static (manifest) and dynamic typing in a single, flexible type system, and supports object-oriented, procedural, and functional styles of programming. Though it has always been a niche language, Pike has a serious pedigree: it was forged in the world of multi-user text games, matured into the implementation language of a commercial web server, and has been continuously maintained for three decades.

History & Origins

Pike’s story begins not with Pike at all, but with LPC — “Lars Pensjö C” — a small, memory-efficient, C-like language created around the late 1980s by Lars Pensjö at Chalmers University in Gothenburg, Sweden. LPC was designed to let people write the rooms, objects, and behaviors of MUDs (multi-user dungeons), the text-based multiplayer adventure games that flourished on early networks.

At the Lysator academic computer society in Linköping, programmers — most prominently Fredrik Hübinette — became interested in LPC not just as a game language but as a general tool. They separated the language and its virtual machine from the rest of the MUD driver and evolved a dialect known as LPC4, increasingly using it as a rapid-prototyping language for ordinary applications.

There was a problem, though: LPC’s original license did not allow commercial use. So in 1994, with financial backing from Signum Support AB, Hübinette set out to write a clean, independent implementation under the GNU GPL, which he called µLPC (“micro LPC”). When the company InformationsVävarna AB — later renamed Roxen Internet Software (Roxen AB) — adopted µLPC to build its web server (replacing an earlier LPC4-based server), the language got a new, more marketable name: in 1996, µLPC became Pike.

At Roxen, Pike was developed by Hübinette together with a talented group that included Per Hedbor, Henrik Grubbström, Martin Stjernholm, Pontus Hagland, and Marcus Comstedt. Roxen funded Pike’s development through its early years and continues to contribute. In 2002, Roxen handed primary maintenance to the Programming Environment Laboratory (PELAB) at Linköping University, where the language’s stewardship has remained.

Design Philosophy

Pike was conceived as a language that feels comfortable to a C or C++ programmer while removing the drudgery and danger of manual memory management. Its guiding ideas include:

• Familiar surface, high-level core. The syntax deliberately resembles C, so braces, semicolons, and control structures look the way many programmers expect — but underneath sits a garbage-collected runtime with dynamic, high-level data types.
• A type system that meets you in the middle. Pike lets you write loosely typed, dynamically checked code for quick prototyping, or add explicit type declarations where you want the compiler’s help. The result combines some of the safety of static typing with the flexibility of dynamic typing.
• Batteries included for the network era. Because Pike grew up building a commercial web server, it has long shipped with strong support for strings, networking, data formats, and other facilities needed for server-side and Internet programming.
• Open and free. Pike is distributed under a choice of free-software licenses (GPL, LGPL, and MPL), reflecting its origins as a deliberately unencumbered alternative to the commercially restricted LPC.

Key Features

• Garbage collection. Memory is managed automatically, including the collection of cyclic data structures.
• Rich built-in data types. Beyond the usual integers and floats, Pike offers built-in strings, arrays, mappings (associative arrays/dictionaries), and multisets, among others, as native, high-level types.
• First-class and anonymous functions. Functions are values that can be passed around and created inline, enabling a functional style alongside object-oriented and procedural code.
• Object orientation. Pike supports classes, objects, inheritance, and program-as-object semantics drawn from its LPC heritage.
• Flexible typing. Static (manifest) type declarations and dynamic typing coexist, letting code range from script-like to strongly typed.
• Arbitrary-precision and high-level math, plus broad library support for things like networking, image processing, cryptography, and data serialization, reflecting decades of use in production server software.

A flavour of the syntax

int main()
{
    write("Hello, World!\n");

    array(string) names = ({ "Ada", "Grace", "Alan" });
    foreach (names, string name)
        write("Hello, %s!\n", name);

    mapping(string:int) ages = ([ "Ada": 36, "Grace": 85 ]);
    write("Grace is %d\n", ages["Grace"]);

    return 0;
}

The C-like int main() entry point and braces sit alongside Pike-specific literals: ({ ... }) for arrays and ([ key:value ]) for mappings, plus the foreach iteration construct and printf-style write.

Evolution

Over its lifetime Pike progressed through a series of major lines — the 7.x series under Roxen and the university, and the long-lived 8.0 series that has received many point releases (identified by build numbers such as 8.0.1738 and 8.0.1956). Development has continued into the 9.0 series, whose betas began appearing around 2024 and are intended to become the next stable line.

The two defining arcs of Pike’s evolution are independence — the move from a license-restricted MUD language to a free, commercially usable implementation — and endurance: a small but steady community has kept the language maintained and shipping cross-platform binaries (macOS, Linux, and Windows) decades after its debut.

Current Relevance

Pike today is a niche but actively maintained language. It does not have the mindshare of mainstream scripting languages, and most of its visibility comes from its association with the Roxen web server and its academic home at Linköping University. Yet it remains under genuine development: the stable 8.0 series continues to receive releases, and a 9.0 series is in beta as of 2026. Official binaries are provided for macOS, Linux, and Windows.

For a working programmer, Pike’s appeal is that of a comfortable, C-flavored scripting language with grown-up facilities for networking and server work — a quieter cousin of the dynamic languages that became famous in the same era.

Why It Matters

Pike is a fascinating case of a language that escaped its origins. Born inside the MUD subculture as a way to script text adventures, it was deliberately re-implemented to break free of license restrictions, then pressed into service as the foundation of a commercial web server at the dawn of the web. Its careful blend of C-like familiarity with garbage collection, high-level data types, and a hybrid static/dynamic type system anticipated design choices that many later languages would popularize. And its long, low-key survival — maintained by a Swedish academic lab and a dedicated community for thirty years — makes it a quietly instructive example of how a language can find purpose, earn its independence, and simply keep going.