sota.io
2026-04-02·9 min read·sota.io team

Deploy BCPL to Europe — Martin Richards 🇬🇧 Cambridge + The Language That Made C Possible on EU Infrastructure in 2026

In 1967, a researcher at the University of Cambridge Mathematical Laboratory wrote a programming language that would silently reshape the entire software world. He wanted to simplify CPL — the Combined Programming Language that had been designed at Cambridge and London — into something that could actually be implemented. He succeeded. The language he created became the ancestor of every C program ever written, every Java application ever deployed, every Python script ever run, every Go binary ever compiled.

His name was Martin Richards 🇬🇧. The language was BCPL — the Basic Combined Programming Language. The laboratory was in Cambridge, England. The year was 1967.

The inheritance chain runs directly from Cambridge to the modern world: BCPL (Cambridge, 1967) → B (Ken Thompson, Bell Labs, 1969) → C (Dennis Ritchie, Bell Labs, 1972) → C++, Objective-C, Java, Python, PHP, JavaScript, Go, Rust, Swift, Kotlin. Every major programming ecosystem in production today is a direct descendant of work done by a British computer scientist at Cambridge University in the 1960s.

Martin Richards is still alive. He is Professor Emeritus at Cambridge. He still maintains BCPL. He released an updated version in 2023. The language that made modern computing possible is still actively maintained by its 85-year-old creator, in Cambridge, England.

Martin Richards and the Cambridge Mathematical Laboratory

The University of Cambridge Mathematical Laboratory was established in 1937. It became one of the world's most consequential computer science institutions. Maurice Wilkes — later Sir Maurice Wilkes, winner of the Turing Award 1967 — built EDSAC there in 1949: the first stored-program computer to run a real application (a program to compute a table of squares). EDSAC demonstrated that stored-program computing was practically achievable, and Cambridge became the birthplace of what we now call software.

Martin Richards joined Cambridge as an undergraduate in the early 1960s, then remained as a researcher. He encountered CPL — the Combined Programming Language — which had been designed in a collaboration between Cambridge (where Christopher Strachey worked) and University College London. CPL was extraordinarily ambitious: it aimed to be a language that could express any algorithm cleanly. But CPL was so large and complex that no one had managed to implement it. It existed primarily as a design document.

Richards took a different approach. He stripped CPL down to its essential core — the parts that could actually be compiled efficiently. He removed the type system, simplified the expression grammar, kept the structured control flow, and built a single-pass compiler. The result was BCPL: typeless, fast to compile, portable via an intermediate O-code representation, and small enough to implement in weeks rather than years. Richards implemented the first BCPL compiler in two weeks.

BCPL was portable by design. The compiler did not generate machine code directly. It compiled to O-code — an intermediate representation for a notional abstract machine — and a separate O-code interpreter or translator would run or translate the O-code on the target hardware. This portability was radical in 1967, when each machine typically had its own incompatible language and compiler. BCPL programs could run on IBM mainframes, PDP computers, and any machine with an O-code implementation.

The Lineage: BCPL → B → C → Everything

In 1969, Ken Thompson at Bell Labs was building UNIX for the PDP-7. He needed a systems programming language — something lower-level than Fortran but higher-level than assembly, something portable across the PDP-7 and the PDP-11. He found BCPL. He took BCPL, adapted it to the memory model of the PDP-7, and created B.

B preserved BCPL's fundamental design: typeless (everything is a machine word), structured control flow (if, while, for), and a simple expression language. Thompson used B to write the early UNIX utilities. B was smaller than BCPL — partly because the PDP-7 had very limited memory — and it dropped O-code in favour of direct code generation.

Then Dennis Ritchie added types. In 1972, Ritchie extended B with a type system — integers, characters, pointers, arrays, structures — and the result was C. UNIX was rewritten in C in 1973. The rest is the entire history of modern computing.

