Deploy Eiffel to Europe — EU Hosting for Eiffel Backends in 2026

Most programming languages are named after mathematicians or describe what they do. Eiffel is named after a tower in Paris. The choice was deliberate: Bertrand Meyer, the French computer scientist who created Eiffel in the mid-1980s while working at Interactive Software Engineering (ISE) in Paris, chose the name to signal that the language was an engineering achievement — a structure built on solid foundations, designed to last. The Eiffel Tower was an engineering marvel that critics said would never work. Bertrand Meyer thought software correctness was also achievable, if you approached it with the right principles.

He was right about the principles. Design by Contract — the idea that every function should declare its preconditions, postconditions, and class invariants as part of the code itself — is now embedded in Kotlin, Python's typing system, C#'s Code Contracts, and the way every modern software engineer thinks about interface specification. Eiffel invented it, Europe refined it, and Swiss and French universities spent two decades teaching it to every computer science student who passed through their lecture halls.

Europe's Contributions to Eiffel

The Eiffel language is more thoroughly European than almost any other language in this series. It was created by a French programmer, standardized by a European standards body, and taught for decades at one of Europe's most prestigious technical universities.

Bertrand Meyer 🇫🇷 (born in Reims, France) created Eiffel while at Interactive Software Engineering (ISE) in Paris in 1985. Meyer had studied at the École Polytechnique and Stanford, but his foundational work on software reliability was rooted in the French tradition of mathematical rigor in engineering. He later became a professor at ETH Zürich 🇨🇭, the Swiss Federal Institute of Technology — the same institution where Niklaus Wirth created Pascal, Modula-2, and Oberon (see our Pascal and Oberon posts). ETH Zürich's software engineering chair became synonymous with Eiffel; for decades, first-year computer science students at ETH learned to program in Eiffel as their introduction to systematic software construction. Meyer's textbook, Object-Oriented Software Construction, went through two editions and influenced how software engineering was taught across Europe and beyond.

After ETH, Meyer became a professor at Politecnico di Milano 🇮🇹, one of Italy's premier technical universities, where he continued developing Software Engineering methods and tools. Eiffel thus has a distinctly pan-European biography: French origin, Swiss academic development, Italian continuation.

ECMA-367 and ISO/IEC 25436: Eiffel is one of the few programming languages to be standardized by both ECMA International (the European computer standards body, based in Geneva 🇨🇭) and the International Organization for Standardization. ECMA-367 was first published in 2005 and defines the Eiffel language specification. ISO/IEC 25436:2006 is the corresponding international standard. The fact that a programming language has both ECMA and ISO standards reflects the seriousness with which the European computing establishment treated Eiffel as infrastructure.

EiffelStudio and the Open Source Release: ISE Eiffel, the commercial IDE and compiler, became EiffelStudio and was released as open-source under the GPLv2 in 2006. The open-source community around EiffelStudio has historically been concentrated in Europe. The EWF (Eiffel Web Framework) project, which provides the HTTP server infrastructure for building Eiffel web applications, is maintained by contributors primarily in the EU community.

The Gobo Framework — a collection of portable Eiffel libraries covering data structures, regular expressions, XML, and more — was primarily authored by Eric Bezault 🇫🇷 (France). Gobo is the standard library collection for production Eiffel systems that need Unicode handling, POSIX interfaces, and reusable data structure implementations.

Design by Contract in European Education: Meyer's Design by Contract (DbC) was adopted as the pedagogical foundation for software engineering courses at ETH Zürich, TU Munich, TU Delft, and other European universities. The idea — that correct software is software that satisfies provable contracts between caller and callee — influenced the entire European approach to formal methods, verified software, and proof-carrying code. The formal methods tradition at INRIA 🇫🇷, the verified systems work at TU Munich and TU Vienna 🇦🇹, and the B-method used in French railway signalling (RATP and SNCF use formally verified safety software) are all part of the same European tradition that Eiffel's DbC philosophy represents.

Design by Contract: Why It Matters

Eiffel's key technical contribution — Design by Contract — is built into the language syntax rather than added as a library:

