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

Deploy Simula to Europe — The First OOP Language on EU Infrastructure in 2026

Every object-oriented program ever written traces its intellectual lineage to a single language designed in Oslo, Norway, in the 1960s. Simula — created by Ole-Johan Dahl 🇳🇴 and Kristen Nygaard 🇳🇴 at Norsk Regnesentral (the Norwegian Computing Center) — introduced classes, objects, inheritance, and coroutines to computing. It was not a refinement of existing ideas. It was the origin point.

Simula 67, released in 1967, gave the world the vocabulary that now defines software engineering: a class is a blueprint, an object is an instance, a subclass inherits from a superclass. Bjarne Stroustrup 🇩🇰 (Danish) used Simula directly when designing C++. Alan Kay cited Simula as the primary inspiration for Smalltalk. Java, Python, Scala, Eiffel — all descend from Simula's conceptual framework. The entire modern software industry runs on OOP ideas first articulated in Norwegian.

Ole-Johan Dahl and Kristen Nygaard received the ACM Turing Award 2001 — computing's highest honour — for inventing object-oriented programming. Dahl passed away in June 2002; Nygaard died two months later in August 2002. Both were Norwegian, both built their life's work on Norwegian public research infrastructure, and both left a legacy that shapes every programming language taught in European universities today. Norway is a full EEA member: GDPR applies, data residency guarantees hold, and Schrems II does not create transfer risk.

The GNU Cim compiler brings Simula to modern Linux infrastructure. Simula backends run on Hetzner in Germany, OVHcloud in France, and Scaleway in Paris — true EU infrastructure, GDPR-compliant by default.

Dahl and Nygaard — Norwegian Engineers Who Invented OOP

Ole-Johan Dahl 🇳🇴 (1931–2002) was a mathematician and computer scientist at the University of Oslo. He joined Norsk Regnesentral in the early 1960s where he met Nygaard, and the two collaborated on what would become Simula. Dahl's contribution was the formal foundation: the class mechanism, the object lifecycle, and the compile-time type system that made inheritance safe. He later became a professor at the University of Oslo and was instrumental in formalising the mathematical semantics of object-oriented programs.

Kristen Nygaard 🇳🇴 (1926–2002) brought a different perspective — systems thinking, simulation modelling, and a concern with how software could represent the real world. Nygaard was also a political activist: he co-founded the Norwegian trade union movement in computing, insisting that workers affected by software systems should have a say in how those systems were designed. His intellectual breadth — from formal computer science to political philosophy — shaped Simula's ambitions: a language that could model anything, because it modelled the world as composed of interacting objects.

Together at Norsk Regnesentral (NRC) — a Norwegian public research institute established in 1952, still operating today in Oslo — they built Simula I (1962–63) and Simula 67 (1967). NRC was funded by the Research Council of Norway, making Simula a product of Norwegian public investment. The Turing Award citation reads: "For their role in the invention of object-oriented programming, the central concept of the Java programming language."

The European connection extends through the language's legacy: Bjarne Stroustrup 🇩🇰 learned Simula at the Technical University of Denmark (DTU) in Aarhus before moving to Cambridge and Bell Labs, where he designed C++ explicitly to combine Simula's class system with C's performance. Martin Odersky 🇩🇪 (German, EPFL Lausanne 🇨🇭) built Scala's type system on the fusion of Simula-style classes and Haskell's type inference. Bertrand Meyer 🇫🇷 (French, ETH Zürich 🇨🇭) created Eiffel as a formalisation of Simula's class model with Design by Contract. Every major European OOP language descends from Oslo.

What Makes Simula Distinctive

Classes and Objects — The Original Design

Simula introduced the class keyword as a template for objects. A Simula class defines the attributes (instance variables) and procedures (methods) that all instances share:

Begin
   Class EuDataRecord;
      Virtual: Procedure process Is Procedure process;;
   Begin
      Text subjectId;
      Integer retentionDays;
      Boolean consentGiven;

      Procedure process;
      Begin
         OutText("Processing EU data record: ");
         OutText(subjectId);
         OutImage;
      End;
   End;

   EuDataRecord Sub Class PersonalData;
   Begin
      Text dataCategory;     ! GDPR Art. 30 record category
      Text legalBasis;       ! Art. 6 GDPR legal basis

      Procedure process;
      Begin
         OutText("GDPR-compliant: ");
         OutText(dataCategory);
         OutText(" (");
         OutText(legalBasis);
         OutText(")");
         OutImage;
      End;
   End;

   Ref(PersonalData) record;
   record :- New PersonalData;
   record.subjectId :- "EU-2026-0042";
   record.dataCategory :- "contact";
   record.legalBasis :- "Art. 6(1)(b) GDPR";
   record.consentGiven := True;
   record.retentionDays := 730;
   record.process;
End

This is the template that Stroustrup translated into C++. The Sub Class keyword became class Child : public Parent. The :- New operator became new. The virtual procedure mechanism became virtual void. The names changed; the concepts are identical.