The inheritance of syntax is direct and visible. BCPL introduced the // single-line comment syntax. C and C++ use /* */ for block comments, but C++ reintroduced // comments from BCPL heritage, and C99 standardised them. Every codebase that uses // for comments is expressing a syntax choice made by Martin Richards at Cambridge in 1967.

BCPL's section brackets — $( and $) — became B's { and }. Every curly-brace language — C, Java, JavaScript, TypeScript, Go, Rust, C#, PHP, Swift — inherits the block delimiter syntax from BCPL's design. The { and } that delimit every function body, every class, every if-block in modern code trace back to Cambridge, England.

// BCPL: original syntax from Martin Richards (1967)
// Note: // comments are a BCPL invention, inherited by C++ and C99

GET "libhdr"

LET start() = VALOF {
    LET name = "EU developer"
    LET greeting = "Deploy to Europe"
    writef("Hello, %s: %s*n", name, greeting)
    RESULTIS 0
}

The LET keyword, the VALOF block that produces a value, the writef function — these are BCPL as Richards designed them. The structured control flow, the treatment of programs as expressions producing results, the minimalism of the type system (there is no type system: every variable holds a machine word) — all of this influenced C directly.

BCPL's Technical Design

The Typeless Word Machine

BCPL is typeless in a precise sense. There are no integer types, no character types, no pointer types distinguishable to the compiler. Every variable holds a single machine word — an unsigned integer of the platform's natural word size. What that word means — an integer, a pointer to a string, an address — is entirely the programmer's responsibility.

This sounds dangerous by modern standards. But it was a deliberate philosophical position: the compiler should trust the programmer. The hardware does not distinguish between an integer and a pointer at the bit level; why should the compiler impose overhead enforcing that distinction? BCPL's typelessness meant the compiler was simple, fast, and generated efficient code. C's innovation was adding types to BCPL's word machine — gaining safety without sacrificing performance.

O-code and Portability

BCPL compiles to O-code — an intermediate code for a stack-based virtual machine. The O-code instruction set is simple: push, pop, arithmetic operations, jumps, calls. An O-code interpreter can run BCPL programs on any machine where the interpreter is implemented. A native code translator can translate O-code to machine instructions for performance.

This design — compile to intermediate representation, then interpret or translate — became the foundation for the Java Virtual Machine (Java bytecode), the .NET CLR (MSIL), WebAssembly, and every other portable intermediate representation in modern use. JVM bytecode is a direct intellectual descendant of BCPL's O-code.

Structured Control Flow

BCPL was one of the first languages to make structured programming the norm rather than the exception. if/else, while, for, switchon (switch statements), and break/loop (break/continue) were all present in BCPL. The goto statement existed but was unnecessary for most programs. BCPL demonstrated that you could write real systems programs — operating systems, compilers, editors — without goto.

Edsger Dijkstra's famous 1968 letter "Go To Statement Considered Harmful" argued the same point in theory. BCPL proved it in practice.

BCPL in 2026: The Reference Implementation

Martin Richards' reference implementation of BCPL is available from the Cambridge Computer Laboratory. It compiles via a C backend — BCPL source code compiles to C, and the C compiler generates native binaries. This means BCPL runs on any platform with a C compiler, including modern Linux servers.

FROM ubuntu:22.04 AS builder

RUN apt-get update && apt-get install -y \
    gcc \
    make \
    wget \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /bcpl
# Download Martin Richards' BCPL distribution from Cambridge
RUN wget -q https://www.cl.cam.ac.uk/~mr10/bcplprogs.tar.gz && \
    tar -xzf bcplprogs.tar.gz && \
    cd bcplprogs && make

# Build the BCPL application
COPY hello.b /bcpl/app/hello.b
RUN cd /bcpl/app && /bcpl/bcplprogs/bin/bcpl hello.b to hello

FROM ubuntu:22.04
COPY --from=builder /bcpl/app/hello /app/hello
CMD ["/app/hello"]

