tldraw feels closer to paper than productivity software

Open tldraw and there is an oddly pleasant moment when almost nothing happens.

You get a canvas. A small row of tools. A few restrained controls around the edges. No onboarding tunnel demanding that you classify yourself as a founder, designer, teacher, consultant, strategist, student, enterprise administrator, or person who has somehow forgotten why they opened the browser in the first place.

You can simply start making marks.

That sounds trivial until you notice how uncommon it has become. Most creative software begins by asking you to negotiate with the software. Pick a file type. Name a project. Choose a workspace. Select a template. Accept a workflow. Understand somebody else’s taxonomy before your own thought is allowed to exist.

tldraw takes the opposite position. The thought gets to arrive first.

At tldraw.com, the company’s flagship whiteboard opens directly into a working drawing surface and is presented as a free whiteboard. The deeper tldraw project is much bigger: behind that deceptively quiet page sits a React-based infinite-canvas SDK with drawing, diagramming, rich text, arrows, snapping, image and video handling, collaboration, custom shapes, custom tools, programmable interactions, embedded web content, and a runtime API that lets software manipulate the canvas itself.

That mismatch is the interesting part. tldraw feels lightweight precisely because an enormous amount of work has been spent preventing its machinery from announcing itself.

The company now describes its SDK as the foundation for canvas experiences used inside products from companies including Google, Shopify, BlackRock, Autodesk, ClickUp, Replit, Runway, Padlet, Mobbin and Jam. Its public GitHub repository had about 49,700 stars when checked in August 2026.

Yet if you meet tldraw through the public whiteboard rather than its developer story, none of that is especially obvious.

It still feels like a piece of paper that happens not to have edges.

That is why it belongs in Web Radar. tldraw is easy to mistake for a small drawing site. Spend ten minutes with it and you discover a remarkably considered tool for diagrams, loose thinking, visual notes, interface sketches and collaborative scribbling. Spend longer around the project and the stranger idea emerges: tldraw is trying to make the canvas a primitive of software itself, something other products can borrow instead of rebuilding.

The project is compelling on both levels.

As a user, you get somewhere to think without ceremony.

As a developer, you get the machinery that makes such a place possible.

And lately, tldraw has pushed the idea somewhere even more unusual. A new desktop version called tldraw offline stores canvases as local files, works without an account or server, and lets local coding agents write scripts that alter how individual canvas files behave.

A whiteboard is quietly turning into a programmable medium.

But the reason that evolution works is the same reason the original site works.

The canvas still comes first.

The rare pleasure of software that responds immediately

Draw a rectangle in tldraw and it feels unremarkable.

That is a compliment of the highest order.

The rectangle appears where you expected it. Drag it and it follows. Resize it and the handles behave as your hand predicts. Draw an arrow between two objects and the connection behaves like a relationship rather than a decorative line. Sketch freely and the stroke feels loose enough to remain a sketch. Select several objects and their collective behaviour mostly matches the mental model you brought with you.

Nothing about this should be surprising.

Yet anyone who has used enough browser-based visual tools knows how often tiny points of friction accumulate. The selection target is slightly wrong. Panning starts when you meant to drag. Text editing requires an extra click. A shape snaps somewhere you did not want. An arrow loses its target. The canvas jumps when the viewport changes. A line acquires the polished stiffness of presentation software when you were only trying to think.

Creative flow tends to die from paper cuts, not dramatic failures.

tldraw has spent years on those paper cuts.

Its public repository describes support for pressure-sensitive drawing, geometric shapes, rich text, arrows, shape snapping, edge scrolling, image and video handling, exports, custom tools and custom bindings. The same repository exposes an editor API that software can use to drive the canvas at runtime.

The company’s own website now carries a striking little statement about the effort behind all of this: it says tldraw has spent three years and five million dollars building thousands of table-stakes canvas features, from rotating cursors to pasted-image behaviour.

That phrase, table stakes, gets at the problem.

Nobody opens a whiteboard because they are excited that pasted images behave correctly.

Nobody recommends a drawing app because pointer coordinates were handled well across browsers.

Nobody celebrates selection geometry.

Nobody wants a press release announcing that modifier keys now behave correctly during an obscure drag gesture.

But every one of those details becomes noticeable when it fails.

The better the canvas gets, the more invisible the engineering becomes.

A good pen does not ask you to admire its ink-delivery system every thirty seconds. A good notebook does not require you to think about how its pages are bound. Physical tools earn trust through predictability, and once that trust forms, attention shifts away from the tool and toward the thing being made.

tldraw’s most distinctive achievement is reproducing some of that trust inside a browser.

The visual design helps.

The canvas is intentionally plain. Controls are compact. Shapes have a slightly informal character. Freehand drawing does not pretend to be drafting software. Even geometric objects avoid looking excessively polished. The result is an environment where rough work does not feel embarrassed to exist.

That matters because the appearance of a tool changes the threshold for putting an unfinished thought into it.

Open a heavyweight design suite and you may begin designing.

Open presentation software and you may begin composing slides.

Open a document editor and you may begin writing sentences.

Open tldraw and you can begin with something worse than any of those: a half-formed arrangement of boxes, arrows, fragments, scribbles, circles and labels whose logic is only temporarily obvious to you.

That is often exactly what thinking looks like.

