ihash 0.1.2

World's fastest high-quality non-cryptographic hash, deterministic cross-platform XOF, and seekable stream cipher
Documentation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
[![crates.io](https://img.shields.io/crates/v/ihash.svg)](https://crates.io/crates/ihash) [![docs.rs](https://img.shields.io/docsrs/ihash)](https://docs.rs/ihash) [![license](https://img.shields.io/badge/license-MulanPSL--2.0-blue.svg)](https://license.coscl.org.cn/MulanPSL2)

[![English](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/en.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/en/README.md) [![简体中文](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/zh.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/zh/README.md) [![Français](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/fr.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/fr/README.md) [![Deutsch](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/de.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/de/README.md) [![Español](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/es.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/es/README.md) [![日本語](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ja.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ja/README.md) [![العربية](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ar.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ar/README.md) [![Português](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/pt.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/pt/README.md) [![Русский](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ru.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ru/README.md) [![Italiano](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/it.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/it/README.md) [![Nederlands](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/nl.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/nl/README.md) [![한국어](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ko.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ko/README.md) [![Türkçe](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/tr.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/tr/README.md) [![Indonesia](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/id.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/id/README.md) [![正體中文](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/zh-TW.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/zh-TW/README.md) [![हिन्दी](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/hi.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/hi/README.md) [![Polski](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/pl.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/pl/README.md) [![தமிழ்](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ta.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ta/README.md) [![Gaeilge](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ga.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ga/README.md) [![Svenska](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/sv.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/sv/README.md) [![বাংলা](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/bn.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/bn/README.md) [![עברית](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/he.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/he/README.md) [![ไทย](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/th.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/th/README.md) [![Norsk](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/no.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/no/README.md) [![Tiếng Việt](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/vi.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/vi/README.md) [![मराठी](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/mr.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/mr/README.md) [![Bahasa Melayu](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ms.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ms/README.md) [![Dansk](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/da.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/da/README.md) [![Română](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ro.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ro/README.md) [![اردو](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ur.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ur/README.md) [![Čeština](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/cs.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/cs/README.md) [![فارسی](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/fa.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/fa/README.md) [![తెలుగు](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/te.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/te/README.md) [![ਪੰਜਾਬੀ](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/pa.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/pa/README.md) [![ಕನ್ನಡ](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/kn.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/kn/README.md) [![ગુજરાતી](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/gu.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/gu/README.md) [![Ελληνικά](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/el.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/el/README.md) [![Suomi](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/fi.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/fi/README.md) [![Català](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ca.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ca/README.md) [![Gàidhlig](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/gd.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/gd/README.md) [![Қазақша](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/kk.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/kk/README.md) [![Filipino](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/tl.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/tl/README.md) [![Kiswahili](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/sw.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/sw/README.md) [![ئۇيغۇرچە](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ug.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ug/README.md) [![Magyar](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/hu.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/hu/README.md) [![Українська](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/uk.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/uk/README.md) [![Oʻzbekcha](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/uz.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/uz/README.md) [![മലയാളം](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ml.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ml/README.md) [![Slovenčina](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/sk.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/sk/README.md) [![Afrikaans](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/af.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/af/README.md) [![Hrvatski](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/hr.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/hr/README.md) [![Српски](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/sr.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/sr/README.md) [![Български](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/bg.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/bg/README.md) [![Brezhoneg](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/br.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/br/README.md) [![አማርኛ](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/am.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/am/README.md) [![Cymraeg](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/cy.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/cy/README.md) [![ଓଡ଼ିଆ](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/or.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/or/README.md) [![සිංහල](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/si.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/si/README.md) [![Hausa](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ha.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ha/README.md) [![Euskara](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/eu.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/eu/README.md) [![Ślōnskŏ](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/szl.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/szl/README.md) [![Lietuvių](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/lt.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/lt/README.md) [![Беларуская](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/be.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/be/README.md) [![IsiZulu](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/zu.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/zu/README.md) [![Galego](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/gl.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/gl/README.md) [![မြန်မာ](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/my.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/my/README.md) [![Slovenščina](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/sl.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/sl/README.md) [![Azərbaycanca](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/az.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/az/README.md) [![অসমীয়া](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/as.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/as/README.md) [![ខ្មែរ](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/km.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/km/README.md) [![नेपाली](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ne.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ne/README.md) [![Kurdî](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ku.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ku/README.md) [![IsiXhosa](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/xh.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/xh/README.md) [![Latviešu](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/lv.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/lv/README.md) [![Eesti](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/et.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/et/README.md) [![Татарча](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/tt.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/tt/README.md) [![Íslenska](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/is.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/is/README.md) [![ქართული](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ka.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ka/README.md) [![Bosanski](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/bs.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/bs/README.md) [![Shqip](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/sq.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/sq/README.md) [![Հայերեն](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/hy.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/hy/README.md) [![Монгол](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/mn.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/mn/README.md) [![Кыргызча](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ky.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ky/README.md) [![Македонски](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/mk.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/mk/README.md) [![ລາວ](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/lo.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/lo/README.md) [![Тоҷикӣ](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/tg.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/tg/README.md) [![Ikinyarwanda](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/rw.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/rw/README.md) [![Esperanto](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/eo.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/eo/README.md) [![Filipino](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/fil.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/fil/README.md) [![Nynorsk](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/nn.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/nn/README.md) [![سۆرانی](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/ckb.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/ckb/README.md) [![Wolof](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/wo.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/wo/README.md) [![Frysk](https://fastly.jsdelivr.net/npm/@i18n.site/svg@2.2.2/fy.svg)](https://atomgit.com/i18n-site/rs/blob/main/ihash/i18n/fy/README.md)

# ihash

A cross-platform non-cryptographic hash library built on the AES round function, with extendable output and addressable stream-cipher support.

Benchmarked on 4 `x86_64` and `aarch64` hosts, full-length slice and `HashMap` combined throughput both rank first among 16 tested algorithms, and all 32 / 64 / 128 / 256-bit variants **pass all 20 statistical quality test suites of [smhasher3](https://crates.io/crates/smhasher3) with zero failures** (non-cryptographic use; no cryptographic collision-resistance guarantee is provided).

General-purpose non-cryptographic hashes often face two kinds of engineering trade-offs:

- Implementations that only pursue hash-table speed do not guarantee cross-architecture result consistency.
- Implementations targeting hardware instruction sets only cannot compile under WebAssembly or in environments without AES extensions.

`ihash` provides 32 / 64 / 128 / 256-bit prefix-consistent digests, arbitrary-length streaming keystreams, and an 8-byte hash table state.

Outputs are bit-identical across `x86_64`, `x86`, `aarch64`, the built-in scalar T-table fallback ([soft.rs](https://atomgit.com/i18n-site/rs/blob/main/ihash/src/arch/soft.rs)), and pure CPU software vector ([fearless_simd](https://docs.rs/fearless_simd)); supports `#![no_std]` and C ABI export.

- [Performance Benchmark](#performance-benchmark)
- [Usage](#usage)
  - [Build Configuration](#build-configuration)
- [Interface](#interface)
  - [Seedless Default Interface](#seedless-default-interface)
  - [Explicit Seed Module](#explicit-seed-module)
  - [Pure Software Fallback and C Interface](#pure-software-fallback-and-c-interface)
- [Feature Flags](#feature-flags)
- [Extendable Output and Addressable Stream](#extendable-output-and-addressable-stream)
  - [Prefix Consistency and Random Access](#prefix-consistency-and-random-access)
  - [Use Cases](#use-cases)
- [Selection Comparison](#selection-comparison)
  - [Output Bit Width and Streaming Extension](#output-bit-width-and-streaming-extension)
  - [Cross-Platform Consistency and Runtime Environment](#cross-platform-consistency-and-runtime-environment)
  - [State Size and Hash Table Overhead](#state-size-and-hash-table-overhead)
- [Hash Quality](#hash-quality)
- [Design Principles](#design-principles)
  - [Tiered Absorption](#tiered-absorption)
  - [Asymmetric Finalization and High-Half Derivation](#asymmetric-finalization-and-high-half-derivation)
  - [Extended Output and Stream Cipher](#extended-output-and-stream-cipher)
  - [Hardware Adaptation and Software Fallback](#hardware-adaptation-and-software-fallback)
  - [Hash Table State and Seed Isolation](#hash-table-state-and-seed-isolation)
- [Performance Benchmark Details](#performance-benchmark-details)
  - [Apple M2 Max](#apple-m2-max)
  - [Intel Xeon Platinum 8269CY](#intel-xeon-platinum-8269cy)
  - [AMD EPYC](#amd-epyc)
  - [ARM Neoverse-N1](#arm-neoverse-n1)
  - [Cross-platform consistency](#cross-platform-consistency)

## Performance Benchmark

The following summarizes cross-platform geometric-mean performance across 4 benchmarked hosts (Apple M2 Max, Intel Xeon Platinum 8269CY, AMD EPYC, ARM Neoverse-N1); see [smhasher3](https://crates.io/crates/smhasher3) for the full 16-algorithm ranking and failure list.

Per-platform tier details and charts are available in [Performance Benchmark Details](#performance-benchmark-details) at the end of the document.

![Cross-Platform Geometric Mean Throughput Comparison](https://x-0.kdns.fr/JGC-Jgtl6mmGyU7nu0WZJcU_vTa15KdAmIE4F8-FGPU)

Comparison libraries include [gxhash](https://docs.rs/gxhash) (v4, `gxhash4`), [lanehash](https://crates.io/crates/lanehash) (AES variant `lh_aes` and pure-arithmetic variant `lanehash64`), [foldhash](https://docs.rs/foldhash) (`foldhash_fast` and `foldhash_quality`), [rapidhash](https://docs.rs/rapidhash), [xxhash-rust](https://docs.rs/xxhash-rust) (`xxh3`), [ahash](https://docs.rs/ahash), [rustc-hash](https://docs.rs/rustc-hash) (`fxhash`), and the standard library `std`.

Cross-host geometric-mean throughput for slice scenarios (unit: GiB/s, higher is faster):

| Algorithm | Short slice 4..=128 B | Long slice 256 B..=256 KiB | Random short slice | Geometric mean |
| --- | ---: | ---: | ---: | ---: |
| ihash | 7.44 | 45.99 | 4.96 | 19.84 |
| gxhash4 | 6.35 | 42.78 | 4.29 | 17.74 |
| foldhash_fast | 5.92 | 15.91 | 3.87 | 10.07 |
| lh_aes | 2.36 | 31.48 | 2.05 | 9.53 |
| lanehash64 | 3.08 | 23.33 | 2.29 | 9.17 |
| xxh3 | 4.23 | 15.29 | 2.53 | 8.45 |
| ahash | 4.14 | 8.39 | 3.15 | 6.06 |

`HashMap` multi-key-type cross-host geometric-mean throughput (10,000 keys, including 32..=59 B URLs, unit Mop/s, higher is faster):

| Hasher | u64 R/W | Short string R/W | URL R/W | Total geometric mean |
| --- | ---: | ---: | ---: | ---: |
| ihash | 129.3 | 28.1 | 16.3 | 38.9 |
| foldhash_fast | 136.5 | 24.8 | 14.4 | 36.5 |
| fxhash | 138.6 | 23.8 | 14.6 | 36.4 |
| foldhash_quality | 116.2 | 23.8 | 14.5 | 34.2 |
| rapidhash | 115.8 | 22.4 | 13.4 | 32.6 |
| ahash | 117.5 | 21.7 | 13.4 | 32.5 |
| gxhash4 | 109.7 | 22.3 | 13.5 | 32.1 |
| std | 58.8 | 18.4 | 11.0 | 22.9 |

Quality and scenario notes:

- `gxhash4` fails 4 `SMHasher3` test suites (`Zeroes`, `SeedZeroes`, `SeedBlockLen`, `SeedBlockOffset`).
- `fxhash` and `foldhash_fast` omit or simplify the avalanche finalization to accelerate short-key reads/writes and fail `SMHasher3` tests; see [smhasher3](https://crates.io/crates/smhasher3) for the complete failure details.
- All 32 / 64 / 128 / 256-bit variants of `ihash` pass all 20 test suites with zero failures; see [Hash Quality](#hash-quality) for details.

## Usage

Full example code: [`examples/basic.rs`](https://atomgit.com/i18n-site/rs/blob/main/ihash/examples/basic.rs), run command:

```bash
cargo run -p ihash --example basic --all-features
```

```rust
use std::hash::Hasher;

#[cfg(feature = "cpu")]
use ihash::cpu;
use ihash::{
  HashMap, HashMapExt, HashSet, HashSetExt, IHasher, Stream, hash_xof, hash32, hash64, hash128,
  hash256, seed,
};

fn main() {
  let msg = b"Hello World";

  // Seedless default API (deterministic & bit-exact across x86_64, aarch64, and pure CPU).
  println!("hash32  = 0x{:08x}", hash32(msg));
  println!("hash64  = 0x{:016x}", hash64(msg));
  println!("hash128 = 0x{:032x}", hash128(msg));
  println!("hash256 = {:02x?}", &hash256(msg)[..8]);

  // Extendable-output hash (XOF).
  let mut xof_li = [0u8; 64];
  hash_xof(msg, &mut xof_li);
  println!("xof[..8]= {:02x?}", &xof_li[..8]);

  // Explicit seed API lives under `ihash::seed`.
  println!("seed64  = 0x{:016x}", seed::hash64(msg, 42));

  // Seekable stream cipher (default unseeded key or seeded keystream).
  let mut buf_li = *b"fast non-cryptographic stream cipher";
  let mut enc = seed::keystream(12345);
  enc.xor_keystream(&mut buf_li);
  let mut dec = seed::keystream(12345);
  dec.xor_keystream(&mut buf_li);
  println!("stream  = {}", String::from_utf8_lossy(&buf_li));
  let mut key_stream = Stream::new(msg);
  key_stream.xor_keystream(&mut buf_li[..8]);

  // Stateful Hasher and standard-style HashMap / HashSet.
  let mut hasher = IHasher::new();
  hasher.write(msg);
  hasher.write_u64(12345);
  println!("hasher  = 0x{:016x}", hasher.finish());

  let mut map: HashMap<&str, usize> = HashMap::new();
  map.insert("ihash", 1);
  let mut set: HashSet<&str> = HashSet::new();
  set.insert("ihash");
  println!(
    "map/set = {:?} / {}",
    map.get("ihash"),
    set.contains("ihash")
  );

  // Optional pure-CPU SIMD fallback (feature = "cpu").
  #[cfg(feature = "cpu")]
  println!("cpu64   = 0x{:016x}", cpu::hash64(msg));
}
```

### Build Configuration

It is recommended to enable hardware AES and base SIMD features in `.cargo/config.toml` at the project or workspace root:

```toml
[target.'cfg(target_arch = "x86_64")']
rustflags = ["-C", "target-feature=+aes,+sse2"]

[target.'cfg(target_arch = "aarch64")']
rustflags = ["-C", "target-feature=+aes,+neon"]
```

Why is it necessary to enable?

- Rust compiles to the lowest common instruction baseline by default; without `+aes`, hardware AES must be dispatched through a runtime function-pointer table, and the compiler cannot inline it into `HashMap` probe loops or `<= 128 B` short-key call sites.
- Once enabled, `0..=128 B` inputs can be directly inlined as native AES instructions across crate boundaries; with `std` enabled, `x86_64` automatically upgrades `> 128 B` inputs at runtime to `AVX + AES`, `AVX2 + VAES`, or `AVX-512F + VAES`.
- Hardware availability: `x86_64` from Intel Westmere (2010), AMD Bulldozer (2011) and later, as well as mainstream server and desktop/mobile `aarch64` processors, all ship with native hardware AES.
- Environments without hardware AES: omitting `rustflags` automatically falls back to the built-in scalar T-table; `RISC-V` and `WebAssembly` require no extra configuration. For pure CPU software-vector acceleration, enable the `cpu` feature and call `ihash::cpu`.

## Interface

### Seedless Default Interface

- `hash32(data: &[u8]) -> u32`
- `hash64(data: &[u8]) -> u64`
- `hash128(data: &[u8]) -> u128`
- `hash256(data: &[u8]) -> [u8; 32]`
- `hash_xof(data: &[u8], out: &mut [u8])`
- `Stream`: `Stream::new(data)`, `Stream::from_root(root)`, `root()`, `position()`, `seek(pos)`, `fill(out)`, `xor_keystream(buf)`; implements `std::io::Read` when `std` is enabled
- `IHasher`: `new()`, `finish_u128()`, implements `core::hash::Hasher`
- `IBuildHasher`: `new()`, `default()` (per-thread random independent seed under `std`; seed `0` fallback under `no_std`)
- `HashMap<K, V>`, `HashSet<T>`, `HashMapExt`, `HashSetExt` (available when `std` is enabled; support `new()` and `with_capacity(cap)`)

### Explicit Seed Module

When a fixed `u64` seed is supplied, call the corresponding functions under `ihash::seed`:

- `seed::hash32(data, seed)`, `seed::hash64(data, seed)`, `seed::hash128(data, seed)`, `seed::hash256(data, seed)`
- `seed::hash_xof(data, seed, out)`
- `seed::stream(data, seed)`, `seed::keystream(seed)` (derived from `hash256(&[], seed)`)
- `seed::hasher(seed)`, `seed::build_hasher(seed)`, `seed::hash_map(seed)`, `seed::hash_set(seed)` (the latter two require `std`)

### Pure Software Fallback and C Interface

- `ihash::cpu` (requires the `cpu` feature): mirrors all root-module functions, `Stream`, `IHasher`, `IBuildHasher`, `HashMap` / `HashSet` (requires `std`; shares root-module `HashMapExt` / `HashSetExt`), and the `cpu::seed` submodule. Provides `*_with_level`, `with_level`, and `from_root_with_level` entry points that accept a specified `fearless_simd::Level` for free functions, `Stream`, `IHasher`, `IBuildHasher`, and seeded collection constructors.
- `ihash::c` (requires the `c` feature): exports C ABI symbols consistent with the header file [`include/ihash.h`](https://atomgit.com/i18n-site/rs/blob/main/ihash/include/ihash.h) (`ihash_hash32`, `ihash_hash64`, `ihash_hash128`, `ihash_hash128_out`, `ihash_hash256`, `ihash_hash_xof`, `ihash_xor_stream`, and corresponding `*_seed` entry points). Build a static library with `cargo rustc -p ihash --release --features c --crate-type staticlib`.

## Feature Flags

- `std` (enabled by default): enables `HashMap` / `HashSet`, runtime instruction-set dispatch, `std::io::Read`, and per-thread random hash-table seeds. When disabled, the crate operates in a `#![no_std]` environment.
- `cpu`: Enables the `ihash::cpu` pure-software AES + SIMD fallback implementation.
- `c`: Exports the stable C ABI symbols from `ihash::c`.

## Extendable Output and Addressable Stream

### Prefix Consistency and Random Access

Traditional hashes return fixed-length integers; obtaining more pseudorandom bytes typically requires re-hashing with a salt. `ihash` extends the output to an arbitrary-length byte stream:

- Bit-exact prefixes: the first 4, 8, 16, and 32 bytes of `hash32`, `hash64`, `hash128`, and `hash256` are bit-identical to the corresponding prefixes of `hash_xof` and `Stream` output. Multiple bit-width digests of the same input can be extracted in one pass without re-hashing.
- Constant-time seeking: `Stream::seek(pos)` computes the keystream at any byte offset or performs in-place XOR decryption directly by block number, without sequentially generating preceding bytes.

### Use Cases

- Deriving multiple parameter sets from a single digest: compute `hash256` once or read from `hash_xof`, then split out multiple index sets, weight tables, or initialization vectors for Bloom filters.
- Sharded stream obfuscation and concurrent reads: multiple threads share the same 256-bit root, `seek` to their respective offsets, and execute `xor_keystream` in parallel.
- Deterministic stress testing and corpus generation: stream GB-scale reproducible pseudorandom payloads via `Stream`, eliminating the need to pre-allocate entire memory blocks.

`Stream` targets high-speed non-cryptographic stream obfuscation; use a standard cryptographic suite when cryptographic confidentiality and attack resistance are required.

## Selection Comparison

Beyond throughput, selection also requires evaluating output bit width, cross-platform consistency, and struct size.

### Output Bit Width and Streaming Extension

| Algorithm | Output bit width | Extended output | Output stream random access |
| --- | --- | --- | --- |
| ihash | 32 / 64 / 128 / 256 | Supported | Supported |
| gxhash | 32 / 64 / 128 | Not supported | Not supported |
| lanehash | 64 / 128 | Not supported | Not supported |
| xxh3 | 64 / 128 | Not supported | Not supported |
| foldhash | 64 | Not supported | Not supported |
| ahash | 64 | Not supported | Not supported |
| fxhash | 32 / 64 | Not supported | Not supported |

32 / 64-bit widths suit in-memory hash tables and shard modulo; use 128 / 256-bit for persistent content addressing, content chunk deduplication, or billion-scale object caches.

`ihash` prunes upper-half rounds via compile-time const generics, incurring zero extra round overhead for short-digest calls.

### Cross-Platform Consistency and Runtime Environment

| Algorithm | Cross-platform consistency | Hardware AES absence fallback | `#![no_std]` |
| --- | --- | --- | --- |
| ihash | Hardware / software / scalar | Supported | Supported |
| gxhash | Consistent within the same major hardware version | Compile failure | Supported |
| lanehash | Cross-platform consistent | Supported | Supported |
| xxh3 | Cross-platform consistent | Supported | Supported |
| foldhash | Not guaranteed | Supported | Supported |
| ahash | Not guaranteed | Supported | Supported |
| fxhash | Not guaranteed | Supported | Supported |

`foldhash`, `ahash`, and `fxhash` target single-process in-memory hash tables and do not guarantee cross-architecture digest equality; persistent index verification and cross-end cache sharding require cross-platform bit-exact consistency.

### State Size and Hash Table Overhead

The following shows struct sizes for streaming hashers and table-seed state of each library on 64-bit targets (unit: bytes; `ahash` streaming state is 32 bytes under soft fallback, 48 bytes with `x86_64` hardware AES; `xxh3` with a custom seed/key raises the constructor and streaming state to 216 and 576 bytes respectively):

| Algorithm | Streaming state size | Table seed state size |
| --- | ---: | ---: |
| ihash | 8 | 8 |
| gxhash | 16 | 16 |
| lanehash | 48 | 24 |
| xxh3 | 384 | 0 |
| foldhash | 48 | 8 |
| ahash | 32 | 32 |
| fxhash | 8 | 0 |
| std | 72 | 16 |

Both `IBuildHasher` and `IHasher` occupy only 8 bytes, reducing metadata memory footprint when maintaining large numbers of small tables, and the hot path can reside in a single 64-bit general-purpose register.

## Hash Quality

Against the full 20-suite quality battery of pure-Rust [smhasher3](https://crates.io/crates/smhasher3), all 4 output bit widths pass with zero failures (covering `Sanity`, `Avalanche`, `BIC`, `Sparse` with 512-bit 22,370,049 sparse keys, `Permutation`, `Cyclic`, `TwoBytes`, `PerlinNoise`, `Bitflip`, `Seed*`, and `BadSeeds`):

| Algorithm | Bit width | Suites passed | Sub-items passed | Failures |
| --- | ---: | ---: | ---: | ---: |
| ihash32 | 32 | 20 / 20 | 188 / 188 | 0 |
| ihash64 | 64 | 20 / 20 | 189 / 189 | 0 |
| ihash128 | 128 | 20 / 20 | 189 / 189 | 0 |
| ihash256 | 256 | 20 / 20 | 187 / 187 | 0 |

## Design Principles

`ihash` combines [gxhash](https://docs.rs/gxhash)'s single-instruction AES round-function diffusion, [lanehash](https://crates.io/crates/lanehash)'s multi-lane parallel striding, and [foldhash](https://docs.rs/foldhash)'s single-register state folding, ensuring every 16 bytes of input undergo at least one full AES state transformation.

At compile time, all round constants and 16-lane initial keys are generated from a fixed master seed via `SplitMix64` and packed into a 64-byte-aligned read-only constant table `TBL`; for the seedless fast path, `TBL` pre-expands `sv0 = F(fin_li[6])` and pre-XORed keys `lane_sv0_li[i] = lane_li[i] ^ sv0`, eliminating per-call seed expansion.

In what follows, `F(x) = MixColumns(ShiftRows(SubBytes(x)))` denotes a full unkeyed AES round, `FL(x) = ShiftRows(SubBytes(x))` denotes the final AES round without MixColumns, `+` denotes wrapping vector addition across two 64-bit lanes (`u64x2::wrapping_add`), and the four-lane broadcast length key is denoted `lk = [len32; 4]` (for `> 2048 B`, the high 32 bits are folded into `(len as u32) ^ ((len >> 32) as u32)`).

### Tiered Absorption

| Length tier | Parallel lanes | Absorption & mixing structure |
| --- | ---: | --- |
| `0..=16 B` | 1 | `16 B` full-block load; `8..=15 B` dual 8B head/tail; `4..=7 B` dual 4B head/tail; `1..=3 B` sample `[0, len >> 1, len - 1]`; `0 B` zero vector; with seed: expand `sv = F([seed, seed] ^ c)`, compute `u = F(F(b ^ sv) ^ lk)`, feedforward output `lo = F(u) + u` |
| `17..=32 B` | 2 | Two-lane parallel absorption of 16B head/tail yields `a = F(b0 ^ k0)` and `c = F(b1 ^ k1)`; lane 0 mixes in `lk` through one round of `F` before merging with lane 1: `u = F(F(a ^ lk) ^ c)`, feedforward output `lo = F(u) + u` |
| `33..=64 B` | 4 | Four-lane parallel absorption of 32B head/tail (`[ptr, ptr+16, end-32, end-16]`) yields `l_i = F(b_i ^ key_i)`, entering the 4-lane asymmetric finalizer |
| `65..=128 B` | 4 | First round: four-lane absorption of the leading 64B `head[0..4]`; second round: lane `i` absorbs one round of `F` using symmetric slots `tail[i ^ 2] + head[i ^ 2]` (`tail = end - 64`), eliminating sparse-key and overlapping-byte differential cancellation with zero extra AES rounds |
| `129..=512 B` | 4 | `129..=192 B` uses a 3-stripe fast path; remaining lengths absorb in 64B stripes alternating forward order and half-width slot swap `i ^ 2`, with tail handling at `end - 128` and `end - 64` before merging |
| `513..=2048 B` | 8 | 128B stride with 64B alternating half-group absorption; tail at `end - 128` performs 32B slot swap `i ^ 2`; merges to 4 lanes via `p_i = F(A_i) ^ A_{i+4}` (`A_i` is the post-absorption state of each lane) |
| `> 2048 B` | 16 | 256B stripes alternating cross-group (`lo`/`hi` half-group swap) and forward-order absorption, always reading in ascending address order; `x86` / `x86_64` prefetch L1 cache 768–1152 B ahead for `> 32 KiB`; tail at `end - 256` performs group-swap absorption then two-level folding (`m_i = F(A_i) ^ A_{i+8}`, then `p_i = F(m_i) ^ m_{i+4}`) to 4 lanes |

### Asymmetric Finalization and High-Half Derivation

The 4-lane state `[l0, l1, l2, l3]` enters the asymmetric finalizer to eliminate isomorphic-column linear cancellation and truncation distinguishers:

1. Lane 0 executes the no-MixColumns final round and XORs with lane 2: `q0 = FL(l0 ^ lk) ^ l2` (`aarch64` uses a single `aese` to skip `aesmc`; `x86` uses a single `aesenclast`).
2. Lane 1 passes through one round of `F`, performs 64-bit vector addition with lane 3, then byte-interleaves the high and low halves: `q1 = zip_u8(F(l1) + l3)`, breaking column alignment and XOR cancellation.
3. Merges the two branches through an arithmetic Davies-Meyer feedforward to output the low 128 bits: `s = F(q0) ^ q1`, `u = F(s)`, `lo = F(u) + u`.

The 256-bit high half `hi` is enabled on demand via the compile-time const generic `const HI: bool` (zero compile-time overhead pruning for `hash32` / `hash64` / `hash128`). It is derived from `lo`, mixed state `mix` (`q1` for 4-lane finalization, `sv` for `0..=16 B`, lane-1 output `c` for `17..=32 B`), length key `lk`, and finalization constants through 3 chained AES rounds: `hi = F(F(F(lo ^ (mix ^ c1)) ^ lk) ^ c2)`.

### Extended Output and Stream Cipher

`hash_xof` and `Stream` use the 32 bytes of `hash256` output as the root node `root`:

- Offsets `0..32` directly copy or XOR the corresponding `root` slice, guaranteeing bit-exact prefix consistency with `hash32` / `hash64` / `hash128` / `hash256`.
- From byte 32 onward, a 4-round simplified AES-CTR runs in 16-byte blocks: block number `blk = (pos - 32) / 16` constructs the counter `(blk, blk.wrapping_mul(M_CTR))`; four round keys are derived from `root` and stream constants: `rk0 = root[0..16]`, `rk1 = root[16..32]`, `rk2 = rk0 ^ STREAM_KEY_LI`, `rk3 = rk1 ^ STREAM_FIN_LI`; after 3 rounds of `F` and 1 round of `FL`, the output is finalized with XOR `rk0`.
- The hardware path computes in parallel with 8-lane 128-bit (NEON / AES-NI) or 4-lane wide vectors (`VAES256` processes 8 blocks at a time, `VAES512` processes 16), directly supporting arbitrary offset jumps.

### Hardware Adaptation and Software Fallback

- Dual-semantic AES fusion: at compile time, `AesMode` distinguishes `PreXor` (`aarch64` native `aese + aesmc` macro fusion and scalar T-table) from `PostXor` (`x86` / `x86_64` native `aesenc` / `aesenclast`) XOR fusion ordering; the hot loop introduces no extra XOR instructions.
- Static inlining and runtime dispatch: under `std`, dispatches as needed to `AVX-512F + VAES`, `AVX2 + VAES`, `AVX + AES`, `SSE2 + AES`, `ARMv8 AES + NEON`, or scalar T-table; on `x86` / `x86_64` with `+aes,+sse2` enabled at compile time, `0..=128 B` is inlined directly while `> 128 B` still auto-upgrades to wider backends via runtime probing.
- Pure software vector ([ihash::cpu](https://atomgit.com/i18n-site/rs/tree/main/ihash/src/cpu)): `<= 128 B` uses a 64-byte-aligned 4×1 KiB scalar T-table ([soft.rs](https://atomgit.com/i18n-site/rs/blob/main/ihash/src/arch/soft.rs)); `> 128 B` and `>= 64 B` streaming output use [fearless_simd](https://docs.rs/fearless_simd) zero-platform conditional-compile dispatch—wide-byte lookup backends (NEON `TBL4`, AVX-512, WASM) use 64B-chunked full S-box tables, AVX2 / SSE4.2 use `GF((2^4)^2)` composite-domain tower lookup; when hardware byte shuffling is unavailable, automatically falls back to scalar T-table with bit-exact results.

### Hash Table State and Seed Isolation

`IHasher` compresses streaming state into a single 8-byte `u64`: fixed-length integers and `0..=64 B` slice writes take a 64×64→128-bit folding-multiplication fast path; `> 64 B` slice writes fall back to the main AES 64-bit path (the 128-bit output `finish_u128` performs one more folding multiplication on state to produce the high 64 bits).

With `std` enabled, `IBuildHasher::default()` performs lock-free golden-ratio stepping from a thread-local `RandomState`-initialized seed slot and derives per-table independent seeds via folding, defending against cross-key / cross-table hash flooding while maintaining the 8-byte state footprint (see [adversarial.rs](https://atomgit.com/i18n-site/rs/blob/main/ihash/tests/adversarial.rs) for the contrast test).

## Performance Benchmark Details

The following lists throughput line charts, short/long slice comparisons, `HashMap` throughput, multi-bit-width averages, and cross-platform consistency for each of the 4 measured hosts.

The complete 16-algorithm ranking, all 13-tier details, and per-algorithm failure lists are included in [smhasher3](https://crates.io/crates/smhasher3).

### Apple M2 Max

macOS, `aarch64`, 12 cores, compiled with `+neon,+aes,+sha2` enabled; measured to support `ARMv8 AES + NEON`.

![Apple M2 Max Throughput Comparison](https://x-0.kdns.fr/1KEWyTfNswKzUfQm4KOepGtSSFZoiN97qnw-xogRyq0)

Short-slice throughput (4..=128 B, in GiB/s):

| Algorithm | 4 B | 8 B | 16 B | 32 B | 64 B | 128 B | Random short slice | Short-key avg |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| ihash | 3.43 | 6.93 | 15.80 | 25.38 | 35.27 | 49.71 | 13.72 | 15.99 |
| gxhash4 | 3.29 | 6.75 | 14.48 | 20.02 | 32.17 | 44.51 | 8.40 | 14.48 |
| lh_aes | 1.07 | 2.12 | 4.49 | 8.41 | 9.95 | 24.64 | 4.51 | 5.26 |
| lanehash64 | 1.77 | 3.34 | 7.13 | 12.09 | 16.67 | 14.56 | 5.15 | 7.06 |
| foldhash_fast | 4.02 | 9.53 | 20.27 | 13.92 | 22.45 | 31.37 | 8.21 | 14.03 |
| xxh3 | 2.48 | 4.81 | 9.50 | 12.47 | 15.25 | 16.83 | 5.25 | 8.45 |
| ahash | 2.92 | 5.95 | 11.77 | 16.30 | 19.05 | 20.97 | 7.16 | 10.49 |

Long-slice throughput (256 B..=256 KiB, in GiB/s):

| Algorithm | 256 B | 512 B | 1 KiB | 4 KiB | 16 KiB | 64 KiB | 256 KiB | Long-key avg | Full-length avg |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| ihash | 57.64 | 76.17 | 87.51 | 102.41 | 120.01 | 127.63 | 78.46 | 89.85 | 40.50 |
| gxhash4 | 63.52 | 77.72 | 91.41 | 107.46 | 122.35 | 124.06 | 79.09 | 92.56 | 39.32 |
| lh_aes | 39.23 | 39.06 | 55.41 | 71.64 | 82.51 | 87.27 | 79.61 | 61.91 | 19.83 |
| lanehash64 | 18.91 | 20.47 | 25.29 | 41.21 | 49.10 | 51.09 | 50.02 | 33.82 | 16.42 |
| foldhash_fast | 32.79 | 35.87 | 39.16 | 41.46 | 41.48 | 42.37 | 38.98 | 38.74 | 24.24 |
| xxh3 | 25.84 | 29.96 | 34.16 | 36.05 | 34.09 | 34.44 | 32.82 | 32.31 | 17.39 |
| ahash | 20.53 | 20.27 | 17.66 | 17.27 | 16.36 | 16.38 | 15.51 | 17.62 | 13.87 |

`HashMap` multi-key-type read/write throughput (in Mop/s):

| Hasher | u64 write | u64 read | Short string write | Short string read | URL write | URL read | Geometric mean |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| ihash | 248.7 | 468.8 | 56.1 | 153.9 | 44.1 | 114.4 | 131.1 |
| gxhash4 | 226.4 | 468.7 | 42.0 | 145.8 | 34.9 | 123.4 | 118.7 |
| foldhash_fast | 267.3 | 525.2 | 53.4 | 170.7 | 46.9 | 116.4 | 138.3 |
| foldhash_quality | 239.3 | 441.2 | 48.9 | 156.3 | 41.8 | 118.2 | 125.9 |
| rapidhash | 258.1 | 442.0 | 47.3 | 147.1 | 46.9 | 101.9 | 124.9 |
| ahash | 260.6 | 459.8 | 48.4 | 134.4 | 48.3 | 95.8 | 123.8 |
| fxhash | 261.2 | 606.1 | 50.5 | 158.3 | 42.6 | 115.9 | 135.7 |
| std | 118.0 | 145.2 | 53.0 | 81.5 | 29.8 | 47.2 | 68.6 |

Multi-width, extended output, and pure-software fallback geometric means (in GiB/s):

| hash32 | hash64 | hash128 | hash256 | hash_xof | Stream | cpu fallback | lanehash64 |
| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| 67.45 | 65.92 | 65.76 | 66.99 | 20.11 | 21.93 | 2.84 | 15.27 |

### Intel Xeon Platinum 8269CY

Linux, `x86_64`, 4 cores, compiled with `+sse2,+aes` enabled; measured to support `AVX-512F + AVX2 + AES-NI`.

![Intel Xeon Platinum 8269CY Throughput Comparison](https://x-0.kdns.fr/03uK2TjE9WSaL2j2RYEtf7QvDKRvFzvMIkhDP6jQhA8)

Short-slice throughput (4..=128 B, in GiB/s):

| Algorithm | 4 B | 8 B | 16 B | 32 B | 64 B | 128 B | Random short slice | Short-key avg |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| ihash | 1.23 | 2.65 | 5.57 | 8.59 | 13.24 | 19.14 | 3.58 | 5.83 |
| gxhash4 | 1.16 | 2.23 | 5.15 | 7.97 | 12.80 | 14.82 | 3.40 | 5.22 |
| lh_aes | 0.43 | 0.85 | 1.65 | 3.19 | 4.39 | 11.30 | 1.79 | 2.14 |
| lanehash64 | 0.59 | 1.18 | 2.13 | 4.79 | 6.53 | 6.24 | 1.84 | 2.57 |
| foldhash_fast | 1.53 | 3.53 | 6.35 | 4.82 | 7.32 | 12.00 | 3.52 | 4.94 |
| xxh3 | 0.86 | 1.64 | 3.33 | 6.02 | 8.36 | 10.20 | 2.33 | 3.66 |
| ahash | 0.75 | 2.19 | 3.75 | 7.63 | 6.95 | 5.04 | 2.42 | 3.44 |

Long-slice throughput (256 B..=256 KiB, in GiB/s):

| Algorithm | 256 B | 512 B | 1 KiB | 4 KiB | 16 KiB | 64 KiB | 256 KiB | Long-key avg | Full-length avg |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| ihash | 20.55 | 30.25 | 32.54 | 34.82 | 36.65 | 37.74 | 39.44 | 32.52 | 14.71 |
| gxhash4 | 21.56 | 29.55 | 30.38 | 33.83 | 34.89 | 34.97 | 39.07 | 31.57 | 13.76 |
| lh_aes | 15.31 | 18.07 | 24.88 | 30.49 | 33.19 | 36.40 | 38.52 | 26.74 | 8.33 |
| lanehash64 | 8.37 | 17.08 | 29.20 | 54.25 | 57.55 | 56.68 | 59.72 | 33.16 | 10.19 |
| foldhash_fast | 11.78 | 14.04 | 17.62 | 19.16 | 16.80 | 16.86 | 17.29 | 16.04 | 9.31 |
| xxh3 | 9.27 | 11.64 | 13.76 | 14.38 | 13.07 | 14.07 | 13.92 | 12.74 | 7.17 |
| ahash | 5.99 | 6.55 | 6.88 | 7.04 | 6.81 | 6.89 | 7.25 | 6.76 | 4.95 |

`HashMap` multi-key-type read/write throughput (in Mop/s):

| Hasher | u64 write | u64 read | Short string write | Short string read | URL write | URL read | Geometric mean |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| ihash | 51.0 | 172.7 | 14.1 | 35.0 | 12.3 | 11.2 | 29.0 |
| gxhash4 | 43.4 | 126.2 | 12.6 | 31.5 | 10.4 | 9.6 | 24.6 |
| foldhash_fast | 51.1 | 174.3 | 13.9 | 34.2 | 12.5 | 11.4 | 29.0 |
| foldhash_quality | 48.5 | 149.1 | 13.5 | 31.7 | 11.7 | 10.8 | 27.0 |
| rapidhash | 48.8 | 149.3 | 13.4 | 31.1 | 11.1 | 10.5 | 26.6 |
| ahash | 48.5 | 149.3 | 13.2 | 30.3 | 10.4 | 9.7 | 25.8 |
| fxhash | 53.3 | 193.2 | 14.0 | 32.9 | 12.1 | 10.9 | 29.3 |
| std | 33.2 | 59.6 | 12.0 | 21.2 | 9.9 | 10.1 | 19.2 |

Multi-width, extended output, and pure-software fallback geometric means (in GiB/s):

| hash32 | hash64 | hash128 | hash256 | hash_xof | Stream | cpu fallback | lanehash64 |
| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| 24.29 | 25.02 | 25.18 | 23.20 | 6.69 | 9.21 | 1.38 | 10.67 |

### AMD EPYC

Linux, `x86_64`, 8 cores, compiled with `+sse2,+aes` enabled; measured to support `AVX2 + AES-NI`.

![AMD EPYC Throughput Comparison](https://x-0.kdns.fr/1UkmhvwgnRVez_bKdmeQir-Ipbjo7SoyoN0q2VxllWk)

Short-slice throughput (4..=128 B, in GiB/s):

| Algorithm | 4 B | 8 B | 16 B | 32 B | 64 B | 128 B | Random short slice | Short-key avg |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| ihash | 0.78 | 2.90 | 4.80 | 7.65 | 12.20 | 18.92 | 3.67 | 5.17 |
| gxhash4 | 0.78 | 0.77 | 4.53 | 5.86 | 7.63 | 15.36 | 3.70 | 3.51 |
| lh_aes | 0.30 | 0.59 | 1.59 | 2.80 | 2.62 | 9.65 | 1.42 | 1.64 |
| lanehash64 | 0.44 | 1.03 | 2.33 | 3.34 | 2.83 | 6.24 | 1.62 | 1.99 |
| foldhash_fast | 0.94 | 4.06 | 7.86 | 3.94 | 7.72 | 13.06 | 2.78 | 4.78 |
| xxh3 | 0.83 | 0.91 | 3.89 | 5.69 | 8.32 | 10.28 | 1.67 | 3.35 |
| ahash | 1.09 | 1.30 | 3.89 | 8.16 | 7.08 | 5.07 | 2.37 | 3.43 |

Long-slice throughput (256 B..=256 KiB, in GiB/s):

| Algorithm | 256 B | 512 B | 1 KiB | 4 KiB | 16 KiB | 64 KiB | 256 KiB | Long-key avg | Full-length avg |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| ihash | 24.84 | 30.82 | 46.93 | 42.27 | 61.13 | 62.40 | 45.97 | 42.88 | 16.15 |
| gxhash4 | 22.31 | 28.79 | 37.85 | 29.38 | 38.41 | 36.62 | 38.80 | 32.58 | 11.66 |
| lh_aes | 14.95 | 18.02 | 27.32 | 28.43 | 33.05 | 28.71 | 36.87 | 25.66 | 7.22 |
| lanehash64 | 9.47 | 7.78 | 17.63 | 30.58 | 40.08 | 42.60 | 39.58 | 22.23 | 7.30 |
| foldhash_fast | 14.41 | 13.11 | 17.67 | 17.43 | 20.22 | 18.02 | 17.94 | 16.82 | 9.41 |
| xxh3 | 7.44 | 9.41 | 7.83 | 11.68 | 12.99 | 11.72 | 13.76 | 10.43 | 6.18 |
| ahash | 6.49 | 6.36 | 6.24 | 7.10 | 7.33 | 7.47 | 7.61 | 6.92 | 5.00 |

`HashMap` multi-key-type read/write throughput (in Mop/s):

| Hasher | u64 Write | u64 Lookup | Short String Write | Short String Lookup | URL Write | URL Lookup | Geometric Mean |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| ihash | 60.7 | 140.6 | 18.0 | 30.3 | 14.5 | 11.9 | 30.5 |
| gxhash4 | 51.5 | 117.8 | 15.1 | 23.2 | 11.5 | 11.2 | 25.5 |
| foldhash_fast | 66.7 | 169.3 | 17.3 | 29.7 | 12.1 | 10.4 | 30.0 |
| foldhash_quality | 58.5 | 130.7 | 15.6 | 26.7 | 12.4 | 11.1 | 27.5 |
| rapidhash | 56.1 | 120.1 | 14.4 | 24.3 | 10.1 | 10.0 | 24.9 |
| ahash | 58.0 | 126.4 | 14.2 | 23.0 | 10.3 | 9.9 | 25.0 |
| fxhash | 54.5 | 151.0 | 15.1 | 26.6 | 11.8 | 11.0 | 27.5 |
| std | 30.8 | 49.6 | 12.8 | 18.1 | 9.9 | 8.7 | 17.7 |

Multi-width, extended output, and pure-software fallback geometric means (in GiB/s):

| hash32 | hash64 | hash128 | hash256 | hash_xof | Stream | cpu fallback | lanehash64 |
| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| 28.55 | 29.39 | 28.94 | 27.67 | 6.95 | 8.42 | 1.33 | 8.08 |

### ARM Neoverse-N1

Linux, `aarch64`, 6 cores, compiled with `+neon,+aes`, verified support for `ARMv8 AES + NEON`.

![ARM Neoverse-N1 Throughput Comparison](https://x-0.kdns.fr/N2QJwXH5Y1CMfpb16vFO_02QqMlT31lcCRJxAFaypkU)

Short-slice throughput (4..=128 B, in GiB/s):

| Algorithm | 4 B | 8 B | 16 B | 32 B | 64 B | 128 B | Random Short Slice | Short Key Average |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| ihash | 1.26 | 2.99 | 6.96 | 11.04 | 13.87 | 16.64 | 3.37 | 6.37 |
| gxhash4 | 1.50 | 2.97 | 6.80 | 10.19 | 11.77 | 14.41 | 3.21 | 6.11 |
| lh_aes | 0.37 | 0.77 | 1.56 | 1.78 | 3.28 | 9.04 | 1.55 | 1.69 |
| lanehash64 | 0.68 | 1.34 | 2.71 | 4.19 | 5.02 | 4.67 | 1.78 | 2.49 |
| foldhash_fast | 1.58 | 3.11 | 6.31 | 3.14 | 4.20 | 6.30 | 2.78 | 3.70 |
| xxh3 | 0.99 | 1.98 | 3.48 | 4.39 | 5.17 | 5.70 | 2.00 | 3.10 |
| ahash | 0.63 | 1.30 | 2.59 | 3.67 | 4.65 | 5.06 | 2.40 | 2.38 |

Long-slice throughput (256 B..=256 KiB, in GiB/s):

| Algorithm | 256 B | 512 B | 1 KiB | 4 KiB | 16 KiB | 64 KiB | 256 KiB | Long Key Average | Full-Range Average |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| ihash | 23.81 | 31.05 | 33.73 | 39.88 | 42.85 | 42.07 | 41.22 | 35.70 | 16.11 |
| gxhash4 | 23.31 | 30.00 | 33.25 | 38.92 | 42.58 | 42.45 | 40.86 | 35.19 | 15.69 |
| lh_aes | 13.36 | 14.88 | 21.50 | 26.90 | 31.11 | 31.54 | 31.27 | 23.12 | 6.91 |
| lanehash64 | 5.83 | 6.78 | 8.61 | 15.42 | 19.20 | 19.98 | 16.67 | 11.89 | 5.78 |
| foldhash_fast | 6.26 | 5.92 | 6.30 | 6.30 | 6.30 | 6.28 | 5.56 | 6.13 | 4.85 |
| xxh3 | 9.15 | 11.51 | 13.49 | 14.25 | 14.59 | 14.74 | 12.47 | 12.73 | 6.63 |
| ahash | 5.74 | 6.03 | 6.17 | 6.22 | 6.21 | 6.23 | 5.54 | 6.02 | 3.92 |

`HashMap` multi-key-type read/write throughput (in Mop/s):

| Hasher | u64 Write | u64 Lookup | Short String Write | Short String Lookup | URL Write | URL Lookup | Geometric Mean |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| ihash | 50.5 | 176.1 | 9.2 | 18.3 | 5.3 | 7.7 | 19.8 |
| gxhash4 | 43.7 | 136.2 | 7.2 | 10.0 | 4.8 | 4.1 | 14.3 |
| foldhash_fast | 50.5 | 169.5 | 6.6 | 9.8 | 4.7 | 4.0 | 14.8 |
| foldhash_quality | 42.9 | 133.0 | 7.7 | 9.9 | 5.3 | 4.4 | 14.7 |
| rapidhash | 43.4 | 133.5 | 6.9 | 9.0 | 4.9 | 3.7 | 13.7 |
| ahash | 43.5 | 130.9 | 6.4 | 9.2 | 5.3 | 4.2 | 14.0 |
| fxhash | 53.2 | 191.3 | 7.1 | 9.9 | 5.6 | 4.4 | 16.1 |
| std | 38.5 | 71.6 | 6.4 | 8.2 | 4.5 | 3.8 | 11.7 |

Multi-width, extended output, and pure-software fallback geometric means (in GiB/s):

| hash32 | hash64 | hash128 | hash256 | hash_xof | Stream | cpu fallback | lanehash64 |
| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| 26.74 | 26.86 | 26.27 | 25.55 | 6.02 | 7.32 | 1.29 | 5.71 |

### Cross-platform consistency

Before timing begins, each host runs a self-check over every byte length from `0..=1100 B` as well as `4 KiB`, `16 KiB`, and `64 KiB` (1,104 length tiers × 3 seed groups = 3,312 input sets in total).

The local hardware-accelerated path has been verified bit-for-bit against the `ihash::cpu` pure-software path, and all outputs across `hash32`, `hash64`, `hash128`, `hash256`, `hash_xof`, and `Stream` are identical on 4 hosts with different architectures.