I’m a big handwriting input fan. I wanted to like Scribble. I really, really did. I tested it with Scrivener and Ulysses, as well as Bear, Pages, Word, Notes, and Google Docs.
Folks, it is not ready for prime time.
Scribble’s fine for short text messages, data entry fields, and the like—text fields that don’t wrap. At least it’s no worse than hasty keyboarding. I’ve seen posts on the Scrivener forum that suggest it’s useful in pure editing mode. People find its ability to select by circling text a big help, and if you’re only substituting one word for another its quirks aren’t as challenging. But attempting to write a paragraph longer than one line drove me to screaming frustration, then back to WritePad in short order.
Scribble recognises handwriting well. It also recognises fast—too fast, and I can’t slow it down. So then I have a stray mark that may or may not be a letter, and may or may not be the beginning of a word I was trying to write. Convincing Scribble to erase any stray mark I accidentally make is an exercise in futility. I can’t erase a single letter, only an entire word. Undo in that case undoes too much—all the text I’d written since I started Scribbling. I can pop up the Scribble keyboard, but I find that I need it so often I just need to leave it open. If I’m going to do that why not just use a handwriting keyboard to begin with?
In order to use Scribble inside text that wraps, you need to have really tiny handwriting that will fit inside a normal line of text. If you stray, your writing will “scratch” over text you’ve already written in the previous line or the next, erasing it. I used the Undo button so much just trying it that I did more undoing than writing. Other possible solutions are zooming (not possible in Ulysses), enlarging the text, or triple-spacing lines, but the last two I’d need to revert later when I switched back to typing.
I could restrict myself to only adding text to the end of a document—but even that didn’t work for me. There was never enough space at the bottom for me to write without deleting, not even in Scrivener or Ulysses with typewriter mode turned on. (Yes, I have big handwriting. I don’t know how other people write so small as to be able to fit their signatures on the tiny spaces available on most forms.)
Recommendations:
While Scribble is fine for short text messages and data entry in online forms, I still recommend handwriting keyboard apps for significant text entry in editing and word processing apps. The keyboards avoid the space available problem simply by providing a dedicated data entry area. An added benefit is that they’re also usable on iPhone.
If you’re one of the folks who prefers to use a note-taking app, then copy-and-paste large batches of recognised handwriting, you can give Scribble a try, but I suspect you’ll prefer your current method of working.
My recommended handwriting keyboards, in order of my personal preference:
WritePad I (iPad) / Penquills (iPhone): Each takes time to set up to recognise your handwriting well, but I find the ability to remove mis-recognitions and typos before committing text to document to be a plus. (I prefer the “continuous handwriting” setup, in which I write over my previously recognised text to commit it to the document and start a new recognition, to the “recognition delay” setup, which is more like Scribble: The text is recognised and committed automatically after a configurable delay.)
Selvy PenScript: The current handwriting keyboard most like the late lamented “MyScript Stylus”. It’s my favourite of the “automatic entry” handwriting keyboards (i.e., your handwriting is recognised and automatically committed to the document after a brief delay, like Scribble, WritePad/Penquills with recognition delay enabled, and MyScript Stylus). The recognition delay is configurable (I prefer a slightly longer delay) and alternate recognitions are provided so you can correct mis-recognitions immediately with a single tap.
Mazec: It recognises English handwriting. However, it neither automatically commits your handwriting after delay (Scribble, Selvy PenScript) nor does it permit continuous writing by writing over the previously recognised text (WritePad, Penquills). No, you have to tap Enter after every recognition. It also recognises far fewer languages than either of the other two options. I suggest trying it only if neither of the first two options suits.
What is this obsession with block editors recently?
Everybody and their sibling is rolling out a block editor with great fanfare. They slice, they dice, they make julienne fries…
They deny the concept of plain text, nor do they use OS-level rich text support, so they’re slow. (Nimbus Note concedes the possibility of plain text, but puts it in a code block. Seriously.) They purport to be rich text but severely limit the options of rich text, which doesn’t seem to make them any faster. You can move blocks around by dragging, which… what? Saves you the step of selecting before dragging? And like any modern rich text system I’m familiar with, the formatting codes (Which are there behind the scenes. Believe me.) are hidden, making it difficult to control what formatting I want to use.
I’m sorry. Give me Markdown in whatever flavour instead.
What did they do—again? They completely re-wrote an app that was working fine and made it unusable, while losing features.
When did they do it before? Their handwriting note app, Penultimate, was re-written in 2014, rendering it almost unusable and losing some functionality permanently.
… And what have they done now? In October, they released completely rewritten versions of their primary Evernote client app for every supported platform (see Unlocking Evernote’s Future.)
iOS is unusable. It takes 20 minutes to display a (large) plain-text note. Mac is unusable. I can’t select more than 50 notes at a time (I have a database of 2200+ notes. No more than 50? Really?) The iOS version no longer has a widget. The iOS version also lost its Watch app. (Full disclosure: I don’t own an Apple Watch. But if I did, I’d be furious.)
If the history of Penultimate is any guide, the apps will actually be usable by about April 2021. But it may take longer. I can’t do without my writing research, my personal notes, my brain that long. And some functionality may never return.
Consider switching to this (or anything besides Evernote, really.)
So I’m moving on. Enter Nimbus Notes. It’s fast. It has many of (old) Evernote’s features. It’s half the annual subscription price. It can import notes from Evernote, if you export them in .enex format.
The problem is that exporting Evernote notes in .enex format only happens in the Mac/PC Evernote apps. And at 50 notes at a time, exporting would take forever (see above.)
So I uninstalled the New Broken Mac Evernote, and went back through my Time Machine backups (you do use Time Machine on your Mac, don’t you?) and restored Old Working Mac Evernote. I’ve exported my notes, and will be building my Nimbus Notes database today. Expect a Nimbus Notes review soon.
In Part 1 of this series, I talked about changing your Scrivener habits in order to edit with Ulysses, eventually. In Part 2, I talked about changing your existing project so that it compiles with the Scrivener “Convert MultiMarkdown to Rich Text” (MMD→Rich Text) compile option ON, and so that it syncs as smoothly as possible with Ulysses. In Part 3, I discussed setting up sync between Ulysses and Scrivener on either Dropbox or iCloud Drive, and best practices going forward. In Part 4, I discussed some simple methods to refer to your Scrivener metadata (or outline) while working in iOS Ulysses.
If you’re new to my articles on how to edit Scrivener projects with Ulysses, please review “Is this workflow for you?” in Part 1. I strongly recommend you make the changes to your existing Scrivener project that I suggested in Part 2 and set up sync as in Part 3 before proceeding.
Workflow with Aeon Timeline
An Aeon Timeline (AT) timeline that’s synced with your Scrivener project already has much of your Scrivener metadata in it. Further, you can both view and edit that metadata on your iOS device by opening your timeline in iOS Aeon Timeline (or on iPads, by putting AT in a split-screen with Ulysses or in a slide-over panel.) You’ll need to have AT installed on both your Mac and on iOS for this to work.
I don’t recommend this workflow if you don’t want to use AT for, well, a timeline. In order to sync your Mac Scrivener project with AT, you’ll need to actually build a timeline with at least relative dates for your texts (called events in AT). It’s a lot of effort if you don’t want to work with a timeline. In that case, you’ll be ahead by compiling your metadata to an outline document, as I described in Part 4. Besides, while AT is not expensive software (as such things go) it’s not free either, and you’ll need to buy both Mac and iOS licences for it.
So let’s assume that you already use AT and have a timeline for your Scrivener project set up and syncing. You are syncing title, synopsis, label, status, keywords, and timeline-specific custom metadata (start date, end date, location, and arc.) The only Scrivener metadata that’s in your project and not in your timeline are your Inspector document notes and maybe non-timeline custom metadata.1 How do you integrate your AT timeline with your Mac Scrivener—iOS Ulysses workflow?
The key to understanding this workflow is that AT syncing happens on the Mac. You can’t sync your Scrivener project with your AT timeline on iOS, even if you have both iOS Scrivener and iOS AT installed. The only way to get your changes from iOS AT into your Scrivener project (or vice-versa) is to open your timeline in Mac AT and sync with your Mac Scrivener project.
Be sure your AT timeline is available on iOS. If you’ve always used your timeline only on Mac, you’ll want to move it to a cloud service folder—your Dropbox folder, your iCloud drive, Google Drive—that you can access with the Files app on iOS.
Sync your project with your AT timeline. This happens on Mac, and your Scrivener project must be closed before you can sync it with your AT timeline. This is not a problem since you want your External Folder Sync to happen before you move to iOS anyway. Close your Scrivener project, which will execute External File Sync, then sync your project with your AT timeline as normal.
On iOS, open your timeline in iOS AT. Open Ulysses and start working on your draft. When you need to refer to your metadata (outline), switch to AT, or put AT in a split screen with Ulysses. If you want to edit your outline, go ahead and edit the metadata in iOS AT. You don’t need to do anything special to make your changes available on Mac. You can work on your timeline too, if you want.
When you return to your Mac, sync the changes to your AT timeline with Scrivener projectbeforeyou open your project in Scrivener. AT will write the changed metadata back to your project.
Finally, open your project in Mac. Your metadata changes are already in place. External File Sync will run, incorporating your changes from Ulysses.
That’s it! There’s no chance of sync conflicts between Ulysses and AT—Ulysses can only edit main text, it can’t change metadata. AT can’t edit main text, it can only affect metadata.
Enjoy!
If you still want to refer to those document notes as a compiled outline, as in Part 4, just modify your compile section layout to only include your title and your document notes. If you have custom metadata that’s not timeline data, you could include metadata if you like. What you won’t want is your synopsis—that’s in your AT timeline. ↩
In Part 1 of this series, I talked about changing your Scrivener habits in order to edit with Ulysses, eventually. In Part 2, I talked about changing your existing project so that it compiles with the Scrivener “Convert MultiMarkdown to Rich Text” (MMD→Rich Text) compile option ON, and so that it syncs as smoothly as possible with Ulysses. In Part 3, I discussed setting up sync between Ulysses and Scrivener on either Dropbox or iCloud Drive, and best practices going forward.
If you’re new to my articles on how to edit Scrivener projects with Ulysses, please review “Is this workflow for you?” in Part 1. I strongly recommend you make the changes to your existing Scrivener project that I suggested in Part 2 and set up sync as in Part 3 before proceeding.
If you need a review of Markdown, and of MultiMarkdown tables, you can find them here:
For this series, I’m assuming that you’re using Mac Scrivener to organise your work: You use the Corkboard, the Outliner, collections, keywords, labels, and and so forth to give you information about your project.
Metadata is defined as “data about data”; in this case, I’m referring to data both about each document, and about your project. Each document in Scrivener potentially has these metadata items:
A title
Created and modified dates
A label
A status
One or more keywords
A synopsis (plain text)
A corkboard image
An Inspector document note (rich text)
A section type
An “Include in Compile” flag
Document Bookmarks
Custom metadata
In addition, the entire project has:
Project Bookmarks (which refer to in-project notes as well as external references.)
As of this writing, even iOS Scrivener can access and edit only a subset of these:
Title
Label
Status
Synopsis (plain text)
Corkboard image
Inspector document note (rich text)
“Include in Compile” flag
So far, we’ve managed, in Part 3, to transfer the project notes to Ulysses (any text in the project that isn’t part of your draft.) Let’s see about the others.
Referring to Your Outline
You can do better than iOS Scrivener does here, as long as you don’t need to edit your outline on iOS. (But we’re assuming that you want to organise in Mac Scrivener, so this should work fine.)
For our purposes, the “outline” means most of the metadata you can view in your Mac outliner view (title, synopsis, label, status, keywords, custom metadata) plus your Inspector document notes. Sorry, but corkboard images, section type, document bookmarks, and the “Include in Compile” flag won’t make it over. To begin:
Use File→Compile… The compile dialog will open.
Set up a compile of your entire draft. If you don’t want some of your Draft outlined (for example, I outline only to the Chapter level, not to individual scenes), set up a collection that contains only your outline documents and filter your draft to include them only.
Pick a format from the Compile for: list. I’d suggest either Multimarkdown (poorer formatting but you can view the outline directly in Ulysses) or PDF (better formatting for document notes, but you must view it split-screen (iPad) or separately (iPhone) in your favourite iOS PDF app.)
Select your compile format (Markdown Outline for Multimarkdown, Full Indented Outline for PDF.)
Assign your Section Layouts. Choose the same “outline item” layout for all your section types. (e.g., all Decimal Outline Item or all Bulleted Outline Item, or some other item type depending on what’s offered in the compile format you picked.)
If we only wanted titles and synopses, we’d be done and could compile now. But to include the rest of our metadata, we must edit the section layout we picked.
Click on the pencil icon in the preview of the section layout.
Click “Duplicate and Edit Format” in the alert box that appears. This will take you to the Compile Format Designer.
In the Compile Format Designer dialog, check all the checkboxes except “Text” for your selected layout (its name will be in bold.) This will get all your metadata (title, synopsis, created and modified dates, label, status, keywords, and any custom metadata) as well as your Inspector document notes compiled into your outline document.
Click “Save” to save changes and return to the main compile dialog.
Click “Compile” to compile your outline.
When your compile is finished, you’ll see a standard Mac save file dialog. Name your outline file, and save it to your chosen cloud service, outside your project sync folder.
If you produced a Markdown outline, open iOS Ulysses and add it to your external files. Don’t add it to one of your project external folders!
If you produced a PDF, open your iOS PDF app and open the outline with it.
N.B.: You may find that the full outline document is pretty hefty (my current work-in-progress has an outline of 8,000 words, including all synopses, document notes, and metadata.) Further, if you compiled to a Markdown outline and imported it to Ulysses, Ulysses will (helpfully, it thinks) put the whole thing into a code block (because Markdown code blocks can be made by indenting with a tab at the start of every line, rather like an outline.) Ulysses then becomes pretty darn slow. To speed it up, put your cursor below the code block, and tap your delete (or backspace) key once. The entire code block should be selected. Tap the delete/backspace key again, and Ulysses will (slowly) remove the code block tag so that your outline becomes a normal Markdown indented list. Be patient: it took about five minutes for that 8,000 word outline. After this, Ulysses will be much speedier.
Editing Your Outline
It’s easy to say that you should wait on metadata changes until you’re back at your Mac and use Scrivener. But if you’re like me, you won’t remember your changes that long. If this is the case, I suggest you put Yet Another Inline Annotation™ at the top of your text in Ulysses (just surround it with double parentheses ((like this)) .) Date it, and note the changes you want to make to your metadata. When you sync with Scrivener and check your updated documents, you should see your annotation so that you can make the needed changes to your Scrivener metadata. After that you can delete the annotation if you like.
Dealing with Bookmarks
Bookmarks… just don’t transfer well to iOS. Not even iOS Scrivener will give you access to them. But if you must have some of them available, here’s some strategies. All of them require some effort on your part, and some may require maintaining two lists, one for Mac Scrivener and one for iOS Ulysses. You’ve been warned.
If a bookmark refers to a document on your Mac only, there’s nothing to be done. There’s no way to access that while in Ulysses or on iOS in general. All you can do is move it to the Web or a cloud service so you can access it as in Step 2, below.
If a bookmark refers to a document on the Web or on a cloud service that you have access to (your website, iCloud, Dropbox, Evernote, etc.), you can put a link to it in a text document within your Notes. If you choose to do this, I’d suggest taking these out of your project or document bookmarks—having to maintain the list in two places risks forgetting to update one or the other.
If a bookmark refers to a text document inside your project and it’s synced to Ulysses, you can add it to Ulysses’ Favourites list. This will require maintaining both the Mac Scrivener bookmarks and the Ulysses Favourites list, with the risk of updating one but not the other. Or you may choose to move the document to the Web or a cloud service and follow Step 2 above.
If a bookmark refers to a non-text document inside your project (web archive, image, PDF, etc.) again there’s nothing to be done other than export it to the web or a cloud service and add it to your list in Step 2.
My own strategy has been to keep all my non-text research in a cloud note service (Evernote, but OneNote might serve as well.) Rather than building bookmark lists, I use the Evernote app on Mac and on iOS to refer to it. This way I avoid the whole issue. (Some Scrivener users whose research use is heavier than mine use DEVONthink and its iOS companion app. I haven’t tried it so I can’t say how well it works, but many academics swear by it.)
UPDATE 2020-10-28: “Convert Multimarkdown to Rich Text” Bug alert:
In Mac Scrivener 3.1.5 and earlier, conversion to rich text can fail if there is no paragraph break at the end of a text file. If you have files in which some or all MMD is not being converted in compile though other files convert normally, see if adding a paragraph break at the end of the file fixes it.
Literature and Latte have acknowledged this bug, and it will be fixed in version 3.1.6 and subsequent versions.
Addendum (Part 3.5): Finding Compile
It struck me that in all this time, I haven’t discussed actually compiling with the “Convert Multimarkdown to Rich Text” option on—where to find it, what to do with it, etc. Okay, then, when you first use File→Compile in Scrivener, here’s how you turn on that option:
Choose any “Compile for:” target except a target that says “Multimarkdown,” Those are part of a different workflow that compiles to an intermediate format. You’re going to compile directly to your intended final output format.
In the right-hand sidebar, click on the gear icon to bring up the Compile Options panel.
Turn the “Convert Multimarkdown to Rich Text in Notes and Text” option ON.
Choose a compile format from the left hand column.
That’s it! Scrivener will now take your Multimarkdown and convert it to rich text before compiling to your chosen target.
Optional settings:
Remove Annotations: Turn this on to make sure your inline annotation “tags” don’t show up in your compiled output.
“Convert Markdown to rich text in titles and synopses”: This is a bit misleading. It only really converts *italics* and **bold.** But if you use these in your titles (and in your synopses if you’re including them in your compile) you can convert them on compile with this.
I’m not going to cover more detail of how to compile. You can find compile help in Scrivener’s Interactive Tutorial (Help→Interactive Tutorial…) and a complete reference in the Scrivener Manual (Chapter 23, “Compiling the Draft” and Chapter 24 “The Compile Format Designer”). But I will say that if you’re new to Scrivener’s compiler, give yourself plenty of time to learn it! Compile is almost a whole second application. On the Scrivener forums, I often see posts from desperate writers who left learning the compiler until two hours before a hard deadline. Such posts usually end in tears.
Don’t be that writer. Take time to learn to compile.
In Part 1 of this series, I talked about changing your Scrivener habits in order to edit with Ulysses, eventually. In Part 2, I talked about changing your existing project so that it compiles with the Scrivener “Convert MultiMarkdown to Rich Text” (MMD→Rich Text) compile option ON, and so that it syncs as smoothly as possible with Ulysses.
If you’re new to my articles on how to edit Scrivener projects with Ulysses, please review “Is this workflow for you?” in Part 1. I strongly recommend you make the changes to your existing Scrivener project that I suggested in Part 2 before proceeding.
If you need a review of Markdown, and of MultiMarkdown tables, you can find them here:
The good news is that this process is completely independent of whether you choose iCloud Drive or Dropbox for your sync location. Use whichever you like; I won’t distinguish between them in the rest of this article. However, as of this writing, there are only two other cloud services that I know will work: Working Copy or Secure ShellFish. Ulysses may add another, but hasn’t done so yet.1 You don’t need to have Dropbox installed on your iOS device or devices, however, so that if you’re using a free Dropbox account, your iOS devices won’t count against your three-device limit.
Preparing Your Laptop or Desktop Computer
Dropbox Prep: You must have Dropbox installed on your Mac, so that you have a Dropbox folder available on your hard drive or SSD.
iCloud Drive Prep: None needed, really, other than turning iCloud Drive on in your System Preferences.
Create a Sync Folder for Your Project
We’re going to use Scrivener’s “External Folder Sync” feature to set up sync with Ulysses. The initial setup must be done on the Mac, and mostly from your Scrivener project. External folder sync is a project-based feature, so you’ll need to set up sync separately for each project you want to edit with Ulysses.
If you’ve never used External Folder Sync before, please review Section 14.3, “Synchronised Folders”, in the Scrivener Manual.
In Finder, somewhere inside your chosen cloud service’s folder, create a new folder with the name of your project (hereinafter referred to as “MyProject_Sync”.) I’m not going to tell you how to organise your cloud service’s folder—create inside the cloud folder wherever it makes sense to you.
From this point onward, we’ll be working in Scrivener with the project you want to sync open. First, let’s set up our export options to work with Ulysses. Use the menu item Scrivener→Preferences… and move to the “Sharing” panel. In the “Sync” tab, turn on the option “Convert text inside (()) and {{}} to inline notes when using plain text.” Turn this on, because it will let us use Scrivener’s inline annotations and footnotes as we discussed in Part 1 and in Part 2. The panel should look like this:
In Scrivener, choose the menu item File→Sync→With External Folder… . You’ll see this dialog:
Let’s take each option and see how best to use it with Ulysses.
“Sync files in this project with external folder:” – Click the “Choose…” button here, and you’ll get the standard Mac Open File dialog. Navigate to the folder MyProject_Sync you created in step 1 above, and with that folder selected, click the “Open” button. You should see the path to your folder appear in the text box.
“Sync the contents of the Draft folder” – This is your work-in-progress. Turn this ON.
“Sync all other text documents in the project” – This would be all your notes that are in text documents, your front matter, and your back matter. If you’d like to be able to review these files in Ulysses, turn this ON, otherwise leave it OFF.
“Sync only documents in collection:” – This is how you limit what gets synced. If, for example, you want your notes in Ulysses but don’t want your front and back matter, set up a collection (See Section 10.2, “Using Collections”, in the Scrivener manual) that contains all your Draft documents and only the Notes documents that you want to be able to see in Ulysses.2 Choose that collection from the dropdown menu and turn this option ON. Otherwise, leave it OFF and everything gets synced. You can always change this later if you change your mind.3
“Prefix file names with numbers” – this is up to you. If you turn this on, there will be a number (representing Scrivener Binder order) at the front of each file name when you look at it in Ulysses. By then setting Ulysses to sort by file name, you can see all your documents in their Scrivener Binder order. I find this very useful indeed, and always keep this option on, but decide for yourself. You can always change your mind on this.
“Take snapshots of affected documents before updating” – I strongly suggest leaving this ON. This Scrivener option is what will let you quickly recover from any accidental formatting loss from Ulysses. Once a week, I use the Documents→Snapshots→Show Snapshots Manager dialog to clean up automatic snapshots I no longer need. Learn more in the Scrivener manual, section 15.8, “Using Snapshots.”
“Check external folder on project open and automatically sync on close” – I recommend leaving this ON. This is where the automation happens on the Scrivener side of things. You’ll need to remember to close your project when you switch to Ulysses for the day, or whenever. If this just isn’t going to happen for you, there’s a setting for that – in Scrivener→Preferences, “General” panel, “Automatic Quit” in the sidebar. Choose an auto quit interval that’s not so short that it will annoy you but not so long that you’ll be typing away in Ulysses before it happens.
“Import new non-Draft items into” – This needs a bit of explanation. (If you’re not syncing your notes and such, this won’t apply to you.) Any new document you create in Ulysses that you put into the Draft folder in Ulysses will show up at the bottom of the Draft (or Manuscript) folder in Scrivener, and you’ll need to sort it into your project structure. But if you do sync notes, this lets you choose which folder any new note you make will appear in Scrivener. The Research folder is a good option.4
“Format for external Draft files” and “Format for other external files” – Ulysses can’t read Scrivener “.rtf” files any more than Scrivener can read Ulysses’ native format (“.ulyz”). The format that both can read and write is “Plain Text” with extension “md”. Set this up here.
“Automatically convert plain text paragraph spacing” – Turn this OFF.5
Re-check your settings, then click the “Sync” button. Scrivener will write out Markdown files for all the documents you included in sync. They’ll appear in two new folders, “Draft” and “Notes”, that Scrivener creates inside the folder you created in Step 3.1 above. If you’ve decided to sync a lot of files, this may take a while the first time.
Close your Scrivener project! We’re moving to Ulysses at last!
Connect iOS Ulysses to Your Sync Folder
For each iOS device you’d like to use with your new Scrivener sync folder, you’ll need to set up Ulysses to use Ulysses’ own External Folder feature. (It’s unfortunate that it uses a similar name to the Scrivener feature, because it’s really quite different.) If you’ve never used Ulysses’ External Folder capability before, I suggest you review its tutorial on the Ulysses website.
Tap the gear icon in your Ulysses library panel.
In the Settings popover, tap the Library item.
Connect Ulysses to the sync folder:
If you’re using iCloud Drive or some other non-Dropbox cloud service:
Tap on the “Add from Other Location…” item. You’ll be taken to the Apple Files app interface.
Navigate to the folder you created in Step 3.1 above. You’ll see the new Draft and Notes folders inside, but be sure the top level folder “MyProject_Sync is selected.
Tap “Done” in the upper-right corner. You’ll be taken to the folder settings panel.
If you’re using Dropbox:
Tap the “Add from Dropbox…” item.
If you haven’t connected Dropbox to Ulysses before, sign in to the Dropbox account that you saved your sync folder to.
Navigate to the folder you created in Step 3.1 above.
Tap the “MyProject_Sync” item at the bottom of the panel. You’ll be taken to the folder settings panel.
In the folder settings panel:
Change the icon if you like.
Sort by title if you like (to take advantage of your Binder order numbers.)
Set “Read and Write Markdown Files” to ON.
Set the “Default File Extension” to “.md” to match what you told Scrivener.
Turn “Create Reference Links” on if you like (I don’t, but it’s a matter of personal preference. Review CommonMark if you don’t remember the difference.)
Turn “Always use Fenced Code Blocks” ON. This will make using code blocks to mark off styled text in Scrivener much easier.
Repeat the above for every iOS device you want to use to edit your Scrivener projects, and for each Scrivener project you want to edit.
There you are! When you want to work on iOS Ulysses, close your project on your Mac, or use the menu item File→Sync→With External Folder Now. (You can put this in Scrivener’s toolbar if you like.) When you want to incorporate your changes from Ulysses, open the project on your Mac or again use File→Sync→With External Folder Now.
A Warning About Document Titles/File Names
Are you letting Scrivener automatically name some of your files? Scrivener External Folder Sync produces long, long filenames in that case, like this: “068 I opened the sitting room drapes and settled myself into my own armchair. I... [85].md”
That final “[85]” is Scrivener’s internal file ID and without it, your changes won’t get synced back to your original file. Instead, you’ll find a new document with your changes.
The problem is that Ulysses can’t handle such a long filename, and will truncate it to something like: “068 I opened the sitting room drapes and settled myself into my own ar.md” It loses Scrivener’s file ID (“[85]”) and thus confuses Scrivener on the return trip.
My workaround is to edit the filename myself, to “068 [85]” (in the first line in the Ulysses sheet) before editing anything else in the file. Scrivener is perfectly happy with that, and my changes are synced normally. Another solution would be to name all your files yourself in Scrivener with somewhat shorter names.
If you accidentally have a file ID truncated, all is not lost. You’ll find the “new” document at the bottom of the Draft folder in your Binder. You’ll be able to tell that it’s not connected to the original when you’re doing your “return from sync” check because you won’t see any snapshots in the Inspector for it. Take a deep breath, and find the original in its place in the Binder. Now, you’ll do manually what External Folder sync would have done:
Make a snapshot of your original (“Real_File” in this example), naming the snapshot whatever you like. (“Lost_ID” for this example.)
Open the new version from Ulysses (“Duped_File” in this example), select all its text, and copy to the clipboard.
Return to Real_File, select all its text, and paste in the text from Duped_File.
Compare the text you just pasted to the Lost_ID snapshot, restoring formatting if you need to.
Move Duped_File to the Trash, and then delete it from the Trash (so you won’t get confused in future). You don’t need it any more; you’ve incorporated your changes into the original and have a snapshot of that original before changes.
Best Practices
Avoid using Scrivener features for things that Markdown and Multimarkdown plus MMD→Rich Text compile can do. Lists, tables, images, external links, italics, and bold text are best done with Markdown features rather than with Scrivener.
Remember to mark paragraphs containing Scrivener styled text, Scrivener internal links, or Scrivener-inserted graphics when you add them in Scrivener.
Avoid editing paragraphs containing Scrivener styled text, Scrivener internal links, or Scrivener inserted graphics with Ulysses.
If you can’t remember to close your projects so that Scrivener writes out changes (or use the File→Sync→With External Folder Now command), use the Scrivener→Preferences→General “Automatic Quit” option.
When you return to Scrivener after editing with Ulysses and External Folder Sync gets run, you’ll be shown an Updated Documents list in the Binder area. I suggest checking each document against its most recent snapshot in the Inspector, to spot any formatting, image, or link loss and correct it quickly before you forget! (Read more in the Scrivener manual about using snapshots in section 15.8.) This seldom takes long and is good insurance.
To keep project size and backup time lower, once a week use Documents→Snapshot→Show Snapshot Manager in Scrivener, after you’ve checked your most recent Ulysses updates. Delete older “Pre-Sync External File Version” and “Pre-External File Sync Overwrite” snapshots. Your own caution and experience will be your best guide as to how to balance project size, sync speed, and safety.
Be aware of your Ulysses filename length. If a filename ends in “…” before the ID number in brackets, edit the filename in Ulysses to contain only the ID in brackets and the front Binder order number (if you’re using it). This will prevent the file from getting disconnected from its Scrivener original.
You could as easily be using Scrivener for Windows, and this workflow would still work on the iOS side. I’m not addressing this for two reasons: First, I don’t have a Windows device so I can’t address Windows-specific Scrivener procedures. Second, using Ulysses on iOS has its own limitations (not unlike iOS Scrivener.) There are certain preferences that can only be changed in Mac Ulysses—and Ulysses does not have a Windows version, nor is it likely to in future. All my directions will assume that you are using Mac Scrivener. ↩
I use a saved search for this. I added a keyword, “SYNC”, to the files I’d like to have in Ulysses, searched for that keyword in Project Search, then at the very bottom of the project search context menu, saved the search as a collection. I don’t have to adjust the collection, just add the keyword to each new file as it comes back to Scrivener. There are many other ways to set up project searches that may work well for you. Read more detail in the Scrivener manual, section 10.2.4 “Saved Search Result Collections” and section 11.1, “Project Search.” ↩
Perhaps this is a good place to talk about Scrivener folders. You might be tempted to eliminate your folders from the files you’ll be syncing – there’s no text in them, right?
Well, not necessarily. I often put notes into my folders – they’re just specially tagged text files in Scrivener, after all. Some people put things like chapter introductions or epigrams into them. More than that, though, they’re “markers” – even though they don’t show up as indented in Ulysses, I can use them to show me where I am in my document structure. This is one of those things that’s up to you. Me, though, I sync all mine, even if they’re empty. ↩
If you’d like to have new Draft files show up in an “Inbox” folder instead of at the bottom of the Draft folder, you can do that. Set up a new top-level folder in Scrivener called “Inbox”, outside the Draft folder. Point this setting to that folder. Then, when you create a new Draft “sheet” in Ulysses, move it in Ulysses to the Notes folder (or create it there in the first place.) On return sync, Scrivener will take those new files, put them in the Inbox folder you’ve set up (along with any new Notes files), and from there you can sort them back into your project structure where they belong, be they draft or notes.
If you use this option, do use a regular collection to limit your sync rather than a saved search. Scrivener will automatically add new files to the collection. ↩
This would convert single enter characters to double enters on outgoing sync, and reduce double enters to single on incoming sync. You’ve already done this because Scrivener MMD→Rich Text compile requires it. Turning this on will mess up your documents’ appearance in Ulysses and make it harder to edit in Ulysses and have the results compile in Scrivener. OFF.↩
In Part 1 of this series, I talked about changing your Scrivener habits in order to edit with Ulysses, eventually. In Part 2, I’m going to talk about changing your existing project so that it compiles with the Scrivener “Convert MultiMarkdown to Rich Text” option ON, and so that it syncs as smoothly as possible with Ulysses. Believe me, you want to do as much as possible of this work before you start syncing and editing with Ulysses. If you’re new to my articles on how to edit Scrivener projects with Ulysses, please review “Is this workflow for you?” in Part 1. You’re about to make some significant changes to your existing project, and I wouldn’t want you to put in a few hours of work on it and then blame me if you don’t like the result… If you’re not sure, I suggest you start with a new project making the changes to the base preferences I suggest in Part 1, and then skipping ahead to Part 3. Or, you could make a fresh copy of the Scrivener Tutorial Project (in Scrivener, use the menu item Help→Interactive Tutorial to make a new one.) and follow along here in Part 2 without touching your work-in-progress (WIP) until you’re sure you understand the needed changes. But if you’re brave and reasonably certain, I’ll provide directions so that you’ll be able to revert your entire WIP (if needed) or any part of it. Just as a reminder, you’ll need to type Markdown and MultiMarkdown directly into Scrivener. If you need to, you can review them here:
First, use the menu command File→Back Up→Back Up To… to make a backup of the project you’re converting. (From now on I’ll refer to that project as your WIP, even though it may be a copy of the Tutorial.) Be sure to tick the “Back up as ZIP file” checkbox underneath the file list to make the backup a compressed archive! Save the backup somewhere other than your usual backup folder, so that you can find it easily (I suggest the Desktop.) With that backup tucked away as insurance, let’s make named snapshots of all your WIP’s files and folders.
Select all the top-level folders in your Binder.
Use the menu command View→Outline→Expand All to show everything in your Binder.
Use ⌘-A or Edit→Select All so that all the documents in your Binder are selected.
Use Documents→Snapshots→Take Titled Snapshots of Selected Documents.
Give the snapshots a name, like “Before Ulysses Conversion” or whatever else takes your fancy, and click OK. (Any document that isn’t text, or is empty, will be ignored.) It may take a while, if your WIP is large. Get a fresh cup of your caffeinated beverage of choice.
Now you can not only revert any individual document to its “before Ulysses” state, you’ll be able to see what it looked like before you started, so you can check your progress. Finally, before we start the changes, I suggest you turn on View→Text Editing→Show Invisibles. Some of what we must do involves changing the number of spaces, tabs, and returns in your text. It helps to be able to see them.
Convert Inspector Comments and Inspector Footnotes
This one’s easy, and easy to reverse as well.
In the Binder, select all the text documents that you think you might ever compile.
Put the editor into Scrivenings view. It may take a few seconds to load if your project is large.
After the view loads, put your cursor somewhere in the editor.
Display the Inspector, showing the Comments and Footnotes tab.
Nothing there? You’re done. Move on to Update Paragraphs, below.
If you have some, ask yourself this question: Will I ever need to have these in the Inspector again?
If your answer is yes, scan through your comments and footnotes.
If any comment or footnote has more than one paragraph, remove the paragraph breaks. (I like to put in a bullet so that I can easily restore the paragraphs after I return the comments to the Inspector.)
After you’re done, put your cursor somewhere in the editor again.
Use the menu command Edit→Transformations→Convert Inspector Comments to Inline Annotations.
Use the menu command Edit→Transformations→Convert Inspector Footnotes to Inline Footnotes.
If later you need to put your comments and footnotes back into the Inspector, use a similar process but instead use Edit→Transformations→Convert Inline Annotations to Inspector Comments and Edit→Transformations→Convert Inline Footnotes to Inspector Footnotes. It’s easiest if you restore paragraphs after you’ve transformed the comments and footnotes back to the Inspector.
Update Paragraphs
First, if you haven’t already, follow the directions I referenced in Part 1 for removing any “body style” or “normal style” from your project, and the directions for changing your default paragraph style to block style throughout your project. Here are the links again:
At this point you’re probably cursing me: “Darn you, Dragon, now I couldn’t find where my paragraphs begin and end if I didn’t have ‘Show Invisibles’ on!” This next step is where you fix that.
Once again, in the Binder, select all the text documents that you think you might ever compile.
Somewhere in the Scrivenings view, select the ¶ symbol at the end of a paragraph and copy it.
Now choose Edit→Find→Project Replace… and paste the ¶ symbol once into the Find box and twice into the Replace box. It should look like this:
Click “Replace.” In the “Project Replace Cannot Be Undone” alert, click OK.
From now on, you’ll need to press “enter” twice after each paragraph. This paragraph formatting will make it obvious if you don’t! It quickly becomes habit.
Quality Point: Line Breaks
Do you ever use line breaks within a paragraph? (They show up as “↩︎” when you have Show Invisibles on.) If you do, you’ll need to change each one to two spaces plus a new paragraph (“・・¶” when Show Invisibles is on.) Use the technique of copying and pasting into the Project Replace dialog above to change all these now.
Update Bold and Italic Text
This isn’t hard, but it is tedious if you have a lot of these. (If you use a keyboard macro utility, you can automate this. I’ll give keystrokes so that you can do that easily, but as I don’t use such a utility myself, I can’t tell you how to set it up.)
Change Scrivener preferences to use underscores as italics markers. Open Scrivener→Preferences…, and in the Sharing panel under the Export tab, uncheck “Convert underscores to underlines when converting Markdown”. It should look like this:
You should already have your “compilable” documents selected from above. If not, please select them and place your cursor at the beginning of the Scrivenings view.
Use the menu command Edit→Find→Find by Formatting… (Keystroke: control-option-command-F “⌃⌥⌘F”)
Set up to search for italics. It should look like this:
Go ahead and click “Find.”
Repeat the following steps until you’ve processed them all:
Move to the beginning of the selection. (Keystroke: left arrow key “←”)
Type an underscore. (Keystroke: shift-hyphen “⇧-“)
Select the italics again. (Keystroke: shift-option-command-G “⇧⌥⌘G”)
Move to the end of the selection. (Keystroke: right arrow key “→”)
Type another underscore. (Keystroke: shift-hyphen “⇧-“)
Select the next italics in the Scrivenings view. (Keystroke: shift-option-command-G “⇧⌥⌘G”)
Start over from step 2, but this time search for bold, and type two asterisks “**” instead of a single underscore.
Some folks use a style for italics and bold. Life with Ulysses will be much simpler if you don’t. To de-style your italics and bold, just delete the styles you used for them from the Styles list (Format→Style→Delete Style and choose your italics or bold style from the menu.) The text will still be formatted (though again, life with Ulysses will be simpler if you don’t bother in future and use underscores and double asterisks instead.)
Convert Tables
A word about Scrivener tables in general: In my opinion, Scrivener’s tables are the most problematic feature of its editor. Users on the Scrivener forums who live and die by tables (many are scientific writers) often don’t bother; they create their tables in a spreadsheet app, format them there, and paste the result into Scrivener, more as a placeholder than anything. Then, after compiling to DOCX or some other intermediate format, they do a final polish of the table formatting. They may even go back to their spreadsheets and re-paste the tables at that point. If you use that philosophy, then MMD tables are just another kind of placeholder, and you can use my conversion process to produce them almost straight from your spreadsheets. If, on the other hand, you’ve always used Scrivener tables directly, I’m going to suggest you use a spreadsheet app as an intermediate step to convert your Scrivener tables to MMD tables. (You can produce them by hand, as you will lists later, but it’s going to be a slower and more error-prone process.) Here’s my process:
You should already have your “compilable” documents selected from above. If not, please select them and place your cursor at the beginning of the Scrivenings view.
Once again, open the Edit→Find→Find by Formatting… dialog. This time, we’ll choose “Tables” from the dropdown menu, like this:
Click Find, and at your first table, open the Inspector to the Snapshots panel. Find the original table in the snapshot (which won’t have the extra “enters” we put in!)
Select the entire table in the snapshot and copy it to the Clipboard.
Open your favourite spreadsheet application. (If you don’t have one, Apple’s Numbers is free on the App Store.)
Create a new spreadsheet and paste in your table. Save the spreadsheet if you like.
Now select what you just pasted, and copy it (the spreadsheet app will have added important information, like row and column numbers, that you can’t see.)
Go to the Tables Generator site. Use its “File” dropdown and select “Paste Table Data…” Do so and click “Load.” Then click the “Generate” button beneath your pasted-in data.
That’s it! You’ll see a MultiMarkdown version of your table. Click the green “Copy to Clipboard” button.
Back in your main editor pane, select the table and the empty line after it as well.
Use the Format→Table→Remove Table menu command.
Paste the MultiMarkdown table over the remains of your old table.
The output from the tables generator site is basic. Add such things as alignment tags and merged cells if needed.
Repeat steps 3-13 until you’ve converted all your tables.
Convert Links
External links
Once again, we’ll use Find→Find by Formatting…, this time searching for “Web/File Link”. The dialog will look like this: Click “Next”, then for each link you find:
Put square brackets around the link, and an empty pair of parentheses after it, like this: [Google it!]()
Right-click or control-click on the link, and select “Copy Link”
Paste the link into the parentheses. Your link should now look like: [Google it!](https://google.com)
You can right-click on the link again (“Google it!” in my example) and select “Remove link” if you like.
If you prefer reference-style links, that’s fine! But don’t set them up now. When we start syncing and editing with Ulysses, we’ll configure it to use reference links if you prefer, and these will be converted.
Internal links
Repeat the process for external links above, but this time search for “Document Link”. For each document link you find, insert an inline annotation (shift-command-A) at the beginning. It should look like this: Use whatever tag you like. (If it’s an obvious link like a table of contents link, you can skip this, but remember that without some sort of clue, you won’t be able to tell the difference between internal links and plain text in Ulysses.)
Convert Lists
Sadly, we can’t search for lists with the “Find by Formatting” command. Instead, we’ll search for tab characters. This may find a few things that aren’t lists. We’ll just skip them.
You should already have your “compilable” documents selected from above. If not, please select them and place your cursor at the beginning of the Scrivenings view.
Open the Edit→Find→Find… dialog. In the Find box, hold down the option key and type the tab key. You should see a blue right-arow “→” in the Find field.
Click “Next” until you find a list. It should look something like this:
◆ Foobar
⁃ Foo
⁃ Bar
◆ Foobat
⁃ Foo
⁃ Bat
Select the entire list and choose Format→Lists→None. The bullets or numbering will disappear.
Remove the blank lines between items.
Open your Inspector pane to the Snapshots panel and find the list to use as a guide. Using Markdown list syntax, recreate the list in the main editor as closely as you can, using hyphens instead of bullets, and simple numbers followed by periods for enumerated items.
Repeat steps 3-6 until you’ve converted all your lists.
Convert Images
Embedded images, images linked to image files within your project, and images that Scrivener linked to files outside your project—all are invisible in Ulysses, and can be accidentally deleted from your text simply by using Ulysses to edit the paragraph they’re in, like internal links. (You’ll have the means to fix this, never fear, but why deal with it if you don’t have to?) I’ll give you options so that Ulysses won’t touch your images.
Once again, use Edit→Find→Find By Formatting… while you’re viewing a Scrivenings session of your compilable documents. This time, search for images.
For each image you find:
Option 1: Put an inline annotation tag in front of it, just as you did for internal links. If you are willing to reinsert images from your snapshots if you accidentally edit their paragraphs with Ulysses, this is by far the fastest option.
Option 2: Create a Markdown image insertion for the image. This is much safer than Option 1. Ulysses will never mess with your image insertion unless you deliberately delete it.
Right- or control-click on the image in Scrivener. If the popup menu has the item Save As Picture… in it, it’s an embedded image. Use the menu item and save the image to your hard drive, outside of any cloud drive. Do not save it to either Google Drive or iCloud Drive! The compiler will not be able to load it from there. — Or — If the popup menu has the item Reveal In Binder in it, it’s linked to an image that’s in the research area of your project. Go ahead and select Reveal In Binder, click on its revealed filename in the Binder, and use File→Export→Files… to save it as you would an embedded image, above. — Or — If the popup menu has the item Reveal In Finder, it’s an image already linked to an external image file and you need not save it.
Navigate to the image in the Finder. Use the Reveal in Finder item in the popup menu, or navigate to where you just saved the image.
Right- or control-click on the image in Finder.
Hold down the option key. You should see an item in the popup menu that says, Copy “myimage.jpg” as Pathname.
Continue to hold down the option key and select that menu item.
Return to Scrivener. Delete the image, and type the Markdown syntax for an image insertion. Inside the parentheses, type “file://” and then paste your pathname from step 5. Your final image insertion should look something like 
Styled Text Cleanup
I’ve already suggested that you not style most of your text. Every time you edit a paragraph containing styles with Ulysses, you’ll need to reapply the formatting when you return to Scrivener if you want to retain it for compile. Do think critically about the styling you really need—Can you style this at compile time rather than in the text? Would it be easier to adjust the styling after compile? Do you really need both underlining and italics? Limit your styles to what you do need (I find I need blockquotes, attributions, and small caps occasionally in body text, and a few more styles in front and end matter—title pages, tables of contents, acknowledgments and the like.) Delete the others. Then follow these steps for each of the remaining styles:
You should already have your “compilable” documents selected from above. If not, please select them and place your cursor at the beginning of the Scrivenings view.
Once again, open the Edit→Find→Find by Formatting… dialog. This time, we’ll choose “Style” from the dropdown menu. For each style you have,
Search for text with the style.
Put an inline annotation with the name of the style at the beginning of each paragraph that contains the style.
Odds and Ends
If you have styles that include tabbed text, put them inside fenced code blocks, like this:1
```MyStyleName
§This style uses columns separated
§by tabs. These are sometimes useful
§for things like manuscript headers in
§very old- fashioned submission
§guidelines
```
The problem is not that Ulysses will strip the style—of course it will, if you edit the paragraphs with Ulysses. No, it’s Scrivener’s MMD→RTF conversion that will strip out the tabs before compile. I’ve used section markers to show the lines that are styled. You must have an unstyled empty line before the closing fence.
I’ve given methods that don’t require any adjustment to the standard built-in compile formats. If you’re willing to edit compile formats, you can do all sorts of things—and you probably will. Some of the things I’ve set up:
Using Markdown tags to tag styles instead of inline annotations.
Colour-coding Scrivener styles to match colours I’ve set up in Ulysses for things like block quotes, header styles, and centred text.
Colouring text inside inline annotations in Ulysses to match the annotation colour in Scrivener.
If there’s any interest, I may do a blog post on this sort of advanced cross-formatting.
Image storage for Markdown: Using your own hard drive for image storage works perfectly well and will save you from slips of the keyboard. If you’d like to see your images while editing in iOS Ulysses (at least in preview mode) I’ve found you can store them two places:
On a website you control. Even a WordPress.com blog will do. Upload the images and use their URLs from your website in your image references.
On Dropbox. (NOT iCloud Drive. Sorry.) If you have Dropbox on your Mac, store the image somewhere in your Dropbox folder. Right click on the image file in Finder, and select “Copy Dropbox Link.” Use that link in your image references, but edit the link slightly: Change the dl=0 at the end of the link to dl=1. This will let Scrivener access the image for compile as well as giving you visibility in Ulysses preview mode on iOS.
Tag placement for italics and bold: Ulysses likes its bold and italics tags to be surrounded by whitespace, like this: … greeted me with a hearty _¡Hola, amigo!_
Most of the time you can achieve this by simply including your punctuation inside your tags. But if you follow Chicago Manual of Style recommendation for dashes—em dashes are not set off by spaces—you may be in trouble if your italics/bold start right after your em-dash, as Ulysses will arbitrarily decide that of course you don’t want italics or bold to start in the middle of a word! And will put a helpful backslash in so that your italics or bold is messed up on compile.
The easy way to get around this is to use CMS’s alternate recommendation of space-en dash-space. If you really want your em dashes, set up a compile substitution rule to convert space-en dash-space to em dash. (If you have no idea what the differences are among em dashes, en dashes, and hyphens, don’t worry about it. Just be aware that if your italics or bold don’t show up after compile, this peculiarity of Ulysses may be the reason. In Scrivener, search for a blackslash followed by an underscore or an asterisk to find and correct this problem.)
You can do this for any Scrivener-styled paragraph that doesn’t have any Markdown inside. I like it; the styled paragraphs really stand out in Ulysses, and they’re easy to find in Scrivener even if the style is accidentally stripped. It’s just that for tabs to survive, you must use code blocks for styles incorporating tabs. ↩
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. (This article assumes you’re starting with a new Scrivener project, or have already prepped a project for MMD→RTF compile. I’ll cover prepping an existing project in Part 2.)
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. (The other option for styles, particularly if they’re formatting you only use for final output, such as in front and back matter, is just to apply them after you compile, in your favourite word processor.)
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
Ulysses round trip effects:
Any paragraph that you edit with Ulysses will
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.
Lose Scrivener styles. Any style you truly need will have to be reapplied.
Have Inspector comments and Inspector footnotes (linked notation) stripped out.
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.)
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.
Scrivener-style image insertions and external links are invisible inside Ulysses. If you edit their paragraphs, they disappear (see above).
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 {{}}.
Scrivener internal links look like plain text. MMD-style internal links are ignored.
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.
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,
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.
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.
“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.
Markdown lists and MMD tables appear in the compiled output as well.
Scrivener lists show up as a series of paragraphs with hand-bulleting or numbering. Indents are lost.
Scrivener tables appear in the compiled output as a single massive collapsed paragraph. No “table-ness” survives.
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.
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.
Strangely enough, MMD-style footnotes have formatting problems.
Scrivener-style external links disappear.
Scrivener inline annotations and inline footnotes work just fine.
Scrivener-style internal links compile just fine.
Compile ignores Dividers (four hyphens).
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. ↩
I’ve had a lot of time on my hands, lately, what with my coworking venue going out of business, and all the coffeehouses being closed (at least for purposes of sitting and writing for long periods.) The time I spent commuting had to go somewhere, and when I wasn’t too depressed to do anything except play video games, I found myself niggling at The iOS Scrivener Problem. (Yes, I know, I could have been productively writing. Still…)
Abandoning Scrivener totally is out of the question for me. I use the Scrivenings view constantly on my Mac, as well as stacked corkboards, the Outliner view, keywords, custom metadata… ad infinitum. (About the only features of Scrivener I don’t use are document notes, scriptwriting, and research. Oh, and the various LaTeX workflows.) I also use Aeon Timeline, and while theoretically I could use AT with Ulysses, I’ve got Scrivener all set up with it.
Ulysses… hmm. What about using Ulysses as an iOS editor for Scrivener projects? I can’t access many of my Mac Scrivener features in iOS Scrivener anyway. I already know and pay for Ulysses (I write this blog on it.) Ulysses has as slick an iOS-style interface as any app going. Any metadata I need to refer to (synopses, keywords, etc.) is available on iOS via Aeon Timeline. My research is already available on iOS via Evernote. I can even edit metadata in AT if I need to and sync it up to my Scrivener project on my Mac.
I’m no stranger to using non-Scrivener editors on iOS. In the Bad Old Days before iOS Scrivener, I used both the Index Card app and the Editorial app to edit my Scrivener projects, using Scrivener’s External Folder Sync feature. It was harder to describe than it was to do.
It’s taken me some experimentation. Scrivener 3 is more complex than Scrivener 2 so there are more pitfalls on the Scrivener side. Also, Ulysses is more complex than either of my old two iOS apps, though that turns out to be all to the good.
Nonetheless, I’ll be posting my new Mac Scrivener 3 <=> iOS Ulysses editing workflow in a series of several blog posts:
Translating Between Scrivener 3 and Ulysses: Ulysses speaks Markdown. Scrivener speaks Rich Text. Rich text has a lot more formatting flexibility than Markdown. This means modifying some things in your Scrivener project, and avoiding certain Scrivener features. I’ll cover what you’ll need to do to your Scrivener manuscript to prepare it to work smoothly with Ulysses’s Markdown. WARNING: You may not be willing to live with these limitations. In that case, this isn’t the workflow you’re looking for.
Setting Up Sync: I’ll reveal the nitty gritty of using either iCloud or Dropbox (dealer’s choice) to sync between Mac Scrivener 3 and iOS Ulysses. I’ll provide detailed sync settings for each app.
Avoiding The Editing “Gotchas”: I’ll tell you how to sidestep the “OMG no!!!” moments, or at least face them with confidence.
Compiling Your Project: I’ll describe the modifications you’ll need to make to your Scrivener compile formats to output your Ulysses-savvy manuscript.
But What If I Don’t Want To Use Aeon Timeline?: I’ll go over some strategies for getting at least some of your metadata into Ulysses. Note that these methods are minimally, if at all, automated. If you update the metadata in Ulysses, you, and you alone, will be responsible for updating said metadata in your Scrivener project by hand. Be told.
A Study In Silver 