# MyPaint: a tablet-first painting app built around libmypaint

> MyPaint is a GPL-2.0 Python painting program for Wacom-style tablets, with an infinite canvas and per-stroke brush settings. Here is how it installs, how its brush engine is split across repositories, and where it stops being the right tool.

**mypaint/mypaint** — MyPaint is a simple drawing and painting program that works well with Wacom-style graphics tablets.

- Repository: https://github.com/mypaint/mypaint
- Website: https://mypaint.app
- Stars: 2,984 · Forks: 449
- Language: Python
- License: GPL-2.0
- Published: 2026-09-24 · Updated: 2026-09-24 · Language: en
- Canonical page: https://hysenlabs.com/projects/mypaint-mypaint

## The problem MyPaint solves: painting on a tablet without a cockpit

Most raster editors grew up around photo retouching and compositing. Their interfaces carry panels for channels, paths, filters and selections, and a tablet user pays for that in screen space and in attention. MyPaint takes the opposite position. The README describes it as "a fast and dead-simple painting app for artists" and lists an infinite canvas, distraction-free fullscreen mode and extensive graphic tablet support as headline features. The audience is narrow and clearly stated: people drawing or painting with a Wacom-style tablet who want the canvas to fill the screen and the brush to respond to pressure, not a file-management console.

The second problem is brush behaviour. Painting brushes are not just a radius and a hardness value. MyPaint's feature list includes an extremely configurable brush system and brush settings stored with each stroke on the canvas. That last point matters more than it sounds. If the brush parameters travel with the stroke, reopening a file does not require the original brush preset to still exist in the same state, which is a real failure mode in editors that store only a brush name.

MyPaint also ships a pigment model rather than a plain alpha blend, described in the README as a realistic paint-like pigment model in a 15 bit Rec 709 linear RGB colorspace. That choice shapes what the program is good at. It is built for laying down colour and letting strokes interact, not for pixel-exact retouching or colour-managed print preparation.

## How MyPaint is split: the app, libmypaint and mypaint-brushes

The repository layout explains the architecture better than the feature list does. This repository is the application: mypaint.py at the top level, gui/ and lib/ for the Python side, glade/ for interface definitions, palettes/ and backgrounds/ as data, plus packaging directories for appimage/, flatpak/, windows/ and desktop/. The actual brushstroke rendering does not live here. The README states that MyPaint depends on its brushstroke rendering library, libmypaint, and on its brush library, mypaint-brushes. setup.py hardcodes the dependency as the string LIBMYPAINT = "libmypaint-2.0" and resolves it through pkg-config.

That split has consequences. libmypaint is a separate C library with its own repository, and mypaint-brushes is a separate data package. A distribution that packages MyPaint without a matching libmypaint-2.0 pkg-config file cannot build it, and the build script exits with "pkg-config could not find package" rather than falling back. The same script reads the PKG_CONFIG environment variable, so a system with a non-default pkg-config name needs that variable set before setup.py will find anything.

The build also compiles translations. The script defines a BuildTranslations command and reads MSGFMT from the environment, defaulting to msgfmt. In practice this means a source build needs gettext tooling in addition to the Python and C dependencies, and a stripped-down container image will fail at that step rather than at the painting code.

## Installing MyPaint on Windows and Linux

For most users the release page is the shortest path. According to the README, releases and prereleases contain links to standalone packages and installers for Windows, and AppImage files for Linux. The README says to download the .AppImage file and make it executable.

On Windows, the README documents winget as an option. The package is not maintained by the development team, so version lag is possible.

```bash
winget search MyPaint
```

```bash
winget install --id MyPaint.MyPaint
```

If you would rather not build, the README points Linux users at a rolling AppImage release in the mypaint-appimage repository under the tag continuous. That channel tracks the master branch rather than a tagged release, which is the trade-off: newer code, and the README's own warning that alpha releases sometimes carry crashes.

Building from source is documented as a three-step sequence, but only after libmypaint and mypaint-brushes plus third-party dependencies are installed. The README suggests trying the demo before installing anything system-wide.

```bash
git clone https://github.com/mypaint/mypaint.git
cd mypaint
python setup.py demo
```

If the demo window opens and a stroke registers from your tablet, the environment is complete. Installing and removing are both managed by the same script.

```bash
python setup.py managed_install
python setup.py managed_uninstall
```

The README defers further detail to BUILDING.md. Note that setup.py also honours OPENMP_CFLAG and OPENMP_LDFLAG environment variables, defaulting to -fopenmp, which exists because some clang versions need different flags to link. If a source build fails at the extension step rather than at configuration, that is the first thing to check.

## Where MyPaint is the wrong tool

