Bayanat-Labs/arabic-unicode-conformance

Arabic Unicode Conformance Suite

300 test cases with the exact expected output of Arabic text normalisation under 6 named policies, and the observed outputs of 7 implementations. Version 0.1.0 (2026-10-15). Code and runner: GitHub. Published by Bayanat Labs (bayanatlabs.com). Arabic summary at the end of this card.

What it is

Arabic text normalisation (removing harakat and tatweel, folding alef forms, mapping presentation forms such as ﻻ, handling ZWNJ, bidi controls and Arabic-Indic digits) is done differently by every tool, and reports rarely say exactly what was done, so word error rates and deduplication counts computed with different tools are not comparable. This dataset pins the behaviour down: each case gives an input string (with its code points and UTF-8 bytes) and the exact output under six named policies: identity, nfc, nfkc, and the three policies of the open-source library arabic-normalize: raw-safe-v1 (cleaning only), bayanat-norm-v1 (a normalised text column) and asr-eval-v1 (speech recognition scoring). The policies are defined stage by stage in policies/BAYANAT-NORM-V1.md.

arabic-normalize also ships 80 conformance fixtures (Bayanat-Labs/arabic-normalization-conformance); this suite is broader, with more categories, more policies and more implementations.

Intended uses: testing an Arabic normaliser against a named policy; stating which normalisation a word error rate or a search index used; comparing tools on Arabic Unicode edge cases. Out-of-scope uses: training or evaluating language models (the set is small and synthetic); statistics about how often a phenomenon occurs in real text; judging whether a policy is linguistically right for a task (the policies are choices).

What is released

Config	Split	One row per	Rows
cases (default)	test	case, with the expected output of every policy in its own column	300
expectations	test	case and policy, with exact expected code points	1800
observations	test	implementation pipeline and case: the output it gave and whether it matched	6000

Also in the repository: jsonl/ (the same cases and observations as JSON Lines, with invisible characters written as \uXXXX escapes), conformance/ (the conformance matrix as CSV and HTML, and the versions of every tool run), policies/ (policy specs and the normative text in English and Arabic), MANIFEST.json and SHA256SUMS.

How to load

from datasets import load_dataset
cases = load_dataset("Bayanat-Labs/arabic-unicode-conformance", "cases", split="test")

def exact_input(row):  # rebuilds the exact input, lone surrogates included
    return "".join(chr(int(cp[2:], 16)) for cp in row["input_codepoints"])

failures = [r["case_id"] for r in cases
            if r["input_kind"] == "text" and my_normaliser(exact_input(r)) != r["expected_bayanat_norm_v1"]]

The runner on GitHub does the same for several tools and builds the matrix: pip install "git+https://github.com/Bayanat-Labs/arabic-unicode-conformance@v0.1.0", then arabic-unicode-conformance run --impl <adapter>. The package will also be installable with pip install arabic-unicode-conformance once it is published.

Breakdown

Cases	300 (297 text inputs, 3 raw-byte inputs that are not valid UTF-8)
Inputs with a lone surrogate	2
Levels	264 must, 36 should
Cases with letters that must survive (must_preserve)	23
Language tags	14 (ar 237, fa 21, und 21, ur 6, en 3, ary 2, ckb 2, ug 2, ar-DZ 1, ar-Latn 1, ar-MA 1, hi 1, kk 1, ps 1)

Category	Cases	must	should
alef	18	15	3
bidi	18	15	3
confusables	12	12	0
diacritic_order	22	17	5
dialect_letters	15	15	0
digits	24	22	2
hamza	23	21	2
joiners	18	11	7
lam_alef	14	13	1
malformed	14	13	1
mixed_script	10	10	0
presentation_forms	26	18	8
punctuation	14	14	0
quranic	18	16	2
spaces	12	12	0
taa_marbuta	10	10	0
tatweel	14	13	1
yeh	18	17	1

Policy	Text cases whose expected output differs from the input	Defined by
identity	0 of 297	definition
nfc	32 of 297	Python unicodedata.normalize('NFC'), Unicode 16.0.0
nfkc	85 of 297	Python unicodedata.normalize('NFKC'), Unicode 16.0.0
raw-safe-v1	65 of 297	arabic-normalize policy, SHA-256 57c3d9f03fb9b6854f2527cd1e8a47cadc266f47f02dda94652306dacea03bb5
bayanat-norm-v1	196 of 297	arabic-normalize policy, SHA-256 ebdb82000d0762a65120ffa9311bc6f01b481b19d4348ea5bedb3ab23d759321
asr-eval-v1	226 of 297	arabic-normalize policy, SHA-256 5d866146536a23b90c0882044dae5f55f2484f0635e206828246eabeb69668de

