Command Support Matrix

Every ZPL command the parser recognizes, its published status, and a note wherever the behavior differs

This page lists the 231 ZPL commands the compatibility layer recognizes, in the 16 categories the command reference uses. Today that is 81 supported, 15 partial, 113 ignored, 7 planned and 15 unsupported.

Each command links to its reference page, which gives the syntax, the parameter table, and the measured differences between the renderer, Labelary and the specification.

Status legend

Status	What it means
`supported`	Renders the same output Labelary does, for every documented parameter.
`partial`	Renders, but a named parameter, mode or fidelity caveat applies.
`ignored`	Recognized and deliberately skipped because it cannot affect a rendered label (device, host, network, RFID configuration). Matches Labelary.
`planned`	Rendering-relevant and not implemented yet. Where the work is scheduled, the status names the milestone that will close it; where it is not, the note says the gap is acknowledged but unscheduled.
`unsupported`	Rendering-relevant and not implemented, with no intention to — almost always because Labelary does not implement it either, so there is no compatibility target. The note says what to use instead.

A planned row reads planned (5.6) where a milestone closes the gap. A bare planned means the gap is known and not yet scheduled.

Coverage legend

The coverage column says how much of the documented behavior of a command has a test behind it. For each command the count includes:

every documented difference or support note;
the minimum, the maximum and one step outside every documented numeric range;
every documented value of an enum parameter;
every parameter whose bad-argument behavior the data states.

The fraction is the tested items out of the documented items, and is relative to one command's surface. A two-parameter command can read full where a twelve-parameter barcode command with the same number of tests reads partial.

Coverage	What it means
`full`	Every documented statement, bound, value and invalid-value behavior has a test that counts as coverage.
`partial`	Some do. The fraction is obligations pinned out of obligations documented.
`none`	The command documents things a test could pin, and no test pins any of them.
`nothing`	The data documents no statement, bound, value or invalid-value behavior, so there is nothing to pin.
`n/a`	Coverage is not a meaningful question: the command does not render.
‡	A `content` or `blocking` known issue is attributed to this command, so the bucket is downgraded one step: output we know to be wrong is published as a caveat, never as evidence.
†	A `cosmetic` known issue is attributed to this command. It counts as coverage and the caveat is published alongside it.

Today 96 of the 231 commands render. Across those commands, 410 of 1234 documented behaviors have a test. The suite has 2143 annotated tests, which carry 2232 annotations. A low number measures the test annotations, not the renderer. Annotation of the existing suite is in progress.

Format control

Commands that start and end a label, store and recall formats, and change the characters ZPL itself uses.

Command	Name	Status	Coverage	Notes
`^XA`	Start Format	`supported`	`full` 1/1
`^XZ`	End Format	`supported`	`nothing`
`^XB`	Suppress Backfeed	`ignored`	`n/a`	Controls the media in the printer's mechanism, which cannot change the image. Both engines ignore it.
`^DF`	Download Format	`supported`	`none` 0/6	The renderer stores every command between `^DF` and `^XZ` under the named path, and prints no page for the label that carries the definition. The path is a `d:o.x` triple whose device letter is resolved through `^CM`, and whose extension defaults to `ZPL` rather than to the `GRF` a graphic takes. `^JB` erases a stored format; `^EG` does not. Measured against Labelary on 2026-08-20.
`^XF`	Recall Format	`supported`	`partial` 1/7	The renderer replays the stored format at the point the command stands, and binds each `^FN` placeholder inside it to the `^FN` and `^FD` pair the recalling label carries. A recall of a path that holds no format reports that the file does not exist. Measured against Labelary on 2026-08-20.
`^HF`	Host Format	`ignored`	`n/a`	Returns data over the printer's link rather than changes the label. Both engines ignore it.
`^CC / ~CC`	Change Caret	`supported`	`none` 0/3
`^CD / ~CD`	Change Delimiter	`supported`	`none` 0/3
`^CT / ~CT`	Change Tilde	`supported`	`none` 0/3

Fields

Commands that place a field, supply its data, and control how the renderer wraps, rotates and reverses it.

Command	Name	Status	Coverage	Notes
`^FO`	Field Origin	`supported`	`partial` 10/14
`^FT`	Field Typeset	`partial`	`partial` 10/15	An omitted coordinate continues from the previous field, the guide's default. Only text and `^GS` fields move that position.
`^FD`	Field Data	`supported`	`none` 0/4 †
`^FS`	Field Separator	`supported`	`nothing` †
`^FB`	Field Block	`supported`	`none` 15/26 ‡
`^FH`	Field Hexadecimal Indicator	`supported`	`none` 0/2
`^FN`	Field Number	`supported`	`partial` 2/6	Inside a stored format the command marks the place a value goes. On recall the renderer replaces it with the data the recalling label gives that field number. A field number the recall does not bind renders nothing. Measured against Labelary on 2026-08-20.
`^FV`	Field Variable	`supported`	`partial` 3/7	A `^FV` field prints exactly what the equivalent `^FD` field prints, so the two differ only under `^MCN`, where the renderer clears the variable field and carries the fixed one into the next label.
`^FW`	Field Orientation	`partial`	`partial` 10/13	The rotation argument works, and the justification argument accepts `0` (left) and `1` (right) as well as the letters; `2` (auto) falls back to the default, which is how Labelary renders it.
`^FR`	Field Reverse Print	`supported`	`partial` 2/2 ‡	The field inverts as one mask wherever `^FR` stands in it, so a `^GS` mark that crosses itself inverts once. A field whose content is an image does not reverse yet.
`^FX`	Comment	`supported`	`none` 0/1
`^FP`	Field Parameter	`supported`	`partial` 9/14 †
`^FC`	Field Clock	`supported`	`partial` 2/4
`^FE`	Field Data Embed Character	`ignored`	`n/a`	The parser reads the embed character, and the renderer gives it no effect, because Labelary gives it none either. A field carrying `^FE` renders identical to the same field without it, measured pixel for pixel on 2026-08-22. Reading the slot is what raises the argument report on a value longer than one character. The ZPL II Programming Guide does not index the command, so Labelary's table is the only documentation.
`^FL`	Font Link	`ignored`	`n/a` ‡	The parser reads both font paths and the link indicator, and the renderer makes no link, because no font this command can name is one the renderer draws with. Only a `TTF` or `TTE` file can be linked, and no resident font is one: `^A@` answers `File 'Z:TT0003M_.TTF' does not exist` for the TrueType path a printer carries, measured 2026-08-22. So the extension font is always one a `~DY` or `~DU` download placed on a device, and the renderer does not read a downloaded font file. Reading the slots is what raises the argument reports Labelary raises.
`^FM`	Multiple Field Origin Locations	`supported`	`partial` 1/8

Fonts and text

Commands that choose a font for a field, set the format's default font, download fonts and control character encoding.

