# inkscape-silhouette sends cut paths to a vinyl cutter

> inkscape-silhouette is a pure Python Inkscape extension that drives Silhouette Cameo and similar plotters over the libusb backend, and it covers twenty device models from the Portrait to the Cameo 5 Alpha Plus. The device support is broad, but the installation path differs sharply per operating system, and Windows needs a driver replacement.

**fablabnbg/inkscape-silhouette** — An extension to drive Silhouette vinyl cutters (e.g. Cameo, Portrait, Curio series) from within inkscape.

- Repository: https://github.com/fablabnbg/inkscape-silhouette
- Stars: 689 · Forks: 149
- Language: Python
- License: GPL-2.0
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/fablabnbg-inkscape-silhouette

## What the extension actually does

inkscape-silhouette is an extension to drive Silhouette vinyl cutters, for example the Cameo, Portrait and Curio series, from within Inkscape. The README describes it as an extension to drive a Silhouette Cameo and similar plotter devices from within inkscape, and adds the technical summary: 100% pure python, on top of the libusb backend.

So the mechanism is direct USB. The extension talks to the cutter's USB interface itself rather than going through a vendor application, and the choice of libusb is what makes that possible on Linux and macOS without a kernel driver. The device appears on the bus as a Graftek America USB Printing Support device, which the Fedora section confirms with the vendor and product IDs 0b4d and 1137.

The repository layout shows three separate Inkscape extensions rather than one. sendto_silhouette.inx with sendto_silhouette.py is the main one, silhouette_multi.inx with silhouette_multi.py is the Silhouette Multiple Actions feature, and render_silhouette_regmarks.inx with render_silhouette_regmarks.py handles registration marks. The user guide is in USERGUIDE.md, there is a Commands.md, and the wiki linked from the README carries photos and a video of the workflow.

The separation into three extensions matches how the hardware actually behaves. Sending a cut job is one operation, printing registration marks on the sheet is another, and the multi-action feature cuts several materials in one pass, which the README says requires the xmltodict dependency specifically for Silhouette Multiple Actions.

The licence is GPL-2.0, the primary language is Python, and the last push was on 2026-10-14 with the newest tag v1.29 from 2024-09-12.

## The device list, and what working confirmed means

The supported devices section is worth reading closely, because the parenthetical notes are the honest part.

The list runs from Silhouette Portrait, Portrait 2, Portrait 3 and Portrait 4, through Cameo, Cameo 2, Cameo 3, Cameo 4, Cameo 4 Plus, Cameo 4 Pro, Cameo 5, Cameo 5 Plus, Cameo 5 Alpha, Cameo 5 Alpha Plus and Cameo Pro MK-II, and then the Curio, the Craft Robo CC200-20 and CC300-20, and the SD 1 and SD 2.

Several entries carry a status marker. Portrait 2, Portrait 4, Cameo 4 Pro, Cameo 5 Alpha Plus and Cameo Pro MK-II are marked working confirmed, and the Curio is marked as partial success confirmed in issue 36.

That distinction is the useful part of the list. The project is telling you which models have been verified to work and which one is only partly working, rather than claiming everything in a family. The Curio is the odd one out, and the issue reference tells you where to look if you own one.

The reason the list is so long is that these machines share a common protocol and a common USB identity, and the differences are mostly in the supported media sizes and the tool head. That is good news for anyone whose machine is in the list and bad news for anyone whose cutter is from a different vendor, since nothing in the extension is generic.

The repository also carries an examples/ directory with the sort of files a user would want to check a machine against: a dashline.svg, a narrow_serpentine.svg, a sharp_turns.svg, a fablab_logo_stencil.svg, a gecko_silhouette.svg, a testcut_sq_tr.py with its dump and command files, and a registration-marks/ directory.

## The dependency list, and what each entry is for

The requirements.txt is short and the comments on each line explain which feature needs what, which is unusual and useful.

```text
numpy      >= 1.21.5
pyusb      >= 1.2.1
lxml       >= 4.8.0
xmltodict  >= 0.13.0 # required for Silhouette Multiple Actions
cssselect  >= 1.1.0  # required for inkscape >= 1.2
tinycss2   >= 1.1.1  # required for inkscape >= 1.4
matplotlib >= 3.7.2  # required displaying cut preview
```

pyusb is the USB layer, and lxml handles the SVG that Inkscape hands over. The three conditional entries are the interesting ones. cssselect is needed from Inkscape 1.2, tinycss2 from Inkscape 1.4, and xmltodict for the multi-action feature, because that feature parses a nested document describing the material list rather than a single SVG path.

matplotlib for the cut preview is the one that stands out, since a preview is a display nicety and it pulls in a numerical stack to draw a picture of what is going to be cut. The comment says it is required for displaying the cut preview, so the feature is not optional in practice unless you skip the preview.