Conformance matrix

Conformance rows are implementations that claim the policy. Agreement rows are tools that claim no suite policy, compared with the closest one; low agreement means the tool normalises differently, not that it is wrong. "Same tokens" ignores whitespace differences only. The three raw-byte cases are not applicable to tools that accept only strings. The exact calls are listed in ADAPTERS.md on GitHub.

Implementation	Version	Pipeline	Policy	Relation	Pass	Same tokens
Python unicodedata.normalize	3.14.7	py-nfc	nfc	conformance	300/300 (100.0%)	100.0%
Python unicodedata.normalize	3.14.7	py-nfkc	nfkc	conformance	300/300 (100.0%)	100.0%
Node.js String.prototype.normalize (ICU)	78.2	icu-nfc	nfc	conformance	300/300 (100.0%)	100.0%
Node.js String.prototype.normalize (ICU)	78.2	icu-nfkc	nfkc	conformance	300/300 (100.0%)	100.0%
arabic-normalize (Python)	0.1.0	an-py-raw-safe-v1	raw-safe-v1	conformance	300/300 (100.0%)	100.0%
arabic-normalize (Python)	0.1.0	an-py-bayanat-norm-v1	bayanat-norm-v1	conformance	300/300 (100.0%)	100.0%
arabic-normalize (Python)	0.1.0	an-py-asr-eval-v1	asr-eval-v1	conformance	300/300 (100.0%)	100.0%
arabic-normalize (JavaScript)	0.1.0	an-js-raw-safe-v1	raw-safe-v1	conformance	300/300 (100.0%)	100.0%
arabic-normalize (JavaScript)	0.1.0	an-js-bayanat-norm-v1	bayanat-norm-v1	conformance	300/300 (100.0%)	100.0%
arabic-normalize (JavaScript)	0.1.0	an-js-asr-eval-v1	asr-eval-v1	conformance	300/300 (100.0%)	100.0%
arabic-normalize (JavaScript)	0.1.0	an-js-nfc	nfc	conformance	300/300 (100.0%)	100.0%
arabic-normalize (JavaScript)	0.1.0	an-js-nfkc	nfkc	conformance	300/300 (100.0%)	100.0%
CAMeL Tools	1.6.0	camel-unicode-nfc	nfc	agreement	297/297 (100.0%)	100.0%
CAMeL Tools	1.6.0	camel-unicode	nfkc	agreement	295/297 (99.3%)	99.3%
CAMeL Tools	1.6.0	camel-norm	bayanat-norm-v1	agreement	178/297 (59.9%)	62.3%
CAMeL Tools	1.6.0	camel-norm-teh	asr-eval-v1	agreement	156/297 (52.5%)	55.6%
PyArabic	0.6.15	pyarabic-norm	bayanat-norm-v1	agreement	177/297 (59.6%)	59.6%
PyArabic	0.6.15	pyarabic-norm-teh	asr-eval-v1	agreement	146/297 (49.2%)	53.2%
Whisper BasicTextNormalizer	0.1.15	whisper-basic	asr-eval-v1	agreement	79/297 (26.6%)	40.7%
Whisper BasicTextNormalizer	0.1.15	whisper-basic-rd	asr-eval-v1	agreement	132/297 (44.4%)	49.8%

Run on 2026-10-15 with: Python unicodedata.normalize (tool Python unicodedata, version 3.14.7, unicode 16.0.0); Node.js String.prototype.normalize (ICU) (node 22.23.2, icu 78.2, icu_unicode 17.0, tool Node.js String.prototype.normalize (ICU), version 78.2); arabic-normalize (Python) (tool arabic-normalize (Python), version 0.1.0, unicode 18.0.0, python 3.14.7); arabic-normalize (JavaScript) (node 22.23.2, icu 78.2, icu_unicode 17.0, tool arabic-normalize (JavaScript), version 0.1.0, unicode 18.0.0); CAMeL Tools (tool camel-tools, version 1.6.0, python 3.12.14, unicodedata 15.0.0); PyArabic (tool PyArabic, version 0.6.15, python 3.12.14, unicodedata 15.0.0); Whisper BasicTextNormalizer (tool whisper-normalizer, version 0.1.15, python 3.12.14, unicodedata 15.0.0). Tools were run unmodified, through their public functions, each in its own environment; PyArabic (GPL) ran as a separate process. Maintainers and users are welcome to send corrections to hello@bayanatlabs.com.

Structure (config cases)

