aclpubcheck catches the formatting errors ACL publication chairs actually reject

What aclpubcheck looks for in an ACL paper

ACL pubcheck automatically detects common formatting problems in papers that use the LaTeX style files for ACL venues. The README lists font errors, author formatting errors, margin violations, outdated citations and other issues among them. It is aimed at two groups: authors preparing a paper, and publication chairs who need to check batches of submissions. The tool writes a JSON report for every paper, plus annotated PNG pages for margin errors, so a failure is something you can point at rather than a vague warning.

There is one scope restriction that matters. ACL pubcheck is intended for the camera-ready version of the paper when checking final formatting. Running it on an anonymous or line-numbered review version may produce spurious margin errors because of the line numbers. That is not a bug to work around; it is a consequence of how the margin check reads the page. Plan to run it twice: once before submission if you want an early signal, and again on the final version before upload.

How the margin and citation checks actually work

The margin check is the simplest part to explain. Typically the space at the bottom of a paper should be left empty, because page numbers are added during the watermarking process of the proceedings. By default ACL pubcheck ensures that a margin of approximately 2 cm at the bottom of each page is left blank. If any text is detected in that area, such as page numbers mistakenly added by the author, a warning is generated. You can disable the check with `--disable_bottom_check` when that area must contain information.

The citation check is the more involved part. The bibliography is extracted from the PDF using the Scholarcy API. Each bib entry is then updated by pulling information from ACL Anthology, DBLP and arXiv, using fuzzy matching on titles. After the bibs are updated, the author names are compared and mismatches are warned about. The functions live in `aclpubcheck/name_check.py`, and the class `PDFNameCheck` is used in `formatchecker.py`. A demo of the PDF name checking is available online.

The README is explicit that some of the warnings generated for citations may be spurious and inaccurate, due to parsing and indexing errors. The advice there is to double check the citations and update them depending on the latest source, and to ignore warnings when you believe your citation is already updated and correct. If a margin error is caused by a figure running into the margin, the README suggests applying the adjustbox package; if it is caused by an equation, breaking the equation over two lines may help.

Installing and running aclpubcheck locally

ACL pubcheck requires Python 3.10 or newer. It depends on rebiber, which is installed from a pinned GitHub commit for reproducibility. The simplest local option is uv. After installing uv, you can run ACL pubcheck without installing it permanently:

uvx --from git+https://github.com/acl-org/aclpubcheck \
    aclpubcheck --paper_type PAPER_TYPE /path/to/paper.pdf

Replace PAPER_TYPE with `long`, `short`, or `demo`.

You can also install directly from GitHub with pip:

pip3 install git+https://github.com/acl-org/aclpubcheck

and then run:

aclpubcheck --paper_type PAPER_TYPE path/to/paper.pdf

or:

python3 -m aclpubcheck --paper_type PAPER_TYPE path/to/paper.pdf

For example:

python3 -m aclpubcheck -p long example/2023.acl-tutorials.1.pdf

To develop or modify the tool, clone and install in editable mode:

git clone https://github.com/acl-org/aclpubcheck.git
cd aclpubcheck
pip install -e .

If you only want to check a single paper and do not want a local environment, the README points to a Google Colab notebook and a Hugging Face Space. Both run in the browser with no local installation.

Where the reports go and how they are named

Each run writes a JSON report for every paper, plus annotated PNG pages for margin errors, to the current directory. The reports are named after the paper ID, which is the file name without `.pdf`, cut at the first underscore. `1234_paper.pdf` gives `errors-1234.json` and `errors-1234-page-N.png`. If several PDFs in one run share an ID, ignoring case, such as `1234_original.pdf` and `1234_corrected.pdf`, their reports are named after the file name without `.pdf` instead, giving `errors-1234_original.json` and `errors-1234_corrected.json`. If PDFs in different directories also share a file name, the first 8 hex digits of the SHA-256 hash of each PDF are appended, as in `errors-1234_paper_3f9a1c2e.json`. A later run overwrites reports with the same names but does not delete other files, so annotated pages from an earlier run can remain next to a newer JSON report.

To save the reports to another directory, which is created if needed, use `--output-dir`, or `-o`. To keep runs apart, use `--temp-output-dir`, which saves them to a new temporary directory. With either option the directory is printed when the check starts and finishes:

aclpubcheck --paper_type PAPER_TYPE --output-dir path/to/reports path/to/paper.pdf
aclpubcheck --paper_type PAPER_TYPE --temp-output-dir path/to/paper.pdf

Additional information can be found in `aclpubcheck_additional_info.pdf`, included in the repository.

Online checker versus a local install

The README offers two routes that differ in what they are good for. The online versions, a Google Colab notebook and a Hugging Face Space, require no installation and are the easiest way to check a single paper. The Colab route uploads a PDF and runs ACL pubcheck directly in the browser. The local route exists for repeated use, batch checking, and publication-chair workflows, where uploading papers one at a time through a browser is impractical. The local route also gives you the report files on disk, which is what you want when you are auditing a proceedings rather than checking your own paper. The practical difference is therefore not capability but friction: the local install is the one that fits into a script.

Limitations, false positives and when it is the wrong tool

ACL pubcheck is not a substitute for reading the ACL style files. Its citation warnings can be spurious and inaccurate because of parsing and indexing errors, and the README says to double check citations against the latest source. Its margin warnings depend on the page being free of line numbers, so running it on an anonymised review draft produces noise rather than signal. The bottom-margin check assumes the bottom 2 cm should be empty because page numbers are added later; if your paper legitimately places text there, you need `--disable_bottom_check` rather than a workaround in LaTeX.

It is also the wrong tool if you need a general LaTeX linter. ACL pubcheck is built around the ACL venue style files and the ACL citation ecosystem, and its name-checking pipeline depends on the Scholarcy API plus ACL Anthology, DBLP and arXiv. If your venue is not an ACL venue, or your bibliography is not in a form those services can match, the citation half of the tool will not help you.

Maintenance, licence and upgrade cost

The repository is not archived and its last push was on 2026-10-07. There are no GitHub releases, and setup.py declares version 0.1 with `python_requires=">=3.10"`. The licence is MIT. The one dependency worth planning around is rebiber, which is pinned to a specific commit (`b917e36ec94084a84025eb06781b5aac96d1cedd`) in setup.py for reproducibility. That pin is a feature for a submission tool, because it makes a given ACL pubcheck install behave the same way over time, but it also means upgrading rebiber requires editing setup.py and reinstalling, rather than running a normal dependency update. The entry point is `aclpubcheck=aclpubcheck.__main__:main`, and the repository ships tests, an example PDF (`example/2023.acl-tutorials.1.pdf`), and `aclpubcheck_additional_info.pdf` alongside the package. Before adopting it, confirm your Python version and that the pinned rebiber commit installs in your environment; those are the two facts the README treats as requirements.

Editorial conclusion

Adopt aclpubcheck if you are submitting to an ACL venue and can run it on the camera-ready PDF; skip it for the anonymised review draft, where line numbers make margin checks noisy, and verify first that your Python is 3.10 or newer and that the pinned rebiber commit installs in your environment.

Frequently asked questions

Official sources

1. acl-org/aclpubcheck on GitHub
2. Issues
3. License: MIT
4. README