Web Label Editor

Design labels and print them straight from your browser to DYMO LabelWriter and Brother P-touch / QL label printers. No drivers, no CUPS, no server: the page renders your design to the exact dots the printer will burn and sends them over WebUSB or Web Serial (Bluetooth). Continuous rolls are first class: a label is as long as its content, or any length you choose.

See it at its real size before you print. Under the editor, the label is drawn at its actual size on your screen: calibrate once by holding a bank card against it, then hold the label, the cable or the jar lid up to the screen to check it fits. As far as we know, none of the other label editors listed under Other tools do this.

Open it: https://mofosyne.github.io/web-label-editor/ (Chrome, Edge or another Chromium browser on desktop to print; any browser to design)

Who it's for

This editor is for you if:

• You have a DYMO LabelWriter (400 / 450 family) and/or a Brother P-touch (or QL) and want one editor for both, in the browser on Linux, Windows, macOS and ChromeOS (Windows needs a one-time driver switch for USB).
• You print on continuous rolls or tape, where the label is as long as its content.
• You want to edit text right on the label (click it and type) and have it fit: sized automatically to its box, never cut off, as in the original DYMO Label software.
• Position matters: the preview shows the true printable area, and test prints and per-roll calibration handle third-party label stock.
• You want to see the label at its real size on screen before printing: calibrate once with a bank card, then hold the label or the thing it goes on up to the screen.

Another tool may suit you better if:

