ArPDF — does Arabic survive a PDF?

Author: Syamjith NK Write-up: Your Arabic PDF is fine. What reads it is not. Third in a series with ArNum-TTS (speech) and ArShape (screen rendering).

The finding

No PDF generator and extractor pair reads Arabic reliably, and correctness depends on the pair rather than on either tool.

5 Arabic strings × 4 generators × 3 extractors. Clean extractions out of 5:

generator	pypdf	pdfminer.six	poppler pdftotext
Chrome (HTML → PDF)	3/5	0/5	1/5
ReportLab (naive)	0/5	5/5	0/5
ReportLab (+ reshaper)	3/5	0/5	3/5
LibreOffice (.docx → PDF)	5/5	0/5	2/5

Re-measured on 9 October 2026, with every tool version recorded in versions.json. The table is identical, cell for cell, to the first run of 19 August 2026 (see Corrections):

	version
macOS (arm64)	27.0.1
Chrome	154.0.8037.99
LibreOffice	26.8.1.1
pypdf	6.19.0
pdfminer.six	20260107
poppler pdftotext	26.09.0
reportlab	5.0.1
arabic_reshaper / python-bidi	3.0.1 / 0.6.11
python-docx (builds the .docx inputs)	1.2.0

Why pdfminer inverts

pdfminer is 0/5 against three generators and 5/5 against exactly one — the only one that performs no text layout. That is not a coincidence, and it explains the whole table.

ReportLab-naive writes the characters into the PDF in logical order, because it does no shaping or bidi. Chrome, LibreOffice and reshaped ReportLab all lay the line out visually first, so the PDF stores glyphs in visual order. pdfminer returns what is stored without re-applying bidi, so it is right precisely when the generator was naive. pypdf and poppler apply their own reordering heuristics, which is why they land in between.

So the question a PDF answers is not "is the Arabic correct" but "which order is it stored in, and does this reader re-apply bidi". No tool tells you either.

The two ends invert. ReportLab-naive extracts perfectly through pdfminer and fails every other reader; Chrome — the route most web tooling uses — is 0 for 5 through pdfminer, which is what many document pipelines run.

So you cannot choose a "good" PDF library or a "good" extractor. A document that survives one reader is unreadable to the next, and when you submit a PDF you do not control which reader is on the other side.

Why it matters

A PDF looks correct, so it is trusted. But almost nothing that consumes one looks at it — procurement portals parse the text, search engines index it, compliance tools scan for terms, applicant systems read CVs. All of them extract.

An Arabic tender response that renders perfectly on screen and extracts as reversed text is, to the system reading it, gibberish. Nobody involved sees the failure.

Seven verdicts, six failure modes

Counted separately, because they need different fixes and have very different blast radii. Each row's verdict comes from classify() in classify.py, checked in this order:

verdict	what happens	rows
clean	the source string comes back in logical order	22
bidi_controls	letters and order are right, but invisible bidi embedding marks sit inside the text and break exact matching	3
ligature	logical order, but a lam pair comes back swapped: الإمارات → اإلمارات, المهيري → املهيري	6
reversed	the string comes back in visual order and reads backwards; digit and Latin runs stay left-to-right	15
reversed_ligature	reversed and a lam pair swapped, e.g. تاراملإا ةلود يف مكب ابحرم	8
reordered	every character is there but whole segments come back out of order, e.g. بالمئة47 بلغت النسبة2026في عام	2
mangled	characters are missing	4

Reversal is the most common failure: 23 of the 38 failing rows read backwards (reversed plus reversed_ligature). A lam pair is swapped in 14 rows (ligature plus reversed_ligature).

Correction, 27 October 2026. The previous verdict called anything that was neither clean nor an exact character-by-character reversal "ligature". That swept in three other things: reversals of strings containing digits or Latin, which a visual-order PDF keeps left-to-right and so are never an exact character reversal; reversals that also swapped a lam pair; and text that was correct apart from embedded bidi controls. It produced the earlier "23 ligature, 11 reversed". This card's own "reversed" example (rows 1 and 10) and "spacing" example (row 24) were in fact scored ligature, and spacing could never be assigned, because the comparison removes whitespace before matching. The verdicts were re-derived from the stored extracted text by reclassify.py. No PDF was regenerated, order_ok and chars_ok are unchanged on every row, and so is the clean-extraction table above.

Correction, 21 August 2026. This line previously read "9 reversed, 17 ligature, 4 mangled". Those figures were wrong: they summed to 30 rows when the matrix has 38 non-clean results, and they under-counted both reversed and ligature. The corrected counts above are recomputed directly from results.jsonl and can be reproduced with:

import json, collections
collections.Counter(json.loads(l)["verdict"] for l in open("results.jsonl"))

The direction of the finding is unchanged — ligature remains the most common failure mode and the most dangerous, because it survives a human proofread. Only the counts were wrong.

The ligature mode is still the dangerous one, even though reversal is more common. A reversed string is obvious to any Arabic reader. اإلمارات survives a human proofread while still breaking exact-match search, keyword compliance checks and any automated comparison.

Detecting it after the fact

This benchmark measures extraction. The corruption it produces usually does not stay in a terminal — it gets written to a JSON export, a search index, a database column. At that point it is at rest, and every later reader inherits it.

arabic-lint finds it:

pip install arabic-lint
arabic-lint results.jsonl
# 21 corrupted span(s) in 1 file(s); 5 cannot be auto-fixed safely.

That is this dataset's own results.jsonl — the tool flags exactly what the benchmark recorded, which is the check that it works on real data rather than fixtures.

