2026-04-10·8 min read·sota.io team
Deploy to Europe: Complete Guide for 190 Programming Languages (2026)
If you're building software for European users — whether you're writing Go microservices, Python data pipelines, Node.js APIs, or JVM enterprise applications — one question comes up sooner or later: where do you deploy it?
AWS, Vercel, Railway, and Heroku all default to US regions. That works fine until you have a GDPR audit, a banking client with data residency requirements, or a healthcare app subject to DSGVO §22. Then "just push to us-east-1" stops being an option.
sota.io is the EU-native PaaS built for exactly this. It runs on Hetzner infrastructure in Germany. Your data stays in the EU by default — no configuration, no data transfer agreements, no GDPR exceptions to manage. This guide is the complete index of every language we've documented, with direct links to each deployment guide.
Why EU Hosting Matters
The Schrems II ruling (CJEU C-311/18) invalidated the EU-US Privacy Shield and established that personal data of EU residents cannot be freely transferred to US-controlled infrastructure. The US Cloud Act (2018) further complicates this: US-headquartered cloud providers (AWS, GCP, Azure, Vercel, Railway) are legally obligated to produce data upon US government request — regardless of where that data is physically stored.
For developers in DACH, France, Benelux, and the Nordics, this has a practical consequence: regulated industries (banking, healthcare, insurance, legal) require EU-jurisdiction data processors. sota.io is that processor — German company, German infrastructure, no US corporate parent.
The 48-Language Deployment Index
Web Frameworks & Full-Stack
| Language | Framework | Guide | Use Case |
|---|---|---|---|
| Node.js | Express, Fastify, NestJS | Deploy Node.js to Europe → | APIs, microservices, SSR |
| Next.js | App Router, Pages Router | Deploy Next.js to Europe → | Full-stack React, SSR/ISR |
| Python | FastAPI, Django, Flask | Deploy Python to Europe → | ML serving, REST APIs, data apps |
| Go | Chi, Gin, net/http | Deploy Go to Europe → | High-throughput APIs, CLIs |
| Rust | Axum, Actix-web, Warp | Deploy Rust to Europe → | High-performance services, WebAssembly |
| C++ | Crow, Drogon, Pistache | Deploy C++ to Europe → | Native-binary backends, finance, automotive, scientific computing — Bjarne Stroustrup 🇩🇰 (Aarhus University + Cambridge), ISO WG21 (BSI 🇬🇧 + DIN 🇩🇪), Qt 🇫🇮, MISRA C++ 🇬🇧, AUTOSAR 🇩🇪 |
| Zig | zap, httpz, std.http | Deploy Zig to Europe → | Industrial IoT backends, C replacement, embedded APIs, minimal binaries |
| Nim | Jester, httpbeast | Deploy Nim to Europe → | Python-like syntax at C speed, German-origin language (Andreas Rumpf 🇩🇪), minimal binary footprint |
| PHP | Laravel, Symfony | Deploy PHP & Laravel to Europe → | CMS backends, traditional web apps |
| Ruby | Ruby on Rails | Deploy Ruby on Rails to Europe → | Rapid prototyping, SaaS MVPs |
| Crystal | Kemal, Lucky | Deploy Crystal & Kemal to Europe → | Ruby syntax, C-level performance, low-memory APIs |
| Swift | Vapor 4, Hummingbird | Deploy Swift & Vapor to Europe → | iOS backend, native binary APIs |
| Dart | Dart Frog | Deploy Dart & Dart Frog to Europe → | Flutter backend, full-stack Dart, AOT binaries |
JVM & Enterprise
| Language | Framework | Guide | Use Case |
|---|---|---|---|
| Java | Spring Boot, Quarkus | Deploy Java & Spring Boot to Europe → | Enterprise systems, banking, insurance |
| Kotlin | Ktor, Spring Boot | Deploy Kotlin & Ktor to Europe → | Android backend, JVM microservices |
| Scala | Play Framework, ZIO HTTP | Deploy Scala & Play to Europe → | FinTech, risk systems, DACH enterprise (Deutsche Bank, Zalando, ING) |
| .NET / C# | ASP.NET Core, Minimal APIs | Deploy .NET to Europe → | Enterprise .NET, Azure-independent hosting |
| F# | Giraffe, Saturn | Deploy F# & Giraffe to Europe → | Functional .NET, Nordics FinTech, quantitative finance |
| Clojure | Ring, Reitit, http-kit | Deploy Clojure to Europe → | Functional JVM, EU FinTech, immutable data, REPL-driven backends |
| Groovy | Micronaut, Grails | Deploy Groovy & Micronaut to Europe → | JVM microservices, Gradle tooling, Spring-compatible APIs |
| TypeScript | NestJS, ts-rest | Deploy TypeScript & NestJS to Europe → | Enterprise TypeScript backends, Anders Hejlsberg 🇩🇰 (TypeScript creator), Kamil Myśliwiec 🇵🇱 (NestJS) |
Modern JavaScript Runtimes
| Language | Framework | Guide | Use Case |
|---|---|---|---|
| Deno 2.0 | Fresh, Oak | Deploy Deno to Europe → | Modern TypeScript APIs, edge-compatible services |
| Bun | Hono, Elysia | Deploy Bun to Europe → | High-performance Node.js replacement, fast startups |
Functional & BEAM
| Language | Framework | Guide | Use Case |
|---|---|---|---|
| Erlang/OTP | Cowboy, Ranch | Deploy Erlang to Europe → | Telecom backends, nine-nines reliability (Ericsson 🇸🇪 Stockholm), EU FinTech, distributed systems |
| Elixir | Phoenix, LiveView | Deploy Elixir & Phoenix to Europe → | Real-time apps, WebSockets, fault-tolerant systems |
| Haskell | Servant, Warp | Deploy Haskell & Servant to Europe → | Fintech, type-safe APIs, trading systems, correctness-critical services |
| OCaml | Dream, Caqti | Deploy OCaml to Europe → | EU FinTech, Jane Street-style quant finance, INRIA research backends, type-safe APIs |
| Caml Light | OCaml (direct successor), Dream | Deploy Caml Light to Europe → | Xavier Leroy 🇫🇷 + Damien Doligez 🇫🇷 (INRIA Rocquencourt, 1991) — made ML portable with ZINC abstract machine running on 286 PCs, direct precursor CAML(1987)→Caml Light(1991)→OCaml(1996)→F#(2005), CompCert formally verified C compiler (DO-178C Level A, Airbus), Collège de France Chair in Software Science, ACM Software System Award 2023, Jane Street London MiFID II trading infrastructure, .mli interface files = Caml Light's 1991 invention |
| LML (Lazy ML) | GHC (direct descendant), Stack, Clash | Deploy LML to Europe → | First compiled lazy functional language — Lennart Augustsson 🇸🇪 + Thomas Johnsson 🇸🇪 (Chalmers University of Technology, Gothenburg, 1987), Thomas Johnsson's G-machine (1984 Chalmers PhD) = first abstract machine for compiling lazy programs, STG machine (Jones 1992) designed as direct improvement on G-machine, every GHC-compiled Haskell binary runs LML's architecture, Lennart Augustsson created Lava (1998, Haskell hardware DSL, Chalmers) → Clash (Baaij 🇳🇱 UTwente 2009, Haskell→VHDL/SystemVerilog), NXP 🇳🇱 + Ericsson 🇸🇪 + ESA 🇳🇱 use Clash in production, EU Chips Act 2023 (€43B semiconductor design) — Clash enables EU-native chip design, GDPR Art. 25 lazy evaluation = data minimisation by construction |
| ISWIM | Haskell/GHC, Python (off-side rule heir) | Deploy ISWIM to Europe → | Peter Landin 🇬🇧 (Queen Mary College, University of London, 1966) — "The Next 700 Programming Languages" (CACM 9(3)), the theoretical notation that gave every modern language its let-expressions, indentation rules (off-side rule coined here), and first-class functions; SECD machine (1964) = ancestor of JVM + ZINC + STG + Python VM; J operator (1965) = first-class continuations 9 years before Scheme call/cc; Lineage ISWIM→SASL→KRC→Miranda→Haskell; Python off-side rule = Guido van Rossum 🇳🇱 (CWI Amsterdam) implementing Landin's 1966 rule |
| Bigloo | Native binary, JVM, WebAssembly, HOP.js | Deploy Bigloo to Europe → | Manuel Serrano 🇫🇷 (INRIA Sophia-Antipolis, 1992) — multi-target Scheme compiler: same R7RS source compiles to native C binary, JVM bytecode, or WebAssembly; HOP.js isomorphic web framework (server + client in one Scheme file, tilde operator marks client-side code); INRIA Sophia-Antipolis also produced Caml Light + OCaml + Esterel + Lustre; Université Côte d'Azur (IDEX 2016, EU Horizon Europe); 30+ years active maintenance; GDPR Art. 25 pure functions = data minimisation by construction; EU Chips Act WASM backend for embedded EU semiconductors |
| Gofer | GHC/Haskell, Hugs, Stack | Deploy Gofer to Europe → | Mark Jones 🇬🇧 (University of Oxford, 1993) — the functional language that designed Haskell's type class system; "Qualified Types: Theory and Practice" (Oxford DPhil thesis, Cambridge University Press 1994) = the definitive type class theory; Gofer was the Haskell committee's prototype workbench for refining type classes before Haskell 98; led to Hugs (Haskell Users' Gofer System) — standard Haskell teaching system at Oxford, Edinburgh, Nottingham, Chalmers 🇸🇪, TU Delft 🇳🇱; Functional dependencies (Jones 2000) → GHC TypeFamilies → Rust traits → Scala type classes; Simon Peyton Jones 🏴 (Glasgow) + Philip Wadler 🏴 (Edinburgh) + John Hughes 🇸🇪 (Chalmers) built Haskell on Gofer's foundations |
| Racket | web-server, Typed Racket | Deploy Racket to Europe → | Language-oriented programming, EU university platforms, research backends, CS education tools |
| Idris 2 | Network.Socket, idris2-http | Deploy Idris 2 to Europe → | Dependently typed backends, Quantitative Type Theory, safety-critical systems, formal verification |
| Curry | KiCS2, CYPM packages | Deploy Curry to Europe → | Functional logic programming, constraint solving, search problems, CAU Kiel research |
| Haxe | tink_web, HashLink/C, hxnodejs | Deploy Haxe to Europe → | Cross-platform backends, game studio infrastructure, one codebase for JS/C++/Python targets |
| Clean | Platform, iTasks | Deploy Clean to Europe → | Purely functional backends, uniqueness types, Dutch government workflow systems, safe I/O |
| Oz/Mozart | Mozart2, FD constraints | Deploy Oz/Mozart to Europe → | Multi-paradigm backends, constraint programming, distributed systems, CTMCP curriculum |
| Jolie | Jolie runtime (JVM) | Deploy Jolie to Europe → | Microservice-native language, choreographic programming, Fabrizio Montesi 🇮🇹 (SDU Odense), ERC-funded |
| Gleam | wisp, gleam_http | Deploy Gleam to Europe → | BEAM type-safety, Ericsson 🇸🇪 Stockholm distributed DNA, modern functional syntax |
| LFE (Lisp Flavoured Erlang) | Cowboy, Ranch | Deploy LFE to Europe → | Lisp macros on BEAM, Robert Virding 🇸🇪 (Ericsson co-creator of Erlang), nine-nines OTP supervision trees, NIS2 critical infrastructure resilience |
| Pharo Smalltalk | Teapot, Zinc HTTP | Deploy Pharo Smalltalk to Europe → | Live image programming, Stéphane Ducasse 🇫🇷 (INRIA Lille), EU university research environments |
| Common Lisp | Hunchentoot, Caveman2 | Deploy Common Lisp to Europe → | Metaprogramming backends, Edmund Weitz 🇩🇪 Hamburg (Hunchentoot), Bruno Haible 🇩🇪 KIT (CLISP) |
| Prolog | SWI-Prolog HTTP | Deploy Prolog to Europe → | Logic programming, AI explainability (EU AI Act), Alain Colmerauer 🇫🇷 (Marseille), Jan Wielemaker 🇳🇱 (VU Amsterdam) |
Scientific Computing
| Language | Framework | Guide | Use Case |
|---|---|---|---|
| R | Plumber, Shiny Server | Deploy R & Plumber to Europe → | Statistical APIs, Eurostat/ECB data services, Martin Maechler 🇨🇭 (ETH Zürich), Kurt Hornik 🇦🇹 (WU Wien) |
| Julia | Oxygen.jl, HTTP.jl | Deploy Julia to Europe → | High-performance scientific computing, Bogumił Kamiński 🇵🇱 (DataFrames.jl), Kristoffer Carlsson 🇸🇪 (Pkg.jl) |
| Fortran | Fortran stdlib, FHTTP | Deploy Fortran to Europe → | Climate modelling, HPC backends, ECMWF 🇮🇹 Bologna, DWD 🇩🇪 Offenbach, Météo-France 🇫🇷 |
Safety-Critical & Formally Verified
| Language | Framework | Guide | Use Case |
|---|---|---|---|
| Ada | AdaWebServer (AWS), GNAT | Deploy Ada to Europe → | Safety-critical systems, Jean Ichbiah 🇫🇷 (École Polytechnique, Ada creator), Airbus fly-by-wire |
| Eiffel | EWF (Eiffel Web Framework) | Deploy Eiffel to Europe → | Design by Contract backends, Bertrand Meyer 🇫🇷 (Paris/ETH Zürich), formal verification |
| Standard ML | PolyML, MLton | Deploy Standard ML to Europe → | Type-safe APIs, Robin Milner 🏴 (Edinburgh/Cambridge), type inference for safety-critical systems |
| Alice ML | Alice ML runtime, Seam VM | Deploy Alice ML to Europe → | Concurrent functional backends, Andreas Rossberg 🇩🇪 (Saarbrücken → WebAssembly), first-class futures |
| Mercury | mmc (Mercury compiler), C backend | Deploy Mercury to Europe → | Logic-functional backends, Zoltan Somogyi 🇭🇺🇦🇺 (Melbourne), determinism modes, Prolog expressiveness + Haskell types |
| Chapel | chpl compiler, TCP server | Deploy Chapel to Europe → | HPC parallel backends, Brad Chamberlain (Cray/HPE), locales + domains, PRACE/EuroHPC validated |
| Pony | pony-http, net/http | Deploy Pony to Europe → | Actor-model backends, Sylvan Clebsch (Imperial College London), capability types eliminate data races |
| Agda | Agda-based servers, GHC/Warp | Deploy Agda to Europe → | Formally verified backends, Ulf Norell 🇸🇪 (Chalmers University, Gothenburg), TYPES EU consortium |
| BBC BASIC | BBC BASIC for SDL (BBCSDL), Docker | Deploy BBC BASIC to Europe → | Structured BASIC with inline assembler — Sophie Wilson 🇬🇧 (Acorn Computers Cambridge, 1981). Sophie Wilson subsequently co-designed the ARM instruction set architecture (1983) with Steve Furber 🇬🇧. ARM Holdings (Cambridge 🇬🇧) powers 99% of smartphones, Apple Silicon, and AWS Graviton EU data centres. BBC Micro ran in 80% of UK schools by 1985 — Eben Upton 🇬🇧 created Raspberry Pi inspired by it. BBCSDL by Richard Russell 🇬🇧, MIT licence, Linux-native. GDPR Art. 25 data minimisation by minimal 4KB-origin runtime. NIS2 near-zero attack surface. |
| LPC | DGD (Dworkin's Game Driver), FluffOS, Docker | Deploy LPC to Europe → | Language for Programming LPMud — Lars Pensjö 🇸🇪 (Chalmers University of Technology, Gothenburg, 1989). First internet-accessible multiplayer virtual world. DGD by Felix Croes 🇧🇪 (Belgium) — transactional atomic objects, hot code replacement, snapshot persistence. LPC pioneered persistent objects (1989), sandbox capability model, coroutines — patterns now central to cloud architecture (Cloudflare Durable Objects, Kubernetes operators). GDPR Art. 17 atomic erasure via object deletion. NIS2 capability-based access control by language design. |
| CORAL 66 | GCC (C transpilation), static binary, Docker | Deploy CORAL 66 to Europe → | Computer On-line Real-time Applications Language — Royal Radar Establishment (RRE) 🇬🇧 (Malvern, Worcestershire, 1966), standardised by National Physical Laboratory (NPL, Teddington 1970). Safety-critical real-time language for embedded systems: no heap allocation, fixed-point arithmetic, ALGOL 60 block structure with coroutine-based concurrency (WAIT/SIGNAL). Deployed in Rapier surface-to-air missile, Sea Wolf CIWS, Lynx helicopter avionics, Nimrod MR2. CORAL 66 design principles → DEF STAN 00-55 (1991) → IEC 61508 (1998) — now mandatory across EU via Machinery Regulation (EU) 2023/1230, EN 50128 (railway), EN 62061 (industrial). RTL/2 (ICI, J.G.P. Barnes, 1972) = direct successor. CHILL (ITU Geneva 1980) influenced by CORAL 66 real-time model. Ada (Jean Ichbiah 🇫🇷, 1983): UK MoD CORAL 66 experience shaped Ada requirements. EU Cyber Resilience Act 2024: memory safety by design (no heap = no heap overflow). GDPR Art. 25 static allocation = bounded data lifetimes. |
| Links | OCaml + Links runtime, Docker | Deploy Links to Europe → | Tier-unified web language — Philip Wadler 🏴 (University of Edinburgh, 2006). One language compiles to JavaScript (client), SQL (database), and server-side handlers. SQL injection and XSS structurally impossible — type system prevents untrusted strings from reaching SQL or DOM. Continuation-based sessions: state lives on EU server, not in cookies. Wadler also co-designed Haskell and invented monads-for-I/O. EU Cyber Resilience Act (2024): security by construction. GDPR Art. 32: session state stays EU-resident. NIS2: eliminates injection and XSS vulnerability classes at compile time. |
| TTCN-3 | Eclipse TITAN (Ericsson 🇸🇪), Docker | Deploy TTCN-3 to Europe → | Testing and Test Control Notation version 3 — ETSI 🇪🇺 (Sophia Antipolis 🇫🇷, 2001). The telecommunications conformance testing language: Nokia 🇫🇮, Ericsson 🇸🇪, Siemens 🇩🇪, T-Systems 🇩🇪. Verifies 5G NR, LTE, UMTS, GSM, IMS, SIP protocols. Parallel test components, typed ports, formal verdicts (pass/fail/inconclusive). Eclipse TITAN (Ericsson, open source 2016) compiles TTCN-3 to C++. NIS2 Article 21: formal auditable security testing. EU CRA: conformance testing infrastructure for CE marking. GDPR: protocol traces and test results stay EU-resident. |
| Pliant | Pliant native binary, Docker | Deploy Pliant to Europe → | Self-extending systems language — Hubert Tonneau 🇫🇷 (France, 1994). Compiles to native x86/x86-64 — no VM, no interpreter, native C-equivalent performance. Meta system: programmers define new statement types and control flow constructs that integrate into the compiler as first-class syntax. FullPliant: complete self-hosting environment — HTTP server, PostgreSQL/SQLite database layer, template engine — all written in Pliant, all compiled to native code. Predates Rails, Django, and Express by years. LGPL open source. NIS2: minimal attack surface (single native binary). GDPR Art. 25: no US cloud SDK dependencies, no external telemetry calls. EU CRA: auditable, deterministic native binary without GC pauses. |
| Timber | Timber C backend, GCC, Docker | Deploy Timber to Europe → | Reactive object language for real-time embedded systems — Johan Nordlander 🇸🇪 (Chalmers University of Technology, Gothenburg, 2002). Unifies Hindley-Milner type inference with reactive concurrent objects: action (async fire-and-forget), request (sync with result), pure functional values. No garbage collector — stack allocation and explicit object lifetimes ensure predictable real-time execution. Compiles via portable C to any target (x86-64, ARM, MIPS, RISC-V). Descended from O'Haskell (Nordlander 1998). Chalmers cluster: LPC 🇸🇪 (Pensjö 1989) → LML 🇸🇪 (Augustsson+Johnsson 1984) → Timber 🇸🇪. Effect types: pure functions cannot send messages; action handlers cannot block; enforced at compile time. NIS2: embedded controllers with provable concurrency safety. EU CRA: static typing eliminates injection attacks at language level. GDPR Art. 25: no GC = no inadvertent data retention in heap. |
| VDM-SL | Overture Tool (Eclipse/JVM), Docker | Deploy VDM-SL to Europe → | ISO-standardised formal specification language — IBM Vienna Scientific Center 🇦🇹 (Peter Lucas 🇦🇹, Cliff Jones 🇬🇧, Dines Bjørner 🇩🇰, 1970s). Model-based specification: algebraic types + state invariants + pre/post-conditions + auto-generated proof obligations. Started as formal semantics of PL/I via Meta-IV notation (Vienna Definition Language). ISO/IEC 13817-1 (1996). Overture Tool open-source (Aarhus University 🇩🇰, Eclipse + VSCode). VDM++: OO extension. Applications: pacemaker formal specification (Medtronic), Danish Railways 🇩🇰 interlocking systems, British Telecom 🇬🇧 telephone exchange software. Cliff Jones's "Software Development: A Rigorous Approach" (1980): first formal methods textbook for practitioners. Dines Bjørner → RAISE/RSL (EU ESPRIT project). IEC 61508 SIL 3/SIL 4: formal methods required — VDM-SL explicitly cited. EN 50128 SIL 4 (railway safety). EU AI Act Art. 9: formal specification as high-risk AI documentation evidence. NIS2: traceable requirements → proof obligations → implementation. |
| B-Method | Atelier B (ClearSy 🇫🇷), ProB (Düsseldorf 🇩🇪), Docker | Deploy B-Method to Europe → | Formal specification and verification method — Jean-Raymond Abrial 🇫🇷 (France, 1989, The B-Book 1996). Abstract Machine Notation (AMN): state machines with invariants + pre/post-conditions + mechanically discharged proof obligations. Proved the world's first fully automated metro: Paris Metro Line 14 (METEOR, RATP 🇫🇷 + Alstom 🇫🇷, 1998) — 86,000 lines of B, 111,000 proof obligations, 0 runtime errors since launch, 200,000 passengers/day 2024. Brussels Metro Line 1 🇧🇪: same toolchain. Atelier B (ClearSy 🇫🇷, Aix-en-Provence): industrial tool, B0 code generator → Ada/C/C++. Event-B: Abrial extension for concurrent/distributed systems (ETH Zurich 🇨🇭 + Newcastle 🇬🇧). Rodin Platform (Eclipse, EU FP6 project, ETH Zurich + Southampton + Newcastle + Siemens CT 🇩🇪). ProB (Michael Leuschel 🇩🇪, University of Düsseldorf): model checker + constraint solver, open source. EN 50128 SIL 4 (railway): B proof obligations = direct compliance evidence. IEC 61508 SIL 3/4. EU AI Act Art. 9: formally proved invariants as high-risk AI safety evidence. Siemens Mobility 🇩🇪 + SNCF 🇫🇷 + Alstom 🇫🇷: B-verified signalling across Europe. |
| Event-B | Rodin Platform (Eclipse, EU FP6), ProB (Düsseldorf 🇩🇪), Docker | Deploy Event-B to Europe → | Refinement-based formal method for concurrent/distributed systems — Jean-Raymond Abrial 🇫🇷 (ETH Zurich 🇨🇭 + Newcastle 🇬🇧, 2000s). Evolution of B-Method: events (guarded state transitions) replace sequential operations → concurrent/distributed modelling. Rodin Platform (EU FP6 IST 511599, 2004–2007): Eclipse-based IDE, open source, consortium ETH Zurich + Systerel 🇫🇷 + Southampton + Newcastle + Siemens CT 🇩🇪. ProB (Michael Leuschel 🇩🇪, University of Düsseldorf): model checker + constraint solver + animation for B/Event-B. Atelier B (ClearSy 🇫🇷, Aix-en-Provence): industrial toolchain compatible with Event-B. Applications: Swiss Federal Railways 🇨🇭 interlocking systems, Belgian ATC 🇧🇪, nuclear control 🇫🇷 (Systerel). Abrial's "Modeling in Event-B" (Cambridge University Press, 2010): definitive reference. EN 50128 SIL 4 (railway): refinement proofs = certification evidence. IEC 61508 SIL 3/4. EU AI Act Art. 9: machine-checked invariants = formal AI safety evidence. NIS2: critical infrastructure operators → formally verified control software. GDPR Art. 25: invariants encode data access policies as proved properties. EU CRA: proof obligations eliminate unsafe state classes by construction. |
| Z Notation | ProZ / ProB (Düsseldorf 🇩🇪), Fuzz type-checker, CZT | Deploy Z Notation to Europe → | Mathematical specification language at the root of European formal methods — Jean-Raymond Abrial 🇫🇷 (Oxford PRG 🇬🇧, 1977). Set-theoretic state + schema calculus + first-order predicate logic: schemas declare variables with type constraints (invariants), operations define preconditions and postconditions. Named after Ernst Zermelo 🇩🇪 (ZF set theory). ISO/IEC 13568:2002. Oxford PRG team: Bernard Sufrin 🇬🇧, Mike Spivey 🇬🇧 ("The Z Notation: A Reference Manual", 1989), Roger Duke 🇦🇺, Ian Hayes 🇦🇺. The formal ancestor that inspired B-Method (Abrial 1989) and Event-B (ETH Zurich 2000s) — completing the EU formal methods lineage VDM-SL → Z → B → Event-B. Industrial applications: IBM CICS 🇬🇧 (one of the earliest large-scale formal specs), British Telecom 🇬🇧 ADSL protocol, Inmos Transputer 🇬🇧, Praxis Tokeneer 🇬🇧 (NSA smart card, Common Criteria EAL5, SPARK Ada). ProZ (Michael Leuschel 🇩🇪, University of Düsseldorf): Z animation + model checking within ProB — open source, MIT license. CZT (Community Z Tools): Eclipse/VSCode plugin. IEC 61508 SIL 3/4: formal specification recommended at SIL 3, required at SIL 4. EN 50128 SIL 4 (railway): Z specs as certification evidence. EU AI Act Art. 9: Z invariants as formal safety documentation for high-risk AI. GDPR Art. 25: data minimisation expressible as machine-checked Z predicates. |
| CCS | mCRL2 (TU Eindhoven 🇳🇱), CADP (INRIA Grenoble 🇫🇷), CWB (Edinburgh 🇬🇧) | Deploy CCS to Europe → | Calculus of Communicating Systems — Robin Milner 🇬🇧 (University of Edinburgh / Cambridge, 1980, ACM Turing Award 1991). Process algebra: processes communicate via channel synchronisation; complementary actions a and ā produce silent τ transition. Invented bisimulation (Park-Milner bisimulation): strongest behavioural equivalence — finer than trace equivalence, captures branching nondeterminism. π-calculus (1992): Milner + Parrow (Uppsala 🇸🇪) + Walker (Edinburgh 🇬🇧) — channel names as first-class values enabling mobile processes. Same Milner invented: ML language (1973), Hindley-Milner type inference (polymorphic let), LCF proof assistant. ACP (Jan Bergstra 🇳🇱 + Jan Willem Klop 🇳🇱, CWI Amsterdam 🇳🇱, 1982): axiom-based parallel (CWI = birthplace of Python). mCRL2 (TU Eindhoven 🇳🇱): CCS/ACP successor with data + time + μ-calculus model checking. CADP (Hubert Garavel 🇫🇷, INRIA Grenoble 🇫🇷): supports LOTOS/LNT/CCS, bisimulation minimisation, generates C, used in Airbus avionics. CWB (Colin Stirling 🇬🇧, Edinburgh LFCS): original CCS model checker. LOTOS (ISO 8807): EU telecom standard based on CCS. Session types (Honda 🇯🇵 + Yoshida, Imperial College 🇬🇧 + Vasconcelos 🇵🇹, EU Marie Curie): π-calculus typed channels → Rust channel types. IEC 61508 SIL 3/4: mCRL2/CADP verify concurrent behaviour for ASML 🇳🇱, NXP 🇳🇱, ProRail 🇳🇱. EN 50128 SIL 4 railway: CCS-descended verification in EU rail (SNCF 🇫🇷, DB 🇩🇪, RFI 🇮🇹). EU AI Act Art. 9: bisimulation proofs for deadlock-freedom in concurrent AI components. NIS2: CADP-verified protocol stacks for critical infrastructure. |
| CSP | FDR4 (Oxford 🇬🇧), ProB (Düsseldorf 🇩🇪), LTSA (Imperial College 🇬🇧), mCRL2 (TU Eindhoven 🇳🇱) | Deploy CSP to Europe → | Communicating Sequential Processes — Sir Tony Hoare 🇬🇧 (Oxford PRG, 1978, ACM Turing Award 1980). Process algebra: parallel processes communicate by synchronising on named events — no shared memory, no race conditions. Primitives: prefix (a → P), external choice (P □ Q), internal choice (P ⊓ Q), parallel composition (P ‖ Q), hiding (P \ A). Traces + Failures + Divergences model: complete account of deadlock, livelock, and safety. From the same Oxford PRG as Z Notation — Hoare 🇬🇧 and Abrial 🇫🇷 in the same laboratory. Bill Roscoe 🇬🇧 (Oxford): FDR4 model checker — proved Needham-Schroeder authentication protocol attack (1995), open source (BSD). Occam: David May 🇬🇧 (INMOS Bristol) — CSP as a hardware language for the Transputer parallel processor. LOTOS (ISO 8807): EU standard for OSI telecommunications protocol specification, directly based on CSP/CCS. ACP (Jan Bergstra 🇳🇱, CWI Amsterdam): European algebraic parallel, birthplace also of Python. mCRL2 (TU Eindhoven 🇳🇱): modern successor, μ-calculus model checking. LTSA (Imperial College London 🇬🇧): FSP language, Jeff Magee + Jeff Kramer. Go channels: CSP direct descendants (Rob Pike cites Hoare). Erlang actors: independent CSP convergence (Ericsson 🇸🇪, nine-nines reliability). IEC 61508 SIL 3/4: concurrent behaviour formally verified under all interleavings. EN 50128 SIL 4 (railway): CSP safety cases for UK/EU interlocking systems. EU AI Act Art. 9: FDR4 proof of deadlock-freedom = formal concurrency safety evidence for high-risk AI. NIS2: CSP-verified protocols (Needham-Schroeder attack methodology) for critical infrastructure security. |
| Promela/SPIN | SPIN model checker, pan verifier (C), iSpin GUI | Deploy Promela/SPIN to Europe → | Explicit-state model checker for concurrent systems — Gerard Holzmann 🇳🇱 (Bell Labs Murray Hill NJ, 1980; NASA JPL 2003). Promela: Process Meta Language — proctype (concurrent processes), chan (synchronous/buffered channels), atomic/d_step blocks, assert (safety), ltl formulas (LTL properties), never claims (Büchi automata). SPIN verification: pan = generated C verifier compiled with host gcc; nested DFS for acceptance cycles; partial order reduction (POR) prunes equivalent interleavings; bitstate hashing (Holzmann's memory-efficiency innovation) enables 10^8-state spaces in megabytes. ACM Software System Award 2001 — prior winners: Unix, TeX, DNS, WWW. Industrial record: Lucent 5ESS telephone switch (concurrent C race conditions), Boeing TCAS II collision avoidance (unsafe command pair absence), Bluetooth pairing protocol (man-in-the-middle absence), IEEE 802.11 DCF backoff (draft standard bugs), NASA MSL Curiosity Rover (autonomous command execution), NASA Mars 2020 Perseverance (sample caching fault response), Airbus AFDX timing (A380 avionics network). Book: "The SPIN Model Checker: Primer and Reference Manual" (Addison-Wesley 2004). "Power of Ten" safety coding rules (IEEE Software 2006) — embedded in MISRA C, IEC 61508 coding guidelines, CERT C. EU ecosystem: TU Delft 🇳🇱 (Holzmann's alma mater, POR theory + Java PathFinder co-development); Eindhoven 🇳🇱 (mCRL2↔Promela interop); Aalborg 🇩🇰 (UPPAAL+SPIN curriculum); Stuttgart 🇩🇪 (AUTOSAR verification, Bosch/ZF/Continental); Politecnico di Milano 🇮🇹 (AFDX, EU CESAR FP7); KTH Stockholm 🇸🇪 (IoT security, Horizon 2020). Industrial EU users: Airbus 🇫🇷, Siemens Mobility 🇩🇪, Thales Rail 🇫🇷, Ericsson 🇸🇪, Nokia Bell Labs 🇫🇮, NXP 🇳🇱, Alstom 🇫🇷. IEC 61508 SIL 3/4: LTL model checking satisfies formal verification requirement for concurrent protocol software. EN 50128 SIL 4: Promela models of interlocking logic in EU rail signalling. EU AI Act Art. 9: SPIN-verified AI decision state machines = machine-checked concurrency safety evidence. NIS2: verified protocol stacks for critical infrastructure. DO-178C DO-333: formal methods credit for avionics software (Airbus, Thales Avionics, Diehl). BSD licensed, Ubuntu package. |
| Alloy | Alloy Analyzer (SAT/Kodkod), Alloy4Fun (INESC TEC Porto 🇵🇹), Electrum (Minho+Porto 🇵🇹) | Deploy Alloy to Europe → | SAT-based relational model finder — Daniel Jackson 🇺🇸 (MIT CSAIL, 2002). Relational first-order logic with transitive closure: sig (types), fields (relations), facts (invariants), pred (named constraints), assert (properties to check), run/check commands. Small scope hypothesis: most design bugs appear in small instances — check counterexamples in seconds via SAT solving. Kodkod backend (Emina Torlak 🇺🇸, MIT/UW): boolean matrix encoding of relations + symmetry breaking + incremental SAT. SAT4J default solver, external: MiniSat, Glucose, CryptoMiniSat. Alloy 6 (2022): temporal operators (var, always, eventually, after, until) — merging Electrum research from Portugal. Electrum (Alcino Cunha 🇵🇹, Universidade do Minho + Nuno Macedo 🇵🇹, INESC TEC Porto): temporal Alloy extension, now Alloy 6 core. Alloy4Fun (Nuno Macedo group, INESC TEC Porto 🇵🇹): web Alloy exercises — used by EU universities for formal methods education. "Software Abstractions" (Daniel Jackson, MIT Press, 2006/2012): primary reference, graduate textbook across EU. Industrial applications: Amazon AWS Zelkova (IAM access control policy reasoning, privilege escalation detection — relational technique descends from Alloy); ext3 file system crash consistency (Alloy found incorrect invariant in published ext3 paper); Chord P2P routing (5-node counterexample); electronic health records (GDPR Art. 9 access control, Mondrian model). EU research: TU Eindhoven 🇳🇱 (mCRL2 complement), KTH Stockholm 🇸🇪 (distributed specs), TU Wien 🇦🇹 (B-Method composition), INRIA Grenoble 🇫🇷 (CADP composition), Politecnico di Milano 🇮🇹 (UML consistency). nuXmv (FBK Trento 🇮🇹): Electrum unbounded model checking backend. EU AI Act Art. 9: Alloy invariant checking = structural safety evidence for high-risk AI data models. GDPR Art. 25: data minimisation + access control models as machine-checked predicates. NIS2: Alloy-verified network topology + trust boundary models. DORA: dependency graph structural correctness. IEC 61508: relational specification of safety-critical data flows. MIT License. |
| UPPAAL | UPPAAL MC/SMC/Stratego/Tiga (Uppsala 🇸🇪 + Aalborg 🇩🇰), verifyta CLI, Docker | Deploy UPPAAL to Europe → | Timed automata model checker — Kim Guldstrand Larsen 🇩🇰 (Aalborg University) + Wang Yi 🇸🇪 (Uppsala University), 1995. UPPAAL = UPpsala + AALborg. Networks of timed automata: finite state machines + real-valued clocks, guards (clock lower bounds on transitions), invariants (clock upper bounds on locations). Symbolic verification via Difference Bound Matrices (DBMs): infinite clock state space compacted to finite symbolic representation. CTL subset queries: A[] invariant (safety), E<> reachability, A<> liveness (progress), p --> q leads-to (response). Tool suite: UPPAAL MC (symbolic model checker), UPPAAL SMC (statistical model checking — Monte Carlo simulation + hypothesis testing for probabilistic/stochastic systems), UPPAAL Stratego (optimal strategy synthesis for timed games, energy management, autonomous systems), UPPAAL Tiga (two-player timed reachability games), UPPAAL CORA (cost-optimal reachability in priced timed automata), UPPAAL Yggdrasil (model-based test generation). EU FP7 grants 318490 (SENSATION), 601148 (CASSTING), EU ARTEMIS 269335 (MBAT). BRICS EU project: Aarhus+Aalborg 🇩🇰+Edinburgh 🇬🇧+Pisa 🇮🇹+Warsaw 🇵🇱. Industrial applications: Volvo 🇸🇪 (ISO 26262 turn indicator timing, brake-by-wire deadlines, AUTOSAR component timing), Airbus 🇫🇷 (AFDX avionics network timing), Siemens 🇩🇪 (safety-critical embedded schedulers), medical devices IEC 62304 (infusion pump dosing intervals, insulin delivery protocols, robotic surgery), EU ERTMS railway EN 50128 SIL 4 (interlocking timing verification, collision avoidance). European publication leadership: DK 30/year, SE 13, IT 21, FR 19, DE 12, BE 10 — vs US 11. ITAR-adjacent: EU data residency mandatory for aerospace/defence system model IP. ISO 26262 (automotive FuSa) + IEC 61508 SIL 3/4 (industrial safety) + IEC 62304 (medical software) + EN 50128 SIL 4 (railway) + DO-178C DO-333 (avionics). EU AI Act Art. 9: UPPAAL-verified timing constraints for autonomous vehicle/medical AI = machine-checked real-time safety evidence. NIS2: timed protocol verification for critical infrastructure. GDPR Art. 25: timing-constrained data access windows verified as timed automata properties. Free academic, commercial licence via Aalborg. |
| Dafny | Dafny CLI, Boogie + Z3 backend, VSCode Language Server | Deploy Dafny to Europe → | Verification-aware programming language — K. Rustan M. Leino 🇺🇸 (Microsoft Research Redmond, 2009; now Amazon Web Services). Specification and implementation coexist: requires/ensures (pre/postconditions), invariants, decreases (termination), ghost variables, lemmas. Compiler refuses to generate code until all verification conditions discharged by Z3 SMT solver via Boogie intermediate language. Proves: memory safety (no null deref, no array OOB), functional correctness (postcondition holds for all inputs), termination (decreases clauses), information flow (ghost annotations). Multi-target: compiles to C#, Go, Python, Java, JavaScript — verified spec = production artefact. Boogie (Leino + Michał Moskal 🇵🇱 + Peter Müller 🇩🇪 ETH Zürich 🇨🇭): intermediate verification language shared with SPARK Ada's GNATprove backend. Industrial use: Amazon S3 Encryption SDK (proved correct for all input sequences), AWS Cedar policy language (Verified Permissions formal spec + Rust impl validation), AWS Firecracker microVM isolation properties, MSR IronClad/IronFleet distributed systems (formally verified OS + services). EU ecosystem: ETH Zürich Viper project (Peter Müller 🇩🇪) — parallel intermediate verification infra; TU Delft 🇳🇱 VerCors (van Eekelen); POPL 2026 workshop on Dafny included EU researchers (INRIA 🇫🇷, TU Delft 🇳🇱, Edinburgh 🇬🇧). DafnyPro: commercial AWS offering for enterprise verification. EU AI Act Art. 9: Dafny requires/ensures = machine-readable + machine-checked specification — direct evidence for high-risk AI technical documentation. GDPR Art. 25: data minimisation as verified Dafny postconditions. NIS2: Dafny-verified protocol handlers for critical infrastructure. MIT License. |
| CADP | CAESAR/LNT compiler, BCG tools, EVALUATOR (μ-calculus), BISIMULATOR, SVL scripts | Deploy CADP to Europe → | EU-native distributed systems verification toolbox — Hubert Garavel 🇫🇷 + INRIA Grenoble 🇫🇷 (CONVECS team, since 1989). INRIA = French public national research institution (Ministry of Higher Education + Ministry of Economy). Input: LOTOS (ISO 8807 standard for OSI protocol specification) + LNT (LOTOS New Technology, modern process algebra). Intermediate representation: BCG (Binary Coded Graphs) — binary labeled transition system format, de facto EU standard. Core tools: CAESAR (LOTOS/LNT→BCG compiler), CAESAR.ADT (algebraic data type compiler), EVALUATOR 4 (μ-calculus model checking — on-the-fly BFS, subsumes CTL/LTL/CTL*), BISIMULATOR (strong/branching/weak bisimulation checker), REDUCTOR (LTS minimisation by bisimulation quotient), DISTRIBUTOR (parallel BFS for billion-state models). OPEN/CAESAR API: plugin architecture enabling third-party tools to connect to CADP's exploration engine. SVL (Specification and Verification Language): scripting layer orchestrating the full verification pipeline. Process algebra: parallel composition ‖, synchronisation on named channels, internal action τ, external/internal choice, hiding. Connection to ACM Turing Award: Joseph Sifakis 🇬🇷🇫🇷 (VERIMAG Grenoble, same technology park) co-received 2007 Turing Award with Clarke + Emerson for model checking. Industrial EU users: Airbus 🇫🇷 (A380/A350 AFDX avionics network — DO-178C DAL A), EDF 🇫🇷 (nuclear reactor safety systems, IEC 61508 SIL4 equivalent), Thales 🇫🇷 (avionics + railway EN 50128 SIL4, SESAR ATM protocols), RATP 🇫🇷 (Paris Metro line automation, LOTOS protocol verification), Orange Labs 🇫🇷 (SDN protocol verification), CEA 🇫🇷 (nuclear + renewable energy I&C). EU research funding: FP7 HATS, FP7 CONNECT, H2020 HEADS, H2020 VERCORS, French ANR. BCG interoperability: mCRL2 (TU Eindhoven 🇳🇱) reads BCG — direct EU cross-tool compatibility. μ-calculus: Kozen 1983, strictly more expressive than CTL ∪ LTL — νX.(P ∧ [true]X) = AG P (invariant), μX.(P ∨ <true>X) = EF P (reachability). EU AI Act Art. 9: CADP distributed system verification proves communication safety for multi-agent AI systems (deadlock-freedom, message delivery, starvation-freedom). NIS2: CADP protocol verification for OT/IT integration (industrial Ethernet, PROFINET, OPC-UA). GDPR Art. 5(1)(f): non-interference properties via LNT hiding + EVALUATOR — prove low-security processes cannot influence high-security data channels. Free academic licence; INRIA = 100% EU public institution, no US Cloud Act, no ITAR. |
| SMV | NuSMV CLI (SMV-compatible), Cadence SMV, Docker | Deploy SMV to Europe → | Original symbolic model verifier — Edmund M. Clarke 🇺🇸 (Carnegie Mellon University, 1993, ACM Turing Award 2007 with Emerson + Sifakis 🇫🇷 VERIMAG Grenoble). Ken McMillan PhD thesis (CMU, 1992): BDD-based symbolic verification of hardware circuits. BDD representation (Randal Bryant CMU 1986): canonical Boolean formula compact encoding — 10^{120}-state IBM ES/9000 cache coherence verified. IEEE Futurebus+ standard bug found (1992): concurrent bus transaction interleaving race condition discovered by model checking that testing missed — led to standard revision. Intel Pentium Pro cache coherence protocol + AMD K5/K6 FPU verified at Intel/AMD internal groups. SMV language: MODULE/VAR/ASSIGN init(v)/next(v)/SPEC (CTL: AG/EF/AF/EG)/LTLSPEC (LTL)/INVARSPEC — same language used by NuSMV and nuXmv today. CTL model checking algorithm: Clarke-Emerson 1981 (LNCS "Synthesis of Synchronization Skeletons") — fixpoint computation polynomial in state space. Turing Award lineage: Clarke (CMU Pittsburgh) + Emerson (UT Austin) + Sifakis (VERIMAG Grenoble 🇫🇷) = model checking invented simultaneously in US + EU. EU successor: NuSMV (FBK Trento 🇮🇹, 2002) reimplemented SMV with industrial-grade engineering + BMC; nuXmv (FBK Trento, 2014) adds IC3/PDR + MathSAT5 — both 100% EU-origin, LGPL. EU industrial users: Siemens DE (IEC 61508 SIL4 PLC verification), STMicroelectronics IT (ISO 26262 ARM Cortex-M), Infineon DE (automotive ASIL D), Bosch DE (AUTOSAR), NXP NL (i.MX automotive SoC). EU AI Act Art. 9: SMV CTL exhaustive state verification = mathematical proof of AI component behavioural correctness. IEC 61508 SIL 3/4, EN 50128 SIL 4, DO-178C DO-333. Open source (McMillan CMU implementation). |
| Why3 | why3 prove (CLI), why3 ide (GUI), Alt-Ergo 🇫🇷 (OCamlPro Paris), Z3, CVC5, Isabelle, Coq/Rocq | Deploy Why3 to Europe → | EU-native multi-prover deductive verification platform — Jean-Christophe Filliâtre 🇫🇷 + Claude Marché 🇫🇷 (LRI Paris-Sud / INRIA Saclay — Toccata team, 2010). WhyML: functional+imperative verification language with contracts (requires/ensures/invariant/decreases), ghost code, algebraic types. Dispatches proof obligations to Alt-Ergo 🇫🇷 (EU-native SMT, OCamlPro Paris), Z3, CVC5, Eprover (TU Munich 🇩🇪), SPASS (MPI Saarbrücken 🇩🇪), Isabelle/HOL (TU Munich 🇩🇪 + Cambridge 🇬🇧), Coq/Rocq (INRIA 🇫🇷). Proof session: incremental re-verification — only changed obligations re-dispatched. Code extraction: WhyML → OCaml (primary), Python, C, Java (verified → production artefact). Intermediate verification language (IVL) for: Frama-C WP plugin (CEA LIST 🇫🇷 C verification → Why3 → Alt-Ergo), SPARK Ada GNATprove (AdaCore 🇫🇷 Paris → Why3 → Alt-Ergo). Complete EU C verification stack: Frama-C (CEA LIST + INRIA) → Why3 (LRI + INRIA Saclay) → Alt-Ergo (OCamlPro Paris) — 100% French public research, no US dependency. Industrial EU users: Airbus 🇫🇷 (DO-178C DAL A C verification via Frama-C WP→Why3), EDF 🇫🇷 (nuclear IEC 61508 SIL4 via Frama-C WP→Why3), AdaCore 🇫🇷 (GNATprove→Why3 for Airbus A350 avionics + EUROCONTROL SESAR ATM). LRI = CNRS UMR 8623 + Université Paris-Saclay: 100% French public, no US Cloud Act, no ITAR. EU AI Act Art. 9: Why3-discharged proof obligations = machine-checked formal verification evidence for C/Ada AI inference components. LGPL licence; apt package why3. |
| Alt-Ergo | alt-ergo CLI (.ae native + SMT-LIB 2), Why3 driver (auto-configured), opam / apt package | Deploy Alt-Ergo to Europe → | EU-native SMT (Satisfiability Modulo Theories) solver — Sylvain Conchon 🇫🇷 + Evelyne Contejean 🇫🇷 (LRI Paris-Sud / CNRS, 2006), maintained by OCamlPro 🇫🇷 (Paris). Completes the EU formal verification stack: Frama-C (CEA LIST 🇫🇷) → Why3 (INRIA Saclay 🇫🇷) → Alt-Ergo (OCamlPro 🇫🇷) — 100% French institutions, no US Cloud Act, no ITAR. DPLL(T) architecture: SAT propositional backbone + theory solvers combined via Shostak method (canonizer + solver for linear arithmetic) + Nelson-Oppen (non-Shostak theories). Theories: linear arithmetic over integers (ℤ) + rationals (ℚ), uninterpreted functions (congruence closure, E-graph), McCarthy arrays (select/store with extensionality), bitvectors (Alt-Ergo Pro), algebraic data types. Quantifier instantiation: E-matching (pattern-based heuristic — finds ground terms matching quantifier triggers in current context). Input formats: native .ae (Alt-Ergo format, higher-level than SMT-LIB) + SMT-LIB 2 .smt2 (standard interchange format). Default prover for: Why3 (LRI/INRIA Saclay, all proof obligation shapes), Frama-C WP plugin (via Why3 driver, ACSL-derived weakest preconditions), GNATprove / SPARK Ada (AdaCore 🇫🇷 Paris, via Why3 IVL). Performance advantage over Z3/CVC5 for program verification obligation shapes: linear arithmetic + uninterpreted function equalities discharged in <50ms for typical Frama-C WP output. Alt-Ergo Pro (OCamlPro commercial): extended bitvectors + IEEE 754 floating-point + improved E-matching for embedded/automotive obligations. Industrial EU users: Airbus 🇫🇷 (DO-178C DAL A — A350/A380 avionics C code via Frama-C WP→Why3→Alt-Ergo; ITAR data residency met), EDF 🇫🇷 (IEC 61508 SIL4 nuclear reactor protection functions — ASN safety case evidence), Thales 🇫🇷 (EN 50128 SIL4 railway interlocking, SESAR ATM), AdaCore 🇫🇷 (entire SPARK Ada customer base: Airbus, EUROCONTROL 🇧🇪, MBDA 🇫🇷🇬🇧🇩🇪, Siemens Mobility 🇩🇪, Rolls-Royce FADEC 🇬🇧). LMF (Laboratoire Méthodes Formelles) = CNRS UMR 9653 + Université Paris-Saclay + ENS Paris-Saclay + CentraleSupélec: 100% French public research. EU AI Act Art. 9: Alt-Ergo-discharged proof obligations = machine-checked formal evidence for high-risk AI system technical documentation (Annex III). GDPR Art. 25: Frama-C assigns \nothing + Alt-Ergo proof = machine-checked data minimisation for C health/ID applets. IEC 61508 SIL4 / EN 50128 SIL4 / DO-178C DO-333: formal verification credit. NIS2: OT control software formally proved against specifications. CeCILL-C open-source licence (French FSF equivalent of LGPL); opam install alt-ergo / apt install alt-ergo. |
| Prusti | cargo prusti (cargo plugin), Viper Silicon/Carbon (ETH Zurich 🇨🇭), #[requires]/#[ensures]/#[invariant]/#[assert_on_expiry] proc_macro, Z3 backend | Deploy Prusti to Europe → | Deductive verifier for safe and unsafe Rust — Peter Müller 🇨🇭 + Alexander Summers 🇨🇭 + Vytautas Astrauskas + Fabian Wolff (ETH Zurich 🇨🇭, 2016). Translates Rust MIR → Viper (Verification Infrastructure for Permission-based Reasoning, ETH Zurich) → Silicon (symbolic execution over permission heaps, Z3) or Carbon (VCGen + Boogie). Permission logic (Implicit Dynamic Frames, IDF): heap reasoning without explicit separation logic — each memory location carries a permission; &mut T = exclusive write permission; &T = fractional read permission. No explicit aliasing proofs required: ownership discipline from Rust borrow checker = permission ownership at runtime. Specification language: #[requires(P)] (precondition), #[ensures(P)] (postcondition, result for return value), #[invariant(P)] (loop invariant), #[assert_on_expiry] (expiry assertion for &mut T), #[pure] (pure functions usable in specs), `forall( |
| Gobra | gobra.jar (Java 11+, Viper Silicon/Z3 backend), //@ requires/ensures/invariant Go comment annotations, acc() permission specs | Deploy Gobra to Europe → | Viper-based formal verifier for Go programs — Felix Wolf 🇩🇪 + Malte Schwerhoff 🇩🇪 + Peter Müller 🇨🇭 (ETH Zurich 🇨🇭, CAV 2021). Translates Go source → Viper (Verification Infrastructure for Permission-based Reasoning, ETH Zurich) → Silicon (symbolic execution, Z3). Permission logic (Implicit Dynamic Frames, IDF): acc(x.field, 1/1) = exclusive write permission, acc(x.field, 1/2) = fractional read permission for concurrent read-sharing. Specification language embedded as Go comments: //@ requires P (precondition), //@ ensures P (postcondition), //@ invariant P (loop invariant), //@ fold///@ unfold (predicate packing/unpacking), forall i int :: { arr[i] } P (quantifiers with triggers). Go concurrency model: channel send/receive annotations transfer permission ownership between goroutines — prevents data races by proof, not runtime detection. Mutex annotation: acc(mu) tracks mutex ownership, permission model encodes critical section access. Goroutine creation: permission splitting on goroutine spawn — parent retains fractional read, goroutine receives exclusive write. Struct predicates: named predicate definitions encapsulate heap permission + invariant — (q *BoundedQueue) Inv() captures all permissions + constraints, fold/unfold makes heap structure explicit. Interface verification: method contracts on interface types, structural subtyping proofs. Viper ecosystem: Gobra (Go, CAV 2021) + Prusti (Rust, PLDI 2019) + Nagini (Python, VMCAI 2018) — all ETH Zurich 🇨🇭, same Silicon/Z3 backend. Engineers learning one Viper spec language understand all three. Cloud-native Go infrastructure: Kubernetes (golang.google.com/pkg) controller verification, Docker daemon security invariants, Prometheus metric pipeline correctness, etcd Raft consensus verification, CoreDNS query routing. ETH Zurich: Swiss federal university (1855), ERA associate, SNSF + EU Horizon funded, no US Cloud Act. VS Code extension: Gobra (viperproject.gobra) — inline verification feedback. EU AI Act Art. 9: Gobra-verified Go AI inference services = machine-checked functional correctness (postconditions + loop invariants + goroutine safety). Cyber Resilience Act (CRA, 2027): Go memory safety + Gobra functional correctness = documented security testing evidence for CRA-in-scope digital products. NIS2: formally verified Kubernetes operators and DNS controllers for essential entity infrastructure. GDPR Art. 25: //@ requires user.ConsentGiven annotations on data access functions = GDPR lawfulness constraints enforced by proof. IEC 62443 (industrial cybersecurity): Go-based industrial control system microservices. Apache 2.0 licence. |
| Nagini | pip install nagini (Python 3.8–3.12, Java 11+ for Viper), Requires()/Ensures()/Invariant()/Acc() from nagini_contracts, Z3 via Viper Silicon | Deploy Nagini to Europe → | Viper-based static verifier for Python 3 programs — Marco Eilers 🇩🇪 + Peter Müller 🇨🇭 (ETH Zurich 🇨🇭, VMCAI 2018). Translates Python 3 AST → Viper (Verification Infrastructure for Permission-based Reasoning, ETH Zurich) → Silicon (symbolic execution, Z3). Permission logic (Implicit Dynamic Frames, IDF): Acc(self.field, 1/1) = exclusive write permission, Acc(self.field, 1/2) = fractional read permission for concurrent read-sharing. Specification language as Python function calls: Requires(P) (precondition), Ensures(P) (postcondition, Result() for return value), Invariant(P) (loop invariant), Acc(obj.field, p) (heap access permission), Old(expr) (pre-state value), Forall(T, lambda x: P) / Exists(T, lambda x: P) (quantifiers), Implies(A, B) (implication). Predicate definitions via @Predicate decorator — Fold(pred) / Unfold(pred) for predicate packing/unpacking. Thread safety: Thread/Lock annotations track lock ownership as permissions — acquire() transfers protected permissions, release() transfers back. MyPy type annotations required for field access verification: self.value: int = 0 (PEP 526) or # type: int. Viper ecosystem: Nagini (Python, VMCAI 2018) + Gobra (Go, CAV 2021) + Prusti (Rust, PLDI 2019) — all ETH Zurich 🇨🇭, same Silicon/Z3 backend. Nagini predates Gobra and Prusti by publication date — established Viper feasibility for dynamically-typed OOP languages. Python AI/ML: FastAPI inference services, Django web backends, NumPy/Pandas data pipelines, scikit-learn/TensorFlow wrappers, healthcare IT. EU AI Act Art. 9 (high-risk): Nagini-verified Python AI inference components = machine-checked functional correctness for Annex III systems. EU AI Act Art. 10 (data governance): Nagini postconditions on ETL pipelines prove normalization correctness, null-checking exhaustiveness, stratified sampling proportionality. GDPR Art. 25: Ensures(Result() == requested_fields_only) on data access functions = machine-checked data minimisation. Cyber Resilience Act (CRA, 2027): Requires(input_validated) preconditions + Ensures(no_sensitive_data_logged) postconditions = CRA security-by-default documentation evidence. Python 3.12 no-GIL (experimental): Nagini thread safety verification increasingly relevant as production Python moves toward genuine parallelism. ETH Zurich: Swiss federal university (1855), ERA associate, SNSF + EU Horizon funded, no US Cloud Act. MPL 2.0 licence; pip install nagini. |
| Viper | Silicon (symbolic exec, Z3), Carbon (VCGen, Boogie, Z3), Silver IL, Viper IDE (VS Code), viper.ethz.ch | Deploy Viper to Europe → | Permission-based intermediate verification language — Peter Müller 🇨🇭 + Malte Schwerhoff 🇩🇪 + Alexander Summers 🇨🇭 (ETH Zurich 🇨🇭, VMCAI 2016). Silver IL: method (imperative, pre/postconditions), function (pure, usable in specs), predicate (named heap permission + invariant, foldable), domain (uninterpreted types + axioms). Implicit Dynamic Frames (IDF): acc(x.f, p) — heap access permission to field f of ref x with amount p ∈ (0,1]. acc(x.f, 1/1) = exclusive write; acc(x.f, 1/2) = fractional read (shareable). Permission set defines footprint implicitly — no explicit modifies clauses. inhale P adds assertions without proof; exhale P removes with proof obligation. fold pred(x) packs heap into abstract predicate; unfold pred(x) unpacks. old(expr) = pre-state value; label L; old[L](expr) = value at labeled state. Quantifiers: forall x: T :: {trigger} P with SMT triggers. Magic wands: A --* B for partial heap context reasoning (iterator patterns, concurrent data structures). Two backends: Silicon (symbolic execution, path-sensitive, concrete counterexamples) + Carbon (VCGen → Boogie → Z3, quantifier-heavy programs). Front-ends using Viper as verification target: Prusti (Rust, PLDI 2019, ETH Zurich 🇨🇭) + Gobra (Go, CAV 2021, ETH Zurich 🇨🇭) + Nagini (Python, VMCAI 2018, ETH Zurich 🇨🇭) + VeriFast (C/Java, iFM 2008, KU Leuven 🇧🇪) + Voila (concurrent objects, PLDI 2021, ETH Zurich 🇨🇭) + VerCors (Java/C/OpenCL, FM 2017, TU Twente 🇳🇱). A bug fixed in Silicon benefits Rust, Go, and Python verification simultaneously — shared infrastructure, compounding research investment. EU AI Act Art. 9: Viper is the proof engine behind Prusti/Gobra/Nagini Article 9 compliance evidence — auditable, open-source, EU-funded verification infrastructure. CRA 2027: Silver IL output = machine-checkable audit artifact bridging source language specification and Z3 satisfiability results. GDPR Art. 25: Silver permissions (requires acc(x.personalData, 1/2)) structurally enforce field-level data minimisation across all Viper front-ends. ETH Zurich: Swiss federal university (1855), ERA associate, SNSF + EU Horizon funded, no US Cloud Act. MPL 2.0 licence; viper.ethz.ch. |
| VeriFast | verifast CLI (Linux/macOS/Windows), Java 11+ JVM, //@ requires/ensures C/Java comment specs, Z3 SMT backend | Deploy VeriFast to Europe → | Separation logic verifier for C and Java — Bart Jacobs 🇧🇪 + Frank Piessens 🇧🇪 (KU Leuven 🇧🇪, iFM 2008, Toulouse 🇫🇷). Combines separation logic specifications with symbolic execution engine — verifier executes symbolic program state, consuming/producing heap predicates at each step, discharging proof obligations via Z3. Specification as C/Java comments: //@ requires P; ensures Q; (function contracts), /*@ predicate ... @*/ (user-defined heap predicates), //@ open pred(x); close pred(x); (predicate folding/unfolding, analogous to Viper fold/unfold). Built-in heap predicates: integer(p, v) (pointer p holds integer v, exclusive ownership), chars(p, n, cs) (n chars at p form list cs), malloc_block(ptr, n) (allocated block ownership for safe free). Fractional permissions: [1/2]integer(p, v) = read-only half-ownership; two threads each holding [1/2] = safe concurrent reads; writer requires full [1/1]. Separating conjunction P &*& Q: P and Q hold for disjoint heap regions — no aliasing between P and Q footprints. Pattern variables: ?v binds ghost variable at predicate consumption — integer(p, ?v) means "∃v. *p == v at entry." Lemma functions: ghost-only functions containing pure proof steps, machine-checked against own pre/postconditions — enable inductive reasoning over recursive heap structures without axiom gaps. Inductive datatypes: `inductive intlist = nil |
| Chalice | chalice.jar (Java 11+), Boogie + Z3 backend, acc()/rd() permission annotations, --boogie CLI flag | Deploy Chalice to Europe → | Object-oriented research language — K. Rustan M. Leino 🇺🇸 + Peter Müller 🇨🇭 (Microsoft Research Redmond + ETH Zurich 🇨🇭, 2009). Historical significance: first implementation of Implicit Dynamic Frames (IDF) and magic wands (A --* B) — the two permission-reasoning innovations that became the foundation of Viper, Prusti, Gobra, Nagini, and VerCors. acc(x.f) = exclusive write permission (full ownership, non-shareable); rd(x.f) = fractional read permission (shareable among concurrent readers). Predicate instances encapsulate heap regions: predicate List(node) with fold/unfold (same mechanism as Viper Silver). Monitor invariants: class-level invariant clause holds whenever no thread holds the monitor lock — structural lock-coupling concurrency pattern. Channels with permission transfer: between acc(data) and emp on send transfers heap ownership to receiver, preventing data races in message-passing concurrency (same principle as Gobra goroutine channel annotations). Fork/join thread annotations: fork t := method(args) transfers precondition permissions to new thread; join reclaims postcondition permissions. Magic wands: A --* B for partial data structure reasoning — first programming language to implement wands, enabling iterator/cursor verification without full recursive predicate unrolling. Boogie backend: Chalice → Boogie → Z3 verification pipeline proved the IDF permission model computable before Viper productized it. Lineage: Chalice IDF proof-of-concept (Peter Müller, 2009) → Viper Silver IL production infrastructure (Peter Müller + Malte Schwerhoff + Alexander Summers, ETH Zurich, 2016) → Prusti (Rust) + Gobra (Go) + Nagini (Python) front-ends. ETH Zurich 🇨🇭: ERA associate, SNSF funded, no US Cloud Act. EU AI Act Art. 9: IDF permission model underlying Chalice = theoretical foundation for machine-checked concurrent AI system correctness. GDPR Art. 25: monitor invariants encode data minimisation constraints as heap ownership invariants. CRA 2027: race-freedom by permission proof as CRA Article 13 evidence. Apache 2.0 licence; github.com/viperproject/chalice. |
| CompCert | ccomp CLI (OCaml/OPAM), Clight C subset, x86-64/ARM/RISC-V/PowerPC targets, AbsInt 🇩🇪 commercial | Deploy CompCert to Europe → | Only formally verified C compiler with machine-checked semantics-preservation proof — Xavier Leroy 🇫🇷 (INRIA Paris → Collège de France, Chair of Software Safety, 2006). Coq/Rocq proof (~100,000 lines): if Clight source has defined behaviour, compiled binary implements same observable behaviour (volatile reads/writes, external calls, exit value). Eight verified passes: Clight → C#minor → Cminor → RTL → (ConstProp+CSE+Deadcode+Inlining) → LTL → Linear → Mach → x86-64/ARM/RISC-V/PowerPC assembly. Each arrow = Coq proof of semantics preservation. Target: LEON (SPARC-V8 for ESA space + Airbus avionics), x86-64, ARM-v7/v8, RISC-V 32/64, PowerPC. DO-178C Level A: AbsInt Angewandte Informatik 🇩🇪 (Saarbrücken, Saarland University campus) = commercial qualification + aiT WCET analysis integration. Airbus 🇫🇷 (Toulouse): A380/A350 flight control law C code; Thales 🇫🇷: avionics + EN 50128 SIL4 railway; Alstom 🇫🇷: ETCS train protection; Safran 🇫🇷: FADEC engine control; ESA 🇪🇺: LEON-based space software. Semantics gap closed: Frama-C WP plugin proves source correctness → CompCert proves compiled binary identical → no miscompilation hole in verification chain. French verified stack: OCaml (INRIA 🇫🇷) + Coq/Rocq (INRIA 🇫🇷) + Why3 (INRIA Saclay 🇫🇷) + Alt-Ergo (OCamlPro 🇫🇷) + Frama-C (CEA LIST+INRIA 🇫🇷) + CompCert (INRIA 🇫🇷) — 100% EU, no US Cloud Act, no ITAR. JACM 2009: "Formal verification of a realistic compiler" (seminal paper, 4,000+ citations). Collège de France lectures (free, EN/FR): formal methods for software safety, Coq+CompCert. EU AI Act Art. 9: CompCert closes compiler-correctness gap in high-risk AI C inference pipeline — Frama-C proves source, CompCert proves binary = end-to-end machine-checked correctness. IEC 61508 SIL 3/4 + EN 50128 SIL4 + DO-178C Level A + IEC 62304 Class C. CRA 2027: formally proved compilation as CRA Article 13 evidence against miscompilation-induced vulnerabilities. INRIA non-commercial licence (free for research/education); AbsInt commercial licence for DO-178C qualified use. |
| seL4 | seL4 kernel (C, bare metal / QEMU), CAmkES component framework, Python build system (sel4-deps), Isabelle/HOL proof corpus | Deploy seL4 to Europe → | World's first OS kernel with machine-checked proof of correctness — Gerwin Klein 🇩🇪 + June Andronick 🇫🇷 + Kevin Elphinstone (NICTA Australia, SOSP 2009). Isabelle/HOL proof (~500,000 lines): functional correctness (C implementation refines abstract spec), integrity (capability-based isolation — no process can access another's memory without explicit capability), confidentiality (Mutual Noninterference — information flow security). AutoCorres (TU Munich 🇩🇪, Tobias Nipkow group): mechanically verified C-to-Isabelle translation bridging the C semantics gap. Capability-based access control: every kernel object (memory frame, IPC endpoint, thread) accessed only via capability in thread's CSpace — kernel enforces at all system call boundaries. CAmkES component framework (TU Munich 🇩🇪 / NICTA): generates capability wiring from component interface definitions. SOSP 2009 ACM SIGOPS Hall of Fame; ASPLOS 2018 Influential Paper. EU industrial: Hensoldt Cyber GmbH 🇩🇪 (Taufkirchen, Bavaria — TRENTOS secure OS for German Bundeswehr defence electronics, capability-proved isolation between classified/unclassified domains), Airbus Defence & Space 🇩🇪🇫🇷 (aerospace evaluation DO-178C Level A), ESA 🇪🇺 (LEON-based space software evaluation). seL4 Foundation (Linux Foundation, 2020): Proofcraft (Klein + Andronick 🇩🇪🇫🇷), Hensoldt 🇩🇪, RISC-V International. TRENTOS = first formally verified OS in mass-production EU defence electronics — isolation certificate from Isabelle/HOL proof submitted to German BWB. CRA 2027 Art. 13: seL4 isolation proof = highest-assurance evidence for product security architecture separation. NIS2: proved domain separation for OT/IT convergence in critical infrastructure. EU AI Act Art. 9: seL4 isolation prevents compromised non-AI component from accessing AI model weights or sensor inputs. GPL-2 (kernel) + BSD (userland); github.com/seL4/seL4. |
| Boogie | boogie CLI (.NET tool, dotnet tool install boogie), BoogiePL (.bpl source), Z3 SMT backend, SMT-LIB2 output | Deploy Boogie to Europe → | Intermediate verification language and VC generator — K. Rustan M. Leino 🇺🇸 + Mike Barnett + Bart Jacobs 🇧🇪 (Microsoft Research Redmond, FMCO 2005). The shared backend of Dafny, Chalice, and Viper Carbon: frontends generate BoogiePL, Boogie applies weakest precondition (WP) calculus to produce SMT-LIB2 queries, Z3 discharges. BoogiePL constructs: procedure with requires/ensures/modifies (Hoare-style contracts), polymorphic heap <alpha>[Ref, Field alpha]alpha, loop invariant (cut-point method), old(e) (pre-state value), havoc (non-determinism), assume (path constraint), assert (inline check), free requires/free ensures (assumed, not proved). Quantifier {:trigger} annotations guide Z3 instantiation — shared trigger engineering across all Boogie frontends. Modular architecture: each verifier (Dafny, Chalice, Viper Carbon) translates into Boogie IR; Boogie handles loop verification, frame condition checking, and VC generation independently of the source language. EU connection: Viper Carbon (ETH Zurich 🇨🇭, Peter Müller 🇨🇭) uses Boogie as VC generator — Prusti (Rust), Gobra (Go), Nagini (Python) all dispatch via Carbon → Boogie → Z3 when run with --backend Carbon. Bart Jacobs 🇧🇪 (KU Leuven) co-authored original Boogie (FMCO 2005) and went on to create VeriFast — the EU verification cluster's separation logic C/Java tool. Dafny industrial EU deployment: TU Delft 🇳🇱, TU Munich 🇩🇪, EPFL 🇨🇭, Amazon AWS (S3, Glacier, EC2 formally verified via Dafny → Boogie → Z3). "Boogie 2" technical report (2008): Leino's redesign establishing the polymorphic heap + triggers + modifies-clause architecture all modern dependents use. EU AI Act Art. 9: Boogie-discharged proofs from Dafny/Viper Carbon = machine-checked postcondition evidence for high-risk AI systems (all inputs satisfying precondition → postcondition holds). GDPR Art. 25: modifies {} procedure = pure function (frame condition proved) — no personal data written outside specified scope, structurally enforced. CRA 2027: Boogie-verified Dafny/Viper programs as CRA Article 13 formal correctness evidence. IEC 61508 SIL 3/4 + EN 50128 SIL4: WP calculus → SMT discharge chain is an auditable, tool-qualified formal verification pipeline. Apache 2.0 licence; github.com/boogie-org/boogie. |
| VerCors | vct CLI (Linux/macOS, JDK 17+), --silicon/--carbon backends, Java/C/OpenCL annotation specs, PVL (Prototypal Verification Language), Viper Silver IL backend | Deploy VerCors to Europe → | EU-native concurrent program verifier for Java, C, and OpenCL — Marieke Huisman 🇳🇱 + Wytse Oortwijn 🇳🇱 + Pieter Bos 🇳🇱 (University of Twente 🇳🇱, ICFEM 2017). Translates annotated Java/C/OpenCL/PVL to Viper (ETH Zurich 🇨🇭) Silver IL, discharges proof obligations via Silicon (symbolic execution, Z3) or Carbon (VCGen, Boogie, Z3) — the same two Viper backends used by Prusti, Gobra, and Nagini. Specification language in Java/C comment annotations: //@ requires P; ensures Q; (method contracts), //@ loop_invariant P; (loop invariants), context P (requires+ensures combined). Permission model (Viper IDF): Perm(x.f, 1) = full exclusive ownership, Perm(x.f, 1\2) = half fractional read permission, (\forall* int i; range; Perm(arr[i], p)) = iterated separating conjunction over array elements. Resource predicates: resource valid() = Perm(x, 1) ** Perm(y, 1) ** inv; — named permission + invariant bundles, unfold/fold for structural reasoning. Concurrent Java: thread annotations (share/unshare for permission transfer at fork/join), lock invariants (given resource lock_invariant()), acquire/release ghost annotations, atomic block specifications. OpenCL/GPU kernel contracts: \gtid (global thread ID), \ltid (local thread ID), kernel-level context_everywhere invariants, work-group isolation via disjoint Perm(\gtid) — statically excludes data races across entire GPU kernel execution without dynamic race detection. PVL (Prototypal Verification Language): minimal imperative research language with seq<T>, ` |
| Creusot | cargo-creusot (cargo plugin), Pearlite (#[requires]/#[ensures]/#[invariant] proc_macro), Why3 + Alt-Ergo 🇫🇷 backend | Deploy Creusot to Europe → | EU-native deductive verifier for safe Rust — Xavier Denis 🇫🇷 + Claude Marché 🇫🇷 + Jacques-Henri Jourdan 🇫🇷 (INRIA Saclay / Université Paris-Saclay, ATVA 2022). Translates Rust MIR (Mid-level IR, post-borrow-check) to WhyML (Why3 verification language), dispatches to Alt-Ergo 🇫🇷 (EU-native SMT, OCamlPro Paris) + Z3 + CVC5. Key insight: Rust ownership = no mutable aliasing = heap cells behave as pure functional values → proof obligations structurally simpler than C/Java verification. Pearlite specification language embedded in Rust via proc_macro: #[requires(P)] (precondition), #[ensures(P)] (postcondition, result for return value), #[invariant(P)] (loop invariant), #[logic] / #[predicate] (specification-only functions), #[trusted] (external code). Prophecy variables for &mut T: ^x is the final value of mutable reference x when loan expires — models what callee will do to borrowed data without separation logic overhead. ShallowModel trait: logical model of concrete types (Vec<T> as Seq<T>, Option<T>, Result<T,E>, iterators) — Pearlite contracts expressed over mathematical models, not heap addresses. EU formal verification stack extension: Creusot (INRIA Saclay 🇫🇷) → Why3 (INRIA Saclay 🇫🇷, same team, Claude Marché) → Alt-Ergo (OCamlPro 🇫🇷) — 100% French, no US Cloud Act, no ITAR. Covers Rust alongside: Frama-C (C) + SPARK Ada (Ada) — same Why3/Alt-Ergo backend. Prusti (ETH Zurich 🇨🇭): Swiss alternative using Viper/Z3, less Why3 integration. Verus (CMU 🇺🇸): Z3-based, US-origin. Ferrocene 🇩🇪 (Ferrous Systems Berlin): qualified Rust compiler (ISO 26262 ASIL D + DO-178C + IEC 62443) — Creusot + Ferrocene = formally verified + qualified-compiler Rust for EU automotive/avionics. EU AI Act Art. 9: Creusot-verified Rust AI inference components (ONNX-rs, candle, burn) = machine-checked functional correctness for Annex III systems. GDPR Art. 25: #[ensures] frame constraints on mutable references = machine-checked data minimisation for Rust health/finance services. Cyber Resilience Act (CRA, 2027): Rust memory safety + Creusot functional correctness = dual-layer CRA compliance evidence. IEC 62443 OT security: verified Rust control system components. MIT licence; cargo install cargo-creusot. |
| KeY | key.jar (Java 11+), JML annotations (structured comments), Z3/CVC5 SMT backends, KeY IDE | Deploy KeY to Europe → | EU-native Java formal verifier — Reiner Hähnle 🇩🇪🇸🇪 (Chalmers University 🇸🇪 + TU Darmstadt 🇩🇪), Bernhard Beckert 🇩🇪 (KIT Karlsruhe), Peter H. Schmitt 🇩🇪 (Uni Karlsruhe, 2001). Java Dynamic Logic (JavaDL): extends first-order logic with program modalities — box [prog]φ (partial correctness: if prog terminates, φ holds) + diamond <prog>φ (total correctness: prog terminates and φ holds). Programs appear as first-class syntactic objects inside logical formulas. JML (Java Modeling Language) specification language: requires (precondition), ensures (postcondition), signals (exception postcondition), assignable (frame condition), \old(expr) (pre-state value), \result (return value), normal_behavior / exceptional_behavior. Sequent calculus: symbolic execution rules for every Java statement — if-branching creates proof tree branches, loops require loop invariants, method calls use JML contracts as call/return rules. SMT backends: Z3 + CVC5 + Simplify for arithmetic/first-order leaves; KeY IDE for interactive proof construction. JavaCard formal verification: EU payment infrastructure — JavaCard applets on ISO 7816 microcontrollers (16–32 KB RAM, ROM mask = no patch after manufacture). Industrial EU users: Infineon Technologies 🇩🇪 (Munich, dominant EU smart card chip: SLM/SLE series for bank cards + ID + health cards), Giesecke+Devrient (G+D) 🇩🇪 (Munich, StarSign/Convego OS, 4B+ cards/year), Idemia 🇫🇷 (Courbevoie, EU smart card leader, bank cards + passports + SIM), NXP Semiconductors 🇳🇱 (Eindhoven, MIFARE/SmartMX, German national ID P60 EAL 6+), Bundesdruckerei 🇩🇪 (Berlin, German Gesundheitskarte eGK + Personalausweis JavaCard applets). Common Criteria: EAL 4+ (bank/SIM cards) + EAL 5+ (EU passports, ID cards, health cards — requires Formal Security Policy Model + formal correspondence to implementation) + EAL 6+ (crypto hardware). CC formal verification evidence = machine-checked proof that implementation satisfies security policy model. EU payment protocols: EMV (Mastercard/Visa payment applets), German Girocard (EC-Karte), eRezept (electronic prescription), UICC (SIM/eSIM per ETSI TS 102 221). KeY Book (2016): Springer LNCS 10001, Hähnle + Schmitt (eds.) — definitive reference on deductive Java verification. EU AI Act Art. 9: KeY JML postconditions for Java AI inference methods = machine-checked functional correctness evidence (classifier output bounds, heap frame conditions, exception safety). NIS2: JavaCard formal verification for national identity and healthcare infrastructure. GDPR Art. 25: assignable frame conditions + ensures postconditions prove minimal data access in Java health/ID applets. GPL licence. Chalmers 🇸🇪 + KIT 🇩🇪 + TU Darmstadt 🇩🇪 = 100% EU public universities, no US Cloud Act, no ITAR. |
| Frama-C | WP plugin (Why3 + Alt-Ergo 🇫🇷), Eva plugin (abstract interp), ACSL annotations | Deploy Frama-C to Europe → | EU-native C code formal verification platform — CEA LIST 🇫🇷 (Commissariat à l'Énergie Atomique, Paris-Saclay) + INRIA 🇫🇷 (2008). Plugin architecture operating on shared ACSL-annotated C AST. WP plugin: deductive verification via Weakest Preconditions + Hoare logic — function contracts (requires/ensures/assigns), loop invariants, ghost variables → proof obligations → Why3 (Jean-Christophe Filliâtre 🇫🇷, INRIA Saclay) → Alt-Ergo 🇫🇷 SMT solver (OCamlPro Paris, EU-native) + Z3 + CVC5 + Isabelle. Eva plugin: abstract interpretation — computes all possible values at every program point over all inputs, detects runtime errors (integer overflow, null deref, out-of-bounds, uninitialized reads) without user contracts. Complete EU-origin deductive stack: Frama-C (CEA LIST 🇫🇷) → ACSL (INRIA+CEA 🇫🇷) → Why3 (INRIA Saclay 🇫🇷) → Alt-Ergo (OCamlPro 🇫🇷). Industrial EU users: Airbus 🇫🇷 (DO-178C DAL A flight control law C code — A350/A380 avionics, formal correctness certificates for aerodynamic model computations), EDF 🇫🇷 (nuclear reactor I&C, IEC 61508 SIL4 — ASN safety case documentation, runtime error freedom proofs for reactor protection functions), Thales 🇫🇷 (EN 50128 SIL4 railway interlocking C code + SESAR ATM protocols). CEA LIST is a French public institution — no US Cloud Act, no ITAR. MISRA C: Eva detects MISRA C rule violations. DO-178C DO-333: WP + Eva provide formal verification credit for avionics (Airbus, Thales Avionics, Diehl). IEC 61508 SIL 3/4: ACSL contracts satisfy "rigorously defined language with formal semantics" requirement. EN 50128 SIL4: interlocking safety logic formally proved. EU AI Act Art. 9: WP-proved ACSL contracts on AI C inference code = machine-checked functional correctness for Annex III systems. NIS2: Eva-verified C drivers for critical infrastructure OT systems. LGPL licence; Ubuntu package frama-c. |
| NuSMV | NuSMV CLI, nuXmv (IC3/PDR + MathSAT5), Docker | Deploy NuSMV to Europe → | EU-native symbolic model checker — Alessandro Cimatti 🇮🇹 + FBK Trento 🇮🇹 (Fondazione Bruno Kessler, 2002). Re-implementation of Edmund M. Clarke 🇺🇸 CMU SMV (ACM Turing Award 2007, with Emerson + Sifakis 🇬🇷🇫🇷 VERIMAG Grenoble). Input language: SMV — MODULE, VAR, ASSIGN (init/next), SPEC (CTL: AG/EF/AF/EG), LTLSPEC (LTL: G/F/X/U), INVARSPEC (invariant). Two verification engines: BDD-based symbolic model checking (Bryant 1986, CUDD library, finite state) + SAT-based BMC (Bounded Model Checking, zChaff → MathSAT5). nuXmv (2014, FBK Trento): IC3/PDR algorithm (Aaron Bradley 2011, property-directed reachability) + infinite-state via MathSAT5 (SMT over LIA/LRA/bit-vectors/arrays — also FBK Trento). Complete EU vertical: model checker + SMT solver from same institution. Industrial EU users: Siemens AG 🇩🇪 (PLC verification, IEC 61508 SIL4), STMicroelectronics 🇮🇹 (ARM Cortex-M chips, ISO 26262), Bosch 🇩🇪 (AUTOSAR ASIL D), Alstom 🇫🇷 (EN 50128 SIL4 interlocking), Leonardo SpA 🇮🇹 (DO-178C/DO-333 avionics), ESA Estec 🇳🇱 (spacecraft FDIR). EU research funding: FP6 PROSYD, FP7 CRYSTAL, Horizon 2020 EMPHYSIS. Simulink import (nuXmv): direct model import from Matlab/Simulink for automotive/aerospace workflows. EU AI Act Art. 9: NuSMV CTL/LTL = exhaustive state-space proof for AI decision logic — highest assurance for Annex III high-risk systems. NIS2: SCADA/PLC invariant verification for critical infrastructure operators. GDPR Art. 25: nuXmv infinite-state proves data lifecycle invariants over unbounded integers. LGPL (NuSMV) / free academic (nuXmv). 100% EU provenance: FBK Trento = Italian public research institution funded by Trentino regional government — no US Cloud Act, no ITAR. |
| TLA+ | TLC model checker, TLAPS (INRIA Nancy 🇫🇷), PlusCal translator | Deploy TLA+ to Europe → | Temporal Logic of Actions — Leslie Lamport 🇺🇸 (DEC Systems Research Center Palo Alto, 1994, ACM Turing Award 2013). State-machine specification with ZF set theory: states are variable assignments, actions are predicates over current+next state (primed variables), safety via invariants □P, liveness via fairness WF/SF + leads-to ~>. TLC model checker (1999): Yuan Yu + Lamport + Stephan Merz 🇩🇪 (INRIA Nancy 🇫🇷) — exhaustive state-space exploration for finite-state abstractions. TLAPS (TLA+ Proof System): INRIA Nancy 🇫🇷 + INRIA Saclay 🇫🇷 + LORIA Nancy 🇫🇷 — machine-checked deductive proofs for infinite-state systems, backed by Zenon (INRIA 🇫🇷), Isabelle (TU Munich 🇩🇪 + Cambridge 🇬🇧), Z3, CVC5. PlusCal (2009): C/Pascal-like algorithm language that compiles to TLA+, used by Amazon engineers. Lamport's body of work: Lamport clocks (1978, logical time in distributed systems), Bakery algorithm (1974, mutual exclusion), Byzantine Generals (1982, with Shostak + Pease, SRI), Paxos consensus (1989/1998, used in Google Chubby/Spanner + Apache ZooKeeper), LaTeX (1984). AWS deployment: 14 protocols verified (S3, DynamoDB, EBS) — 19 bugs found that testing missed, including leader election race causing data loss (Chris Newcombe et al., CACM 2014). Microsoft Azure Cosmos DB: Paxos verified in TLA+. TigerBeetle financial transactions: TLA+ core invariants. Airbus avionics: distributed algorithm verification. EU contribution: TLAPS entirely INRIA (Stephan Merz 🇩🇪/🇫🇷, Kaustuv Chaudhuri, Damien Doligez 🇫🇷) — EU-funded, BSD licence. IEC 61508 SIL 3/4: distributed safety controller protocols — TLC verifies all interleavings. EU AI Act Art. 9: TLA+ specs of distributed AI serving/inference protocols = machine-checked safety evidence. NIS2: TLC-verified network protocol state machines for critical infrastructure. GDPR Art. 25: data-flow invariants as TLA+ properties. |
| Lean 4 | Lake build system, IO server | Deploy Lean 4 to Europe → | Proof assistant + functional language, Leonardo de Moura (MSR), Mathlib 200k+ theorems, EU AI Act verification |
| Rocq | Dream HTTP (extracted OCaml), CompCert | Deploy Rocq to Europe → | Proof assistant + code extraction, Thierry Coquand 🇫🇷 (INRIA Rocquencourt, Calculus of Constructions), Christine Paulin-Mohring 🇫🇷 (INRIA, inductive types), Gérard Huet 🇫🇷 (INRIA director), Four Color Theorem proof, CompCert certified C compiler for Airbus/avionics, formally proved GDPR/EU AI Act compliance |
| Dyalog APL | Dyalog HTTP server, GNU APL | Deploy Dyalog APL to Europe → | Array programming language, Kenneth Iverson 🇨🇦 (Turing Award 1979), Morten Kromberg 🇩🇰 (Danish CTO, Dyalog Ltd) + Gitte Christensen 🇩🇰 (Danish CEO), rank-polymorphic arrays, MiFID II VaR/CVaR in one expression, GDPR data masking via array operations, Nordic quant finance + EU insurance actuarial systems, Stibo Systems 🇩🇰 |
| Isabelle | isabelle server, extracted Haskell/ML | Deploy Isabelle to Europe → | Generic theorem prover / proof assistant, Lawrence Paulson 🇬🇧 (University of Cambridge, 1988) + Tobias Nipkow 🇩🇪 (TU Munich, Isabelle/HOL) + Markus Wenzel 🇩🇪 (Isar proof language), seL4 formally verified OS kernel (world's first), Archive of Formal Proofs 700+ theories, EU AI Act Art. 9/15 formal safety proofs, GDPR proven privacy, DO-178C avionics certification |
| HOL4 | HOL4 (Poly/ML SML), CakeML verified ML compiler, ARM ISA formal model (Anthony Fox 🇬🇧) | Deploy HOL4 to Europe → | Higher-order logic theorem prover — Mike Gordon 🇬🇧 (Cambridge Computer Lab, 1988), descended from LCF (Robin Milner, Edinburgh 1979). The LCF approach: proof objects are SML abstract type thm, cannot be forged — only the kernel inference rules create theorems. SML (Standard ML) was invented to write LCF tactics; HOL4 is still written in SML/Poly/ML. HOL family tree: LCF(Edinburgh 1979)→HOL88(Cambridge 1988)→HOL4(2000) ‖ HOL Light(John Harrison 🇬🇧, Cambridge→Intel) ‖ Isabelle/HOL(Paulson+Nipkow). Key applications: ARM ISA formal specification (Anthony Fox 🇬🇧, Cambridge) — the architecture of 230 billion EU devices (smartphones, automotive ECUs, Airbus avionics, Siemens industrial); CakeML verified ML compiler (Magnus Myreen 🇸🇪, Chalmers University Gothenburg 🇸🇪) — proved correct from SML source semantics to x86/ARM machine code in HOL4, including verified GC and bootstrap proof; HOL Light (John Harrison 🇬🇧, Intel) — formally proved IEEE 754 floating-point correctness for x87/SSE transcendental functions. CakeML uniqueness: only compiled language with end-to-end proof from source to binary; bootstrap theorem = no trusted binary blob in the verification chain. Magnus Myreen 🇸🇪 at Chalmers (Gothenburg, Sweden 🇸🇪, ERA associate, SNSF/VR funded): decompilation-into-logic technique — lifts ARM/x86 binary semantics into HOL4 theorems, enabling formal verification of compiled binaries without source code. EU academic cluster: Chalmers 🇸🇪 (Myreen group, CakeML), Cambridge 🇬🇧 (Gordon lineage, ARM model), Edinburgh 🏴 (LCF origin, HOL4 theory library), TU Munich 🇩🇪 (Isabelle/HOL interaction). Industrial EU: NXP Semiconductors 🇳🇱 (Eindhoven, HOL4-style tactic proofs for ARM Cortex-M i.MX RT, ISO 26262 ASIL D), Airbus Defence 🇩🇪🇫🇷 (ARM binary verification for DO-178C Level A). Mike Gordon ACM Software System Award 2016. EU AI Act Art. 9: HOL4 proofs of ARM binary properties = highest-assurance evidence for Annex III embedded AI (CakeML-compiled inference engines). DO-178C DO-333: CakeML semantic preservation proof + HOL4 ARM model = formal evidence substitute for MC/DC structural coverage at binary level. GDPR Art. 25: HOL4 information-flow proofs (seL4 confidentiality proof originated in HOL4 before Isabelle port) = formal non-interference evidence. BSD 3-Clause licence; github.com/HOL-Theorem-Prover/HOL. CakeML BSD 3-Clause; cakeml.org. |
| CBMC | CBMC CLI (SAT/SMT), JBMC (Java), GitHub Actions | Deploy CBMC to Europe → | C Bounded Model Checker — Daniel Kroening 🇩🇪 (University of Oxford 🇬🇧, TACAS 2004). BMC + SAT encoding: converts C programs to propositional formulas, finds buffer overflows/null derefs/integer overflows/assertion violations for all executions up to a bound. Amazon AWS uses CBMC in CI for s2n-tls (found buffer over-read in TLS session resumption); Toyota for ISO 26262 ASIL D automotive C code; NASA JPL for flight software (Power of Ten rules). SV-COMP (Dirk Beyer 🇩🇪, LMU Munich) top tier (ReachSafety + MemSafety categories). CPAchecker (Beyer, LMU Munich 🇩🇪) + UltimateAutomizer (Heizmann/Podelski, Freiburg 🇩🇪) — EU SV-COMP ecosystem. JBMC (Java bytecode, Oxford 2018): NullPointerException + ArrayIndexOutOfBoundsException proofs for DORA/NIS2 Java services. Harness pattern: __CPROVER_assume() + __CPROVER_assert() for universal quantification over all valid inputs. ESBMC fork (Manchester 🇬🇧, MathSAT5 from FBK Trento 🇮🇹, MISRA-C). EU AI Act Art. 9: CBMC UNSAT certificates = machine-checked absence of memory-safety vulnerabilities in embedded C AI inference engines. IEC 61508 SIL 3/4: SAT-based formal verification satisfies "formal methods" requirement when --unwinding-assertions proves loop bound sufficiency. ISO 26262 ASIL D: bounded reachability proofs for safety functions (braking, steering). DO-178C DO-333 MC/DC: CBMC checks + test vectors from counterexamples. EU CRA 2027: buffer overflow + integer overflow proofs = formal market access evidence. BSD 4-Clause; github.com/diffblue/cbmc (Diffblue, Oxford 🇬🇧 spinout). |
| ESBMC | ESBMC CLI, Docker, GitHub Actions | Deploy ESBMC to Europe → | Efficient SMT-Based Bounded Model Checker — Lucas Cordeiro 🇵🇹 (University of Manchester 🇬🇧, TACAS 2009) + Daniel Kroening 🇩🇪 (Oxford 🇬🇧). SMT-BMC: translates C/C++/Java programs to SMT formulae (bit-vectors + arrays + arithmetic), checks integer overflow/null-deref/out-of-bounds/race/deadlock/memory-leak/use-after-free. k-Induction: extends bounded proofs to unbounded invariants without manual loop annotations — base case (BMC k steps) + inductive step (assume k, prove k+1). EU SMT backends: MathSAT5 (Alberto Griggio 🇮🇹, FBK Trento 🇮🇹 — 100% EU) + Bitwuzla (Aina Niemetz/Armin Biere, JKU Linz 🇦🇹 — EU-origin). SMT encoding precision: C integers → QF_BV exact wrap-around; floats → QF_FP IEEE 754; pointers/arrays → QF_ABV aliasing model — no false positives within bound. Supports C (C90–C17), C++11–C++20, Java bytecode (Soot), Solidity smart contracts, Python 3. SV-COMP top tier: ReachSafety-C + MemSafety-C + ConcurrencySafety-C. Oxford–Manchester axis: CBMC(2004)+ESBMC(2009)+2LS(2014) — most prolific bounded-model-checker group globally. ISO 26262 ASIL D: formal overflow + null-deref absence in automotive C firmware. IEC 61508 SIL 3/4: k-induction proofs as IEC 61508-3 Annex B formal verification artifacts. IEC 62304 Class C: counterexample traces as test-case generation evidence. DO-178C DO-333: tool qualification package available. EN 50128 SIL 4: SMT proofs for ERTMS/ETCS control software. EU AI Act Art. 9: verified absence of overflow in C++ AI inference loops. CRA 2027: CWE-119 buffer overflow + CWE-190 integer overflow + CWE-476 null-deref formal absence. Apache 2.0; github.com/esbmc/esbmc. |
| BLAST | pblast.opt CLI (OCaml), research tool | Deploy BLAST to Europe → | Berkeley Lazy Abstraction Software Verification Tool — Thomas A. Henzinger 🇦🇹 (UC Berkeley → now IST Austria 🇦🇹, President since 2009) + Ranjit Jhala + Rupak Majumdar (now MPI-SWS 🇩🇪) + Grégoire Sutre (now Université de Bordeaux 🇫🇷) — POPL 2002 "Lazy Abstraction". Predicate abstraction + CEGAR: abstract state = boolean vector of predicates; CEGAR = counterexample-guided abstraction refinement (abstract → model check → check counterexample → refine). Lazy abstraction: builds Abstract Reachability Tree (ART) incrementally — only abstracts where exploration actually goes; refinement adds predicates locally to ART nodes, not globally. Key algorithmic innovation over prior CEGAR (e.g., SLAM): no global restart after refinement, only local ART update at spurious counterexample point. Craig interpolation for predicate discovery: given infeasible path A∧B=false, interpolant I separates A from B, provides minimal new predicate. EU intellectual lineage: Dirk Beyer 🇩🇪 co-authored BLAST tool paper (SPIN 2003) → founded SoSy-Lab at LMU Munich 🇩🇪 → created CPAchecker as direct architectural descendant (ART→ARG, lazy abstraction→PredicateCPA, Craig interpolation→SMTInterpol). BLAST was the existence proof that lazy abstraction + CEGAR scales to industrial C programs; CPAchecker generalised this to a pluggable CPA framework. Thomas Henzinger 🇦🇹 at IST Austria (Klosterneuburg, Austrian Federal + Land NÖ funded, EU law, no US Cloud Act): formal methods research continues — reactive synthesis, quantitative verification, hybrid systems. Rupak Majumdar 🇮🇳 at MPI-SWS Kaiserslautern 🇩🇪 (Max Planck Society, German federal institution): concurrent program analysis, probabilistic verification, distributed synthesis. ISO 26262 ASIL D: predicate abstraction proofs for automotive C safety functions. IEC 61508 SIL 3/4: CEGAR-based formal verification satisfies IEC 61508-3 Annex B. EU AI Act Art. 9: lazy abstraction verifies absence of reachable error states in embedded C AI inference code. CRA 2027: CWE-476 null-deref + CWE-190 integer overflow formal absence. Research licence; embedded.eecs.berkeley.edu/research/blast. |
| Storm | Storm CLI (C++), Docker (movesrwth/storm), GitHub Actions | Deploy Storm to Europe → | Probabilistic model checker — Joost-Pieter Katoen 🇩🇪🇳🇱 (RWTH Aachen 🇩🇪) + Arnd Hartmanns 🇳🇱 (now University of Twente 🇳🇱) + Tim Quatmann 🇩🇪 + Sebastian Junges 🇳🇱 (now Radboud University Nijmegen 🇳🇱) — CAV 2017 "A Storm is Coming". Probabilistic model checking: DTMCs (discrete-time Markov chains), MDPs (Markov decision processes), CTMCs (continuous-time Markov chains), POMDPs, Markov automata. PCTL (P≥p [F goal] / P≤p [F≤k bad]) + CSL (time-bounded/steady-state) + LTL over MDPs. Four engines: sparse (iterative numeric, sound value iteration), hybrid (BDD symbolic + numeric), DD (fully symbolic MTBDD), exact (rational arithmetic). Parametric model checking: probabilities as symbolic rational functions in parameters — parameter synthesis, Bayesian model checking with uncertain rates. DFT (Dynamic Fault Trees): MTTF/availability for ISO 26262 ASIL D fault trees. GSPN (Generalised Stochastic Petri Nets): queuing/manufacturing systems. JANI format (Hartmanns et al.): universal probabilistic model exchange, compatible with PRISM/Modest/FAUST²/Mcsta. PRISM language support: Storm is a drop-in replacement for PRISM with superior scalability. EU AI Act Art. 9 direct tool: MDPs = mathematical model of reinforcement learning agents — Storm formally verifies worst-case collision/failure probability over all possible adversarial environments. Probabilistic safety certificates for autonomous systems (robotics, autonomous vehicles, medical AI). ISO 26262 ASIL D: fault tree analysis (MTTF below 10⁻⁸/h) for automotive. IEC 61508 SIL 3/4: SIL verification via CTMC availability analysis. DORA 2025 (EU): ICT system resilience quantification for financial institutions. DO-178C/ED-12C: probabilistic failure mode analysis for aerospace. RWTH Aachen 🇩🇪: DFG + Horizon Europe funded, 100% EU research infrastructure. GPL-3.0; github.com/moves-rwth/storm. Docker: movesrwth/storm:stable. |
| Tamarin Prover | tamarin-prover CLI (Haskell/cabal), interactive browser GUI (localhost:3001), Docker (ubuntu:22.04 + cabal), GitHub Actions | Deploy Tamarin Prover to Europe → | Automated cryptographic protocol verifier — David Basin 🇨🇭 (ETH Zurich 🇨🇭, Information Security group) + Cas Cremers 🇳🇱 (CISPA Helmholtz Center 🇩🇪, Saarbrücken) + Simon Meier 🇩🇪 (ETH Zurich) + Benedikt Schmidt (ETH Zurich) — IEEE S&P 2012 / CSF 2012. Multiset rewriting: protocol = set of rewriting rules consuming/producing linear facts (one-use messages) and persistent facts (long-term keys !Ltk). Dolev-Yao adversary: reads/replays/crafts all network messages; cannot break crypto primitives. Equational theories: Diffie-Hellman (exp(exp(g,x),y)=exp(exp(g,y),x)), XOR (x XOR x = 0), Bilinear pairings, Abelian groups — handles DH-based protocols that ProVerif cannot (TLS 1.3, 5G AKA). Temporal logic lemmas: secrecy (K(k) unreachable), authentication (Commit implies prior Running), perfect forward secrecy (key compromise after session does not expose past sessions), unlinkability (indistinguishability of sessions for same device). Constraint solving: proof search by constraint system exhaustion — sound and complete for bounded protocols; interactive mode for undecidable cases. Landmark verifications: TLS 1.3 (RFC 8446): 4 handshake modes + 9 security properties formally proved (Cremers, Dowling, Hale, Paterson, Warinschi — IEEE S&P 2017) — IETF incorporated fix for draft-18 composability issue before publication; 5G AKA (3GPP TS 33.501): SUPI privacy XOR-masking flaw discovered and fixed before 5G deployment (Cremers, Dehnel-Wild, Lukert — IEEE S&P 2019); Signal Protocol Double Ratchet (forward secrecy + break-in recovery); WireGuard VPN handshake (Noise_IK); EUDI Wallet (eIDAS 2.0) OpenID4VCI/OpenID4VP; WPA3 SAE (Wi-Fi authentication). Every EU HTTPS connection (TLS 1.3) and every EU 5G authentication runs on Tamarin-verified protocols. CISPA Helmholtz Center 🇩🇪: German federal research institution, no US Cloud Act exposure. ETH Zurich 🇨🇭: Swiss federal, GDPR/FADP compliant. EU CRA 2027 Art. 13: protocol security proofs eliminate CWE-290/CWE-330/CWE-295 from verified implementations. NIS2 Art. 21: 5G AKA + TLS 1.3 formally proved for EU critical infrastructure. eIDAS 2.0 EUDI Wallet: protocols formally verified. GDPR Art. 32: machine-checked encryption adequacy evidence. DORA: TLS 1.3 proof covers financial ICT systems. Open source (GNU GPL); github.com/tamarin-prover/tamarin-prover. |
| KeYmaera X | KeYmaera X JAR (JVM 17+), web UI (localhost:8090), Docker (eclipse-temurin:17-jdk + Z3), GitHub Actions | Deploy KeYmaera X to Europe → | Hybrid systems theorem prover (Differential Dynamic Logic, dL) — André Platzer 🇩🇪 (TU Munich 🇩🇪, Leibniz Prize 2020, Alexander von Humboldt Professorship €5M) + Philipp Rümmer 🇩🇪 (Uppsala University 🇸🇪) + Stefan Mitsch 🇦🇹 (ETH Zurich 🇨🇭) + Jan-David Quesel 🇩🇪 (Univ. Oldenburg 🇩🇪) — CAV 2015 San Francisco, LICS 2012. Differential Dynamic Logic (dL): first-order modal logic for hybrid programs — programs combining discrete control (assignments, conditionals, nondeterministic choice α∪β, loops α*) with continuous dynamics (ODEs x'=f(x)&φ). Safety modality [α]φ: after ALL executions of α, φ holds. Uniform substitution calculus: ~30 axioms + 7 rules, complete relative to real arithmetic (Tarski decision procedure via Mathematica cylindrical algebraic decomposition or Z3 incomplete). Differential invariants: prove ODE invariants via Lie derivative without solving ODE — ṗ(x)=∇p(x)·f(x) ≥ 0 implies p(x) stays non-negative; differential ghosts (auxiliary ODEs); barrier certificates (Lyapunov-style positivity). Landmark verifications: European Train Control System (ETCS Level 3): collision-freedom of EU railway movement authority protocol formally proved (Platzer+Clarke, HSCC 2009) — deployed across 30,000+ km EU rail; Adaptive Cruise Control (ACC): all-direction vehicle following safety for bidirectional braking/acceleration (CAV 2007); ACAS X airborne collision avoidance: DO-178C Level A safety for aircraft separation maneuver (Jeannin+Platzer et al., FM 2015 — Eurocontrol 🇪🇺); autonomous lane changes: formally proved collision-freedom under nondeterministic surrounding traffic (Mitsch+Ghorbal+Platzer, IJRR 2013); Ground Collision Avoidance: pilot recovery maneuver bounds. TU Munich anchor: Platzer received both highest German science award (Leibniz Prize, DFG, 2020) and highest-funded German research professorship (Alexander von Humboldt Professorship, BMBF) — KeYmaera X is now an EU-anchored project. EN 50128 SIL 4: ETCS/ERTMS railway (Deutsche Bahn 🇩🇪, SNCF 🇫🇷, RFI 🇮🇹, ProRail 🇳🇱, Infrabel 🇧🇪). DO-178C Level A: ACAS X avionics (Airbus 🇫🇷, Thales Avionics 🇫🇷). ISO 26262 ASIL D: ACC + lane-change autonomous vehicle control (Bosch 🇩🇪, Continental 🇩🇪, ZF 🇩🇪, Valeo 🇫🇷). EU AI Act Art. 9: autonomous vehicle high-risk AI system risk management — machine-checked collision-freedom for all possible road conditions within physical model. UNECE WP.29 ALKS Regulation (EU) 2021/646: formal safety arguments for Automated Lane Keeping. GDPR Art. 25: formal verification of personal data controller logic in connected vehicle systems. CRA 2027 Art. 13: neural network sandbox verification (ModelPlex runtime monitor, Mitsch 🇦🇹/Platzer 🇩🇪). NIS2 Art. 21: ETCS formal verification evidence for critical infrastructure operators. Eclipse Public Licence 1.0; github.com/LS-Lab/KeYmaeraX-release. |
| Rebeca | Afra IDE headless (Eclipse/Java 17), mCRL2 backend, Docker (eclipse-temurin:17-jdk + mcrl2), GitHub Actions | Deploy Rebeca to Europe → | Actor-based reactive objects formal modeling language — Marjan Sirjani 🇸🇪 (Mälardalen University 🇸🇪 → Reykjavik University 🇮🇸) — Workshop on Foundations of Software Engineering 2001 / Concurrency and Computer Science 2004. Actor model: each reactiveclass has private statevars + finite mailbox (capacity declared) + msgsrv message handlers. Run-to-completion semantics: one message handler executes atomically; no re-entrancy, no shared memory between actors. main block: instantiates actors with knownrebecs (known-actor references) and initial parameters. Global state = tuple of actor statevars + mailbox contents → finite bounded state space → decidable model checking. Afra IDE: Eclipse-based graphical editor + symmetry reduction (symmetric actor instances collapsed to equivalence classes) + mCRL2 backend for LTL model checking (TU Eindhoven 🇳🇱). Timed Rebeca (2012, Reykjavik University 🇮🇸): delay(t) execution time + after(t) message delivery delay → dense-time semantics, zone-graph reachability (DBMs, identical to UPPAAL), TCTL model checking. Probabilistic Rebeca: probability distributions on msgsrv scheduling → PRISM/Storm backends. Hybrid Rebeca: ODE continuous dynamics + discrete actor model → cyber-physical formal verification. ABS (Abstract Behavioral Specification) cluster: Oslo 🇳🇴 + Kaiserslautern 🇩🇪 + CWI 🇳🇱 + Chalmers 🇸🇪 — EU actor-based formal methods ecosystem. Erlang/OTP 🇸🇪 (Ericsson): actor processes = natural Rebeca models; Rebeca verifies OTP supervision tree restart safety. EU funding: Vetenskapsrådet 🇸🇪 + Icelandic Research Fund 🇮🇸 + EU Horizon DESTINE (€3.2M edge computing actor-based verification). ISO 26262 ASIL D: Timed Rebeca models automotive ECU reactive software (sensor → CAN → actuator timing chains), deadline verification by Afra TCTL. IEC 62304 Class C: actor-model infusion pump/patient-monitor control logic, message-passing concurrency formally verified. NIS2 Art. 21: concurrent network protocol state machines (TLS session, BGP), exhaustive interleaving exploration. EU AI Act Art. 9: actor-framework AI inference services (Akka, Erlang), deadlock/race absence proofs. IEC 61508 SIL 3/4: PLC message-passing network reactive control. GDPR Art. 32: concurrent personal data actor pipeline, race-freedom machine-checked. MÄLARDALEN MDART 🇸🇪 + Reykjavik University 🇮🇸 — 100% EEA/EU research provenance. Open source; rebeca-lang.org. |
| LTSmin | mc-reachability / sym-reachability / dist-reachability CLI, Docker (ubuntu:22.04 + mcrl2 + spins), GitHub Actions | Deploy LTSmin to Europe → | Language-independent multi-core symbolic model checker (PINS architecture) — Jaco van de Pol 🇳🇱 (University of Twente 🇳🇱 → Aarhus University 🇩🇰) + Stefan Blom 🇳🇱 (Twente → CWI Amsterdam 🇳🇱) + Michael Weber (Twente → CWI 🇳🇱) — CAV 2010 "LTSmin: Distributed and Symbolic Reachability". PINS (Partitioned Next-State Interface): abstract interface separating model description language from verification algorithm — dependency matrix D[i][j] encodes which state variables transition group i reads/writes, enabling structural partial-order reduction (POR) at interface level without knowledge of language semantics. Frontends via PINS adapters: mCRL2 (mcrl2-ltsmin, TU Eindhoven 🇳🇱), Promela/SPIN (spins compiler, Holzmann DK), DVE/DIVINE (Masaryk University 🇨🇿), UPPAAL networks of timed automata (opaal), ETF exchange format. Three exploration backends: (1) multi-core explicit-state BFS with work-stealing (lockless hash maps, compare-and-swap, near-linear scaling to 64 cores); (2) symbolic BDD-based chained saturation (disjunctive partitioning over MTBDD — Sylvan multi-core BDD library, Tom van Dijk 🇳🇱 Twente → Radboud University 🇳🇱, BDD operations parallel via work-stealing with lockless memoisation cache); (3) distributed MPI BFS (state distribution by hash, MPI message exchange, cluster-scale state spaces exceeding single-machine RAM). LTL model checking: Büchi automaton product + nested DFS (NDFS) counterexample extraction, parallel cyan-blue-red NDFS for multi-core. CTL* model checking: symbolic backward fixed-point over BDD state space. POR reduces state spaces exponential in concurrent component count. NWO (Netherlands Organisation for Scientific Research) + ERC (European Research Council) funded — 100% EU research lineage: Twente NL → CWI NL → Aarhus DK. IEC 61508 SIL 3/4: Annex B model checking for industrial concurrent control software. EN 50128 SIL 4: concurrent railway protocol formal verification (interlocking logic, ETCS communication). NIS2 Art. 21: PROMELA concurrent network protocol exhaustive state-space security verification. EU AI Act Art. 9: concurrent AI inference service deadlock/race freedom by multi-core exhaustive exploration. IEC 62304 Class C: concurrent medical device software formal concurrent analysis. GDPR Art. 32: concurrent personal data pipeline race-freedom machine-checked. BSD 3-Clause; github.com/utwente-fmt/ltsmin (University of Twente Formal Methods group 🇳🇱). |
| EasyCrypt | easycrypt check CLI (OCaml opam), Docker (easycrypt/easycrypt:latest), GitHub Actions | Deploy EasyCrypt to Europe → | Proof assistant for machine-checked cryptographic security proofs based on probabilistic relational Hoare logic (pRHL) — Gilles Barthe 🇫🇷 (INRIA Sophia Antipolis 🇫🇷 → IMDEA Software Madrid 🇪🇸 → Max Planck Institute for Security and Privacy Bochum 🇩🇪) + Benjamin Grégoire 🇫🇷 (INRIA Sophia Antipolis 🇫🇷) + Manuel Barbosa 🇵🇹 (Universidade do Porto 🇵🇹) + Pierre-Yves Strub 🇫🇷 (IMDEA Madrid 🇪🇸 → École Polytechnique 🇫🇷) + José Bacelar Almeida 🇵🇹 (Universidade do Minho 🇵🇹) — FOSAD 2013 "EasyCrypt: A Tutorial". pRHL judgment ⊢ c₁ ~ c₂ : Φ / Ψ relates two probabilistic programs with pre/post-conditions — captures game-based security proof structure. Game hops: G₀ ≈ε₁ G₁ ≈ε₂ G₂ ≈ε₃ G₃ (final game unwinnable), each step machine-verified. Module system: adversaries and oracles as parameterized modules with module type interfaces. proc for probabilistic procedures; <$ for sampling; tactics: call, rnd, wp, skip, seq, auto. Ambient higher-order logic for distribution reasoning. Verified: CRYSTALS-Kyber / ML-KEM FIPS 203 (NIST PQC winner, IEEE SP 2023 — Barbosa+Bhargavan+Blot+Grégoire+Kiefer+Kobeissi+Liao+Rezk+Strub), CRYSTALS-Dilithium / ML-DSA FIPS 204, HACL* (Firefox + Linux kernel + Signal, CCS 2017 — Zinzindohoué+Bhargavan+Protzenko), AWS s2n-tls. Jasmin pipeline (CCS 2017 — Almeida+Barbosa+Barthe+Blot+Grégoire+Laporte+Oliveira+Pacheco+Strub+Unruh): EasyCrypt proof → Jasmin assembly-level source → verified compilation → machine-checked security from proof to binary. BSI TR-02102 🇩🇪: ML-KEM + ML-DSA PQC migration mandate — EasyCrypt proofs as highest-assurance compliance evidence. ANSSI 🇫🇷: post-quantum roadmap references INRIA/IMDEA ecosystem; EasyCrypt artefacts accepted in security evaluation. NIS2 Art. 21(2)(h): "appropriate cryptographic measures" — machine-checked proofs exceed pen-and-paper assurance for operators of essential services. eIDAS 2.0 (EU) 2024/1183: EUDI Wallet ML-DSA credential signatures — EasyCrypt ML-DSA verification directly supports LoA High certification. EU AI Act Art. 9: cryptographic security proofs for high-risk AI system authentication/integrity components constitute documented risk management evidence. CRA 2027: "state of the art" security claim — machine-checked proofs are defensible CRA compliance for cryptographic components. IMDEA Software Institute 🇪🇸 + INRIA 🇫🇷 + Max Planck 🇩🇪 + Universidade do Porto 🇵🇹 + Universidade do Minho 🇵🇹 — 100% EU research provenance. ANR 🇫🇷 + ERC Advanced Grant EU funded. MIT License; github.com/EasyCrypt/easycrypt. |
| CryptoVerif | cryptoverif CLI (OCaml opam), Docker (ocaml/opam:ubuntu-22.04 + cryptoverif), GitHub Actions | Deploy CryptoVerif to Europe → | Computationally sound automated prover for cryptographic protocols in the cryptographic model — Bruno Blanchet 🇫🇷 (INRIA Paris 🇫🇷 / ENS) — ESOP 2006 "Computationally Sound, Automated Proofs for Security Protocols". Operates in the computational model: security as probability bounds Pr[A breaks protocol] ≤ neg(n), not symbolic Dolev-Yao. Protocol language: probabilistic process calculus with types (bitstring, key, nonce), pattern matching, new k: key fresh generation, <$ probabilistic sampling. Cryptographic assumptions declared via equiv blocks: proba P_ind_cpa. equiv(ind_cpa_sym) ... <=(P_ind_cpa)=> ... — CryptoVerif applies these as game hops. Proof engine: simplification → primitive replacement (IND-CPA/IND-CCA2 equiv) → ROM lazy sampling → terminal game with negligible advantage. Outputs machine-verified probability bound: Pr[break] ≤ n² × P_ddh + n × P_prf. TLS 1.3 verified (IEEE SP 2017 — Bhargavan+Blanchet+Kobeissi FR INRIA): key schedule correctness, forward secrecy, mutual authentication, cross-protocol attack in draft found and fixed before RFC 8446. WireGuard verified (Lipp+Blanchet FR, Haase+Cremers NL, 2019): static-static DH forward secrecy, identity hiding, replay protection. Signal Double Ratchet (Blanchet 2022): chain key PRF independence, break-in recovery in O(1) DH ratchet steps. Library: default.pvl — IND-CPA/IND-CCA2 symmetric/asymmetric enc, PRF MACs, EUF-CMA signatures, PRF-ODH for HKDF, CDH/DDH/GDH for DH groups, ROM hash. ProVerif relation: same applied pi-calculus input syntax (Abadi+Blanchet POPL 2001); ProVerif=symbolic, CryptoVerif=computational — verified same TLS 1.3 from both models. EasyCrypt bridge: EasyCrypt proves primitive security (IND-CCA2, PRF) → CryptoVerif uses as assumption → protocol proved computationally secure — full INRIA stack. BSI TR-02102 🇩🇪: TLS 1.3 key schedule CryptoVerif proof = machine-verified compliance evidence for §3.3. ANSSI 🇫🇷: INRIA CryptoVerif cited in "Recommandations TLS" as reference tool; ANR-funded. NIS2 Art. 21(2)(h): computational protocol proofs exceed pen-and-paper assurance for OES cryptographic measures. CRA 2027: machine-verified protocol security bound = defensible "state of the art" CRA evidence. eIDAS 2.0: TLS 1.3 computational proof chain supports EUDI Wallet LoA High transport security. INRIA Paris 🇫🇷 100% EU; ANR 🇫🇷 + ERC Horizon Europe funded. Distributed free; github.com/blanchet/cryptoverif. |
| Jasmin | jasminc CLI (OCaml opam), Docker (ubuntu:22.04 + opam + jasmin), GitHub Actions | Deploy Jasmin to Europe → | Assembly-level language for high-assurance high-speed cryptographic implementations — José Bacelar Almeida 🇵🇹 (Universidade do Minho 🇵🇹) + Manuel Barbosa 🇵🇹 (Universidade do Porto 🇵🇹) + Gilles Barthe 🇫🇷 (IMDEA Software Madrid 🇪🇸 → Max Planck Institute Bochum 🇩🇪) + Benjamin Grégoire 🇫🇷 (INRIA Sophia Antipolis 🇫🇷) + Dominique Unruh 🇩🇪 (University of Tartu 🇪🇪) + 6 more EU co-authors — CCS 2017 "Jasmin: High-Assurance and High-Speed Cryptography". Typed assembly-like language: reg u32/reg u64 register types + [u8 N] stack arrays + mem u64 heap pointers — bounds checked at compile time. x86-64 intrinsics: #ADD_32, #XOR, #ROL_32, #MULX_64, #ADCX_64, #VPSHUFB_256 (AVX2/AVX-512). Inline functions: expand before verification, no call overhead. Verified compiler (Coq): semantic preservation proof — any property proved about Jasmin source holds for compiled x86-64 assembly (same approach as CompCert/Leroy 🇫🇷). Constant-time verification: #secret/#public type system — type checker enforces no secret-dependent branches, no secret-dependent memory indices — machine-checked at instruction level, not source level, compiler transformations cannot introduce violations. jasminc -CT src/cipher.jazz verifies CT property. HACL* (High-Assurance Cryptographic Library) Jasmin primitives: ChaCha20-Poly1305 (Firefox NSS + Linux kernel), Salsa20/XSalsa20 (libsodium), SHA-3/Keccak (Firefox), BLAKE2b/BLAKE2s (Signal Protocol), Curve25519 X25519 (Firefox + Signal + WireGuard), Ed25519 (Firefox + Tails OS), Poly1305 AVX2 (Linux kernel ARM/x86), ML-KEM/Kyber-768 (PQC). Full verified pipeline: EasyCrypt (security proof: IND-CCA₂, INT-CTXT, PRF game-based) → Jasmin (assembly-level implementation, CT-checked) → jasminc (Coq-verified compiler) → x86-64 (runs in Firefox/Signal). BSI TR-02102 🇩🇪: ML-KEM Jasmin implementation = highest-assurance PQC migration artefact (verified + CT). ANSSI 🇫🇷: INRIA/IMDEA Jasmin group referenced in PQC roadmap — CT proofs accepted as formal security evidence. CRA 2027: CWE-208 (observable timing discrepancy) + CWE-385 (covert timing channel) formally eliminated by machine-checked CT certificates. NIS2 Art. 21(2)(h): Jasmin CT verification = machine-checked "appropriate cryptographic measures" evidence. FIPS 140-3: Project Everest (MSR Cambridge 🇬🇧 + INRIA Paris 🇫🇷) uses Jasmin for FIPS module validation. EU AI Act Art. 9: Jasmin CT proofs for cryptographic AI system authentication/integrity components. Universidade do Minho 🇵🇹 + Universidade do Porto 🇵🇹 + IMDEA Madrid 🇪🇸 + INRIA Sophia Antipolis 🇫🇷 + Max Planck Bochum 🇩🇪 + University of Tartu 🇪🇪 — 100% EU/EEA research provenance. FCT Portugal 🇵🇹 + ANR France 🇫🇷 + ERC Advanced Grant funded. MIT License; github.com/jasmin-lang/jasmin + jasmin-lang.eu. |
| HACL* | hacl-packages (cmake), KreMlin C extraction, Docker (debian:bookworm-slim + cmake + gcc), GitHub Actions | Deploy HACL* to Europe → | Formally verified production cryptographic library — Karthikeyan Bhargavan 🇫🇷 + Jean-Karim Zinzindohoué 🇫🇷 (INRIA Paris 🇫🇷, Prosecco/Cascade team) + Benjamin Grégoire 🇫🇷 (INRIA Sophia Antipolis 🇫🇷) + Jonathan Protzenko 🇫🇷 (INRIA Paris → MSR Cambridge 🇬🇧) + Cédric Fournet 🇫🇷 (MSR Cambridge) — CCS 2017 "HACL*: A Verified Modern Cryptographic Library". Written in F* Low* (dependently typed, KreMlin → C extraction) with EasyCrypt security proofs and Jasmin constant-time assembly: every primitive verified for functional correctness + memory safety + constant-time (CWE-208/385 formally eliminated) + cryptographic security (IND-CCA2, PRF, EUF-CMA). Algorithms verified: ChaCha20-Poly1305 (AEAD, RFC 8439), Curve25519/X25519 (key exchange, RFC 7748), Ed25519 (signatures, RFC 8032), SHA-2/SHA-3/Keccak (FIPS 180/202), HMAC/HKDF (RFC 5869), BLAKE2b/BLAKE2s (Signal), Poly1305 (MAC, AVX2 assembly), ML-KEM/Kyber (FIPS 203, fastest verified PQC NTT implementation). Production deployments: Mozilla Firefox NSS 🇺🇸 (since 2017: ChaCha20-Poly1305 for all TLS 1.3 + SHA-3 + Curve25519 + Ed25519 — first major browser with formally verified crypto); Linux kernel 5.10+ (2020): WireGuard crypto module ChaCha20-Poly1305 + Poly1305 AVX2 + Curve25519 (arch/x86/crypto/poly1305_glue.c from Jasmin verified sources); Signal Protocol (libsignal): Ed25519 identity keys + X25519 X3DH + SHA-256/HMAC-SHA-256 Double Ratchet; Tezos blockchain 🇫🇷: Ed25519/Curve25519 signing. Project Everest (MSR Cambridge + INRIA Paris): miTLS verified TLS 1.3 reference + QUIC* — HACL* as primitive layer for first fully verified HTTPS stack. Full INRIA verification stack: ProVerif (#165, protocol symbolic) → CryptoVerif (#178, protocol computational) → EasyCrypt (#176, security proofs) → HACL* F* Low* (#179, verified C library) → Jasmin (#177, verified assembly CT) → x86-64 binary. BSI TR-02102 🇩🇪: HACL* ChaCha20-Poly1305 + ML-KEM = machine-verified compliance artefacts for TLS 1.3 §3.3 + PQC migration. ANSSI 🇫🇷: INRIA Prosecco/Cascade team — ANR-funded; ML-KEM HACL* implementation cited in ANSSI PQC transition guidance. NIS2 Art. 21(2)(h): F* memory-safety proofs eliminate Heartbleed-class cryptographic implementation attacks for OES operators. CRA 2027 Art. 13: CWE-119/121/122 buffer overflow + CWE-208/385 timing channel formally eliminated — highest possible CRA cryptographic evidence. FIPS 140-3 CMVP: Project Everest FIPS module validation path via HACL* verified primitives. eIDAS 2.0: EUDI Wallet Ed25519 + ML-DSA credential signatures with machine-verified implementation. EU AI Act Art. 9: formally verified cryptographic components for high-risk AI authentication/integrity. INRIA Paris 🇫🇷 + INRIA Sophia Antipolis 🇫🇷 + MSR Cambridge 🇬🇧 — 100% EU/EEA research origin. ANR 🇫🇷 + ERC Advanced Grant + EU Horizon Europe funded. MIT License; github.com/hacl-star/hacl-star. |
| Coccinelle | spatch CLI (OCaml opam), Docker (ubuntu:22.04 + coccinelle), GitHub Actions | Deploy Coccinelle to Europe → | Semantic patch engine for C code transformation and security fix automation — Julia Lawall 🇫🇷 (INRIA Paris 🇫🇷, Gallium/Cambium team) + Gilles Muller 🇫🇷 (LIP6 / Sorbonne Université 🇫🇷) — EMSE 2009 "Coccinelle: Tool Support for Automated CERT C Secure Coding Standard Enforcement". SmPL (Semantic Patch Language): rules match C AST patterns, not strings — metavariables bind expressions/identifiers/types, ... matches arbitrary statement sequences, isomorphisms handle syntactically different but semantically equivalent code. Rule structure: @@ expression E; @@ header + - deletion + + addition + * context lines — operates like a diff but on syntax trees. Linux kernel: scripts/coccinelle/ (130+ patterns), make coccicheck runs all patches in CI — 6000+ kernel commits trace to Coccinelle-generated patches. Security fixes: CWE-908 (kmalloc→kzalloc eliminates uninitialized heap content leaks), CWE-476 (null pointer check insertion for platform_get_resource/devm patterns), CWE-401 (kfree insertion on error paths — missing memory release), CWE-667 (spin_lock/unlock symmetry across all exit branches). Python scripting: coccilib module — rule results accessible from Python, structured diagnostics, arithmetic on AST-extracted values. spatch --sp-file rule.cocci --dir src/ --jobs $(nproc) runs parallel across codebase. Written in OCaml (INRIA-native language, same ecosystem as Coq/CompCert). Codebase coverage: Linux kernel (30M+ lines), OpenSSL, QEMU, FreeBSD, Eclipse CDT. CRA 2027: semantic patches constitute machine-executable CRA Art. 13 evidence — CWE-908/476/401/667 elimination traceable in git history. NIS2 Art. 21(2)(i): systematic vulnerability pattern remediation across critical infrastructure C codebases. ISO 26262 ASIL D: MISRA C rule enforcement via semantic patches for automotive embedded C (AUTOSAR BSW, Classic Platform). IEC 61508 SIL 3/4: safety function C code API evolution patches. IEC 62304 Class C: medical device C library pattern enforcement. Coccinelle Coq formal correctness: Lawall group published SmPL semantics in Coq (INRIA Paris 🇫🇷). INRIA Paris 🇫🇷 + Sorbonne Université 🇫🇷 — 100% EU research provenance. ANR 🇫🇷 funded. GPL v2; github.com/coccinelle/coccinelle. |
| Alive2 | alive-tv CLI (cmake + Z3), Docker (ubuntu:22.04 + cmake + llvm-dev + libz3-dev), GitHub Actions | Deploy Alive2 to Europe → | Translation validation framework for LLVM optimization passes — Nuno P. Lopes 🇵🇹 (Universidade de Lisboa 🇵🇹 / IST, formerly MSR Cambridge 🇬🇧) + John Regehr (University of Utah) + Juneyoung Lee + Chandrakana Nandi + Zhengyang Liu — PLDI 2021 "Alive2: Bounded Translation Validation for LLVM". Predecessor: Alive (PLDI 2015, Lopes + Menendez + Nagarakatte + Regehr) — verified LLVM InstCombine peephole optimizations. Alive2 generalises to arbitrary LLVM passes via SMT refinement checking: target IR refines source IR iff every defined behavior of target is also a defined behavior of source. SMT encoding: Z3 bitvector + FP + memory theories; LLVM UB model (poison propagation, undef/freeze, noalias, dereferenceable, align); bounded loop unrolling for scalability. Found 47+ previously unknown LLVM compiler bugs: incorrect nsw/nuw flag propagation in InstCombine, GVN load forwarding across potential aliases, dead store elimination incorrectly removing volatile zeroing of cryptographic key material, incorrect constant folding under poison semantics. Alive2 complements CompCert (Xavier Leroy 🇫🇷, INRIA Paris 🇫🇷, full Coq correctness proof for CompCert pipeline) — CompCert: global proof for verified compiler; Alive2: per-pass SMT check for LLVM (used by Clang/C++/Rust/Swift/Kotlin-Native). alive-tv before.ll after.ll checks single-pass correctness; integrated into LLVM CI to catch regressions. CRA 2027: compiler correctness is supply chain security — Art. 13 "state of the art" obligation extends to LLVM pass correctness; Alive2 validation artifacts document per-build optimizer correctness. DO-178C / ED-12C: object code verification alternative to CompCert for LLVM-based avionics toolchains — translation validation evidence. ISO 26262 ASIL D: compiler tool qualification (TCL-3) — Alive2 per-optimization evidence narrows scope of manual object code review. NIS2 Art. 21(2)(d): supply chain security — LLVM version + optimization flags validated against Alive2 constitute ICT supply chain risk management documentation. MPI-SWS Kaiserslautern 🇩🇪 (Ralf Jung, Derek Dreyer): LLVM relaxed memory model formalization underpins Alive2 correctness theory. Universidade de Lisboa 🇵🇹 / IST + MSR Cambridge 🇬🇧 — EU-anchored research. Apache 2.0; github.com/AliveToolkit/alive2. |
| SeaHorn | Docker (seahorn/seahorn-llvm14:nightly), sea verify --cex, CI/CD (GitLab/GitHub Actions) | Deploy SeaHorn to Europe → | Fully automated unbounded safety verification framework for C/C++ via LLVM IR — Jorge A. Navas 🇪🇸 (SRI International, formerly NASA JPL) + Arie Gurfinkel (University of Waterloo 🇨🇦) + Temesghen Kahsai (AWS) — CAV 2015 "The SeaHorn Verification Framework". Pipeline: C/C++ → Clang → LLVM IR → SeaHorn passes → Constrained Horn Clauses (CHC) → Z3 Spacer (PDR/IC3 for CHC). CHC encoding: each LLVM basic block becomes a Horn predicate; transition relation encodes assignments and guards; safety query ∀x. error(x) → false is SAT iff program is SAFE. Z3 Spacer: Nikolaj Bjørner (MSR) + Gurfinkel — IC3/PDR generalized to Horn clauses over linear arithmetic + bit-vectors + arrays; interleaves inductive strengthening with counterexample-guided refinement. Crab (abstract interpretation pre-analysis): intervals → zones → octagons (Antoine Miné 🇫🇷, ENS Paris — Cousot group lineage) → polyhedra; seeds CHC encoding with pre-computed invariants, dramatically reduces Spacer search space. NASA JPL: Navas applied SeaHorn to Core Flight System (cFS) flight software verification — same LLVM IR that produces the flight binary is the verification input, closing the model/binary gap. AWS: Kahsai applied CHC techniques to Lambda function verification — memory safety + null pointer + resource bounds in bounded cloud functions. SV-COMP: ReachSafety + MemSafety categories; LLVM-based approach gives unbounded verification where CBMC/2LS require large unrolling bounds. sea verify --cex program.c → SAFE or UNSAFE + concrete counterexample trace. sea verify --crab --crab-dom=zones for richer pre-analysis. __VERIFIER_error() convention (SV-COMP compatible): reachability = UNSAFE. Jorge Navas: born Spain 🇪🇸, Universidad de Málaga background → PhD Univ. Minnesota → NASA JPL → SRI International. EU AI Act Art. 9: unbounded memory safety proof for C-based AI inference engines. DO-178C: verification on same LLVM IR as flight binary eliminates model/binary gap — complementary to Alive2 (which verifies LLVM passes preserve semantics). ISO 26262 ASIL D: C/C++/Rust LLVM IR memory safety verification. NIS2 Art. 21: CWE-119/125/787 (buffer overflow, null deref, use-after-free) formally excluded via CHC proof. CRA 2027: machine-checkable absence of specific vulnerability classes in verified components. BSD-3-Clause; github.com/seahorn/seahorn. |
| Infer | Docker (fbinfer/infer:latest), infer run -- mvn compile, infer run -- make, CI/CD (GitHub Actions/GitLab) | Deploy Infer to Europe → | Compositional static analysis tool based on Separation Logic and Bi-abduction — Peter O'Hearn 🇬🇧 (Queen Mary University of London 🇬🇧 → Meta, ACM Turing Award 2023) + Cristiano Calcagno 🇮🇹 (Queen Mary → Imperial College London 🇬🇧, co-founder Monoidics Cambridge 🇬🇧) + Dino Distefano 🇮🇹 (Queen Mary University of London 🇬🇧 → UCL London 🇬🇧) — POPL 2009 "Compositional Shape Analysis by Means of Bi-abduction". Separation Logic: P * Q asserts P and Q hold on disjoint heap regions — frame rule {P*frame} code {Q*frame} enables local reasoning without global alias analysis. Bi-abduction: given function body code and postcondition Q, simultaneously infer anti-frame H (missing heap precondition) and frame F (heap code doesn't touch); P * H ⊢ code → Q * F for both unknowns at once. Compositionality: each function analyzed once in isolation against inferred spec; callers use cached specs without re-analysis — O(n) in number of functions, not heap size. Properties: NULL_DEREFERENCE (CWE-476), MEMORY_LEAK (CWE-401), RESOURCE_LEAK (file/socket/DB), USE_AFTER_FREE (CWE-416), THREAD_SAFETY_VIOLATION via RacerD. Languages: Java, Kotlin, C, C++, Objective-C. Production at Meta: runs on every diff across Facebook/WhatsApp/Instagram/Messenger — 100k+ diffs/day. Spotify 🇸🇪 (Stockholm) Java backend. Mozilla 🌍 Firefox C++. Monoidics 🇬🇧 (Cambridge, 2009) acquired by Facebook 2013 — ACM Turing Award 2023 arc. CRA 2027: CWE-476+CWE-401+CWE-416 systematically screened per-diff as machine-checkable evidence. NIS2 Art. 21: resource leak in connection pool = availability risk. EU AI Act Art. 9: Java/Kotlin Android on-device inference null safety. GDPR Art. 25: memory/resource leak of personal data structures directly addressed. Peter O'Hearn 🇬🇧 QMUL (1997–2013) + Calcagno 🇮🇹 Imperial College London + Distefano 🇮🇹 UCL London — UK/EU academic provenance. Apache 2.0; github.com/facebook/infer. |
| AFL++ | Docker (aflplusplus/aflplusplus:latest), afl-fuzz -i seeds -o out -- ./target @@, LLVM/QEMU/persistent modes, GitHub Actions/GitLab CI | Deploy AFL++ to Europe → | Dominant coverage-guided greybox fuzzer for C/C++ and binaries — Andrea Fioraldi 🇮🇹 (EURECOM 🇫🇷 → CISPA Helmholtz Center 🇩🇪 Saarbrüken) + Dominik Maier 🇩🇪 (TU Berlin 🇩🇪 → CISPA) + Heiko Eißfeldt 🇩🇪 (Intel, Munich) + Marc Heuse 🇩🇪 (Berlin) — USENIX Workshop on Offensive Technologies (WOOT) 2020 "AFL++: Combining Incremental Steps of Fuzzing Research". Coverage feedback: SHM bitmap (64KB); each byte records edge (src→dst basic block) coverage — new edges = interesting input enters corpus. CmpLog: instruments every LLVM icmp instruction, logs comparison operands at runtime (magic bytes, string constants, checksums), splices operands into future mutations — breaks magic byte barrier without format knowledge. LAF-Intel: transforms multi-byte icmp into chains of 1-byte comparisons at compile time — incremental path coverage toward complex conditions. MOpt: Particle Swarm Optimisation (PSO) dynamically schedules mutation operators (bit flip / byte flip / arithmetic / interesting values / dictionary / splice / havoc) toward operators producing most new coverage. Custom Mutators API: C + Python plugin interface for domain-aware mutation of structured inputs (network protocols, serialisation formats, image codecs, TLS handshakes). Power schedules: 7 modes (exploit/fast/coe/rare/seek/quad/lin) for corpus energy allocation. LLVM instrumentation: persistent mode (1000+ test cases per process, eliminates fork/exec overhead), CmpLog + LAF-Intel integration, deferred forkserver. QEMU mode: dynamic binary translation for closed-source fuzzing. Parallel scaling: -M master + -S workers, one per core. Google OSS-Fuzz default fuzzer (1000+ projects: OpenSSL, curl, libpng, FreeType, SQLite, FFmpeg, WebRTC) — 10,000+ CVEs found since 2016. Linux kernel: QEMU+KVM fuzzing of eBPF verifier, network sockets, filesystem drivers. CISPA Helmholtz Association: funded by BMBF (German Federal Ministry of Education and Research) + State of Saarland — no Cloud Act, no US commercial affiliation. CRA 2027 Art. 13: continuous fuzzing crash reports = machine-readable systematic vulnerability screening evidence; supply chain fuzzing closes third-party component obligation. NIS2 Art. 21(2)(d): systematic memory corruption detection (CWE-119/125/787/416/120) for C/C++ critical infrastructure. EU AI Act Art. 9(2)(e): fuzzing of ONNX/TFLite C++ parsers and input pipelines as documented testing evidence. GDPR Art. 25: corpus + crashes on EU infrastructure, source never leaves EU perimeter. Apache 2.0; github.com/AFLplusplus/AFLplusplus. |
| KLEE | Docker (klee/klee:latest), klee --libc=uclibc --posix-runtime prog.bc --sym-arg 64, GitHub Actions/GitLab CI | Deploy KLEE to Europe → | LLVM-based symbolic execution engine for automatic test generation and bug finding — Cristian Cadar 🇷🇴 (Politehnica University Bucharest 🇷🇴 → Stanford → Imperial College London 🇬🇧, Dept of Computing, Professor) + Daniel Dunbar + Dawson Engler (Stanford) — USENIX OSDI 2008 "KLEE: Unassisted and Automatic Generation of High-Coverage Tests for Complex Systems Programs" (Distinguished Paper Award). Symbolic execution: treats program inputs as symbolic variables α; state = (σ: variables→expressions, π: path condition); on branch if (e), forks into (π∧e) and (π∧¬e); queries STP/Z3 SMT solver to check feasibility and generate concrete test inputs. Result: 84 previously unknown bugs in GNU Coreutils (10+ years old: paste buffer size CWE-131, seq integer overflow CWE-190, tr null dereference CWE-476, dd logic error); 90%+ branch coverage across 89 utilities; Busybox 56 bugs; bash 17 bugs. Copy-on-write state sharing: forked states share heap representation until mutation — orders-of-magnitude memory reduction for path-explosion-heavy programs. Constraint independence optimisation: partitions path condition into independent subsets, queries solver only on relevant partition — reduces SMT invocation cost. Query caching: expression-level (not string-level) cache identifies semantically equivalent SMT queries. Search heuristics: Random Path Selection (binary tree walk, bias toward short paths) + Coverage-New (prioritises states nearest to uncovered LLVM instructions) interleaved. POSIX runtime models (--sym-arg N, --sym-files N M, --sym-stdin M): symbolic file/stdin/argv for Coreutils-class programs without kernel in scope. KLEE + AddressSanitizer: compile with -fsanitize=address → KLEE reports ASan violations as error witnesses with path condition. Deployed in Debian automated package testing; contributes to GNU Coreutils regression test suite. Cadar🇷🇴 (Imperial College London 🇬🇧, Reliable and Secure Systems Lab) = primary upstream maintainer since 2013. CRA 2027: .err error witnesses + .ktest reproducible triggers = machine-readable CVE-ready vulnerability evidence. NIS2 Art. 21(2)(d): CWE-131+CWE-190+CWE-476+CWE-416 systematically found for C/C++ critical infrastructure. EU AI Act Art. 9(2)(e): ONNX/TFLite C++ parser symbolic execution explores adversarial model-file input space exhaustively. GDPR Art. 25: source code, path conditions, symbolic traces on EU infrastructure — implicit program behaviour never leaves EU perimeter. UIUC/LLVM/Stanford → Imperial College London 🇬🇧 EU academic home. BSD 2-Clause; github.com/klee/klee. |
| QuickCheck | cabal install QuickCheck, stack test --test-arguments --quickcheck-tests=1000, Docker (haskell:9.8), GitHub Actions/GitLab CI | Deploy QuickCheck to Europe → | Property-based testing library for Haskell — Koen Claessen 🇸🇪 (Chalmers University of Technology 🇸🇪, Gothenburg) + John Hughes 🏴 (Chalmers, professor since 1988; Scottish-born, 30+ years in Sweden) — ACM SIGPLAN ICFP 2000 "QuickCheck: A Lightweight Tool for Random Testing of Haskell Programs". Core idea: replace specific test cases with properties — universally-quantified specifications that must hold for all inputs of the given type; QuickCheck generates thousands of random inputs via the Arbitrary typeclass and falsifies or confirms each property. Arbitrary a defines arbitrary :: Gen a (generator) + shrink :: a -> [a] (candidates smaller than a for counterexample minimisation). On property failure: shrinker greedily searches for the minimal counterexample — runs the property on all elements of shrink x, recursing on the first smaller failing case until none exists; developer sees the simplest reproducer, not an accidental large input. Gen a monad: choose, elements, oneof, frequency, sized, vectorOf, listOf, arbitrary — composable generators for any domain. Conditional properties: (==>) operator restricts tests to inputs satisfying a precondition; classify + label + cover report input distribution statistics and enforce minimum coverage thresholds. State machine testing (QuickCheck-State-Machine / Test.StateMachine): model-based API testing — define a pure state model, generate random command sequences, compare model transitions to actual API responses; shrinking finds the minimal command sequence revealing a model/implementation divergence. Ericsson 🇸🇪 telecom: John Hughes co-founded Quviq 🇸🇪 (Gothenburg) to commercialise QuickCheck for Erlang/OTP; Quviq QuickCheck found race conditions in Ericsson's SCTP media gateway and protocol state machine violations in the mobile subscriber platform — bugs surviving years of conventional testing. Riak case study (EUC 2011): 14 previously unknown bugs in Basho's distributed key-value database; shrinking reduced 100+-step failing sequences to 3–7-step reproducers. Language ecosystem: Hypothesis 🇬🇧 (David MacIver, Python, 13M+ PyPI downloads/month); fast-check 🇫🇷 (Nicolas Dubien, TypeScript/JS, 8M+ npm downloads/month); ScalaCheck 🇸🇪 (Rickard Nilsson, Chalmers adjacent, Scala); PropEr 🇬🇷→🇸🇪 (Kostis Sagonas, Uppsala University, Erlang typed stateful); jqwik 🇩🇪 (Johannes Link, Java); proptest (Rust). Chalmers University of Technology 🇸🇪: Swedish state-funded (Chalmers stiftelse), no CLOUD Act, Swedish Research Council grants. CRA 2027 Art. 13: cover combinator produces quantified coverage evidence — formal record that specified input classes were exercised at declared frequency, satisfying systematic testing obligation; property-based generators explore CWE-190 (integer overflow at INT_MAX/INT_MIN/0), CWE-131 (buffer size arithmetic edge cases), CWE-119 (array bounds at length boundaries) automatically. NIS2 Art. 21(2)(d): state machine testing of protocol implementations — directly applicable to NIS2-regulated network component certification (Ericsson use case). EU AI Act Art. 9(2)(e): property specifications formalise "all foreseeable conditions" obligation; cover reports provide auditable evidence for high-risk AI system test coverage. GDPR Art. 25: test generators, counterexamples, and coverage logs remain on EU infrastructure. BSD-3-Clause; hackage.haskell.org/package/QuickCheck. |
| Valgrind | valgrind --tool=memcheck --leak-check=full ./prog, valgrind --tool=callgrind ./prog, valgrind --tool=helgrind ./prog, Docker (ubuntu:24.04 + apt valgrind), GitHub Actions/GitLab CI | Deploy Valgrind to Europe → | Dynamic binary instrumentation framework for C/C++ runtime analysis — Julian Seward 🇬🇧 (2002, creator of bzip2, open-source). VEX IR: disassembles native binary to portable typed IR, instruments with analysis callbacks, re-synthesises and executes; no recompilation required. Six tools: memcheck (shadow bits track addressability+validity of every byte: invalid reads/writes, use-after-free CWE-416, double-free CWE-415, memory leaks CWE-401, uninitialised value reads CWE-457), callgrind (instruction + cache simulation per function: L1/LLC misses, branch mispredictions, call-graph attribution — visualised with KCachegrind 🇩🇪/KDE), helgrind (happens-before race detection: data races CWE-362, lock-order violations, POSIX pthreads API misuse), cachegrind (cache simulation only, lightweight), massif (heap footprint timeline with allocation-site attribution), DHAT (dynamic heap analysis: write-only allocations, partial-access over-allocations). EU maintainers: Philippe Waroquiers 🇧🇪 (Belgium, UCLouvain-adjacent, Massif+DHAT primary maintainer); Mark Wielaard 🇳🇱 (Netherlands, Red Hat EU, DWARF+Linux compat). Real-world impact: Mozilla Firefox memory error count reduced from thousands to near-zero (2004–2010) via Valgrind-guided fixes; PostgreSQL runs test suite with -DUSE_VALGRIND; OpenSSH key-parsing uninitialised reads found; Linux kernel kselftest infrastructure. XML output (--xml=yes): machine-readable error reports with CWE-mapped classifications, stack traces, addresses — ingestible by DefectDojo/OWASP Dependency-Track for CVE documentation. Suppression files version-control known false positives. CRA 2027 Art. 13: Valgrind XML = machine-readable vulnerability evidence with precise location (file+line+function); satisfies systematic testing documentation obligation. NIS2 Art. 21(2)(d): CWE-416+CWE-401+CWE-119+CWE-362 detected in network-facing C/C++ services — documented evidence for NIS2 compliance declarations. EU AI Act Art. 9(2)(e): memcheck on llama.cpp/ggml/TensorRT inference code finds memory errors in model-loading paths; callgrind profiles inference performance deterministically. GDPR Art. 25: all analysis runs locally within process address space; memory layouts and stack traces on EU infrastructure; no telemetry. GPL-2.0; valgrind.org. |
| nuXmv | nuXmv binary (FBK Trento), Docker (ubuntu:24.04 + wget), GitHub Actions/GitLab CI | Deploy nuXmv to Europe → | IC3/PDR property-directed reachability model checker for infinite-state systems — FBK Trento 🇮🇹 (Fondazione Bruno Kessler), CAV 2014: Roberto Cavada 🇮🇹 + Alessandro Cimatti 🇮🇹 + Michele Dorigatti 🇮🇹 + Alberto Griggio 🇮🇹 + Alessandro Mariotti 🇮🇹 + Andrea Micheli 🇮🇹 + Sergio Mover 🇮🇹 + Marco Roveri 🇮🇹 + Stefano Tonetta 🇮🇹 — all Italian, all FBK Trento. Extends NuSMV (also FBK Trento, 2002) with IC3/PDR (Aaron Bradley, FMCAD 2011): property-directed reachability searches for an inductive invariant I satisfying Init⇒I, (I∧T)⇒I', I⇒P — instead of computing the reachable set, IC3 blocks counterexample-to-induction states and generalises clauses inductively; avoids the BDD blowup entirely. IC3ia (IC3 modulo theories): combines IC3 coordination with MathSAT5 SMT theory reasoning — enables infinite-state verification over LIA (Linear Integer Arithmetic), LRA (Linear Real Arithmetic), bit-vectors, and arrays. MathSAT5: SMT solver also developed at FBK Trento (Griggio 🇮🇹 primary developer) — complete EU vertical stack where model checker + SMT solver trace to the same Italian public institution. SMV input language (full NuSMV superset): MODULE, VAR (integer/real/bounded types), ASSIGN init/next, SPEC (CTL: AG/EF/AF/EG), LTLSPEC (LTL: G/F/X/U), INVARSPEC (invariant). Engines: BDD-based (inherited NuSMV), BMC (SAT), IC3 (SAT, finite-state), IC3ia (MathSAT5 LIA/LRA, infinite-state). Simulink import: direct Matlab/Simulink model import for automotive/aerospace workflows. Industrial users: Toyota Motor Europe 🇧🇪 (brake-by-wire verification, Prius hybrid powertrain); Siemens AG 🇩🇪 (PLC IEC 61508 SIL4); Bosch 🇩🇪 (AUTOSAR ASIL D); Alstom 🇫🇷 (EN 50128 SIL4 railway interlocking); Leonardo SpA 🇮🇹 (DO-178C/DO-333 avionics); ESA Estec 🇳🇱 (spacecraft FDIR). EU research funding: FP6 PROSYD, FP7 CRYSTAL, Horizon 2020 EMPHYSIS, Horizon Europe. FBK Trento: Italian public research foundation (Fondazione Bruno Kessler), funded by Trentino Autonomous Province + MIUR — no US Cloud Act, no ITAR; 100% EU-origin tool + solver. CRA 2027 Art. 13: IC3 inductive invariant proofs = mathematical safety certificates; IC3ia over LIA proves integer counter safety properties that no test suite can cover exhaustively. NIS2 Art. 21(2)(d): CTL/LTL formal verification of network protocol state machines for NIS2 essential entity obligations. EU AI Act Art. 9(2)(e): IC3ia invariant proofs for AI decision logic — bounded output, data access control, safe operating envelope. GDPR Art. 25: LTL formulae over integer time counters prove unbounded data retention invariants; verification runs on EU infrastructure under GDPR. IEC 61508 SIL 3/4, ISO 26262 ASIL D, EN 50128 SIL 4, DO-178C DO-333. Free for academic use; nuxmv.fbk.eu. MathSAT5: free for academic use; mathsat.fbk.eu. |
| Gazer-Theta | gazer-bmc CLI (LLVM/Clang + Java 17), Theta backend, Docker (ftsrg/gazer-theta), GitHub Actions | Deploy Gazer-Theta to Europe → | LLVM-based C/C++ model checker — Ákos Hajdu 🇭🇺 + Zoltán Micskei 🇭🇺 (ftsrg, BME Budapest, TACAS 2019). Gazer frontend: C/C++ → Clang → LLVM IR → Control Flow Automata (CFA). Theta backend: CEGAR loop over Abstract Reachability Graph (ARG), predicate abstraction with Craig interpolation, explicit-value analysis, XSTS (concurrent reactive models). SMT backends: Z3 (default) or MathSAT5 (FBK Trento 🇮🇹, full EU stack). SV-COMP medals: ReachSafety Bronze 2021, Silver 2023 (ControlFlow). Correctness witnesses (GraphML, SV-COMP format) independently verifiable. XSTS analysis: concurrent state machines for automotive/railway embedded software (Simulink/Stateflow model analog). BME (Budapest University of Technology and Economics, founded 1782): Hungarian state university funded by NKFIH + Horizon Europe — no US Cloud Act, no ITAR; Hungary EU member since 2004. EU SV-COMP satellite: complements CPAchecker 🇩🇪 + UltimateAutomizer 🇩🇪 + DIVINE 🇨🇿 — Central/Eastern EU anchor. EN 50128 SIL 4: MÁV (Hungarian State Railways) + EU rail contractors — Theta reachability proves interlocking safety invariants. ISO 26262 ASIL D: Audi Győr 🇭🇺 + automotive suppliers — CEGAR verifies AUTOSAR C components. IEC 61508 SIL 3/4: XSTS analysis of concurrent PLC/DCS software. EU AI Act Art. 9: ARG-based reachability proofs for embedded C AI inference engines — strongest assurance for Annex III high-risk systems. CRA 2027 Art. 13: SV-COMP-format correctness witnesses = machine-verifiable safety certificates. NIS2 Art. 21: CWE-476 + CWE-119 + CWE-190 + CWE-362 formal exclusion certificates for network-facing C/C++ services. GDPR Art. 25: verification artefacts on EU infrastructure under Hungarian + GDPR law. Apache License 2.0; github.com/ftsrg/gazer + github.com/ftsrg/theta. |
| ECLiPSe CLP | ECLiPSe runtime (eclipseclp.org), Python/Java embedding, Docker (ubuntu:22.04), GitHub Actions | Deploy ECLiPSe CLP to Europe → | Constraint Logic Programming system — Joachim Schimpf 🇩🇪 + Kees Shen 🇳🇱 (ECRC Munich 🇩🇪, EU ESPRIT 1988 — Bull 🇫🇷 + ICL 🇬🇧 + Siemens 🇩🇪 + Philips 🇳🇱 + Nixdorf 🇩🇪 consortium). ic library: CLP(FD) + CLP(R) unified integer/real interval constraints — arc consistency (AC-5) + bounds consistency, occurrences/alldifferent/cumulative global constraints. CHR (Constraint Handling Rules): user-defined propagators, Thom Frühwirth 🇩🇪 (Ulm University + LIP6 Paris 🇫🇷, ICLP 1991). Coroutining: suspend/wake demand-driven propagation — demons re-fire on domain events. EU industrial applications: Lufthansa 🇩🇪 + British Airways 🇬🇧 crew rostering (ILOG commercialisation, EASA Part-FCL + EU OPS regulatory constraints), SNCF 🇫🇷 railway maintenance scheduling (EPSF compliance + ERTMS possession procedures), Philips 🇳🇱 semiconductor wafer fab scheduling (NXP heritage). ECRC (European Computer-Industry Research Centre, Munich 🇩🇪): funded by EU ESPRIT programme + Bull 🇫🇷 + ICL 🇬🇧 + Siemens 🇩🇪 + Philips 🇳🇱 + Nixdorf 🇩🇪 — the canonical pan-European CLP consortium. Mark Wallace 🇬🇧 (IC-Parc → Monash): constraint modelling methodology. Open source 2006 (Mozilla Public Licence); eclipseclp.org. EU AI Act Art. 13: CLP solutions are inherently explainable — each binding justified by explicit constraint propagation chain, satisfies high-risk AI transparency requirements. EU AI Act Art. 9(2)(e): CLP SATISFIABLE/UNSATISFIABLE is formal proof of regulatory compliance (EASA, EU OPS), not statistical estimate. NIS2 Art. 21: security policy constraint validation across full configuration space. CRA 2027: product family invariant verification via constraint propagation. GDPR Art. 25: data minimisation constraints verified formally before processing. |
| Clingo/ASP | clingo CLI (pip install clingo), Python API, Docker (ubuntu:22.04 + pip), GitHub Actions | Deploy Clingo/ASP to Europe → | Answer Set Programming solver — Torsten Schaub 🇩🇪 + Roland Kaminski 🇩🇪 + Benjamin Kaufmann 🇩🇪 (University of Potsdam 🇩🇪, LPNMR 2007). Clingo = Gringo (first-order grounder) + clasp (Conflict-Driven Nogood Learning, CDNL — ASP generalisation of CDCL). Stable model semantics (Gelfond & Lifschitz 1988): answer set = minimal self-supported model satisfying all rules; non-monotonic reasoning via default negation (not). Grounder: first-order rules with variables → propositional ground program. clasp CDNL: 3-valued truth (true/false/undefined), unit propagation, conflict analysis, nogood learning, non-chronological backjumping, well-founded stability check. Multi-shot ASP: incremental horizon-based planning — ground and solve incrementally without restart, reusing learned nogoods across horizons. #minimize/#maximize: optimisation mode finds optimal stable model by cost function. Constraint logic programming: integrity constraints :- body prune invalid models. Industrial EU applications: Siemens AG 🇩🇪 product configuration (10,000+ component catalogues, compatibility constraints), Deutsche Bahn 🇩🇪 railway timetabling (headway + platform occupation constraints + delay minimisation), Airbus 🇫🇷🇩🇪🇪🇸 maintenance scheduling (EASA Part 145 compliance, MRO facility capacity). Martin Gebser 🇩🇪 (now Uni Klagenfurt 🇦🇹): co-architect of CDNL clasp algorithm. DFG (Deutsche Forschungsgemeinschaft) SFB 1044 + Heisenberg Programme: German federal research funding — no US Cloud Act, no ITAR. University of Potsdam: Brandenburg state university. Python API: import clingo; ctl = clingo.Control(); ctl.add(); ctl.ground(); ctl.solve(). EU AI Act Art. 13 (Transparency): every answer set atom has explicit justification trace via rule applications — intrinsically explainable AI, satisfies logging/traceability for high-risk systems. EU AI Act Art. 9: ASP SATISFIABLE/UNSATISFIABLE verdict = formal proof of constraint feasibility, not statistical estimate. NIS2 Art. 21: network security policy constraint validation — ASP proves all configurations satisfy access control invariants before deployment. CRA 2027: software configuration space exhaustive constraint validation. GDPR Art. 25: privacy policy constraint modelling — proves data minimisation constraints are simultaneously satisfiable across system configurations. MIT License; github.com/potassco/clingo (Potassco, University of Potsdam 🇩🇪). |
| SICStus Prolog | SICStus runtime (RISE licence), Jasper Java embedding, Docker (debian:bookworm-slim), GitHub Actions | Deploy SICStus Prolog to Europe → | High-performance ISO 13211-1 Prolog with CLP(FD/R/B) and CHR — Mats Carlsson 🇸🇪 + Seif Haridi 🇸🇪 (SICS Stockholm 🇸🇪, 1988; now RISE Research Institutes of Sweden 🇸🇪). WAM (Warren Abstract Machine, Warren 1983 Edinburgh 🇬🇧): compiled bytecode execution — get_structure/unify_variable/call instructions, register machine, first-argument indexing, last-call optimisation. ISO 13211-1 (1995): one of the most complete compliant implementations — all directives, exceptions, arithmetic, string handling. CLP(FD) (library(clpfd)): finite domain constraints — arc consistency (AC-3/AC-5 + Régin alldifferent), global_cardinality (Hall's theorem), cumulative (resource levelling), element (table lookup). CLP(R) (library(clpr)): linear real arithmetic — Jaffar+Michaylov simplex solver (ICLP 1987 original reference implementation). CLP(B) (library(clpb)): Boolean BDD constraints — satisfying-assignment counting, circuit analysis. CHR (library(chr)): Constraint Handling Rules — Thom Frühwirth 🇩🇪 (Ulm 🇩🇪, ICLP 1991) simplification/propagation/simpagation rules, user-defined constraint solvers. Jasper: bidirectional Java↔Prolog embedding — Java calls SICStus predicates, SICStus calls Java methods. Industrial EU applications: Ericsson 🇸🇪 AXE telephone exchange resource allocation and protocol configuration (contributed to Erlang design lineage); SNCF 🇫🇷 train driver assignment (EU OPS + EPSF rest-period constraints + collective agreement rules); Lufthansa 🇩🇪 crew rostering (via ILOG CPLEX CP Optimizer which drew on SICStus CLP(FD) semantics); IBM ILOG CP Optimizer: SICStus CLP(FD) academic precursor — ILOG acquired the Prolog constraint technology and commercialised it as CP Optimizer. RISE Research Institutes of Sweden 🇸🇪: Swedish state-funded non-profit (Vetenskapsrådet + Vinnova + industry); no US parent company, no CLOUD Act exposure. EU ESPRIT programme: early SICStus versions co-funded by EU research in constraint logic programming (ESPRIT projects PRINCE, COSINE). EU AI Act Art. 13 (Transparency): CLP(FD) constraint store is first-class — every scheduling decision has explicit propagation justification, satisfying Art. 13 technical documentation for high-risk AI (Annex III: workforce scheduling, resource allocation). EU AI Act Art. 9(2)(e): SATISFIABLE/UNSATISFIABLE verdict is formal proof, not statistical estimate — machine-checkable evidence for risk management systems. NIS2 Art. 21: CLP(B) BDD-based security policy constraint validation — Boolean formula satisfying-assignment counting proves access control completeness. CRA 2027 Art. 13: CHR termination + confluence proofs for constraint solver modules = cybersecurity-by-design evidence. ISO 13211-1 compliance: suitable for DO-178C tool qualification path. GDPR Art. 25: constraint model expresses only necessary data relationships; CLP(R) linear constraints provably process minimum data. Commercial (RISE licence); rise.se/sicstus. |
| Verificatum | vfork CLI (Java 21+), VMN + VCR JARs, Docker (eclipse-temurin:21-jdk), GitHub Actions | Deploy Verificatum to Europe → | Verifiable re-encryption mix-net system for cryptographically secure e-voting — Douglas Wikström 🇸🇪 (KTH Royal Institute of Technology, Stockholm 🇸🇪) — TCC 2004 "A Universally Composable Mix-Net". Mix-nets solve the e-voting anonymity problem: ballots are ElGamal-encrypted, shuffled + re-encrypted through a pipeline of mixing servers, then threshold-decrypted — output ballots unlinkable to input ballots. Wikström–Groth shuffle proof (2009): ZK proof of correct shuffling, O(n) group elements, Pedersen commitment to permutation + Hadamard product argument + Fiat-Shamir challenge. Universally composable (UC framework, Canetti 2001): secure under arbitrary concurrent protocol composition. VMN (Verificatum Mix-Net): multi-party key generation (Pedersen 1991 DKG), bulletin board broadcast protocol, sequential mixing pipeline, threshold ElGamal decryption with Chaum–Pedersen partial decryption proofs. VCR (Verificatum Crypto Lib): Java arithmetic library — ECqPGroup (P-256/P-384/P-521 EC groups), modular Z_p* subgroups, ElGamal + threshold ElGamal, Pedersen commitments, sigma-protocol infrastructure. Universal verifiability: any third party can re-run vfork -verify on published bulletin board — cryptographic proof of election integrity without trusting the authority. Deployed: Norway 🇳🇴 Valgdirektoratet reference mix-net (2011/2013 trials + 2021 commission), Switzerland 🇨🇭 cantonal elections (Post-eVoting audits), EU Horizon DEMOS2 (KTH SE + Athens GR + Surrey GB). eIDAS 2.0 (EU) 2024/1183: Verificatum + EUDI Wallet = LoA High e-voting with cryptographic anonymity. Council of Europe CM/Rec(2017)5: universal verifiability + end-to-end verifiability requirements — vfork -verify satisfies both. ENISA e-voting security guidelines: verifiable mix-net reference architecture. GDPR Art. 9: political opinion = special category data — cryptographic unlinkability implements GDPR Art. 9(2)(g) substantial public interest processing; election authority cannot re-link ballots to voters. GDPR Art. 25: data minimisation — authority receives only a vote count, no linkage to identity. NIS2 Art. 21: election infrastructure (Annex I critical infrastructure) — open-source publication + independent audit + universal verifiability satisfies "appropriate technical measures". KTH Royal Institute of Technology 🇸🇪 (est. 1827): Johan Håstad (Turing Award 2024, complexity cryptography) + Wikström — Swedish cryptography lineage. Vetenskapsrådet 🇸🇪 + EU Horizon funded — 100% EU research provenance. LGPL; verificatum.org + github.com/verificatum. |
| Java PathFinder | JPF CLI (Java 17+), Gradle buildJars, Docker (eclipse-temurin:17-jdk), GitHub Actions | Deploy Java PathFinder to Europe → | Explicit-state JVM model checker — Klaus Havelund 🇩🇰 (Aalborg University DK → DLR Oberpfaffenhofen 🇩🇪 → NASA Ames) + Peter Mehlitz 🇩🇪 (DLR Oberpfaffenhofen 🇩🇪 → NASA Ames) — SPIN Workshop/TACAS Amsterdam 🇳🇱 1999 / STTT 2000. JVM as model checker: JPF executes Java bytecode on a custom JVM that systematically explores all thread interleavings — saving/restoring full JVM state (heap + thread stacks + program counters) at each scheduling choice point. Deadlock detection: cycle of monitors waiting (T1 holds L1 waits L2; T2 holds L2 waits L1) — found under any reachable thread scheduling. Race condition detection: concurrent field accesses without synchronisation ordering — CWE-362 formal elimination. Assertion violations: every reachable assert condition = false path reported with exact counterexample trace. Partial Order Reduction (POR): independent concurrent transitions pruned without completeness loss, reducing state space exponential in number of threads. On-the-fly LTL model checking: LTL properties verified during state space exploration, terminating at first violation. Symbolic PathFinder (SPF): Corina Pasareanu 🇷🇴 (NASA Ames) + Neha Rungta — symbolic execution extension replacing concrete inputs with Z3/Coral symbolic variables, enabling test generation + security input discovery + path coverage over all inputs. Cyrille Artho 🇨🇭 (VERIMAG Grenoble 🇫🇷 → KTH Stockholm 🇸🇪): concurrency analysis, POR implementation, jRATS race detection. jpf-jdart (TU Darmstadt 🇩🇪 + Siemens 🇩🇪): concolic testing combining JPF execution with SMT-based test generation. DLR connection: Havelund + Mehlitz both transitioned DLR Oberpfaffenhofen → NASA Ames — JPF's EU intellectual lineage is direct German aerospace research. NASA missions: Deep Space 1 Remote Agent (1999) deadlock verification before launch, Mars Exploration Rovers (MER 2004), MSL Curiosity (2012). EU AI Act Art. 9: JPF exhaustive concurrency verification of Java AI runtime — machine-checked deadlock/race-freedom for concurrent AI inference services. ISO 26262 ASIL D: AUTOSAR Adaptive Platform (AP) Java service layer verification. IEC 61508 SIL 3/4: Annex B formal methods requirement satisfied by exhaustive state-space exploration. IEC 62304 Class C: concurrent medical device Java software (infusion pumps, patient monitoring). EN 50128 SIL 4: ETCS/ERTMS Java components (Thales 🇫🇷, Alstom 🇫🇷, Siemens 🇩🇪). DO-178C Level A: structural coverage via all-path exploration. EU CRA 2027 Art. 13: CWE-362 race condition formal elimination. GDPR Art. 25: synchronisation proof for personal data field accesses. Apache 2.0 licence; github.com/javapathfinder/jpf-core. |
| CPAchecker | CPAchecker CLI (Java), BenchExec, GitHub Actions | Deploy CPAchecker to Europe → | Configurable Program Analysis framework — Dirk Beyer 🇩🇪 (LMU Munich 🇩🇪, TACAS 2007). CPA = (D, ⊤, ⊑, merge, stop, transfer) — pluggable abstract domains: predicate abstraction + CEGAR (Craig interpolation, lazy abstraction from BLAST), k-induction (base case BMC + inductive step), BDD-based explicit-state, symbolic execution, interval analysis. Multi-year SV-COMP champion (ReachSafety + MemSafety + Overflow + Concurrency categories). Correctness witnesses: XML annotations of CFA invariants, independently validated by FShell-w2t (separates trust from CPAchecker implementation). BenchExec (SoSy-Lab LMU Munich, pip install benchexec): containerized reproducible benchmarking infrastructure used by all SV-COMP participants. SMT solvers: Z3 + MathSAT5 (FBK Trento 🇮🇹) + Princess (Uppsala 🇸🇪) + SMTInterpol (Freiburg 🇩🇪, Craig interpolation). EU SV-COMP ecosystem: CPAchecker 🇩🇪 + UltimateAutomizer (Heizmann/Podelski, Freiburg 🇩🇪) + nuXmv (FBK Trento 🇮🇹) + Gazer-Theta (BME Budapest 🇭🇺). Applied to Linux kernel device drivers (lock correctness), AUTOSAR ISO 26262 ASIL D safety functions, IEC 61508 SIL 3/4 industrial PLCs. PSL (IEEE 1850) property specification. Witness-based DO-178C tool qualification path. EU AI Act Art. 9: predicate abstraction proofs for embedded C AI inference engines. GDPR Art. 25: taint-tracking specification automata for personal data flow. Apache License 2.0; github.com/sosy-lab/cpachecker (SoSy-Lab, LMU Munich 🇩🇪). |
| UltimateAutomizer | UltimateAutomizer CLI (Java), Ultimate framework, GitHub Actions | Deploy UltimateAutomizer to Europe → | Automata-based software verifier — Matthias Heizmann 🇩🇪 + Andreas Podelski 🇩🇪 (University of Freiburg 🇩🇪, TACAS 2013). Trace abstraction: programs as automata, safety as Büchi automata, verification = language emptiness. CEGAR via Craig interpolation (SMTInterpol, Hoenicke 🇩🇪, also Freiburg). SV-COMP ReachSafety + MemSafety top tier (multi-year), Termination category-leading. LGPL 3.0. |
| 2LS | 2ls CLI (CPROVER infrastructure), Docker | Deploy 2LS to Europe → | Two-Level Lattice Solver for automated loop invariant synthesis — Saurabh Joshi 🇮🇳 + Daniel Kroening 🇩🇪 (University of Oxford 🇬🇧, CAV 2014 Vienna 🇦🇹). Two-level abstract domain: outer lattice = template polyhedra (intervals/zones/octagons/template polyhedra) over-approximation, inner lattice = BMC under-approximation (CBMC engine). k-Induction: synthesises inductive loop invariants automatically — no manual @invariant annotation. Template polyhedra optimal bound synthesis via Z3 linear arithmetic. CPROVER infrastructure (shared with CBMC): same harness patterns, complementary verification modes. SV-COMP ReachSafety + MemSafety participant. Oxford formal verification cluster: CBMC(2004)+2LS(2014)+JBMC(2018)+Diffblue Cover(2016). ISO 26262 ASIL D: automatic invariant synthesis for automotive control loops. IEC 61508 SIL 3/4: k-induction discharges formal proof requirement (T3.7). EN 50128 SIL 4: termination + invariant proofs for ETCS control software. EU AI Act Art. 9: invariant synthesis for embedded C AI inference loops — output range proofs. EU CRA 2027: integer overflow + buffer overflow absence certificates. GDPR Art. 25: data-range invariants prove data minimisation. BSD licence; github.com/diffblue/2ls. |
| Astrée | AbsInt commercial (DO-178C qualified), Frama-C/Eva open-source | Deploy Astrée to Europe → | Sound abstract interpreter for C — Patrick Cousot 🇫🇷 + Radhia Cousot 🇫🇷 (INRIA Paris / ENS Paris 🇫🇷, PLDI 2003). Proved Airbus A380 primary flight control software (132,000 lines C) has zero runtime errors — no false negatives. Abstract interpretation fixpoint over product domain: interval + octagon (Antoine Miné 🇫🇷, ENS Paris, SAS 2001) + congruence + relational + trace partitioning (Xavier Rival 🇫🇷 + Laurent Mauborgne 🇫🇷, ESOP 2007). Sound = if no alarms, no runtime errors in any execution on any input — unlike fuzzing or testing. AbsInt GmbH 🇩🇪 (Saarbrücken): commercial Astrée + DO-178C Level A tool qualification documentation. Full EU certification stack: Astrée (runtime errors) + CompCert (compiler errors) + aiT (WCET timing) — all AbsInt 🇩🇪. Airbus 🇫🇷 A380/A350/A400M + Thales Avionics 🇫🇷 + Safran 🇫🇷 + Dassault Aviation 🇫🇷: DO-178C DAL A. Alstom 🇫🇷 + Siemens Mobility 🇩🇪 railway: EN 50128 SIL 4. EDF/CEA 🇫🇷 nuclear: IEC 61508 SIL 4. ISO 26262 ASIL D: Bosch/Continental/ZF automotive. EU AI Act Art. 9: absence-of-runtime-error proofs for embedded C AI inference engines — all-path soundness satisfies "all reasonably foreseeable risks". EU CRA 2027: CWE-190/CWE-125/CWE-787/CWE-476/CWE-369 formal absence certificates. GDPR Art. 25: data-range invariants prove data minimisation by design. Commercial licence: absint.com/astree; open-source prototype: PLDI 2003 distribution. |
| ProVerif | ProVerif binary (OCaml), Docker | Deploy ProVerif to Europe → | Automated cryptographic protocol verifier — Bruno Blanchet 🇫🇷 (INRIA Paris 🇫🇷, CSFW 2001). Applied pi-calculus (Martín Abadi + Bruno Blanchet, POPL 2001 / JACM 2018): symbolic model, Dolev-Yao adversary, Horn clause resolution. Formally verified TLS 1.3 (RFC 8446): Bhargavan + Blanchet + Kobeissi (IEEE S&P 2017) — found subtle cross-protocol attack in TLS 1.3 draft, corrected before standardisation. Signal Protocol: Double Ratchet + X3DH — secrecy + post-compromise security + deniability. 5G EAP-AKA′ linkability flaw discovered via symbolic analysis (corrected in 3GPP specification). Security properties: secrecy (attacker cannot derive secret), injective correspondence (authentication with replay protection), observational equivalence (unlinkability / privacy). INRIA Paris Prosecco/Cascade team: ProVerif + CryptoVerif (computational model) + HACL* (formally verified crypto, deployed in Firefox + Linux kernel) + miTLS (reference TLS implementation) + F* (proof assistant). NIS2 Art. 21: formal cryptographic protocol evidence for critical infrastructure operators. DORA: ICT risk management cryptographic resilience documentation. eIDAS 2.0: EUDI Wallet OpenID4VP/SD-JWT unlinkability and selective disclosure proofs. ANSSI 🇫🇷 (French national cybersecurity authority) ecosystem. EU AI Act Art. 9: API security protocol formal verification. CRA 2027: CE-marked software cryptographic protocol evidence. GPLv2; bblanche.gitlabpages.inria.fr/proverif. |
| DIVINE | DIVINE CLI (LLVM/Clang), Docker, GitHub Actions | Deploy DIVINE to Europe → | Explicit-state concurrent C/C++ model checker — Jiří Barnat 🇨🇿 + Luboš Brim 🇨🇿 + Petr Ročkai 🇨🇿 (ParaDiSe Lab, Masaryk University Brno 🇨🇿). DIVINE 4: LLVM frontend — compiles C/C++ via Clang to LLVM IR, executes under DiVM (Divine Virtual Machine) model-checking semantics, explores all thread interleavings explicitly. DiOS: DIVINE Operating System — intercepts pthreads, C11 threads, malloc/free, replacing OS with formally controlled environment. Properties checked: deadlock freedom (all threads blocked), data race detection (happens-before at LLVM IR level), memory safety (null dereference, use-after-free, double-free, out-of-bounds), assertion violations, LTL safety and liveness properties (Büchi automaton product). τ-reduction: partial-order reduction at LLVM instruction granularity — dramatically reduces state space for programs with local computations between synchronisations. Weak memory model (TSO/x86): store-buffer non-determinism explored — finds races visible only on real hardware, invisible to SC-assuming tools. Counterexample: complete thread interleaving trace, fully reproducible. SV-COMP ConcurrencySafety category top tier, ETAPS/TACAS regular participant. Czech Republic 🇨🇿 industrial context: Škoda/VW Group automotive (ISO 26262 ASIL D), Honeywell Aerospace Brno (DO-178C DAL A), Continental Czech R&D. ParaDiSe distributed model checking (DIVINE 2-3, MPI): state spaces too large for one machine distributed across cluster. Czech Science Foundation (GAČR) + Horizon Europe funded. ISO 26262 ASIL D: exhaustive concurrent state-space proof for AUTOSAR C++ tasks. IEC 62443-4-1: deadlock freedom proof for PLC/DCS concurrent firmware. IEC 61508 SIL 3/4: formal concurrent analysis satisfies Table A.6 "formal methods" requirement. EU AI Act Art. 9: concurrent inference thread verification — no interleaving leads to assertion violation. CRA 2027: CWE-362 (race enabling link following) + CWE-820 (missing synchronization) formal absence certificates. GDPR Art. 25: no data race in concurrent personal data processing pipelines. ISC licence; github.com/paradise-fi/divine. Docker: paradise/divine. |
| Miranda | mira interpreter, native binary | Deploy Miranda to Europe → | Lazy functional language, David Turner 🇬🇧 (University of Kent Canterbury, 1985), direct predecessor to Haskell, algebraic data types + lazy evaluation + Hindley-Milner types, Clean 🇳🇱 (Radboud University Nijmegen, Plasmeijer + van Eekelen — EU-native Miranda descendant, uniqueness types → Rust ownership), GDPR Art. 25 data minimisation enforced by lazy semantics, pure functions for GDPR Art. 5(2) accountability |
| SASL | GHC (SASL heritage), Docker | Deploy SASL to Europe → | First lazy higher-order functional language — David Turner 🇬🇧 (University of St Andrews 🏴, 1972), invented call-by-need evaluation + SKI combinator reduction + graph reduction: the three mechanisms that underpin all lazy languages, lineage SASL→KRC(1981)→Miranda(1985)→Haskell(1990), Turner combinators = standard lazy implementation technique for 20 years, University of St Andrews founded 1413 (oldest Scottish university), GDPR Art. 25 lazy evaluation = data minimisation by language semantics, EU AI Act total functions enforce exhaustive error handling |
| KRC | GHC (KRC heritage), Docker | Deploy KRC to Europe → | Invented list comprehensions — David Turner 🇬🇧 (University of Kent Canterbury, 1981), middle step SASL(1972)→KRC(1981)→Miranda(1985)→Haskell(1990), list comprehensions + guard expressions + equation-based pattern matching, Philip Wadler 🇬🇧 "I stole the list comprehension from KRC" → Haskell → Python PEP 202 (2000) → C# LINQ (2008), every [x for x in xs] in Python descends from KRC, University of Kent Canterbury 🇬🇧 British functional programming tradition, lazy evaluation = GDPR Art. 25 data minimisation, pure functions = GDPR Art. 5(2) accountability |
| Concurrent Haskell | GHC (STM, green threads, MVar), Warp | Deploy Concurrent Haskell to Europe → | Invented Software Transactional Memory — Simon Peyton Jones 🏴 (University of Glasgow, 1996), forkIO + MVar (1996) + STM (2005, Harris + Jones + Marlow + Peyton Jones): composable atomic transactions with no locks, no deadlocks, no low-level synchronisation bugs, pure functions = data races impossible by type system (no shared mutable state), GHC green-thread runtime (millions of lightweight threads on N CPU cores, microsecond overhead), lineage: Concurrent Haskell(1996) → STM Haskell(2005) → Clojure STM → Rust memory safety (different path, same insight), Philip Wadler 🇬🇧 (Edinburgh) + John Hughes 🇸🇪 (Chalmers Gothenburg) + Simon Marlow 🇬🇧 (GHC runtime), GDPR Art. 5(1)(f) data integrity by pure function construction, EU AI Act Art. 9 STM transactions = composable formal atomicity proofs, NIS2 concurrent server reliability via GHC runtime |
| Golo | Docker + JDK 21 LTS | Deploy Golo to Europe → | Dynamic JVM language designed from scratch around invokedynamic — Julien Ponge 🇫🇷 (INSA Lyon, 2012), first JVM language that used invokedynamic as its primary dispatch mechanism (not retrofitted), Eclipse Foundation open governance (Brussels 🇧🇪, relocated 2021), augmentations extend existing types without global state mutation (GDPR-safe monkey-patching), closures + higher-order functions + match expressions, radically simple spec, runs on JDK 21 LTS, JVM bytecode verification = formal memory safety, GDPR Art. 25 minimal surface area by design, EU AI Act Art. 9 JVM structured exceptions for risk auditability |
| Component Pascal | GPCP (JVM), Docker | Deploy Component Pascal to Europe → | Wirth-lineage finale — Cuno Pfister 🇨🇭 (Oberon Microsystems AG, Zürich, 1997), Pascal(1970)→Modula-2→Oberon→Oberon-2→Component Pascal, module-as-component model with fine-grained visibility (EXPORT/READWRITE/READONLY), ANYPTR/ANYREC safe polymorphism, single-exit procedures, no mid-body RETURN, GPCP compiles to JVM for Linux deployment, type safety + GC = NIS2 critical infrastructure, module isolation = GDPR Art. 25 by language design, Robert Griesemer 🇨🇭 (Go co-designer) PhD under Wirth — package system inherited from Wirth school |
| Active Oberon | JAOS (JVM), Docker | Deploy Active Oberon to Europe → | Concurrent objects by language design — Pieter Muller 🇨🇭 + Jürg Gutknecht 🇨🇭 (ETH Zürich, 1999), extends Oberon-2 with ACTIVE bodies (own thread), EXCLUSIVE sections (mutual exclusion at procedure level, no locks), AWAIT conditions (formal conditional synchronisation), Bluebottle/A2 OS written entirely in Active Oberon (networking, GUI, file systems — all active objects), JAOS compiles to JVM for Linux deployment, no data races by construction = GDPR Art. 5(1)(f), AWAIT predicates = formal data validity specification, Wirth-Gutknecht ETH Zürich lineage, Go goroutines/channels = different path to same solution |
| GNU Guile (Scheme) | Fibers, (web server), GNU Guix | Deploy GNU Guile to Europe → | Official GNU extension language (R7RS Scheme), Andy Wingo at Igalia 🇪🇸 (La Coruña, Spain — EU cooperative) + Ludovic Courtès 🇫🇷 (INRIA Bordeaux, GNU Guix lead), homoiconic — code is data for auditable GDPR pipelines, Fibers green-thread concurrency (10k+ connections), GNU Guix reproducible builds (Max Planck 🇩🇪 + Institut Pasteur 🇫🇷 deployed), EU AI Act Art. 15 supply chain integrity via Guix, hygienic macros for compile-time data governance enforcement |
| Occam | KRoC (Kent Retargetable occam Compiler), FORK | Deploy Occam to Europe → | CSP-based concurrent language, Tony Hoare 🇬🇧 (Oxford, CSP 1978, Turing Award 1980) + David May 🇬🇧 (Inmos Ltd Bristol, 1983), Transputer hardware → acquired by STMicroelectronics 🇫🇷 (Grenoble, EU Chips Act), XMOS Ltd 🇬🇧 (Bristol, 2005, David May — CSP in modern silicon), KRoC: Peter Welch 🇬🇧 + Fred Barnes 🇬🇧 (University of Kent Canterbury), no shared mutable state → GDPR Art. 5(1)(f) integrity by construction, CSP model checking (FDR4, Roscoe 🇬🇧 Oxford) → EU AI Act Art. 9 formal proof |
| Esterel | esterel compiler → C → gcc, Docker | Deploy Esterel to Europe → | Synchronous reactive programming language, Gérard Berry 🇫🇷 (INRIA Sophia-Antipolis + CMA École des Mines de Paris, 1983), SCADE (Esterel Technologies 🇫🇷 Sophia-Antipolis + Toulouse, 2000 → Ansys) powers Airbus A320/A380 🇫🇷 fly-by-wire FCS (DO-178C Level A) + EDF nuclear 🇫🇷 (IEC 61511) + SNCF TGV 🇫🇷 (EN 50128), synchronous hypothesis: deterministic concurrency (all parallel threads execute within same instant), formal safety proofs → EU AI Act Art. 9, GDPR Art. 5(1)(f) integrity by synchronous semantics, French synchronous school: Esterel + Lustre (Halbwachs 🇫🇷 IMAG Grenoble) + Signal (Le Guernic 🇫🇷 IRISA Rennes) |
| Lustre | Heptagon (INRIA, OCaml), SCADE KCG | Deploy Lustre to Europe → | Synchronous dataflow language, Nicolas Halbwachs 🇫🇷 + Paul Caspi 🇫🇷 (IMAG Grenoble, VERIMAG laboratory, 1984), powers Airbus A320/A380/A350 🇫🇷🇩🇪🇪🇸 fly-by-wire FCS (DO-178C Level A, SCADE KCG qualified generator), TGV/Eurostar train control 🇫🇷 (EN 50128 SIL 4), EDF nuclear reactor safety 🇫🇷 (IEC 61511, 56 reactors), French Synchronous School: Lustre + Esterel (Berry 🇫🇷 INRIA Sophia-Antipolis) + Signal (Le Guernic 🇫🇷 IRISA Rennes), Joseph Sifakis 🇬🇷🇫🇷 (VERIMAG, Turing Award 2007) model checking for Lustre verification, EU AI Act Art. 9 formal guarantees, NIS2 critical infrastructure (aviation/energy/transport), Heptagon (INRIA Paris, OCaml, open-source Lustre dialect, compiles to C) |
| Hope | hope interpreter (GitHub bnoordhuis/hope) | Deploy Hope to Europe → | First algebraic data types + exhaustive pattern matching in PL history, Rod Burstall 🏴 FRS (University of Edinburgh LFCS, 1980) + Dave MacQueen + Don Sannella 🏴, Hope → ML/SML (Milner 🏴 Edinburgh/Cambridge) → OCaml (INRIA 🇫🇷) + Haskell (Glasgow/Edinburgh) + F# (Cambridge) + Rust enums, every match statement in modern code traces to Hope, GDPR Art. 25 ADTs enforce complete explicit data state modelling, EU AI Act Art. 9 exhaustive type checking for risk state coverage |
| CHILL | CHILL compiler (GCC-CHILL), Docker | Deploy CHILL to Europe → | Telecom language, CCITT/ITU-T (Geneva 🇨🇭, 1980), ISO 9496, process model + message signals + real-time timers + strong mode system, powered Ericsson AXE 🇸🇪 (40% of global digital telephone switching capacity, 125+ countries), Siemens EWSD 🇩🇪 (Deutsche Telekom backbone, 160M subscriber lines), Nokia DX 200 🇫🇮, Alcatel S-12 🇫🇷🇧🇪, SS7 signalling + ISDN + early GSM MSC/BSC software — three decades of European telecoms, NIS2 Directive electronic communications sector critical infrastructure, GDPR Art. 5(1)(f) call detail records security |
| LOTOS | CADP toolbox (INRIA Grenoble), CAESAR → C → gcc, Docker | Deploy LOTOS to Europe → | Formal specification language, ISO 8807 (1989), process algebra based on CCS (Milner 🏴 Edinburgh, Turing Award 1991), Francis Boudol 🇫🇷 (INRIA Sophia-Antipolis) + Ed Brinksma 🇳🇱 (University of Twente) + Tommaso Bolognesi 🇮🇹 (CNR Pisa), specified OSI protocol stack (X.25, ISDN Q.931, X.400 mail) for Alcatel 🇫🇷, Philips 🇳🇱, Siemens 🇩🇪, CADP toolbox (Hubert Garavel 🇫🇷, INRIA Grenoble) generates C from LOTOS specs, mCRL2 successor (Jan Friso Groote 🇳🇱, TU/e Eindhoven), E-LOTOS (ISO/IEC 15437:2001) adds real-time + improved ADTs, LOTOS specified the protocols CHILL implemented — formal complement to the EU telecom implementation stack, EU AI Act Art. 9 formal verification, GDPR Art. 25 non-interference proofs, NIS2 protocol conformance evidence |
| E-LOTOS | CADP/LNT toolchain (INRIA Grenoble 🇫🇷), mCRL2 (TU/e Eindhoven 🇳🇱), Docker | Deploy E-LOTOS to Europe → | Enhanced LOTOS — ISO/IEC 15437:2001, Ed Brinksma 🇳🇱 (University of Twente, Enschede), ISO/IEC JTC1/SC7/WG7 chair for both LOTOS (ISO 8807) and E-LOTOS. Solved LOTOS's architectural split between ACT ONE data types and process algebra behaviour by unifying value-passing into process synchronisation: offer !42 (send), offer ?x: Nat (receive), [guard(x)] (conditional receive). Typed value-passing syntax propagated directly into LNT (INRIA Grenoble) and mCRL2 (TU Eindhoven) — E-LOTOS is the ISO-standardised bridge between first-generation LOTOS and modern EU process algebra toolsets. University of Twente FMT group: Jan Tretmans 🇳🇱 (ioco testing theory — conformance testing of reactive systems, TorX+JTorX tools, used by Philips+ASML+NEN); Mariëlle Stoelinga 🇳🇱 (probabilistic model checking, PRISM connections). ETSI 🇫🇷 (Sophia-Antipolis): E-LOTOS standardised contemporaneously with 3GPP UMTS protocol stack standardisation (1997-2001) — RRC, PDCP, RLC protocol machines. Value-passing model used in E-LOTOS influenced LNT (CADP's modern input language) and mCRL2 data integration. Industrial EU: Alcatel 🇫🇷, Nokia Bell Labs 🇫🇮, Ericsson 🇸🇪, Siemens 🇩🇪, Philips 🇳🇱 (all ETSI 3G contributors). IEC 61508 SIL 3/4: ISO-standardised formal specification satisfies "rigorously defined language" requirement. EN 50128 SIL 4: railway safety formal specification. EU AI Act Art. 9: typed value-passing models concurrent AI communication protocols. NIS2: E-LOTOS/ETSI lineage for verified telecom protocol stacks. |
| SIGNAL | Polychrony toolset (INRIA Rennes), SIGNAL → C → gcc, Docker | Deploy SIGNAL to Europe → | Polychronous synchronous language, Pierre Le Guernic 🇫🇷 (IRISA Rennes, 1986), third member of French Synchronous School alongside Esterel (Berry 🇫🇷 INRIA Sophia-Antipolis) + Lustre (Halbwachs 🇫🇷 IMAG Grenoble), clock algebra: signals carry explicit clocks, multi-rate real-time systems (different components at different clock rates), static clock consistency check = formal coherence proof, Polychrony toolset (INRIA Rennes) compiles SIGNAL to C and VHDL (hardware/software co-design), Syndex (INRIA Rennes) maps SIGNAL specs to multi-processor architectures, Thales 🇫🇷 (Thomson-CSF, Rennes defence electronics) + Dassault Aviation 🇫🇷 (Rafale avionics) + CNES 🇫🇷 satellite on-board software, EU AI Act Art. 9 clock coherence = formal safety proof, GDPR Art. 25 clock-domain isolation proves data minimisation, NIS2 multi-rate temporal isolation in critical infrastructure |
| mCRL2 | mCRL2 toolset (TU/e Eindhoven), mcrl22lps → lps2lts → model checking, Docker | Deploy mCRL2 to Europe → | Process algebra toolset for formal verification of concurrent systems, Jan Friso Groote 🇳🇱 (TU/e Eindhoven, 2001), direct successor to LOTOS (ISO 8807) and µCRL (CWI Amsterdam 1994, Groote + Ponse), lineage: ACP (Bergstra + Klop 🇳🇱, CWI 1984) → µCRL → mCRL2, data language based on typed lambda calculus, modal µ-calculus property specification (subsumes LTL + CTL), model checking via PBES (Parameterised Boolean Equation Systems), bisimulation reduction (strong/branching/weak), open-source toolset (Boost licence, TU/e), Philips Healthcare 🇳🇱 + ASML 🇳🇱 (EUV lithography, Veldhoven) + ESA ESTEC 🇳🇱 (Noordwijk), EU AI Act Art. 9 deadlock-freedom proofs, GDPR Art. 25 non-interference via τ-abstraction, NIS2 protocol conformance verification |
| F* | F* compiler → OCaml/C extraction, Dream | Deploy F* to Europe → | Verified functional programming language, Karthikeyan Bhargavan 🇫🇷 (INRIA Saclay/Paris, Prosecco team) + Cédric Fournet 🇫🇷 (MSR Cambridge), refinement types + SMT automation (Z3), miTLS = formally verified TLS 1.2/1.3 (deployed in Firefox via NSS, QUIC), HACL* = verified crypto library (Linux kernel, WireGuard, Signal, Tezos), Project Everest (verified HTTPS stack), eIDAS 2.0 Ed25519 signatures verified end-to-end, EU AI Act Art. 9 machine-checkable safety specifications, NIS2 verified cryptographic baseline |
| Elm | elm make, Go static server | Deploy Elm to Europe → | No-runtime-exceptions frontends, Evan Czaplicki (Prezi 🇭🇺 Budapest), Amsterdam Elm Conference, EU fintech/medtech compliance UIs |
| PureScript | spago + Node.js, httpurple | Deploy PureScript to Europe → | Stricter-than-Haskell compile-to-JS, Phil Freeman 🇬🇧, Harry Garrood 🇬🇧 Edinburgh (Pursuit), Christoph Hegemann 🇩🇪 (psc-ide), row polymorphism for GDPR-safe data pipelines |
| D | vibe.d, DUB, LDC compiler | Deploy D to Europe → | Systems-language backends, Andrei Alexandrescu 🇷🇴 (Romanian, D co-designer), Martin Nöhring 🇩🇪 (Sociomantic Berlin, D Language Foundation), @safe/@nogc for EU compliance |
| Vala | libsoup, GLib/GObject, Meson | Deploy Vala to Europe → | GNOME-native backends, Jürg Billeter 🇨🇭 (Swiss, Vala creator, GNOME Project), Emmanuele Bassi 🇮🇹 (GNOME Foundation), compiles-to-C zero runtime, D-Bus/systemd integration |
| Raku | Cro HTTP, zef, MoarVM | Deploy Raku to Europe → | Gradual typing + grammar system, Jonathan Worthington 🇬🇧 (MoarVM + Cro, edument Sweden 🇸🇪), Carl Mäsak 🇸🇪 (Swedish, Advent Calendar), multiple dispatch, PEG parsers built-in |
| Futhark | Python bindings, FastAPI, futhark-pycffi | Deploy Futhark to Europe → | GPU array programming, Troels Henriksen 🇩🇰 (DIKU Copenhagen, Futhark creator), Martin Elsman 🇩🇰 + Cosmin Oancea 🇷🇴 (DIKU), automatic parallelisation, size-polymorphic types, EU-origin GPU language |
| Koka | Node.js backend, C backend, std/net/http | Deploy Koka to Europe → | Algebraic effects language, Daan Leijen 🇳🇱 (Dutch, Microsoft Research), effect types track side effects in compiler, Perceus reference counting (no GC pauses), EU-origin: Plotkin 🇬🇧 Edinburgh + Pretnar 🇸🇮 Ljubljana theory |
| Eff | OCaml backend, Dream HTTP, Docker | Deploy Eff to Europe → | First algebraic effects language (2011), Andrej Bauer 🇸🇮 + Matija Pretnar 🇸🇮 (University of Ljubljana), ERC-funded EU research, delimited continuations, non-determinism, direct predecessor of Koka/Frank/Effekt, Ljubljana–Edinburgh axis |
| Red | Native binary, Docker scratch, Red/System | Deploy Red to Europe → | Fullstack native language, Nenad Rakočević 🇷🇸 (Serbian, Belgrade, EU accession candidate), single-binary deployment (no runtime VM), Parse dialect for GDPR data pipelines, Red/System C-level sublanguage, REBOL-inspired homoiconic design |
| Unison | UCM, native binary, Docker | Deploy Unison to Europe → | Content-addressed distributed language, Rúnar Bjarnason 🇮🇸 (Icelandic, EEA member) + Paul Chiusano 🇺🇸, every function identified by definition hash (no dependency hell), abilities = algebraic effects (type-safe GDPR pipelines), native distributed computation, Iceland = full EEA GDPR coverage |
| Perl / Mojolicious | Mojolicious, Hypnotoad, Mojo::Pg | Deploy Perl to Europe → | Real-time web framework, Sebastian Riedel 🇩🇪 (German, Mojolicious creator), zero non-core dependencies, built-in async HTTP server (Hypnotoad), EU enterprise Perl modernisation (banking, logistics, bioinformatics, EMBL Heidelberg) |
| Tcl | NaviServer, Wapp, Pgtcl | Deploy Tcl to Europe → | Scripted web backends, Jan Nijtmans 🇳🇱 (Dutch, Tcl Core Team), Alexandre Ferrieux 🇫🇷 (French), Harald Oehlmann 🇩🇪 (German), CERN LHC accelerator control systems, ESA spacecraft testing, EU semiconductor EDA scripting (Infineon/NXP/STMicro), Tcl 9.0 Unicode 15 + native coroutines |
| Pike | Protocols.HTTP.Server, Caudium, Sql.pmod | Deploy Pike to Europe → | C-like scripted web backends, Fredrik Hübinette 🇸🇪 (Swedish, Linköping University, Pike creator), Martin Stjernholm 🇸🇪 (Swedish, Pike core), Roxen Internet Software 🇸🇪 (Roxen web server powered Nordic/EU media infrastructure), built-in PostgreSQL + POSIX threads + async I/O |
| Logtalk | SWI-Prolog HTTP, ECLiPSe, SICStus | Deploy Logtalk to Europe → | Object-oriented logic programming, Paulo Moura 🇵🇹 (Portuguese, University of Beira Interior, FCT-funded), ISO Prolog compatible (SWI-Prolog/ECLiPSe/SICStus/GNU Prolog), inherent EU AI Act explainability via proof traces, GDPR rule encoding as auditable logic clauses |
| COBOL | GnuCOBOL + libmicrohttpd, ESQL | Deploy COBOL to Europe → | EU banking & financial workloads, MicroFocus (Cambridge 🇬🇧) world-dominant COBOL toolchain, Simon Sobisch 🇩🇪 (German GnuCOBOL maintainer), Deutsche Bundesbank/Société Générale/ING run trillions EUR daily in COBOL, MiFID II + DORA + PSD2 + GDPR compliance, native COMP-3 decimal arithmetic |
| ABAP | SAP BTP, OData REST, abapGit | Deploy ABAP to Europe → | SAP enterprise ERP backend, SAP SE founded 1972 Walldorf 🇩🇪 (Dietmar Hopp/Hasso Plattner/Hans-Werner Hector/Claus Wellenreuther/Klaus Tschira — all 5 founders German), powers BMW/Siemens/VW/Airbus/Deutsche Telekom, EU Taxonomy Regulation ESG reporting, GDPR ILM built-in, MiFID II + DORA compliance |
| Seed7 | Compiled binary + nginx | Deploy Seed7 to Europe → | Extensible general-purpose language, Thomas Mertes 🇩🇪🇦🇹 (German-Austrian, Linz, Austria), compiles to C, stronger type system than C++ or Java with first-class operator overloading and user-definable syntax, 30+ years development, GDPR-aligned type safety (data-classification at compile time), EU AI Act auditability via C output |
| Simula | GNU Cim, compiled binary + nginx | Deploy Simula to Europe → | The first object-oriented programming language, Ole-Johan Dahl 🇳🇴 + Kristen Nygaard 🇳🇴 (Norsk Regnesentral, Oslo — Norwegian Computing Center), invented classes/objects/inheritance/coroutines in 1967, Turing Award 2001, direct ancestor of C++ (Stroustrup 🇩🇰) / Eiffel (Meyer 🇫🇷) / Scala (Odersky 🇩🇪), compiles to C via GNU Cim, Norway = EEA GDPR coverage |
| BETA | gbeta compiler, C backend | Deploy BETA to Europe → | Scandinavian OOP successor to Simula, Ole Lehrmann Madsen 🇩🇰 (Aarhus University) + Birger Møller-Pedersen 🇩🇰 + Kristen Nygaard 🇳🇴 (Oslo, Simula co-inventor, Turing Award 2001), 1983, Pattern concept unifies class/method/exception/co-routine into one abstraction, prefix inheritance (inner) enforces contracts sub-patterns cannot bypass, virtual patterns → Scala abstract type members (via Erik Ernst 🇩🇰 gbeta + family polymorphism), gbeta native binary via C, Denmark (EU) + Norway (EEA GDPR) |
| Sather | GNU Sather → C → binary | Deploy Sather to Europe → | Eiffel successor with Design by Contract + iterators, Stephan Murer 🇩🇪 + Clemens Szyperski 🇩🇪 (Universität Passau → ICSI Berkeley, 1990), iterators (! suffix + yield) predate Python generators by a decade, Design by Contract (pre/post/invariant) = GDPR Art. 25 by compiler, multiple inheritance linearisation → Python MRO, GNU Sather compiles to C, Szyperski "Component Software" (Addison-Wesley) = foundational EU software architecture text |
| ABC | abc interpreter (apt install abc) | Deploy ABC to Europe → | Python's direct predecessor, Lambert Meertens 🇳🇱 + Leo Geurts 🇳🇱 + Steven Pemberton 🇬🇧 (CWI Amsterdam, 1987), Guido van Rossum implemented ABC at CWI before designing Python, Python's indentation syntax + workspace REPL + high-level data structures all originate in ABC, same CWI Amsterdam institution as ALGOL (Dijkstra + van Wijngaarden), Bird-Meertens Formalism (Squiggol) for algorithm derivation, strong typing without declarations |
| Ballerina | GraalVM native or JVM | Deploy Ballerina to Europe → | Network-native cloud language, architected by James Clark 🇬🇧 (creator of XML/XSLT/XPath/RelaxNG — EU e-government standards), REST/GraphQL/gRPC built into type system, JSON and XML as native types, auto-generates OpenAPI specs and sequence diagrams for EU AI Act + DORA compliance, Apache 2.0, WSO2 European offices |
| Oberon | Oberon+ HTTP, gm2 | Deploy Oberon to Europe → | Minimal footprint backends, Niklaus Wirth 🇨🇭 (ETH Zürich, Turing Award 1984), Go's module system ancestor |
| Oberon-2 | OBNC (Oberon-2 to C), Docker | Deploy Oberon-2 to Europe → | OOP extension of Oberon — Niklaus Wirth 🇨🇭 + Hanspeter Mössenböck 🇦🇹 (ETH Zürich/JKU Linz, 1991), type-bound procedures (methods on records), read-only exported fields, OBNC compiles to C for native Linux deployment, Component Pascal + BlackBox Component Framework (Oberon Microsystems Zürich), Active Oberon concurrent objects (A2 OS, ETH Zürich), Mössenböck's Compiler Construction textbook = standard across EU university curricula |
| Concurrent Pascal | Free Pascal (FPC) + SyncObjs, Docker | Deploy Concurrent Pascal to Europe → | First high-level concurrent programming language with built-in monitors — Per Brinch Hansen 🇩🇰 (Technical University of Denmark DTU Lyngby, 1975), monitor concept co-invented with Tony Hoare 🇬🇧 (Oxford) — Java synchronized (1996) + Python threading.Condition + Go sync.Mutex + Rust Mutex<T> all trace to this, Solo OS (1976) = first OS written entirely in a high-level language, RC 4000 nucleus (Regnecentralen Copenhagen) = microkernel precursor, GDPR Art. 5(1)(f) mutual exclusion by construction, NIS2 race-condition-free concurrent critical infrastructure |
| SPARK Ada | GNAT + GNATprove + gprbuild, Docker | Deploy SPARK Ada to Europe → | Formally verifiable subset of Ada — Bernard Carré 🇬🇧 (Program Validation Limited, University of Southampton, 1988), Rod Chapman 🇬🇧 (Praxis → AdaCore, SPARK 2014 lead), Yannick Moy 🇫🇷 (AdaCore Paris, GNATprove lead), AdaCore HQ: Paris 🇫🇷 — GNATprove proves absence of runtime errors + functional correctness via SMT solvers (Z3 + Alt-Ergo 🇫🇷 INRIA/OCamlPro) before compilation, Why3 intermediate language (INRIA Saclay 🇫🇷 Filliâtre + Marché), used in Airbus A350 🇫🇷 DO-178C Level A + EUROCONTROL 🇧🇪 SESAR ATM + Rolls-Royce FADEC 🇬🇧 + MBDA 🇫🇷🇬🇧🇩🇪 + Siemens Mobility EN 50128 SIL 4 🇩🇪, EU AI Act Art. 9 formal proof evidence, DORA ICT resilience, information flow analysis for GDPR Art. 25 data minimisation |
| Free Pascal | fpWeb, synapse | Deploy Free Pascal to Europe → | DACH enterprise backends, Niklaus Wirth 🇨🇭 (Pascal 1970) + Anders Hejlsberg 🇩🇰 (Turbo Pascal 1983) + Florian Klämpfl 🇩🇪 (FPC) |
| REXX / NetRexx | NetRexx JVM, IBM ooRexx | Deploy REXX/NetRexx to Europe → | EU banking operational backbone, Mike Cowlishaw 🇬🇧 (IBM Hursley Park, Winchester, England, 1979), z/OS REXX automates SEPA payment rails at Deutsche Bank 🇩🇪 + BNP Paribas 🇫🇷 + ING 🇳🇱, NetRexx compiles to JVM bytecode, DORA operational resilience automation, MiFID II compliance pipelines |
| PL/I | Iron Spring PL/I (Linux x86-64), Docker | Deploy PL/I to Europe → | IBM 1964 enterprise language — hidden EU chapter: IBM Vienna Research Laboratory 🇦🇹 (Dines Bjørner 🇩🇰 DTU Copenhagen + Peter Lucas 🇦🇹 + Hans Bekič 🇭🇷 Zagreb) invented Vienna Definition Language (VDL) to formally specify PL/I semantics → VDM (Vienna Development Method, ISO 13817-1) still used in DO-178C avionics + ISO 26262 automotive + EU AI Act Art. 9 risk management today, PL/I remains EU banking backbone on IBM z/OS: Deutsche Bank 🇩🇪 + BNP Paribas 🇫🇷 + Société Générale 🇫🇷 + ING 🇳🇱 process trillions EUR in PL/I, FIXED DECIMAL arithmetic = exact decimal for SEPA/MiFID II, ECMA-50 (Geneva 🇨🇭, 1976) + ISO 6160 standardised, ON condition exception handling = first mainstream exception system |
| POP-2 / Poplog | GNU Poplog (MIT licence, Linux x86-64), POP-11, Common Lisp, ML, Prolog | Deploy POP-2 to Europe → | First UK/EU language designed specifically for AI — Robin Popplestone 🏴 + Rod Burstall 🏴 (University of Edinburgh 1966), COWSEL (1966) → POP-2 (1970) → POP-11/Poplog, stack-based execution + first-class functions + pattern matching, Freddy II robot = first EU autonomous assembly robot, Edinburgh lineage: Robin Milner's ML (Hindley-Milner type inference → OCaml/Haskell/Rust) + Edinburgh Prolog (Warren Abstract Machine, David Warren 🇬🇧), GNU Poplog = multi-language VM (POP-11 + Common Lisp + Standard ML + Prolog in one system), EU AI Act Art. 13 explainability = symbolic AI advantage, open-source since 2020 |
| BCPL | Martin Richards' reference impl (C backend) | Deploy BCPL to Europe → | Direct ancestor of C, Martin Richards 🇬🇧 (University of Cambridge Mathematical Laboratory, 1967), BCPL → B (Ken Thompson, Bell Labs 1969) → C (Dennis Ritchie 1972) → C++/Java/Go/Rust, introduced // comments and {} block syntax, O-code portable intermediate representation (precursor to JVM bytecode), still maintained by Martin Richards at Cambridge, GDPR Art. 5(1)(f) predictable memory model |
| Modula-2 | GNU Modula-2 (gm2, part of GCC 13+) | Deploy Modula-2 to Europe → | Invented the module system, Niklaus Wirth 🇨🇭 (ETH Zürich, Turing Award 1984, 1978), definition/implementation separation → Go packages/TypeScript modules/Rust crates, Lilith workstation (ETH Zürich, 1980), GDPR Art. 25 privacy-by-design via module boundary enforcement, Robert Griesemer (Go co-designer) PhD under Wirth at ETH Zürich |
| Modula-3 | cm3 (Critical Mass Modula-3, open-source, Linux/amd64), Docker | Deploy Modula-3 to Europe → | The type-safe GC language that taught Java everything — Luca Cardelli 🇮🇹 (Olivetti Research Centre, Cambridge 🇬🇧, 1988) + Mick Jordan 🇬🇧 + DEC SRC team, first mainstream language to prove GC + static typing are compatible at systems performance, interfaces (opaque types) → Java interface keyword, LOCK/MUTEX standard library → Java synchronized, TRY/EXCEPT/FINALLY checked exceptions → Java throws, Cardelli's type theory (System F<:, subtype polymorphism, 1985–1994) at MSR Cambridge → TypeScript's entire type system, cited by James Gosling in Java Language Specification, Anders Hejlsberg 🇩🇰 built C# on the Java/Modula-3 lineage, Olivetti (Ivrea, Turin 🇮🇹) = Italian tech pioneer (first personal computer Programma 101, 1965), GDPR Art. 25 opaque types enforce information hiding at compile time, EU AI Act Art. 9 checked exceptions require exhaustive error handling proof |
| Plankalkül | Plankalkül interpreter (TU Berlin reference impl, Python 3) | Deploy Plankalkül to Europe → | The first programming language ever designed — Konrad Zuse 🇩🇪 (Berlin, 1942–1945), designed on the Z3 (world's first programmable electromechanical computer), before ENIAC, before von Neumann's architecture paper, before stored-program theory — Zuse designed typed variables, nested composite data structures (Komponenten), loops, conditionals, subroutines, and wrote the world's first chess program in 1945, Plankalkül → ALGOL lineage (Rutishauser 🇨🇭 ETH Zürich read Zuse's manuscripts), Zuse-Institut Berlin (ZIB) active today (Coxeter Groups, computational geometry, combinatorial optimization), Deutsches Museum (Munich) preserved original Z3 reconstruction |
| ALGOL | Algol 68 Genie (algol68g, apt install) | Deploy ALGOL to Europe → | Ancestor of all structured languages, Peter Naur 🇩🇰 (Copenhagen, Turing Award 2005), Edsger Dijkstra 🇳🇱 (CWI Amsterdam, Turing Award 1972), Adriaan van Wijngaarden 🇳🇱 (CWI Amsterdam, ALGOL 68), Friedrich Bauer 🇩🇪 (TH Munich), BNF invented for ALGOL 60 — used in every language spec since 1960, block structure + lexical scoping → all modern languages, ALGOL → Pascal → Modula-2 → Go, ALGOL → Simula → all OOP, ALGOL → BCPL → C |
| ALGOL 68 | algol68g (Marcel van der Vegt 🇳🇱, apt install), Docker | Deploy ALGOL 68 to Europe → | The most mathematically rigorous language of its era — Adriaan van Wijngaarden 🇳🇱 (CWI Amsterdam / Mathematisch Centrum, 1968), IFIP WG 2.1 — invented operator overloading (1968, 15 years before C++), PAR parallel primitives (before Go goroutines), W-grammars (two-level grammars = first unambiguous formal language definition), orthogonal mode system (REF/PROC/FLEX → influenced C declarations + Ada strong typing), Lambert Meertens 🇳🇱 (CWI, ABC → Python) + Guido van Rossum 🇳🇱 (CWI, Python) from same institution, GDPR Art. 25 compositional data access by mode system, NIS2 language-level PAR/SEMA synchronisation |
| ALGOL W | ALGOL W compiler (C backend, gcc), Docker | Deploy ALGOL W to Europe → | The missing link between ALGOL 60 and Pascal — Niklaus Wirth 🇨🇭 (ETH Zürich, Turing Award 1984) + Tony Hoare 🇬🇧 (Oxford, Turing Award 1980), Stanford 1966, introduced records/variant fields (first struct type), first built-in string type, while loops, case statements — all ideas Wirth carried into Pascal (1970) when ALGOL committee rejected ALGOL W in favour of ALGOL 68, Hoare's null reference invented here ("billion-dollar mistake"), Hoare Logic (1969) born from ALGOL W formalisation → EU AI Act Art. 9 formal verification today, ALGOL W → Pascal → Turbo Pascal (Hejlsberg 🇩🇰) → Delphi → C# → TypeScript |
AI & Emerging
| Language | Framework | Guide | Use Case |
|---|---|---|---|
| Any language | Claude, LangChain, LangGraph | Deploy an AI Agent to Europe → | GDPR-compliant AI apps, agent memory in EU |
Alternative Hosting Comparisons
- Railway Alternative: EU-Native Hosting → — Why developers switch from Railway to sota.io
- Why EU Developers Are Leaving Vercel → — The EU data residency argument
- Deploy Node.js in 5 Minutes → — Quickstart for new users
- Managed PostgreSQL in Europe → — GDPR-compliant database hosting included with every project
What All These Guides Have in Common
Every language on this list deploys the same way on sota.io:
- Write a Dockerfile (or use our language-specific templates)
sota deploy— single CLI command, deploys from your local directory- Automatic TLS — HTTPS certificate provisioned within seconds
- Managed PostgreSQL —
DATABASE_URLinjected automatically if you need a database - EU data residency — Hetzner Germany, no configuration required
The deployment command is identical whether you're shipping a Rust binary or a Laravel application. The infrastructure is the same. The pricing is the same. The only thing that changes is your Dockerfile.
Pricing That Doesn't Scale Against You
Most PaaS platforms use metered pricing that becomes expensive as you grow. sota.io uses flat-rate pricing:
- Starter: €5/month — 512 MB RAM, 1 vCPU, 10 GB storage
- Pro: €9/month — 2 GB RAM, 2 vCPU, 50 GB storage, managed PostgreSQL included
No egress fees. No per-request pricing. No "compute units" that reset monthly. For most European startups and SaaS applications, the €9 Pro plan covers everything — application, database, and TLS, in Germany.
EU Compliance: What You Get by Default
Deploying on sota.io means:
- GDPR Article 28 compliance — Data processor agreement (DPA) available on request
- No US Cloud Act exposure — No US corporate parent, no CLOUD Act jurisdiction
- Data residency in Germany — Hetzner Frankfurt, EU territory
- No third-party analytics — We don't inject tracking into your app
- ISO 27001 infrastructure — Hetzner's certification covers the physical layer
For regulated industries, these are not optional — they are the baseline requirements for going to production.
Choosing the Right Language for Your EU Project
If you're starting a new project and haven't committed to a language yet, here's a quick decision tree based on European market realities:
Enterprise / Banking / Insurance (DACH): Java Spring Boot, Kotlin Ktor, or Scala/Play. The JVM is the lingua franca of DACH enterprise. Java and Spring Boot for existing teams; Scala for type-safety-critical systems (risk calculation, derivatives pricing); Kotlin for modern JVM microservices. BaFin-regulated applications commonly run on all three.
FinTech / Risk Systems (Frankfurt, Nordics): Scala with ZIO or Play Framework. Deutsche Bank, Zalando, and ING run Scala for good reason — the type system makes financial domain errors compile-time impossible. Also consider Haskell/Servant for formal correctness requirements.
SaaS / Startup (Europe-wide): Node.js, Python (FastAPI), or Go. These have the best hiring pools across the EU, the largest framework ecosystems, and the fastest time-to-market.
High-performance APIs: Go or Rust. Go for team productivity, Rust for extreme throughput or memory-safety requirements.
C Replacement / Industrial IoT: Zig. If your team writes C for embedded systems and needs a backend service that calls C libraries natively, Zig gives you explicit memory management without the borrow checker complexity. Common in DACH industrial automation (Siemens, Bosch, Beckhoff) and EU medical device software (EU MDR compliance).
Real-time Applications: Elixir/Phoenix. The BEAM VM's fault tolerance and soft-real-time scheduling are unmatched for WebSocket-heavy applications.
Modern TypeScript: Deno 2.0 or Bun. Both support TypeScript natively without transpilation — Deno for correctness-first teams, Bun for maximum performance.
Android Backend: Kotlin/Ktor. If your team already writes Kotlin for Android, Ktor lets them share domain models and business logic with the backend without a language switch.
iOS Backend: Swift/Vapor. If your team writes Swift for iOS, Vapor 4 lets you run the same language, same async/await model, and shared domain models on the backend. Native binary performance, no JVM overhead.
Flutter Backend: Dart/Dart Frog. If your team writes Flutter, Dart Frog enables full-stack Dart — shared types, same null-safety, same async model. AOT-compiled binary, no Dart VM in production.
Ruby Developer, Performance Bottleneck: Crystal/Kemal. Ruby syntax, static typing, compiled to native code via LLVM. ~8 MB memory, ~45,000 req/sec. Migrate service-by-service without a language switch.
Gradle/Spring-Adjacent JVM Teams: Groovy/Micronaut. If your team already uses Groovy for Gradle build scripts or testing (Spock Framework), Micronaut is a natural backend choice — full Spring-compatible annotations, compile-time DI, and GraalVM native image support. Startup time under 100ms, Docker image under 50 MB with GraalVM. Groovy's dynamic typing reduces boilerplate without leaving the JVM. Common in DACH enterprises that run Jenkins pipelines and want a lightweight alternative to Spring Boot for new microservices.
Legacy PHP Modernization: Laravel on sota.io. PHP 8.3 with Laravel 11 is a serious production stack — don't let the ecosystem's age fool you.
EU FinTech / Quant Finance (INRIA lineage): OCaml/Dream. OCaml was created at INRIA in France — it is literally a European language. Jane Street's trading infrastructure runs on OCaml for the same reason EU quant teams adopt it: algebraic data types with exhaustive pattern matching eliminate an entire class of financial logic bugs at compile time. OCaml 5 Multicore removes the GIL and adds effect handlers for structured concurrency. For Swiss/Austrian FinTech teams, INRIA-adjacent research, and EU derivatives desks, OCaml on sota.io satisfies both the technical requirement (native binaries, predictable latency) and the compliance requirement (EU data residency, no Cloud Act exposure).
Fintech / Correctness-Critical APIs: Haskell/Servant or F#/Giraffe. Haskell for maximum type-system guarantees — standard in London/Nordics financial services for pricing engines and risk models. F# for teams that need functional programming with full .NET ecosystem access — Nordea and Nordics quantitative finance teams commonly use F# for type-provider-based market data pipelines and domain-modeled financial instruments.
Functional .NET (Azure-to-EU migration): F#/Giraffe. Teams migrating from Azure to EU-native hosting can keep their .NET stack while switching to a functional-first language. F# type providers generate typed bindings to PostgreSQL schemas at compile time — zero schema drift, zero manual serialization.
Get Started in 5 Minutes
Pick your language from the table above, follow the guide, and you'll have your application running in Europe before the end of the day.
If you don't see your language listed, reach out — we support any containerized workload. If it runs in Docker, it deploys on sota.io.
This guide is maintained by the sota.io team. Last updated: April 2026 (162 languages).