• You print onto A4 / Letter sticker sheets: try burnmark.
• You only use a Brother P-touch and want to open P-touch Editor files: try labelpeel.
• You want a print server that phones or other computers print through: try brother_ql_web.
• You have a DYMO LabelManager or LetraTag tape printer: try Labelle.
• You have a DYMO LabelWriter 550 / 5XL (not supported here; they need DYMO's chip-locked labels): try burnmark.

More in Other tools.

Motivation

Label printers are simple machines: they take rows of dots and burn them onto paper or tape. Yet on Linux, using one is a chore:

• The makers' design software doesn't run on Linux. DYMO Connect and Brother's P-touch Editor are Windows and macOS only. Drivers exist, but DYMO's Linux CUPS driver is an old release, and Brother's are closed, mostly x86-only binaries.
• The existing Linux tools didn't fit the job. glabels, for one, is built around fixed label sheets and templates and prints through CUPS: continuous rolls are awkward, and there's no auto-sizing text, so text gets cut off.
• So Linux users end up second-class citizens with hardware that works fine everywhere else.

A web page that talks to the printer directly fixes that for everyone at once: the same editor on Linux, Windows, macOS and ChromeOS, no installs, and continuous rolls treated as the normal case rather than an afterthought.

Philosophy

Ease of use over features. It does less on purpose. The aim is not the longest feature list: it is that making a label is quick and obvious. Click the text and type; it fits its box; the preview is what prints; the printer just works. A feature earns its place only if it doesn't make that everyday case harder, and the rest below follows from this.

Reuse the lessons commercial label software already learned the hard way, instead of relearning them. Over years of users, programs like the original DYMO Label and Brother's P-touch Editor settled on things that work: text you edit right on the label, text that shrinks to fit rather than getting cut off, a canvas that is the real label size with the unprintable edges shown, picking the label from a list instead of typing dimensions, quick reprints of past labels, and undo for everything. Where they got it right, copy it; don't make users discover the same problems again.

• Modelled on the original DYMO Label software, not DYMO Connect. The things it got right: editing text right on the label, a preview that shows what will print, copy and paste between labels, and above all text that sizes itself to fit a box. Too many label editors leave you guessing, and text gets cut off.
• Continuous rolls are the normal case. A label is as long as its content unless you say otherwise; fixed sizes and die-cut labels are the special case, not the other way round.
• What you see is what prints, at the size it prints. The preview is the exact dots the printer will burn, from the same code that prints, and a calibrated panel shows them at their real size. It shows where the printer cannot reach (hatched) and the maker's safe area (dashed); going past the safe area, even onto the liner, is allowed on purpose. The editor tells you what will happen and leaves the call to you.
• Print directly. The page talks to the printer itself, so it works the same on Linux, Windows, macOS and ChromeOS, with nothing to install (Windows needs a one-time driver switch for USB).
• Measure, don't guess. Printers and label stock vary, especially third-party rolls. Test prints show where ink actually lands, and the calibration is saved per label type or per roll.
• Never lose work. Undo and redo cover every change; switching how a row of labels is filled hides a label's own design rather than deleting it; the current design is kept as you go and every print is in the history.
• Nothing leaves your computer. It is a static page; designs stay in your browser unless you save them to a file.
• Keep it that way. docs/UX-CHECKLIST.md has the lessons learned so far and a checklist to run before merging anything a user can see.
• Build on others' work, and say when another tool fits better. The printer protocols come from projects that worked them out first, and Other tools lists the alternatives honestly.

Printers

Printer	Status	Protocol	Connection	Labels / notes
DYMO LabelWriter 450	✅ Tested	DYMO LabelWriter raster	USB	LabelWriter labels, up to 62 mm; 300 × 600 dpi tested
DYMO LabelWriter 450 Turbo	🧪 Experimental	DYMO LabelWriter raster	USB	LabelWriter labels, up to 62 mm
DYMO LabelWriter 400 / 400 Turbo	🧪 Experimental	DYMO LabelWriter raster	USB	LabelWriter labels, up to 62 mm
DYMO LabelWriter 450 Duo (label side)	🧪 Experimental	DYMO LabelWriter raster	USB	LabelWriter labels, up to 62 mm
DYMO LabelWriter 450 Twin Turbo	🧪 Experimental	DYMO LabelWriter raster	USB	LabelWriter labels, up to 62 mm
DYMO LabelWriter 4XL	🧪 Experimental	DYMO LabelWriter raster	USB	LabelWriter labels, up to 104 mm
DYMO LabelWriter SE450	🧪 Experimental	DYMO LabelWriter raster (SE450 subset)	USB	LabelWriter labels, up to 62 mm
DYMO LabelManager PnP / 280 / 420P / 500TS (D1 tape label makers)	⬜ Unimplemented	DYMO LabelManager		DYMO's tape label makers, like P-touch. Different protocol, and some first appear as a USB drive; Labelle supports them.
Brother PT-P710BT (USB)	✅ Tested	Brother P-touch raster	USB	TZe tape, up to 24 mm
Brother PT-P710BT (Bluetooth)	🧪 Experimental	Brother P-touch raster	Bluetooth	TZe tape, up to 24 mm
Brother PT-P700	🧪 Experimental	Brother P-touch raster	USB	TZe tape, up to 24 mm
Brother PT-P750W	🧪 Experimental	Brother P-touch raster	USB	TZe tape, up to 24 mm
Brother PT-H500	🧪 Experimental	Brother P-touch raster	USB	TZe tape, up to 24 mm
Brother PT-E500	🧪 Experimental	Brother P-touch raster	USB

Tried a printer? Report how it went, whether it worked or not: reports are how printers move from 🧪 to ✅. Missing a label or tape size? Request it. The app links to these forms pre-filled with your printer, label, OS and browser.

✅ Tested: printed on real hardware. 🧪 Experimental: uses a protocol path checked against a reference implementation, but nobody has printed on that model with this app yet. ⬜ Unimplemented: not supported yet.

• DYMO LabelWriter 550 / 550 Turbo / 5XL: not planned. Only print on DYMO labels with an authentication chip.

The same table is in the app under Help → Printers. Adding a printer is described below.

Without internet

• Installed or cached: open the site once in Chromium, Chrome or Edge and it keeps working offline (it caches itself). File → Install as an app gives it its own window and launcher icon.
• On a computer that has never been online, e.g. from a USB stick: File → Download for offline use (or web-label-editor.zip) is the whole app with two scripts. On Linux, sudo ./install-udev-rules.sh once (USB access for DYMO and Brother printers, --remove to undo), then ./start.sh: it serves the app on this computer only, at http://localhost:8737/, and opens it in Chromium, Chrome or Edge. It needs Python 3, which most Linux systems have. Opening index.html directly doesn't work: browsers only allow USB on secure pages, and localhost is one, a file isn't.
• Firefox and Safari can design and download a PNG, but can't print: they have no WebUSB or Web Serial. The app says so where it matters.

Sharing a printer on the network

A computer with the printer plugged in (a Raspberry Pi, a NAS, even an ESP32) can host the editor for every device on the network: phones, tablets, Firefox and Safari included, none of which can reach a USB printer themselves. The editor finds the printer on that server by itself, and Print sends the label there.

python3 scripts/print-server.py --model dymo-lw450 --device /dev/usb/lp0

That is the reference server (standard-library Python, also in the offline download). Other servers, such as brother_ql_web or a home-made one, can do the same by serving the editor's files next to two small endpoints: docs/PRINT-SERVER-API.md is the contract.

Getting started

1. Open the site, pick your printer and label in the Printer panel.
2. Click the text on the label and type; it sizes itself to fit. Add more text, QR codes, barcodes, images or boxes from the toolbar, and drag to move them.
3. Connect USB (or Bluetooth), then Print. If your OS refuses the browser access, the app shows the one-time fix (see per-OS setup). On Linux with a snap or Flatpak browser, such as Ubuntu's Chromium, the sandbox needs a one-line permission as well.
4. If prints land off position, use Test prints in the Printer panel to calibrate (see Labels, margins and calibration).
5. Printed on a 🧪 experimental printer? The app asks how it went, with a pre-filled report. That's how printers become ✅ tested.

The app has its own welcome page and Help with the same information.

Features

• Items: text (multi-line, any installed font, fixed size or fitted to a box, turned 90°, 180° or 270° for cable flags and vertical text), QR codes, barcodes (Code 128, EAN-13, UPC-A), images (threshold or dithering), shapes (rectangle, rounded rectangle, circle or ellipse, line) and symbols (Symbol: safety and hazard signs, handling marks, recycling and trash, electrical including earth and class II, IT, tools, arrows and brand icons such as Instagram or GitHub; plus characters such as ®, ™, °, € that go into text). On a die-cut label each new item goes into free space, or beside fitted text, which narrows to make room. Drag to move, corner handle to resize.
• Editing: click selected text (or double-click it, or press Enter / F2) to edit it in place, right on the label; the bar above the label sets its font, size (Auto fits it to its box; A− / A+), bold, italic, alignment and turning, as in DYMO Label; double-click empty space to add text; Ctrl+C / Ctrl+X / Ctrl+V for items (and pasting text or images from other apps); Ctrl+D duplicates; arrow keys nudge; Ctrl+Z / Ctrl+Shift+Z (or Ctrl+Y) undo and redo, with a drag or a burst of typing as one step.
• Batches from data, numbering and dates: put {{Name}} (a column), {{n}} (a counter) or {{date}} / {{time}} in any text, QR code or barcode (double braces, as in most mail merges, so a single {brace} in a label stays text). The Batch… button, next to Copies, walks through it: open a data file or paste cells (Try an example shows the same example data as CSV, JSON, a Markdown table and so on), click the fields to put on the label, check each label, print. Data comes from spreadsheet cells, a CSV, a Markdown table, JSON or a GNU recfile. A CSV or a pasted list without column names (say, a list of serial numbers) is spotted, and its columns are {{A}}, {{B}}…; a tick box says otherwise when the guess is wrong. Print makes one label per chosen row, as one job where the printer allows. Step through the labels before printing to check each one fits; the counter carries on from where the last print stopped. The data is saved with the label, so a saved label is a template.
• Label and ink colours in the preview: yellow or clear labels, white or gold ink on black tape and so on, chosen under Label (a P-touch reports its loaded tape's colours itself). The printer prints the ink the label or tape has, so this only changes how the preview looks.
• Changing the label keeps the design on it: if it no longer fits the new label or tape, it is shrunk evenly to fit (undo brings it back).
• Label length on rolls and tape: the Length box in the toolbar says Auto or a length in mm. On Auto the label ends one margin after the last item, so it grows as you add or move things along (and saves tape when the text varies); nothing goes before the start margin. A length is for labels that must all match; type one, or drag the label's end as in P-touch Editor. On die-cut labels it shows their own length.

Direct USB instead of a printer driver

This editor does not go through the operating system's print system (CUPS on Linux and macOS, the spooler on Windows). The browser opens the printer's USB or Bluetooth connection itself and sends the printer's own raster commands.

Why:

• Works the same everywhere. No driver to install, and nothing Linux-specific: the same page works on Linux, Windows, macOS and ChromeOS. DYMO's Linux driver is old, and Brother's are closed x86-only binaries.
• Continuous rolls without page-size gymnastics. Print drivers think in fixed paper sizes, so continuous tape means defining custom page sizes, and some drivers cap the length. Here the label is simply as long as the design.
• Exact dots. The page renders at the printer's resolution and sends those dots unchanged. No driver scaling, margins or halftoning, so barcodes and QR codes stay sharp.
• Two-way. The printer can be asked what tape is loaded and whether anything is wrong. A print queue is one-way.

The trade-offs:

• The browser needs permission on the USB device. Apps like glabels print through CUPS, whose USB backend runs as a system user, so they never needed it. Here the browser runs as you, so on Linux you add one udev rule (below). That is the "Access denied" error.
• One user of the printer at a time. A USB printer interface has one owner at a time, so programs take turns. The editor claims the printer only while it prints or reads status and then lets go, as CUPS does, so glabels and the editor can both use it, just not at the same moment. The exception is the usblp kernel driver, which holds the printer for as long as it's plugged in (see Linux setup below).
• Chromium-based browsers only (Chrome, Edge, Brave, Opera), since WebUSB and Web Serial exist only there.
• No print queue or network sharing. For those, use Download PNG and print the image through your normal printer driver.

Connecting: per-OS setup

The browser opens the printer's USB device itself (see Direct USB above). If you see "Failed to execute 'open' on 'USBDevice': Access denied", the operating system is keeping the browser out. The fix depends on the OS.

Linux

Give your desktop user access to the printers with a udev rule:

sudo tee /etc/udev/rules.d/60-label-printers.rules <<'RULES'
# DYMO
SUBSYSTEM=="usb", ATTRS{idVendor}=="0922", TAG+="uaccess"
# Brother
SUBSYSTEM=="usb", ATTRS{idVendor}=="04f9", TAG+="uaccess"
RULES
sudo udevadm control --reload-rules && sudo udevadm trigger

Then unplug and replug the printer. (uaccess grants the logged-in desktop user access. On a system without it, use MODE="0666" instead of TAG+="uaccess".)

Browser installed as a snap or Flatpak? You also need this. Ubuntu ships Chromium as a snap, and snaps and Flatpaks are sandboxed away from USB devices even after the udev rule. Grant access once, then quit and restart the browser:

# Snap (Ubuntu's Chromium; check with: snap list chromium)
sudo snap connect chromium:raw-usb

# Flatpak (check with: flatpak list --app; use your browser's app ID)
flatpak override --user --device=all com.google.Chrome
flatpak override --user --device=all org.chromium.Chromium

If a Flatpak browser still can't see the printer, a browser from your distribution's regular packages (or Google's own Chrome package) avoids the sandbox.

• "Unable to claim interface" (only then): something else has the printer. lsusb -t shows the printer's Driver=: usblp is the kernel printer driver (below); usbfs means a program has it, usually CUPS mid-job, so close it or sudo systemctl stop cups while printing from here. If modprobe -r usblp reports the module is in use, stop CUPS first.
  • Try it out, nothing saved: sudo modprobe -r usblp. It comes back on the next plug-in or reboot.
  • Keep it off: echo 'blacklist usblp' | sudo tee /etc/modprobe.d/no-usblp.conf. This applies to every USB printer. Check lpstat -v first: a usb:// address means CUPS uses its own libusb backend and does not need usblp; a /dev/usb/lp0 address means it does, so use the temporary option.
  • Undo: sudo rm /etc/modprobe.d/no-usblp.conf && sudo modprobe usblp.
• Undo the permission rule: sudo rm /etc/udev/rules.d/60-label-printer.rules, then replug.

Windows

Windows' own printer driver (usbprint) owns the device. Either

• use Bluetooth on P-touch models that have it (pair it in Windows Settings first, then pick it in the browser's port list), or
• switch the printer to WinUSB with Zadig: Options → List All Devices, pick the printer, choose WinUSB, Replace Driver. DYMO Connect / P-touch Editor won't see the printer until you reinstall their driver (Device Manager → Update driver).

macOS

Usually works. If access is denied, another program has the printer: quit DYMO Connect, the DYMO Web Service (menu bar) or P-touch Editor, then unplug and replug.

ChromeOS, Android

Usually works. On ChromeOS, remove the printer from Settings → Printers if it was added there.

The app explains this itself: when the browser is refused, a How to fix… button opens the steps for your system, with the commands for your exact printer.

Bluetooth

P-touch models with Bluetooth (PT-P710BT, D460BT, D610BT, E310BT, E560BT) print over Bluetooth Classic (Serial Port Profile), which browsers reach through Web Serial. That is not Web Bluetooth, which only covers Bluetooth Low Energy.

1. Pair the printer in your OS Bluetooth settings.
2. Click Connect Bluetooth / serial and pick the printer. On Windows and macOS it may also be listed as a serial/COM port created by the pairing.

This needs Chrome or Edge 117 or later on the desktop; Android support for Bluetooth serial is not confirmed. On Windows this is the easiest route because it needs no driver swap. Bluetooth is slower than USB, so long labels take a few seconds to send.

Labels, margins and calibration

• Hatched border: where the printer cannot put ink at all (the LabelWriter's leading margin, the edges of Brother tape and DK labels outside the printable width, or an edge a position adjustment moved out of reach). Anything there is cut off and flagged under the preview. Every label is shown at its real size, DYMO and Brother alike.
• Dashed line, the safe area: the makers' own printable area (for DYMO, the driver's). The head can print past it, but the die-cut edge or a label sitting slightly off may trim what is there, so it may not come out the same every time; the preview notes it, and the actual-size panel leaves it off. Fill to edge sizes a fitted text box to the whole reachable label instead of the safe area. The head does not print on the backing past the die cut (tested on a LabelWriter 450).
• Two labels per row (e.g. DYMO 30333, 13 × 25 mm halves): the preview shows the whole row. Labels in a row chooses Same design on all (the other labels show a dimmed copy; Copies counts rows), A different design on each (click a label to add items to it, drag items between labels; Copies counts rows) or Same design, one label at a time (Copies counts labels, filling each row from the top). The 🔓 Edit separately button on a dimmed copy switches to a design per label, starting from a copy of the first; 🔗 Same as label 1 links it back (its own items are kept, hidden, until you unlink again).
• Actual size: a panel under the editor shows the label at its real size, so you can hold the label or the thing it goes on up to the screen while editing at any zoom. Until the screen is calibrated it is an estimate (the browser's nominal millimetre) and says so; Calibrate… matches an outline to a bank card or a ruler held against the screen. The calibration follows browser zoom; a different monitor needs its own. 1:1 or Hide turns the panel off (remembered); when a label is too long for the panel, pressing 1:1 shows it at real size in the editor itself.
• The roll: a short faded stub past the label's trailing end shows the rest of the roll still in the printer (the gap and the next label, or the tape running on), with a torn edge and an arrow the way the label moves out.
• Which way it prints: the ruler along the feed marks the end that comes out of the printer first (◀ ▶ ▲ ▼), where the label is cut (✂, with auto-cut on), and where a continuous label grows (»); the note under the preview says it in words. Brother QL printers feed the right-hand end first; DYMO and P-touch the left.
• DYMO LabelWriter: the printer starts printing about 5.8 mm into each label (DYMO's driver calls this the leading margin; measured 6 mm on a LabelWriter 450). The app leaves that part out of the job, so the rest lands where the preview shows it and the job ends at the label's end.

Adding a label or tape size

Try it first with "Custom size…". On a LabelWriter or a Brother QL, the last entry in Media takes any size (third-party rolls, round stickers): die-cut or continuous, width and length, corner radius or round, and a safe margin. Print the Grid test, then Generate report opens a label request with a ready record for the catalogue (or copy it, or save it as a file). Round labels show as a circle, with the safe area a circle inset from the edge. On a Brother QL it is experimental: the printer is sent the size, so enter the roll's own, and where it can print is an estimate (3 mm less than the label, the offset of the nearest Brother size) to fine-tune with the Grid test. Brother's round DK labels (12, 24 and 58 mm) are in the list.

Label and tape sizes live in catalog/media.rec, a GNU recutils file: one record per label, one field per line, with comments. Each record belongs to a printer family (dymo-lw, brother-pt, brother-ql); every model in the family whose head is wide enough offers it. To add one, copy a similar record, give it a new Id, and fill in the sizes in millimetres. The comments at the top of the file describe every field.

Id: 30252
Family: dymo-lw
Name: 30252 Address 28 × 89 mm
Kind: diecut
WidthMm: 27.86
LengthMm: 88.9
MarginLeftMm: 5.84
MarginRightMm: 1.52
MarginTopMm: 1.02
MarginBottomMm: 1.52
CornerMm: 3
Source: lw450.ppd 30252: 78.96 x 252 pt, imageable 4.32 4.32 76.08 235.44

• Never rename or reuse an Id: saved designs refer to labels by it.
• Not comfortable editing the file? Request the label size instead (the app's Missing a label size? link pre-fills your printer).
• Say where the numbers came from in Source (a driver file, a datasheet, or "measured").
• Check the file with recfix catalog/media.rec (from the recutils package). CI runs that too, and checks that the app's parser reads the file exactly as recsel does.

Why recutils: the catalogue is flat, hand-edited data where every number needs a comment saying where it came from. One field per line keeps diffs and merges clean, and recfix validates types, required fields and unique ids. Designs stay JSON because they are nested and written by the app.

Adding a printer

Not listed? Try "Other printer". Pick Other printer (ZPL, TSPL or ESC/POS) and describe yours: the language it speaks (ZPL for Zebra and its many compatibles, TSPL for most budget 4 × 6 shipping printers, ESC/POS raster for receipt-style printers), its resolution, head width and label size. Print the Grid test, adjust until it lines up, and send the report: the app fills in the settings you used, and a set that works becomes the printer's own entry (in catalog/printers.rec). This is experimental by design: these printers differ in how they sense labels and which way round they print. Generate report in that panel shows the settings to copy or save as a file, and opens the GitHub issue with them filled in.

Maintainers: docs/MAINTAINING.md says how each kind of report becomes support, and the checks to run.

1. If it speaks a protocol already implemented (LabelWriter, P-touch raster, QL raster, or ZPL / TSPL / ESC/POS in src/printers/generic.js), add an entry to MODELS in src/printers/models.js with its USB IDs, head width and quirks. Otherwise add an encoder (bitmap → bytes) next to the others, ported from a reference implementation, with tests that check its output against that reference.
2. List the devices the entry covers with their status: tested only once someone has printed on that model with this app, otherwise experimental. Devices not supported yet go in src/compat.js.
3. Add its labels to the catalogue if it is a new family.
4. Run npm run docs to regenerate the table above, and npm test.

Tested a printer marked experimental, or one that isn't listed? Report how it went (the app's report link pre-fills your printer, label, OS and browser).

How it works

design (mm, per label)
   │  render.js: each label of the row, plus any overprint border
   ▼
view bitmap (printer dots) ◀── layout.js: label slots, overprint border,
   │                            and what the head can reach
   │  x = along the feed, y = across the head
   │  layout.js jobBitmap: position adjustment, leading-margin skip,
   │  crop to the reach
   ▼
job bitmap ──encoder (per printer family)──▶ bytes ──▶ WebUSB / Web Serial

The preview and the printer get the same view bitmap, which is what makes the preview exact. Design decisions worth knowing:

• Units: designs are in millimetres, relative to the label's top-left corner as you see it (upright in portrait), so they survive a change of printer resolution. Portrait renders the upright page and turns the bitmap a quarter turn anticlockwise into the strip (layout.js pageToStrip). Items on the second label of a 2-up row carry lane: 1.
• Strip orientation: every printer gets a bitmap whose x runs along the feed and y across the head; the encoders map that onto each printer's raster lines.
• Two kinds of margin: hard (the printer can't put ink there: the LabelWriter's leading margin, the edges of Brother media outside their printable band, or an edge a position adjustment moved out of reach) and safe (the maker's printable area). Only hard margins cut anything off; layout.js works out the reach, including the head's width past the label edge that an overprint border can use.
• Brother media are shown whole: a medium's band is the printable part (ptouch-print's and brother_ql's printable dots, centred on the tape or label); the preview hatches the rest and the job sent to the printer is just the band, so the encoders still receive printable-width bitmaps.
• The job is not the view: the job drops what the printer can't reach and applies the position adjustment, so a calibrated print lands where the preview shows it, and a die-cut job ends at the label's end instead of running into the next label.
• Undo: JSON snapshots of the design; quick successive changes and a whole drag merge into one step, while clicks and menu changes start new ones.
• Docs from code: the compatibility table, Who it's for and Other tools are generated into this README from src/ by npm run docs, and the help pages read the same data, so neither drifts from the app.

Files:

• src/app.js: the editor UI, preview, printing and storage.
• src/render.js: design → bitmap for one label, via an off-screen canvas.
• src/layout.js: the view (row of labels, overprint border, reach of the head), row modes, and the view → job transform.
• src/printers/dymo-labelwriter.js: LabelWriter 400/450/4XL commands (ESC L, ESC D, SYN raster lines, ESC G/ESC E), from DYMO's dymo-cups-drivers.
• src/printers/brother-ptouch.js: P-touch raster mode with per-model quirks, from ptouch-print.
• src/printers/brother-ql.js: QL raster mode, from brother_ql.
• src/printers/models.js, src/compat.js: printer models, their status and the compatibility table.
• catalog/media.rec, src/recfile.js, src/catalog.js: the label catalogue, a small recutils reader, and the code that turns records into media.
• src/calibration.js, src/rolls.js: test print patterns, and saved rolls with their calibration codes.
• src/codes/qr.js, src/codes/barcode.js: QR (byte mode, versions 1–40, levels L/M/Q/H), Code 128, EAN-13 and UPC-A encoders, verified by decoding every QR version and level at full capacity, and the linear codes, with the zxing-cpp reader.
• src/undo.js, src/library.js: undo history; saved labels and print history.
• src/about.js, src/help.js, src/others.js, src/report.js: the welcome and help pages, connection help, the other-tools list, and the pre-filled issue links.
• src/transport.js: WebUSB and Web Serial. The printer is claimed only while printing, so other programs can use it in between.

Development

Plain HTML and JavaScript modules, no build step.

npm run serve   # http://localhost:8000
npm test        # unit tests
npm run docs    # regenerate this README's generated sections and sw.js's file list
npm run package # dist/: the site as deployed, and the offline download (zip)
npm run screenshots  # regenerate docs/screenshots (needs Playwright + Chromium)

The published site registers a service worker (sw.js) that caches the app for offline use; it isn't registered on plain http, so local development always loads the files as they are.

Before merging a change a user can see, go through docs/UX-CHECKLIST.md.

Tests check every encoder's command stream byte by byte against its reference implementation's logic, the catalogue against recsel/recfix (when recutils is installed), the layout and undo logic, and that this README's generated sections match the code.

.github/workflows/ci.yml runs the tests on every push and pull request and deploys main to GitHub Pages, with the offline zip built by npm run package.

Other tools

This editor does less on purpose: fewer features than some of the tools below, but the everyday label is quick to make and prints where you expect. Low-level libraries for these printers are plentiful; label editors are rarer, mostly cover one brand, and often print through CUPS or a small server. This one aims at DYMO LabelWriter and Brother printers together, continuous rolls, text edited in place that fits its box, and a true preview of the printable area, also at real size; if one of these fits you better, use it. Developers: the libraries are where most of the protocol knowledge lives.

🤖 AI-assisted marks projects written largely with AI coding assistants ("vibe coded"), judged from their own commits, README or AI config files as of October 2026. This editor is AI-assisted too: written largely with Claude Code, but steered by use rather than by a feature list. Its author tries each change on real printers and labels, and judges it by how it feels to use: whether the everyday label got quicker or clearer, often by borrowing what commercial label software already learned. Many requests end up smaller than first asked, or as a ticket for later.

Label editors in the browser, printing directly

• label-maker (burnmark) (🤖 AI-assisted): Vue label designer printing over WebUSB to Brother QL, DYMO LabelWriter and DYMO LabelManager printers.
• labelpeel: designer for Brother P-touch printers (experimental QL) over Bluetooth or USB, with auto-fit text, templates, CSV data and P-touch Editor file import; also Mac and Android apps. Formerly labelsmith.
• ql700-printer: designer for the Brother QL-700 over WebUSB.
• NiimBlue: designer for NIIMBOT label printers (D11, D110, B1, B21 and others) over Bluetooth or serial, at niim.blue.
• ptouch (fjanicki) (🤖 AI-assisted): Rust library and web studio for Brother P-touch Bluetooth printers (PT-P710BT); early development.

Desktop label editors

• gLabels: label and business card designer for Linux, built around label sheets and templates; prints through CUPS.
• Labelle: Python GUI and command line for DYMO LabelManager tape printers (the successor of dymoprint).
• TuxLabel: PyQt6 editor for Brother P-touch (TZe) printers on Linux with a WYSIWYG preview; prints through CUPS.
• ptlabel (🤖 AI-assisted): Python editor (GUI and command line) for the Brother PT-P750W over Wi-Fi, and USB on Linux.
• pLabels: Qt GUI for Brother P-touch printers, built on ptouch-print.
• ptouch-rs (mlloyd5): Rust driver, command line and GUI for Brother P-touch printers over USB on Linux.
• ptouch-rs-notstupid: Rust driver, GUI designer and command line for Brother P-touch printers (tested with the PT-D600).
• ptouch-770: Python GTK3 GUI for the Brother PT-P700 on Linux.
• PT-P710BT-Label-GUI (🤖 AI-assisted): GUI for the Brother PT-P710BT on Ubuntu/KDE, wrapping ptouch-print.
• oh-brother (🤖 AI-assisted): Rust command line and web UI for Brother P-touch printers, a cross-platform replacement for P-touch Editor.
• ptouch-editor-wine (🤖 AI-assisted): runs Brother's P-touch Editor 6 on Linux under Wine, printing to a PT-P700.
• P-Tux: label designer for Brother P-touch printers on Linux and macOS (announced).

Self-hosted web interfaces (a server, e.g. a Raspberry Pi, drives the printer)

• brother_ql_web: web service for Brother QL printers, built on brother_ql; maintained forks include FriedrichFroebel/brother_ql_web and DL6ER/brother_ql_web.
• brother_ql_app: web app and REST API for Brother QL printers: text, images, QR codes, PDFs, a print queue.
• label-designer (teknopartz) (🤖 AI-assisted): WYSIWYG drag-and-drop designer for a Brother QL-700.
• bql-label-printer: simple text label interface for Brother QL printers with HTML templates.
• labelle-web (🤖 AI-assisted): browser designer for DYMO LabelManager printers through Labelle.
• ptouch-labelmaker (🤖 AI-assisted): web app for designing and printing on a Brother P-touch from a Raspberry Pi.
• labeler: web interface for Brother P-touch printers around ptouch-print.

Libraries, drivers and command-line tools

• ptouch-print: C command line printing to Brother P-touch printers over USB (libusb) on Linux; the reference for many of the projects here.
• brother_pt: Python package for the Brother PT raster protocol (PT-P710BT verified).
• labelprinterkit: Python toolkit for Brother P-touch printers, with a JavaScript WebUSB/WebBluetooth port (labelprinterkit-web).
• tapen: Brother P-touch printing from HTML templates.
• ptouch-bt: Brother P-touch printers over Bluetooth on Linux.
• PT-P300BT: reverse-engineered protocol for the Brother PT-P300BT (Bluetooth LE).
• brother_ql: Python implementation of the Brother QL raster protocol; continued in brother_ql2 (matmair/brother_ql2).
• brotherql-webusb: printing to Brother QL printers from the browser over WebUSB.
• node-brother-label-printer: Node.js library for Brother label printers.
• thermal-label (🤖 AI-assisted): TypeScript drivers for DYMO LabelWriter, Brother and other label printers: Node.js, browser WebUSB and command line.
• node-dymo-printer: Node.js driver for DYMO label printers.
• dymonite: Python text and QR labels for DYMO LabelWriters, printed through CUPS.
• dymo-linux-service: stand-in for DYMO Connect's local web service on Linux, so web apps built for it can print.

More

• Label-Printing-Resources: a larger index of label printer utilities, drivers and bridges (Brother, DYMO, Niimbot, Zebra and more).
• GitHub topics: brother-label-printer, brother-ptouch, dymo-labelwriter and label-printer list many more.
• The makers' own: DYMO Connect and Brother P-touch Editor (Windows and macOS), and their CUPS drivers for printing from any Linux app.

Roadmap

• Hardware reports for the experimental printers
• PT-P900 series (360 dpi)
• A desktop build (e.g. Tauri) with native USB and raw network printing, so Windows needs no driver swap and Wi-Fi models work

Credits

This editor stands on work others did first. No third-party files are bundled, but parts of the code are ports of the projects below, kept under licences compatible with this project's GPL-3.0 and credited in each file; the tests check the ports against their sources' behaviour.

Printer protocols

• ptouch-print: by Dominic Radermacher: the Brother P-touch raster protocol, per-model quirks, USB IDs and the tape table (printable dots per TZe width).
• brother_ql: by Philipp Klaus: the Brother QL raster protocol, per-model parameters and the DK label table (sizes, printable dots, offsets).
• dymo-cups-drivers: DYMO's open-source CUPS drivers: the LabelWriter command set, and the PPD files (lw450.ppd, lw4xl.ppd) that give each DYMO label's size and printable area.
• Brother and DYMO technical references: the makers' raster command references, as documented by the projects above.

Ported code (which of our files comes from where)

• src/printers/brother-ptouch.js, the P-touch models and tape table: ported from ptouch-print's libptouch.c and device table; Copyright (C) 2013-2026 Dominic Radermacher, GPL-3.0.
• src/printers/brother-ql.js, the QL models and DK label table: ported from brother_ql's conversion.py, raster.py, models.py and labels.py; by Philipp Klaus, GPL-3.0-or-later.
• src/printers/dymo-labelwriter.js, the DYMO label sizes and margins: ported from DYMO's LabelWriterDriver.cpp and taken from its lw450.ppd and lw4xl.ppd; Copyright (C) 2008 Sanford L.P., GPL-2.0-or-later.
• src/lucide.js, the symbols and button icons: icons from Lucide, ISC License, Copyright (c) Lucide Icons and Contributors (the notice is in the file); the electrical symbols there (earth, class II, AC, DC, fuse) are our own.
• src/icons.js, the brand icons: SVG paths from Simple Icons, CC0 1.0 (public domain); the brands are trademarks of their owners.
• src/codes/qr.js: follows Project Nayuki's QR Code generator library (tables, Reed–Solomon, placement, masking); Copyright (c) Project Nayuki, MIT License, whose notice is in the file.

Standards and tools

• ISO/IEC 18004 (QR Code), Code 128, EAN-13 and UPC-A: the specifications the barcode encoders follow.
• zxing-cpp: the barcode reader used to check that every QR version and level, and the linear codes, decode.
• GNU recutils: the format of the label catalogue (catalog/media.rec); the tests check it with recsel and recfix.

Measurements

• Hardware tests: the LabelWriter 450 leading margin, the PT-P710BT margins and print length, and the DYMO 30252 calibration were measured on real printers by the project's author. Your printer reports add to this.

License

GPL-3.0-or-later (see LICENSE), with one file held at GPL-3.0 only: each source file says which in its SPDX-License-Identifier line.

• src/printers/brother-ptouch.js is GPL-3.0-only: it is ported from ptouch-print, which is licensed under GPL version 3 without the "or later" option.
• src/codes/qr.js is GPL-3.0-or-later and keeps Project Nayuki's MIT notice, as its structure follows their QR Code generator library.
• Everything else, including the code ported from brother_ql (GPL-3.0-or-later) and DYMO's drivers (GPL-2.0-or-later), is GPL-3.0-or-later.

So the editor as a whole can be used under GPL-3.0 today, and every part but the P-touch encoder under any later version too. See Credits for the sources.