Command	Name	Status	Coverage	Notes
`^A`	Scalable / Bitmapped Font	`partial`	`partial` 20/36 †	The renderer honors every font slot, rotation and size, and the character cells match Labelary's. But slots `D` and `H` draw in the font `0` typeface rather than a monospaced face and OCR-A. So letter shapes and text widths differ, which can change where a line wraps or clips. A height below 10 dots also scales literally here, where Labelary floors it at 10. The typeface gap is an asset-licensing matter for the font-matching work, not a parser defect.
`^A@`	Use Font Name to Call Font	`supported` (5.9)	`none` 1/10 ‡	`^A@` resolves a path on `Z:` to the built-in font it names and draws the field in it, at the requested height, width and orientation. A path a `~DY` font download occupies resolves too and reports nothing, as on Labelary, but the face is not drawn with: the field prints font A. A path this printer has no font for reports `RESOURCE_MISSING` and draws font A, which is what Labelary does.
`^CF`	Change Alphanumeric Default Font	`supported`	`partial` 3/16
`^CI`	Change International Font / Encoding	`partial`	`partial` 6/35	The renderer honors encodings 0–17, 24, 26–31 and 33–36. A number outside that set defaults to encoding 0 and reports `ARGUMENT_INVALID` with the value. Earlier versions aborted the render. The parser reads the character remapping (`s1,d1,…`) and ignores it.
`^CW`	Font Identifier	`supported` (5.9)	`none` 0/3 ‡	A letter aliased to a path on `Z:` selects that built-in font for `^A` and `^CF` alike, and the alias outlives the format that set it. A path a `~DY` font download occupies is accepted and reports only the remapping note, as on Labelary, but no alias to a downloaded face is made. A path this printer has no font for is rejected with `RESOURCE_MISSING` and leaves the letter as it was, which is what Labelary does.
`~DB`	Download Bitmap Font	`unsupported`	`n/a`	Labelary does not support it either, so no compatibility target exists. Fields with the downloaded font default to a built-in font.
`~DE`	Download Encoding Table	`unsupported`	`n/a`	Labelary does not support it either. Use `^CI28` and UTF-8 field data instead of a custom encoding table.
`~DS`	Download Scalable Font	`unsupported`	`n/a`	Labelary does not support it either. Fields with the downloaded font default to a built-in font.
`~DT`	Download TrueType Font	`unsupported`	`n/a`	Labelary does not support it either. Text for the downloaded typeface renders in a built-in font, so its metrics and line breaks differ.
`~DU`	Download Unbounded TrueType Font	`planned` (5.9)	`n/a` ‡	The renderer does not parse this command yet. It serves CJK and other large character sets, so affected text defaults to a built-in font that can lack the glyphs.
`^TB`	Text Block	`supported`	`partial` 6/18
`^PA`	Advanced Text Properties	`planned` (5.9)	`n/a` ‡	The renderer does not parse this command yet. No font here carries a Hebrew or Indic glyph, so those scripts draw nothing; Arabic draws unjoined isolated forms on the faces that carry it.
`^SE`	Select Encoding	`unsupported`	`n/a`	Labelary does not support it either, and it depends on `~DE`, which the renderer also does not support. Use `^CI28` with UTF-8 field data instead.

Bar codes

Commands that turn a field into a bar code symbol, plus the ^BY defaults that every one of them inherits.

Command	Name	Status	Coverage	Notes
`^BY`	Bar Code Field Default	`supported`	`partial` 6/13
`^B3`	Code 39 Bar Code	`supported`	`partial` 11/19
`^BC`	Code 128 Bar Code	`partial`	`partial` 17/26	All four modes render, and mode `U` defaults its interpretation line above the symbol. One behavior is absent. The renderer parses the `e` GS1 check-digit argument but never applies it, which changes the printed label. Write the `e` check digit into the data.
`^B2`	Interleaved 2 of 5 Bar Code	`supported`	`partial` 1/19
`^BI`	Industrial 2 of 5 Bar Code	`supported`	`partial` 10/16
`^BJ`	Standard 2 of 5 Bar Code	`supported`	`partial` 9/16
`^B1`	Code 11 Bar Code	`supported`	`partial` 11/19
`^BA`	Code 93 Bar Code	`supported`	`partial` 10/19
`^BK`	ANSI Codabar Bar Code	`supported`	`partial` 8/28
`^BL`	LOGMARS Bar Code	`supported`	`partial` 1/14	The renderer always prints the interpretation line for LOGMARS, so no argument suppresses it. The third argument chooses only whether the line sits above the symbol or below.
`^BM`	MSI Bar Code	`supported`	`partial` 1/24
`^BP`	Plessey Bar Code	`supported`	`partial` 2/19
`^B8`	EAN-8 Bar Code	`supported`	`partial` 10/18
`^BE`	EAN-13 Bar Code	`supported`	`partial` 11/18
`^BU`	UPC-A Bar Code	`supported`	`partial` 2/19
`^B9`	UPC-E Bar Code	`supported`	`partial` 11/20
`^BS`	UPC/EAN Extension	`supported`	`partial` 1/15
`^BR`	GS1 DataBar Bar Code	`supported` (5.6)	`partial` 16/37	All twelve symbology types render, and every one of them takes the 2D composite component a `\|` in the field data introduces. Type 8, UPC-E, is reported rather than drawn, which is parity: Labelary draws no UPC-E for any payload.
`^B5`	Planet Code Bar Code	`supported`	`partial` 11/17
`^BZ`	Postal Bar Code	`supported`	`partial` 7/20
`^BQ`	QR Code Bar Code	`partial`	`partial` 5/28	Model 2 renders, with the error correction and input mode from the `^FD` prefix. The renderer does not implement model 1, mixed mode and Kanji mode. Labelary does not implement them either, so there is no compatibility gap. The renderer parses the `m` model argument and ignores it.
`^BX`	Data Matrix Bar Code	`partial`	`partial` 5/35	ECC 200 symbols render at the requested module size. The `c` argument selects a square symbol size, and the `g` argument turns on the field-data escape sequences. The renderer parses the other sizing arguments `r`, `f` and `a` and ignores them. The renderer does not implement the older quality levels. Labelary supports quality 200 only. That part is not a compatibility gap.
`^B7`	PDF417 Bar Code	`supported`	`partial` 5/26
`^BF`	MicroPDF417 Bar Code	`supported`	`partial` 4/13
`^BO`	Aztec Bar Code	`supported`	`partial` 8/24
`^BD`	UPS MaxiCode Bar Code	`partial`	`partial` 3/16	The symbol renders, including the modes 2 and 3 carrier header read off the head of the field data. Where two code-set switch sequences cost the same, the encoder picks a different one from Labelary. A symbol carrying mixed-case data then holds the same message in a different pattern of modules. The renderer does not implement structured append: it parses `n` and `t` and ignores them. Each symbol in a multi-part sequence renders as a single symbol.
`^B4`	Code 49 Bar Code	`unsupported`	`n/a`	Labelary does not implement `^B4` either, so there is no compatibility target to match and no plan to add one. The renderer draws nothing and reports a diagnostic. Use `^B7` PDF417 or `^BX` Data Matrix instead; both hold more data and scan more reliably.
`^BB`	Codablock Bar Code	`unsupported`	`n/a`	Labelary does not implement `^BB` either. There is no compatibility target to match, and there is no plan to add one. Use `^B7` PDF417 or `^BX` Data Matrix. Both hold more data in less space.
`^BT`	TLC 39 Bar Code	`unsupported`	`n/a`	Labelary does not implement `^BT` either. There is no compatibility target to match, and there is no plan to add one. A `^B3` field and a `^BF` field together are the closest equivalent.

