Deploy Standard ML to Europe — Robin Milner's Cambridge Legacy in 2026

In 1973, at the University of Edinburgh, Robin Milner was trying to build a theorem prover. The problem was not the logic — it was the programming language. The languages available at the time could not express the kind of structured reasoning his LCF (Logic for Computable Functions) system needed. So he built one.

That language was ML — Meta Language. Created not as a general-purpose language but as the implementation language for a proof assistant, ML introduced two ideas that changed computer science: type inference and the Hindley-Milner type system. You no longer had to annotate every variable with its type. The compiler could figure it out. If the types did not match, the compiler told you before the code ran — not after.

ML became the most influential language most programmers have never used. Its direct descendants include OCaml (used at INRIA France and Jane Street), F# (developed at Microsoft Research Cambridge), and Haskell (influenced by ML's type system). Standard ML is the standardized version, defined formally in 1990 in The Definition of Standard ML — one of the most mathematically rigorous language specifications ever written.

Milner went on to Cambridge, where he invented the π-calculus and bigraphical reactive systems, earning the Turing Award in 1991. But ML — Standard ML — remained: a language where the type system is a proof system, and the compiler is your collaborator.

The European Roots of Standard ML

Standard ML is not merely European in origin. It is a crystallization of decades of European programming language research.

Robin Milner 🏴󠁧󠁢󠁳󠁣󠁴󠁿 (University of Edinburgh → Cambridge) created ML in 1973 at Edinburgh's Laboratory for Foundations of Computer Science (LFCS). The LFCS at Edinburgh is one of the world's preeminent research groups in programming languages, type theory, and formal verification — a tradition that continues today with Milner's intellectual descendants. After Edinburgh, Milner moved to Cambridge's Computer Laboratory, where he led theoretical computer science research until his death in 2010. The Milner Award, given annually by the Royal Society, is named in his honour.

Luca Cardelli 🇮🇹 (Edinburgh → DEC Systems Research Center → Microsoft Research Cambridge) worked at Edinburgh in the ML tradition before joining DEC SRC in California. His fundamental contributions to module systems, polymorphic type theory, and object-oriented type systems shaped what Standard ML's module system became. Cardelli later returned to Europe at Microsoft Research Cambridge, where he continued research on programming languages and type systems. His book Types and Programming Languages (with Benjamin Pierce) is the standard graduate text on the subject.

Mads Tofte 🇩🇰 (DIKU — Department of Computer Science, University of Copenhagen) is one of the four co-authors of The Definition of Standard ML (1990, revised 1997), alongside Milner, Robert Harper, and David MacQueen. The book is a complete formal specification of the language — its static semantics (type system) and dynamic semantics (evaluation) defined as mathematical judgements. Tofte later developed region-based memory management at DIKU, an alternative to garbage collection where memory lifetimes are inferred statically by the compiler. This work led to ML Kit, a Standard ML compiler that can run programs with no runtime garbage collector.

The ML Kit compiler — developed at DIKU Copenhagen by Mads Tofte and colleagues — is still actively maintained. It compiles Standard ML to native code (x86-64 Linux, WebAssembly) using region inference. Benchmarks show ML Kit programs running within 10-30% of C performance for computation-heavy workloads, without GC pauses.

Poly/ML — the most widely used Standard ML runtime in Europe — was developed at the University of Cambridge by David Matthews 🏴󠁧󠁢󠁳󠁣󠁴󠁿. Poly/ML is the runtime used by Isabelle (the theorem prover developed jointly at TU Munich 🇩🇪 and Cambridge 🇬🇧) and HOL4 (a proof assistant from the University of Edinburgh 🏴󠁧󠁢󠁳󠁣󠁴󠁿). These are not academic curiosities: Isabelle has been used to verify the seL4 microkernel (used in military and aerospace systems), ARM processor correctness proofs, and cryptographic protocols. Poly/ML's multicore garbage collector, developed with Cambridge's Technology Transfer Office, makes it production-capable.

The European SML ecosystem forms a triangle: Edinburgh (origin, theory, HOL), Cambridge (Poly/ML, Isabelle, formal verification), Copenhagen (ML Kit, region inference). Each node has been active for decades and continues producing working software.

What Standard ML Brings to Modern Backends

Standard ML's type system enforces correctness before deployment. For backend services — where errors cause real financial or data damage — this matters.

Algebraic data types with exhaustive matching:

(* Payment processing with no unhandled cases *)
datatype PaymentResult =
    Success of { transactionId: string, amount: real }
  | Declined of { reason: string, code: int }
  | NetworkError of string
  | RateLimited of { retryAfter: int }

