Any new-ish tools for authoring Quill games?


Are there any modern authoring tools for Quill games out there? It seems to be a pretty simple system, and I’m looking for a project to use as an excuse to learn the Fyne GUI toolkit for Go. It’s possible that nothing will come of it, and I don’t think I’ll bother if there are awesome new-ish tools out there, but I’m having trouble finding much. I’m not promising that anything will come of it and I’m easily distra… ooh shiny.

Anyway, thanks :slight_smile:

You may be looking for DAAD.


You could use either InPaws to make a PAW game (which is essentially QUILL 2.0), or Adventuron targets the same system (in 8-bit compatibility mode).

Then of course there is DAAD.

THE QUILL is a nice simple system and was the favourite authoring system of the late John Wilson.


Thanks for those recommendations. I love DAAD and what it (and Adventuron for that matter!) do. It’s such an awesome thing to have capable tools that cater to so many wonderful platforms.

I was thinking of The Quill specifically though and I was mostly curious if there was a small unexplored niche for making something modern for the humble Quill :slight_smile:

It’s not really an unexplored niche. There are still people making Quilled games; just not as many as people making games for PAW or DAAD.

There isn’t currently any easy-to-use modern system/interface for making Quilled games… At the moment you have to program directly in the Quill/Adventure Writer on your targeted system of choice. Some people have used shortcuts, mostly in the form of macros, to transfer material from one version of the Quill to another, after extracting the database from their chosen development platform using unQuill… Useful if you want to take advantage of the large number of systems that the Quill is available on, which is one of the main draws of the Quill.

I have an, in-progress, reference guide to Quill on various platforms…

I do understand the attraction of wanting to target The Quill. I do want to look at making a Quilled game myself at some point. But my main system of choice is still PAWs, through inPAWs, despite the availability of DAAD (which I do like).

For a recent(ish) example of a great modern game made using (the absolute base version of) the Quill, see Resistance


Yeah, so that was really the angle I was considering exploring. The Quill is more “structured” than PAW or DAAD (for example) so I think it’d lend itself more readily to a GUI based approach. I wrote a GUI editor for Scott Adams games a couple of years ago, but I wasn’t completely happy with how it turned out technically and I’d really like to give it another try.

That is a good starting point. Your Quill reference document had a lot of nice information and links as well. Thanks for that! It helps. :slight_smile:

1 Like

PAW and Quill are both extremely similar in terms of their structure; at least on the Spectrum, where it’s an editor-based system. CP/M PAW and DAAD share the same DNA, and are based around source files. Uto has produced a GUI interface for making simple DAAD games, from what I can remember.

Having a system that could export to Quill on various platforms would certainly be interesting. inPAWs shows that it’s possible to do if the motivation is there. The Spanish Conversational Adventure community have been the ones driving any Quill/PAW/DAAD development historically… they produced many (many) systems based on the Quill/PAW.