class STACK [G]
feature
    push (item: G)
        require
            -- precondition: stack must not be full
            not is_full
        do
            -- implementation
            count := count + 1
            storage.put (item, count)
        ensure
            -- postcondition: count increases by 1
            count = old count + 1
            not is_empty
        end

    pop: G
        require
            not is_empty
        do
            Result := storage.item (count)
            count := count - 1
        ensure
            count = old count - 1
        end

invariant
    -- class invariant: count always non-negative
    count >= 0
    count <= capacity
end

The require block defines preconditions — what must be true when the function is called. The ensure block defines postconditions — what is guaranteed when the function returns. The invariant block defines class invariants — properties that must hold throughout the object's lifetime. When you run an Eiffel program in debug mode, the runtime checks these contracts automatically. When you run in production, they can be compiled out for performance — but the specifications remain in the code as documentation that cannot go stale.

This discipline is why Eiffel has been used in aerospace, medical devices, and financial systems where correctness matters more than novelty.

Eiffel in Production in 2026

Eiffel is not fashionable. It is correct. The organizations that use Eiffel in production in 2026 have typically made an active choice to prioritize verifiability over ecosystem size.

Aerospace and Safety-Critical Systems: The Design by Contract approach maps directly onto DO-178C (airborne software certification) and IEC 61508 (functional safety) requirements. Several European aerospace contractors have used Eiffel-derived methods for safety case documentation.

Financial Systems: The formal verification properties that DbC enables are valuable in financial systems where a function that silently returns wrong results can cost millions. Several European financial institutions have maintained Eiffel-based calculation engines because the code is verifiably correct.

Academic Computing: European universities that teach formal methods and software verification continue to use Eiffel as a teaching language. Its combination of clean OO design and built-in contract specification makes it the ideal language for teaching systematic software construction.

Performance: Compiled Eiffel with contracts disabled for production is fast. EiffelStudio's SCOOP (Simple Concurrent Object-Oriented Programming) model provides high-level concurrency based on message passing, which scales well on multi-core hardware.

Eiffel is not the fastest language for web services, but for systems where correctness is the primary concern, the performance is entirely adequate and the contract checking in development mode catches logic errors before they reach production.

Building an Eiffel HTTP Backend

The standard stack for a modern Eiffel web backend is EWF (Eiffel Web Framework) for HTTP handling, ECLI for database access, and EiffelStudio (or the open-source ec compiler) as the build tool.

Project Structure

src/
  application.e
  api_handler.e
  db.e
Dockerfile
sota.yaml

HTTP Handler with EWF

class API_HANDLER
inherit
    WSF_DEFAULT_SERVICE [WSF_LAUNCHABLE_SERVICE]
        rename
            make as make_service
        end

create
    make_and_launch

feature {NONE} -- Initialization
    make_and_launch
        do
            make_service (create {WSF_SERVICE_LAUNCHER_OPTIONS})
        end

feature -- Request handling
    execute (req: WSF_REQUEST; res: WSF_RESPONSE)
        require
            req /= Void
            res /= Void
        local
            body: STRING
        do
            if req.path_info.same_string ("/health") then
                res.put_header ({HTTP_STATUS_CODE}.ok, <<["Content-Type", "application/json"]>>)
                body := "{%"status%":%"ok%"}"
                res.put_string (body)

            elseif req.path_info.starts_with ("/api/") then
                handle_api (req, res)

            else
                res.put_header ({HTTP_STATUS_CODE}.not_found, Void)
                res.put_string ("Not found")
            end
        ensure
            -- response was sent
            res.header_committed
        end

    handle_api (req: WSF_REQUEST; res: WSF_RESPONSE)
        require
            req /= Void
            res /= Void
        local
            db: DATABASE_HANDLER
            result_json: STRING
        do
            create db.make
            if db.is_connected then
                result_json := db.query_as_json ("SELECT id, name FROM items LIMIT 10")
                res.put_header ({HTTP_STATUS_CODE}.ok, <<["Content-Type", "application/json"]>>)
                res.put_string (result_json)
            else
                res.put_header ({HTTP_STATUS_CODE}.service_unavailable, Void)
                res.put_string ("{%"error%":%"database unavailable%"}")
            end
        end