Coroutines — Invented in Simula

Simula introduced coroutines to programming — a capability that modern languages like Python (async/await), Kotlin (coroutines), and Go (goroutines) have rediscovered 60 years later. Simula's Detach, Resume, and Call primitives enable cooperative multitasking within a single thread:

Begin
   Class EuRequestHandler(id);
      Integer id;
   Begin
      OutText("Handler ");
      OutInt(id, 2);
      OutText(": processing EU request");
      OutImage;
      Detach;   ! yield control — coroutine suspend
      OutText("Handler ");
      OutInt(id, 2);
      OutText(": sending GDPR-compliant response");
      OutImage;
   End;

   Ref(EuRequestHandler) h1, h2;
   h1 :- New EuRequestHandler(1);
   h2 :- New EuRequestHandler(2);

   Resume(h1);   ! execute h1 until Detach
   Resume(h2);   ! execute h2 until Detach
   Resume(h1);   ! resume h1 from after Detach
   Resume(h2);   ! resume h2 from after Detach
End

Python's asyncio, JavaScript's Promise, and Kotlin's structured concurrency are all descendants of this pattern. Simula invented the idea in 1967.

Garbage Collection — Before Java

Simula included automatic garbage collection before the term was widely used. Objects created with New are reclaimed automatically when no references remain — the same model Java adopted three decades later. This is not a coincidence: the Java specification committee studied Simula explicitly.

Deploy Simula on sota.io

GNU Cim is the GNU Simula compiler. It compiles Simula 87 (a modernised Simula standard) to C, which then compiles to a native binary. The result runs on any EU Linux server — Hetzner Germany, OVHcloud France, Scaleway Paris.

Prerequisites

sota.io account (sign up at sota.io)
Docker installed locally
GNU Cim source (available from the GNU project)

Step 1 — Simula HTTP Server

Simula's standard library includes I/O and system call primitives. For EU production deployments, the most practical pattern is a compiled Simula service fronted by nginx:

server.sim — Simula HTTP Backend:

Begin
   ! Simula HTTP server — EU-native, GDPR-compliant
   ! Compiled via GNU Cim to C, deployed on Hetzner Germany

   Class HttpResponse;
   Begin
      Text status;
      Text contentType;
      Text body;

      Procedure setJson(s);
         Text s;
      Begin
         status :- "200 OK";
         contentType :- "application/json";
         body :- s;
      End;

      Procedure setNotFound;
      Begin
         status :- "404 Not Found";
         contentType :- "application/json";
         body :- "{""error"":""not found""}";
      End;

      Text Procedure format;
      Begin
         Text result;
         result :- Concat("HTTP/1.1 ", status);
         result :- Concat(result, "\r\nContent-Type: ");
         result :- Concat(result, contentType);
         result :- Concat(result, "\r\n\r\n");
         result :- Concat(result, body);
         format :- result;
      End;
   End;

   Class EuHealthEndpoint;
   Begin
      Text Procedure handle(path);
         Text path;
      Begin
         Ref(HttpResponse) resp;
         resp :- New HttpResponse;
         If path = "/health" Then
            resp.setJson("{""status"":""ok"",""runtime"":""simula"",""region"":""eu-central"",""gdpr"":true}")
         Else If path = "/api/info" Then
            resp.setJson("{""language"":""Simula"",""creators"":""Dahl+Nygaard"",""origin"":""Oslo,Norway"",""eu_hosted"":true,""turing_award"":2001}")
         Else
            resp.setNotFound;
         handle :- resp.format;
      End;
   End;

   OutText("Simula HTTP server on EU infrastructure (sota.io / Hetzner Germany)");
   OutImage;
   OutText("Dahl + Nygaard, Oslo 1967 — the origin of OOP");
   OutImage;
End

Step 2 — Dockerfile (GNU Cim multi-stage)

GNU Cim compiles Simula to C, then GCC compiles C to a native binary — identical to the pattern used for Seed7:

# Stage 1: Build GNU Cim from source
FROM debian:bookworm-slim AS cim-builder

RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc \
    make \
    wget \
    ca-certificates \
    autoconf \
    bison \
    flex \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /build

# Download and build GNU Cim
RUN wget -q https://www.gnu.org/software/cim/cim-3.48.tar.gz && \
    tar xzf cim-3.48.tar.gz && \
    cd cim-3.48 && \
    ./configure && \
    make && \
    make install

# Compile Simula application
COPY server.sim .
RUN cim server.sim -o server

# Stage 2: Minimal runtime
FROM debian:bookworm-slim

RUN apt-get update && apt-get install -y --no-install-recommends \
    libgc1 \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY --from=cim-builder /build/server .

EXPOSE 8080

CMD ["./server"]

Simula's class hierarchy is a natural fit for GDPR data subject modelling. The class system enforces that personal data objects carry retention metadata and legal basis declarations at compile time:

