Import into Scrivener

I’m using Scrapple to outline a project. The nodes (all but the top level) are connected to other nodes, making a tree. I would like to import the tree structure into Scrivener as an outline (nodes with children as folders, childless nodes as text items), but I can’t get the expected hierarchy. Instead I get a flat structure of notes as text items. Obviously, this isn’t an outline. Is there a way to get the structure of the Scrapple file into Scrivener?

The tree traversal described in section 9.2.1 of the User Manual should recognize a valid tree and parse the Scrapple file into folders and text items. I guess that’s a wish list item. Thanks.

The tree traversal mentioned in the manual is for making a best guess at what order you intend the items to appear in, not as a way of establishing outline hierarchy—that would be impossible because you could just as easily connect a “level 8” item to a “level 2” item—and then what happens? There is no outline in Scapple, it is specifically designed to not have an outline and to be purely flat. So I’m afraid that isn’t something that is going to be changing any time soon.

One thing worth noting is that if you use background shapes, they can be analogous to containers when exporting as OPML. It’s nothing fancy, and you can’t label them, but if you want to group a certain number of notes together that’s the way to do it.

I appreciate the reply. The (retired) professor in me compels me to say that Scrapple is used to create networks and that a tree (outline, hierarchy) is readily recognized as a distinct kind of network. I would guess that the programmer(s) who developed the underlying data structure used to represent a Scrapple network would agree - especially if the underlying data structure used to represent a Scrivener binder was produced by the same developer(s).

Based on only a couple of hours’ work, I would say that the inability to organize all those free-form ideas into a hierarchy is a significant shortcoming, especially for Scrivener’s target audience. Most books - non-fiction, anyway - are very hierarchical, which makes the use of Scrapple to capture more than a handful of related ideas problematic. Of course, the implication is that it should be possible to import a Scrivener project (which is organized as a tree) into Scrapple with all the connections intact.

So it’s still a feature request - maybe version 2.

The developer of Scapple (who is yes, the same person that makes Scrivener) not only agrees with what I said, but was the person who originally said these things, and specifically designed the program to be flat—we even went out of the way to avoid features that might look like hierarchy, so that it wouldn’t be confusing—shapes were the big compromise in that, but only from a UI standpoint.

If you don’t believe me, open up the .scap file in a plain-text editor. You’ll see each note is in a flat list, there is zero hierarchy in the Scapple format. Worse, connections are just references to other notes from the originating note. A note can have zero, one or five-hundred link references. You cannot have hierarchy in a purely equal system like this, where any note can link to any other note no matter the conditions of that note. Even background shapes, which I mentioned before, are not an example of hierarchy. There is a separate list of shapes below the notes list, and you will find no association with “its” notes, in this file. The only thing that “associates” a note with a shape is if it happens to overlapping it—and a note can be overlapping two or more shapes to create a fuzzy declaration (meaning that on export, some data in the form of associative declarations like this will be lost, since a hierarchy can only represent one parent per item).

You had me up until the tree bit. Scapple can be used to create networks, this is true, but this is of course a very broad word. A network can even be anarchic in its component parts (which I would say Scapple is probably a good example of). To then suddenly leap to thoughts of hierarchy trees is to focus on only one single (albeit popular and familiar) approach to the concept of associating thoughts together. If you want to look up something that is closer to Scapple’s approach, do some research on concept mapping. It’s not quite the same, mainly in that it relies upon an explicit declaration for each connection “is a”, “will be”, etc., but it also uses a flat non-hierarchical approach to thinking. Connections are not declarations of topical lineage, but of association.

Only if you insist on using Scapple like a mind-mapping program or a visual outliner. It’s not designed to be used that way, however. You would run into as many problems trying to use it like Powerpoint. It’s meant to be purely flat, no disclosure, no parental assignments, and thus: no restrictions on how you form connections, no requirements to chain an idea to another idea, and no stigma to bind oneself to the principle of categorisation for everything they do. Whether that’s your cup of tea or not is up to you, but I’m just telling you what the program was designed for and what the people who enjoy using it like about it (and wouldn’t want it to radically change, turning into Yet Another Outline Based Mind-Mapping program).

So yup, Scrivener is a tree, and Scapple is a map. They are oil and water, and that’s precisely the point: Scapple is for the types of thinking that are abstract. Scrivener is for the types of thinking that require structure and rigidity. The two can be a part of the same project in different phases, but the two are meant to be discrete, performing for different cognitive outlets. There are some basic copy-and-paste type procedures that can get data between the programs—but they are lossy, always will be, and are meant more for transition than integration.

