I would love if the product had a built in to-do/task list – essentially a list of tasks that you can use as reminders, and then check them off when done.
add the ability to delete all completed tasks
add the ability to automatically add a task based upon text entered into a scrivening (for example, in MS Visual Studio, I can add a comment in my code that looks like //TODO: (some text), and it automatically creates a task with that text. Very convenient to not interrupt the flow of writing, but still capture something you really need to remember – the task would also link back to that specific comment in the scrivening, so you could quickly find the place where your to-do item applied to.
For to do items in my projects I change the relevant document’s Binder icon from its default to something else; thought cloud usually for a document that needs more thought; eye for a document that needs to be reviewed; magnifying glass for a document that needs in depth review and examination. Using the Inspector’s status and label features would provide something similar. Set the document/project progress and then use Outline mode with the Progress column displayed. Use the Keywords feature for target dates and show them in Outline.
Then there’s the feature of Scrivener that I abuse on a daily basis: Collections. Have Collection for TO DO, or refine by having a Collection for TO DO: reason.
My development project - the Scrivener project I use to keep to keep track of what I need to do for the next version, and the version after that - is one big task list. I also keep task lists in other projects. The way I do it is to have a “To Do” folder and create a separate document inside that folder for each task. That way I can view the folder in scrivenings mode to see them all at once, and I can either delete them or move them to the “Done” folder when I’m finished with them. As reepicheep says, you can also change the binder document icons and use the label colours for more information in there if you want.
I wonder if Comments might serve many of your purposes. (I am speaking of the Mac version, but the Windows version either has this ability or will when full parity is achieved.) You can associate them with particular points in or chunks of text, they have their own dedicated view in the Inspector and you can survey the comments across groups of documents when in Scrivenings mode. Each comment has a handy close box for when you are done with it.
To-Dos that are not associated with particular documents might want to be placed elsewhere (project notes?), I suppose.
P.S. I have not been in the habit of using comments like this – just thinking aloud. I use a dedicated To-Do app for my general To Do needs and I use a system of document Labels in Scrivener (together with some coordinated Smart Collections) to reflect the general where-I-am-with-that-bit and hence what I would need to do next with it. I use in-line annotation to jot down things when I need to flag some point in a text with something I need to deal with. My needs may be simpler than yours.
Embedding todo lists within your text.
Interestingly, this one sounds a lot like what you are already used to doing (even down to the punctuation—though I understand in your case part of that is a comment indicator—in Scrivener the analogy to comments are inline annotations, but I use punctuation to make searches precise instead of pulling up any old mention of the word “todo”). Scroll down to the highlight text in that post, I was responding to a number of different questions in that thread. I also don’t believe I mentioned it there, but what I actually do in my projects is create a saved search collection that hunts for TODO //. Thus whenever I mark something down as needing to be done, it pops up in that list (and goes away once I change the punctuation to no longer use both slashes—or of course if I delete the comment/annotation entirely).
Some of that is Mac-specific, but I can think of nothing within these concepts that would be crippled by a missing feature. All of the core concepts can be done on Windows.
I’d like to put in another vote for this feature. To help the developers a few more details.
For an individual document I want to be able to create a to list for that document. I imagine this would be a new tab in the inspector that would show me a list of tasks I put in. I think a simple task list would do with the ability to add, delete, re-order, and complete tasks. It would be nice to have a the ability to toggle the visibility of completed tasks.
Then ideally there would be a global view of the to do list in an outline view that is grouped by document. I could see this as a fourth view in addition to the document, outline, and corkboard. That way you could see tasks at different levels in the project (e.g. document, chapter, entire manuscript.)
Here are the kinds of things I’d imagine tracking in tasks:
Changes and additions that need to be made to a document (e.g. fix dialog section)
Listing specific editing or copy editing tasks (e.g. check dialog, check directions, check name spellings)
Instructions to my self for new content to add (e.g. add scene about foobar)
This would be an extremely useful feature–I’m also using a workaround like the suggestions above. It sounds like the requested feature is a lot like something OneNote does right: You can mark some line(s) of text with live checkbox(es) and then automatically compile a list of them in a separate page, with each item linked back to its source. You have the option to filter/sort the summary page when you create it, for example by document or by date. Scrivener is so good at helping to manage chronic disorganization that it’s a bit surprising that there is no such feature already.
Maybe this is easy to do on Windows since OneNote already does it?
I keep my To-Do list in Project Notes, where it’s always one click away and can float accusingly over my working desktop without ruffling the Binder.
The more I use Scrivener the more useful Project Notes becomes, everything from lengthy time-lines to capsule character sketches.
Individual document tasks I keep in Document Notes, which are likewise readily available, particularly when writing in Compose mode.
With respect to TODO code comments vs Scrivener, You can just use Inspector Comments. When you load a document into the editor, and click on the text linked to your comment, it loads all of that document’s comments in the inspector and scrolls to the specific comment associated with the text you clicked on. Unlike most word processors, Scrivener’s comments are all stacked together in the inspector, so you don’t have to scroll to find out if there are more of them lurking down the page.
Keywords can be used to list tasks that need to be done to a given document. You can order them however you like, delete them when you’re done, view them in the outliner mode or as colored chips on the cork board mode.
Alternately, you can put your task list in the synopsis. The document notes field is a little less visible, but also good for task lists–as a bonus, it’s rich text, so lists and strike-through work in that part of the inspector.
If you use chapter folders that don’t contain text themselves, you can write your task lists there (“on” the folder instead of in a sub-document of the folder), assigning a distinct font/font color to make them stand out in Scrivenings mode. Most out-of-the-box novel templates/compile presets exclude the text written “on” folders, or you can customize your compile settings for that outcome.
At the top of any document, you can write your task lists in rich text, and mark that text as an in-line annotation. In the Compile settings, you can strip out all inline annotations from the output.
Another option is to do what Keith does and make your to-do lists in another folder; creating one binder entry per task, grouping those tasks into folders named similarly to the document they’re related to. Use the Reference tab in the inspector to link to that list’s folder from the relevant document, or use Scrivener links in the main text or the document notes for that purpose.
No matter how you do it, making use of the Status built-in metadata lets you see at a high level which documents need work, and what level of work is required, by making “BIG revision”, “Moderate Editing needed”, or “Needs polish” types of statuses that you can choose from.
You have a plethora of options to accomplish what you need that don’t require a new feature added… you just need to familiarize yourself with the tools in your Scrivener workshop.
It’s certainly true that Scrivener is feature-rich enough that one can hack a task list functionality–it’s what I’m doing right now–but this is completely besides the point. There are plenty of examples of Scrivener features which to some extent duplicate or overlap other features, but L&L decided to build in a dedicated feature rather than just advising people to repurpose some other feature as a workaround. The suggestion on this thread is that the same be done for task list functionality, which is apparently useful enough that many people (including you) have taken the trouble to come up with workarounds.
I think the main difference in how you are thinking between how we are thinking is that in a program like Scrivener, which is a system built of many small tools, part of using the program is developing larger workflows out of the various combinations of those smaller tools you can make use of. Hence, if one is building a workflow out of the toolset Scrivener provides, it isn’t a “workaround”, it’s called using this kind of software the way it is meant to be used: the ability to exert your creativity upon the software (which in accumulation is something we could never fully predict), rather than having to wait for developers to grant upon you the capability to do so in prepackaged features is in itself the big feature.
Your point is well-taken, but these various methods for task tracking are all from my perspective still “workarounds” because none of them actually do what I wish I could do. The only existing feature that comes close would be Comments/Footnotes, but you cannot view them in Scrivenings mode (at least not in Windows–I’ve never used Scrivener for Mac). So if I use the Comments workaround, I cannot see all of my tasks at once. Even if I could do that, I still wouldn’t be able to sort, filter, reorder, or otherwise manipulate my task list. Similarly, if I use the Binder workaround, I have access to the functionality of the Outliner, but I need to manually insert a link back to the document the task refers to and/or search for it, and then find that bit of text within the document. And so on.
It might be the case that the L&L team doesn’t think there should be a text-integrated task management feature in Scrivener, but as far as I can tell, it’s really not true that some combination of existing features already meets that need. At least not very well, especially when compared with how good the implementation is other functionality.
I want to add that Scrivener for me isn’t just a useful tool, it’s really life-changing software given how much I struggle with disorganization. (The people who are organized enough to use some multi-step system for task management probably aren’t the people who REALLY NEED Scrivener.) I’m just trying to constructively delineate a suggestion for feature which (1) seems to periodically come up and (2) would add to Scrivener’s already numerous strengths.
Hmmm the notion of having my tasks in with my manuscripts seems v. misguided to me. I used to do this but have become much more efficient at getting writing done by moving all the tasks, notes on issues to resolve, etc. into separate text files (using Taskpaper format). I can look up next tasks on a second monitor or ios device while devoting the computer to writing. For me this has been a much better solution than jumping between tasks and writing in the same app.
I think the main problem with this line of idea in general is that it’s… well it’s a rather huge area of stuff. There are entire software packages, some quite expensive, that devote themselves to managing to-do lists in one form or another, and the many countless ways in which they do so together compounds with the first problem: (a) this isn’t something that is easy to just slap into any old type of software that doesn’t already specialise in productivity and (b) there is a wide latitude of what various people want in such a program. You seem to be assuming that if there were a feature, it would do what you want. But what does that feature even look like? You’re talking about aspects of it that nobody else has suggested before even right here in this post. Look at the thousands upon thousands of features in the countless to-do style programs that exist out there and tell me what the quintessential concept is that any random non-productivity program could easily embed that would make it so this request went away?
Take for example the post above: I use TaskPaper as well for some things. It’s a remarkable tool for the job, especially for larger complex tasks that require extensive documentation of the steps you take. What better format to do so than in a text file—and that I can throw TaskPaper files into the binder and open them as needed with ease is just a bonus to the whole idea. But to some people, the concept of tracking to-dos inside of a plain old Notepad level text file would be ridiculous—1985 all over again, markup, who does that any more?
My strong sense is that no matter what we did here, if we did anything at all, only a few people would like the way it works anyway—and even among those who liked the basic idea, it would still never be enough (refer back to this being the domain of entire programs). It’s the old problem of if you don’t have a feature people ask for just the feature—if you make the feature, ten times more people ask for it to be different.
Case in point, that’s a matter of opinion that I happen to completely disagree with. Yes, I do use to-do programs for other things (not everything I need to do is inside of a project), but I find the toolset Scrivener provides hits just about everything I need of it for tracking the things I need to do inside of a project. I don’t need a big sortable list of colour-coded filterable to-dos in Scrivener like you mention. I don’t need checkboxes. I need a cross-referencing system, snapshots, global and stepwise search, simple text-based markings and the ability to pepper a working document with these “invisible” codes, sometimes back-referenced to simple bullet list documents with strikeout. It does just about 100% what I need it to without any dedicated features.
So what if we made a dedicated “real” to-do feature, whatever that means, and it doesn’t have sortable universal listing or whatever—you’d still be saying it’s not good enough. So we make those things, but then there are other things other people think are critical to the idea—and before you know it Scrivener is a shambling mutation, straddling the line between PIM and database and whatnot.
You know? Why can’t something just be a writing program—that’s a pretty big topic all by itself after all.
But to that: yes, there are some pieces of the puzzle you’re missing on Windows right now—and well for that matter the Mac is missing a lot too. Scrivener has been moving more deeply into all of the things I’ve been talking about—not to make a better to-do system, but to overall streamline and improve all the things it already does well. More tools, more ways to combine them, more flexibility within them. For example cross-referencing will be way easier. Filtering by multiple axes will be possible and easy. Building your own checkbox functionality will be possible. Building views based on checkbox states will be possible. Assigning dates to items and filtering by date ranges, done. Compiling based on meta-data states will be possible. Viewing global lists of markings in the inspector in large Scrivenings sessions will be possible. Having an item open with a 5-point checklist referring to fifteen binder items in a separate window with easy access to those items in and out of the project window will be possible. Effortless integrated two-way editing access between any linked pair of documents; possible. And again, lots of things that haven’t been invented yet by other people, that I haven’t thought of are all buried in there as potential, too.
The great thing about this approach is that you might use this stuff to track what you need to do, but another person might use it to track where they mention certain types of toxic sea urchin across five different volumes in a twenty volume set on scuba diving. There is no hard coded prescriptive way to use any of the above.
Well maybe, or maybe they use Scrivener differently than you do. I mean, I’d consider myself in that group, and I’d have a pretty hard time giving up Scrivener. Glad as I am to hear it from you, for me it’s not an organisation life saver, for me it’s a friction killer. It makes 250,000 words feel like 2,500 via its dual-pane multi-function history based heavy duty outliner. But hey that’s part of the magic—and I’d say part of why it has that magic is because it doesn’t excessively service either of us specifically, but rather gives us both a set of omnifunction tools that were designed to be good at organising things and busting down the sheer weight of a large text in one move instead of two.
To each their own. For me there is no more efficient interface on my Mac than Scrivener, and no better place to say “fix this” than stuck fast within millimetres of the thing I need to fix. I do need other programs and use them alongside it—that’s why these things multitask after all—but effortlessly moving through a manuscript, piece by piece, jumping from task to words, from one thing that needs to be done and back again, well, that’s what Scrivener does, to my mind. To me there is very little difference between task, process and product in my projects. I move between them as simply as I move between subsections within a topic.
Yeah, I’d concur with nearly everything you said. I only mentioned my approach because I had tried to work for several years on a big project keeping tasks in Scrivener but have made much more rapid progress having moved everything out. And yes, taskpaper works great for these very highly detailed tasks. For the big picture though I’ve switched to omnifocus from TP, which was another breakthrough for me. All of which for me confirms the argument against trying to build a track tracking system into a writing program - not only will different users want different features, they’ll also expect different features sets for different kinds of writing (not to mention the folks who use Scrivener as a general notes repository etc.). Given limited developer time, I can’t see that this should be a priority.
AmberV/Ioa, thanks for the detailed response. I agree that the planned features you describe would do the trick and also be more flexible for other purposes. So I guess I’ll just have to sit tight.
FWIW, for reasons I won’t go into here, I have mixed feelings about managing Scrivener-related tasks on a separate app. I do often use the excellent Windows/iOS/Android personal organizer MyLifeOrganized (which is very similar to OmniFocus). But the big obstruction for me to using MLO (or TaskPaper, or whatever) to manage tasks in Scrivener is the lack of a Scrivener URL scheme together with a way to grab a link to a Scrivener doc that doesn’t involve pasting the link in a Scrivener doc.
I’ve tried using the scrivlnk protocol with several other apps that launch other URL schemes just fine. But scrivlnk doesn’t seem to even launch Scrivener. If there’s a way to get this to work, I’d love to know what it is.
And that’s another thing we got planned. We’ve been working on a Windows version to finally get all of this caught up, as well as to the new Mac version that is yet to be released. So there is a bit of a back log of ideas at the moment. But yes, having external links makes external software even better of course, as well as making multiple projects more useful together. For example I can jot down a note on something that needs to be fixed in Scrivener in one project, and put down a reference there pointing to how that behaviour is described in the user manual, so that if the fix alters the way it needs to be documented I can go straight to it. That sort of dependency based “to-do” mechanism is something I’ve found difficult to implement in OmniFocus/idea-bucket style programs.