A strange advantage of paper is that it never demands semantic consistency. A circle can mean a person in one corner and a database in another. An arrow can mean sequence, ownership, movement, causation, dependency or merely “look over there.” A word can float alone because you have not decided where it belongs yet.

Paper tolerates ambiguity.

Many software systems dislike it.

They want objects to have types, records to have fields, tasks to have statuses, nodes to obey schemas and data to belong somewhere.

tldraw gives you enough structure to move quickly without forcing every mark to explain itself.

That makes it unusually good for the messy stage before a formal representation exists.

Suppose you are sketching a product idea. You draw three screens, a database, two arrows, an ugly blob representing some external service, and a sentence that says “maybe background job?” Nothing needs to compile. Nothing needs to become a Jira ticket. Nothing needs to satisfy a design system.

The canvas holds the ambiguity while you work out what you mean.

Then, when the thought becomes more concrete, the same canvas can become tidier. Objects can align. Arrows can bind. Text can settle into shapes. Images can be dropped in. Frames can separate regions. Collaborators can join.

The tool does not force the moment when sketch turns into structure.

That gradual transition is one reason tldraw feels closer to paper than a conventional diagram builder.

Diagram software often begins with the assumption that you already know what diagram you are making. Flowchart. Org chart. Network topology. UML. Mind map. Process map.

tldraw begins with the assumption that you have something in your head and need somewhere to put it.

Those are very different starting points.

Its speed reinforces the distinction. The best interactions feel almost throwaway. Draw a thing. Move it. Duplicate it. Delete it. Undo. Try another shape. Pull an arrow somewhere else. Scribble across the entire arrangement. Nothing feels precious.

Low ceremony makes experimentation cheap.

When experimentation is cheap, people make more intermediate versions.

That sounds like a minor UX observation, but it reaches surprisingly far. A slow canvas encourages planning before action. A quick canvas encourages action as part of planning.

You stop asking, “How should I represent this?”

You represent it badly, look at it, and then fix it.

That is much closer to how paper works.

The tldraw experience at a glance

The important pattern is continuity. tldraw does not make sketching, structuring, sharing and extending feel like completely separate categories of work. They can all happen on the same spatial surface.

This is also why comparing tldraw purely by feature count misses its appeal.

A larger whiteboard platform may have more templates, meeting functions, enterprise controls, integrations and facilitation systems. A dedicated illustration package has deeper drawing tools. A diagramming suite may have stronger formal notation. A design application may offer much richer layout and typography.

tldraw wins when you do not want the surrounding institution.

You want an empty place where an idea can move.

There is a lovely old dream in computing that digital tools should become extensions of thought rather than destinations we visit. Most software ended up moving the other way. Apps accumulated accounts, workspaces, notification systems, dashboards, content hierarchies and commercial machinery.

tldraw cannot escape that world entirely. It is a company with a commercial SDK, licensing, customers and developer products.

Yet the canvas retains something rare.

You touch it and something happens.

The distance between intention and visible result is very short.

Infinite space changes the way you arrange thoughts

The phrase infinite canvas has become familiar enough that it is easy to stop thinking about what it means.

A normal document gives you sequence.

A spreadsheet gives you a grid.

A slide deck gives you ordered frames.

A database gives you records.

An infinite canvas gives you proximity.

You decide what belongs near what.

That one change produces an entirely different relationship with information.

On tldraw, a thought can live above another thought without being a heading. It can sit to the side without becoming a sidebar. Two objects can be near each other without being formally grouped. A large empty area can separate concepts without requiring a new page.

Space itself becomes syntax.

This is particularly useful when you know relationships before you know categories.

Imagine investigating a complicated problem. You have screenshots, quotes, questions, people, dates, ideas and possible explanations. A document forces you to choose an order early. A database forces you to choose fields. A slide deck forces you to make frames.

On a canvas, you can place first and classify later.

Drop one screenshot in the middle.

Add another near it because something feels related.

Write a sentence.

Draw an arrow.

Move the entire cluster left.

Start another cluster.

Zoom out.

Suddenly a pattern appears.

That moment—when spatial arrangement reveals something that was difficult to see linearly—is the reason infinite canvases keep returning in software.

tldraw’s contribution is not inventing the concept. The web has had whiteboards, node editors, design canvases and visual thinking tools for years.

Its contribution is making the spatial surface unusually easy to inhabit.

Zoom and pan are not secondary navigation tools here. They are part of thinking.

You might keep the main architecture of a system in the centre, rough alternatives far to the right, discarded ideas below, reference images above and a tiny “parking lot” of unresolved questions somewhere near the edge.

A document would treat that arrangement as disorder.

On a canvas, the disorder can be informative.

The infinite surface also creates a curious sense of ownership. A board gradually acquires geography.

You remember that the authentication flow is “over there.”

The early sketches are “down below.”

The database notes are “next to the blue box.”

A strange idea you do not want to delete is “far off to the right.”

People begin referring to digital coordinates almost as if they were locations in a room.

Multiplayer makes this literal.

The tldraw sync system supports multiple people editing the same document simultaneously, with cursor presence and viewport following. Its collaboration documentation says the system handles connection management, conflict resolution and presence synchronization, while a server component coordinates shared changes.

A shared canvas becomes somewhere colleagues can meet.