The hello.b program (BCPL source, using .b extension as Thompson's B did):

GET "libhdr"

MANIFEST {
    port = 8080
}

LET start() = VALOF {
    writef("sota.io BCPL service starting on port %n*n", port)
    writef("BCPL: Cambridge Mathematical Laboratory, 1967*n")
    writef("Lineage: BCPL -> B -> C -> C++ -> Java -> everything*n")
    RESULTIS 0
}

GDPR and EU Regulatory Compliance

GDPR Article 5(1)(f) — Security by Design

BCPL programs have predictable, auditable memory behaviour. Without a garbage collector, without a runtime heap manager, without dynamic type dispatch, a BCPL program's memory access pattern is determined entirely at compile time. For data processing systems handling personal data under GDPR Article 5(1)(f), this predictability is a security property: there are no GC-triggered pauses that could cause timing side-channels, no hidden memory allocation that could retain personal data past its intended lifetime.

EU AI Act Article 13 — Transparency and Auditability

BCPL compiles to C, which compiles to native machine code. The compilation chain is short, deterministic, and fully auditable. For AI-adjacent data preprocessing pipelines — data ingestion, transformation, normalisation — a BCPL implementation can be verified to do exactly what the source code states. The EU AI Act's transparency requirements for high-risk systems benefit from compilation chains where every step is inspectable.

GDPR Article 25 — Data Minimisation by Design

BCPL's typeless word model means no hidden metadata, no object headers, no reference counting fields. A BCPL data structure contains exactly the words the programmer declares and nothing more. Data structures that hold personal data under GDPR Article 30 (records of processing activities) can be designed with precisely the footprint the data requires — no runtime overhead, no hidden copies.

The Cambridge Legacy in EU Computing

The Cambridge connection runs deeper than BCPL alone. The Cambridge Computer Laboratory — now the Department of Computer Science and Technology — has been responsible for an extraordinary fraction of fundamental computing research:

Robin Milner — a fellow of St John's College, Cambridge — won the Turing Award 1991 for ML and the pi-calculus. The type inference that prevents runtime type errors in modern languages traces to Cambridge. The process calculi that justify Erlang's nine-nines reliability trace to Cambridge. Bjarne Stroustrup 🇩🇰 spent years at Cambridge before designing C++, building on the very tradition Richards established.

Cambridge is in the United Kingdom. Post-Brexit, the UK is outside the European Union, but it remains inside the European Economic Area for GDPR purposes — the UK GDPR is effectively identical to EU GDPR, and data transfers between the EU and UK operate under an adequacy decision. Cambridge research, Cambridge-born languages, and Cambridge-derived computing infrastructure are part of the European computing heritage that GDPR was designed to protect.

Deploy BCPL on sota.io

sota.io supports any language that compiles to a Linux binary or runs in a standard container. A BCPL application containerised as shown above deploys with:

sota deploy --region eu-west

The platform detects the container, provisions EU infrastructure on Hetzner (Germany) or Scaleway (France), injects managed PostgreSQL credentials as environment variables, configures TLS termination, and assigns a .sota.io subdomain. All infrastructure runs within the European Economic Area.

For BCPL programs that need database access, the standard pattern is to compile a hybrid: BCPL for the core logic, with C interface functions for JDBC/PostgreSQL connectivity. The BCPL-to-C compilation path makes this straightforward — BCPL and C share the same compiler toolchain and ABI on any platform where Martin Richards' BCPL distribution is installed.

Cambridge University gave the world BCPL in 1967. Bell Labs turned it into C. The entire industry built on top of C. sota.io brings that heritage to EU infrastructure — GDPR-compliant, German-hosted, managed PostgreSQL included.

Martin Richards still maintains BCPL. The language that made modern computing possible is still alive in Cambridge, England. And it can deploy to Europe.

sota.io is the EU-native platform-as-a-service for developers who need European infrastructure, GDPR compliance by default, and managed PostgreSQL without the operational overhead. Deploy your BCPL application to EU servers in minutes at sota.io.