Knowledge Base

tldraw SDK: Agent-Driven Infinite Canvas

2026-07-17agentscanvassdk

tldraw SDK: Agent-Driven Infinite Canvas

Source: [https://x.com/i/status/2077745437415481644 https://x.com/i/status/2077857355639734340 https://x.com/i/status/2077873317495595447

With rust and claude or grok whats possibility are endless it seems. Build game, write doc, build interactive dashboard and more this. How fast is it tldraw sdk how much does it take to load and how well does it work with rus and go and python whats the different venchmark and theri result](https://x.com/i/status/2077745437415481644 https://x.com/i/status/2077857355639734340 https://x.com/i/status/2077873317495595447

With rust and claude or grok whats possibility are endless it seems. Build game, write doc, build interactive dashboard and more this. How fast is it tldraw sdk how much does it take to load and how well does it work with rus and go and python whats the different venchmark and theri result)

📌 tldraw is a high-performance React/TypeScript infinite-canvas SDK that coding agents can script into games, dashboards, and interactive docs—especially via the offline app’s runtime JavaScript path. Performance comes from viewport culling, spatial indexing, and large-doc defaults, while Rust/Go/Python sit beside the JS client as backends or WASM, not as canvas replacements.

🖼️ Canvas as product surface

Infinite canvas SDK for whiteboards, diagrams, games, and UIs on one shared surface. Offline app lets agents inspect files, inject runtime JS, or attach load-time scripts so a document becomes a mini-app without a full shell.

🤖 Agents write the product

Claude, Codex, and peers drive the Editor API (e.g. createShapes). Community demos show interactive one-shots in ~3 minutes. Agent starter kit and MCP-style integrations wire canvas into Claude/Cursor workflows.

⚡ Built for large docs

Viewport culling keeps huge canvases smooth (e.g. 10k shapes → ~50 rendered). Defaults: maxShapesPerPage 4,000; debouncedZoom above ~500 shapes; SDK 5.0 adds spatial indexing and faster overlays. Strength is runtime feel, not a single cold-load ms number.

🧩 Language roles, not rivals

First-class client is JS/TS in the browser. Rust/WASM for heavy compute, Go for concurrent services, Python for data/ML—all feed or sit beside the canvas. No fair “tldraw vs Rust vs Go vs Python” head-to-head; agents bridge layers by generating editor-facing JS.

🚀 What ships well

Games, living docs, dashboards, custom shapes/tools, and wireframes on the same runtime. Pattern: agents script the canvas; optional backends handle sync, APIs, or compute.

Key facts

Fact Value
Product surface Infinite canvas SDK (React/TS) + offline app with agent-writable scripts and runtime JS
AI workflow Claude/Codex create/edit via Editor API; demos ~minutes for interactive one-shots
Scale defaults maxShapesPerPage 4,000; debounced zoom above ~500 shapes; culling can leave only visible shapes live (e.g. 10k → ~50)
Performance focus Viewport culling, spatial index (5.0), batched updates, overlay efficiency—not a published cold-load ms figure
Language fit First-class JS/TS client; Rust/Go/Python as backends, tools, or WASM—not native canvas engines
Agent strengths Games, interactive docs, dashboards, custom shapes/tools on one canvas runtime

Details

tldraw is a high-performance infinite-canvas SDK for React and TypeScript—whiteboards, diagrams, games, and interactive UIs on one surface. In mid-July 2026, founder Steve Ruiz and the team highlighted how well coding agents (Codex, Claude, and peers) write against its runtime API: creating shapes, custom interactions, and scripts that run in-product. The offline app is central—agents can inspect a file, inject JavaScript at runtime, or attach scripts that run whenever the document loads, turning a canvas into a small game, living doc, or dashboard without a traditional app shell.

That workflow explains the open-ended “Rust + Claude/Grok” vibe: the canvas is the UI, JavaScript is the glue, and agents fill the product surface quickly. Community demos show Codex one-shotting interactive experiences in about three minutes; models already know APIs like editor.createShapes and the broader customization layer. tldraw also ships an Agent starter kit and MCP-style canvas integrations so agents can draw, diagram, and wireframe inside Claude or Cursor. The practical pattern is not “rewrite tldraw in Rust,” but drive the canvas with agents while optional backends or WASM do heavy work elsewhere.

On speed and load, tldraw targets large canvases rather than a single published cold-start millisecond number. Viewport culling can keep a 10,000-shape document smooth by rendering only what is on screen (e.g. ~50 visible). Defaults include maxShapesPerPage at 4,000, debouncedZoom when shape count exceeds 500, and LOD-style shortcuts such as disabling text shadows below a zoom threshold. SDK 5.0 added spatial indexing, faster overlay rendering, and hotter-path math so camera moves and large docs stay responsive. Load time depends on bundle, network, and document size; published strength is pan/zoom/edit feel at scale.

Rust, Go, and Python do not replace the SDK: the client is TypeScript/React in the browser, and agents plus offline scripting target JavaScript. Those languages fit beside it—servers for multiplayer sync or APIs, Python for data/ML feeding the canvas, Rust/WASM for heavy compute behind JS, Go for concurrent services. There is no fair head-to-head canvas benchmark across those stacks because they are different layers; agents bridge them by generating the JS that talks to the editor.

Sources