Wayscript vs articy:draft

The longer answer

The graph: two capable flow editors

Both tools get the core job right — a visual branching graph with dialogue nodes, hubs and jumps, global variables, and conditions and instructions on the links between them. articy's flow view nests fragments inside fragments, which suits enormous projects that need hierarchy to stay navigable. Wayscript's graph is flatter and faster to read, with per-link conditions and logic written in plain, checkable expressions. On the canvas itself, honestly, neither tool embarrasses the other — the differences start with what surrounds it.

Quests and world structure: a first-class layer vs hand-built templates

articy can absolutely model quests — its template system is powerful enough to build quest objects, states and rewards from scratch, and many studios have. But it is a modelling exercise: you design the schema, wire the references, and maintain the conventions yourself. Wayscript ships the quest layer as a native feature — gated unlocks and rewards, success and failure gates, per-link conditions with any-of/all-of logic, auto-complete rules and a player-facing quest journal — plus a world map with quests pinned to places, travel routes between them, and a live traveled-route overlay when you playtest. If quest structure is the spine of your game, having it built in rather than built by hand is the single biggest difference between these tools.

Playtest and QA: simulation maturity vs a richer checklist

articy's presentation and simulation mode has years of production use behind it and does exactly what it promises. Wayscript's Play Mode answers with conveniences — a live variable debugger, saves you can branch from, and shareable prototype links so a teammate or tester can play a build without installing anything. On automated checking, Wayscript's flow analysis goes further than articy's basic validation: it hunts dead ends, unreachable nodes, soft-locks, undefined variables and conflicting gates, and turns the results into a fix-it list.

The entity database: the deepest templates vs a bible that links itself

Credit where due — articy's template and property system is the deepest entity modelling in any narrative tool, full stop. Custom types, inheritance, dropdowns, references, numeric properties: if your pipeline needs items with weight, rarity and vendor price, articy will model it precisely. Wayscript's typed story bible covers characters, places, items and factions with relationships — and adds the thing articy doesn't have: a self-updating backlink graph. Name a character in a dialogue node or a quest and her entry already lists it. articy tracks references; Wayscript draws the living map.

Collaboration: a server product vs built into the graph

Multi-user articy means articy:server plus SVN or Perforce — robust, proven, and genuinely the right shape for large studios that already run that infrastructure, but it is an installation and an admin job before it is a feature. In Wayscript, the graph itself is collaborative: presence, comments and history are built in, two writers can work the same flow at once, and there is nothing to host. For small teams without a build engineer to spare, that difference is the whole conversation.

Localization: two real pipelines

Both tools treat localization as a first-class workflow, which is rarer than it should be. articy exports and re-imports translation tables and offers DeepL integration for machine-assisted passes. Wayscript does CSV round-trip — every line keyed and stable across edits — with AI-assisted translation as an optional, opt-in pass. Neither will embarrass your loc team; this row is closer to a tie than a win.

Engine integration: first-party plugins vs open formats

Being fair here matters. articy's first-party Unity and Unreal importers are established, documented and proven in shipped production — today, that pipeline is more mature than anything Wayscript offers directly, and Wayscript's own first-party Unity importer is still on the roadmap. Wayscript's answer is openness instead: it exports ink and Yarn, two open formats with mature open-source runtimes already used in shipped games across Unity, Unreal and Godot, plus JSON and a live fetch API that serves your latest build or a pinned version. The trade is real: articy gives you the smoothest first-party path into two engines; Wayscript gives you formats no vendor can take away.

Platforms and offline: license checks vs local-first everywhere

articy:draft is a desktop tool with Windows-first heritage — articy:draft X added macOS support — and no mobile or web authoring; licensing is managed with an activation check. Wayscript ships the full studio on Windows, macOS, Linux, iOS, Android and the web, works offline by default with your project in local files, and never phones a license server to let you write. If you plot on a tablet on the sofa, or write on trains, this row decides it.

Price: licences vs a subscription

articy:draft 3 offers a free single-user edition — a genuinely generous on-ramp — and articy:draft X moves to subscription, with tiers by seat and features (check their site for current numbers; multi-user adds articy:server). Wayscript's writing studio and story bible are free on every platform; the interactive studio — graph, quests, playtest, world map, engine export — ships with the Author plan at $8/month. For a solo narrative designer, both entry points are cheap; for teams, compare articy's per-seat tiers plus server against a flat $8 per writer.

Switching from articy:draft

Honestly: there is no importer for articy project files. Flow structure, quest schemas and entity templates are re-created in Wayscript by hand, and prose or scripts move across via standard document imports. For a team deep in production inside articy, switching mid-project is almost never worth it — finish the game. Where Wayscript earns the look is the next project: start the graph, the quests and the bible in one place, and keep the articy archive on disk untouched.