Graphics and images

Drawing primitives, and the commands that download, store, recall and delete image objects.

Command	Name	Status	Coverage	Notes
`^GB`	Graphic Box	`supported`	`none` 6/19 ‡
`^GC`	Graphic Circle	`supported`	`partial` 7/12
`^GD`	Graphic Diagonal Line	`supported`	`partial` 12/22
`^GE`	Graphic Ellipse	`supported`	`partial` 9/16
`^GF`	Graphic Field	`partial`	`partial` 6/22	Compression types `A` and `B` render, including the `:Z64:`/`:B64:` and ACS-repeat encodings of an `A` payload. The renderer rejects type `C`, as Labelary does.
`^GS`	Graphic Symbol	`partial`	`partial` 10/19	All five symbols render as glyphs of the symbol face, the way Labelary sets them, so each mark matches stroke for stroke. Under `^FR` every symbol inverts once, crossings included. The one gap left is the default size: an omitted height or width takes the minimum here and the last `^CF` on Labelary.
`~DG`	Download Graphic	`supported`	`partial` 1/14
`~DN`	Abort Download Graphic	`ignored`	`n/a`	The renderer accepts it and does nothing. A download is complete or absent by the time the parser reads the label, so nothing remains to abort.
`^EG / ~EG`	Erase Download Graphics	`supported`	`none` 0/1
`^HG`	Host Graphic	`ignored`	`n/a`	Sends data back over the printer's serial link, which means nothing for a rendering API. The renderer ignores it, as Labelary does.
`^ID`	Image Delete	`partial`	`none` 0/6 †	Deletes by exact object name. The renderer does not implement the asterisk wildcard, so `^IDR:*.GRF` deletes nothing.
`^IL`	Image Load	`supported`	`full` 4/4	The background is drawn under everything else the format draws, wherever the `^IL` stands in it, and takes its position from `^LH` alone. An `^IL` naming a label saved by `^IS` still finds nothing, because `^IS` stores no raster.
`^IM`	Image Move	`supported`	`none` 0/5	The renderer recalls the stored graphic at the field origin, the same way `^XG` does with both magnification factors at one. `^IM` takes a single parameter, the object path, so text written after it is unrecognized content and not a magnification factor.
`^IS`	Image Save	`partial` (5.9)	`none` 0/8	The renderer reads the path and acts on the print flag: `^ISd:o.x,N` saves without printing, so the format renders no output page. The raster itself is not stored, so a later recall of the saved name finds nothing.
`^TO`	Transfer Object	`supported`	`partial` 2/4
`^XG`	Recall Graphic	`supported`	`none` 0/13	The renderer recalls the graphic and applies both magnification factors, replicating each stored dot into a block of that width and height. A factor outside 1 to 10 resets to 1, matching Labelary.
`~DY`	Download Objects	`partial` (5.9)	`none` 8/20 ‡	The renderer stores a raw bitmap (`x` of `G`) sent as ASCII hex or raw binary, and recalls it like a `~DG` object. A font download (`x` of `T`) is validated and stored, so `^A@` and `^CW` resolve it, but no field draws with the face yet. A `.BMP` or `.PNG` download is parsed and reported rather than stored, so a label that downloads one this way loses that object.

Label geometry

Where the label's origin sits, how big it is, and which way round it prints.

Command	Name	Status	Coverage	Notes
`^LH`	Label Home	`supported`	`partial` 2/10
`^LL`	Label Length	`ignored`	`n/a`	The parser reads it, and the renderer ignores it, because Labelary ignores it too. The page size comes from the dimensions in the API request, not from the label. Regression snapshots pin this, so no one "fixes" it into a divergence.
`^LS`	Label Shift	`supported`	`partial` 2/4
`^LT`	Label Top	`supported`	`partial` 4/5
`^LR`	Label Reverse Print	`supported`	`partial` 2/3
`^PO`	Print Orientation	`supported`	`partial` 2/3
`^PW`	Print Width	`partial`	`partial` 4/8	The renderer honors this only as a centering offset: a narrower print width centers the content horizontally. It clips only the page an extra-page command injects, and never resizes the page. A width wider than the requested label clamps to the label width, centers nothing, and renders as though no `^PW` were present. That matches Labelary.
`^PM`	Print Mirror Image	`supported`	`none` 0/4 †	The parser reads the flag and the renderer applies it. `^PMY` mirrors the finished page left-to-right about the page's own vertical centerline, so a box drawn 50 dots from the left edge lands 50 dots from the right one. It mirrors the rendered result and not the layout. Glyphs, barcode modules and the human-readable line under a barcode are all reversed along with their positions. The flip is about the page width and not the `^PW` window's, so the window's centering happens first and the whole page turns over after it. The command reaches the whole page from anywhere in the format, with no `^FS` boundary of the kind `^JM` has, and a `^PM` outside a format never lands. The mirror is a printer setting and survives `^XZ` until a later `^PMN` takes it back. It composes with `^POI` commutatively into a plain vertical flip, and `^JMB`'s magnification is applied after it. Measured against Labelary on 2026-08-21 at 6, 8 and 12 dpmm.
`^ML`	Maximum Label Length	`ignored`	`n/a`	A media-detection setting for the printer's gap sensor, which cannot change the image. Both engines ignore it.
`^MU`	Set Units of Measurement	`supported`	`partial` 9/18

Print control

Commands that drive the print engine: quantity, speed, darkness, feed and pause. Only ^PQ changes what comes back; the rest are printer mechanics.

