Deploy Eff to Europe — The First Algebraic Effects Language on EU Infrastructure in 2026

Before Koka had effect types, before Frank had row-typed effects, before Effekt compiled handlers to efficient JVM bytecode — there was Eff. Eff is the language that proved algebraic effects could exist outside a theorem prover. It was the existence proof: you could take the mathematical theory of algebraic effects and handlers, as developed by Gordon Plotkin and Matija Pretnar, and turn it into a real programming language with a syntax, a type checker, an evaluator, and programs that actually ran. Everything that came after — the practical explosion of algebraic effects as a programming language feature — traces back to Eff.

Eff was created in 2011 by Andrej Bauer 🇸🇮 and Matija Pretnar 🇸🇮, both at the University of Ljubljana 🇸🇮 — funded by the European Research Council. Ljubljana, Slovenia. A small Central European university, ERC-backed, producing work that restructured how the programming language community thinks about computational effects. Eff's handlers showed that exceptions, state, non-determinism, coroutines, and cooperative concurrency are not four separate mechanisms requiring four separate language features — they are four instances of one mechanism: algebraic effects with delimited continuations.

Eff applications deploy to sota.io on EU infrastructure with full GDPR compliance. This guide shows how.

The European Eff Team

Eff's creation and theoretical foundations are entirely EU-origin.

Andrej Bauer 🇸🇮 — Slovenian mathematician, Full Professor at the Faculty of Mathematics and Physics, University of Ljubljana — co-created Eff and has been the primary advocate for algebraic effects as a unifying framework for computational effects in practical languages. Bauer's mathematical background spans constructive mathematics, realizability theory, and computable topology — fields where the relationship between computation and logic is fundamental. His ERC-funded research at Ljubljana (ERC Starting Grant "ALEA" and subsequent projects) directly funded Eff's development: the European Research Council providing the resources for Slovenian mathematicians to build a programming language that influenced every subsequent algebraic effects implementation. Bauer's "An Introduction to Algebraic Effects and Handlers" (2015, ENTCS) remains the most widely cited accessible treatment of the subject — the paper that brought algebraic effects from the denotational semantics community to the broader programming languages audience. His blog (Mathematics and Computation) has been instrumental in spreading the ideas from Ljubljana to the wider community. Bauer is also known for his work on homotopy type theory (HoTT), constructive mathematics, and his principle that "every proof has a corresponding algorithm" — a philosophy that shaped Eff's design as a bridge between mathematical theory and running programs.

Matija Pretnar 🇸🇮 — Slovenian computer scientist, Associate Professor at the Faculty of Mathematics, Natural Sciences and Information Technologies, University of Primorska (previously University of Ljubljana) — co-created Eff and wrote the foundational formal theory for effect handlers. Pretnar completed his PhD at the University of Edinburgh 🏴󠁧󠁢󠁳󠁣󠁴󠁿 in 2010, supervised by Gordon Plotkin 🇬🇧 — the Edinburgh theorist whose work on algebraic effects and handlers provided the mathematical substrate for Eff. Pretnar's thesis "Logic and Handling of Algebraic Effects" (Edinburgh, 2010) is the definitive formal reference for effect handlers: the type theory, the operational semantics, the denotational model. It is the document that algebraic effect implementations — Koka, Frank, Links, Helium, Effekt — have used as their formal specification. Pretnar then returned to Slovenia to build Eff with Bauer, turning the formal model from his thesis into a running interpreter. The academic trajectory — Edinburgh PhD, Ljubljana implementation — is a microcosm of the EU research network: theory developed at a UK university with European roots, implemented at a Slovenian university with ERC funding.

Gordon Plotkin 🇬🇧 — British computer scientist, Professor Emeritus at the University of Edinburgh — is the theoretical ancestor of Eff. Plotkin and Pretnar's joint papers ("Handlers of Algebraic Effects", GLL 2009; "Algebraic Effects and Handlers", MFPS 2013) established the formal semantics that Eff implements. Plotkin's contribution to programming language theory spans four decades: the structural operational semantics framework (SOS), domain theory, and denotational semantics. His collaboration with Pretnar on algebraic effects connected fifty years of theoretical computer science to a new practical programming feature. Edinburgh's Laboratory for Foundations of Computer Science has been the theoretical home of algebraic effects research. That Eff was born from an Edinburgh PhD student returning to Ljubljana to build a language demonstrates how EU academic networks — cross-border PhD supervision, shared theoretical foundations — produce programming language innovations that then spread globally.

The Ljubljana–Edinburgh Axis is the EU research infrastructure behind algebraic effects. The theory was developed collaboratively: Pretnar in Edinburgh under Plotkin, Bauer in Ljubljana independently developing constructive foundations, both feeding back into the Eff implementation. The European Research Council (ERC) funding mechanism — supporting individual researchers at EU institutions for high-risk, high-reward foundational research — is precisely what enabled a Slovenian mathematician and a Scottish theorist to produce work that influenced programming language design worldwide. Eff is EU-funded infrastructure, in the deepest sense: public European money invested in mathematical foundations that became a global programming language feature.