There just isn’t as much interest in the Quill at the moment. We don’t even have any tools for extracting the databases from most of the Adventure Writer-variant platforms, such as the Apple ][ and Atari… Which is a shame as the Atari, in particular, has quite a few platform-exclusive games.

[As an aside, one platform that isn’t currently listed in my Quill document is an unofficial one… the TI graphical calculators The Quill Adventure Writer - ]


Interesting! Didn’t know that the Quill ecosystem was that fragmented, but that only means that there are more fun things to do. More or less assumed that it was mostly restricted to British and Spanish games on the ZX Spectrum. Getting a handle on all of this will take a little bit of time in itself.

Gilsoft published the Quill in English for ZX Spectrum, Amstrad CPC, Commodore 64, BBC Micro & Acorn Electron, Sinclair QL, and Oric 1/Atmos; and also produced an (unreleased) Atari 800/XL version.

There were also Norweigian, Danish and Swedish officially licensed variants.

CodeWriter licensed and sold the system in the US (and “illegally” in France) for the C64, Atari 800/XL, Apple II/Franklin Ace 1000, and MS-DOS PC.

We currently have 797 games listed on CASA as being produced using The Quill, for at least one platform.

The Quill was very popular in Italy. There have been games written in other, technically not-supported languages, such as Russian, Slovenian, Dutch, Serbian, Czech, Portuguese, and Polish.

The Quill wasn’t a Spanish thing… The PAW was specifically tailored to work in Spanish. (A system needs to be able to see the endings of words to work in Spanish)

1 Like

The TI Port looks very interesting. I am a calcaholic. I DL’ed a copy for experimentation.

Thank you!


There seems to be also a version for the ZX81.


Another good spot! Doesn’t seem to have been completed, but still really interesting to find all these attempts at porting the system to other platforms.

What might be of interest to the OP, is that it looks like they were trying to develop a Windows-based visual editor for the Quill too.

The core issue in developing a modern Quill compiler is that the text editing use the target machine’s editing & formatting, esp. on color, blinking, reversing & similiar, so, on a spectrum one has eight foreground & background colours, on a C=64 one has sixteen colors and a reverse on/off and so on.

Of course, this imply that the 64 quill can create C64 story files, and the spectrum quill, spectrum story files, and so on…

and debating on how should be implemented text styling & colouring format for a modern quill toolset, I’m sure that the ancient Commodore/Sinclair rivaltry will re-raise its ugly head, so I warmly suggest treading with care on this debate…

Best regards from Italy,
dott. Piergiorgio.

1 Like

Yeah to be honest, when looking at developing across several different Quill platforms it’s the screen width that tends to cause the most issues. Quill is a lot more basic than the PAW, in that it doesn’t automatically insert line breaks. You have to manually arrange the text on screen yourself; taking care that words aren’t split between lines of the screen.

This is fine when you’re developing for a single platform, such as 32 columns on the Spectrum, but when you want to move your game across to another format, such as the 40 character Atari then it becomes an issue.

Manually reformatting the game for a new system is relatively easy but it can often cause memory issues, with the adjusted text not taking up the same amount of space. On limited memory systems, such as the Atari or Apple IIe, this can be very problematic.

Add to this the large number of differences between releases of the Quill even on a single platform (something like the Spectrum has several distinct variants as well as the option of using the various add-on tools to add functionality like ramsave, compression, fonts, graphics) and the fact that the BBC version is virtually a completely different system… It would be quite a challenge to create a single unified GUI-powered program that exports to the various flavours of Quill… Which is a shame, because that would be very cool.

For an idea of the difficulties porting to one of the more memory challenged systems like the Atari, take a look at some of Dev’s conversions on his page where he explains the various strategies… The Quill & AdventureWriter

(I realise that the whole cross-system side of thing is likely to be outside the scope of the original post, but it’s nice to highlight the intricacies of the Quill landscape for people; particularly those that were under the impression The Quill was just a British thing, or even just a Spectrum thing. It wasn’t, of course. In addition to all the various European games created using it, there were a lot of US and Australian titles produced.)


So much interesting information here and I’ve learned a lot from the recent comments.

As for actual implementation, I think I will focus on the ZX Spectrum Quill to begin with at least with an eye out for keeping things as platform independent as possible. The “beeb” Quill feels like it’s sort of an intermediate step between Quill and PAW, so I won’t deal with that (at least not initially).

I did find a nice-looking GUI (windows-only) program that seems to support both Quill and PAW: WinPAW
…my attempt won’t be as ambitious as that.

So, there’s no option to just leave it at 32 cols? Maybe by replacing spaces with new lines?

No, that’s really just a “next generation” PAW… it doesn’t produce 8-bit databases. There are lots of “next generation” PAWs… particularly from the Spanish community. See ngPAWS, NMP, Superglús etc.

As Dev says on his site… the options for a Spectrum to Atari conversion are…

  1. text padding from 32 to 40 (“wasting” memory)
  2. modifying the Atari screen resolution to 32, but with side effects losing last three lines for printing (including if the input line is at the bottom).
  3. converting the CRLF-tabs (is like a tab of 16 characters with the Quill does in the Sinclair)

But they’re not ideal, especially the padding as it eats into the memory on systems that already don’t have access to the same level of compression as Spectrum Quill plus The Press.

Yeah. That’s what I don’t understand. I guess option 3 is the closest, but instead of converting crlf-tabs, you convert space(chr32) → newline. So option 4.

Yes, if that was an option it would be a good solution; but it’s not an option.

Good to know! I started going through some ZX Spectrum snapshots with UnQuill and I’m starting to understand the extent of the reliance on platform-specific features. The ZX Spectrum games often use a lot of user-defined graphics (UDG) characters in location descriptions, which I imagine don’t translate over easily to other platforms.

Edit: …and then there’s the “newer” database format which supports “Illustrator” line graphics as well, i guess. Not going to support that initially either, so I suppose my target is limited indeed, for now.