Self-hosted service
rocq-prover/rocq avatar
rocq-prover/rocq

Rocq: a Dune-built proof assistant with two generations of names

The Rocq Prover is an interactive theorem prover, or proof assistant. It provides a formal language to write mathematical definitions, executable algorithms and theorems together with an environment for semi-interactive development of machine-checked proofs.

5,670 stars774 forksOCamlLGPL-2.1

At a glance

What is it?
Rocq is an interactive theorem prover written in OCaml, and the parts a new user has to settle are the ones the repository leaves open: which install channel to use, which documentation set matches the build in front of you, and what a version crossing the Coq to Rocq rename does to existing proofs. The build itself is Dune driven, quiet by default, and not parallel at the make level.
Who is it for?
Rocq fits people whose work needs machine-checked proofs and who will read the Recent changes chapter before every major upgrade. It does not fit someone expecting a one line install, because the repository hands you to an install page and an INSTALL.md instead of a command.
Can I use it commercially?
Yes, with conditions. LGPL-2.1 is a weak copyleft licence: you can use it inside commercial and closed-source software, but if you distribute changes to its own files, you must publish those changes under the same licence.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly OCaml, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • rocq-prover/rocq5,670 ★ · +84
Star history
Repository2026-09-232026-11-15
rocq-prover/rocq5.6k5.7k

84 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

One tree holds two generations of names

The project lives at rocq-prover/rocq on the master branch, is written in OCaml, and ships under LGPL-2.1. Inside a single tree sit manifests from both naming eras, several of them paired with a template.

text
coq-core.opam
coq-core.opam.template
rocq-core.opam
rocq-core.opam.template
rocq-runtime.opam
rocq-devtools.opam
rocq-test-suite.opam
rocqide.opam
rocqide-server.opam
META.rocq-core.template

Both command names are still live for the version check, coqtop -v or rocq -v, which is why a bug report accepts either spelling. Continuous integration is split the same way, with a pipeline on GitLab at gitlab.inria.fr/coq/coq and another on GitHub at rocq-prover/rocq.

The build is quiet by default and set not to parallelize

Building from source goes through a Makefile that is a thin layer over Dune, and two settings there decide what you see. Quiet mode is on by default, so make echoes abbreviated commands instead of complete ones unless you pass VERBOSE=1. The file also sets .NOTPARALLEL, with a comment saying parallel build is not allowed there because the file is mostly a placeholder for dune commands. A third setting, WITHJOBS, points at dev/tools/with-jobs.sh and is documented as unset to disable jobserver integration, in which case a -j argument to make is ignored.

bash
make world
make test-suite
make install
VERBOSE=1 make world

Targets are grouped by purpose: help, help-install, states, world, rocqide, watch and check for development, refman-html, refman-pdf, refman-indices, corelib-html and apidoc for documentation, fmt, ocheck, obuild, ireport and clean for maintenance, and dunestrap, release and install as miscellaneous. DUNEOPT=--display=short sits commented in the file as the switch for a more verbose build. Makefile.ci, .gitlab-ci.yml and a .github directory cover continuous integration, and flake.nix, shell.nix and default.nix cover Nix based flows.

Two documentation sets, and one chapter that explains version breaks

Version boundaries are where a Rocq user loses time, and the project names one place to look: the Recent changes chapter of the reference manual, which explains the differences and the incompatibilities of each new version and carries advice on problems you may hit. The instruction to read it carefully is aimed squarely at anyone upgrading. Two documentation sets then exist side by side. The last released version is published at rocq-prover.org/docs, while the master branch is deployed continuously, so the manual, the standard library pages and the ML API pages under doc/master describe a build you may not be running.

text
https://rocq-prover.org/docs
https://rocq-prover.org/doc/master/refman/
https://rocq-prover.org/doc/master/stdlib/
https://rocq-prover.org/doc/master/api/

Sources for all of it live in the doc directory, and doc/README.md explains how to build them, with the wiki and a separate FAQ page covering user-contributed documentation. Releases move quickly: V9.2.0 shipped on 2026-03-27, a V9.3+rc1 candidate on 2026-07-22, and V9.3.0 on 2026-09-19. That chapter is the one to read before you upgrade a development you already have working.

The install path is a web page, a file, and two badges

The repository carries no install recipe. What it carries is a pointer: rocq-prover.org/install for packaged installs, and INSTALL.md for building and installing from sources. Two badge links show where distribution actually happens, one to the Repology metapackage page for the coq package and one to the rocq/rocq-prover repository on Docker Hub with its supported tags, next to a wiki page covering the docker-coq images.

