{"id":43011193,"url":"https://github.com/themattspiral/fast-prng-wasm","last_synced_at":"2026-01-31T05:14:44.457Z","repository":{"id":264498669,"uuid":"893541748","full_name":"themattspiral/fast-prng-wasm","owner":"themattspiral","description":"High-performance, SIMD-enabled WebAssembly PRNGs with a seamless TypeScript interface. Includes PCG, xoroshiro128+, and xoshiro256+","archived":false,"fork":false,"pushed_at":"2025-11-18T17:24:34.000Z","size":340,"stargazers_count":1,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-11-30T01:48:28.482Z","etag":null,"topics":["assemblyscript","monte-carlo","pcg-random","prng","pseudorandom-number-generator","random","random-number-generators","simd","wasm","wasm-simd","webassembly","xoroshiro128","xoshiro256"],"latest_commit_sha":null,"homepage":"","language":"TypeScript","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/themattspiral.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE.md","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2024-11-24T17:54:12.000Z","updated_at":"2025-11-18T17:24:35.000Z","dependencies_parsed_at":null,"dependency_job_id":"5c576eeb-89ac-4aa8-973c-ccc4177ac3c7","html_url":"https://github.com/themattspiral/fast-prng-wasm","commit_stats":null,"previous_names":["themattspiral/fast-prng-wasm"],"tags_count":21,"template":false,"template_full_name":null,"purl":"pkg:github/themattspiral/fast-prng-wasm","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/themattspiral%2Ffast-prng-wasm","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/themattspiral%2Ffast-prng-wasm/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/themattspiral%2Ffast-prng-wasm/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/themattspiral%2Ffast-prng-wasm/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/themattspiral","download_url":"https://codeload.github.com/themattspiral/fast-prng-wasm/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/themattspiral%2Ffast-prng-wasm/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":28929889,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-01-31T04:05:25.756Z","status":"ssl_error","status_checked_at":"2026-01-31T04:02:35.005Z","response_time":128,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["assemblyscript","monte-carlo","pcg-random","prng","pseudorandom-number-generator","random","random-number-generators","simd","wasm","wasm-simd","webassembly","xoroshiro128","xoshiro256"],"created_at":"2026-01-31T05:14:44.347Z","updated_at":"2026-01-31T05:14:44.450Z","avatar_url":"https://github.com/themattspiral.png","language":"TypeScript","funding_links":[],"categories":[],"sub_categories":[],"readme":"# fast-prng-wasm\n\n[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)](LICENSE.md) [![npm package version](https://img.shields.io/npm/v/fast-prng-wasm.svg?style=flat\u0026logo=npm)](https://www.npmjs.com/package/fast-prng-wasm) [![CI/CD Pipeline](https://github.com/themattspiral/fast-prng-wasm/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/themattspiral/fast-prng-wasm/actions/workflows/ci-cd.yml) [![codecov](https://codecov.io/gh/themattspiral/fast-prng-wasm/branch/main/graph/badge.svg)](https://codecov.io/gh/themattspiral/fast-prng-wasm)\n\n\nHigh-performance, SIMD-enabled, WebAssembly pseudo random number generators (PRNGs) with a seamless TypeScript interface. Faster and better statistical quality than `Math.random()`.\n\n**Perfect for:** Simulations, Monte Carlo methods, games, procedural generation, parallel computations\n\n- [Quick Start](#quick-start)\n- [Features](#features)\n- [PRNG Algorithms](#prng-algorithms)\n- [Usage Guide](#usage-guide)\n- [API Documentation](#api-documentation)\n- [Examples \u0026 Demos](#examples--demos)\n- [Testing \u0026 Verification](#testing--verification)\n- [Performance](#performance)\n- [Compatibility](#compatibility)\n- [Contributing](#contributing)\n\n## Quick Start\n\n```bash\nnpm install fast-prng-wasm\n```\n\n```typescript\nimport { RandomGenerator } from 'fast-prng-wasm';\n\nconst gen = new RandomGenerator();  // Xoroshiro128+ SIMD is default\nconsole.log(gen.float());           // random 53-bit float (number) in [0, 1)\nconsole.log(gen.int53());           // random 53-bit int (number)\nconsole.log(gen.int64());           // random 64-bit int (bigint)\n```\n\n## Features\n\n- **🚀 High Performance** - Optimized for speed and SIMD-accelerated\n- **📊 Better Statistical Quality** - Superior uniformity and randomness vs. `Math.random()`\n- **⚡ Bulk Generation** - Single values or bulk array fills\n- **🎯 Simple API** - Clean TypeScript interface, no memory-management required\n- **🔢 Multiple Formats** - 64-bit `bigint`, 53-bit int, 32-bit int, and 53-bit float\n- **🌱 Seedable** - Full control over initialization (or automatic seeding)\n- **🧵 Parallel-Ready** - Unique stream selection for multi-threaded applications\n- **✨ Zero Config** - Synchronous WASM loading, no `fs` or `fetch` required\n- **🌐 Universal** - Works in Node.js 18+ and all modern browsers\n- **📦 AssemblyScript Library** - Can be imported to larger WASM project builds\n\n## PRNG Algorithms\n\n| Algorithm | Description | Native Output | State Size | Period | SIMD |\n|-----------|-------------|---------------|------------|--------|------|\n| **Xoshiro256+** | Very fast, large state, very long period - best for applications needing maximum randomness guarantees | 64-bit | 256 bits | 2\u003csup\u003e256\u003c/sup\u003e | ✅ |\n| **Xoroshiro128+** | *Very* fast, smaller state - excellent balance for most applications, fastest provided here | 64-bit | 128 bits | 2\u003csup\u003e128\u003c/sup\u003e | ✅ |\n| **PCG (XSH RR)** | Small state, fast, possibly best randomness (read Learn More links) | 32-bit | 64 bits | 2\u003csup\u003e64\u003c/sup\u003e | ❌ |\n\nThe included algorithms were chosen for their high speed, parallelization support, and statistical quality. They pass rigorous statistical tests (BigCrush, PractRand) and provide excellent uniformity, making them suitable for Monte Carlo simulations and other applications requiring high-quality pseudo-randomness. They offer a significant improvement over `Math.random()`, which varies by JavaScript engine and may exhibit statistical flaws.\n\n**SIMD (Single Instruction, Multiple Data)** generates 2 random numbers simultaneously, theoretically doubling throughput when using array output methods.\n\n\u003e **⚠️ Security Note:** These PRNGs are NOT cryptographically secure. Do not use for cryptography or security-sensitive applications, as they are not resilient against attacks that could reveal sequence history.\n\n#### Learn More\n- [PCG: A Family of Better Random Number Generators](https://www.pcg-random.org)\n- [`xoshiro` / `xoroshiro` generators and the PRNG shootout](https://prng.di.unimi.it/)\n\n## Usage Guide\n\n### Importing\n\n#### ES Module (bundler / modern browser / modern Node)\n```typescript\nimport { RandomGenerator, PRNGType, seed64Array } from 'fast-prng-wasm';\n```\n\n#### CommonJS (legacy Node)\n```javascript\nconst { RandomGenerator, PRNGType, seed64Array } = require('fast-prng-wasm');\n```\n\n#### UMD (browser script tag)\n```html\n\u003cscript src=\"https://unpkg.com/fast-prng-wasm\"\u003e\u003c/script\u003e\n\u003cscript\u003e\n  const { RandomGenerator, PRNGType, seed64Array } = fastPRNGWasm;\n\u003c/script\u003e\n```\n\n### The Basics\n\n```typescript\nconst gen = new RandomGenerator();      // Xoroshiro128Plus_SIMD, auto-seeded\nconsole.log(gen.int64());               // unsigned 64-bit int (bigint)\nconsole.log(gen.int53());               // unsigned 53-bit int (number)\nconsole.log(gen.int32());               // unsigned 32-bit int (number)\nconsole.log(gen.float());               // 53-bit float (number) in [0, 1)\nconsole.log(gen.coord());               // 53-bit float (number) in (-1, 1)\nconsole.log(gen.coordSquared());        // 53-bit float (number) in (-1, 1) squared\n\nconst pcgGen = new RandomGenerator(PRNGType.PCG);\nconsole.log(pcgGen.int64());\n// ... etc - all PRNG types expose the same JS/TS interface\n```\n\nThe internal WASM binary is instantiated automatically when a `RandomGenerator` instance is created.\n\n### Array Output (Bulk Array Fill)\n\nThe fastest way to get random numbers **in bulk** is to use the `*Array()` methods of `RandomGenerator`. Each call fills a WASM memory buffer with the next 1000 (by default) random numbers, and returns a view of the buffer as an appropriate [`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray): either `BigUint64Array` for `int64Array()`, or `Float64Array` for all methods.\n\n\u003e **💡 SIMD Performance:** Array methods **MUST** be used to realize the additional throughput offered by SIMD-enabled PRNG algorithms. These have higher throughput because they produce 2 random numbers at the same time with WASM's 128-bit SIMD support) .\n\n#### Bulk Fill Example\n```typescript\nconst gen = new RandomGenerator();\n\n// `bigint`s in BigUint64Array\nconst bigintArray = gen.int64Array();     // 1000 64-bit integers\n\n// `number`s in Float64Array\nlet numberArray = gen.int53Array();       // 1000 53-bit integers\nnumberArray = gen.int32Array();           // 1000 32-bit integers\nnumberArray = gen.floatArray();           // 1000 floats in [0, 1)\n```\n\n#### WASM Array Memory Buffer\n\u003e **⚠️ Reused Buffer Warning:** The array returned by these methods is actually a `DataView` looking at a portion of WebAssembly memory. For performance, this memory buffer is **reused between calls** to the `*Array()` methods by default (to minimize WASM-JS boundary crossing time), so **you must actually consume (e.g. read/copy) the output between each call** (unless using the `copy` param).\n\n```typescript\nconst gen = new RandomGenerator();\n\n// ⚠️ Warning: Consume before making another call to any method that returns a Float64Array\nconst array1 = gen.floatArray();          // 1000 floats in [0, 1)\nconsole.log(array1);                      // consume (extract random results)\n\n// Values originally in array1 have been replaced! (despite different local variable)\nconst array2 = gen.floatArray();          // 1000 new floats in [0, 1)\nconsole.log(array2);                      // consume again (extract more random results)\n\nconsole.log(array1 === array2);           // true (same array in memory)\nconsole.log(array1[42] === array2[42]);   // true (second call refilled the same array)\n```\n\n**Copying Arrays:** If you need to store multiple arrays, use the optional `copy` parameter:\n\n```typescript\n// Get independent copies\nconst array1 = gen.floatArray(true);      // Pass true to copy\nconst array2 = gen.floatArray(true);      // Each call returns a new array\n\nconsole.log(array1 !== array2);           // true (different arrays)\nconsole.log(array1[0] !== array2[0]);     // true (different values preserved)\n```\n\n**Performance Note:** Using `copy=true` is 30-50% slower than the default buffer reuse, but provides safety when storing multiple arrays.\n\n#### Set Array Output Size\nIf you don't need 1000 numbers with each method call, you can specify your preferred size for the output array via the constructor. Note that an array larger than the default of 1000 does not increase performance further in test scenarios. For a detailed explanation, see: [Understanding Performance: Why Array Methods Are Faster](examples/basic-usage#understanding-performance-why-array-methods-are-faster).\n\n```typescript\n// Set size of output buffer to 200\n//  - `null` for `seeds` param will auto-seed\n//  - `null` for `uniqueStreamId` param will use default stream\nconst gen = new RandomGenerator(PRNGType.PCG, null, null, 200);\nlet randomArray = gen.floatArray();       // 200 floats in [0, 1)\n\n// To use a different size, create a new generator instance\nconst gen2 = new RandomGenerator(PRNGType.PCG, null, null, 42);\nrandomArray = gen2.floatArray();          // 42 floats in [0, 1)\n```\n\n\u003e **⚙ Memory Constraint Note:** The `outputArraySize` parameter is **immutable after construction** due to intentional memory constraints. We use AssemblyScript's stub runtime for performance, but it employs a simple bump allocator that never frees memory. `asconfig.release.json` specifies a fixed WASM memory size of 1 page (64KB) - intentionally kept small to limit resources, but enough space for the default of 1000 numbers. This allows a maximum array size of ~3000 elements, considering that we allocate 2 types for each generator.\n\nArrays exceeding memory limits will fail at construction:\n\u003e ```typescript\n\u003e // exceeds the configured memory limits of WASM instances\n\u003e const gen = new RandomGenerator(PRNGType.PCG, null, null, 5000);  // Runtime Error ⚠️\n\u003e ```\n\n### Manual Seeding\nManual seeding is optional. When no seeds are provided, a `RandomGenerator` will seed itself automatically.\n\nManual seeding is done by providing a collection of `bigint` values to initialize the internal generator state. Each generator type requires a different number of seeds (between 1 and 8). The required count for a specific PRNG is exposed via `RandomGenerator`'s `seedCount` property, as well as in the `SEED_COUNT` variable and `setSeed()` function signature in the [AssemblyScript API](docs/as-api.md).\n\n```typescript\nconst customSeeds = [7n, 9876543210818181n];    // Xoroshiro128+ takes 2 bigint seeds\nconst customSeededGen = new RandomGenerator(PRNGType.Xoroshiro128Plus, customSeeds);\n\nconst anotherGen = new RandomGenerator(PRNGType.Xoshiro256Plus);\nconsole.log(anotherGen.seedCount);              // 4\n```\n\nUsing high quality seeds is important, as summarized on Vigna's [Xoshiro page](https://prng.di.unimi.it/):\n\u003e We suggest to use [SplitMix64](https://prng.di.unimi.it/splitmix64.c) to initialize the state of our generators starting from a 64-bit seed, as [research has shown](https://dl.acm.org/citation.cfm?doid=1276927.1276928) that initialization must be performed with a generator radically different in nature from the one initialized to avoid correlation on similar seeds.\n\nPer this guidance, automatic seeding using `seed64Array()` internally is done with SplitMix64.\n\n### Parallel Generators \u0026 Sharing Seeds\n\nSome PRNG applications may require several (or very many) instances of a PRNG running in parallel - for example, multithreaded or distributed computing processes. In this case it is recommended to use the same set of seeds across all parallel generator instances **in combination with** a unique jump count or stream increment. This approach essentially ensures that randomness quality is maximized across all parallel instances.\n\nSee the [`pmc` demo](examples/pmc) for an example that follows this approach, with each generator instance running in a different Node worker thread.\n\n#### Generate a Seed Collection\nIf you don't have custom seeds already, the `seed64Array()` function is provided. It returns a `bigint[8]` containing seeds generated with SplitMix64. The initial SplitMix64 seed uses `crypto.getRandomValues()` when available (all modern browsers and Node.js 15+) for strong entropy, falling back to combining multiple entropy sources (`Date.now()`, `performance.now()`, and `Math.random()`) in older environments. This collection can be provided as the `seeds` argument for any PRNG in this package.\n\n#### Choose a Unique Stream for Each Parallel Generator\nSharing seeds between generators assumes you will also provide a unique `uniqueStreamId` argument:\n- For the PCG PRNG, this will set the internal increment value within the generator, which selects a unique random stream given a specific starting state (seed).\n- For Xoshiro family PRNGs, this will advance the initial state (aka `jump()`) to a unique point within the generator period, allowing for effectively the same behavior - choosing a non-overlapping random stream given a specific starting state\n\nIn both cases, this value is simply a unique positive integer (the examples below provide this as `bigint` literals).\n\n#### Examples\n\n```typescript\nconst sharedSeeds = seed64Array();    // bigint[8]\n\n// Two PCG generators, using the same seeds but choosing unique stream increments (5n vs 4001n)\nconst pcgGen1 = new RandomGenerator(PRNGType.PCG, sharedSeeds, 5n);\nconst pcgNum1 = pcgGen1.float();\n\nconst pcgGen2 = new RandomGenerator(PRNGType.PCG, sharedSeeds, 4001n);\nconst pcgNum2 = pcgGen2.float();\n\nconsole.log(pcgNum1 === pcgNum2);     // false\n\n// Two Xoshiro256+ generators using the same seeds, but with unique jump counts (1n vs 13n)\nconst seededGen1 = new RandomGenerator(PRNGType.Xoshiro256Plus_SIMD, sharedSeeds, 1n);\nconst num1 = seededGen1.float();\n\nconst seededGen2 = new RandomGenerator(PRNGType.Xoshiro256Plus_SIMD, sharedSeeds, 13n);\nconst num2 = seededGen2.float();\n\nconsole.log(num1 === num2);           // false\n\n// Another Xoshiro256+ generator using the same seeds, and same jump count (13n) as seededGen2.\n// ⚠️ seededGen2 and seededGen3 are effectively identical and will return the same random stream.\nconst seededGen3 = new RandomGenerator(PRNGType.Xoshiro256Plus_SIMD, sharedSeeds, 13n);\nconst num3 = seededGen3.float();\n\nconsole.log(num2 === num3);           // true: using same seeds and same uniqueStreamId!!\n```\n\n### Using from AssemblyScript Projects\n```typescript\n// import the namespace(es) you want to use\nimport { PCG, Xoroshiro128Plus } from 'fast-prng-wasm/assembly';\n\nXoroshiro128Plus.setSeeds(57n, 1000123n);             // manually seeded - seed64Array() only in JS\n\nconst rand: u64 = Xoroshiro128Plus.uint64();          // using the AS interface\nconst rand2: f64 = Xoroshiro128Plus.uint53AsFloat();  // return types are cast for JS runtime usage\n\nconst arr = new Uint64Array(1000);                    // create array in WASM memory\nXoroshiro128Plus.uint64Array(arr);                    // generate \u0026 fill\n```\n\n\u003e **⚠️ Thread Safety Warning ⚠️:**\n\u003e WASM PRNG implemetations use top-level internal state and functions to\n\u003e prevent the accumulation of small overhead that comes with using classes.\n\u003e \n\u003e While they are encapsulted within namespaces so as not to interfere with\n\u003e your own AssemblyScript project's global namespace, this also means that\n\u003e they are NOT THREAD SAFE WITHIN WASM DIRECTLY.\n\u003e \n\u003e To acheive thread safety from the JS runtime calling your AssemvblyScript WASM\n\u003e project binary, it must be structured in such a way as to create separate WASM \n\u003e instances from JS. This is the approach used by the included JavaScript/TypeScript wrapper API.\n\n## API Documentation\n\n- **[JavaScript/TypeScript API Documentation](docs/js-api.md)**\n- **[AssemblyScript API Documentation](docs/as-api.md)**\n\n## Examples \u0026 Demos\n\nSee the [`examples/` folder](examples/) for all available examples and demos.\n\n#### [**`basic-usage` - Getting Started**](examples/basic-usage)\nA simple walkthrough of core features\n- Quick start for new users\n- Covers all major API methods\n- Basic performance comparisons and tips\n- Practical examples (dice simulator, Monte Carlo basics)\n\n#### [**`pmc` - Pi Monte Carlo**](examples/pmc)\nA Monte Carlo statistical estimation of π (pi) using a large quantity of random numbers\n- Node CLI app for advanced users\n- Uses parallel generator instances in `worker_threads`\n- Shares seeds across instances, using a unique jump count / stream increment for each\n\n## Testing \u0026 Verification\n\nThis library employs a dual-layer testing strategy to ensure algorithm correctness and statistical quality:\n\n**AssemblyScript Unit Tests** validate core algorithm implementations:\n- **Determinism:** 10K-sample sequences match exactly with same seeds (chance coincidence effectively zero)\n- **Uniqueness:** 10K consecutive values confirmed unique (collision probability ~10⁻¹²)\n- **Range validation:** 10K samples verify correct boundaries (high/low bit coverage \u003e99.99%)\n- **Uniformity smoke tests:** Basic quartile distribution checks across 100K samples\n- **Monte Carlo smoke tests:** π estimation within expected tolerance across 100K samples\n\n**JavaScript Integration Tests** provide rigorous statistical validation:\n- **Chi-square uniformity:** 1M samples detect deviations as small as 0.3% (\u003e99.9% confidence)\n- **Serial correlation:** 100K samples verify independence with standard error ~0.003 (\u003e99.9% confidence)\n- **Monte Carlo π estimation:** 1M samples with tolerance ±0.01 (\u003e99.9% confidence)\n- **Randomized edge case testing:** 10 iterations per test with freshly generated random seeds on each run to catch edge cases fixed seeds might miss\n\nAll algorithms are tested for uniqueness, full-range output, array method consistency, and parallel stream independence. The test suite maintains \u003e90% code coverage across both AssemblyScript and JavaScript layers.\n\n| Test Type | Sample Size | Statistical Power | Purpose |\n|-----------|-------------|-------------------|---------|\n| AS: Deterministic | 10K | N/A (deterministic) | Algorithm correctness |\n| AS: Distribution | 100K | \u003e99% confidence | Smoke testing |\n| JS: Chi-square | 1M | \u003e99.9% confidence | Uniformity validation |\n| JS: Correlation | 100K | \u003e99.9% confidence | Independence validation |\n| JS: Monte Carlo | 1M | \u003e99.9% confidence | Comprehensive validation |\n\n## Performance\n\nThe goal is to provide random number generation in WASM that's faster and higher-quality than `Math.random()`, and faster than any equivalent JavaScript implementation of these PRNG algorithms.\n\nGenerator algorithms are implemented in [AssemblyScript](https://www.assemblyscript.org/), a variant of TypeScript that compiles to WASM.\n\n#### Key performance advantages:\n- PRNG algorithms chosen for speed\n- WASM is faster than JS by design\n- AssemblyScript project structure and compilation are optimized for speed\n- Bulk array generation minimizes JS/WASM boundary crossing overhead\n- Reusing WASM array memory avoids alloc delays and heap fragmentation\n- SIMD acceleration can nearly double throughput for supported algorithms\n- Monte Carlo unit square vs unit circle test included for validation\n\n\u003e ⚡ Additional performance stats coming soon! ⚡\n\n#### Arrays Deep Dive\n\nFor a detailed explanation of **why array methods are 3-5× faster** than single-value methods, see **[Understanding Performance: Why Array Methods Are Faster](examples/basic-usage#understanding-performance-why-array-methods-are-faster)**\n\n## Compatibility\n\n### Node\n| Version | Notes |\n|---------|-------|\n| 18+ | Full support |\n| 16.4+ | All features, but EOL (not tested) |\n| 15.0 | All features except SIMD (not tested) |\n| \u003c15 | No SIMD, No `bigint` (not tested) |\n\n\u003e Node 18+ is required. Older versions may work but are not tested or supported (Node 16 reached EOL in September 2023).\n\n### Browsers\nAll modern browsers are fully supported. \n\n| Browser | Full Support | Partial (No SIMD) | Degraded (No `bigint`) |\n|---------|--------------|-------------------|------------------------|\n| Chrome  | 91+ | 85 | 57 |\n| Edge    | 91+ | 85 | 16 |\n| Safari  | 16.4+ | 14.1 | 11 |\n| Firefox | 89+ | 78 | 52 |\n| Opera   | 77+ | 71 | 44 |\n\nCheck caniuse.com for other browser support:\n - [WASM SIMD](https://caniuse.com/wasm-simd) - Indicates Full Support\n - [WASM bigint](https://caniuse.com/wasm-bigint) - Support for everything except SIMD\n - [WASM](https://caniuse.com/wasm) - Basic support (53-bit int and float `number` but no 64-bit `bigint`)\n\n## Contributing\n\nThis is an open source project, and contributions are welcome!\n  - **Bugs:** Open an Issue to report a bug or request a feature\n  - **Features:** For now, please first open an Issue to discuss any desired / planned contributions\n  - Full contribution guidelines coming soon\n  - See scripts in `package.json` for available build commands\n  \n---\n\n## License\n\n[MIT License](LICENSE.md)\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fthemattspiral%2Ffast-prng-wasm","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fthemattspiral%2Ffast-prng-wasm","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fthemattspiral%2Ffast-prng-wasm/lists"}