Command	Name	Status	Coverage	Notes
`^PQ`	Print Quantity	`partial`	`partial` 6/22	The renderer applies the label count: `^PQ3` returns three identical pages and counts as three in `X-Total-Count`. It also applies the replicates argument `r`, but only where it is observable, which is a label carrying `^SN`: `r` sets how many pages one serialized value occupies. The remaining three arguments are printer mechanics that the parser reads and the renderer ignores.
`^MC`	Map Clear	`supported`	`partial` 2/5	The parser reads the flag and the renderer applies it. `^MCN` carries the finished label's content into the next label, `^FV` fields excepted, so a format can draw its fixed frame once and resupply only the variable data. Map clear is a printer setting, so one `^MCN` goes on carrying content over label after label. The setting in force at a label's own `^XZ` decides whether that label carries over. An omitted or a rejected value keeps the setting already in force. A `~JA` or `~JX` canceled format prints no page of its own. The ink it had already laid down still carries over, while what it drew after the cancel is lost. Carried-over content is part of the page it lands on: `^POI` turns it with the rest of that label, and the consuming label's `^LH` moves only its own fields. Measured against Labelary on 2026-08-20.
`^JM`	Set Dots per Millimetre	`supported`	`partial` 1/5	The parser reads the density letter and the renderer applies it. `^JMB` halves the printhead's dot density, so one ZPL dot covers two device pixels and every coordinate, dimension, font height and barcode module doubles. The page keeps the size the request asked for, so a label authored for full density overflows it and the overflow is clipped, which is what Labelary does. The magnification reaches the finished page geometry and not the arguments. `^MU`'s inch and millimeter conversions still divide by the head's real resolution. The `^PW` window is still centered on the unscaled page width. The density is a printer setting and survives `^XZ` until a later `^JMA` takes it back. A `^JM` outside a format is ignored silently, and one past the format's first `^FS` is ignored with Labelary's own report. Measured against Labelary on 2026-08-20 at 6, 8 and 12 dpmm.
`^PH / ~PH`	Slew to Home Position	`supported`	`none` 0/2	The renderer feeds the slewed blank label as an output page ahead of the format that carries the command, wherever inside the format the command sits, and counts that page in `X-Total-Count`. A second `^PH` in one format feeds no second page. A `^PQ` in the same format replicates the label alone, so `^PH` with `^PQ3` gives four pages. A format that draws nothing still feeds the page its `^PH` asked for, and `~PH` sent with no format at all feeds one page on its own (all measured 2026-08-15).
`^PR`	Print Rate	`ignored`	`n/a`	The parser reads this command and the renderer ignores it, as Labelary does. Speed is a motor setting that cannot change the image.
`^PF`	Slew Dot Rows	`supported`	`partial` 3/6	The parser reads the count and the renderer blanks the band. `^PFr` runs the bottom `r` dot rows of the label past the head without printing them, so the page comes back blank over `[H - r, H)` where `H` is the page height in dots. On a 4 by 6 inch label at 8 dpmm, 1218 dot rows tall, `^PF200` blanks rows 1018 to 1217. Nothing rounds the cut to a field boundary, so a field that straddles the boundary prints through the middle of its glyphs. The slew applies at `^XZ` however early in the format the command stands, and there is no `^FS` boundary. The last `^PF` in the format wins and the counts do not add up: `^PF60^PF60` is one 60-row band. `H` is the page height and not `^LL`, and `^LH` does not shift the band. `^MU` converts the count, so `^MUi^PF1` slews 200 dot rows at 8 dpmm. The setting belongs to the format and does not survive `^XZ`, and a `^PF` outside a format never lands. Under `^POI` the band is turned over with the content, so it comes out at the top of the paper. `^JMB`'s magnification is applied after the cut, which moves the boundary to `2 * (H - r)`. Measured against Labelary on 2026-08-21.
`^PN`	Present Now	`ignored`	`n/a`	This command drives the media out of the printer, and a render has none. Labelary is also unaffected: `^PN100` changes neither the image nor the page count (measured 2026-07-30). The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~PL`	Additional Present Length	`ignored`	`n/a`	A media-handling distance, which cannot change the image. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^SP`	Start Print	`ignored`	`n/a`	A latency optimization for complex labels on real hardware. It splits the print into segments and does not change their content, so the image is identical. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^JZ`	Reprint After Error	`ignored`	`n/a`	Error recovery is a printer function. A render either succeeds or returns an error. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^ZZ`	Printer Sleep	`ignored`	`n/a`	Power management, with no effect on a rendered label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^MD`	Media Darkness	`ignored`	`n/a`	Darkness controls how much heat the printhead applies. The output of the renderer is pure black and white. There is no darkness to change. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~SD`	Set Darkness	`ignored`	`n/a`	As with `^MD`, there is no darkness to set in a monochrome raster. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^SZ`	Set ZPL Version	`ignored`	`n/a`	The renderer and Labelary always interpret ZPL II, and Labelary's command table says "version 2 only". Both engines render a version 1 format as version 2: no compatibility gap, only a shared limitation. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^PP / ~PP`	Programmable Pause	`unsupported`	`n/a`	A pause has no meaning for a request that renders and returns. Labelary does not support it either, so no compatibility target exists.
`~PS`	Print Start	`unsupported`	`n/a`	The other half of `^PP`, unsupported for the same reason. Labelary does not support it either.
`~PR`	Applicator Reprint	`unsupported`	`n/a`	A reprint needs a previous label. A stateless render does not have a previous label. Labelary does not support this command either. This command is different from `^PR`, which sets the print rate.

Media and sensors

How the printer handles the stock: media type, label tracking, sensor thresholds and calibration. None of it reaches the image, so the renderer recognizes every command here and ignores it.

Command	Name	Status	Coverage	Notes
`^MF`	Media Feed	`ignored`	`n/a`	The parser stores this command as `MfCommand`, and nothing reads it. Both arguments are inert: they describe what the motor and the media sensor do before any format, which cannot reach the image. The parser reads it, so the renderer reports no unsupported-command warning, unlike the unparsed media commands below.
`^MM`	Print Mode	`ignored`	`n/a`	The parser stores this command as `MmCommand`, and nothing reads it. Every mode describes where the media goes after the print, so the image is the same in all modes. The parser reads it, so the renderer reports no unsupported-command warning, unlike the unparsed media commands below.
`^MN`	Media Tracking	`ignored`	`n/a`	The parser stores this command as `MnCommand`, and nothing reads it. On a printer this setting decides where one label ends. With gap or mark tracking the sensor finds the break; with continuous media (`^MNN`) the length comes from `^LL`. Neither route reaches the output. The parser gives `^LL` no effect on purpose, and the page size comes from the API request dimensions. The parser reads it, so the renderer reports no unsupported-command warning, unlike the unparsed media commands below.
`^MT`	Media Type	`ignored`	`n/a`	The parser stores this command as `MtCommand`, and nothing reads it. The choice decides whether the printer expects a ribbon, and the renderer has neither ribbon nor stock. The parser reads it, so the renderer reports no unsupported-command warning, unlike the unparsed media commands below.
`~JL`	Set Label Length	`ignored`	`n/a`	The printer measures the length as it feeds blank media past the sensor, and draws nothing. The page size comes from the dimensions in the API request, so a measurement has nothing to set here. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^JS`	Sensor Select	`ignored`	`n/a`	This command selects the hardware that tells the printer where the label break is. A render has no sensor and no media. This command is not the same command as `~JS`. The command `~JS` sets the backfeed sequence. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~JS`	Change Backfeed Sequence	`ignored`	`n/a`	Backfeed pulls the media back so the next label starts in the correct place under the printhead. This command moves media and does not change the image. It is not `^JS`, which selects the media sensor. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^SS`	Set Media Sensors	`ignored`	`n/a`	This command replaces the values `~JC` measures. All nine arguments describe how the sensor hardware reads the stock, which cannot change the image. The label-length argument looks like an exception. It sets the calibrated length of the printer, and the page size comes from the dimensions in the API request. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^SI`	Set Sensor Intensity	`ignored`	`n/a`	A narrower version of `^SS`. It adjusts one sensor reading, not all nine, and tunes hardware that a render does not have. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~JC`	Set Media Sensor Calibration	`ignored`	`n/a`	This command feeds blank media to find the sensor thresholds and the label length. Every result is a printer setting, and the media carries no image. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~JG`	Graphing Sensor Calibration	`supported`	`none` 0/2	The only command here that prints its own output. The renderer prints the graph as a page ahead of the format carrying the command, wherever in the format it sits, and counts it in `X-Total-Count`. A second `~JG` prints a second page, each format carrying one prints its own, and `^PQ` replicates the label alone. Labelary has no sensors to read, so the graph is empty: five numbered rules, a zero line and one sentence. Only the label size reaches the drawing, setting how long the rules are and how far apart. A `^PW` ahead of the `~JG` centers the page in the print window and cuts the rest away. A `^POI` ahead of it turns the page over. Either one after the `~JG` leaves the page alone (measured 2026-08-16). Only `~JG` is a command.
`^XS`	Set Dynamic Calibration	`ignored`	`n/a`	This command decides whether the printer recalibrates the length, threshold and gain during the print. A recalibration changes printer settings, never the image. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~TA`	Tear-Off Adjust Position	`ignored`	`n/a`	This command moves the media and not the printed image, so unlike `^LT` it moves no field on the label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^CN`	Cut Now	`ignored`	`n/a`	This command operates the cutter. A render has no cutter and no media to cut. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^CP`	Remove Label	`ignored`	`n/a`	This command clears a label that an operator did not take. It moves finished media and cannot change the image on it. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^JW`	Set Ribbon Tension	`ignored`	`n/a`	Ribbon tension changes how evenly the ink transfers on real stock. The renderer draws a monochrome raster with no ribbon to tune. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.

