This may be captain obvious stuff to many, but it's likely to be helpful somebody to know how Cups differs from the older print setups.

Before cups, there was lpr (or lp, which is different, but more similar than different.) By default, lpr just took whatever was fed to it and fed it to the printer, and it handled things like networking, queuing, etc. so the users didn't have to worry about that. (Or if you do want to worry about that, "cat file.ps > /dev/lp0", but I digress.)

The de facto standard print formats in Unix has typically either been just plain text or PostScript. Not that Unix forced you to pick from these two options, but if you got a general purpose printer they usually either did plain text or PostScript.

lpr does have the abilty to add filters, and you could use these filters to convert from one format to another, so you'd often set up a filter to convert text to postscript (and perhaps further customize that), or do printer accounting or whatnot, but for the most part this stuff was something a sysadmin worked out themselves and edited lpr.conf to support.

Enter cups: Cups changed this greatly, and its default (most common?) filter mechanism is to accept Postscript or text input (so it's backwards compatible with the older stuff) and feed this to ghostscript which executed the postscript (postscript = code, after all) and converted it to a bitmap (a bitmap is the lowest common denominator, anyways -- it might be smarter than that), and then the bitmap was fed to the printer via whatever the printer's language is.

(Side note: I think Windows works similarly, except that it has its own printer language rather than PostScript that is fed into the printer driver, and then the printer driver emits something correct for that specific printer.)

This is super flexible, and allows Unix to use pretty much any printer out there that Ghostscript can emit a bitmap in the right format for (which is pretty much all of them.) But it takes some of the control away from the source program, which is less important for just printing on a page, but more important for a label printer like those using ZPL where precise control of every aspect of the output is important.

But cups supports that too -- just disable all the drivers (filters) and have it feed what it gets directly to the printer, just like lpr did. It's not the default, but it's there and works fine once you realize that it's there. (It would not surprise me if Ghostscript supports ZPL printers too, so it may even sort of work if you try to set things up in the "usual" way, but it's helpful to understand why this may not be the best.)

And as a side note, it's worth mentioning that the standard "dumb" print server just listens on port 9100/tcp (this may be called the "jetdirect protocol" and feeds whatever it gets to the filter, exactly as-is. (This may sound insecure, and it is -- that's why you filter what can reach these ports.) But it's super useful for troubleshooting -- print to a file, then "cat file | nc printer 9100" will often make your file print, assuming that file is in the right format for that printer.)