That feels different from collaborative editing in a text document. In text, participants often compete for sequence. Someone is at paragraph three, another person is rewriting paragraph five, someone else leaves a comment on a sentence.

On a canvas, people can occupy different regions.

One person sketches.

Another collects references.

Someone pulls arrows between objects.

Someone else hangs back and watches.

The spatial separation reduces a particular kind of collaborative claustrophobia.

It also makes gesture more useful.

A collaborator can circle something.

Drag an object aside.

Point with a cursor.

Sketch a line through a region.

Move a cluster instead of explaining that the cluster should move.

These are tiny acts, but they resemble working beside someone at a physical whiteboard.

The software’s newer commenting system makes the location itself part of discussion. In SDK version 5.3, released on August 5, 2026, tldraw introduced comments that can be pinned to positions on a canvas or attached to objects. Pins follow shapes as those shapes move or rotate, can cluster when zoomed out, and can be linked directly so another participant opens at the relevant location.

The comment belongs to a place, not merely to a document.

That distinction sounds small until you think about reviewing visual work.

“Change this” means almost nothing without where.

Traditional comments solve the problem by referencing text ranges, cells, timestamps or selected elements.

A canvas can reference the location itself.

tldraw’s 5.3 comments go a step further because the company describes them as the first feature in a separately licensed collaboration package, with support for mentions, reactions, resolution and agent interactions.

There is a business story there, but the interaction story is more interesting.

The canvas is accumulating social behaviour without losing its spatial character.

That is the danger every simple tool eventually faces.

Success attracts features.

Features attract menus.

Menus attract settings.

Settings attract administration.

Before long, the lovely blank surface becomes a cockpit.

tldraw has not avoided new capabilities. Quite the opposite. Its SDK keeps gaining them.

The interesting test is whether the project can continue adding power below the surface rather than above it.

So far, much of its architecture points in that direction.

Custom shapes let developers make objects that behave in application-specific ways.

Custom tools can introduce new interactions.

Bindings can represent relationships between objects. The default arrows use bindings so that their endpoints stay attached as connected shapes move; the same underlying system can be applied to other constraint or node-style interactions.

The canvas can also render ordinary web content because it uses DOM-based rendering, allowing embedded material such as web pages and media rather than restricting every object to a single graphics technology.

This means the blank surface can stay conceptually simple while its objects become sophisticated.

That is a strong architectural trick.

Instead of turning tldraw into one giant application containing every workflow, developers can turn individual objects and behaviours into whatever a particular product needs.

A rectangle does not always have to be a rectangle.

It might become a database table.

A job in a pipeline.

A playable media object.

A task.

A model output.

A screenshot with annotations.

A simulation.

A custom business record.

A live component.

This is where tldraw stops being merely a pleasant whiteboard and becomes something more consequential.

The canvas is an interface pattern that other software can borrow.

The company has explicitly pursued that position.

In its 2025 Series A announcement, tldraw said the project began in 2021 as an open-source side project growing out of founder Steve Ruiz’s earlier work on digital ink. The team later saw a larger opportunity: product teams wanted canvas features but did not want to spend years building the underlying interaction system. tldraw framed its ambition as supplying that foundation.

By April 2025, the company said its SDK was already powering ClickUp Whiteboards, Padlet Sandbox, Jam’s screenshot annotations and internal tools at Mobbin, among other products and experiments.

That makes tldraw one of those strange web projects you may have used without knowing you used it.

The branded whiteboard is only the visible tip.

The more important product may be the feeling of its canvas appearing elsewhere.

The product underneath the product

There are really two tldraws.

One is the website people open when they need a quick board.

The other is a developer platform.

The first one is delightful because it feels small.

The second is interesting because it is not small at all.

The SDK is distributed as a React package and is meant to provide the foundation for custom canvas applications. Its GitHub documentation lists custom shapes, tools, bindings, UI components, side effects and event hooks. It supports self-hostable multiplayer through @tldraw/sync, and developers can control the running editor through its API.

In practical terms, developers can start with the behaviour of a mature drawing surface instead of beginning with raw pointer events and geometry.

Anyone who has attempted to build a canvas from scratch understands why that matters.

At first, the problem looks approachable.

Render a rectangle.

Move the rectangle.

Resize the rectangle.

Draw an arrow.

Add zoom.

Then the problem starts multiplying.

What happens when the rectangle rotates?

What happens when you resize a rotated rectangle?

How does selection work at different zoom levels?

What counts as a hit?

How do multiple selected objects resize around a shared centre?

What happens when a pointer leaves the window during a drag?

How do touch events coexist with scrolling?

How should stylus pressure behave?

How does snapping behave while objects rotate?

What happens to a bound arrow when its target is deleted?

How are pasted images positioned?

How does undo interact with multiplayer edits?

How do you migrate documents after the shape schema changes?

The basic demo is easy. The finished surface is brutal.

tldraw’s value to developers lies inside that gap.

The company has been unusually candid about the cost. Its current site repeats the “$5M canvas” idea: years and millions spent on details that a user mostly notices only when they are wrong.

That line also explains why so many software companies eventually buy or license foundations instead of rebuilding common infrastructure.

A team making a collaborative research product may have a brilliant idea for what should happen on the canvas.

They probably do not have a brilliant idea about pointer capture.

Nor should they need one.

Infrastructure becomes interesting when it absorbs the boring expertise.