Serialisation

The two commands that make a field's data change from one printed copy to the next. ^SN supplies the data itself and counts in decimal; ^SF lays a per-character mask over the data the field already carries.

Command	Name	Status	Coverage	Notes
`^SF`	Serialization Field	`supported`	`partial` 4/7 †	The renderer parses `^SF` and advances the data of the field it sits in, once per copy `^PQ` prints. Each mask character counts its position through its own alphabet, a carry runs leftwards through the held positions and stops at the region's left edge, and the increment is read one character per position. `^PQ`'s replicates argument `r` sets how many output pages share one value. Labelary's report about a mask or increment width that differs from the field data has no counterpart here. Measured against Labelary on 2026-08-21.
`^SN`	Serialization Data	`supported`	`partial` 2/7	The renderer parses `^SN` and uses it as the field's data in place of `^FD`. The right-most run of at most twelve digits advances by `n` once per copy, wraps inside the width of that run, and keeps every character around it. With `z` set to `N` the leading zeros of that run print as spaces. `^PQ`'s replicates argument `r` sets how many output pages share one value. Measured against Labelary on 2026-08-20.

Real-time clock

Commands that configure the printer's clock, which is what a ^FC field prints. ^ST moves the primary clock, ^SO defines the two offset clocks, and ^SL chooses the language of the names.

Command	Name	Status	Coverage	Notes
`^SL`	Set Mode and Language (for Real-Time Clock)	`supported`	`partial` 2/29
`^SO`	Set Offset (for Real-Time Clock)	`supported`	`partial` 2/30
`^ST`	Set Date and Time (for Real-Time Clock)	`supported`	`partial` 5/31
`^KD`	Select Date and Time Format (for Real-Time Clock)	`ignored`	`n/a`	The renderer recognizes and ignores it. It sits in the clock family, but affects only the front-panel display and the printer's configuration labels, not the date a `^FC` field substitutes. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.

Memory and storage

Commands that reorganize, clear or cache the printer's storage devices. The renderer keeps one in-memory object store, keyed by the device letter, the object name and the extension together, so a reformat or a letter remap changes which object a later recall finds, as it does on Labelary.

