Datasets:

steveruizoktldraw
/

tldraw-datasets

license: mit
pretty_name: tldraw snapshot history datasets
size_categories:
  - n<1K
tags:
  - tldraw
  - whiteboard
  - canvas
  - snapshots
  - diagrams
  - vector-graphics
configs:
  - config_name: default
    data_files:
      - split: train
        path: data/train-*
dataset_info:
  features:
    - name: filename
      dtype: string
    - name: jsonl
      list:
        - name: kind
          dtype: string
        - name: ts
          dtype: string
        - name: prev
          dtype: string
        - name: clock
          dtype: int64
        - name: documentClock
          dtype: int64
        - name: tombstoneHistoryStartsAtClock
          dtype: int64
        - name: schemaJson
          dtype: large_string
        - name: documents
          list: large_string
        - name: tombstones
          list:
            - name: id
              dtype: string
            - name: clock
              dtype: int64
        - name: documentsAdded
          list: large_string
        - name: documentsModified
          list: large_string
        - name: documentsRemoved
          list: string
        - name: tombstonesAdded
          list:
            - name: id
              dtype: string
            - name: clock
              dtype: int64
        - name: tombstonesRemoved
          list: string
    - name: images
      list: image
  splits:
    - name: train
      num_bytes: 271866378
      num_examples: 1
  download_size: 542341375
  dataset_size: 271866378

tldraw-datasets

Snapshot history datasets from tldraw rooms. Each row is a single editing session (a "trajectory") from one room, captured as a sequence of periodic JSON snapshots with matching rendered PNGs.

Source and tooling: https://github.com/tldraw/tldraw-datasets

Schema

One row per room. Each row has three columns:

column	type	description
`filename`	`string`	e.g. `1dUMRx3oRxs33vPdsy2uY.jsonl`.
`jsonl`	`Sequence[struct]`	Row 0 is the initial full snapshot; rows 1..N are per-change diffs.
`images`	`Sequence[Image]`	1:1 with `jsonl`. `images[0]` is the initial snapshot PNG; `images[i>0]` is the state after diff i.

Rows where the diff has no document changes (idle periods) are dropped from both jsonl and images, so each kept frame corresponds to a real edit.

`jsonl` item schema

Each element of jsonl is a struct. Fields that only apply to snapshots or diffs are empty on the other kind.

field	type	notes
`kind`	`string`	`"snapshot"` on row 0, `"diff"` on rows 1..
`ts`	`string`	ISO timestamp with `:` → `-` (lex sort = chronological).
`prev`	`string \| null`	Previous snapshot's `ts`. `null` on row 0.
`clock`	`int64`
`documentClock`	`int64`
`tombstoneHistoryStartsAtClock`	`int64`
`schemaJson`	`string`	JSON-encoded tldraw schema block.
`documents` (snapshot only)	`Sequence[string]`	JSON-encoded `{state, lastChangedClock}` records.
`tombstones` (snapshot only)	`Sequence[struct]`	`{id, clock}`.
`documentsAdded` (diff only)	`Sequence[string]`	JSON-encoded records.
`documentsModified` (diff only)	`Sequence[string]`	JSON-encoded records.
`documentsRemoved` (diff only)	`Sequence[string]`	Record IDs.
`tombstonesAdded` (diff only)	`Sequence[struct]`	`{id, clock}`.
`tombstonesRemoved` (diff only)	`Sequence[string]`	Record IDs.

Why JSON strings for documents / schema? tldraw shape types have widely varying schemas (geo, draw, arrow, image, embed, …). Unioning all their props into one struct produces a combinatorial schema that breaks parquet. The record payloads are stored as JSON strings; call json.loads(...) to recover the original tldraw record. See the RoomSnapshot type for the deserialized shape.

Usage

from datasets import load_dataset

ds = load_dataset("steveruizoktldraw/tldraw-datasets", split="train")
row = ds[0]
print(row["filename"])        # 1dUMRx3oRxs33vPdsy2uY.jsonl
print(len(row["jsonl"]))      # number of keyframes in the trajectory
print(row["jsonl"][0]["kind"])  # 'snapshot'
print(row["images"][0])       # PIL.Image of the initial state

# Reconstruct the nth intermediate tldraw state:
import json
initial_docs = [json.loads(d) for d in row["jsonl"][0]["documents"]]

Reconstructing a full `RoomSnapshot`

Replay semantics (apply diffs in order onto the initial snapshot state):

import json

def reconstruct(jsonl, up_to: int):
    initial = jsonl[0]
    docs = {json.loads(d)["state"]["id"]: json.loads(d) for d in initial["documents"]}
    tombs = {t["id"]: t["clock"] for t in initial["tombstones"]}
    schema = json.loads(initial["schemaJson"])

    for step in jsonl[1 : up_to + 1]:
        for s in step["documentsAdded"] + step["documentsModified"]:
            r = json.loads(s)
            docs[r["state"]["id"]] = r
        for rid in step["documentsRemoved"]:
            docs.pop(rid, None)
        for t in step["tombstonesAdded"]:
            tombs[t["id"]] = t["clock"]
        for rid in step["tombstonesRemoved"]:
            tombs.pop(rid, None)
        schema = json.loads(step["schemaJson"])

    last = jsonl[up_to]
    return {
        "clock": last["clock"],
        "documentClock": last["documentClock"],
        "tombstoneHistoryStartsAtClock": last["tombstoneHistoryStartsAtClock"],
        "schema": schema,
        "tombstones": tombs,
        "documents": list(docs.values()),
    }

License

MIT — see LICENSE.