The feature list is also a boundary. There is no mention of vector layers, text tools, filters, scripting, animation timelines, or a plugin API. MyPaint draws raster strokes and that is the whole surface. A designer who needs editable text, non-destructive adjustment layers or a CMYK workflow has no path here, and no amount of brush configuration will substitute for those.

The release cadence is the second limitation, and it is visible in the data rather than inferred. The most recent release listed is v2.0.1 from 2020-05-29. The repository itself is not archived and its last push was 2026-09-13, so work continues on master, but a user who installs a stable package is installing a build that predates years of that work. The README's own advice to Linux users points at an alpha rolling AppImage instead, which tells you where the current code actually is. Anyone who needs a fixed, supported version with a changelog between releases should weigh that gap.

The third limitation is dependency friction. MyPaint is not a self-contained binary in its source form. It needs libmypaint-2.0 discoverable by pkg-config and the mypaint-brushes data package. On a distribution that ships an older libmypaint, the build stops. The README does not document a fallback path for that case, and it does not document rollback for managed_install beyond the managed_uninstall command.

## MyPaint versus Krita and GIMP

The comparison people actually search for is MyPaint versus Krita, and the difference is scope rather than quality. Krita targets illustration and concept art with a full document model: layers with blending modes, vector and text tools, selection and transform machinery, animation, and a Python plugin API. MyPaint's README lists layers, various modes and layer groups, which covers the compositing basics, but nothing resembling a scripting surface or a text engine. If your work involves assembling many elements, Krita's document model is doing work that MyPaint does not attempt.

GIMP is the other common comparison, and it is a different axis again. GIMP is a general raster image editor built around selection, channels, filters and scripted batch work. MyPaint has no filter stack and no batch mode. Choosing MyPaint over GIMP means giving up image manipulation in exchange for a canvas that scrolls infinitely and a brush engine tuned for continuous strokes.

The honest framing is that MyPaint is not a smaller Krita. It is a program that removed the parts Krita kept, and the removal is the feature. If you have never found yourself using a filter menu during a painting session, the trade costs you nothing.

## Licence and what a fork or downstream package inherits

MyPaint is GPL-2.0, and the README describes it as Free/Libre/Open Source software with a pointer to Licenses.md for a summary of its licensing. The repository also carries Licenses.dep5, which suggests dependency licence tracking is maintained alongside the main licence file. The README does not enumerate the licences of libmypaint or mypaint-brushes in the text shown, so anyone redistributing a bundle needs to read those repositories rather than assume they match.

The practical implication for a downstream packager is that GPL-2.0 applies to the application, and the build pulls in a C rendering library and a brush data package that are separate works with their own files. Whether a combined distribution is straightforward depends on those licences, which this README does not state. That is a question for the project's own licensing documentation, not for an article. Nothing here is legal advice.

## Conclusion

Adopt MyPaint if you draw on a graphics tablet and want a canvas that never ends, a pigment model that mixes like paint, and brush settings recorded with each stroke. Skip it if you need vector output, text layout, filters or a compositing pipeline: the README lists none of those. Before committing, check that libmypaint-2.0 and mypaint-brushes are packaged for your distribution, because the source build fails without them, and confirm that the stable release channel still matches the version you need, since v2.0.1 dates from 2020-05-29 while the repository's last push was 2026-09-13.

## FAQ

### Is MyPaint free?

Yes. The README describes MyPaint as Free/Libre/Open Source software and the repository licence is GPL-2.0, with a pointer to Licenses.md for a summary of its licensing.

### How do I install MyPaint?

On Windows the README documents winget install --id MyPaint.MyPaint, and on Linux it points to AppImage files on the release page or a rolling AppImage build. Building from source requires libmypaint and mypaint-brushes first, then python setup.py demo followed by python setup.py managed_install.

### Is MyPaint better than Krita?

They aim at different work. MyPaint's README lists an infinite canvas, configurable brushes and a pigment model, while Krita covers a broader document model that this material does not describe in detail. If you need vector tools, text or scripting, MyPaint's feature list does not include them.

### What is MyPaint software?

It is a drawing and painting application for Wacom-style graphics tablets, written in Python and licensed GPL-2.0. The README lists an infinite canvas, a distraction-free fullscreen mode, layers and layer groups, and brush settings stored with each stroke on the canvas.

## Sources

- [License: GPL-2.0](https://github.com/mypaint/mypaint/blob/master/LICENSE)
- [mypaint/mypaint on GitHub](https://github.com/mypaint/mypaint)
- [Project website](https://mypaint.app)
- [README](https://github.com/mypaint/mypaint/blob/master/README.md)
- [Releases](https://github.com/mypaint/mypaint/releases)

---

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