Why Eff for EU Backends

Effects are first-class language citizens. In Eff, effects are declared, typed, and handled as primary constructs — not bolted-on annotations or monadic wrappers. An effect is declared with its operations:

effect State : sig
  operation get : unit -> int
  operation set : int -> unit
end

A computation performs operations from the effect:

let counter () =
  let x = State.get () in
  State.set (x + 1);
  State.get ()

A handler interprets the effect — defining what get and set actually mean:

let state_handler init = handler
  | State.get () k -> (fun s -> k s s)
  | State.set x k -> (fun _ -> k () x)
  | val x -> (fun s -> x)

The handler captures the delimited continuation k at each operation — the rest of the computation after the operation is called. This is the core insight: effect handlers are not callbacks or exception catchers but continuation manipulators, able to resume, discard, or duplicate the continuation. For EU backends that need to reason about stateful data processing — GDPR audit trails, financial transaction logs, healthcare record mutations — this means the entire state management story is explicit, composable, and compiler-checked.

Non-determinism, backtracking, and search are natural. Because handlers capture continuations, a single handler can implement non-deterministic computation:

effect Choose : sig
  operation decide : unit -> bool
end

let choose_all = handler
  | Choose.decide () k -> k true @ k false
  | val x -> [x]

A computation using Choose.decide () explores both branches. The choose_all handler returns a list of all possible results. This is not a library or a monad — it is a plain function calling an effect operation, interpreted by a handler that resumes the continuation twice. For EU AI systems under Article 22 of the GDPR (automated decision-making with human oversight requirements), Eff's native backtracking search means decision logic is transparent and auditable rather than embedded in opaque library internals.

Cooperative concurrency without callbacks. Effect handlers naturally implement cooperative concurrency: a scheduler effect whose operations are yield and fork, handled by a round-robin scheduler. Concurrent programs in Eff are written as straight-line code using yield when willing to pause — no callbacks, no async/await, no explicit coroutine machinery. The scheduler handler manages the queue of suspended continuations. For EU services with concurrent request handling — GDPR data subject access requests that must process multiple streams of personal data simultaneously — cooperative concurrency via effects is composable in ways that callback-based or thread-based models are not.

GDPR-relevant effect boundaries. Eff's type system tracks which effects a computation can perform. A function that only performs Log effects cannot perform Network effects without declaring them. A computation typed as unit (no effects) cannot read from a database without the Db effect in its type. For EU backend services handling personal data under GDPR Article 5 (data minimisation, purpose limitation), effect-typed functions make the data flow boundaries explicit and compiler-enforced: the category of personal data processing is visible in every function's type signature.