Field	Type	Description
case_id	string	Stable id, never reused (ar-uc-<category>-<nnn>)
category, level	string	Phenomenon tested; must or should
language_tag	string	Language of the input (und when not language-specific); the policies do not depend on it
input_kind	string	text, or utf8_bytes for raw bytes that are not valid UTF-8
input	string, nullable	The input. Null for raw-byte inputs and for inputs holding a lone surrogate (Parquet strings must be valid UTF-8): rebuild those from input_codepoints
input_codepoints	list of string	Exact input code points (U+0649)
input_utf8_hex	string, nullable	UTF-8 bytes in hex; the raw bytes for utf8_bytes inputs; null when the input holds a lone surrogate
expected_identity ... expected_asr_eval_v1	string, nullable	Expected output per policy; null when the input must be rejected or when the output holds a lone surrogate (the expectations config has the exact code points)
expected_error	string, nullable	invalid_utf8 when every policy must reject the input
must_preserve	list of string	Code points that raw-safe-v1, bayanat-norm-v1 and asr-eval-v1 must keep
rationale_en, references	string, list	Why the expected outputs are what they are, and the specifications behind them
nfc_nfkc_unicode_version	string	Unicode version of the nfc and nfkc expectations (16.0.0; every input uses code points assigned since Unicode 13.0.0)
added_in, author, synthetic, review_status	string, bool	Suite version, authorship (Bayanat Labs), synthetic: true, review status

Creation

• Every input was written by Bayanat Labs for this suite; no text is taken from a corpus or from another project's tests (synthetic: true).
• identity, nfc and nfkc expectations: Python 3.14 unicodedata (Unicode 16.0.0).
• raw-safe-v1, bayanat-norm-v1 and asr-eval-v1 expectations: an independent reference implementation written from the stage definitions; many were also stated explicitly in the case source and checked against it. arabic-normalize (Python and JavaScript, commit 3ad22326a66596e8dc413321017251eed6e60439) passes every case.
• Every expected output is a fixed point of its policy (checked by the build).
• Review status: not yet reviewed by native Arabic speakers (review_status: "pending native review").

Considerations and limitations

• The policies are choices: folding أ to ا or ى to ي merges some distinct words, and asr-eval-v1 splits numbers at Arabic separators. The suite tests that a normaliser does what a policy says.
• The cases show behaviour; they say nothing about frequency in real text.
• Agreement rows depend on how each tool's functions were combined into a pipeline; other combinations exist.
• Bidi display order and glyph shaping are not tested.
• Personal data: none. Common names such as محمد and مصطفى appear only as spelling examples.

Licensing

CC BY 4.0. Attribute as "Arabic Unicode Conformance Suite, Bayanat Labs, CC BY 4.0". The runner code on GitHub is Apache-2.0. The observations config records outputs of third-party tools; the tools keep their own licences.

Citation

@misc{bayanatlabs_arabic_unicode_conformance_2026,
  title  = {Arabic Unicode Conformance Suite},
  author = {{Bayanat Labs}},
  year   = {2026},
  note   = {Version 0.1.0},
  url    = {https://huggingface.co/datasets/Bayanat-Labs/arabic-unicode-conformance}
}

Contact, corrections and takedown

hello@bayanatlabs.com. Bayanat Labs also builds Arabic speech and text datasets for evaluation and training.

Changelog

Version	Date	Change
0.1.0	2026-10-15	First release: 300 cases, 6 policies, 7 implementations

بالعربية

The Arabic text has not yet been reviewed by a native Arabic writer; the English governs.

حزمة اختبار مفتوحة لتوحيد النص العربي: 300 حالة، لكل منها نص مدخل ونقاط ترميزه وبايتاته، والناتج الدقيق المتوقع تحت 6 سياسات مسمّاة (identity وnfc وnfkc وraw-safe-v1 وbayanat-norm-v1 وasr-eval-v1)، مع مخرجات 7 تطبيقات مسجّلة في مصفوفة مطابقة. تغطي الحالات التطويل والهمزات وصور الألف والألف المقصورة والتاء المربوطة وترتيب الحركات والعلامات القرآنية والأرقام وأشكال العرض ولام ألف والفاصل غير الواصل ومحارف الاتجاه وعلامات الترقيم والمسافات وحروف اللهجات (ڤ ڨ ݣ ڭ پ چ گ) والمحارف المتشابهة والمدخلات المعيبة. كتبت بيانات لابز كل الحالات لهذه الحزمة، والترخيص CC BY 4.0. النص المعياري للسياسات بالعربية في policies/BAYANAT-NORM-V1.ar.md.