{"id":14991198,"url":"https://github.com/seahorn/seahorn","last_synced_at":"2025-05-15T12:02:43.377Z","repository":{"id":27993361,"uuid":"31487486","full_name":"seahorn/seahorn","owner":"seahorn","description":"SeaHorn Verification Framework","archived":false,"fork":false,"pushed_at":"2025-03-03T12:08:47.000Z","size":7823,"stargazers_count":446,"open_issues_count":28,"forks_count":131,"subscribers_count":19,"default_branch":"main","last_synced_at":"2025-04-14T19:59:24.508Z","etag":null,"topics":["abstract-interpretation","horn-clauses","llvm","model-checking","program-analysis","static-analysis","verification"],"latest_commit_sha":null,"homepage":"http://seahorn.github.io/","language":"C","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/seahorn.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"license.txt","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2015-03-01T05:08:17.000Z","updated_at":"2025-04-08T07:39:48.000Z","dependencies_parsed_at":"2022-07-14T22:17:07.703Z","dependency_job_id":"2e3fd82d-bef3-4337-b616-6e3f46062413","html_url":"https://github.com/seahorn/seahorn","commit_stats":{"total_commits":2766,"total_committers":41,"mean_commits":67.46341463414635,"dds":0.7270426608821403,"last_synced_commit":"36a30812ba8a2921802a648ca171703c98a69a1e"},"previous_names":[],"tags_count":20,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/seahorn%2Fseahorn","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/seahorn%2Fseahorn/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/seahorn%2Fseahorn/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/seahorn%2Fseahorn/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/seahorn","download_url":"https://codeload.github.com/seahorn/seahorn/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":254337612,"owners_count":22054253,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["abstract-interpretation","horn-clauses","llvm","model-checking","program-analysis","static-analysis","verification"],"created_at":"2024-09-24T14:21:43.579Z","updated_at":"2025-05-15T12:02:43.331Z","avatar_url":"https://github.com/seahorn.png","language":"C","funding_links":[],"categories":[],"sub_categories":[],"readme":"[![seahorn](https://seahorn.github.io/images/seahorn-logo.png)](https://seahorn.github.io)\n\n\n![os](https://img.shields.io/badge/os-linux-orange?logo=linux)\n![os](https://img.shields.io/badge/os-macos-silver?logo=apple)\n[![Nighly Build](https://img.shields.io/github/actions/workflow/status/seahorn/seahorn/seahorn-docker.yml)](https://github.com/seahorn/seahorn/actions/workflows/seahorn-docker.yml)\n[![codecov](https://codecov.io/gh/seahorn/seahorn/branch/master/graph/badge.svg)](https://codecov.io/gh/seahorn/seahorn)\n[![gitter](https://badges.gitter.im/seahorn/seahorn.svg)](https://gitter.im/seahorn/seahorn?utm_source=badge\u0026utm_medium=badge\u0026utm_campaign=pr-badge)\n\n\u003c!-- \n\n[![Azure DevOps builds (branch)](https://img.shields.io/azure-devops/build/seahorn/seahorn/1/dev10?label=azure-build)](https://dev.azure.com/seahorn/seahorn/_build)\n\n--\u003e\n\n# About #\n\n[SeaHorn][seahorn-web] is an automated analysis framework for\n LLVM-based languages. This version compiles against LLVM 14.\n\nSome of the supported features are\n \n * Abstract Interpretation-based static analysis\n * Unification-based Context-Sensitive pointer analysis\n * SMT-based Bounded Model Checking (i.e., symbolic execution)\n * CHC-based Software Model Checking (i.e., invariant inference)\n * Executable counterexamples (i.e., no reports, just bugs!)\n \nSeaHorn is developed primarily as a framework for conducting research in\nautomated verification. The frameworks provides many components that can be put\ntogether in a variety of ways. However, it is not an \"out-of-the-box\" static\nanalysis tool.\n\nMany analysis tools and examples are provided with the framework. We are\nconstantly looking for new applications and provide support to new users. For\nmore information on what is happening, check our (infrequently updated)\n[blog][seahorn-blog].\n\n## License \n\n[SeaHorn][seahorn-web] is distributed under a modified BSD license. See\n [license.txt](license.txt) for details.\n \n# Introduction\n\n[![Demo](https://asciinema.org/a/261355.svg)](https://asciinema.org/a/261355)\n---\n\nSeaHorn provides a python script called `sea` to interact with\nusers. Given a C program annotated with assertions, users just need to\ntype: `sea pf file.c`\n\nThe result of `sea-pf` is `unsat` if all assertions hold, an `sat` if any of the\nassertions are violated.\n\nThe option `pf` tells SeaHorn to translate `file.c` into LLVM\nbitcode, generate a set of verification conditions (VCs), and\nfinally, solve them. The main back-end solver\nis [spacer](https://github.com/Z3Prover/z3/tree/master/src/muz/spacer).\n\n\nThe command `pf` provides, among others, the following options:\n\n- `--show-invars`: display computed invariants if answer was `unsat`.\n\n- `--cex=FILE` : stores a counter-example in `FILE` if answer was `sat`.\n\n- `-g` : compiles with debug information for more trackable\n  counterexamples.\n\n- `--step=large`: large-step encoding. Each transition relation\ncorresponds to a loop-free fragments.\n\n- `--step=small`: small-step encoding. Each transition relation\n  corresponds to a basic block.\n\n- `--track=reg` : model (integer) registers only.\n\n- `--track=ptr` : model registers and pointers (but not memory content)\n\n- `--track=mem`: model both scalars, pointers, and memory contents\n\n- `--inline` : inlines the program before verification\n\n- `--crab` : inject invariants in `spacer` generated by the Crab\n  abstract-interpretation-based\n  tool. Read\n  [here](https://github.com/seahorn/crab-llvm/wiki/ClamOptions) for\n  details about all Crab options (prefix `--crab`). You can see which\n  invariants are inferred by Crab by typing option `--log=crab`.\n\n- `--bmc`: use BMC engine.\n\n`sea pf` is a pipeline that runs multiple commands. Individual parts\nof the pipeline can be run separately as well:\n\n1. `sea fe file.c -o file.bc`: SeaHorn frontend translates a C program\n  into optimized LLVM bitcode including mixed-semantics\n  transformation.\n\n2. `sea horn file.bc -o file.smt2`: SeaHorn generates the verification\n  conditions from `file.bc` and outputs them into SMT-LIB v2 format. Users\n  can choose between different encoding styles with several levels of\n  precision by adding:\n\n   - `--step={small,large,fsmall,flarge}` where `small` is small step\n      encoding, `large` is block-large encoding, `fsmall` is small\n      step encoding producing flat Horn clauses (i.e., it generates a\n      transition system with only one predicate), and `flarge`:\n      block-large encoding producing flat Horn clauses.\n\n   - `--track={reg,ptr,mem}` where `reg` only models integer\n      scalars, `ptr` models `reg` and pointer addresses, and `mem`\n      models `ptr` and memory contents.\n\n3. `sea smt file.c -o file.smt2`: Generates CHC in SMT-LIB2 format. Is\n   an alias for `sea fe` followed by `sea horn`. The command `sea pf`\n   is an alias for `sea smt --prove`.\n\n4.  `sea clp file.c -o file.clp`: Generates CHC in CLP format.\n\n5. `sea lfe file.c -o file.ll` : runs the legacy front-end\n\nTo see all the commands, type `sea --help`. To see options for each\nindividual command CMD (e.g, `horn`), type `sea CMD --help` (e.g.,\n`sea horn --help`).\n\n## Static Analysis with Abstract Interpretation \n\n### Inference of Inductive Invariants using Crab \n\nSeaHorn does not use Crab by default. To enable Crab, add the option `--crab`\nto the `sea` command.\n\nThe abstract interpreter is by default intra-procedural and it uses\nthe [Zones](https://jorgenavas.github.io/papers/zones-SAS16.pdf)\ndomain as the numerical abstract domain. These default options should\nbe enough for normal users.  For developers, if you want to use other\nabstract domains you need to:\n\n1. Compile with `cmake` options `-DCRAB_USE_LDD=ON -DCRAB_USE_ELINA=ON`\n2. Run `sea` with option `--crab-dom=DOM` where `DOM` can be:\n   - `int` for intervals\n   - `term-int` for intervals with uninterpreted functions\n   - `boxes`: for disjunctive intervals \n   - `oct` for octagons \n   - `pk` for polyhedra \n\nTo use the crab inter-procedural analysis you need to run `sea` with\noption `--crab-inter`\n\nBy default, the abstract interpreter only reasons about scalar\nvariables (i.e., LLVM registers). Run `sea` with the options\n`--crab-track=mem --crab-singleton-aliases=true` to reason about\nmemory contents.\n\n### How to use Invariants generated by Crab in Spacer \n\nCrab is mostly path-insensitive while Spacer, our Horn clause solver,\nis path-sensitive. Although path-insensitive analyses are more\nefficient, path-sensitivity is typically required to prove the\nproperty of interest. This motivates our decision of running first\nCrab (if option `--crab`) and then pass the generated invariants to\nSpacer. There are currently two ways for Spacer to use the invariants\ngenerated by Crab. The `sea` option `--horn-use-invs=VAL` tells\n`spacer` how to use those invariants:\n\n- If `VAL` is equal to `bg` then invariants are only used to help\n  `spacer` in proving a lemma is inductive.\n- If `VAL` is equal to `always` then the behavior is similar to `bg`\n  but in addition invariants are also used to help `spacer` to block a\n  counterexample.\n\nThe default value is `bg`. Of course, if Crab can prove the program is\nsafe then Spacer does not incur in any extra cost.\n\n## Property Specification\n\nProperties are assumed to be assertions. SeaHorn provides a static assertion command `sassert`, as illustrated in the following example\n``` c \n/* verification command: sea pf --horn-stats test.c */\n#include \"seahorn/seahorn.h\"\nextern int nd();\n\nint main(void) {\n    int k = 1;\n    int i = 1;\n    int j = 0;\n    int n = nd();\n    while (i \u003c n) {\n        j = 0;\n        while (j \u003c i) {\n            k += (i - j);\n            j++;\n        }\n        i++;\n    }\n    sassert(k \u003e= n);\n}\n```\n\nInternally, SeaHorn follows [SV-COMP](http://sv-comp.sosy-lab.org) convention of\nencoding error locations by a call to the designated error function\n`__VERIFIER_error()`. SeaHorn returns `unsat` when `__VERIFIER_error()` is\nunreachable, and the program is considered safe. SeaHorn returns `sat` when\n`__VERIFIER_error()` is reachable and the program is unsafe. `sassert()` method\nis defined in `seahorn/seahorn.h`.\n\n## Inspect Code \n\nApart from proving properties or producing counterexamples, it is\nsometimes useful to inspect the code under analysis to get an idea of\nits complexity. For this, SeaHorn provides a command `sea\ninspect`. For instance, given a C program `ex.c` type:\n\n\tsea inspect ex.c --sea-dsa=cs+t --mem-dot \n\t \nThe option `--sea-dsa=cs+t` enables the new context-, type-sensitive sea-dsa\nanalysis described in\n[FMCAD19](https://jorgenavas.github.io/papers/tea-dsa-fmcad19.pdf). This command\ngenerates a `FUN.mem.dot` file for each function `FUN` in the input \nprogram. To visualize the graph of the main function, use web graphivz interface, or the following commands:\n\n```shell\n$ dot -Tpdf main.mem.dot -o main.mem.pdf\n```\n\nMore details on the memory graphs is in the SeaDsa repository: \n[here](https://github.com/seahorn/sea-dsa#visualizing-memory-graphs-and-complete-call-graphs). \n\nUse `sea inspect --help` to see all options. Currently, the available options\nare:\n\n- `sea inspect --profiler` prints the number of functions, basic blocks,\n  loops, etc.\n- `sea inspect --mem-callgraph-dot` prints to `dot` format the call\n  graph constructed by SeaDsa.\n- `sea inspect --mem-callgraph-stats` prints to standard output some\n  statstics about the call graph construction done by SeaDsa.\n- `sea inspect --mem-smc-stats` prints the number of memory accesses\n  that can be proven safe by SeaDsa.\n\n# Installation\n\nThe easiest way to get started with SeaHorn is via a docker distribution. \n\n```shell\n$ docker pull seahorn/seahorn-llvm10:nightly\n$ docker run --rm -it seahorn/seahorn-llvm10:nightly\n```\n\nStart with exploring what the `sea` command can do:\n```shell\n$ sea --help\n$ sea pf --help\n```\n\nThe `nightly` tag is automatically refreshed daily and contains the latest\ndevelopment version. We maintain all other tags (that require manual update)\ninfrequently. Check the dates on DockerHub and log an issue on GitHub if they\nare too stale.\n\nAdditional examples and configuration options are on the [blog][seahorn-blog].\nThe blog is updated infrequently. In particular, options change, features are\nphased out, new things are added. If you find problems in the blog, let us know.\nWe at least will update the blog post to indicate that it is not expected to\nwork with the latest version of the code.\n\nYou can also manually install by:\n\nFollowing the instructions in the Docker file\nDockerfile: [`docker/seahorn-builder.Dockerfile`](docker/seahorn-builder.Dockerfile).\n\nIf this does not work, run:\n```shell\n$ wget https://apt.llvm.org/llvm.sh\n$ chmod +x llvm.sh\n$ sudo ./llvm.sh 14\n$ apt download libpolly-14-dev \u0026\u0026 sudo dpkg --force-all -i libpolly-14-dev*\n```\nThe first 3 commands will install LLVM 14, the 4th will install libpolly which is wrongly omitted from LLVM 14 (but included in subsequent versions)\n\nNext, follow the instruction in the Docker file above\n\n# Developer's Zone\n\nThe information from this point on is for developers only. If you would like to\ncontribute to SeaHorn, build your own tools based on it, or just interested in\nhow it works inside, keep reading.\n\n## Compilation Instructions \n\nSeaHorn requires [LLVM](https://llvm.org), [Z3](https://github.com/Z3Prover/z3),\nand [boost](https://www.boost.org). The exact versions of the libraries keep\nchanging, but cmake craft is used to check that right version is available.\n\nTo specify a specific version of any of the dependencies, use the usual\n[`\u003cPackageName\u003e_ROOT`](https://cmake.org/cmake/help/latest/variable/PackageName_ROOT.html)\nand/or `\u003cPackageName\u003e_DIR` (see\n[find_package()](https://cmake.org/cmake/help/latest/command/find_package.html)\nfor details) cmake variables.\n\nSeaHorn is broken into multiple components that live in different repositories\n(under SeaHorn organization). The build process automatically checks out\neverything as necessary. For current build instructions, check the CI scripts.\n\nThese are the generic steps. Do **NOT** use them. Read on for a better way:\n1. `cd seahorn ; mkdir build ; cd build` (The build directory can also be\n   outside the source directory.)\n1. `cmake -DCMAKE_INSTALL_PREFIX=run ../ ` (Install is **required!**)\n1. `cmake --build . --target extra \u0026\u0026 cmake ..` (clones components that live elsewhere)\n1. `cmake --build . --target crab \u0026\u0026 cmake ..` (clones crab library) \n1. `cmake --build . --target install` (build and install everything under `run`)\n1. `cmake --build . --target test-all` (run tests)\n\n**Note**: **install** target is required for tests to work!\n\n## Better Compilation Instructions\n\nFor an enhanced development experience:\n1. Use `clang`\n1. On Linux, use `lld` linker\n1. Include debug symbols in Release builds\n1. Use [Ninja](https://ninja-build.org/)\n1. Export [`compile_commands.json`](https://clang.llvm.org/docs/JSONCompilationDatabase.html)\n\nOn Linux, we suggest the following `cmake` configuration:\n```\n$ cd build\n$ cmake -DCMAKE_INSTALL_PREFIX=run \\\n      -DCMAKE_BUILD_TYPE=RelWithDebInfo \\\n      -DCMAKE_CXX_COMPILER=\"clang++-14\" \\\n      -DCMAKE_C_COMPILER=\"clang-14\" \\\n      -DSEA_ENABLE_LLD=ON  \\\n      -DCMAKE_EXPORT_COMPILE_COMMANDS=1 \\\n      ../ \\\n      -DZ3_ROOT=\u003cZ3_ROOT\u003e \\\n      -DLLVM_DIR=\u003cLLMV_CMAKE_DIR\u003e \\\n      -GNinja\n$ (cd .. \u0026\u0026 ln -sf build/compile_commands.json .)\n```\nwhere `\u003cZ3_ROOT` is a directory containing Z3 binary distribution, and `LLMV_CMAKE_DIR` is directory containing `LLVMConfig.cmake`. \n\nOther legal options for `CMAKE_BUILD_TYPE` are `Debug` and `Coverage`. Note that\nthe `CMAKE_BUILD_TYPE` must be compatible with the one used to compile `LLVM`.\nIn particular, you will need a `Debug` build of LLVM to compile `SeaHorn` in\n`Debug** mode. Make sure you have plenty of patience, disk space, and time if you\ndecide to go this route.\n\nAlternatively, the project can be configured using cmake presets. To do this, simply run the following command:\n\n```bash\n$ cmake --preset \u003cBUILD_TYPE\u003e-\u003cPRESET_NAME\u003e\n```\n\nto configure cmake, where `\u003cBUILD_TYPE\u003e` is one of: `Debug`, `RelWithDebInfo` or `Coverage` and `\u003cPRESET_NAME\u003e` is the preset you would like to use. The presets that are currently available are: `jammy`. These presets assume that you have Z3 installed in `/opt/z3-4.8.9` and Yices installed in `/opt/yices-2.6.1`.\n\nThis will also allow the project to be configured and compiled within VS Code using the CMake Tools extension.\n\nIf you would like to use different compilation settings or if you have Z3 or Yices installed in any other directory, you will need to make your own `CMakeUserPresets.json` file with your own presets.\n\n## Compiling on a Mac\n\n**Do not include `-DSEA_ENABLE_LLD=ON`**. The default compiler is clang, so you\nmight not need to set it explicitly.\n\n\n## The **EXTRA** Target \n\nSeaHorn provides several components that are automatically cloned and installed via the `extra`\ntarget. These components can be used by other projects outside of\nSeaHorn.\n\n* [sea-dsa](https://github.com/seahorn/sea-dsa): `git clone https://github.com/seahorn/sea-dsa.git`\n\n  `sea-dsa` is a new DSA-based heap analysis. Unlike `llvm-dsa`,\n  `sea-dsa` is context-sensitive and therefore, a finer-grained\n  partition of the heap can be generated in presence of function\n  calls.\n\n* [clam](https://github.com/seahorn/crab-llvm): `git clone https://github.com/seahorn/crab-llvm.git`\n\n  `clam` provides inductive invariants using abstract interpretation\n  techniques to the rest of SeaHorn's backends.\n\n* [llvm-seahorn](https://github.com/seahorn/llvm-seahorn): `git clone https://github.com/seahorn/llvm-seahorn.git`\n\n  `llvm-seahorn` provides tailored-to-verification versions of\n  `InstCombine` and `IndVarSimplify` LLVM passes as well as a LLVM\n  pass to convert undefined values into nondeterministic calls, among\n  other things.\n\nSeaHorn doesn't come with its own version of Clang and expects to find it\neither in the build directory (`run/bin`) or in PATH. Make sure that the\nversion of Clang matches the version of LLVM that was used to compile \nSeaHorn (currently LLVM14). The easiest way to provide the right version of \nClang is to download it from [llvm.org](http://releases.llvm.org/download.html),\nunpact it somewhere and create a symbolic link to `clang` and `clang++`\nin `run/bin`.\n\n```shell\n$ cd seahorn/build/run/bin\n$ ln -s \u003cCLANG_ROOT\u003e/bin/clang clang\n$ ln -s \u003cCLANG_ROOT\u003e/bin/clang++ clang++\n```\nwhere `\u003cCLANG_ROOT\u003e` is the location at which Clang was unpacked.\n\n## Tests \n\nTesting infrastructure depends on several Python packages. These have their own\ndependencies. If you cannot figure them out, use docker instead.\n\n```shell\n$ pip install lit OutputCheck networkx pygraphviz\n```\n\n## Coverage \n\nWe can use `gcov` and `lcov` to generate test coverage information for SeaHorn.\nTo build with coverage enabled, we need to run build under a different directory\nand set `CMAKE_BUILD_TYPE` to `Coverage` during cmake configuration.\n\nExample steps for generating coverage report for the `test-opsem` target:\n1. `mkdir coverage; cd coverage`  create and enter coverage build directory\n2. `cmake -DCMAKE_BUILD_TYPE=Coverage \u003cother flags as you wish\u003e ../`\n3. Complete the build as usual\n4. `cmake --build . --target test-opsem` Run OpSem tests, now `.gcda` and\n`.gcno` files should be created in the corresponding `CMakeFiles` directories\n5. `lcov -c --directory lib/seahorn/CMakeFiles/seahorn.LIB.dir/ -o coverage.info` collect coverage data from desired module,\nif `clang` is used as the compiler instead of `gcc`, create a bash script `llvm-gcov.sh`:\n```shell\n#!/bin/bash\nexec llvm-cov gcov \"$@\"\n```\n```shell \n$ chmod +x llvm-gcov.sh\n```\nthen append `--gcov-tool \u003cpath_to_wrapper_script\u003e/llvm-gcov.sh` to the `lcov -c ...` command.\n6. extract data from desired directories and generate html report:\n```shell\nlcov --extract coverage.info \"*/lib/seahorn/*\" -o lib.info\nlcov --extract coverage.info \"*/include/seahorn/*\" -o header.info\ncat header.info lib.info \u003e all.info\ngenhtml all.info --output-directory coverage_report\n```\nthen open `coverage_report/index.html` in browser to view the coverage report\n\nAlso see `scripts/coverage` for scripts used by the CI. Coverage report for nightly builds is available at [codecov](https://codecov.io/gh/seahorn/seahorn)\n\n## Code indexing \n\n[Compilation database](http://clang.llvm.org/docs/JSONCompilationDatabase.html)\nfor the seahorn project and all its sub-projects is generated using\n`-DCMAKE_EXPORT_COMPILE_COMMANDS=ON` option for `cmake`.\n\nAn easy way to get code indexing to work with with compilation database support\nis to link the `compilation_database.json` file into the main project directory\nand follow instructions specific to your editor.\n\n- Clion -- https://www.jetbrains.com/help/clion/compilation-database.html\n- Vim (YouCompleteMe) -- [instructions](https://github.com/Valloric/YouCompleteMe#option-1-use-a-compilation-database)\n- Emacs -- use `lsp-ui` with `clangd` which are available in [spacemacs](https://github.com/syl20bnr/spacemacs/tree/develop) develop branch\n\n## Remote Configuration for CLion\nFor a detailed guide for a remote workflow with CLion check \n[Clion-configuration](CLion-configuration.md).\n\n## Remote Configuration for Emacs (and other Editors)\n\nUse our fork of [mainframer](https://github.com/agurfinkel/mainframer). Don't\nmiss the example\n[configuration](https://github.com/agurfinkel/mainframer/tree/master/samples/ag/.mainframer).\n\n# Contributors\n\n* [Arie Gurfinkel](https://arieg.bitbucket.org/)\n* [Jorge Navas](https://jorgenavas.github.io/)\n* [Temesghen Kahsai](http://www.lememta.info/)\n* [Jakub Kuderski](https://github.com/kuhar)\n* [Nham Le](https://github.com/nhamlv-55)\n* [Charles Lei](https://github.com/mrthefakeperson)\n* [Xiang Zhou](https://github.com/danblitzhou)\n* [Siddharth Priya](https://github.com/priyasiddharth)\n* [Isabel Garcia-Contreras](https://igcontreras.github.io/)\n* [Yusen Su](https://github.com/LinerSu)\n* EMAIL ME IF YOUR NAME SHOULD BE HERE\n\n[seahorn-web]: https://seahorn.github.io\n[seahorn-blog]: https://seahorn.github.io/blog\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fseahorn%2Fseahorn","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fseahorn%2Fseahorn","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fseahorn%2Fseahorn/lists"}