text
https://rocq-prover.org/install
https://repology.org/metapackage/coq/versions
https://hub.docker.com/r/rocq/rocq-prover#supported-tags

That leaves real costs. You pick a channel before you pick a version, and the packaged channel is still filed under the coq metapackage name, the same split visible in the manifests. The README does not state which OCaml versions are supported, which matters for a project written in OCaml whose bug reports are expected to name the compiler. It also documents no uninstall and no route back to an earlier release, so a container is the cheaper place to try something and the packaged install is the one you will have to live with.

A useful bug report carries four specific things

Filing an effective report has a contract, and it is spelled out: name the OCaml version used to compile and run Rocq, name the Rocq version, name the configuration used, and include a complete source example that leads to the bug. Both defects and feature requests go to the issue tracker on GitHub.

bash
coqtop -v
rocq -v

Those four items are the starting point, and none of them can be reconstructed from issue text alone. The repository carries a regression side of its own: a test-suite directory, a make test-suite target, and separate continuous integration definitions in Makefile.ci, .gitlab-ci.yml and .github, so a change can be exercised before it reaches you. Questions have a split routing, with Zulip for casual and high traffic discussion, the Discourse forum for structured and easily browsable threads and Q&A, and a community page listing further active platforms.

The editor integration compiles, but its wiring is not described

The build includes an editor integration, and its configuration is the least documented corner. The tree carries an ide directory plus two opam packages, rocqide and rocqide-server, and the Makefile exposes a rocqide target next to a watch target. Nothing in the README says how to attach an editor to them.

bash
make rocqide
make watch

That makes the component something you can compile from the project and a setup step you have to source elsewhere, most plausibly the wiki or the FAQ page. The same limit applies to the programmatic surface: the ML API pages are published for master, so they document what the packages export in a build you may not be running. A reader who needs a stable reference has to match a doc set to a version by hand, which is the same chore the two naming generations create everywhere else in the project.

Credits name INRIA and CNRS, funding runs through a consortium

Ownership is stated plainly at the top of the build. The Makefile header names the Rocq Prover development team, credits INRIA and CNRS with contributors, points at the CREDITS file for authors and dates, and states the GNU Lesser General Public License Version 2.1 with a pointer to LICENSE for the text.

text
LICENSE
CREDITS
CONTRIBUTING.md
CODE_OF_CONDUCT.md
.mailmap
.ocp-indent

The declared license is LGPL-2.1, so code you link into the system carries obligations you need to read for yourself rather than take from a summary. Contribution rules live in CONTRIBUTING.md, and release plans sit on a Release-Plan page in the wiki instead of in the repository, so the schedule is something you look up rather than something you can diff. Funding runs through the Rocq Consortium, which can establish sponsorship contracts or take donations, and Consortium membership is open to people who want a say in direction.

Editorial conclusion

Rocq fits people whose work needs machine-checked proofs and who will read the Recent changes chapter before every major upgrade. It does not fit someone expecting a one line install, because the repository hands you to an install page and an INSTALL.md instead of a command. Before you pin anything, check which release your package manager actually serves, because the packaged channel is still filed under the older name, and read the changes chapter for your exact version pair.

Frequently asked questions

What is a Rocq Prover?

It is an interactive theorem prover, also called a proof assistant, written in OCaml. It provides a formal language for mathematical definitions, executable algorithms and theorems, together with an environment for semi-interactive development of machine-checked proofs.

What is Rocq?

Rocq is the proof assistant hosted at rocq-prover/rocq on the master branch, released under LGPL-2.1, with V9.3.0 published on 2026-09-19. Both coqtop -v and rocq -v report its version, so the two command names are still in use.

Is Coq renamed to Rocq?

The repository carries both naming generations at once. Manifests include coq-core.opam next to rocq-core.opam, rocq-runtime.opam and rocq-devtools.opam, the Repology metapackage page is still filed under the coq name, and one GitLab pipeline sits at gitlab.inria.fr/coq/coq while GitHub hosts rocq-prover/rocq.

Official sources

  1. License: LGPL-2.1
  2. Project website
  3. README
  4. Releases
  5. rocq-prover/rocq on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/rocq-prover-rocq.svg)](https://hysenlabs.com/projects/rocq-prover-rocq)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/rocq-prover-rocq.svg)](https://hysenlabs.com/projects/rocq-prover-rocq)

Was this useful?