OCaml backend for production. Eff compiles to OCaml, which means production deployments benefit from OCaml's industrial-grade runtime: incremental garbage collection with predictable latency, efficient native code compilation, a mature ecosystem of HTTP libraries. The Dream web framework (by Anton Bachin) provides async HTTP/1.1 and HTTP/2 with WebSocket support. OCaml's type system provides a second layer of static verification beyond Eff's effect types. For EU services requiring both functional correctness (Eff's effect types) and production reliability (OCaml's runtime), the combination provides a compiler-verified path from effect-typed business logic to deployed web service.

Deploying Eff on sota.io

sota.io runs on German infrastructure — Frankfurt data centres, GDPR-compliant by design, no US data residency requirements. Eff applications deploy via Docker.

Dockerfile for Eff + Dream

FROM ocaml/opam:debian-12-ocaml-5.1 AS build

WORKDIR /app
RUN sudo apt-get install -y pkg-config libssl-dev

# Install Eff and Dream via opam
RUN opam install eff dream

COPY . .
RUN eval $(opam env) && ocamlfind ocamlopt \
    -package eff,dream \
    -linkpkg \
    src/main.ml -o app

FROM debian:12-slim
RUN apt-get update && apt-get install -y libssl3 ca-certificates
COPY --from=build /app/app /usr/local/bin/app
EXPOSE 8080
CMD ["app"]

HTTP server with effect-typed request handling

(* Effects for the request context *)
effect Db : sig
  operation query : string -> string list
end

effect Auth : sig
  operation current_user : unit -> string option
end

(* Handler that fails on unauthenticated requests *)
let require_auth = handler
  | Auth.current_user () k ->
    (match get_session () with
    | Some user -> k (Some user)
    | None -> Dream.respond ~status:`Unauthorized "")

(* Database handler backed by PostgreSQL *)
let db_handler = handler
  | Db.query sql k ->
    let results = Pg.exec connection sql in
    k results

(* Route handler — types enforce that only Db + Auth effects occur *)
let handle_users_request () : <Db, Auth> Dream.response =
  let user = Auth.current_user () in
  match user with
  | None -> Dream.respond ~status:`Unauthorized ""
  | Some u ->
    let rows = Db.query ("SELECT id, email FROM users WHERE owner = '" ^ u ^ "'") in
    Dream.json (Json.of_list rows)

let () =
  Dream.run ~port:8080
  @@ Dream.router [
    Dream.get "/users"
      (fun _req ->
        with require_auth handle
        with db_handler handle
        handle_users_request ())
  ]

The types enforce that handle_users_request can only access the database and authentication — no network effects, no file system effects, no logging to external services unless explicitly declared. GDPR Article 25 (data protection by design) implemented at the type level.

sota.io deployment

# sota.yaml
name: my-eff-service
region: eu-central-1
build:
  dockerfile: Dockerfile
service:
  port: 8080
  memory: 512mb
  replicas: 2
database:
  postgres: true
  version: "17"

sota deploy
# Building Docker image...
# Pushing to EU registry (Frankfurt)...
# Running health check...
# ✓ Deployed to https://my-eff-service.sota.io

The deployment runs in Frankfurt. Your Eff service, the PostgreSQL database, and all personal data stay in the EU. No CLOUD Act exposure. GDPR-compliant by infrastructure design.

The Algebraic Effects Lineage from Ljubljana

Eff is not just a language — it is the origin point of a lineage:

Eff (2011) — Bauer and Pretnar, Ljubljana. First practical language with algebraic effects and handlers. Proved the concept.

Frank (2014–2017) — Conor McBride and Craig McLaughlin, University of Strathclyde 🏴󠁧󠁢󠁳󠁣󠁴󠁿 Glasgow. Row-typed effects: effects described as rows of operations, handled by pattern matching on operation-return pairs. Frank made effect types more expressive with polymorphic rows.

Links (2017 algebraic effects extension) — Sam Lindley and Daniel Hillerström, University of Edinburgh 🏴󠁧󠁢󠁳󠁣󠁴󠁿. Added algebraic effects to the Links web language. Demonstrated effect-typed web applications.

Koka (2012–present) — Daan Leijen 🇳🇱 (Dutch, Microsoft Research), built on the theory from Edinburgh and Ljubljana. The most production-ready algebraic effects language. Perceus reference counting. EU-origin theory, Dutch practitioner.

Effekt (2020–present) — Jonathan Brachthäuser 🇩🇪 (German, Universität Tübingen and TU Dortmund). Algebraic effects compiling to efficient JVM/JS/LLVM code. German-origin, EU-funded, production-targeted.

OCaml 5 effect handlers (2022) — KC Sivaramakrishnan (Cambridge), Tom Kelly, Stephen Dolan. Algebraic effects built into OCaml 5's Multicore runtime. Mainstream language adoption of the theory from Eff.

Scala 3 / ZIO / cats-effect (2020s) — The monadic encoding of algebraic effects in Scala, influenced by the theory from Ljubljana and Edinburgh. Used in production at Zalando 🇩🇪, ING 🇳🇱, and Klarna 🇸🇪.

The entire algebraic effects ecosystem in mainstream languages — OCaml 5 effects, the influence on Rust's async design, the theoretical basis for effect systems in TypeScript proposals — traces to Eff. To the ERC grant at Ljubljana. To Pretnar's Edinburgh PhD supervised by Plotkin. EU academic funding produced, at minimum, a decade of programming language innovation.

EU Research Credentials

Eff is among the most thoroughly EU-credentialed programming languages:

• ERC-funded development — the European Research Council's Starting Grant mechanism funded Bauer's algebraic effects research at Ljubljana. Public EU money.
• University of Ljubljana 🇸🇮 — a Slovenian public university, an EU institution, producing research that became a global programming language feature.
• Edinburgh PhD connection — Pretnar's theoretical foundation built at a UK university through the EU academic exchange network.
• EuroProofNet COST Action — Bauer is an active participant in the EU COST Action CA20111 "EuroProofNet", building EU-wide infrastructure for formal proof development. Algebraic effects and proof assistants are connected through constructive type theory.
• TYPES EU Consortium — Bauer participates in the EU TYPES consortium, the European network for type theory research.

For EU public sector customers under NIS2 (Network and Information Systems Directive) or the EU Cybersecurity Act, software with verified EU research provenance matters. Eff is not just EU-deployable — it is EU-origin at every level: creators, institutions, funding.

Get Started

Deploy your first Eff service on sota.io today:

# Install the sota CLI
npm install -g sota-cli

# Initialize a new Eff project
sota init my-eff-service --template eff

# Deploy to EU infrastructure (Frankfurt)
cd my-eff-service
sota deploy

Your Eff service runs in Frankfurt. GDPR-compliant by design. Effect types make data flow boundaries explicit at compile time. No GC pauses on the OCaml runtime. EU-origin language, EU infrastructure, EU data residency.

Deploy Eff to sota.io →

See also: Deploy Koka to Europe — the production-ready algebraic effects language built on Eff's theory. Deploy OCaml to Europe — Eff's compilation target with the Dream web framework. All 58 Languages →