Editors Types

We can write in Fountain syntax with minimal text editing softwares, such as basic notepad, memo apps, or the body of a e-mail, which is handy. It is also possible to use generic word processing softwarse (Open Office, Google Doc), as long as you can export in plain text without formatting. However, writing they propose is too basic (it is not dedicated to screenwriting) and the customization of the interface is often too limited to think about devoting the writing of an entire scenario in it. We need a more advanced and customizable editor, which understands that we are writing scenarios and not just any type of text, to provide us dedicated features such as a table of contents for easy navigation between sequences, self-completion of character names etc…

As I mentioned in the previous article, if most script editors are able to import/export Fountain, they often must first convert it into their own file format first. This means that they are not able to alter these files directly, which is a loss of interoperability.

There are some screenwriting softwares which can edit Fountain natively without conversion (a preferable mode of operation, as we’ll see in the next article), while being ergonomic and feature-rich. However most are paid and exclusive MacOS or iOS. If this does not bother you, then do not hesitate and have a look Slugline or LogLine, they could satisfy your needs!

For my part, in order not to feel limited, I always prefer free, open source, cross-platform and modular solutions .

That’s why we’re going to look at a code editor. Designed by developers for developers, this type of editors is particularly modular and thousands of plugins of all kinds are developed for free by their large community, to satisfy a wide variety of needs, for code editing of course, but also for advanced text writing.

In the world of free open source cross-platforms code editors, there is one which shines for its ease of customization: Atom.

Atom was thought of as “A hackable text editor for the 21st Century”. Is not the most efficient, especially in opening speed or long file processing, but it is by far the one which is the easiest to customize, while allowing to go very deep in the settings. That’s why it’s my favorite editor, for both code editing and scriptwriting!

Together, we will transform Atom into a complete script editor, as in the screenshot at the beginning of the article. Do not be scared: I put here all that I have found to meet my personal needs. You can only for for the first step, and be ready in less than 5 minutes.

Setting

Fountain Support

After installing Atom, we will have to install modules to make it meet our Fountain writing needs.

And that’s is cool, because other people have already thought about it!

So the first step is to simply install the Fountain package from Superlou.

To do this, File → Settings → Install , and just type Fountain then Install . That’s it, your Atom manages Fountain syntax!

This package is very interesting because it allows:

• To have different colors according to the different syntax elements (character name, dialogues, description etc …)
• To generate a PDF with standard formatting from your Fountain files
• To have a table of contents for your scenario (a little basic for now, but the developers are preparing a new version, following one of my feature requests)

Themes and Colors

Another great strength of Atom is its ease of interface customization.

There are already several themes installed (bright, dark, dark blue), but you can also install others if you wish. They are available in File → Settings → Themes .

To go further, you can even add your own style rules! A simple little piece of CSS code in File → Stylesheet and the display of my Fountain lines are transformed to fit my needs!

/* Color of character names */
.syntax--name.syntax--fountain {
  color: Silver;
}

/* Dialog color */
.syntax--dialogue.syntax--fountain {
  color: DarkGrey;
}

/* Couleur des description */
.syntax--fountain .syntax--text {
  color: SkyBlue;
}

/* Style des scène */
.syntax--fountain .syntax--scene {
  font-weight: bold;
  color: LimeGreen!important;
  text-decoration: underline;
}

You can customize the appearance of all elements with colors, bold, italic … These changes are visible only on the editor, and will not affect the rendering if you export in PDF.

Soft Wrap

In order not to have lines of text too long, I advise you to activate the function View → Toggle Soft Wrap if it is not already done.

Spell-Checker

When you write a lot of text, having an integrated dictionary is very useful. There is a native module for this: Spell-Check.

Auto-completion, the ability to predict the end of a word you are writing, is also available natively in Atom. You can adjust it according to your needs. I have personally set it to 3 characters, which allows to have characters names suggestion pretty quick when writing dialog.

Word Count

A word counter is very useful for evaluating the duration of a scenario. There is a very nice little module called word-count.

