Edit Mac Scrivener 3 With iOS Ulysses, Part 1: Prepping Your Brain (Changing Your Scrivener Habits) #amwriting

Scrivener and Ulysses CAN get along

So you’re frustrated by iOS Scrivener’s limitations compared to Mac Scrivener 3, and by its old-fashioned (by iOS standards) interface. You may or may not loathe Dropbox, but you’re definitely frustrated by iOS Scrivener’s “stop everything” sync. You look at iOS Ulysses with its slick interface and wonder why you can’t just use it to edit your Scrivener project. After all, you don’t get full-up Scrivener on iOS, anyway…

Well, dear reader, you can! You can have Scrivener and Ulysses sync with either an iCloud Drive-based sync, or a Dropbox-based sync. But—it involves changing the way you use Scrivener, and effort to adapt your existing Scrivener projects. (Sadly, Mac Scrivener itself will need a “stop everything” sync, but you won’t have to start it and it will go by fast.) Still interested? Read on.

What do you mean, “prepping your brain”?

You’re going to learn to work with Scrivener projects in Scrivener while keeping (eventual) editing with iOS Ulysses in mind. No matter how much you do in Ulysses, there will be a lot that you still need to do in Scrivener; Scrivener has far more robust organising tools, and Scrivener’s compiler provides customisable output not possible from Ulysses.

You’ll need a new attitude towards using Scrivener if using iOS Ulysses as editor is to work well for you. You’ll have to mentally “forget about” certain Scrivener features that cause a lot of friction going back and forth with Ulysses. In some cases, you can add these back after you’ve finished your first draft and have moved on to working with beta readers, editors, professors, publishers, etc. Others features will leave your project forever.

This may be your workflow if:

  • You much prefer Markdown-style editing to Rich Text (WYSIWYG) editing. If you love Scrivener organisation tools (Corkboard! Outliner! Scrivenings!) or Scrivener’s output flexibility, but hate its editor, this may be the workflow you’re looking for.
  • Dropbox gives you hives. If you’d much rather have your project on iCloud Drive than Dropbox, yet be able to edit on iOS without copying the project, this may be the workflow you’re looking for.
  • You do most of your work in simple prose. Maybe you use a bulleted list of your acknowledgements in the back pages, or a table of… something in your preface, with a modest title page and an illustration or 3 and that’s about it. If most of your work is straightforward prose, and you like it that way, this may be the workflow you’re looking for.

This workflow may not be for you if:

  • You’re not going to use Scrivener’s compiler. If you’re not compiling for final output in Scrivener, this workflow may not be for you.
  • You use elaborate list formatting inside Scrivener documents. If you need anything more than web-style bulleted or numbered lists, you may need to adjust them in your compiled output. If this won’t suit, this workflow may not be for you.
  • You use anything but the simplest tables inside Scrivener. Only very simple tables typed in as text in MultiMarkdown format will work well. If you need fancier tables, you may need to adjust them in your compiled output. If this won’t suit, this workflow may not be for you.
  • You need Inspector comments and footnotes (show up in the right-hand column) as opposed to inline annotations and footnotes (placed in the midst of the text itself). If you absolutely need Inspector comments or Inspector footnotes while drafting, this workflow may not be for you.
  • You use Scrivener styles. A lot. Every use of a Scrivener style is a friction point with Ulysses. If you can’t use Markdown instead, your use of styles is widespread, and you’re not willing to consider doing without some of this formatting, this workflow may not be for you.
  • You don’t want to learn or use Markdown and some features of MultiMarkdown. You will need to type Markdown formatting in by hand in Scrivener. If you don’t want to fuss with (Multi)Markdown, this workflow may not be for you.
What this guide won’t do:

I won’t give detailed directions for every single step—or this would be novel-length! Instead I’ll refer you to the Scrivener, Ulysses, or Markdown documentation.

Suggested Scrivener Work Habits when planning on using iOS Ulysses

All of these are habits that will either let your project compile smoothly with the “Convert MultiMarkdown to Rich Text” compile option on,1 make the round trip from Ulysses with less formatting loss, or both.