The setup.py is where the packaging is declared, and it is an old-style one: it uses distutils.core setup, reads the version and author out of sendto_silhouette, sets the package to the silhouette package, and declares the licence as GPL-2.0 with the GPLv2 OSI classifier and a Development Status of 5 - Production/Stable. There is also a Makefile with the install and install-local targets, a distribute/ directory that generates the platform specific packages, and a po/ directory for translations with an update_pot target.

## Installing on Linux, and the two ways it differs

The installation instructions are per distribution, and the difference between them is whether you take a binary package or build from source.

On Ubuntu the README warns that SNAP packages may cause issues and that it uses the deb file shown later in the section. The dependency steps are:

```bash
# Add inkscape dev team's PPA key to APT.
# This project require minimum of inkscape V1.0+
# But we want to always keep to latest inkscape version
sudo add-apt-repository ppa:inkscape.dev/stable

# Install Inkscape
sudo apt-get update
sudo apt install inkscape
```

The USB and Python requirements follow, with python3-usb for USB support, python3-wxgtk4.0 for the Silhouette Multiple Actions requirements, and then pip with the requirements file.

Once those are in place, you scroll down to the latest release, head to the Assets section, click the .deb file and install it with sudo apt-get install ./*.deb.

On other Debian based systems the route is the source archive. You download the main.zip, unzip it, change into the directory, and execute make install-local to install just in your user account, or sudo make install to install for all users. Then install python3-usb, or python3 -m pip install usb without permissions, restart inkscape, and check that you see new menu entries under Extensions, then Export, then Send to Silhouette, and the Silhouette Multi Action entry.

The Arch instructions are the same shape in one line, with sudo pacman -S inkscape python-lxml python-pyusb python-tinycss2 python-matplotlib followed by a git clone, and then make install-local or sudo make install.

The Debian package is the easier path because it handles the extension placement and the udev rule for you. The source path is the one to use on a distribution with no package, and it installs into your own account without root.

## The udev rule on Fedora, and the driver swap on Windows

Two platforms need a step that the others do not, and both come down to the same thing: making the operating system let an unprivileged process talk to the cutter.

On Fedora the necessary packages are installed with sudo dnf install python3-pyusb python3-matplotlib make gettext, then the repo is cloned and installed with sudo make install. After that a new rule file has to be added to the udev device manager at /etc/udev/rules.d/99-graphtec-silhouette.rules containing:

```text
SUBSYSTEM=="usb", ATTR{idVendor}=="0b4d", ATTR{idProduct}=="1137", MODE="666"
```

and the file is loaded with sudo udevadm trigger. The repository ships the same rule as silhouette-udev.rules with a silhouette-udev-notify.sh helper alongside it.

On Windows the step is heavier, and it involves replacing a driver. You download Zadig, go to the options menu and choose List all devices, look for USB Printing Support in the dropdown, ensure the USB ID is 0B4D (Graftek America), select the driver libusb-win32 (v1.2.6.0) which installs a libusb0 port for Windows, and click replace driver.

The README also documents the undo, and it is worth reading before doing it: run Zadig again, list all devices, find the same USB Printing Support entry with the same ID, select the driver WinUsb, and click replace driver. The reason to know this is that replacing a driver with Zadig is a system-wide change, and the original driver is usually what the vendor's own software expects.

Windows also needs a Python that Inkscape can use, and the README notes that Inkscape usually comes with a version of Python, and that the feature under Program Files/Python has to be ticked during installation or added later.

## macOS, FreeBSD and the Bluetooth path

macOS has its own shape, and it is the one platform with a wireless option.

The prerequisites are Homebrew, then brew install libusb, then Inkscape either through brew install inkscape or manually from their website. The extension is installed with ./install_osx.sh, and the repository also carries install_osx_stage2.py for the second step.

The macOS-specific detail is the interpreter. You have to add the suggested python interpreter for user extensions in ~/Library/Application Support/org.inkscape.Inkscape/config/inkscape/preferences.xml on the group id extensions element, with the interpreter attribute pointing at a specific python3, for example a path inside a virtual environment. The README links the Inkscape wiki on extension interpreters for the details of selecting a version.

That is the step people usually miss on macOS, because Inkscape 1.x extensions run under a Python that has to be selected rather than assumed.

The installer also includes bleak, which provides Bluetooth Low Energy support, and the README warns that on the first BLE scan macOS may ask for Bluetooth permission for Inkscape, and that you should allow it to discover and connect to the cutter.

FreeBSD is the shortest instruction set in the README, and it comes with a warning about the recipe. The note says the recipe specifies py39-libusb1 and that in case this is out of date you need to choose the usb package appropriate to the version of python that runs by default as python3. The install itself is sudo pkg install inkscape py39-libusb1, then the archive, then sudo make install or make install-local for the current user only.

## Where inkscape-silhouette fits, and where it stops

The comparison worth making is with the vendor's own cutting software, and with a generic Send-to-plotter workflow such as sending SVG to a cutter driver.

Against the vendor software, the difference is that the cutting happens where the design is. Silhouette's own tools take an import and a cut path, and the design lives in a separate application. This extension keeps the vector work in Inkscape, which for a fab lab that already designs in Inkscape means the cut line and the artwork are the same document, and the registration marks are generated by an extension rather than imported from elsewhere.

Against a generic plotter workflow, the difference is device knowledge. A generic Send to plotter path treats the machine as a pen plotter and deals in HPGL or similar. This extension speaks the Silhouette protocol over USB, which is what makes the multi-action feature and the registration mark rendering possible, and what makes the tool work with a media-loaded machine rather than a pen.

The limits are honest. The device support is a closed list, and a cutter from another vendor is simply not addressable. The Curio is documented as partial success, so a Curio owner should expect to hit a wall somewhere. The dependency on matplotlib for the cut preview is a heavy price for a display feature. The udev rule or the Zadig driver swap is a hard requirement on Linux and Windows respectively, and the Windows driver replacement in particular is a system-level change that a locked down corporate machine will not permit.

The version cadence is worth noting for an adopter. The newest tag is v1.29 from 2024-09-12, before v1.28 in 2023 and v1.27 in 2022, while the last push was on 2026-10-14, so the working tree is well ahead of the newest release. The current code is at a version that has not been packaged as a release, and the setup.py still imports setup from distutils.core, which is removed from the standard library in recent Python versions, so a source install on a current interpreter is not as simple as it was.

The GPL-2.0 licence is permissive enough for a lab or a small business to use freely, and the extension itself is a normal Inkscape extension, so it is installed into the extensions directory and appears in the menus like any other.

## Conclusion

inkscape-silhouette suits a fab lab or maker whose cutter is a Silhouette machine and whose design work is already in Inkscape, since the extension replaces the vendor's own cutting software without changing the drawing workflow. It is the wrong tool if you have a different plotter, because the device support list is specific to Silhouette and Craft Robo models, and it is the wrong tool if you cannot install a udev rule or replace a Windows driver, since both are required for the device to be reachable at all. Before installing, check your exact model against the supported list, read the wiki linked from the README for photos and a video of the workflow, and on Windows expect to swap the USB Printing Support driver with Zadig before anything works.

## FAQ

### Which Silhouette devices does inkscape-silhouette support?

The list runs from Silhouette Portrait through Portrait 4, Cameo through Cameo 5 Alpha Plus, Cameo Pro MK-II, the Curio, the Craft Robo CC200-20 and CC300-20, and the SD 1 and SD 2. Several models are marked working confirmed, and the Curio is marked as partial success confirmed in issue 36.

### How do I install inkscape-silhouette on Ubuntu?

Add the Inkscape development PPA with sudo add-apt-repository ppa:inkscape.dev/stable, install Inkscape with sudo apt install inkscape, install python3-usb, python3-wxgtk4.0 and pip, then install the Python requirements. Finally download the .deb from the Assets section of the latest release and install it with sudo apt-get install ./*.deb. The README warns that SNAP packages may cause issues.

### What does the inkscape-silhouette extension need on Linux to reach the cutter?

A udev rule so an unprivileged process can talk to the device. On Fedora you create /etc/udev/rules.d/99-graphtec-silhouette.rules with SUBSYSTEM=="usb", ATTR{idVendor}=="0b4d", ATTR{idProduct}=="1137", MODE="666" and then run sudo udevadm trigger.

### Why does Windows need Zadig for inkscape-silhouette?

Because the extension talks to the cutter over libusb rather than through a vendor driver, and the USB Printing Support device with the ID 0B4D (Graftek America) has to be bound to libusb-win32 instead. The README documents the reverse operation, selecting the WinUsb driver to undo it.

### What are the Python dependencies of inkscape-silhouette?

numpy 1.21.5 or newer, pyusb 1.2.1 or newer, lxml 4.8.0 or newer, xmltodict 0.13.0 or newer for Silhouette Multiple Actions, cssselect 1.1.0 or newer for Inkscape 1.2, tinycss2 1.1.1 or newer for Inkscape 1.4, and matplotlib 3.7.2 or newer for displaying the cut preview.

## Sources

- [fablabnbg/inkscape-silhouette on GitHub](https://github.com/fablabnbg/inkscape-silhouette)
- [Issues](https://github.com/fablabnbg/inkscape-silhouette/issues)
- [License: GPL-2.0](https://github.com/fablabnbg/inkscape-silhouette/blob/main/LICENSE)
- [README](https://github.com/fablabnbg/inkscape-silhouette/blob/main/README.md)
- [Releases](https://github.com/fablabnbg/inkscape-silhouette/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/fablabnbg-inkscape-silhouette