There was a bug in the code which causes Twee plugin v1.5.3 to crash when Story view is open and you enter some incomplete or malformed links and passages.

It is fixed in 1.5.4.

Because I use Naracea mainly as a tool for writing interactive stories these days, I decided to include Twee plugin in .exe installation. Main reason is that Windows has problem with putting downloaded .dll files in Program files folder — it prevents execution by default, which is hard to explain and resolve. Having plugin in installer package solves this issue nicely.

While on it, I added simple diagram representation for Twine/Twee stories (using nice diagramming component from this series) and better handling of settings changes (now they mark branch/document as dirty).

Enjoy!

It isn’t much, but since I’m working on my other projects (new interactive fiction and little game written in Unity3D), I don’t have much time to do more work on Naracea. I was planning to merge changes from latest AvalonEdit, but there are so many changes since I branched my own version, it would require lot of effort, and considering current editor works just fine, I don’t see the benefit from spending time on the task. I take this as a lesson for future development: never branch too far from official OSS libraries, you will regret it in the long term.

However, Naracea is not dead by any means. I’ll continue development albeit at somehow slower pace.

That means, that there are no big announcements for version 1.5.1, just little tweaks here and there.

For example I extended Find&Replace so now it is possible to search not just active branch, but also all branches which are activated already or all branches regardless their state (which means all branches are activated if needed).

Or there is extension of PyScript plugin, which adds Python standard library (as available for IronPython, of course). (See PyScript plugin page for details.)

Or the new Twine/Twee plugin.

Or the new hotkey (F7) for rescanning spelling on the whole branch and some improvements in how the spell-checker works.

And some more fixed issues and minor improvements.

Sure, there is nothing groundbreaking, but this is still worthy update. Just go to the download page, and check for yourself.

So, what’s new in 1.5.0?

There is first wave of small changes which were bugging me for long time: tabs (both document and branch) can now be reordered, I fixed several of the most obvious bugs and added syntax highlighting for twee. And of course – Naracea now has plug-in model, which allowed me to implement IronPython scripting.

There is new ribbon tab for scripting related operations:

Basically any scripts can be placed in proper directory which is auto-created for you when you click Open folder button, however for convenience you can also create new Naracea document which would be configured automatically (so it exports its branches to script folder with proper file extensions, sets syntax highlighting etc.) by clicking on Edit button (in case the file already exists, it will just open it). Location of the script folder is in your profile’s AppData folder (something like C:\Users\<username>\AppData\Roaming\Naracea\Plugins\PyScript). There is console, which can be opened by Show log button and whenever you add some script to the script folder you need to click on Refresh button to update list of scripts. Clicking on script button will run the script, Stop button is there to allow you to cancel script when you do something wrong (like writing infinite loop).

So in the end you can very quickly do something like this:

As you probably noticed there is button Debug mode. When this button is checked, Naracea configures IronPython runtime in such a way, that you can attach Visual Studio 2012 to the Naracea.exe and debug the script:

What I usually do to debug my scripts is, that I enable debugging in the editor, then I open the script folder, drag and drop the script file in to VS2012, attach to Naracea.exe (from Visual Studio menu Debug->Attach to Process), setup some break points and run script in Naracea.

You can even inspect Naracea’s internals from debugger, since IronPyhon is publishing PluginHost interface object, but please, do not abuse this. Only things which are defined in IPluginHost interface are somehow guaranteed to be safe (see folder Naracea.Plugins/Plugin/Interfaces in this repository for details; it is also the only reference for the plug-in interface I have right now). Everything else is implementation detail and subject to change.

So, Python scripting solves lots of problems with missing features in the editor (see e.g. this blog post which shows how to setup Naracea to build Twine stories written in twee) and I’ll try to post some interesting script snippets here. I currently do not plan to extend the documentation for plug-ins too much, however if you feel that you need to write a Naracea plug-in, let me know and I’ll provide you some guidance.

Plug-ins do not require any special installation, just copy them to application installation folder and restart the app. To get rid of plug-in, just delete the .dll. Sure, things can get little bit more tricky when plug-in depends on some 3rd party assemblies, so perhaps I’ll introduce a way to manage this kind of conflicts, but right now things can be kept simple.

So, if you want to take a look on plug-in interfaces, visit Naracea.Plugins repository.

Now, all this is pretty boring, and I probably wouldn’t go from 1.4 to 1.5, if there wasn’t something more. And the one more thing thing is one new plug-in which I’ve written. And that plug-in is Python scripting engine.

Sure, I understand this is not something revolutionary, because there are plenty of editors which can be scripted in various programming languages (and also writing Python scripts to do things with text editor has appeal for limited audience), but well, it is still really exciting to write a script and… well, see it running.

