Skip to content

ESBMC

NEW: 515 commits landed on master between 13 and 27 October, about three in five in the Python frontend. Read the development update.

ESBMC is a mature, permissively licensed open-source SMT-based context-bounded model checker for single and multi-threaded C, C++, CUDA, CHERI-C, Java, Kotlin, Python, and Solidity programs. It automatically detects or proves the absence of runtime errors (e.g., bounds checks, pointer safety, overflow) and verifies user-defined assertions without requiring pre- or postconditions. For multi-threaded programs, ESBMC supports lazy and schedule-recording approaches, encoding verification conditions into SMT formulas solved directly by an SMT solver.

Download

Features

ESBMC detects errors by symbolically executing a finite prefix of the program for all possible inputs. Its frontends and encodings are:

  • The Clang compiler as its C/C++/CUDA frontend, and CHERI Clang for CHERI-C (CHERI-C needs a separate ESBMC build; see the Build Guide);
  • The Soot framework via Jimple as its Java/Kotlin frontend;
  • The ast and ast2json modules as its Python frontend; the first SMT-based bounded model checker for Python programs;
  • Implements the Solidity grammar production rules as its Solidity frontend;
  • IEEE 754 floating-point arithmetic, encoded in the solver’s floating-point theory or, for solvers without one, as bit-vectors.

ESBMC implements bounded model checking (BMC), incremental BMC and k-induction on top of Satisfiability Modulo Theories (SMT) solvers.

We provide some background material/publications to help you understand what ESBMC can offer. These are available online. For further information about our main components, check the ESBMC architecture.

SV-COMP History

ESBMC SV-COMP overall score history

Overall SV-COMP score over time, by per-benchmark time budget.

Applications

ESBMC has been used in a broad range of cutting-edge applications across multiple domains. If you applied ESBMC in your research, but it is not mentioned below, please, do not hesitate to contact us through our GitHub repository.

CBMC Differences

ESBMC and CBMC share a common ancestry but have diverged substantially. The list below reflects ESBMC 8.6 and contrasts it with mainline CBMC.

Frontends and language support.

  • ESBMC uses the Clang/LLVM frontend for C (up to C23), C++ (up to C++20, with selected C++23 features), CUDA and CHERI-C, inheriting Clang’s diagnostics, attribute handling and template instantiation. CBMC uses its own in-tree C and C++ parsers.
  • ESBMC ships dedicated frontends for Python 3.10+ (the first BMC-based Python-code verifier), Solidity (smart contracts) and Kotlin/Java (via the Soot/Jimple IR). CBMC supports only C/C++ in the main tool; Java is handled by the separate JBMC tool, and Rust by Kani, which builds on CBMC.

Verification backend.

  • ESBMC encodes programs directly into SMT and supports multiple solver backends — Z3, Bitwuzla (the default when it is built in), Boolector, CVC4/CVC5, Yices, MathSAT and any SMT-LIB v2 solver — using native theories for arrays, bit-vectors, floating-point and quantifiers. CBMC’s default backend is a SAT solver over a bit-blasted encoding, with SMT solvers as an alternative.
  • ESBMC integrates an interval abstract domain into symbolic execution. It stops unwinding a loop when the intervals prove the loop exits (on by default in plain BMC; disable with --no-interval-symex-guard) and can skip assertions the intervals prove (--interval-symex-assert). Both reduce the size of the SMT formula handed to the solver.

Proof techniques.

  • ESBMC implements incremental BMC, k-induction and bidirectional k-induction in a single invocation, combining base-case, forward-condition and inductive-step checks in one run.
  • ESBMC supports function contracts (__ESBMC_requires, __ESBMC_ensures, __ESBMC_assigns) and loop invariants (__ESBMC_loop_invariant), which it can both check and use in place of the code they describe.

Concurrency verification.

  • ESBMC explores thread interleavings explicitly under context-bounded verification, with both lazy and schedule-recording exploration strategies and a partial-order reduction (POR) pass that prunes independent interleavings.
  • ESBMC ships models for POSIX threads, C11 atomics and a subset of std::thread / std::atomic, and can verify safety, deadlock and data-race properties.

Memory safety and floating-point.

  • A byte-precise memory model with object-level pointer analysis lets ESBMC check pointer-safety, array bounds, use-after-free, double-free and memory leaks across heap and stack. Floating-point follows IEEE 754, through the solver’s floating-point theory by default or through a bit-vector encoding (--fp2bv) for solvers without one.

Operational models and library support.

  • ESBMC ships operational models for the C standard library (compiled to GOTO by c2goto), large parts of the C++ standard library (containers, iterators, algorithms, strings), and Python built-ins and modules (lists, dicts, strings, enum, math, re and others, written in Python). Code that uses the modelled parts of these libraries can be verified without writing stubs.

Recent competition results and industrial use.

  • ESBMC-kind placed 2nd in ReachSafety at SV-COMP 2025 and 2026. At Test-COMP, FuSeBMC, a test generator built on ESBMC, placed 1st Overall every year from 2022 to 2026, 1st in Cover-Error in each of those years, and 1st in Cover-Branches in every year except 2025 (2nd).
  • Applications include the verification of Arm’s Realm Management Monitor in the Confidential Computing Architecture (SAS 2024), Ethereum smart-contract auditing (ICSE 2022), Arduino-based embedded firmware (SBESC 2023), the Ethereum Consensus Specification (ISSTA 2024) and the ESBMC-AI pipeline that pairs LLMs with the model checker to repair code.

