Building Book Production Platforms p3.

The Editor

This series is based on HTML as a source file format for Book Production Platforms. I have looked at many HTML editors over the years and can remember when the first in-browser editors was a shock. Prior to that, all HTML creation was done by writing directly in HTML code, then came fully-featured environments like Frontpage and Dreamweaver which allowed you to create HTML in a desktop app, then came wiki mark-up to liberate us all from the tedium of writing HTML, and then finally...the browser based WYSIWYG editor...

It's worth noting that the Wiki markup and WYSIWYG solutions were a different category to the previous solutions in that they weren't designed for creating webpages, rather they were designed to enable the production of wikis and content management systems.

What-You-See-Is-What-You-Get at that time was a refreshing and liberating idea, a newcomer to this scene (although WYSIWYG as a concept and approach to document creation predates the web, with the first true WYSIWYG editor being a word processing program called Bravo, invented by Charles Simonyi at the Xerox Palo Alto Research Center in the 1970s, the basis for MS Word and Excel). Many WYSIWYG strategies have been explored, and many weaknesses unearthed, including the very important critique that What-You-See-Isn't-What-You-Get, because the HTML created by these editors is unreliable, but more on this later...

As far as I can tell, the first HTML-based WYSIWYG editor was Amaya World( first released in 1996. I don't know what WYISWYG editor was the first to be embedded in a browser (if you know, please email me). However, I remember TinyMCE like it was a revelation. According to their Sourceforge page they started around 2004 ( The founders created it to solve the need to produce HTML in content management systems ( It was, and is, a great product. The strategy at the time was to pretty much emulate rendered HTML within a HTML textfield. TinyMCE (and the others that followed until contenteditable came along) used a heap of JavaScript to turn a simple editable textfield into a window onto the browser's layout engine.

Alt. Typesetting

From this point, a number of plugins were developed for use with WYSIWYG editors like TinyMCE to extend the functionality.

Some of these plugins ventured into the ever important area of typesetting. TinyMCE even tried at times to make up for the lack of browser functionality in this area - for example, there were some early and workable attempts to bring equation editing into TinyMCE. I can't remember when it was, but surely around 2006/2007 that IMathas had an experimental jab at this ( I thought it was pure genius at the time as there was no other solution (I searched! a lot!). As I can remember they used a very clever round-tripping to achieve the result...essentially, since browsers didn't then support Math, IMathAs supported inline equation writing using ASCIIMath syntax. When the user clicked out of the field, the editor sent the equation markup to the server, and the server returned the rendered equation as either a bitmap (PNG, JPG etc) or as vector graphics (SVG). It was genius and I built it into the workflow for FLOSS Manuals around 2010 because we wanted to write books with equations for softwares like CSound (produced in 2010/11). It worked great - the equations always looked a bit 'bit-mappy' but we could write and print books with equations using in-browser editors and HTML as source (the HTML produced included equations as images so we could render PDF direct from the HTML). Awesome.

It's also worth noting that these days math typesetting has largely moved to the client side with the evolution of fantastic libraries like MathJax ( and KateX ( These are JavaScript typesetting libraries designed to be included in webpages and render math from markup on the client side. There are one or two tools that still use server-side rendering, notably Mathoid (, and this is often used to reduce the burden on the client's browser, however they have possible additional bandwidth costs as the client and server must remain in communication with each other' otherwise nothing will be rendered or displayed.

Mature solutions for math and other typsetting issues are only just starting to come online - no surprise to historians who inform us that notations such as math and music were the last to come online for the printing press as well. The first book to contain music notation post-Gutenberg, the Main Psalter (, was printed with moveable type, and the music notation was added manually by scribe. It seems the first thing to get right is the printing of text, all other notations come later in print systems. These solutions are slowly evolving - even music notation has its champions ( However what is really surprising, is that Google, a company priding itself on being built from ground up by math-heads, seems to struggle to bring native math typesetting to their own browser ( I would say that is embarrassing.


Moving on from typesetting... The initial WYSIWYG editors proved an admirable solution for many content management systems. The name persisted but the background technology fundamentally changed in when the first implementations of the W3C contenteditable specification for HTML5 was brought to the browser ( Contenteditable is an attribute that you can add to a number of HTML container elements (like 'P' or 'div') that make their contents editable. So, in essence you are directly editing the content in the browser rather than through some JavaScript textfield trickery. This strategy might be called WYSI (What-you-see-IS). This strategy also spawned a whole new generation of editors leveraging this new native browser functionality. Aloha Editor was one of the first to grab the spotlight but there were many many others to follow. Additionally the big legacy WYSIWYG editors such as TinyMCE and CKEditor added support for contenteditable although they were a little slow to the party.

Contenteditable at first promised a lot... native editing of the browser ... phew ... that certainly lowers the technology burden and opens the door to innovation and experimentation. Additionally the idea that this is a read-write web suddenly comes more keenly into focus when you can just edit the webpage right there and inherit all the same JavaScript and CSS that operates on the element you are editing. It's good stuff.

Inevitably, though, some problems soon emerged, first some wobbly things about not being able to place a caret (your mouse pointer) between block elements (eg between two divs) was really a problem, but later a more serious issue was identified - contenteditable does not produce stable results across different browsers. Meaning that if you edit one page in browser A, the resulting HTML would look different if you edited the same page in browser B. That might not affect many people - if you just want some text with bold and italics and simple things, then it doesn't really matter... the HTML created will render results that will look pretty much the same across any browser. However there are use cases where this is a problem.

In the world I work in at the moment - scholarly publishing - we don't want a manuscript that contains inconsistent HTML depending on the browser it was edited in ... it hurts us down the road when we want to translate that HTML into different formats (eg JATS) or if we want to render that HTML directly to PDF and get consistent results.

So, unfortunately, editors like CKEditor (used by many book production platforms including Atlas), and TinyMCE (used by Press Books AKA Wordpress), or Aloha (used by Booktype 2) have to use a lot of JS magic to produce consistent HTML to overcome the problems with contenteditable and this doesn't always succeed. I would recommend reading this article from the Guardians tech team about these issues. You also may wish to look at this video from the Wikimedia Foundation Visual Editor core devs for the comments on contenteditable (audio is lousy, jump to 1.14.00) (readable subtitles can be found here

A better way

So...what can you do? The answer is kind of threefold.

First choice: decide not to care - an entirely legitimate approach. You can still do huge amounts with these editors, and if you need to tweak the HTML now and then, so what? I can clean up the HTML by hand for a 300 page book in an hour, not too tough really and it enables me to cash in on all the other enormous gains to be had from a single-source HTML environment.

Second choice: provide client-side and server-side clean up tools. Most editors have these built in, but it's also good to implement backend clean up tools to 'consistify' the HTML at save time (or at least at pre-render time).

Third choice: find an editor that is designed to produce consistent HTML.

In my opinion the third choice is the best long term option and the 'right way' to do things. Being able to produce reliable results with ease, and without having to do things twice, will make everyones life easier.

Thankfully there is a new editor on the scene that is designed to do just this - the Wikimedia Foundations Visual Editor ( This editor was developed to help the Wikimedia Foundation solve an uptake problem ( essentially there are not enough people these days prepared to sit around learning Wiki markup (which is pretty much a complicated scripting language these days). The resulting need to drop the threshold on the foundation's contributions environment has resulted in the development of the Visual Editor (VE). New contributors can use an easy WYSIWYG-like environment instead of having to learn mark up.

Obviously, the entire wikimedia universe is already stored as wiki mark-up, so the editor needs to be able to translate between HTML and wiki mark-up on the fly (interestingly, it is actually part of much larger plan to store all Wikimedia Foundation content in HTML - To do this there is a backend called Parsoid that converts mark-up to HTML and vice versa. Also, the HTML produced by the editor obviously needs to be tightly controlled, otherwise the results are going to be a mess when converting back to wiki mark up. VE does this by replicating the content in its own internal (JSON) model and displaying the results in a contenteditable region. When the content is edited, the edits are strictly controlled by the VE internal rules, and then rendered to display. The result... consistent HTML is produced across any edit session regardless of the browser used...

That's pretty good news. This is one reason amongst many that the platform I am working on for the Public Library of Science has adopted VE software (we were the first to use it outside of the Wikimedia Foundation) and we are extending it considerably and contributing the results upstream to the VE repos. So far we have added table, equation, and citation plugins - all of which are in early alpha state. If you want a peek, you can see some of the work here

I highly recommend to anyone building a book platform, or any other kind of knowledge production platform, that you examine VE more closely. It is a sophisticated software and has been carefully thought through. It is still relatively immature, and development is happening at an incredible pace, which can make testing new plugins against a unstable API a little arduous ... still it is a great solution. VE also approaches content editing in a way that will open the door to concurrent editing via operational transformations in HTML, which is a hard problem and currently only solved by Google and Wikidocs (recently acquired by Atlassian, see

If you are in the process of choosing an editor, choose VE and contribute to the effort to make it not just the best Open Source solution to editing in the browser, but the best solution full stop.

Many thanks to Raewyn Whyte for improving this article.