For me scripting is a natural way to extend Naracea’s functionality, mainly because I don’t need to compile and build and package whole application for one little missing piece of functionality. I just write a script, test it, and here we go, I’ve got a new function.

Anyway. There is a bit of UI related to Python scripting, which is quite obvious. Scripts need to be stored in Naracea’s application data folder, and you can open that folder from UI. Plug-in creates Naracea document configured to have Pyhon syntax highlighting and exporting everything to the right place with .py extension, but you don’t need to use it — just copy your scripts into folder and click refresh.

Currently I’m testing the whole thing, and tuning couple of other minor features I implemented, so I expect 1.5 release to be available in couple of weeks. Stay tuned!

One might wonder, why it took me so long to do so little. And the truth is, that while I still care about Naracea, I started working on something else. If you remember, I initiated work on this crazy text editor because I wanted to write something. And since now the editor does pretty much everything I need it to do, I tried some writing. And I realized, that I don’t want to just write dead words, immutable snapshot of current state of my mind, because that’s just… too limiting.

Today’s media can be so rich, that having just one predefined way through the story seems, well, inadequate. So I downloaded Unity3D and started to learn how to use it to build a game. And I downloaded Blender and started learning how to create 3D models, and how to texture them. And I read whole lot of articles and seen number of video lectures about game design and story telling in games. This kind of stuff. You see – I was having lots of fun.

And I realized: this is awesome, this is what I want to do now with the limited amount of my spare time. And I felt bad about leaving Naracea abandoned, because I think it is solid product with features that more people might find useful. But the problem is, that I’m kind of bad in marketing application like this, thus not many people know about it, thus I miss feedback which is essential for further development. And my motivation goes down.

And I was thinking some more: what should I do to get back the right spirit to work on Naracea. Not every free hour, of course, because now I have story to tell (through a game) and I want to work on that, but at least sometimes an evening here or a night there. Creep a feature in from time to time, just to keep it alive. And I figured what is the problem, and what I need to do to put fun back into Naracea’s development.

I need to make it free.

Really. As simple as that. Anyway, it was almost free anyway (it was my intention to not create crippleware, and to make shareware notification as unobtrusive as possible), so in fact it is not a big change (just removing licensing code and change of the license). But the application feels completely different to me now.

I don’t need to worry about lots of things I did worry about. I can, for example, upgrade to .NET 4.5 without worrying application will not run on Windows XP (.NET 4.5 is not supported there) and enjoy the huge performance improvement WPF applications have in 4.5 in comparison to 4.0 or get rid of the old WPF ribbon control and use the one from 4.5 framework (which is far from ideal, but it is somehow better). I can add features easily, test them with less fear of making eventual paying customer angry. It is freeware, I write it, you use it, if there is a bug, let me know and I’ll fix it and everybody’s happy.

I feel I can be much more open about the development now, I can turn this blog into something more personal, and if there is enough interest, I can always add PayPal donate button to let people show that they appreciate what I do.

So from 1.4.0 Naracea is free. For now it is free as in a free beer, because making my repository completely public would need some work I don’t want spend time with right now, however there is at least issue tracker and wiki page available on BitBucket, and I also moved away from releasing Naracea.AvalonEdit as a ZIP file (which was really annoying and stupid from me), and you can access it at BitBucket as well (unfortunately there is no history right now, but future changes will be pushed into the repository). And I’ll make open source as much as possible of the stuff which will be added from now. And what do I plan to add in some foreseeable future?

Well, I have two things I want to do: first is extracting exporters from the application to separate plug-ins with defined interface, so whoever wants to add export to other format can easily write exporter and add it to the application. Second thing is scripting support. At this moment I think Python scripts will be the right choice (via IronPython), but let’s see. And of course, there will be usual bug fixing and little improvements here and there.

So, this is it. If you want, go to download page and give Naracea a try.

Spell check

First major feature is of course background spellchecker, which detects issues in spelling as you type:

While most of the implementation was very straightforward, there was one tough decision I needed to do: which spelling dictionaries should be included in installation package? Since I’ve used Hunspell as an actual spellchecker, and there is wide variety of Hunspell dictionaries which have very permissive licenses, it is not a problem to install lots of them when Naracea is being installed, however from maintenance point of view it would be real hell to keep all these dictionaries up to date.

Therefore I decided to move the decision which dictionaries should Naracea offer to the user, because he knows best what dictionaries he needs. Thus instead of gathering all of the dictionaries and polluting dictionary list with lots of languages which are not need, I implemented easy to use dictionary installer.