SPARK Ada Differences

ESBMC is sometimes compared with SPARK (GNATprove and the SPARK Ada subset), which targets a different region of the verification design space. The main differences are:

Verification methodology.

  • ESBMC is a bounded model checker: it symbolically executes a finite prefix of the program and encodes the resulting verification conditions as SMT. Within the bound, it finds every reachable violation of the checked properties. A proof for all executions requires either that the bound covers every execution (no unwinding assertion fails) or that k-induction converges.
  • SPARK is a deductive verifier: GNATprove translates Ada units to Why3, derives Hoare-style verification conditions from user-supplied contracts, and discharges them with SMT solvers (Alt-Ergo, CVC5, Z3) or, for hard goals, interactive provers (Coq/Isabelle). It proves unbounded functional correctness rather than searching for counterexamples.

Supported languages.

  • ESBMC: C (up to C23), C++ (up to C++20, with selected C++23 features), CUDA, CHERI-C, Python, Solidity, Kotlin, Java.
  • SPARK: a strict subset of Ada 2012/2022 that forbids exceptions, controlled types, side-effects in functions and unrestricted aliasing, with optional escape hatches via SPARK_Mode => Off.

Annotation requirements.

  • ESBMC verifies code essentially as-is: built-in safety properties (pointer safety, overflow, bounds, leaks, data races) are checked automatically; user-defined assertions need only assert or __ESBMC_assert. Loop invariants are optional; --interval-analysis infers interval invariants and adds them as assumptions. When annotations are supplied — __ESBMC_requires / __ESBMC_ensures for pre/post-conditions, __ESBMC_assigns for frame conditions, __ESBMC_loop_invariant for loop invariants, and __ESBMC_contract to mark functions for --enforce-all-contracts and --replace-all-contracts — ESBMC uses them to verify the implementation against its contract and to replace call sites with the contract, which supports compositional verification (see Function Contracts).
  • SPARK proofs depend on the programmer authoring Pre, Post, Contract_Cases, Loop_Invariant, Loop_Variant, Global and Depends aspects. Without these contracts, GNATprove can only prove Ada’s built-in run-time checks (the “Bronze” level).

Automation level.

  • ESBMC is push-button: one invocation reports VERIFICATION SUCCESSFUL, VERIFICATION FAILED (with a counterexample trace), VERIFICATION UNKNOWN (neither proved nor refuted, e.g. when k-induction does not converge), or stops at its time or memory limit.
  • SPARK is mostly automatic through the Silver (absence of run-time errors) and Gold (key integrity properties) levels, given suitable contracts. Reaching the Platinum level — full functional correctness — typically requires iterative contract refinement and occasionally manual proof via Coq/Isabelle through Why3.

Memory and concurrency verification.

  • ESBMC reasons about heap-allocated data structures, pointer arithmetic and aliasing through its byte-level memory model, up to the unwinding bound, and verifies multi-threaded code (POSIX threads, C11 atomics, std::thread) by exploring interleavings, optionally context-bounded, with POR.
  • SPARK relies on a static ownership and borrowing discipline (Ada 2022) to rule out aliasing rather than reason about it, and restricts concurrency to the Ravenscar/Jorvik profiles (statically scheduled tasks, no dynamic allocation of tasks, bounded protected objects). This makes proofs tractable but excludes idiomatic concurrent C/C++ patterns.

Target domains and typical use cases.

  • ESBMC: research, operating-system and firmware verification (e.g. Arm RMM/CCA), smart-contract auditing, embedded/IoT and Arduino, safety-critical C/C++ in industry, ML/AI safety, and education.
  • SPARK: avionics (DO-178C up to Level A), defence, rail signalling (EN 50128 SIL 4), space and security-evaluated software (Common Criteria) — domains where Ada is mandated and full functional proof of contracts is required by certification.

Strengths and limitations.

AspectESBMCSPARK Ada
StrengthsPush-button, multi-language, produces counterexample traces, handles C/C++ pointers, heap and threadsStrong functional-correctness guarantees, mature tooling for certification, sound by construction
LimitationsBounded by default; full proofs require k-induction convergence; counterexamples may be spurious if models are abstractedRestricted language subset; effort-intensive contract authoring; weak support for dynamic aliasing and unstructured concurrency

Recent Applications (2022-2024)

Earlier Applications

Sponsors

Sponsored by Cyber Reasoning

Cite

If you cite ESBMC >= version 7.4, please use the competition paper at TACAS 2024 (BibTex) as listed below:

@InProceedings{esbmc2024,
    author    = {Rafael Menezes and
                 Mohannad Aldughaim and
                 Bruno Farias and
                 Xianzhiyu Li and
                 Edoardo Manino and
                 Fedor Shmarov and
	         Kunjian Song and
	         Franz Brauße and
	         Mikhail R. Gadelha and
	         Norbert Tihanyi and
	         Konstantin Korovin and
	         Lucas C. Cordeiro},
    title     = {{ESBMC} 7.4: {H}arnessing the {P}ower of {I}ntervals},
    booktitle = {$30^{th}$ International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS'24)},
    series       = {Lecture Notes in Computer Science},
    volume       = {14572},
    pages     = {376–380},
    doi       = {https://doi.org/10.1007/978-3-031-57256-2_24},
    year      = {2024},
    publisher = {Springer}
}