SVG vs EPS: Modern Vector Against Print Legacy

Four-colour offset presses, screen-print shops that mix ink by hand, and embroidery digitizers all share one demand: the file must state which inks to use. An EPS can name Pantone 032 at 60% tint. An SVG, as specified, can only say a colour is approximately that red. That is the whole argument in miniature.

Both formats are vector, both are text-based, and both can hold essentially identical geometry. What separates them is what they were written to control, and that shows up most sharply in colour and text.

One is a program, the other is a document

EPS stands for Encapsulated PostScript. It is not a data format in the modern sense — it is a small PostScript program, complete with a header comment block, a bounding box declaration, and a body of drawing operators that a PostScript interpreter executes in order. Lines are drawn with moveto and lineto, fills with fill, and the whole thing is wrapped in %%BoundingBox comments so a host application can place it on a page.

SVG is XML. Elements nest, attributes carry values, and a renderer traverses the tree and paints what it finds. There is no execution model in the base language — the tree describes a final image, and the renderer decides how to produce it.

That distinction has a practical consequence for tooling. EPS requires a PostScript interpreter to render, which is why a modern design app can open an EPS and show you a low-resolution preview stored alongside the PostScript data while still getting the geometry right. SVG requires an XML parser and a rendering engine, both of which every browser already has.

Why the age of the format matters

EPS dates from the mid-1980s and has been frozen essentially since PostScript Level 3. It carries no concept of layers, no live transparency model that every consumer understands, and no standardised handling of embedded raster images beyond a preview convention. It works because the printing industry built its entire prepress toolchain around it, and because it can express exactly the things a press needs.

Colour: the decisive difference

SVG 1.1 defines colour in sRGB, and SVG 2 adds CSS colour syntax and ICC-based colour profiles through the color-profile element — but support for embedded ICC profiles in SVG renderers is thin and inconsistent. In everyday practice, an SVG is an sRGB device colour space document. Whatever CMYK interpretation you intended is lost the moment the file is saved.

EPS inherits PostScript's colour model directly. It can set a device CMYK colour with setcmykcolor, a spot colour through a Separation or DeviceN colour space, and a tint of a named ink. A prepress operator can open the file, see that a shape is Pantone 185 C at 80%, and plate it accordingly.

This matters in two concrete places. In offset printing, a client-supplied brand colour specified as a spot ink must survive to the plate — an RGB approximation of a Pantone match will not, because the press does not have that ink loaded. In screen printing, every colour is a physical screen and a physical ink; the file has to say how many and which ones.

Organic separation work on SVG artwork is possible, and tools exist to generate a separated SVG, but the format itself is still RGB at heart. For production work, PDF with Separation colour spaces or an EPS with named inks is the safer carrier.

Fonts and the outlining rule

Both formats can technically carry font data. In practice neither is dependable for it, and for opposite reasons.

An EPS that references a PostScript font will fail to render correctly on any machine that lacks that font, and the substituted output can shift line breaks and alignment. PostScript Level 3 allows a Type 3 or Type 42 font to be embedded, and some applications do it, but the results are inconsistent and the font licensing may forbid it anyway.

An SVG can carry live text, and the browser will substitute a fallback font of its own choosing if the specified family is missing. It can also reference a web font via CSS or an @font-face rule, but many SVG importers ignore those rules entirely. Illustrator will open the file, notice the missing font, and ask you to resolve it.

The answer is the same in both cases: convert text to outlines before delivery. Letterforms become ordinary paths, they render identically everywhere, and no font licensing question arises. You lose the ability to re-edit the wording, so keep the source document with live text as the master.

Transparency is where SVG wins

SVG handles alpha cleanly, on fills, strokes, groups, and via fill-opacity and opacity. Blend modes are available through mix-blend-mode in SVG 2 and have wide renderer support. Masks and clip paths are part of the base language.

EPS is much weaker here. PostScript Level 3 introduced smooth shading and some transparency support, but the flattened result is what most prepress workflows expect, because older RIPs cannot composite. If your artwork depends on a soft shadow over a gradient, an EPS pipeline will usually rasterise or flatten the region, and the rasterised region will carry an sRGB interpretation.

What print shops actually expect

