Ink/Stitch for Inkscape Embroidery Digitizing

Why Ink/Stitch Extends Inkscape for Embroidery

Ink/Stitch addresses a specific gap between ordinary vector editing and machine embroidery production. Inkscape can represent artwork as editable SVG, but that does not by itself turn a design into stitch instructions for PES, DST, and other embroidery formats. Ink/Stitch places that digitizing work inside an existing SVG editor, so the design process stays connected to paths, shapes, text, and other vector objects rather than requiring a separate visual environment for every editing task.

The intended audience is broad. The README says the project aims to be approachable for hobbyists while providing capabilities needed by professional digitizers. It is therefore relevant to someone creating their first machine embroidery pattern, an experienced digitizer seeking an open source toolchain, or a developer who wants to extend an embroidery application rather than depend on proprietary software.

The extension is not described as a general-purpose stitch simulator by the README. Its documented subject is the design and export workflow for embroidery machines, with PES and DST named explicitly. The project homepage also provides feature, installation, tutorial, photo, and video links, but the repository excerpt does not enumerate individual digitizing controls. That distinction matters because users evaluating a particular operation, such as text conversion or a specific fill treatment, need to consult the project documentation rather than infer feature coverage from the general ambition to provide a full embroidery platform.

Ink/Stitch Repository Structure and Extension Model

The repository is a Python application organized around `inkstitch.py`, a `lib/` directory, extension assets under `addons/`, templates, symbols, fonts, palettes, and translations. That layout points to a conventional Inkscape extension with a Python entry point and supporting libraries rather than a standalone command-line embroidery package. The presence of `inkstitch.py` at the repository root makes the main extension module identifiable, while the larger directories indicate that installation includes more than one script.

The declared dependencies describe the technical path from vector geometry to machine embroidery output. `pystitch` provides the project with its embroidery writing dependency. Geometry processing relies on `shapely>=2.0.0`, graph work on `networkx`, and numerical operations on `numpy==2.2.6`. `fonttools` is relevant to font handling, while `lxml` supports structured XML work associated with SVG. `trimesh>=3.15.2` appears alongside template and rendering resources. The exact internal call sequence is not documented in the repository excerpt, so it would be speculative to claim a particular conversion algorithm.

The user-facing model remains comparatively clear. Artwork is prepared in Inkscape, and Ink/Stitch supplies the embroidery digitizing and export layer. Based on the repository structure and README, the extension includes its own UI and processing code, reusable templates, and locale resources. The repository also contains `tests/`, `pytest.ini`, `mypy.ini`, and development tooling such as `pytest`, `flake8==7.3.0`, and `mypy==1.19.1`, which shows that the project has explicit automated and static analysis paths for contributors.

Installing Ink/Stitch Across Linux, Windows, and macOS

The README sends users to the Ink/Stitch Quick Install page at `https://inkstitch.org/docs/install/` for Linux, Windows, and Mac. It does not provide a one-line installation command in the README, so this review does not invent one. Follow that platform-specific guide rather than assuming that copying the repository alone registers the extension with Inkscape.

The source configuration establishes an important baseline: Python 3.11 or newer is required.

[project]
name = "inkstitch"
version = "0.1.0"
requires-python = ">=3.11"

The Windows and macOS installers bundle a specified version of `inkex`, while Linux distributions may package Ink/Stitch against the `inkex` supplied with Inkscape. Source builds also require `wxPython>=4.1.1`. The project comments that building `wxPython` from source on Linux can be difficult and points to the wxPython downloads and GTK3 extras pages. These distinctions explain why the documented installer is the safer starting point for a normal user.

For a first real use, complete the platform guide, confirm that Ink/Stitch appears in Inkscape, create or open vector artwork, and then follow the relevant tutorial on `https://inkstitch.org/tutorials/` for digitizing and export. The README links a general video tutorial and inspiration pages, but it does not state the exact menu path, panel name, or required button sequence for turning a specific shape into stitches. Those interface details cannot be reproduced faithfully from the README. The first useful checkpoint is therefore whether the extension loads and can reach the operation covered by the chosen tutorial, not whether a particular undocumented shortcut works.

Dependency Boundaries for Source Installations

Ink/Stitch's source dependencies introduce constraints that are easy to overlook when the project is described simply as an Inkscape extension. Python must be at least 3.11, and several geometry, XML, interface, font, and numerical packages are required. The `inkex` dependency is pinned to a specific Git commit rather than left entirely unconstrained.

inkex @ git+https://gitlab.com/CapellanCitizen/extensions.git@a887f9d4c8adacd62786e4f46c8ef1467bedc1df
wxPython>=4.1.1
networkx
shapely>=2.0.0
lxml