The same logic explains the popularity of mapping APIs, rich-text editors, authentication services, payment processors and media frameworks.

tldraw is betting that the infinite canvas deserves a similar layer.

The bet seems increasingly plausible.

ClickUp rebuilt its whiteboarding feature around tldraw. Padlet used it for Sandbox. Mobbin used the SDK to create internal visual tools for content and machine-learning workflows. The tldraw site now showcases use by many companies across design, AI, education, software and creative tooling.

Mobbin’s example is revealing because it has little to do with casual whiteboarding.

According to tldraw’s case study, Mobbin used the canvas foundation to build two internal tools with a three-engineer team in less than three months: one for annotating interface elements and benchmarking machine-learning models, and another for managing design references used by its content team.

The canvas became a custom workbench.

That is a richer idea than “digital whiteboard.”

Once objects on the surface can represent domain-specific things, the infinite canvas becomes a way to arrange application state spatially.

You are no longer drawing a picture of the work.

The picture is the work.

A task card on a canvas might be the task.

A node might execute a process.

An annotation might change training data.

A screenshot might carry structured review state.

An arrow might represent a dependency the application understands.

That idea becomes particularly obvious in tldraw’s experimental projects.

Make Real, one of its viral demonstrations, lets users sketch interface ideas on a canvas and turn selected sketches into generated web prototypes. The output can then return to the canvas, where it can be marked up and iterated on.

tldraw Computer pushes farther, presenting an infinite canvas for connected components that generate and transform data using a multimodal language model. Components can be connected into branching or looping workflows.

The canvas stops representing computation and starts hosting computation.

This direction makes sense because spatial interfaces are unusually compatible with generative AI.

Chat interfaces are linear.

The user asks.

The model responds.

The user asks again.

Even when the system can handle images, files and code, the conversation itself usually remains a single descending column.

A canvas provides another dimension.

Outputs can sit next to inputs.

Alternatives can branch sideways.

Generated images can be grouped.

A model can modify existing objects rather than emitting another blob of text.

Humans can annotate regions instead of verbally describing them.

The spatial state becomes part of the prompt.

The interaction shifts from telling an AI what exists to showing it.

tldraw’s developer work increasingly reflects that interest.

Its current repository includes starter kits for multiplayer apps, AI agents that can read and modify canvas content, node-based workflows, canvas-oriented chat, image pipelines and branching conversations.

This is where the project becomes more than a pleasant drawing tool with a good API.

tldraw appears to be exploring a proposition about the future of software:

when AI can manipulate interfaces directly, the most useful interface may be an open spatial surface rather than a fixed collection of forms and panels.

There is a practical reason for that.

Traditional software encodes possible actions in advance.

A button exists because a developer predicted that somebody would need that action.

A form contains fields because the software already knows the expected structure.

A navigation hierarchy anticipates the user’s destination.

Generative systems weaken that assumption. If software can create or modify objects at runtime, an interface may need room for things that were not designed beforehand.

A canvas provides room.

This does not mean every application should become a whiteboard.

Plenty of tasks are better served by lists, tables, timelines, documents, forms and focused tools.

But the canvas is unusually good when the objects themselves are heterogeneous and the relationships between them are not known in advance.

That describes quite a lot of AI-assisted work.

It also explains why tldraw’s restraint matters.

A flexible canvas cannot feel flexible if the surrounding application is constantly prescribing what belongs on it.

The blankness is not missing functionality.

It is space reserved for somebody else’s functionality.

There is a tension here around licensing.

tldraw began as an open-source project, but its commercial SDK now operates under tldraw’s own license. The current repository states that the SDK may be used freely in development, while production use requires an appropriate license key. tldraw’s pricing page advertises a 100-day trial for production use and commercial licensing with multiplayer sync included.

The company’s 4.0 announcement in September 2025 explained the shift explicitly: development use remained permitted, while production deployment required a trial, commercial or hobby license.

That makes tldraw different from a drop-in permissively licensed canvas library.

For hobbyists experimenting locally, the barrier is low.

For teams building products, licensing is part of the decision.

The starter kits are a separate wrinkle. tldraw states that these project starters are MIT-licensed, even though the underlying SDK has its own production rules.

None of this diminishes the technical interest of the project, but it does matter when evaluating tldraw as infrastructure rather than merely visiting the free whiteboard.

The browser whiteboard is the easiest way to understand the feel.

The SDK is where you understand the ambition.

A whiteboard that has started turning into a file format

Then tldraw did something wonderfully unfashionable.

It made a desktop app that works without an account.

tldraw offline launched on July 16, 2026. The company describes it as a file-based desktop version of the infinite canvas with no accounts and no server. Documents stay local and can be used without an internet connection.

The premise is almost nostalgic.

Open file.

Work.

Save file.

Keep file.

For anyone who grew up with desktop software, this barely sounds like a feature.

For modern collaborative software, it borders on ideological dissent.

Web applications spent the last decade turning files into services.

Instead of “your document,” you get “a document in your workspace.”

Instead of a path on disk, you get a URL.

Instead of saving, the application syncs.

Instead of copying a file, you invite someone.

There are good reasons for this. Cloud collaboration solved real problems. Multiplayer editing is vastly easier when the service controls storage. History, permissions, asset handling and sharing all become manageable.

But something was lost.

A local file is legible ownership.

You know where it is.