Most modern commercial printers prefer PDF over either format. A PDF 1.4 file as defined by PDF/X-4 carries CMYK, spot colours, embedded fonts, and a real trim and bleed model. EPS survives as an accepted legacy format, particularly for logos that a client supplies to be placed into a larger layout.

Where EPS is still firmly expected: screen printing separations, some embroidery and apparel workflows, vinyl and sign shops that have used the same RIP for twenty years, and any client who has been sending EPS since 1998. If you cannot produce what the shop asks for, the job does not run, regardless of which format is technically better.

SVG is expected by a completely different audience: web developers, UI designers, cutting machines, and modern design tools. Sending SVG to a press is usually a mistake, and sending EPS to a web developer is a minor nuisance.

A practical conversion path

Converting SVG to EPS is straightforward geometry work: paths come across, and the header is generated around them. What does not survive automatically is colour intent — an sRGB value becomes a device RGB value, and you then have to decide how the shop converts it to CMYK. Ask for their profile rather than letting a generic conversion decide for you.

Our SVG to EPS converter handles the structural side. For a bitmap source, PNG to EPS traces and writes the PostScript in one step, and EPS to SVG runs the direction most people need after discovering that their client's EPS is actually a font-dependent mess.

The reverse trip, and the reason many teams end up in this article, is that a client hands over a 1990s EPS and the design team needs it on the web. That conversion is genuinely lossy in one direction only: colour comes back as sRGB, spot inks get approximated, and any rasterised regions stay raster inside the SVG.

Units, bounding boxes and placement

EPS carries a bounding box in its header comments, and that box is what a layout application uses to place the file on a page. If the bounding box is wrong — larger than the artwork, or offset — the EPS will appear with unexpected white margins or overlapping neighbouring elements. Designers hit this constantly with logos placed on business cards.

SVG's equivalent is the viewBox plus width and height, and it has the opposite failure mode: a missing viewBox means there is no defined extent, so different viewers crop differently. Neither format enforces correctness; both rely on the producer to declare the bounds accurately.

A second placement complication is scale. An EPS is in PostScript units, which are points at 72 per inch. An SVG's user unit maps to CSS pixels at 96 per inch. A shape described identically in both — say 100 units wide — renders at 100 points in EPS and 100 pixels in SVG. If the SVG also declares width in millimetres, the number means something concrete; if it does not, the receiving application picks. When you convert between them, confirm the ratio rather than assuming the numbers carry over unchanged.

What each format does well outside its home ground

SVG's advantage beyond the browser is that it is trivially manipulable. Because it is XML, a script can recolour every path with a given ID, a build step can inline it into a page, and a CMS can store it as text. Nothing about EPS invites that treatment — a PostScript program is not something you safely transform with a regex.

EPS's advantage beyond prepress is that it is a self-contained page fragment with a declared bounding box, which makes it a natural drop-in asset for older page layout tools. QuarkXPress and InDesign both handle EPS placement with predictable results, including the clipping path that hides the raster preview.

The raster preview problem

Many EPS files carry two representations: the PostScript data, and a low-resolution raster preview used for on-screen display. If the PostScript interpreter is unavailable — which is common in newer software — the application shows the preview instead, and the user sees a soft, pixelated image while the file is actually perfect vector.

This is a source of enormous confusion. A blurry EPS on screen does not mean the file is raster. It means you are looking at the placeholder. Print output uses the PostScript data and is sharp. Conversely, a genuinely raster EPS shows a preview that looks identical to the print output, which is one way to tell them apart: if the print is soft too, the vector was never there.

Practical delivery notes

When sending an EPS to a shop, include the ink list explicitly in the accompanying message. The file can carry named inks, but the shop still has to confirm they have them mixed or loaded. Include the intended finished size, because the bounding box alone does not tell a press operator how large the piece should print.

When sending an SVG to a developer, strip the editor metadata. Illustrator and Inkscape both write namespaced attributes and comments that inflate the file and occasionally confuse importers. Our SVG optimisation guide covers what to remove.

Deciding between them

Send EPS when the destination is a press, a screen-print separation workflow, or a shop that names it explicitly. Send SVG when the destination is a browser, an application, a laser or vinyl cutter, or any pipeline that needs to stay editable and CSS-styleable.

If you are unsure what format a print job needs, our comparison of SVG and PDF for print covers what survives a press workflow in more depth, and the file format reference puts EPS in context alongside AI, PDF and DXF.