The 5 unsafe spans are lam-alef ligature glyphs stored as presentation forms in the ReportLab (+reshaper) rows (rows 6, 7, 8, 43 and 44, two of which extract cleanly). They are not the ligature verdict above, which is about extracted plain letters. NFKC + reverse undoes the corruption exactly, except across a lam-alef: one codepoint decomposes to two in logical order inside visual-order text, so the pair comes back swapped. الإمارات recovers as اإلمارات and السلام as السالم — a real but different word. The tool therefore reports and never rewrites. Source: Syamjith-NK/arabic-lint.

What this does NOT cover

Stated plainly, because it is the obvious next question:

• Microsoft Word itself, InDesign and LaTeX are untested. LibreOffice covers the .docx route because it is the dominant headless converter, but it is a different engine from Word and may lay text out differently. InDesign and LaTeX are not installed here, and WeasyPrint could not run (it needs Pango).
• One font (system Arabic) and one page layout. Embedded subsets and CID fonts may behave differently.
• Extraction only. It says nothing about whether the PDF renders correctly — it does.
• Arabic-Indic digits are not exercised. All five cases use Western digits (2026, 47), so nothing here measures how any extractor handles ٠–٩. That is a separate pypdf bug, and one I reported and fixed: pypdf classified U+0660–U+0669 as right-to-left, so each digit was prepended and ١٢٣٤ extracted as ٤٣٢١. PR #4077 was merged on 14 September 2026 and released in pypdf 6.19.0 (16 September), the version the 9 October re-run used. The table is unaffected either way, because no row in results.jsonl contains an Arabic-Indic digit.

Reproduce

macOS with Google Chrome and LibreOffice in /Applications, and poppler's pdftotext on PATH:

pip install pypdf pdfminer.six reportlab arabic_reshaper python-bidi python-docx
python make_docx.py        # builds docx/<case>.docx: one RTL paragraph, SF Arabic 22 pt
python pdf_bench.py        # writes results.jsonl
python record_versions.py  # writes versions.json

Writes every generator × extractor combination to results.jsonl with the extracted text for each, so the failure modes can be inspected rather than taken on trust. Delete out/ first for a clean run; existing PDFs there are reused.

Corrections

27 October 2026: failure modes re-classified. See the correction under Seven verdicts, six failure modes. task_categories: text-classification and the ocr tag were removed from the metadata, because this dataset is neither, and the Zenodo DOI in Related is now labelled as the audit's.

9 October 2026: full re-run, test string replaced. The name case used a real person's name. It is now a neutral placeholder, سعادة نبيل المهيري, chosen to keep the typographic shape of the original: the same honorific, a four-letter first name that joins throughout, and an ال family name with no lam-alef ligature, a joining run broken by ر, and a final ي. Because the extracted text is measured, the whole matrix was re-run rather than edited:

• The .docx inputs were rebuilt by the new make_docx.py, because the originals were not kept. The first run's tool versions were not recorded; this run's are in versions.json.
• All 60 verdicts are unchanged, including the 12 name rows. The table and the failure-mode counts (22 clean, 23 ligature, 11 reversed, 4 mangled) are identical.
• Three rows changed their extracted text without changing their verdict, all for mixed × LibreOffice. pypdf now drops the space before Pixelogik (still clean, because the comparison ignores whitespace). pdfminer.six and poppler return the same ligature-mode text with the segments split or ordered differently. The likely causes are the rebuilt .docx and the newer LibreOffice and extractors; this run cannot separate them.

Does Arabic Survive the Pipeline?

This is one of three reproducible benchmarks, one per stage of a real production pipeline. Each measures an Arabic failure that looks correct to anyone who does not read Arabic — which is exactly why it ships.

• ArNum-TTS — do numbers survive speech synthesis?
• ArShape — does the standard reshaping recipe survive rendering?
• ArPDF — does Arabic survive a PDF round trip? ← you are here

All three are CC BY 4.0 and ship the scorer, the raw per-item results, and an explicit statement of what the measurement does not establish. Code is MIT (see LICENSE).

Related

This benchmark measures one failure in isolation. syamjithnk/arabic-corpus-audit reports a scan of 341 public Arabic datasets on the Hub, of which 276 were readable, covering 119,517 text fields. A follow-up check of one OCR dataset found stored Arabic presentation forms in all 1,000 sampled labels; this is a sample finding, not a claim that every label is corrupted. The checked labels remain in logical word order, and NFKC normalization recovered ordinary Arabic text in that sample. Presentation-form detection alone does not establish reversed word order or incorrect transcription. See the audit card's correction log for the evidence.

11 October 2026 — wording correction: the earlier summary called the OCR dataset "100% corrupted". The text above replaces that overstatement with the measured sample result and distinguishes stored glyph forms from word order. No benchmark records or scores changed.

The audit is archived on Zenodo: 10.5281/zenodo.22733934 for the version described there, or 10.5281/zenodo.22733933 for all versions. Those DOIs identify the audit, not this benchmark; to cite this dataset, use the BibTeX entry below. (Corrected 27 October 2026: this paragraph previously read as though the DOI belonged to this dataset.)

Sibling benchmarks: arshape (rendering), arnum-tts (speech), arpdf (extraction). The tool: arabic-lint.

Citation

@misc{syamjithnk_arpdf_2026,
  author       = {Syamjith NK},
  title        = {ArPDF: Arabic survival through PDF generation and extraction},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/syamjithnk/arpdf}},
  note         = {Data CC BY 4.0; code MIT}
}