A couple of years back I and Jim Munroe released an alpha version of Texture, a touchscreen optimized interactive fiction authoring system in which you drag and drop words on top of story text. We've worked on the release version ever since and earlier this week it was published at texturewriter.com.

There are too many new features to list them all, but here are the highlights:

• New layout, user interface and typography. Page text adapts to available screen space automatically.
• State tracking through flags and behaviors: actions can toggle flags on and off, which in turn lets the author trigger alternative behavior based on which flags have been set.
• The action's name (which is displayed when the command is dragged over its target) doesn't have to be strictly verb-noun anymore. The most common use case is adding prepositions ("sit under tree" instead of "sit tree") but it can be changed to anything at all ("sit" + "tree" → "rest under the redwood").
• Command targets can consist of more than one word by using underscores which are shown as spaces in the final story (e.g. "oak_tree" would be printed as "oak tree" but both words would be targeted at the same time.)
• A command target can be reused after an action has replaced it with new text by enclosing a word in the new text in [brackets].
• Basic text formatting options (bold and italic text).
• Cover page and cover art; the cover page also acts as a tutorial for people who are playing a Texture game for the first time. Clicking or tapping the play button shows a "ghost" of the button being dragged to demonstrate how interaction works, and clicking again pops up explicit instructions.
• Preview right in the editor, with a debugging console for manually toggling flags and following internal behaviors and flag changes.
• Exporting and importing project backups.
• An interactive tutorial that guides you through the basic features.

In addition to new editor features, stories can be published online at texturewriter.com without needing to download the project and host it on your own web site.

Logging in to the web site will automatically save your projects to the server, so they'll be safe even if you clear the browser's cache and you can access them on any device by logging in. You can still use the system as a guest, in which case the projects will be saved locally to the browser (and nothing is sent to the server), but then you'll have to back up the projects manually.

The flag system makes Texture a "real" system with state tracking instead of just simple tree-like branching. In terms of story logic we're unlikely to add features to the online IDE because it's starting to approach the limit where the visual interface can't represent more complexity in a way that wouldn't make writing stories cumbersome and error-prone. We're planning to release the Texture Reader (analogous to parser game interpreters) as a JavaScript library which would allow writing story logic of any complexity using JavaScript.

Other new features are possible though, and the next major feature under development is story-specific layout options (color and font choice.)

You can read more from Jim Munroe's blog post and from Emily Short's blog where Jim talks about writing Pretty Sure.

I've been working with Jim Munroe (Everybody Dies, Guilded Youth) on developing a new kind of text game authoring system. It's called Texture, and it debuted yesterday at the WordPlay Festival in Toronto.

Stories authored with Texture are structured like books. Each scene or node is one page that has about one screenful of text. On each page under the text are some verb boxes. Dragging and dropping the verbs on the text changes the story, resulting in a sort of e-book that mutates and evolves based on the reader's interaction.

The interface is designed for touchscreen devices. It's possible to play with a mouse but dragging the verbs with a finger is the more natural way of interaction.

The writing tool looks almost the same as the resulting story, with added authoring controls.

There's very little modal difference between the reader and the writer. You write the text on the page directly and create commands by first adding some verbs and then dragging them on nouns, just like you do when you're reading the story.

The writer's user interface steals borrows heavily from Twine 2 which I think does a lot of things right and having similar elements hopefully makes the interface easy to learn. The system itself is Jim's vision, my role is mostly on the implementation side.

When's it out, you ask? Right now! You can try the alpha version at texturewriter.com. (Disclaimer: early alpha. Not tested in IE, use Chrome or Firefox if possible. In Safari you need to save the page manually after clicking the "download" button. You may also need to try dragging the verbs twice before it responds to dropping the verb on words.)

The one major feature that's still missing is setting and reacting to flags, which would let you change the output based on earlier interaction. At the moment the system is basically stateless although not linear – you can branch the story by having different actions open different pages.