fun handlePayment (result: PaymentResult): string =
  case result of
      Success { transactionId, amount } =>
        "OK:" ^ transactionId ^ ":EUR" ^ Real.toString amount
    | Declined { reason, code } =>
        "DECLINED:" ^ Int.toString code ^ ":" ^ reason
    | NetworkError msg =>
        "ERROR:network:" ^ msg
    | RateLimited { retryAfter } =>
        "RETRY:" ^ Int.toString retryAfter
(* Compiler error if any case is missing — no silent failures *)

Parametric polymorphism — the Hindley-Milner type system:

(* Type-safe generic operations — no casting, no runtime errors *)
fun mapOption (f: 'a -> 'b) (opt: 'a option): 'b option =
  case opt of
      NONE   => NONE
    | SOME x => SOME (f x)

(* Type inferred automatically: (int -> string) -> int option -> string option *)
val formatAge = mapOption Int.toString
val result = formatAge (SOME 42)  (* SOME "42" — type-checked, no annotation needed *)

Modules — the most powerful module system in any mainstream language:

(* Signature: interface contract *)
signature DATABASE = sig
  type connection
  type 'a result = (string, 'a) Either.either
  val connect: string -> connection result
  val query: connection -> string -> string list result
  val transaction: connection -> (connection -> 'a result) -> 'a result
end

(* Structure: implementation *)
structure PostgresDB: DATABASE = struct
  type connection = { host: string, port: int, handle: int }
  type 'a result = (string, 'a) Either.either

  fun connect connStr = (* implementation *)
    Right { host = "localhost", port = 5432, handle = 0 }

  fun query conn sql = (* query execution *)
    Right []

  fun transaction conn f = f conn
end

(* Functors: modules parameterized over other modules *)
functor MakeRepository (DB: DATABASE) = struct
  fun findUser conn id =
    DB.query conn ("SELECT * FROM users WHERE id = '" ^ id ^ "'")
end

The module system is ML's most underappreciated feature. Functors — functions from modules to modules — allow dependency injection, interface abstraction, and testability at the type level.

A Poly/ML HTTP Backend for sota.io

Poly/ML supports network programming through its standard library and the basis standard library. Here is a complete HTTP service:

(* server.sml — Poly/ML HTTP API for sota.io deployment *)
structure Server = struct

  (* JSON serialization — minimal, type-safe *)
  datatype json =
      JNull
    | JBool   of bool
    | JInt    of int
    | JFloat  of real
    | JString of string
    | JArray  of json list
    | JObject of (string * json) list

  fun jsonToString (JNull) = "null"
    | jsonToString (JBool true) = "true"
    | jsonToString (JBool false) = "false"
    | jsonToString (JInt n) = Int.toString n
    | jsonToString (JFloat r) = Real.toString r
    | jsonToString (JString s) = "\"" ^ String.toString s ^ "\""
    | jsonToString (JArray xs) =
        "[" ^ String.concatWith "," (map jsonToString xs) ^ "]"
    | jsonToString (JObject kvs) =
        "{" ^ String.concatWith ","
          (map (fn (k, v) => "\"" ^ k ^ "\":" ^ jsonToString v) kvs) ^ "}"

  (* HTTP response builder *)
  fun httpResponse status contentType body =
    "HTTP/1.1 " ^ Int.toString status ^ " OK\r\n" ^
    "Content-Type: " ^ contentType ^ "\r\n" ^
    "Content-Length: " ^ Int.toString (String.size body) ^ "\r\n" ^
    "Connection: close\r\n" ^
    "\r\n" ^ body

  (* Route handler *)
  fun handleRequest path =
    case path of
        "/health" =>
          httpResponse 200 "application/json"
            (jsonToString (JObject [("status", JString "ok"),
                                    ("runtime", JString "poly-ml")]))
      | "/api/users" =>
          httpResponse 200 "application/json"
            (jsonToString (JArray [
              JObject [("id", JInt 1), ("name", JString "Alice")],
              JObject [("id", JInt 2), ("name", JString "Bob")]
            ]))
      | _ =>
          httpResponse 404 "application/json"
            (jsonToString (JObject [("error", JString "not found")]))

  (* TCP server using Poly/ML's built-in network library *)
  fun startServer port =
    let
      val sock = INetSock.TCP.socket ()
      val addr = INetSock.any port
    in
      Socket.Ctl.setREUSEADDR (sock, true);
      Socket.bind (sock, addr);
      Socket.listen (sock, 10);
      print ("Poly/ML HTTP server on port " ^ Int.toString port ^ "\n");
      let
        fun acceptLoop () =
          let
            val (clientSock, _) = Socket.accept sock
            val request = Socket.recvVec (clientSock, 4096)
            val reqStr = Byte.bytesToString request
            (* Parse path from request line *)
            val path = case String.tokens (fn c => c = #" ") reqStr of
                           _ :: p :: _ => p
                         | _ => "/"
            val response = handleRequest path
          in
            Socket.sendVec (clientSock,
              Word8VectorSlice.full (Byte.stringToBytes response));
            Socket.close clientSock;
            acceptLoop ()
          end
      in
        acceptLoop ()
      end
    end

end

val () = Server.startServer 8080

MLton for Production Performance

For production deployments where performance matters, MLton compiles Standard ML to highly optimized native binaries:

(* compute.sml — CPU-bound task, MLton-compiled *)

(* Benchmark: Fibonacci with memoization using functional maps *)
structure IntMap = BinaryMapFn(struct
  type ord_key = int
  val compare = Int.compare
end)

fun memoFib n =
  let
    fun go memo k =
      case IntMap.find (memo, k) of
          SOME v => (memo, v)
        | NONE =>
            if k <= 1 then
              (IntMap.insert (memo, k, k), k)
            else
              let
                val (memo1, v1) = go memo (k - 1)
                val (memo2, v2) = go memo1 (k - 2)
                val result = v1 + v2
              in
                (IntMap.insert (memo2, k, result), result)
              end
    val (_, result) = go IntMap.empty n
  in
    result
  end

val () =
  let
    val n = 40
    val result = memoFib n
  in
    print ("fib(" ^ Int.toString n ^ ") = " ^ Int.toString result ^ "\n")
  end

MLton's whole-program optimization eliminates most allocation and enables inlining across module boundaries. Benchmarks show MLton SML within 5-15% of equivalent C code — faster than Python, Ruby, or unoptimized JVM.

Dockerfile for sota.io Deployment

# Multi-stage: MLton build → minimal runtime image
FROM debian:bookworm-slim AS builder

# Install MLton — available in Debian repos
RUN apt-get update && apt-get install -y \
    mlton \
    libgmp-dev \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY . .

# Compile to native binary
RUN mlton -output server server.mlb

# Runtime: minimal Debian
FROM debian:bookworm-slim

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

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

EXPOSE 8080
CMD ["./server"]

(* server.mlb — MLton build file *)
$(SML_LIB)/basis/basis.mlb
server.sml

sota.io Deployment

# Install sota CLI
curl -fsSL https://sota.io/install.sh | sh

# Login and create project
sota login
sota init --name sml-api --runtime docker

# Deploy
sota deploy

# Your SML backend is live at https://sml-api.sota.io
# GDPR-compliant: EU data residency, PostgreSQL managed

sota.yml configuration:

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

resources:
  memory: 128mb    # MLton binary: lean memory footprint
  cpu: 0.25

health_check:
  path: /health
  interval: 30s

database:
  postgres: true    # Managed PostgreSQL — EU data residency

Why European Teams Choose Standard ML

Isabelle/HOL projects: European aerospace (Airbus 🇫🇷🇩🇪, ESA 🇪🇺), semiconductor firms, and defense contractors use Isabelle for formal verification — all running on Poly/ML. Teams working near these tools often use SML for adjacent tooling.

Theorem-proving adjacent work: Any backend that feeds data into formal verification pipelines benefits from SML's strong type system. The type checker enforces invariants that matter in safety-critical domains.

Academic research prototyping: European CS departments — Edinburgh, Cambridge, Copenhagen, TU Munich, Chalmers — use SML in graduate courses and research prototypes. Researchers who want to deploy their work find sota.io's zero-DevOps model attractive.

GDPR-native hosting: Standard ML code handling personal data benefits from EU-residency hosting. sota.io is built in Europe, stores data in Europe, and is governed by EU law. The same values that make European researchers choose SML — rigor, correctness, formal guarantees — align with EU data protection requirements.

Performance Comparison

MLton and ML Kit produce lean, fast native binaries. For backend services that need speed and minimal memory footprint, SML competes with C.

Deploy on sota.io

sota.io runs Standard ML backends in European data centers with managed PostgreSQL, automatic TLS, and no infrastructure to manage.

sota deploy --from-dockerfile
# Build: 45s → Deploy: 12s → Live at sml-api.sota.io

Robin Milner built ML to make correctness tractable. sota.io makes deploying it to European infrastructure equally tractable.

Deploy your Standard ML backend →