In general, avoid using non-Markdown formatting as much as practical. The less you have, the less you’ll need to reapply after you edit with Ulysses.

  • Learn Markdown, and how to use MultiMarkdown tables. Visit CommonMark if you don’t know any Markdown—their ten-minute interactive tutorial rocks. Read Fletcher Penney’s MultiMarkdown tables documentation. Scrivener will not help you with this. Ulysses will help with Markdown, but with MultiMarkdown tables, you’re on your own.
  • Get rid of any body or “normal” style. It will cause a lot of friction with Ulysses. (For why, see 1.1.1 below.) Most of your Scrivener work should be in unstyled text. For how to get rid of a body text style, see this post on the Scrivener forum: https://www.literatureandlatte.com/forum/viewtopic.php?p=316480#p316480
  • Change your default formatting (“no style”) in Scrivener to block paragraph style—no paragraph indent, and no spacing between paragraphs. Use an extra return to space paragraphs apart. (For why, see 2.1 below. The exceptions are Markdown lists, code blocks, and MMD tables.) To change your default formatting for current and future documents in your project, see this thread on the Scrivener forum: https://www.literatureandlatte.com/forum/viewtopic.php?f=2&t=62229
  • Don’t bother with making text italic or bold; use _surrounding underscores_ for italics and **surrounding double asterisks** for bold. Use Markdown links for any external link you need. Use Markdown image insertions. (For why, see 1.1.1 and 2.2 below)
  • Use Scrivener-style internal links. As these show up in Ulysses as plain text with no link evident, you may want to use an inline annotation to mark them as links.
  • Use Markdown lists and MultiMarkdown tables if you need any. (For why, see several items below.)
  • Use Scrivener inline annotations and footnotes if you need comments or footnotes. Avoid Inspector comments and Inspector footnotes.(For why, see 1.5 and 2.10 below.)
  • You may need a few styles for things like blockquotes, attributions, centred text, etc. I suggest using an inline annotation in each styled paragraph noting the name of the style.
  • If there are non-Markdown character attributes you need (highlighting, etc.), again you’ll have to use Scrivener styles. Using an inline annotation to tag each paragraph containing these will help you out later.
  • Make the styles you do use obvious in Scrivener. Figure that you’re going to need to reapply them occasionally. If you never use coloured text even for links, give your character attribute styles a text colour. If you never use highlighting in your final output, give them a background tint. You can deliberately strip those attributes in compile, but the colour or tint will show up in the automatic snapshots that Sync to External Folder takes. Thus, it will be easier to spot and reapply those styles. Even for pure paragraph styles, tagging styled text with an inline annotation will make life easier.

Conclusion

To sync your project with Ulysses smoothly, you’ll need to use Markdown and MultiMarkdown features within Scrivener text documents instead of many of the native Scrivener features. This way of working quickly becomes a habit, but it isn’t for everyone.

Appendix: What Happens in the Scrivener ↔︎ Ulysses round-trip—and in MMD→RTF compile

  1. Ulysses round trip effects:
    1. Any paragraph that you edit with Ulysses will
      1. Lose its formatting. Italics, bold, underline, and other character attributes will disappear from Scrivener. Indeed, any change from Scrivener’s default style (font, font size, alignment, etc.) will be erased.
      2. Lose Scrivener styles. Any style you truly need will have to be reapplied.
      3. Have Inspector comments and Inspector footnotes (linked notation) stripped out.
    2. Scrivener-style lists will show up as code blocks inside Ulysses, with only one level of indentation. If you edit them, your list formatting will be lost for the items you edit. (see above.)
    3. Scrivener-style tables will just show up in Ulysses as a series of paragraphs. Once again, the table’s formatting will be damaged if you edit its cells in Ulysses.
    4. Scrivener-style image insertions and external links are invisible inside Ulysses. If you edit their paragraphs, they disappear (see above).
    5. Scrivener ((inline annotations)) and {{inline footnotes}} do show up in double parentheses and double braces, respectively, in Ulysses. You can add new comments and new footnotes by enclosing comments in (()) and footnotes in {{}}.
    6. Scrivener internal links look like plain text. MMD-style internal links are ignored.
    7. MMD tables in Ulysses will look like plain text with some vertical bars thrown in, just as they do in Scrivener. You can edit them just the same as you would in Scrivener.
  2. MMD→RTF compile effects:
    When compiling a document in Scrivener with this option on, first the MMD→RTF translation is done, then styles (if any) are applied, and finally the compile layout formatting is done. In practical terms,

    1. Paragraphs separated by only one “enter” are compressed. You must type “Enter” twice between paragraphs in order for the Scrivener MMD processor to recognise them. The exceptions are Markdown lists, code blocks, and MMD tables.
    2. Non-Markdown character formatting is stripped. Underlines, highlighting, strike-through and more will vanish in the compile. If you absolutely need any of these in your output, you’ll need to use styles for them.
    3. “Inline” Markdown definitely comes through. Italics, bold, external links, and images all end up in the compiled output if they are designated in Markdown in the text.
    4. Markdown lists and MMD tables appear in the compiled output as well.
    5. Scrivener lists show up as a series of paragraphs with hand-bulleting or numbering. Indents are lost.
    6. Scrivener tables appear in the compiled output as a single massive collapsed paragraph. No “table-ness” survives.
    7. Markdown and MMD “blocks” in general do not pass through compile intact. They are wiped out by the section layouts unless they are styled. This includes both code blocks and blockquotes.
    8. On the other hand, code blocks surrounding Scrivener styles are absolutely essential to retaining things like intra-paragraph tabs during compile. Without code blocks, tabs don’t survive the MMD→RTF process long enough to be styled.
    9. Strangely enough, MMD-style footnotes have formatting problems.
    10. Scrivener-style external links disappear.
    11. Scrivener inline annotations and inline footnotes work just fine.
    12. Scrivener-style internal links compile just fine.
    13. Compile ignores Dividers (four hyphens).

  1. You can get by without using this compile option, but at the cost of having to do much more “fixing” of your edited files in Scrivener when you get them back from Ulysses. In my opinion, it’s not worth it. 

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.