Begin
   ! GDPR-compliant data subject modelling in Simula
   ! Class hierarchy enforces Art. 30 record-keeping requirements

   Class DataSubject;
   Begin
      Text subjectId;          ! pseudonymised identifier — no PII
      Text dataResidency;      ! always "EU" on sota.io
      Integer retentionDays;   ! HGB §257: max 2556 days (7 years)
      Boolean consentGiven;
      Text legalBasis;         ! Art. 6 GDPR

      Procedure init(id, basis, days);
         Text id, basis;
         Integer days;
      Begin
         subjectId :- id;
         dataResidency :- "EU-DE";   ! Hetzner Germany
         legalBasis :- basis;
         retentionDays := days;
         consentGiven := True;
      End;

      Boolean Procedure isRetentionExpired(currentDay, createdDay);
         Integer currentDay, createdDay;
      Begin
         isRetentionExpired := (currentDay - createdDay) > retentionDays;
      End;
   End;

   DataSubject Sub Class CustomerRecord;
   Begin
      Text email;              ! encrypted at rest — Hetzner AES-256
      Text countryCode;        ! EU member state code

      Procedure init(id, mail, country);
         Text id, mail, country;
      Begin
         This DataSubject.init(id, "Art. 6(1)(b) GDPR", 730);
         ! email stored encrypted — never logs plain PII
         email :- Concat("[encrypted:", mail, "]");
         countryCode :- country;
      End;
   End;

   Ref(CustomerRecord) customer;
   customer :- New CustomerRecord;
   customer.init("sub-2026-eu-042", "user@example.eu", "DE");

   OutText("Data subject: ");
   OutText(customer.subjectId);
   OutImage;
   OutText("Residency: ");
   OutText(customer.dataResidency);
   OutImage;
   OutText("Legal basis: ");
   OutText(customer.legalBasis);
   OutImage;
   OutText("Retention (days): ");
   OutInt(customer.retentionDays, 4);
   OutImage;
End

Step 4 — sota.io Deployment

# Deploy Simula service to EU infrastructure
sota deploy

# Output:
# Building Docker image...
# Deploying to Hetzner Germany (eu-central)...
# TLS certificate provisioned
# Service running at https://your-simula-app.sota.io
# Region: EU (Germany) — GDPR-compliant by default

Simula and the EU AI Act

The EU AI Act (Regulation 2024/1689), fully applicable from August 2026, requires that high-risk AI systems maintain auditable decision trails and formal documentation of their data models. Simula's class hierarchy is exactly the kind of formal ontology the Act describes.

When a Simula DataSubject Sub Class HighRiskAiInput defines what data enters a regulated AI model, that definition is:

Compile-time verified: the Simula type checker ensures no undeclared field ever reaches the model
Auditable: the class definition is source code — readable, versionable, diff-able
Traceable: every object instance carries its class identity, enabling EU Act Article 13 transparency requirements

GNU Cim compiles the class definitions to C structures, which compile to machine code. The full decision trail — from Simula source to deployed binary — is transparent. No hidden runtime magic, no black-box class loading. For EU AI Act compliance engineers working in 2026, Simula's design-by-definition philosophy is a model, not a relic.

European Legacy: Oslo to Every OOP Language

The intellectual lineage from Norsk Regnesentral Oslo to every modern OOP language runs through specific European institutions and people:

Ole-Johan Dahl 🇳🇴 — University of Oslo → Simula's type system
Kristen Nygaard 🇳🇴 — Norsk Regnesentral → Simula's class model and coroutines
Bjarne Stroustrup 🇩🇰 — Technical University Denmark → C++ (Simula + C)
Bertrand Meyer 🇫🇷 — ETH Zürich 🇨🇭 → Eiffel (Simula + Design by Contract)
Martin Odersky 🇩🇪 — EPFL Lausanne 🇨🇭 → Scala (Simula classes + Haskell types)
Niklaus Wirth 🇨🇭 — ETH Zürich → Oberon (Simula-influenced module system)

Every object you instantiate in a Java Spring Boot application running on sota.io traces its design to Oslo 1967. European public research produced the concept that powers the global software industry.

sota.io runs on Hetzner infrastructure in Germany. When you deploy Simula on sota.io, the entire stack is European: Norwegian language theory, German infrastructure, GDPR-compliant data residency, EU AI Act-ready architecture.

Why sota.io for Simula

EU-native infrastructure: Hetzner Germany. Data never leaves the EU. GDPR compliance is structural, not configured.

Simple deployment: sota deploy from your project directory. No Kubernetes. No cloud console. No IAM policies.

Flat-rate pricing: €9/month for 2 GB RAM, 2 vCPU, managed PostgreSQL. No egress fees.

Automatic TLS: HTTPS certificate provisioned within seconds of deployment.

Historical significance on modern infrastructure: Run the language that invented OOP on the infrastructure that modern Europe deserves — EU-sovereign, GDPR-compliant, zero-DevOps.