Skip to content
Back to search

spark2014

SPARK 2014 is the new version of SPARK, a software development technology specifically designed for engineering high-reliability applications.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/AdaCore/spark2014 with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/AdaCore/spark2014'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/adacore--spark2014/badge.svg)](/listings/adacore--spark2014)

HTML

<a href="/listings/adacore--spark2014"><img src="/api/listings/adacore--spark2014/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

You can download a "gnatprove" package from this [github project](https://github.com/alire-project/GNAT-FSF-builds/releases). Extracting the package and adding the `bin` directory to your PATH is enough. You can get the GNAT compiler from the same link, and there is a [different project](https://github.com/AdaCore/gnatstudio/releases) for GNATStudio, the IDE.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 141 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/959/badge)](https://bestpractices.coreinfrastructure.org/projects/959)
  2. # 1. Introduction
  3. This repository contains the source code for the SPARK project. SPARK
  4. is a software development technology specifically designed for engineering
  5. high-reliability applications. It consists of a programming language,
  6. a verification toolset and a design method which, taken together, ensure
  7. that ultra-low defect software can be deployed in application domains where
  8. high-reliability must be assured and where safety and security are
  9. key requirements.
  10. This repository provides visibility on the development process. The main line
  11. of development is in line with the development version of GNAT, which is not
  12. directly visible to the public (although patches are regularly transferred to
  13. the [FSF repository](https://gcc.gnu.org/git/?p=gcc.git;a=tree)), and it will
  14. probably be impossible to build the master branch of the software with any
  15. other compiler. However, buildable branches are provided corresponding to
  16. public compiler releases or the head of the FSF repository, see the section on
  17. *Building SPARK* below.
  18. # 2. Commercial support
  19. SPARK is commercially supported by AdaCore and Capgemini, you can visit the
  20. [AdaCore website](http://www.adacore.com/sparkpro/) for more information.
  21. # 3. Community version
  22. ## 3.1 Manual install
  23. You can download a "gnatprove" package from this [github
  24. project](https://github.com/alire-project/GNAT-FSF-builds/releases). Extracting
  25. the package and adding the `bin` directory to your PATH is enough. You can get
  26. the GNAT compiler from the same link, and there is a [different
  27. project](https://github.com/AdaCore/gnatstudio/releases) for GNATStudio, the
  28. IDE.
  29. ## 3.2 Install using alire
  30. You can obtain SPARK via [Alire](https://alire.ada.dev/crates/gnatprove). To do
  31. this, follow the installation instructions of Alire, then you can add the
  32. `gnatprove` dependency to an alire project using
  33. ```
  34. alr with gnatprove
  35. ```
  36. Alire will download gnatprove if necessary.
  37. ## 3.3 The older GNAT Community version
  38. There is an older community version of the tools, packaged with GNAT and
  39. GNATStudio. You can download it from [AdaCore's
  40. website](https://www.adacore.com/download).
  41. # 4. Governance
  42. SPARK is led by AdaCore and co-developed by AdaCore, Capgemini and Inria. The
  43. SPARK team at AdaCore is responsible for the technology roadmap, taking into
  44. account the needs of all stakeholders: sales and marketing, customers, other
  45. development teams, community.
  46. The team is organized around a set of roles for QA, integration, certification,
  47. language evolution, etc. with two roles managing interactions:
  48. The Team Coordinator:
  49. * Defines the technology roadmap with all stakeholders.
  50. * Coordinates and organizes the work in the team.
  51. * Adjusts efforts and priorities based on the technology roadmap.
  52. The Team Technical Authority:
  53. * Provides and maintains deep knowledge of the technology.
  54. * Is the main reference point for knowledge on the technology.
  55. * Is the software architect on the technology.
  56. Currently these roles are exercised by Claire Dross (Team Coordinator) and
  57. Johannes Kanig (Team Technical Authority).
  58. # 5. Community
  59. News about SPARK project are shared primarily on [AdaCore's
  60. blog](https://blog.adacore.com/). Questions and bug-reports are welcome
  61. via the GitHub issue tracker.
  62. # 6. Documentation
  63. You can find the definition of the SPARK language in the
  64. [SPARK Reference Manual](https://docs.adacore.com/live/wave/spark2014/html/spark2014_rm/index.html),
  65. and instructions on how to use the tool, together with a tutorial, in the
  66. [SPARK User's Guide](https://docs.adacore.com/live/wave/spark2014/html/spark2014_ug/index.html).
  67. # 7. Building SPARK
  68. Building gnatprove requires building the two projects `gnat2why` and `gnatprove`
  69. in this repository, and the `why3` submodule containing the AdaCore fork of
  70. Why3.
  71. ## Building `gnatprove` and `gnat2why`
  72. This requires the following sources and libraries:
  73. - Matching GNAT compiler
  74. - Matching GNAT front-end sources made available in gnat2why/gnat_src
  75. - gprbuild
  76. - VSS
  77. - sarif-ada
  78. - libgpr2
  79. - gnatcoll-core
  80. - ada_toml
  81. See the build instructions in the Makefile for details on how to build gnat2why
  82. and gnatprove.
  83. For FSF compiler and sources, we recommend using the `fsf` branch, or the
  84. versioned `fsf-xx` branches for specific versions.
  85. ## Building Why3 (gnatwhy3)
  86. Why3 needs a working opam setup. The dependencies are documented in the
  87. AdaCore-maintained [Why3 fork](https://github.com/AdaCore/why3).
  88. ## Provers
  89. GNATprove expects provers to be available. GNATprove will detect and
  90. use Z3, cvc5 and alt-ergo when available in PATH, or installed in
  91. PREFIX/libexec/spark/bin.
  92. # 8 Working with source code
  93. Since most of the source code is written in Ada an editor or IDE that has
  94. dedicated support for Ada is recommended. Below are tips for some common IDEs.
  95. ## 8.1 Using GNAT Studio
  96. Simply open the respective project, e.g., `gnatprove.gpr` or
  97. `gnat2why/gnat2why.gpr`, from GNAT Studio or pass it to the executable using
  98. the `-P` switch.
  99. ## 8.2 Using VS Code
  100. The folder `.vscode` contains some settings and a [README](.vscode/README.md)
  101. file that can be helpful when using VS Code.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.