You can duplicate it.

Back it up.

Archive it.

Move it.

Put it on external storage.

Keep it away from a server.

Open it when the network is dead.

The new desktop tldraw brings that model back without abandoning the richer behaviour of the canvas.

Its files use the .tldraw format, and the project says a file can bundle canvas data, associated assets and scripts.

That last part is where the nostalgic file metaphor becomes very current.

A tldraw file can contain behaviour.

The offline application allows scripts to interact with the canvas. Coding agents running on the user’s machine can create shapes, import material, respond to changes and write persistent JavaScript that runs when the file opens.

A file can therefore stop being a passive board and become a small custom application.

The tldraw team has already shown examples.

In a follow-up post published six days after the offline launch, it described boards turned into a data visualizer, presentation system, Kanban board, colour-palette extractor, task tracker and local AI model playground.

The fascinating part is that these remain files.

You can imagine receiving a .tldraw file that opens as a specific tool somebody created for one problem.

Not installing a whole application.

Not registering for a service.

Not configuring a workspace.

Just opening the thing.

That echoes an old dream of personal computing: documents that are alive enough to become tools.

Spreadsheets already do this.

A spreadsheet begins as cells, yet formulas, scripts, macros and structured data let one file become a calculator, forecasting model, tracker, lightweight database or strange piece of internal software.

Notebooks do something related for code and research.

HyperCard famously treated stacks of cards as programmable personal applications.

tldraw offline points toward a spatial variation of the same idea.

The primitive is not a cell or page.

It is an infinite surface full of objects.

This could remain a niche experiment. Scriptable files also introduce obvious questions about security and trust. A file that can run JavaScript is fundamentally different from an inert picture.

tldraw’s own launch post explains that the desktop environment deliberately loosens constraints that would be unacceptable in the online product. Online, allowing a model to generate arbitrary code and execute it would amount to giving it dangerous script-injection power. In the offline application, tldraw chose a local architecture where raw JavaScript can be executed in the editor context.

The freedom comes with responsibility.

Users should treat executable canvas files with the same caution they would bring to other scriptable documents or code obtained from somebody else.

But as a design experiment, the concept is excellent.

A tldraw file can begin as a rough sketch.

Then you ask a coding agent to give certain shapes behaviour.

Maybe cards snap into columns and update status.

Maybe dropping an image onto the canvas extracts information.

Maybe a button runs a local process.

Maybe the board watches files in a directory.

Maybe an architecture diagram updates as a repository changes.

The interface emerges inside the working document rather than requiring a separate software-development project before any custom behaviour can exist.

That dramatically changes the threshold for making little tools.

Internal software has always had a long tail of tiny needs that nobody builds.

One employee wants a custom visual tracker.

A researcher wants a peculiar annotation board.

A teacher wants an interactive exercise.

A designer wants a reference-sorting surface with one strange rule.

A developer wants an architecture diagram tied to local code.

These needs are often too specific for commercial software and too small to justify a formal application.

Scriptable canvas files occupy that neglected middle.

The coding agent is what makes the idea plausible for more people.

Without AI, asking ordinary users to write JavaScript inside a canvas file would sharply limit the audience.

With competent coding agents, the user can describe behaviour while the agent handles implementation.

That does not remove risk. Generated code can still be wrong, destructive or insecure. But it changes who can attempt the work.

The tldraw team describes examples where agents built persistent behaviours directly into files, including interfaces that react when shapes move between regions and visual tools generated around local data.

The canvas becomes an editable boundary between human intention and generated code.

This may turn out to be tldraw’s most interesting direction.

AI application builders usually generate conventional interfaces: websites, forms, dashboards, CRUD apps.

tldraw begins somewhere looser.

You draw the arrangement first.

The agent gives it behaviour.

That order feels natural because humans are often better at indicating spatial intent than specifying software architecture.

Draw three boxes.

Connect them.

Label one “incoming.”

Label another “review.”

Put a third on the right.

Then say: make cards move through these stages and timestamp them.

The sketch becomes a specification without pretending to be formal.

The roughness is an input format.

This loops back to why tldraw’s paper-like feel matters so much.

If drawing on the canvas were laborious, people would hesitate to use sketches as instructions.

If objects were difficult to manipulate, the generated result would feel trapped.

If the base canvas were visually heavy, custom behaviours would compete with the application chrome.

The calm interaction model creates room for these more experimental layers.

tldraw’s online project Make Real already demonstrated a version of this idea in 2023: sketch a user interface, send the selected drawing to an AI model, get a functioning web interpretation, then mark that result up again on the canvas.

tldraw offline extends the principle from “turn this sketch into an interface” toward “turn this particular canvas into the tool I need.”

That is a much stranger proposition.

It is also much more personal.

The imperfections are doing more work than they appear to

Spend enough time with tldraw and you may notice that its marks do not aspire to sterile perfection.

Lines have character.

Drawn shapes feel drawn.

The whole visual system retains enough informality that you are less tempted to treat every early decision as final.

This is not decoration.

It affects behaviour.

A perfectly rendered diagram creates psychological pressure. Once everything looks aligned and polished, modifying the structure can feel like damaging finished work.

A rough sketch gives permission to keep moving.

Visual imperfection lowers the cost of being wrong.

That idea appears repeatedly in creative tools.

Architects sketch because a sketch allows uncertainty.