I modified it to add a time evaluation of the duration of the scenario (or selected text) according to the number of characters (an index more relevant than the number of words). I’ll probably suggest these changes officially at some point, or create my own official package to make installation easier for other users. EDIT 2018-06-04: The changes have been officialy merge into the original package!

Other Customizations

You can also change the behavior of some editing parameters using File → Settings → Editor , such as character size , or allow scrolling of the document after end (a feature that I particularly like, so you can put the text in the middle of the screen even if you write at the end of a script).

Advanced Features

The features above allow you to have features usually offered by a basic screenplay editors. Let’s go further! The following functions, being more advanced, will not be for everyone, but it can give you ideas.

Color for Characters Names

This is the function I missed under the other editors: to have colors for my characters, in order to facilitate the writing of dialogue scenes.

I have been exploring this solution for a long time before finding a functional trick. The implementation is not very easy, but once it is in place, it runs smoothly. Maybe someday someone will make a package easier to set up. The beauty of open source is also this permanent invitation to develop new custom tools!

To solve this problem, install Pigments, a package that looks for words or color codes in code, and visualize it using a maker, underlining or highlighting. The trick is just to create new colors definitions which will be called like our characters.

Then go to Pigments settings, and add fountain to the list of file types scanned by the module.

The code to add colors is not very simple for a novice, but do not be impressed, just change it carefully. Put it in your File → Init Script ... , a file with user custom scripts executed when the software starts. A change in this file therefore requires restarting Atom.

Here is the code in question, which colors the name of the main characters of my Alien 2347 saga:

# Add Alien 2347 Character Names Color
atom.packages.serviceHub.consume 'pigments.api', '1.0.0', (pigmentsAPI) ->
  colorRegexp="\\b(ZAWN|EURG|KRILG|FRUDE|PLAUDE|BERDE)\\b(?![-\\.:=\\(])"
  registry=pigmentsAPI.getProject().getColorExpressionsRegistry()

  registry.createExpression 'my-custom-colors', colorRegexp, ['*'], (match, expression, context) ->
    colors =
      ZAWN: "#0000FF"
      EURG: "#9966CC"
      KRILG: "#FF0000"
      FRUDE: "#800000"
      PLAUDE: "#FF8080"
      BERDE: "#23B8DC"

    [_,name]=match


    scopes: ['fountain']

    @colorExpression=@name=name
    @hex=colors[name].replace('#','')

Note that names are written in upper case. This allows to color only the name in dialog headings, and not name in the middle of a dialog line.

To add a name and a color, simply add the name to line 2 before the first parenthesis closure, prefixed by the | seperator, for example | X-RAYM , and add that name followed by a color below your list, as follows: X-RAYM: "# FFF000" . You see, it was not as complicated as it seems!

For my part, I chose the gutter type display, which I customized with the following style:

/* Pigments */

// Pigments line 48 fixed
.pigments-gutter-marker span, .pigments-gutter-marker-in-selection span {
    background-attachment: scroll !important;
}

atom-text-editor[data-grammar='source fountain'] .gutter .pigments-gutter-marker div span, atom-text-editor .gutter .pigments-gutter-marker-in-selection div span {
    height: 44px;
    top: 11px;
}

Here’s the result :

Tables of Contents

The table of contents by sequence currently proposed by the Fountain module of superlou rests on a architecture a little outdated, which does not allow resizing. Updates are planned (and will be ready soon, if all goes well). In the meantime, I explored a bit and found a rather nice way to have a similar feature, by installing another module: todo show.

The first goal of todo-show is to find all the places in the code (active file, opened files, or all files in the project directory), prefixed by some key words like TODO or NOTE, and to list them in a filterable table.

It is flexible enough to let us add our own rules. If like me you prefix sequences with a . , you only need to define a rule to check the lines which start with a dot. To do this, simply add \. to the list of monitored words.

