Of course, Inkscape is far from being the only game in town. There have existed and still exist dozens of vector editors: commercial and open source, for different platforms, generic and specialized, alive and dead. Only a few of them, however, deserve to be mentioned here. Currently, all of Inkscape’s serious competitors are commercial (and often quite costly) applications, usually limited to the Windows and Mac platforms, which means Inkscape’s zero cost and cross-platform availability immediately give it a competitive advantage.
Adobe Illustrator takes the indisputable first place in this list. An immensely powerful and feature-packed application, it is usually considered the leader in the field and a de facto standard in vector graphics. Even if you don’t use Illustrator, you are likely to run across mentions of its features and versions, comparisons of other programs to it, and of course AI-created vector files in various formats (including SVG).
No doubt much of Illustrator’s clout is channeled from its much more famous cousin, Adobe Photoshop. Positioned as parts of the same creative suite, Photoshop and Illustrator share many UI traits and are optimized for working together. However, compared to Photoshop, Illustrator’s position in its field is fortunately much less of a monopoly. Even without Inkscape, it still has very serious competition, although its prominence has been growing in the recent years.
Dating from the late 1980s, Illustrator has had a long and winding history. It wasn’t always the dominant player in vector graphics. Many of its features were pioneered in competing packages and, sometimes only after several years, were reimplmented in AI. By now, however, it’s so big—and growing bigger with every version, especially if you consider the rest of Adobe’s Creative Suite as well as a whole industry of third-party AI plugins—that any generalizations are risky. Illustrator is a lot of things to a lot of people.
And yet, I think I can risk one such generalization: Whatever its capabilities, few people will claim Illustrator’s UI as a paragon of usability. Critics (admittedly mostly users of competing packages) cite a cluttered interface dominated by a swarm of floating dialogs, too many tools with too narrow functions, limited on-canvas editability of objects’ properties, and scarcity of context information. Competing editors also often claim a speed edge over AI.
I’m not trying to write a comprehensive migration guide for AI users. Still, throughout the book, I will provide the AI equivalents and comparisons for some of Inkscape’s features.
Vector formats associated with Illustrator, and with Adobe in general, play a crucial role in the modern digital world. You need to have an idea of what PostScript and PDF are, how they are related, and what they are capable of, even if you’re not planning to use anything but SVG with Inkscape.
Adobe’s first claim to fame, back in 1984, was creating the grandfather of all vector graphic formats: PostScript. Designed as a standard for sending data to printers, it was ready just in time to become a major component of the “desktop publishing revolution” of the 1980s, driven by accessible personal computers and laser printers.
PostScript was (and is) quite unusual in that it is a complete programming language and not just a data format. A PostScript file is actually a program that a printer or computer must run in order to get an image. For example, a PostScript file may contain an instruction to print a text line, such as “I must not disrupt the class,” and a loop that will repeat this line a hundred times. Unfortunately, this also means that, due to an error in the program or someone’s malicious intent, a PostScript program might run indefinitely, tying up the system’s resources.
On the positive side, PostScript’s interpreter used little memory and could therefore be embedded in the hardware of the day. As a result, it became popular with printer makers and soon was the de facto standard for sending files to print.
It was also used as the base for the native file format of the first versions of Adobe Illustrator, which appeared about that time. Even though the AI file format changed in many ways with every version of the application, for a long time its foundation remained the same: An AI file was simply PostScript that followed certain conventions and used PS function libraries from Adobe.
Unfortunately for the users of Illustrator, PostScript’s priorities as a print language were in addressing the concerns of printer makers rather than becoming a generalized vector graphics language. For example, Level 2 of PostScript (1991) added device-independent CMYK color, but it wasn’t until Level 3 (1997) that such a basic thing as gradients became directly possible. (Until PS 3, applications wishing to create a gradient in PostScript had to “fake” it by overlaying many narrow strips of gradually changing color.) And even today, PostScript still does not support transparency natively.
This is undoubtedly one of the reasons why early versions of Illustrator were so slow to gain the new features that users demanded (and that competing vector editors were already providing). To this day, Illustrator’s UI bears marks of being built with the PostScript feature set in mind, with everything else treated as an afterthought.
However, the biggest issue with PostScript is not its feature limitations. Over time, its being a programming language proved to be much more of a burden: What was once a clever hack in the late 1980s is now regarded as very cumbersome and dangerous. Since any PostScript file is a program, you simply cannot tell what exactly this file will display except by running that program. This means you need a complete PostScript interpreter in order to do even the simplest processing of PostScript files, and you cannot directly combine two PostScript files into a single document with predictable results.
Adobe tried to rectify this by imposing various limitations on PostScript files. One such limitation was the Encapsulated PostScript (EPS) format. An EPS file is simply a one-page PostScript document that can be reliably inserted into other documents. However, this was obviously not enough.
So in 1993, Adobe took a more drastic step: It introduced Portable Document Format (PDF). This format, although based on PostScript, drops the idea of being a programming language. At first, PDF was just simplified PS rewritten in a declarative fashion with added compression and some top-level document management features. Later, Adobe went on to develop PDF well past what was ever available in PostScript; for example, transparency was added in PDF version 1.4 (2001).
Although PDF’s stated goal was Internet document exchange, it became popular and eventually started gaining a foothold in print and design as well. The fact that PDF is an open format, standardized by ISO and free for implementation by anyone, also helped. By now, PDF has largely replaced PS in most commercial applications, including print.
More importantly for our discussion, with version 9.0 (2000), Adobe Illustrator switched its native AI file format to one based on PDF instead of on PostScript. This means that any AI file saved in a modern version of Adobe Illustrator is in fact PDF and can be viewed and imported by any software that supports PDF. For example, Inkscape’s AI importer is actually the same as its PDF importer.
In summary, at this point in time it really makes no sense to use PostScript or EPS if you can use PDF instead. Inkscape can import PS and EPS, but only by converting them into PDF first, which requires the free cross-platform Ghostscript package (B.4 PostScript and EPS (Import, Export)) to be installed on your system. Exporting from Inkscape to PDF gives better results than exporting to PostScript.
Currently, Illustrator’s biggest rival is CorelDRAW. Like Illustrator, it is a large, full-featured application and is part of a suite of graphic applications. Here, however, the similarities end.
CorelDRAW has always positioned itself as a vector editor “for the rest of us.” Priced lower than Illustrator or Freehand (the main contender of Illustrator back in early 1990s, now bought out by Adobe and discontinued), CorelDRAW has always emphasized ease of use and, during the 1990s, greatly expanded the audience of vector editing tools. In some countries and communities, it was, and still is, more popular than Illustrator.
CorelDRAW pioneered some valuable UI concepts that were passed down to a number of other applications, including Inkscape. For example, the single Selector tool that can do all kinds of selections and transformations (move and scale, then click once and you can rotate and skew) first appeared in CorelDRAW; Illustrator and Freehand have separate “select,” “scale,” and “rotate” tools instead.
It has also introduced the notion of shapes (such as rectangles or ellipses) as separate object types, with the path editing tool acting differently on the shapes than on plain paths. Incredibly enough, Illustrator still has no concept of shapes; any rectangle in Illustrator is just a rectangular path, with no rectangle-specific properties.
CorelDRAW was, and still is, an impressive improvement over Illustrator in terms of usability. However, a lot more could be done in this area, as Xara Ltd., a small British company, managed to prove. In the mid-1990s, Xara ported its vector editor from the little-known Atari platform to Windows. The result was one of the most impressive debuts in computer graphics.
Xara’s vector editor scored a number of important firsts. It featured complete on-screen antialiasing, on-canvas editing of gradients with convenient handles, convenient transparency support, and a context-sensitive panel with controls relevant to the current tool (despite the obviousness of the idea, it’s something Illustrator didn’t have until version CS2). On top of that, Xara was very fast, which was especially important with the hardware of the day.
In general, Xara had followed the CorelDRAW UI paradigm (so much so that for a time, Corel even distributed Xara under the name of CorelXARA, as a kind of a little brother to its CorelDRAW). However, the advantage in usability Xara held over CorelDRAW was even greater than the latter’s advantage over the clunky Illustrator. Xara soon acquired a sizeable and very loyal user base. It’s no wonder Inkscape has borrowed a lot of ideas and approaches from Xara.
However, over the years, Xara’s novelty faded somewhat. Xara released several new versions, but so did its competitors, inventing new features and improving usability. By the mid-2000s, Xara was perceived by most people as a “nice little app”—very solid and usable, but somewhat passe.
In 2005, Xara Ltd. took an unprecedented step: It announced its plans to release as open source—and port to Linux—its flagship product, the vector graphic editor, whose most recent version was called Xara Xtreme. The Linux version was to be called Xara LX. This looked like, but actually wasn’t, one of the “better to be open source than abandonware” scenarios. Xara remained in business, continuing to sell the Windows version of Xara Xtreme as well as other graphic products.
Interestingly, one of the reasons for the plunge quoted by Xara Ltd. was the rapid progress of Inkscape. Although much younger than Xara, Inkscape already had some unique features. Apparently, Xara wanted to tap into the open source talent pool to revitalize its product. On the other hand, Inkscape developers had always acknowledged Xara, with its consistent interface design and excellent usability, as one if its role models. So, even though these two applications had been aware of each other before, now for the first time they met face-to-face as competitors.
Indeed, due to its presence on Linux and general similarity of the UI, Xara is currently Inkscape’s most direct competitor. At first, both projects declared themselves open and willing to exchange code and ideas, and there was even talk of an eventual merger. However, after the initial spurt of activity, Xara LX failed to attract significant attention from open source developers, mostly because Xara Ltd. refused to release as open source one crucial part of the code—the renderer. Currently at version 0.7, Xara LX is basically usable, but its future is unclear.
Compared to its commercial competition, Inkscape still scores low in several respects. Of the missing features, perhaps the most important is the lack of native CMYK support, which makes it hardly usable for creating files for print (8.2.2 CMYK). Also, Inkscape has no gradient meshes. This is a feature of AI and some other applications that allows different colors to be assigned to different points of a single object, with smooth transitions between the colors. Gradient meshes allow AI artists to create extremely photorealistic art with a minimum of objects. On the other hand, Inkscape already has some innovative features that are pretty much unique in its field, such as the clone tiler (16.6 Tiling Clones), 3D Box tool (11.3 3D Boxes), path effects (Chapter 12), and parts of the Tweak tool (8.7 Color Tweaking).
The most obvious reason why some features are not yet implemented in Inkscape is that they are missing in SVG. In particular, this is the case for the gradient meshes (although they are being considered for the next version of SVG standard). Similarly, Inkscape implements SVG’s linear and elliptic gradients (10.1 The Gradient Tool) but lacks other gradient types, such as conical supported by Xara. The same reason is behind the impossibility to create multiple-page documents in Inkscape. This is simply not provided for in the SVG standard at this time.
Fortunately, the only area where the limitations of SVG matter for Inkscape is the repertoire of basic object types. In its ways of manipulating these objects and combining them into higher-level objects, on the other hand, Inkscape is entirely free to innovate.
In interface and usability, Inkscape is often acknowledged to be quite easy to learn and work with. Inkscape’s UI is comparable, and in fact quite similar, to that of Xara. Some things are done more conveniently in one of these programs than the other, but both feature an unobtrusive, streamlined interface with a lot of easily accessible power.
As a true open source application, Inkscape is coded mostly by geeks, and geeks’ interests and priorities are sometimes quite different from those of commercial developers. For one thing, geeks hate dumbed-down interfaces and enjoy powerful controls and unlimited tweaking. They especially appreciate rich keyboard control, and Inkscape has an unprecedented number of keyboard shortcuts covering most of its modes, tools, commands, and features (Appendix D).
Not any less important than features and usability are an application’s stability and speed. Inkscape’s released versions may crash or freeze occasionally (save often!), but generally stability is not a concern for most users. Speed, however, is. Inkscape’s screen update speed is far from stellar, and although it is improving with every new version, it may very well become a problem with complex graphics.
Ironically, a few years ago when Inkscape was, overall, significantly slower than it is now, complaints about its speed were rare; in fact, most users considered it pretty snappy. Now, however, even though the screen update is faster and the program is much more responsive, complaints about Inkscape’s slowness and memory consumption are starting to really pile up.[4] The reason for this apparent paradox is simple: Inkscape has grown and matured enough to take on some really complex tasks, and artists using it on complex artwork start to hit the ceiling more and more often.
[4] Along with every speed optimization, there usually comes some exciting new feature that increases the performance demands again. This is what happened in version 0.45, for example. That release introduced interruptible display, so you don’t need to wait for it to finish redrawing the screen before you can issue a command. This greatly improved the responsiveness of the program. However, the same version also added Gaussian blur (17.1 Blur) which, especially in its original implementation, rendered dramatically slower than anything else in Inkscape. As a result, 0.45 received more complaints about slowness than any previous release.