Product teams use sticky notes because nobody confuses one with a finished specification.

Designers use low-fidelity wireframes because stakeholders otherwise start commenting on border radius instead of structure.

The fidelity of the representation tells people what kind of conversation they are allowed to have.

tldraw’s house style sits in an unusually productive middle.

It is not chaotic enough to become illegible.

It is not polished enough to masquerade as final output.

You can make neat diagrams, but they retain a mild sketchbook quality.

That is exactly where many thinking tasks belong.

The project even has a technical lineage in digital ink. tldraw says Steve Ruiz’s original 2021 side project grew out of earlier work on digital drawing, and the current company still treats drawing behaviour as a core part of the product rather than an accessory bolted onto a diagram editor.

The pen is part of the philosophy.

There is a larger pattern here worth noticing.

Software frequently tries to eliminate roughness.

Auto-align the objects.

Correct the line.

Predict the shape.

Standardize the spacing.

Convert handwriting.

Snap everything.

Clean everything.

Make the result look professional.

Those features can be useful, but relentless correction creates a subtle hostility toward the early stages of thought.

Sometimes the crooked arrow is better.

It says: this is provisional.

The hand-drawn mark also carries emphasis in a way geometric objects do not.

Circle something aggressively.

Underline it twice.

Cross something out.

Draw a huge arrow across half the board.

Make a tiny side note.

These gestures communicate priority and emotion without requiring another control.

Physical paper is rich in this kind of accidental metadata.

The size of handwriting, darkness of a stroke, number of circles, spatial placement and degree of mess all say things the writer never encoded formally.

Digital systems often flatten those clues.

A freehand canvas gives some of them back.

This is why tldraw works particularly well when people are explaining things to each other.

A polished flowchart communicates the final model.

A live sketch communicates the act of thinking through the model.

Those are different experiences.

Watch someone explain architecture while drawing boxes and arrows and you can see meaning emerge in sequence.

“This service talks to this.”

Arrow.

“But only after this happens.”

New box.

“And this is the weird part.”

Circle.

“Actually, move this over here.”

Drag.

The interaction itself carries narrative.

On tldraw, that performance can happen remotely while collaborators share the same spatial surface.

It is closer to gesturing at a table than editing a diagram file.

There are limitations.

tldraw is not trying to replace every visual tool.

If you need pixel-level design, advanced vector paths, detailed illustration, formal publishing controls, sophisticated data visualization or domain-specific engineering diagrams, specialist software has stronger tools.

If your work is mostly linear prose, a document is usually better.

If you need strict records with filters and workflows, a database-shaped product may be better.

If your organisation requires complex enterprise governance around every artifact, the free public whiteboard may not map neatly onto those expectations.

The canvas is strongest when spatial freedom is part of the work rather than decoration around it.

That distinction protects tldraw from the usual temptation to become a universal productivity suite.

Its identity is clearest when the answer to “what do you want to make?” remains open.

Sketches.

Diagrams.

Notes.

Maps of ideas.

Wireframes.

Annotations.

Workflows.

Visual explanations.

A strange custom tool you invented yesterday.

The project becomes less interesting whenever it is described as merely another Miro alternative.

Miro is a broad collaborative workspace with a large institutional feature set.

tldraw’s sharper identity lies in the canvas itself as material.

The company’s own history supports that reading. Its business did not grow from selling meeting templates. It grew from developers wanting the underlying canvas mechanics. Its 2025 funding announcement described companies repeatedly asking for the “bones” rather than another finished whiteboard product.

That says something useful about software design.

Some products become platforms because people want their features. Others become platforms because people want their feel.

tldraw is unusually close to the second category.

Developers can copy a feature list.

The harder thing to copy is the accumulation of small interaction choices that determine whether the surface feels trustworthy.

A shape should stay under the pointer.

The zoom should land where expected.

The arrow should remain attached.

The selected object should behave sensibly.

Undo should do what the user believes it will do.

The canvas should remain responsive when the file grows.

Nothing should make you stop and think about pointer mathematics.

This is what the “$5M canvas” line really communicates.

Fluidity is expensive.

The best interaction design often looks like almost nothing happened.

That is why tldraw is such a nice reminder of what craft in software can look like.

It is easy to praise flashy functions because they are visible.

AI generation is visible.

Multiplayer cursors are visible.

Comments are visible.

Offline scripting is extremely visible once you start playing with it.

But the quality that makes those features enjoyable is less visible.

The canvas obeys.

There is a specific pleasure in tools that obey.

Not predict.

Not coach.

Not interrupt.

Not gamify.

Not explain.

Obey.

You make a mark and the mark appears.

You move something and it moves.

You zoom out and the world becomes smaller.

The interaction becomes almost embarrassingly literal.

In an era full of software trying to interpret intent on your behalf, tldraw’s directness feels fresh.

It does not need to disappear completely.

You still know you are using software.

There are menus and controls.

There are constraints.

There are browser behaviours.

But the software spends less time reminding you of itself than most tools in its category.

That may be the closest a browser whiteboard can get to paper.

Where tldraw fits and where it does not

Is tldraw actually free?

The public tldraw whiteboard is offered as a free whiteboard, and the main site can be opened directly for drawing. The company uses that application as the flagship demonstration of its canvas technology.