end

PostgreSQL Access with ECLI

class DATABASE_HANDLER

create make

feature {NONE} -- Initialization
    make
        do
            create session.make
            connect
        end

    session: ECLI_SESSION

feature -- Status
    is_connected: BOOLEAN
        do
            Result := session.is_connected
        end

feature -- Queries
    connect
        local
            db_url: STRING
        do
            db_url := "postgresql://user:password@localhost:5432/mydb"
            session.set_connection_string (db_url)
            session.connect
        ensure
            connected_or_error: is_connected or else session.has_error
        end

    query_as_json (sql: STRING): STRING
        require
            not sql.is_empty
            is_connected
        local
            stmt: ECLI_STATEMENT
            buffer: ECLI_VARCHAR
        do
            create stmt.make (session)
            create Result.make (256)
            stmt.set_sql (sql)
            stmt.execute
            Result.append ("[")
            from
                stmt.start
            until
                stmt.off
            loop
                -- serialize row to JSON
                Result.append (row_to_json (stmt))
                stmt.forth
                if not stmt.off then
                    Result.append (",")
                end
            end
            Result.append ("]")
            stmt.close
        ensure
            Result /= Void
        end
end

Dockerfile

FROM debian:bookworm-slim AS builder

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

# Install EiffelStudio (ISE Eiffel)
RUN wget -q https://downloads.eiffel.com/eiffelstudio/releases/23.09/EiffelStudio-23.09-linux-x86-64.tar.gz \
    && tar xzf EiffelStudio-23.09-linux-x86-64.tar.gz -C /opt \
    && rm EiffelStudio-23.09-linux-x86-64.tar.gz

ENV ISE_EIFFEL=/opt/EiffelStudio-23.09
ENV ISE_PLATFORM=linux-x86-64
ENV PATH="${ISE_EIFFEL}/bin:${PATH}"

WORKDIR /app
COPY . .
RUN ec -config my_app.ecf -finalize -clean

FROM debian:bookworm-slim
RUN apt-get update && apt-get install -y libpq5 && rm -rf /var/lib/apt/lists/*
COPY --from=builder /app/EIFGENs/my_app/F_code/my_app /app/my_app
EXPOSE 8080
CMD ["/app/my_app"]

sota.yaml

name: my-eiffel-api
runtime: docker
port: 8080
region: eu-central-1

env:
  - name: DATABASE_URL
    secret: database-url
  - name: ISE_EIFFEL
    value: /usr/local/eiffelstudio

resources:
  cpu: 0.5
  memory: 256Mi

health:
  path: /health

Deploying to sota.io

# Install sota CLI
npm install -g sota-cli

# Login
sota login

# Deploy from project root
sota deploy

# Check status
sota status

# View logs
sota logs --follow

sota.io handles the containerization, PostgreSQL provisioning, SSL certificates, and EU data residency. Your Eiffel binary runs on German infrastructure, GDPR-compliant by default. No Kubernetes configuration required.

Why European Infrastructure for Eiffel

Eiffel was designed with European values: correctness over convenience, specification over hope, engineering discipline over rapid iteration. The European tradition of formal methods — from Dijkstra's structured programming to Meyer's Design by Contract to the B-method used in French railway systems — reflects a philosophy that software should be provably correct, not just approximately working.

Running Eiffel on European infrastructure is a natural fit. sota.io's EU-native deployment means your data stays in Europe, your latency to European users is minimised, and your GDPR compliance is built in at the infrastructure level rather than bolted on afterwards.

Getting Started

1. Install EiffelStudio — the open-source community edition is sufficient for most projects
2. Create a new EWF project using the EiffelStudio project wizard
3. Add sota.yaml to your project root
4. Deploy: sota deploy

sota.io automatically detects your Dockerfile, builds the container, and deploys to EU infrastructure.

Eiffel resources:

• EiffelStudio documentation
• Eiffel Web Framework (EWF)
• Design by Contract reference

Deploy Eiffel to Europe in minutes. Start for free on sota.io — EU-native PaaS, managed PostgreSQL, GDPR-compliant by default.