Command	Name	Status	Coverage	Notes
`^CM`	Change Memory Letter Designation	`supported`	`partial` 2/29	The parser reads the four device letters and the renderer applies them. A `~DG`, `^XG`, `^ID` or `^JB` letter is resolved through the map this command maintains, so an object stored on `R:` is recalled as `E:` after `^CMB,R,E,A` and is no longer reachable as `R:`. Two arguments naming the same device reset all four letters to their defaults, which a short form such as `^CMB,R` also triggers because the omitted slots keep their own letters. We measured all of this against Labelary on 2026-08-19. The fifth `M` argument newer firmware documents is not read.
`^CO`	Cache On	`ignored`	`n/a`	The renderer recognizes this command and ignores it. The glyph cache only makes repeated use of the same scalable glyph faster, and is invisible in the output. An off cache changes print time, not pixels. We measured this on 2026-07-30. On Labelary, `^CON` and `^COY,9999,1` both render a label pixel-identical to the same format with no `^CO` at all. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^JB`	Initialize Flash Memory	`supported`	`none` 0/1	The renderer erases every object held on the named device, at the point the command stands rather than at `^XZ`. The device argument is a letter and is resolved through `^CM`. Only `A`, `B` and `E` are accepted, so `^JBR` erases nothing even when the letter `R` names a flash device, and the letter is case-sensitive. A value longer than one character is trimmed to its first, which then erases. Measured against Labelary on 2026-08-19.
`~JB`	Reset Optional Memory	`supported`	`none` 0/1	This command differs from `^JB` and only shares the mnemonic: it takes no arguments. It is otherwise exactly `^JBB` — it erases whatever device the letter `B` names, which `^CM` can change. Text written after it is unrecognized content. Measured against Labelary on 2026-08-19.

Printer configuration

Commands that configure the printer itself: maintenance and consumable alerts, printhead tests, serial and front-panel settings, diagnostics and job cancellation. Almost all act on hardware or on the operator, not on the label.

Command	Name	Status	Coverage	Notes
`^CV`	Code Validation	`unsupported`	`n/a`	The parser stores the argument in `CvCommand.validation` and reads it nowhere, so the setting has no effect. On a printer it does change the label: the printer prints `INVALID - X` in reverse image where a symbol with invalid data belongs. It never alters a symbol whose data is valid. Labelary does not implement it either, so no compatibility gap exists. We measured this on 2026-07-30: `^CVY` renders byte-identically to the same format without it. For data problems here, read the diagnostics returned with the render.
`~JA`	Cancel All	`supported`	`full` 2/2	The parser reads the command and the renderer cancels. `~JA` discards the format being received, so it prints no page: `^XA^FO50,50^A0N,40,40^FDhi^FS~JA^XZ` answers `X-Total-Count: 0`. It also empties the rest of the print buffer, so a label the same request has already finished loses its page, and the queued copies of a `^PQ` run go with it. A label after the cancel is not in the buffer yet and prints as usual. A slew page is the printer feeding media rather than a format printing, so `^PH`'s blank page survives a later `~JA`. The command erases no stored `^DF` format, no `~DG` graphic and no `^IS` image, and it resets no printer setting such as `^LH`. A `~JA` replayed out of a recalled format reaches no further than that recall. Measured against Labelary on 2026-08-21.
`~JD`	Enable Communications Diagnostics	`planned`	`n/a` ‡	The renderer does not parse this command. Labelary implements diagnostic mode, re-measured on 2026-08-22: every byte from `~JD` to the next `~JE` draws as its own character with that byte number in hexadecimal underneath, 32 characters to a line, and the dump is a page of its own. A dump longer than the page is clipped rather than continued, so it is always one page, and an empty dump renders no page at all. The renderer interprets the ZPL normally and prints the label instead. The gap needs a parser mode that captures raw bytes plus a page generator for the character grid, so no milestone covers it yet.
`~JE`	Disable Diagnostics	`planned`	`n/a` ‡	The command is inert alone, because the renderer never enters diagnostic mode. It must land together with `~JD` rather than count as ignored. `~JD` alone dumps the entire tail of any format that turns diagnostics on and off, and `~JE` is what closes the dump and flushes its page (measured 2026-08-22). No milestone covers this yet.
`~JF`	Set Battery Condition	`ignored`	`n/a`	The command manages battery power. This service has no battery and nothing to pause. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^JH`	Early Warning Settings	`ignored`	`n/a`	The command tracks consumable wear against an odometer a render does not have. It changes what the printer tells an operator, never what it images. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^JI / ~JI`	Start ZBI	`unsupported`	`n/a`	ZBI is an interpreted BASIC on the printer that can render label content, so a ZBI program can change the printed label. `^JI` names a program already stored on the printer's file system, and this service has no file system and no interpreter. A format that depends on ZBI content therefore renders without it, and no part of the submitted ZPL can recover it. Labelary does not implement ZBI either. Send the finished ZPL, not a program that writes it.
`^JJ`	Set Auxiliary Port	`ignored`	`n/a`	The command configures electrical signals to machinery attached to the printer. None of them reach the image. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~JN`	Head Test Fatal	`ignored`	`n/a`	The command enables a hardware self-test, and no printhead exists to test. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~JO`	Head Test Non-Fatal	`ignored`	`n/a`	This is the other half of the `~JN` switch, and no printhead exists for either half to act on. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~JP`	Pause and Cancel Format	`unsupported`	`n/a`	On hardware this discards the format in progress, so nothing prints. Neither the renderer nor Labelary honors it. We measured this on 2026-07-29: `^XA…~JP^XZ` still returns one page. To suppress a label, do not send it.
`~JQ`	Terminate Zebra Basic Interpreter	`unsupported`	`n/a`	No ZBI session ever starts, so nothing exists to end. Labelary does not implement ZBI either. See `^JI` for why the format cannot recover a ZBI program's content.
`~JR`	Power On Reset	`ignored`	`n/a`	Every render starts from a fresh state, so no leftover state exists to reset. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^JT`	Head Test Interval	`ignored`	`n/a`	The command schedules a hardware self-test. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^JU`	Configuration Update	`ignored`	`n/a`	Nothing persists between requests, so no stored configuration exists to save or restore. Every render begins at printer defaults. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~JX`	Cancel Current Partially Input Format	`supported`	`partial` 1/2	The parser reads the command and the renderer cancels. `~JX` discards the format being received, so it prints no page: `^XA^FO50,50^A0N,40,40^FDhi^FS~JX^XZ` answers `X-Total-Count: 0`. It reaches no further than that format. A label the same request has already finished keeps its page, and so do the queued copies of a `^PQ` run. That is what separates `~JX` from `~JA`, which discards both. Between two formats there is nothing to cancel and the command does nothing at all. Measured against Labelary on 2026-08-21.
`~KB`	Kill Battery	`ignored`	`n/a`	The command performs battery maintenance on hardware this renderer does not have. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^KL`	Define Language	`ignored`	`n/a`	The command translates the operator's menus, not the label. Label text comes from `^FD`, and the printer never translates it. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^KN`	Define Printer Name	`ignored`	`n/a`	The command names the device for the network, which has no bearing on label content. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^KP`	Define Password	`ignored`	`n/a`	The command protects a front panel that does not exist. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^KV`	Kiosk Values	`ignored`	`n/a`	The command cuts, ejects and retracts media, all after the image exists, so none of it changes the image. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^MA`	Set Maintenance Alerts	`ignored`	`n/a`	A printer does print extra labels, but accumulated print distance in its odometer triggers them, never the format. A render has no odometer, so no alert label comes due and the page count does not change. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^MI`	Set Maintenance Information Message	`ignored`	`n/a`	The renderer never prints the alert labels this text appears on, so the message does not affect the format. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^MP`	Mode Protection	`ignored`	`n/a`	The command locks buttons on a panel that does not exist. Each invocation disables one function; `E` re-enables them all. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^MW`	Modify Head Cold Warning	`ignored`	`n/a`	The warning comes from a thermistor on hardware that is not here. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~PM`	Decommission Printer	`ignored`	`n/a`	Destructive on hardware and inert here: no persistent memory exists to wipe, and the serial number it demands belongs to a physical unit. This is not `^PM` print mirror image, which does affect the image. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~RO`	Reset Advanced Counters	`ignored`	`n/a`	The command zeroes an odometer that appears on the printer configuration label and drives the maintenance warnings. A render keeps no such counter. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^SC`	Set Serial Communications	`ignored`	`n/a`	The command sets transport settings for the wire the format arrived on, which cannot change the format's meaning. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^SQ`	Halt ZebraNet Alert	`ignored`	`n/a`	Alerts travel on a printer-to-host channel, and nothing they carry reaches the label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^SR`	Set Printhead Resistance	`ignored`	`n/a`	The command feeds the printer's thermal energy model. The renderer draws a pure black-and-white raster with no energy model. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^SX`	Set Alert	`ignored`	`n/a`	The command routes notifications to a host, and no notification path can alter the raster. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.

Host status and queries

Commands that send information back over the printer's link, or print it on a label of their own, rather than change the requested label.