Basically all you need to do is download Hunspell dictionary, click one button, select the dictionary files and you have a dictionary available. Since hunting for plain Hunspell dictionaries might be tedious, Naracea can extract Hunspell dictionaries from OpenOffice.org extensions (please, check licenses of any dictionary you install from OpenOffice.org extensions, there might apply some limitations). I understand that this is an extra step for end user, however this is the only solution for spell check I’m able to maintain at this point.

Naracea also supports custom dictionaries, so when the word is not in the dictionary you are using, you can add it to your custom dictionary. Custom dictionaries are specific for each installed language.

Markup

Second feature new to 1.3, and I like this one really much, is markup processing. Naracea really is a text editor, and my intention never was to have any kind of WYSIWYG-like text formating functionality, because I believe having all those formatting options available while writing, is shifting author’s focus from content to the form. And that’s something I don’t like.

But the truth is, that some kind of formatting is a must for modern text editing application (let’s say you are writing blog post and you want to turn some part of the text into italics or bold to emphasize something). Fortunately there is a known solution to this problem, which many people (including me) like: markup.

What is markup? It is a way to decorate your text to give application you are using hints about the formatting, so the application can later process your markup and generate out of it e.g. HTML with proper formatting. There are many flavors of markup, but for quick, unobtrusive formatting, particularly popular one is Markdown. Markdown uses special characters like * or _ to tell the application that some portion of the text should be *bold* or _italics_ (which will be converted to bold and italics). There are much more special formatting sequences in Markdown, into which I’m not going to dive too deeply, because first, Naracea doesn’t use Markdown, but Textile, which looks very similar to Markdown, but has, in my opinion, better feature set (e.g. it includes simple table generation, better list support and couple of other things, which make it superior to Markdown), and second most important formatting sequences are described in Naracea’s help.

Of course, Naracea’s internal text viewer now processes most of the markup, and there is also new possibility to view text in web browser, which offers complete support for all supported formatting. I also added possibility to export current (either manually or automatically when document is saved) text to either RTF (Rich Text Format) files (which can be easily imported by almost all WYSIWYG applications like Microsoft Word) or HTML (when using autoexport, you can place your own CSS stylesheet in file style.css to the same directory you are exporting to). Alternatively it is possible to copy formatted HTML to clipboard.

And yes, as you probably noticed already in screenshots, there is syntax highlighter for Textile, so you can see where your markup applies.

And that’s pretty much it.

I really like how Naracea works now. All the basic feature I wanted to have in it are implemented now, and they seem to work very well together. If you are interested, please go and check them yourself.

While I was testing naracea 1.2, which added this nice spellchecker I’m currently using, I was able to put some extra time into development, and before I was satisfied with 1.2, I somehow managed implement on satisfactory level what I intended for 1.3. So considering this short time which would be between the two releases, I decided to skip 1.2 altogether and go from 1.1 to 1.3 directly. There will be some slight delay in the schedule, but since the 1.3 looks pretty solid as it is right now, I believe I’ll be able to release it in the first week of July.

So, what’s new in 1.3? From never-released-1.2 there is the spellchecker, of course, but I also managed to integrate simple markup processor Textile. So now you can markup your plain text with Textile markup and naracea. Of course, I added some very basic syntax highlighter for Textile, so if you turn it on, you can recognize some basic formatting as you are typing, and there is also possibility to export markup to HTML and RTF files. Plus markup processing when you open text viewer. And possibility to view the processed text in web browser.

I think this is neat update, and naracea finally has all features I originally wanted to have in version 1.0, but it wasn’t reasonable to wait with the release until I’ll implement them all. The releasing gave me the urge to fix bugs and keep everything in good shape, and even though I feel slight embarrassment over 1.0 now, when all those features are finished, I’m definitely glad I released early, even though I’m not able to release as often as I’d like.

So, here is the installer, and here you can download the zipped application.

Pressing Check spelling ribbon button will open menu, where you can either select spelling dictionary you want to use for current branch, or install new dictionary. Naracea uses Hunspell for spelling checking, so you can use any Hunspell dictionary available, or you can import Hunspell dictionaries from OpenOffice.org dictionary files (which can be downloaded from OpenOffice.org extension page). Just select .aff and .dic files (Hunspell spelling dictionary files), or .oxt file (OpenOffice.org spelling dictionary file), and Naracea will do rest of the work. (Please note, that different dictionaries come with different licenses. While most of the dictionaries have very permissive licenses, please read carefully attached licenses carefully before installing any dictionary.)

Activating spell checker is as easy as selecting one of the installed languages. Spelling errors are marked with red underline, right clicking word with spelling issue opens context menu with suggestions. To turn spell checker off for current branch, select “None” as your spelling dictionary.

I’ll spend one or two weeks with intensive testing now, and if there are no major issues, I’ll release Naracea 1.2 version early in the June.