The developer SDK is a separate matter. Development use and production deployment have different licensing rules. The current repository says the SDK is free to use in development while production use requires an appropriate license key. The commercial pricing page offers a 100-day production trial and asks companies to contact tldraw for commercial terms.

The new tldraw offline desktop application is also offered free, according to its July 2026 launch announcement.

So “Is tldraw free?” has three answers depending on what you mean: the public whiteboard, yes; the offline app, yes; embedding the SDK into a production product, check the current license.

Do I need an account just to draw?

For the web whiteboard, tldraw positions the experience around quick access rather than account ceremony, and its public site is designed to get you onto a board immediately.

The offline application goes further: it explicitly has no accounts and no server. Your files live locally, and the application works without network access.

That local model is particularly attractive for people who dislike turning every scratchpad into another cloud account.

Can tldraw replace Miro?

Sometimes, but that is not the most useful comparison.

If your needs are quick diagrams, shared sketching, rough workshops, architecture explanations, wireframes, idea maps or uncomplicated visual collaboration, tldraw may feel wonderfully lighter.

If you depend on a large ecosystem of enterprise meeting templates, organisational controls, planning modules and integrations, a broader collaboration suite may fit better.

The reason to try tldraw is not that it reproduces every feature of larger whiteboard platforms. It is that the act of drawing and arranging things feels unusually direct.

For certain users, that simplicity is not a missing feature.

It is the feature.

Is tldraw good for serious diagrams?

It depends on what “serious” means.

tldraw supports geometric shapes, text, arrows, snapping, bindings, images, media, grouping and many of the interactions needed for clear technical explanations.

It is excellent for software architecture sketches, process explanations, system maps, product flows and diagrams whose main job is to make an idea understandable.

It is less suited to domains where a diagram must follow strict technical notation, carry deeply structured metadata or satisfy specialist drafting requirements.

A tldraw diagram is often strongest as a thinking object rather than a formal engineering artifact.

Does collaboration work in real time?

Yes. Real-time collaboration is a core part of tldraw’s technical platform.

The @tldraw/sync system supports multiple users editing together, shared presence, cursors and viewport-related collaboration. Production applications can self-host the backend, while tldraw provides starter infrastructure and documentation for teams building their own applications.

The SDK’s newer collaboration package also adds location-aware comments. As of version 5.3, comment pins can attach to canvas objects, move with them and cluster depending on zoom level.

How private is the offline version?

tldraw says the offline application has no server and keeps files local, which means the basic storage model is fundamentally different from a cloud whiteboard.

That does not automatically make every workflow private. If you ask an external AI service to process information, install third-party tooling, synchronize the directory through another cloud provider or run untrusted scripts, other systems enter the picture.

The cleanest claim is therefore the one tldraw itself makes: the application can operate locally without an account or tldraw server, and the files themselves can remain on your computer.

Are scriptable .tldraw files safe?

They deserve more caution than a passive drawing.

tldraw offline allows executable JavaScript to interact with the editor, and persistent scripts can be saved into a file and run again when that document opens. The company deliberately treats this differently from its web product, where executing arbitrary model-generated JavaScript would carry unacceptable risk.

That power is exactly what makes the offline experiment fascinating, but code is code. A file obtained from somebody else should not be treated like an ordinary image.

The sensible mental model is closer to a scriptable spreadsheet, notebook or small project than to a JPEG.

Who should try tldraw first?

Developers, product designers, teachers, researchers, founders and anyone who explains ideas by drawing boxes and arrows will understand it quickly.

It is particularly good for the moment before the format of the work becomes obvious.

You have an idea, but you do not yet know whether it will become a document, interface, database, plan, diagram or piece of code.

Put it on the canvas.

tldraw is comfortable in that uncertain territory.

The SDK is interesting to a different audience: teams building products where the canvas itself is part of the interface. Those teams can use tldraw’s drawing engine as a foundation rather than reproducing years of interaction work themselves.

Why not just use pen and paper?

You should, when paper is better.

tldraw is compelling because it preserves some of paper’s immediacy while gaining the properties paper cannot have.

Objects move.

Undo works.

The surface keeps expanding.

Images drop in.

Arrows stay connected.

You can zoom from overview to detail.

Other people can enter the same space.

The board can become programmable.

A local coding agent can modify it.

Paper remains unmatched for zero-latency private thought. tldraw becomes interesting when the thought needs to remain fluid after it becomes digital.

Is the infinite canvas genuinely infinite?

“Infinite canvas” is a software convention rather than a claim about mathematical infinity. The practical point is that you are not working against a fixed page boundary.

The viewport moves through a much larger coordinate space, allowing material to spread out and be revisited by panning and zooming.

That changes behaviour far more than the literal size limit matters.

You stop designing pages and start designing neighbourhoods of thought.

Does tldraw work on touch devices?

The tldraw repository says the SDK supports browsers across desktop, touch screens, tablets and mobile devices, and drawing includes pressure-sensitive input.

Touch interaction is also clearly an active area of work rather than something the project considers finished forever. A July 2026 engineering post, for example, examined modifier-like gestures involving a second finger on tablets.

That detail captures something I like about the project.

The team treats apparently tiny input behaviours as product work.

That obsession is probably why the basic canvas feels good.

What is the catch?

There are several, depending on what you want.

For end users, the main limitation is that simplicity means tldraw does not try to swallow every productivity workflow. Specialist software will beat it at specialist jobs.