Well, customers often try to do things developers and marketers don’t think they should be doing. Thanks again.

And that is perfectly fine. :slight_smile: Abusing software to do things it was never meant to do is a hobby of mine. I’m only explaining why a feature request to convert Scapple into another type of software is not something to get your hopes up over. We might continue finding ways to make import/export easier to use with outlining tools (such as Scrivener), but that is the most I can suggest as plausible, at this time.

I am, frankly, dismayed by the dismissive tone of these responses.

Whether or not Scapple uses a particular sort of data structure internally has very little to do with whether it can be made to do what customers want it to do.

Wanting to bring Scapple content into Scrivener is something a rather large fraction of its users are likely to want to do, and is in fact why I bothered to make a forum account at all. To come here and find a reply that says, essentially, “we don’t want to let you do that” is disappointing at the very least.

If what you really want is a hierarchical mind-map, then there are a number of very good applications of that sort, which can export to OPML and other formats, which Scrivener can import into a tree structure. I’ve used some, and have abandoned them because their insistence on hierarchy interrupted the flow of ideas I was trying to jot down.

Since there are plenty of programs which can accommodate your needs, there is very little reason for the makers of Scapple to re-invent the wheel. I for one, am very happy with Scapple as designed, and use it at the exclusion of mind map programs that I’ve invested both time and money into. From your reactions to the design philosophy of Scapple, I’d say that it’s not a good fit for you.

Actually, the internal implementation details have rather a LOT to do with how easily a program can be made to do various tasks. If the internal data format does not record the data necessary to export for the task the customer wants to perform, then that is a major engineering barrier – and fixing it could be a major overhaul that the developer doesn’t want to do, or isn’t warranted.

That’s true, if you insist on interpreting it that way – but it isn’t what was said. Your interpretation doesn’t change the design philosophy behind the development of Scapple. I played with Scapple during the beta and decided not to use it because it didn’t seem to fit my needs because of the mismatch between the design philosophy and how I wanted to use it. Different project, different needs, now I’m exploring it again.

The presence of customers who want a feature doesn’t mean the developers are obligated to change their vision of the program to develop that feature. That may not be the program the developer wants to write. We have gotten used to software development that is driven by marketing and sales (many complain about Word and Office for just this reason), and yet many of the L&L customers don’t want to use the programs that result because they feel bloated, inefficient, or just plain don’t offer a satisfactory user experience. Maybe it’s a good thing that L&L doesn’t subscribe to the same philosophy?

And just to be clear, you can indeed bring Scapple content into Scrivener. I’m not sure where you got the impression that this isn’t possible, or that “we don’t want to let you do that”. Have you tried dragging a note into your Binder? Or better yet, have you tried dragging a cluster of notes into a blank Freeform Corkboard in Scrivener (Mac only, obviously)?

It may not always get the order perfect (that’s where the flat internal storage comes into play) but it is easy to move things around in Scrivener once you’ve brought a batch of notes in. That’s just something you’ll have to live with, moving things from a “sheet of paper” into a “tree”. There is no direct and 100% accurate way of doing that, so at some level there is a degree of arbitrary selection when coming up with a linear or even hierarchical order.

As stjones suggested there are those of us who would like to use Scapple to mindmap and import into Scrivener an hierarchical outline. The developer of Scapple (and Scrivener) doesn’t agree.

Is it possible to reach a compromise?

I’d like to suggest that that when nodes are grouped (with one main root node in the group) that it be treated as hierarchical when imported into Scrivener. It may require the root nodes to be reorganized, but it is a far better scenario that how it presently.

Otherwise, I’d suggest stjones (and like minded) to use MindMup–a free Chrome extension. The mind maps are saved as .mm files and import into Scrivener as hierarchical.

It is already possible to establish simple grouping, you just have to use something that can more logically (in terms of raw algorithms) express that information, than freeform connection lines:

Thanks. That works. Really solves the problem of importing a hierarchical structure. I’d like to mention if there is one root node the hierarchical structure is maintained. Of course there is a little housekeeping to get the documents to display as preferred.

There must be something the rest of us have missed. It seems that you feel strongly that there is a definite advantage to importing a flat structure. When someone is passionate about something as you seem to be I figure it’s an opportunity for me to learn something new.

How do you use Scapple in outlining what you write? What advantages have you found in importing a flat hierarchy into Scrivener? What do you see as the disadvantage of a hierarchical structure?