The comments explain why that exact `inkex` source is currently used: it applies a dependency declaration fix needed for a build issue involving the latest `poetry-core`. This is useful information for maintainers and packagers, but it also means that source installation is tied to a particular extension dependency state. The repository does not provide enough documentation to describe every installer failure or recovery procedure.

Platform-specific dependencies add another layer. `pywinutils` and `pywin32` are declared only when `sys_platform == 'win32'`, while the `tomli` marker in `requirements.txt` refers to Python versions below 3.11. Since the project itself requires Python 3.11 or newer, that marker appears unnecessary for the declared minimum and may exist for legacy packaging paths. Contributors should use the supplied `requirements.txt`, `pyproject.toml`, and `Makefile` as the authoritative build inputs rather than reconstructing dependency installation from individual imports.

Where Ink/Stitch Differs from Plain Inkscape

Plain Inkscape is the clearest real alternative because Ink/Stitch is built around it. An artist can use Inkscape alone to create SVG artwork and benefit from its vector editing tools, but the README does not identify plain Inkscape as a machine embroidery digitizer or an exporter for PES, DST, and the other formats named by Ink/Stitch. The practical difference is the added embroidery-specific layer, not a replacement for the underlying vector editor.

Ink/Stitch began as work on `inkscape-embroidery`, according to the README's project history. The original code is said to be largely replaced, but the design philosophy remained centered on using a capable SVG editor as the foundation of an embroidery design suite. That approach favors familiar vector concepts and open source extensibility. It also means users need Inkscape and the extension's own setup rather than treating Ink/Stitch as an isolated stitch editor.

This distinction does not make every Inkscape user a suitable Ink/Stitch user. Someone who only needs clean SVG graphics may gain little from installing the extension. Someone selecting a digitizer should compare Ink/Stitch against the exact embroidery tasks they expect to perform. The README names output formats and the intended users, but it does not provide a complete feature matrix, supported machine list, or interface comparison. Those checks belong before adoption.

Licensing, Releases, and Maintenance Cost

Ink/Stitch is distributed under the GPL-3.0 license. That designation identifies the repository's stated software license and signals that redistribution and modification are governed by GPL terms. It is not a warranty of compatibility with every commercial workflow or machine, and the repository does not provide legal guidance about particular distribution arrangements. Users evaluating embedding, redistribution, or modified builds need to examine the repository `LICENSE` and applicable terms directly.

The repository is not archived, and its last push was on 2026-10-15. Recent release records include development builds dated 2026-10-14, 2026-10-13, and 2026-10-11. Those dates demonstrate recent repository and release activity, but they do not establish stability for every machine or workflow. The names also indicate development builds rather than numbered stable releases, so an evaluator should not treat a recent build as proof of production compatibility.

Upgrade work is not limited to downloading a new archive. The project depends on Inkscape's `inkex` environment, a Git-pinned extension dependency, Python packages, platform widgets, and packaging scripts in `installer_scripts/`. The `Makefile` detects Windows, Linux, and macOS and distinguishes the target platform from the distribution mode. Contributors should budget for testing against the Inkscape versions and operating systems they support, especially because the dependency comments describe distribution-specific `inkex` handling.

Operational Limits of the Open Source Embroidery Workflow

Ink/Stitch is the wrong tool when the requirement is only SVG editing, because Inkscape already covers that layer and Ink/Stitch adds an embroidery-specific installation and conversion environment. It is also a poor choice for someone unwilling to work with Inkscape or Python extension dependencies. The README presents Ink/Stitch as built on an existing SVG editor, so treating it as a completely standalone replacement for that workflow misunderstands its architecture.

A second limitation is the depth of the repository README. It links to external feature and tutorial pages but does not document individual controls, supported embroidery machines, thread-brand handling, stitch density controls, hoop behavior, or production troubleshooting. Those omissions prevent claims about production readiness or exact output compatibility. The repository's tests and development tools are useful engineering signals, but their presence alone does not answer whether a design will sew correctly on a particular machine.

There is also a packaging boundary. `wxPython` installation can be difficult from source on Linux, and the project uses a commit-specific `inkex` dependency to work around a build issue. These constraints can affect contributors, packagers, and users who need to reproduce an environment outside the official installers. The right adoption decision therefore depends on matching the intended operating system, Inkscape environment, output format, and embroidery workflow to the documentation for that specific case.

Editorial conclusion

Adopt Ink/Stitch when an open source, Inkscape-based embroidery workflow and support for formats such as PES and DST are requirements. Do not choose it for plain SVG editing or a standalone editor that avoids Inkscape and Python dependencies. Verify the official installation guide, your operating system and Inkscape combination, the exact machine workflow you need, and the output format compatibility before committing a production design.

Frequently asked questions

Official sources

1. inkstitch/inkstitch on GitHub
2. License: GPL-3.0
3. Project website
4. README
5. Releases