For developers, production licensing needs to be considered. The SDK is source-visible and easy to experiment with, but current production use is governed by tldraw’s license rather than a blanket permissive open-source license.

For offline scripting, flexibility creates security responsibility.

And for large sprawling boards, the freedom of an infinite canvas can become its own problem. Infinite space does not automatically produce organisation. A board can become a visual attic just as easily as a useful map.

None of those issues undo what tldraw gets right.

They define the conditions where its strengths matter.

A piece of the web worth keeping open

There is a category of website that becomes harder to appreciate because it does not immediately demand admiration.

tldraw belongs there.

You can visit it, scribble something, close the tab and think you have understood the entire project.

A drawing app.

Nice.

Fast.

Done.

But keep looking and the layers start appearing.

The free browser whiteboard is a demonstration of interaction quality.

The SDK is a bet that infinite-canvas mechanics should become reusable infrastructure.

The multiplayer system turns the canvas into shared space.

Custom shapes and tools turn it into application material.

Make Real and tldraw Computer explore the canvas as an interface to generative systems.

The offline application turns the board back into a local file.

Scripts turn that file into a tiny program.

Coding agents turn rough drawings into instructions for behaviour.

And somehow the blank page at the centre survives.

That is the accomplishment.

Most software products become visibly heavier as their ambition grows.

tldraw’s ambition has grown enormously.

The company’s current GitHub page talks about AI agent starter kits, workflow builders, multiplayer infrastructure, runtime APIs and application-specific objects. The company has raised venture funding, signed commercial customers and pushed the SDK into products used by much larger organisations.

Yet the first encounter remains a white surface and a drawing tool.

The best explanation may be that tldraw treats the canvas as the product and everything else as support for the canvas.

That ordering is easy to lose.

Product teams often begin with a simple interaction and then gradually bury it beneath everything the business needs: sharing, accounts, billing, templates, AI, analytics, administration, teams, notifications, automation.

Some of those layers become necessary.

But software acquires character from what it refuses to put in the user’s way.

tldraw’s character comes from shortening the distance between seeing an empty space and changing it.

That is why “it feels like paper” is not really about drawing style.

Paper has qualities software cannot reproduce.

It is instant.

It is private by default.

It has no loading state.

It asks for no login.

It never changes its interface.

It tolerates scribbles.

It tolerates contradiction.

It accepts a bad idea with the same indifference as a good one.

You can draw outside the implied structure because there is no implied structure.

Paper does not need to know what you are doing before it lets you do it.

tldraw gets closer to that principle than most browser tools.

Its canvas accepts something before it has a name.

That may be a sketch.

A diagram.

A plan.

A joke.

A product interface.

An architecture.

A workflow.

A little visual program.

A file that becomes its own application.

Whatever it is, the first move is still just putting something down.

That restraint makes the project unusually memorable.

There is an enormous temptation in software to confuse capability with visibility. If a product team spent months building something, perhaps users should see it. If a system has powerful features, perhaps the interface should announce them. If AI has been integrated, perhaps an enormous glowing button should make sure nobody misses it.

tldraw often feels like a counterargument.

Build extraordinary machinery.

Then let the user forget about it.

A bound arrow quietly keeps following its shape.

A multiplayer edit quietly arrives.

A local file quietly remembers itself.

A script quietly changes behaviour.

The technical accomplishment becomes useful precisely when the user stops thinking about the accomplishment.

This is not minimalism for aesthetic effect.

It is attention management.

Every tool competes with the thing made using the tool.

The worse the tool, the more attention it consumes.

The better the tool, the more attention it returns.

That is the quiet pleasure of tldraw.

It returns attention.

You open a blank board to explain something to somebody, and a few minutes later there are boxes, arrows and notes spread across a space that did not exist before.

The software has mostly vanished from your memory.

You remember the idea instead.

That is worth clicking.

Author:
Jan Bielik
CEO & Founder of Webiano Digital & Marketing Agency

This article is an original analysis supported by the sources cited below

tldraw whiteboard
The official browser-based tldraw whiteboard and the simplest way to experience the project’s infinite canvas directly.

tldraw GitHub repository
The official source repository documenting the SDK’s canvas engine, drawing and diagramming features, multiplayer support, extensibility, starter kits, licensing and current project usage.

tldraw company page
The official company page covering tldraw’s founding, team, flagship whiteboard, SDK business and related projects.

tldraw raises $10M to build the infinite canvas for developers
The company’s account of tldraw’s origins, business direction, SDK adoption, customers and goal of supplying reusable infinite-canvas infrastructure.

tldraw SDK 5.3
Official August 2026 release notes describing comments, object-attached discussion pins, canvas navigation behaviour and recent SDK changes.

Introducing tldraw offline
The official launch article for tldraw’s local file-based desktop application, including its offline model, .tldraw files, scripting and coding-agent integration.

Building with tldraw offline
A collection of early scriptable tldraw offline experiments including visualisation, presentations, task tracking, Kanban workflows and local AI tools.

Infinite Canvas SDK for React pricing and licensing
The official current licensing page covering development use, production trials and commercial SDK licensing.

This article was prepared with the assistance of artificial intelligence tools. The content underwent expert human review, and Webiano Digital & Marketing Agency assumes editorial responsibility for its final version and publication.