Command	Name	Status	Coverage	Notes
`~HB`	Battery Status	`ignored`	`n/a`	Reports the battery voltage of a portable printer over the printer's link. This service has no battery and no link to answer on. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~HD`	Head Diagnostic	`ignored`	`n/a`	Returns power-supply and head-temperature figures over the printer's link. This service has no printhead, and nothing it could report changes the label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^HH`	Configuration Label Return	`ignored`	`n/a`	Returns the same settings `~WC` prints, but over the printer's link instead of onto a label, so it renders no page and cannot change the label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~HI`	Host Identification	`ignored`	`n/a`	Returns an identification string over the printer's link. Callers that use it to detect a printer model get nothing here; the API version is the equivalent fact. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~HM`	Host RAM Status	`ignored`	`n/a`	Reports memory figures over the printer's link. The request bounds this object store, not a fixed RAM budget, so no equivalent number exists to report. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~HQ`	Host Query	`ignored`	`n/a`	Returns odometer, error, serial-number and printhead reports over the printer's link. All of them describe hardware, and none affects a rendered label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~HS`	Host Status Return	`ignored`	`n/a`	Returns paper-out, pause, buffer and label-count flags over the printer's link. A render request has none of those states. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^HT`	Host Linked Font List	`ignored`	`n/a`	Returns the font links `^LF` would print, but over the printer's link, so it renders no page. This service holds no font-link table to describe. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~HU`	Return ZebraNet Alert Configuration	`ignored`	`n/a`	Returns the alert routing `^SX` sets, over the printer's link. Alerts are a ZebraNet feature with no counterpart in a render request. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^HV`	Host Verification	`ignored`	`n/a`	Echoes a field's data over the printer's link, which is how an applicator verifies a printed field. It draws nothing itself, so the label does not change. It also depends on `^FN`, which is `planned`: the parser reads numbered fields but does not yet fill them from a stored format. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^HW`	Host Directory List	`ignored`	`n/a`	Returns a file listing over the printer's link. The store it would list holds only the objects `~DG` downloaded earlier in the same request. The end of the request discards it, so a listing would be near-empty. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^HY`	Upload Graphics	`ignored`	`n/a`	Reads an object out of printer memory and returns it over the printer's link. The transfer direction is what makes it inert here: like `^HG`, it moves an object outward and draws nothing. The object store only holds what `~DG` downloaded in the same request. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^HZ`	Display Description Information	`ignored`	`n/a`	Returns an XML description of the printer, a directory listing or one object over the printer's link. Every selector is a report, so none of them changes the label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^LF`	List Font Links	`supported`	`none` 0/2	Prints its own label rather than an answer to the host, unlike `^HT`. The renderer prints it as the page after the format that carries the command, wherever in the format the command sits, and counts it in `X-Total-Count`. Labelary links no fonts, so the page is the heading `LIST OF FONT LINKS` over an empty double-ruled box, unchanged by `^CW`, `^FL` and `~DY` alike. A second `^LF` in one format prints one page; each format carrying an `^LF` prints its own page; `^PQ` replicates the label alone; and an `^LF` sent between formats prints nothing. Only the label width reaches the layout, setting how wide the box is ruled. A `^PW` ahead of the `^LF` centers the page in the print window and cuts the rest away. A `^POI` ahead of it turns the page over. Either one after the `^LF` leaves the page alone (measured 2026-08-16). Only `^LF` is a command; `~LF` prints nothing, and text written after `^LF` is discarded.
`~WC`	Print Configuration Label	`supported`	`none` 0/3	Prints its own label rather than an answer to the host, unlike `^HH`. The renderer prints that listing as a page ahead of the format carrying the command, wherever in the format it sits, and counts it in `X-Total-Count`. A second `~WC` prints a second listing, each reporting the printer of its moment. `^PQ` replicates the label alone. The listing reads the label size, `^PW`, `^LH`, `^LT`, `^LS`, `^CC`, `^CT` and `^CD` from the format, and carries fixed values elsewhere. A `^PW` ahead of the `~WC` also centers the page in the print window and cuts the rest away. A `^POI` ahead of it turns the page over (measured 2026-08-16). Only `~WC` is a command.
`^WD`	Print Directory Label	`supported`	`none` 0/6	Prints the listing `^HW` would send to the host, so unlike `^HW` it fills a page. The renderer prints it as the page after the format that carries the command, wherever in the format the command sits, and counts it in `X-Total-Count`. The page names the objects the request itself put into memory before the command ran, in alphabetical order, under the heading `DIRECTORY OF` and the mask. A second `^WD` in one format prints one page, of the mask the second command gave. Each format carrying a `^WD` prints its own page, `^PQ` replicates the label alone, and a `^WD` sent between formats prints nothing. Only the label width reaches the layout, setting how wide the box is ruled. A `^PW` ahead of the `^WD` centers the page in the print window and cuts the rest away. A `^POI` ahead of it turns the page over. Either one after the `^WD` leaves the page alone, even though the page follows the label (measured 2026-08-16). Only `^WD` is a command; `~WD` prints nothing.

Network and wireless

Wired and wireless network configuration, along with the protocol settings that accompany it: addressing, SNMP, radio rates and encryption. The renderer recognizes and ignores every command here, because none of it can change a label image.

Command	Name	Status	Coverage	Notes
`^KC`	Set DHCP Client Identifier	`ignored`	`n/a`	DHCP address negotiation happens before a format arrives, and none of it reaches the label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^NB`	Search for Wired Print Server during Network Boot	`ignored`	`n/a`	A boot-time decision about which print server carries the job, made before any format arrives. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^NC`	Set Primary Network Device	`ignored`	`n/a`	Selects which network interface carries print jobs. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~NC`	Network Connect	`ignored`	`n/a`	On real hardware this selects which printer on an RS-485 bus processes what follows; the others ignore it. This service has one virtual printer, so the format always renders. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^ND`	Modify Network Settings	`ignored`	`n/a`	Addressing and protocol configuration cannot change a label image. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^NI`	Network ID Number	`ignored`	`n/a`	Identifies a physical printer on a shared bus, not label content. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^NN`	Set SNMP	`ignored`	`n/a`	Management-protocol configuration that monitoring tools read, not the format. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^NP`	Set Primary/Secondary Device	`ignored`	`n/a`	Decides which stored copy of the network configuration wins at boot. Neither affects a label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~NR`	Set All Network Printers Transparent	`ignored`	`n/a`	Changes which physical printers on a bus listen, not what any of them prints. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^NS`	Change Wired Networking Settings	`ignored`	`n/a`	IP configuration for the wired print server; none of it reaches the label. The guide documents `^NS` twice. The ZPL Commands chapter gives a four-argument Ethernet command; the Wireless Commands chapter gives the nine-argument print-server command below. This page documents the nine-argument form, because it is the superset and matches Labelary's naming. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^NT`	Set SMTP	`ignored`	`n/a`	Alert delivery is a printer-management feature, not label content. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~NT`	Set Currently Connected Printer Transparent	`ignored`	`n/a`	Like `~NR`, this changes which physical printers on a bus listen, not what they print. The guide notes that on Z Series printers it behaves exactly as `~NR`, so every printer on the network receives the transmission. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^NW`	Set Web Authentication Timeout Value	`ignored`	`n/a`	Guards the printer's own web interface. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^WA`	Set Antenna Parameters	`ignored`	`n/a`	Radio hardware selection. This service has no radio and no antenna. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^WE`	Set WEP Mode	`ignored`	`n/a`	Wireless link security, settled before any format arrives. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^WI`	Change Wireless Network Settings	`ignored`	`n/a`	IP configuration for the wireless print server; none of it reaches the label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^WL`	Set LEAP Parameters	`ignored`	`none` 0/3	Wireless authentication, settled before any format arrives. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~WL`	Print Network Configuration Label	`supported`	`none` 0/3	The only command here that prints a page. The renderer prints that page ahead of the format carrying the command, wherever in the format it sits, and counts it in `X-Total-Count`. A second `~WL` prints a second page, each format carrying one prints its own, and `^PQ` replicates the label alone. Labelary has no print server to describe, so the page is a fixed placeholder drawing rather than a real listing; only the label width reaches the drawing, and that sets how wide the box is ruled. A `^PW` ahead of the `~WL` centers the page in the print window and cuts the rest away. A `^POI` ahead of it turns the page over (measured 2026-08-16). Only `~WL` is a command: `^WL` is LEAP.
`^WP`	Set Wireless Password	`ignored`	`n/a`	Protects the printer's own control-panel menus. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^WR`	Set Transmit Rate	`ignored`	`n/a`	Radio link parameters. This service has no radio. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~WR`	Reset Wireless Card	`ignored`	`n/a`	Restarts radio hardware that does not exist here, like the RESET NETWORK control-panel entry. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^WS`	Set Wireless Card Values	`ignored`	`n/a`	Radio association settings, decided before any format arrives. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`^WX`	Configure Wireless Security	`ignored`	`n/a`	Wireless link security, settled before any format arrives. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.