Then, replace capture pattern by /(${TODOS})(.+#)/g. That’s all!

Versioning

A versioning system allows you to control changes to a set of files.

Because you’re working on a simple text file, you can use Git, one of the most advanced versioning systems available. No need to know how it works, nor to know all the available features, most of them related to issues of developers working in teams.

However, some features of Git are interesting in script writing:

• saving changes to scenarios (these backups are called “commits”)
• you can revert to an older saves (if you are not happy with a change)
• difference visualization tools between commits to see what has changed
• collaborative work made easier (we see who changed what and when)
• online synchronization to work from anywhere

And the good news is that a module to manage Git is directly integrated into Atom, since it was developed by GitHub, the leading company for online Git system, used by millions of developers around the world.

However, I advise you to use the GitLab platform if you want to save your scenarios online. It’s free, open source, and you can have private repositories to backup your files privately.

Real Time Collaborative Editing

With Teleype module, Atom can have real-time collaborative editing between multiple users directly on the local files. This type of collaboration is unusual in scenario, as writing is a relatively solitary process. However, during the spell checking process, it becomes very interesting and can save a lot of time!

Synchronizing Settings

You have fully set Atom to meet your needs. Cool!

However, you want to transfer your config to another computer, and you do not want to redo everything. Do not panic!

There is a simple module for synchronizing Atom settings between multiple PCs: sync-settings.

That’s it, your settings are accessible from anywhere. Portability of your Fountain data and your editor … freedom!

Note: there is also a portable version of Atom if you want to have it on a USB key for eg.

Fine Tuning

Here is a list of small modifications made to Atom to make the writing experience more perfect.

Filter the File List

My scenario directory is filled with .fountain files juxtaposed with .html files of the same name. To keep the list clean, I use a module that allows to filter the list of files: tree-view-filter. I just type fountain in the filter, and only those files will appear. Convenient !

Tab Order

Atom allows editing multiple files simultaneously through a tab system. By default, the tabs are in the order of opening. I prefer tabs to be ordered according to their names. I simply use the module tab-smart-sort for that.

Truncate File Names in Tabs

The files of the episodes of my saga are all prefixed by the name of the saga followed by - Episode then the number, and the name of the extension .fountain as suffix. By default, Atom displays full file name and extensions in the tabs. This takes a lot of room for redundant information. A simple little script in init.coffee to take the last number before the extension if it is.fountain , and the tab shows only the number of the episode.

# Add folder and filename to tab title
atom.workspace.observeTextEditors (editor) ->
  if editor.getTitle() isnt "untitled"
    title=editor.getTitle().match(/(\d+)\.fountain/)
    if title?
      editor.getTitle=-> title[1]
      editor.getLongTitle=-> title[1]
      editor.emitter.emit "did-change-title", editor.getTitle()

Custom Macros

The scenario is for me a working document. When I record the actors for an audio fiction, I like to mark the replicas which have been recorded.

Fountain offers a syntax to mark a line or a set of characters in bold, or in italic.

To put a group of words in italic, just add * before and after.

The thing is that when you have hundreds of lines of dialogue to mark, it’s long, it disrupts the concentration during the recording session … You’ve understood, I wanted to do it with a simple key, to not have to think about doing it. Saving time is precious!

In short, I made a small macro, which goes into the file File → Init Script ... :

atom.commands.add 'atom-text-editor', 'custom:x-raym add * line', ->
  editor=atom.workspace.getActiveTextEditor()
  editor.selectLinesContainingCursors()
  selection=editor.getLastSelection()
  text=selection.getText().slice(0, -2)
  selection.insertText("*" + text + "*\n")

Then just add the keyboard shortcut in File → Keymap... :

'atom-text-editor':
	'ctrl-*' : 'custom:x-raym add * line'

And here’s the result ! Effective!

Conclusion

After a small setting phase, you can now use a powerful, fully configurable Fountain editor which can meet your ergonomics and features requirements. Installing existing packages, customizing them, or developing your own functions could answer all your needs!

In the next article, we’ll see how working in Fountain natively can allow you to use or develop scenario analysis tools, no matter the editing software you use.

See you soon, and thanks for reading!

Beyond the time of research and development of proposed solutions, this article took more than 8 hours of writing, editing and translation. I invite you to make a donation if you liked it!

Thanks to Marie for the corrections!