Benchmark: id performance comparison

HTML Preparation code:

<script type="module">
  import { v4 as uuidv4, v1 as uuidv1 } from 'https://jspm.dev/uuid';
  import {ulid} from "https://jspm.dev/ulid";
  import {createId, init} from "https://jspm.dev/@paralleldrive/cuid2";
  import {nanoid} from "https://jspm.dev/nanoid";
  
  window.uuidv4 = uuidv4;
  window.uuidv1 = uuidv1;
  window.ulid = ulid;
  window.cuid2 = createId;
  window.cuid2_32 = init({length: 32});
  window.nanoid = nanoid;
  
  console.log("uuidv4", uuidv4());
  console.log("uuidv1", uuidv1());
  console.log("ulid", ulid());
  console.log("cuid2", window.cuid2());
  console.log("cuid2_32", window.cuid2_32());
  console.log("nanoid", nanoid());
  console.log("crypto.randomUUID", crypto.randomUUID());
    
</script>

Tests:

uuidv1
uuidv1()
uuidv4
uuidv4()
ulid
ulid()
cuid2
cuid2()
cuid2_32
cuid2_32()
nanoid
nanoid()
crypto.randomUUID
crypto.randomUUID()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
uuidv1
uuidv4
ulid
cuid2
cuid2_32
nanoid
crypto.randomUUID

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

I'll break down the benchmark and its options for you.

**What is being tested?**

MeasureThat.net is testing the performance of six different UUID (Universally Unique Identifier) generation algorithms:

1. `uuidv1()`: Generates a UUID based on the host ID, sequence number, and timestamp.
2. `uuidv4()`: Generates a random UUID.
3. `ulid()`: Generates a unique identifier based on a timestamp and a random 13-byte value.
4. `cuid2()`: Generates a cryptographically secure identifier using a pseudo-random number generator.
5. `cuid2_32()`: Similar to `cuid2`, but with a length of 32 bytes instead of the default 16 bytes.
6. `crypto.randomUUID()`: Generates a random UUID using the `randomUUID()` function from the JavaScript crypto module.

**Options being compared**

The benchmark is comparing the performance of these six algorithms across different browsers and devices. The options are:

* Algorithm: Each algorithm is tested independently.
* Browser: Four browser variants are tested for each algorithm (Chrome 127 on Mac OS X).
* Device Platform: Desktop devices only.
* Operating System: Mac OS X 10.15.7.

**Pros and Cons**

Here's a brief summary of the pros and cons of each algorithm:

1. `uuidv1()`: Fast, but vulnerable to host ID changes.
2. `uuidv4()`: Randomly generated UUIDs are suitable for most applications, but may not be cryptographically secure.
3. `ulid()`: Fast and efficient, with a built-in timestamp-based ordering.
4. `cuid2()`: Cryptographically secure, but computationally expensive.
5. `cuid2_32()`: Similar to `cuid2`, but with a larger output size.
6. `crypto.randomUUID()`: Randomly generated UUIDs are suitable for most applications, and is cryptographically secure.

**Library usage**

The benchmark uses several external libraries:

* `uuid` and `ulid` libraries provide the algorithms being tested.
* The `createId` function from `@paralleldrive/cuid2` library implements the `cuid2()` algorithm.
* The `crypto` module provides the `randomUUID()` function, which is used to generate UUIDs.

**Special JS feature or syntax**

The benchmark uses several JavaScript features and syntax:

* ES modules (import/export statements)
* WebAssembly (no explicit mention, but MeasureThat.net may use WASM for performance optimization)

Overall, this benchmark provides a comprehensive comparison of different UUID generation algorithms in various browsers and devices.

Latest run results:

Run details: (Test run date: 3 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:132.0) Gecko/20100101 Firefox/132.0

Browser/OS: Firefox 132 on Windows

View result in a separate tab

Test name	Executions per second
uuidv1	1307604.1 Ops/sec
uuidv4	815208.6 Ops/sec
ulid	39476.4 Ops/sec
cuid2	17269.4 Ops/sec
cuid2_32	11609.9 Ops/sec
nanoid	203407.7 Ops/sec
crypto.randomUUID	814775.2 Ops/sec

Related benchmarks:

id performance comparison (version: 0)

Comparing performance of: uuidv1 vs uuidv4 vs ulid vs cuid2 vs cuid2_32 vs nanoid vs crypto.randomUUID

Created: one year ago by: Guest

Jump to the latest result

uuidv1

uuidv4

ulid

cuid2

cuid2_32

nanoid

crypto.randomUUID

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):