RFID

Commands that read, write and configure the RFID transponder embedded in a smart label. The renderer implements none of them, because the transponder is not part of the printed image. The five that carry their payload in ^FD consume it and draw nothing, so no tag data reaches the label face.

Command	Name	Status	Coverage	Notes
`^HL / ~HL`	Return RFID Data Log to Host	`ignored`	`n/a`	Returns a log held in printer RAM over the host channel. This service has no printer, no log and no host channel, and nothing about it reaches the label image. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines and with or without the command.
`^HR`	Calibrate RFID Tag Position	`ignored`	`n/a`	Moves the media, reads a transponder and reports the settings it found. It needs physical media to calibrate against, and writes its results to the host, not to the label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines and with or without the command.
`^RA`	Read RFID AFI or DSFID Byte	`ignored`	`n/a`	Reads a single byte from a transponder. No transponder exists, so the renderer reads nothing and returns nothing. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary does not implement it either, so neither engine returns tag data.
`^RB`	Define EPC Data Structure	`ignored`	`n/a`	Describes the bit layout the printer must use when `^RF` reads or writes EPC data. It carries no data of its own and draws nothing. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines and with or without the command.
`^RE`	Enable RFID EAS Bit	`ignored`	`n/a`	Flips a theft-detection bit inside the transponder, and prints nothing. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines and with or without the command.
`^RF`	Read or Write RFID Format	`ignored`	`n/a`	Encodes or reads the transponder embedded in a smart label, which is not part of the printed image. The parser consumes the tag payload `^FD` and draws nothing for it. Neither the tag data nor an access or kill password reaches the label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines. A read (`^RFR`) with `^FN` returns no data, so a field that must print the read value comes out empty rather than wrong.
`^RI`	Read RFID Tag ID	`ignored`	`n/a`	Reads the identifier burned into the transponder at manufacture. With no transponder, the renderer reads nothing. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary does not implement it either, so neither engine returns tag data.
`^RL`	Lock or Unlock RFID Tag Memory	`ignored`	`n/a`	Changes the write protection inside the transponder, with an access password that `^RF` set earlier. It has no printed form. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines and with or without the command. The 2006 ZPL II Programming Guide does not document this command, and the parameters below come from Zebra's later RFID documentation for Gen 2 printers.
`^RM`	Configure RFID Motion	`ignored`	`n/a`	A media-transport setting for the encode step. This service has no media transport and no encode step. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines and with or without the command.
`^RN`	Configure RFID Multiple Tag Detection	`ignored`	`n/a`	Decides whether several transponders in range are an error. With no radio, the count is always zero. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines and with or without the command.
`^RQ`	Write RFID EPC Data and Passwords	`ignored`	`n/a`	Encodes the transponder, so it changes nothing on the printed side. The parser consumes the `^FD` that carries the EPC with the access and kill passwords. It draws nothing for that field, so none of it reaches the label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines. Neither Labelary's command reference nor the 2006 ZPL II Programming Guide documents this command, so this page publishes no parameter table rather than a guess.
`^RR`	Enable Adaptive Antenna Selection	`ignored`	`n/a`	A radio retry policy. Nothing it does appears on the label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines and with or without the command.
`^RS`	Set Up RFID Parameters	`ignored`	`n/a`	Configures the encode step: the programming position, how many labels to retry, and what to do when they all fail. The renderer draws none of it. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines and with or without the command.
`^RT`	Read RFID Tag	`ignored`	`n/a`	Reads the transponder. None exists, so a field that would receive the data stays empty rather than wrong. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary does not implement it either, so neither engine returns tag data. `^RF` with the `R` operation is the current replacement for it.
`^RU`	Read Unique RFID Chip Serialization	`planned`	`n/a`	Derives a serial number from the transponder's TID. With no transponder, no TID exists to derive from. The renderer does not parse it, so it reports "valid ZPL, not supported yet". Labelary does not implement it either, so neither renderer returns tag data; only the warning list differs. Read the deviations below: this one does reach printed fields. The 2006 ZPL II Programming Guide does not document this command, and the parameters below come from Zebra's later RFID documentation for Gen 2 printers.
`~RV`	Configure RFID Reporting	`ignored`	`n/a`	Controls a message the printer sends over the host channel after an encode. This service has no encode and no host channel. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines and with or without the command.
`^RW`	Set RF Power Levels for Read and Write	`ignored`	`n/a`	A radio transmit-power setting. It changes how reliably a tag encodes, never the printed label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines and with or without the command.
`^RZ`	Set RFID Tag Password	`ignored`	`n/a`	Writes a password into the transponder. The password travels in parameter `p`, not in `^FD`. The parser consumes any `^FD` given to the command and draws nothing for it, so neither reaches the label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines. On current printers `^RF` with the `S` operation sets the access password.
`^WF`	Write RFID AFI or DSFID Byte	`ignored`	`n/a`	Writes one byte into the transponder. The parser consumes that `^FD` and draws nothing for it, so the byte does not reach the label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines.
`~WQ`	Write Query	`ignored`	`n/a`	A host query about the radio and its counters. It returns text over the host channel and draws nothing. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines and with or without the command. Neither Labelary's command reference nor the 2006 ZPL II Programming Guide documents this command, so this page publishes no parameter table rather than a guess.
`^WT`	Write RFID Tag	`ignored`	`n/a`	Encodes the transponder, which is not part of the printed image. The parser consumes the tag payload `^FD` and draws nothing for it, so no tag data reaches the label. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines. On current printers `^RF` with the `W` operation replaces it.
`^WV`	Configure RFID Write Verify	`ignored`	`n/a`	Decides whether the printer reads a tag back after it writes. Neither the write nor the read-back happens here. The renderer does not parse this command. It reports `IGNORED_COMMAND` at info severity, which does not reach `X-Warnings`. Labelary is also silent, so the rendered label is identical in both engines and with or without the command.

Labelary extensions

Two commands Labelary invented that are not part of ZPL. They simulate colored label stock with a background behind the label, and no Zebra printer accepts them.

Command	Name	Status	Coverage	Notes
`~BI`	Background Image	`planned`	`n/a`	A Labelary-specific extension rather than ZPL, so no Zebra printer accepts it and it appears in no Zebra reference and in no Labelary command table. It draws a background, so it would change the rendered label. That makes it a real gap, not a safe command to ignore, and nothing schedules it yet. The renderer also does not recognize its own name. The dispatcher matches the two-character mnemonic without the prefix, so the parser reads it as `^BI` industrial 2 of 5. It reports no unknown command; see the recorded deviations.
`~BR`	Background Rectangle	`planned`	`n/a`	A Labelary-specific extension rather than ZPL, so no Zebra printer accepts it and it appears in no Zebra reference and in no Labelary command table. It draws a colored background, so it would change the rendered label. That makes it a real gap, not a safe command to ignore, and nothing schedules it yet. The renderer also does not recognize its own name. The dispatcher matches the two-character mnemonic without the prefix, so the parser reads it as `^BR` GS1 DataBar. It reports no unknown command; see the recorded deviations.

Command Support Matrix

On this page