I don’t know what you mean by that since my example had two groups, and they were nested in accordance with their spatial arrangement upon import. We might be looking at a platform difference quirk though. I’m not testing with Windows at the moment, but no matter how many shapes I have, overlapping or no, they stay as logical as possible on import. They aren’t truly containers, so some things may not be perfectly logical but that is because there is no perfectly logical answer to something like a note straddling two shapes.

Maybe try OPML export instead of drag and drop, do you get a different result? There may be something worth reporting in the bug forum.

For myself, I find the lack of hierarchy to be a liberating way to think for even complex ideas. It’s not new to Scapple, it’s as old as paper. It’s just something that has kind of been lost in the modern software world. Hence: a “new” program that makes this kind of thinking easy. If you don’t find yourself thinking the way it works, yeah, there will be friction.

There would be friction trying to use Freemind like Scapple with a huge tangle of notes and connection lines that are used purely for human interpretation rather than strict parent-child topical branching.

I wouldn’t put it that way; I think that’s the wrong question. It comes back to what I already said above: that the two programs use entirely different philosophies for thinking. They do not mesh well, algorithmically, for that reason, and thus the only way to make one import better into the other is to change it so that it is like the other—and then we’re just another mind-mapping program in a sea of similar programs all doing the same basic thing with a varying number of embellishments to the core design. If you want a visual thinking tool that exports outlines, there are already plenty of programs like that.

The question in metaphor is: why are you trying to load a blackboard into a filing cabinet. We may certainly adapt the ideas we put onto a blackboard into rigid logical structures, but doing so necessarily discards the advantages of the blackboard (everything spatially represented in one flat surface) to take on the advantages of the filing cabinet (content obscuration through topical assignment). This isn’t a better vs. worse proposition, but an adaptation between two forms of thought: and adaptation of thought is something outside of the realm of what a computer can do for you.

So: we give you the best result we can, using the import guidelines described in the manual, with the understanding that you’ll nearly always need to do a little reorganisation, but at least we can help you with the hard part: making 85 individual outline elements so that you can freely reorganise them. That’s the part that takes forever and is just mindless drudge work. We’ll take care of “pressing Cmd-N, Cmd-V” 85 times for you, for the rest, we need your brain to interpret the blackboard. Does that make more sense?

Speaking personally: I don’t use it for outlining. If I want to outline I use an outliner, like Scrivener; and if I want a hybrid I use its freeform corkboard. I use Scapple more like I would a text editor, except without the limitation of having all of the text in one linear stream. For me, if something in Scapple eventually ends up in Scrivener, it’s usually not whole structures of notes, but just one note here and there—the stuff around that note, the stuff linking to it maybe, or just clustered around it and using distance to denote similarities and contrasts, the “ephemera” isn’t typically something I want in Scrivener. I don’t want my “What about this?” interjection, I want what eventually came of that line of thought in the main note it links to. I might import it, I might just copy and paste it, more likely though, I’ll probably rewrite it.

It’s not a universal disadvantage in my opinion—more on the blackboard vs. filing cabinet; they each have their strong advantages and disadvantages. For some types of thinking and specifically for the kinds of thinking that produce structured documents, outlining is one of the most powerful tools humans have come up with. That’s why I like Scrivener so much, because it is a pure document-producing outliner. For making sense a 500 page document, little else can compete with that model for thinking.

But what about before that point? What if my idea is still hatching from the void before concepts become language? What if the idea has lots of competing factors and false starts? I don’t know if A goes into B yet, because I don’t even really know what A is: that is the situation Scapple is designed for, and when I’m trying to capture a thought that is forming in that fashion, I don’t want to be hindered by strict hierarchical concepts, I just want to think out loud.

And again, if you do want to use Scapple quasi-hierarchically, I believe you can. The best tools for the job are Stacks and Shapes. Connections are the worst tool because any note can have any number of connections to any other notes—no note is ineligible as a connection target. That is no recipe for building hierarchy.

Amber, Before you posted I had revised my post to say your recommendations do work. When I first tried it only one block was selected and that is all that was exported. After looking at your example a second time I realized that something wasn’t right and after correcting the mistake exported again and this time without any blocks selected.

Really appreciate your suggestion to use blocks. Haven’t done too much with stacks, but it sounds like that will put everything in the proper order. Well done!

It’s nice that we hierarchical outliners can co-exist with the flatliners.

Again, thanks for the solution.

[PS Is it possible at some point to include your suggestions in the manual? Your suggestion is the first time I’ve seen shapes and stacks as a work around for the needs of us hierarchical outliners.]