This is a major update that includes many performance improvements, quality of life fixes, 8 new effects, a rewritten layer rendering engine, and a completely new and modernized FileType plugin system. Much of the work has gone into preparing the app for the features and functionality that will be coming in the big 6.0 version that will be coming later (starting with new blend modes and layer folders). There are also 8 new effects and experimental support for running on Wine.

New FileType Plugin System

The original FileType plugin system dates back to 2005 with the v2.5 release. It has withstood the test of time in the sense that it still works and has provided a lot of value for a lot of people, but it has also aged poorly in ways that have prevented progress in other areas of the app. It was written at a time when .NET itself was just 3 years old, and I had no clue that the project’s longevity would stretch so far into the future, nor that so many plugins would be developed.

The old FileType plugin system is tightly coupled with the Document, Layer, and Surface classes which Paint.NET also uses internally for UI and rendering purposes. They only support the 32-bit BGRA32 pixel format and a flat list of bitmap layers. The new FileType system works through interfaces such as IFileTypeDocument<TPixel> and ILayer<TPixel>, along with a rich and strongly-typed imaging framework providing support for a wide variety of pixel formats, pooled bitmap allocation, scaling/interpolation, quantization/dithering, format conversion, color management, and more.

Decoupling the FileType system from the internal classes means that these two systems can now evolve independently, and internal details can be abstracted away or hidden from plugins. The new plugin system has been designed to support graceful versioning, meaning that functionality can be added or changed in the programming interfaces that are provided to plugins while maintaining compatibility for plugins that have already been published. New layer types and topologies (e.g. layer folders) can be added without breaking existing plugins, new blend modes can (and will) be introduced, and bitmap layers can finally be migrated to a tiled storage system.

Note to plugin authors: In general, plugins should provide pixel data in the image file’s original format without converting it to BGRA32. In other words, let Paint.NET handle the conversion, whether you’re supplying pixels as RGBA64, BGR24, or even an HDR format such as RGBA FP16. Paint.NET will figure out the best conversion for pixel format and color profile handling, and when expanded pixel format support is rolled out your plugin can automatically benefit from it. Note that plugins can query at runtime which pixel formats are supported and which are native, in case they do want to do the conversion themselves for whatever reason.

New Plugin SDK available on NuGet

Both the Effects and FileTypes plugin systems have been modernized in recent years, but an easy to reference NuGet package was still missing. Now you can add a reference to the Paint.NET.Plugin.SDK package instead of manually typing out assembly references pointing at your local Paint.NET installation. Note that the classic/legacy plugin systems are not part of the SDK.

New Layer Rendering Engine

The old layer rendering engine has its roots going all the way back to the 1.0 release in 2004. Over the years it has migrated from C# to C for performance reasons, and then back to C# once the language and .NET’s JIT had finally caught up to (and surpassed!) the performance of the native C compiler’s code generation. However, it has no SIMD optimizations, it only has 8 bits of integer precision (“unsigned integer 8”, or “UI8” for short), and the code was very messy and difficult to maintain. Working with many layers can result in incorrect colors or banding artifacts as off-by-1 errors accumulate across multiple layers. 

With 5.2, this has been completely rewritten and upgraded to use 32-bits of floating-point precision per channel (FP32). It is fully optimized for AVX2, AVX512, and ARM64 NEON thanks to .NET’s new platform-agnostic intrinsics support. Because FP32 uses a lot more memory bandwidth than UI8, many optimization tricks have been employed so that there is no perceptible performance reduction from previous versions (the old renderer not using any SIMD also helps this comparison). Performance really shines on CPUs with AVX512 support (e.g. AMD Zen 5) even with standard dual channel memory.

A driving factor behind this change was to prepare for future versions of Paint.NET that will expand pixel format support beyond BGRA32. In order to do this in a sane and maintainable manner, having a canonical pixel format became important so that each rendering kernel only needs to be written once. All of the rendering kernels can now operate exclusively on FP32 data, with high-performance format conversion and color transform kernels at the beginning and end of the rendering pipeline. This will make it much easier to add application-level support for high bit-depth formats like RGBA64, and HDR formats like RGBA FP16. The layer rendering engine already supports it, the rest of the app just needs to catch up.

HDR Tone Mapping Support

There are several standard file formats with support for HDR, including PNG, JPEG XL, AVIF, HEIC, and even JPEG XR. Previous versions of Paint.NET could load these images, but would not take into account the extended dynamic range — anything about 1.0 would be clamped, usually resulting in blown out colors. Sometimes the color space was not handled correctly either, resulting in other problems.

Paint.NET now has support for HDR metadata with the new FileType plugin system, and will apply HDR-to-SDR tone mapping as part of the loading process. Future versions will have native HDR support, at which point the automatic SDR tone mapping step will be removed.

We can compare the results of Paint.NET v5.1.2 versus v5.2 with a screenshot from Cyberpunk 2077, which was taken with the help of SpecialK. This is how the HDR AVIF image file looks after being opened in each version of Paint.NET:

Paint.NET v5.1.2 (no tone mapping)
Paint.NET v5.2 (tone mapped to SDR)

Nearest Neighbor (Antialiased)

Available with the Move Pixels tool, this is similar to what some retro game emulators call “sharp bilinear.” It first uses Nearest Neighbor to upscale to the ceiling of the requested scaling factor (e.g. from 100% to 700% instead of from 100% to 632%), and then uses bilinear to downscale to the target scaling factor (700% -> 632%). This retains the blocky/pixelated look of Nearest Neighbor, but with the added effect of antialiased edges. This works for both scaling and rotation.

(credit: Stardew Valley)

New Effects

This release adds 8 new effects. These fill in the Artistic submenu, add some new dithering capabilities, two new distortion effects, and finally support for high-quality halftoning.

• Artistic -> Linocut
  • Simulates a relief printmaking technique where an artist carves an image into a sheet of linoleum, rolls ink onto the raised surface, and then stamps it onto paper or fabric.
• Artistic -> Mosaic
  • This is sort of like an expanded Pixelate effect with optional beveling and grout separation between the “pixels.” There are numerous tiling patterns to choose from.
• Artistic -> Pointilism
  • Simulates a painting technique where an artist applies small, distinct dots of color next to each other to form an image.
• Artistic -> Stained Glass
  • Simulates stained glass. Similar to Distort->Crystalize, but more fleshed out.
• Color -> Ordered Dither
  • Simple ordered dithering patterns from the Bayer, Spiral, Dual Spiral, Blue Noise, and White Noise families.
• Distort -> Spherize
  • Similar to Distort -> Bulge, but produces an actual spherical shape.
• Distort -> Waves
  • A very configurable effect that can produce waves, ripples, spirals, flowers, and other shapes.
• Stylize -> Halftone
  • Simulates physical printing, such as seen in newspapers or comic books, using either CMYK or black-and-white dots. The conversions between RGB and CMYK are color space aware and operate in linear gamma space when appropriate, resulting in a very high quality result.

Examples of each new effect:

Original

Linocut

Mosaic

Pointilism

Stained Glass

Ordered Dither

Spherize

Waves

Halftone

Experimental Wine Support

NOTE: This is not for the faint of heart! It is experimental and targeted towards early adopters who aren’t afraid of missing functionality, performance issues, crashes, and wrestling with dependencies. Calling it “pre-alpha” would be generous.

I’ve recently made major progress getting Paint.NET working on top of Wine, which means Paint.NET can now finally run on Linux and Mac. This is available as a separate package that you can download from a dedicated GitHub repository with its own Releases page and Issues tracker. Updates will be independent(-ish) of the main Windows packages, at least for the foreseeable future. Each new Windows release will be accompanied by a corresponding Wine release so that it doesn’t fall behind in functionality. I do not know when (or if) this will reach a stable and performant level of quality; I suspect that Wine will end up being a stepping stone towards something else, but we’ll see what happens.

What’s coming in 6.0?

The next big update will introduce a new .PDN file format that will finally remove the last barrier to adding new features to the document and layering systems. High bit-depth pixel formats, new blend modes, and layer folders are planned to be the first to take advantage of this. Later on, features such as adjustment layers, text layers, and HDR are also planned (to name just a few).

Change Log

Changes since 5.1.12:

• Updated to use .NET 11. Note that on Intel/AMD, having a CPU with SSE4.2 is now a hard requirement.
• Added experimental Wine support which enables Paint.NET to run on Linux and Mac. You can download builds on the Paint.NET-for-Wine GitHub page.
• New translation: Uzbek (uz)
• New: Paint.NET.Plugin.SDK NuGet package. You no longer need to manually add assembly references with paths that are hardcoded for your local system.
• New modernized FileType plugin system
  • Support for a wide variety of pixel formats. The classic BGRA32 is of course available, as well as RGBA64, CMYK, or even HDR formats like RGBA FP16.
  • Plugins can provide image data in HDR formats, which will be automatically tone-mapped and converted to BGRA32. Future versions of Paint.NET will support HDR natively and plugins will not need to be updated.
• Added CICP support for AVIF, JPEG XL, and PNG image files. This is also available for FileType plugins to make use of.
• Added HDR tone mapping support for AVIF, HEIC, JPEG XL, JPEG XR, and PNG. If the image file being opened is HDR then it will be converted to SDR in an appropriate manner. Eventually Paint.NET will have native support for HDR editing and this conversion process will be unnecessary.
• Rewritten and extensively optimized layer rendering engine
  • Precision is significantly improved by using 32-bit floating point (FP32) instead of 8-bit integer (UI8). This eliminates certain types of artifacts and incorrect colors that can happen in the old renderer with multiple layers.
  • Fully optimized for AVX2 and AVX512. Significant performance gains on systems with AVX512 support due to a high compute:memory ratio.
• Renamed Edit -> Copy Merged to Edit -> Copy Flattened.
• Significantly optimized the performance of copy-to-clipboard (Edit -> Copy and Edit -> Copy Flattened) by up to 95%
• Reduced temporary memory usage by 50% for Edit -> Paste into New Image.
• New: Paint Bucket and Color Picker now support holding Ctrl as a shortcut key for specifying Image sampling mode (aka “sample all layers”).
• New: The Eraser tool now supports selecting a Fill pattern in the toolbar.
• Improved: When using Image->Resize and “Maintain aspect ratio”, the rounding has been improved to reduce the aspect ratio error.
• Fixed a bug in the Move tools where shift-clicking on a side handle (north/south/east/west) would sometimes cause it to move on its own by 1-2 pixels.
• Fixed: The Colors window will no longer erase the hex field if an invalid character is typed.
• Fixed the tooltips in the File -> Open Recent menu by removing them (WinForms is just very buggy here). The directory paths are now shown on a second line of text instead.
• Renamed the “Move Selected Pixels” tool to “Move Pixels.”
• New: Added a “Nearest Neighbor (Antialiased)” resampling mode to the Move Pixels tool.
• Substantial performance improvements for larger images. Fluidity of zooming and scrolling is significantly better. A lot of lag, hitching, and even pausing has been entirely eliminated.
• Optimized the performance of the canvas when the zoom level is >100% so that it only requires 1 rendering pass. This will mostly help to reduce power usage on laptops.
• Improved the latency of the brush tool’s “preview cursor” by 1 frame.
• Added some extra digits past the decimal place for the zoom level in the status bar.
• Fixed a rare crash with the brush tools when adjusting the brush size. This crash could only be reproduced with external automation (e.g. macro record/playback with AutoHotKey).
• Fixed an issue when drawing a selection using the intersect combine mode that would make the selection disappear and cause other weird issues with history (undo/redo).
• Fixed a rare crash that could happen while switching tools while also changing the color
• Changed: The Move Selection and Move Pixels tools will now behave more intuitively when using constrained resizing (when holding shift). The aspect ratio that was used for a constrained resize used to be “locked in” when the selection was first drawn. The aspect ratio is now picked up when you start a constrained resize, and remembered until a non-constrained resize is performed.
• Renamed the Save Configuration dialog to Save Options.
• Fixed some cases of metadata not being preserved correctly.
• New: PNG tEXt/iTXt metadata is now preserved, which includes prompt and parameter information for images generated by Stable Diffusion et. al.
• Expanded and improved the imaging framework for plugins.
  • Added Rgb64, Rgb64Half, and Rgb128Float pixel formats.
  • Better support for a wider variety of color management transforms.
  • New interpolation modes for bitmap scalers (BitmapInterpolationMode2).
  • Channel extraction and channel replacement. This makes it easier to work with a variety of non-standard pixel formats (e.g. Gray+Alpha) that do not have direct support in the imaging framework.
  • Support for generic 2-channel pixel formats (ColorGenericXY[16, 32, 32Half, 64Float]). These are meant to be used with the aforementioned channel extraction and replacement support.
  • Support for alpha formats beyond 8-bits: 16-bit integer, as well as 16- and 32-bit floating point.
  • Better CMYK pixel format support, which enables importing CMYK32, CMYKA40, CMYK64, and CMYKA80 images.
• Improved reliability of some GPU effects/adjustments on certain older or low-end systems.
• Fixed some RNG in the Frosted Glass effect
• Fixed: Circles and ellipses drawn with the Shapes tool, with a 1 pixel brush size, and without antialiasing, are now rendered symmetrically.
• Optimized the Median Blur effect by 10-50% depending on the selected quality value.
• Optimized histogram calculation for Levels and Auto-Levels by about 20%.
• The “classic” (aka legacy) effect plugin system is now fully deprecated. Old plugins will still continue to work forever, but new ones can no longer be compiled.
• The “classic” (now legacy) FileType plugin system is now at the first stage of deprecation. You can still compile old FileType plugins but you will see a warning at compile time. The next major app update will turn the warning into an error.
• Added ControlInfoPropertyNames.AutoPopulateFileTypes, which when set to true on a FileChooser-typed property will cause it to be auto-populated with all FileTypes (built-ins and plugins) (thanks @toe_head2001!)
• Adjustments to the install and update workflow so that it only requests UAC elevation when it’s actually necessary.
• Updated bundled AVIF FileType plugin to use the new FileType plugin system.
• Updated bundled DDS FileType Plus plugin to use the new FileType plugin system.
  • The Save Options dialog will now remember the original file’s settings for the DDS format, mipmaps, and cubemaps.
• Updated bundled JPEG XL FileType plugin to use the new FileType plugin system.
• Updated bundled WebP FileType plugin to use the new FileType plugin system.
• Converted the SetupDownloader EXE from C# to C++, thus eliminating the last dependency on .NET Framework 4.8. This executable is used for the small “Any CPU” / “Web” installer.
• Fixed a scaling issue with the “compass” mouse cursor used by various tools (Move, Shapes).
• Fixed an uncommon cosmetic glitch with the selection outline when the selection quality is set to “pixelated”
• Fixed an ultra-rare hang that could happen after opening an image or when the “Committing changes” progress bar was at 70%.

Get the Update

There are a few different releases of Paint.NET:

• Microsoft Store release (recommended)

  • You can purchase it here. This helps fund development and is an alternative or supplement to sending in a donation. In addition, updates happen automatically in the background when you’re not using the app.
  • If you already have it installed, the update should happen automatically once Microsoft certifies the update, usually within the next day or so. To get the update immediately (once it’s certified), you can follow the instructions listed here.

• Classic Desktop release

  • Download the installer from the website. This is the recommended download if you don’t have Paint.NET installed. It can also be used to update the app.
  • If you already have it installed, you should be offered the update automatically within the next few days, but you can also get it immediately by going to Settings -> Updates -> Check Now.
• Offline Installers and Portable ZIPs are available over on GitHub.
• For the experimental Wine packages, you can download them over here.

​

• PyPI's redesigned project pages now warn when provenance changes
• gilguard catches the import that turns the GIL back on
• pip 26.3: pylock extras, and pip says plainly that untrusted wheels aren't safe
• All developer tools
• Extras
• Joke

About the show

Sponsored by LongLink: Open-source platform for building and running custom business applications with Python and FastAPI Connect with the hosts

• Michael: Mastodon / BlueSky / X / LinkedIn
• Calvin: Mastodon / BlueSky / X / LinkedIn
• Show: Mastodon / BlueSky / X Join us on YouTube at pythonbytes.fm/live to be part of the audience. Usually Tuesday at 7am PT. Older video versions available there too. Finally, if you want an artisanal, hand-crafted digest of every week of the show notes in email form? Add your name and email to our friends of the show list, we'll never share it.

Calvin #1: PyPI's redesigned project pages now warn when provenance changes

• Live now on pypi.org (Nov 6). Announced in July, shaped by user research, funded by OpenSSF and built by Kabu Creative.
• New Security tab on every project page shows each release's provenance state and per-file attestations, with a link to the transparency log.
• Two attestation types: PyPI Publish (uploaded by a Trusted Publisher) and SLSA Build Provenance (ties a file to its source commit, build platform and instructions).
• "No provenance" isn't a malware flag; it means the file's origin can't be cryptographically verified. That's typical for older releases or projects without Trusted Publishing.
• Four new provenance warnings: Incomplete (e.g. wheels via Trusted Publishing but sdist via API token), Inconsistent (mixed build systems or repos), Change (different repo or workflow than last release), Loss (stopped publishing attestations).
• Warnings are meant to catch files that may not have come from the maintainers, such as after an account or publishing-workflow takeover. PyPI says a Change of Provenance "can also indicate a compromised pipeline or account takeover," and an unexpected Loss of Provenance should be treated "with skepticism until verified.”
• Warnings now sit at the top of the page with yanked, archived and pre-release banners. A quarantine banner overrides all of them. Sidebar metadata is labeled "PyPI data" or "Data verified by PyPI."
• Release files tab gets search, filters, a per-file provenance column and orange icons for "late" files (uploaded more than 14 days after release). Those only appear on releases from before July 2026, when PyPI started rejecting new files after 14 days.

Michael #2: gilguard catches the import that turns the GIL back on

gilguard catches a nasty free-threading surprise: importing a C extension without declared free-threading support can turn the GIL back on for the rest of the process. Import gilguard first and it raises a detailed error naming the extension, distribution/version, import chain, and the line of your code responsible.

• A transitive dependency can undo your move to free-threaded Python. Fail at the offending import instead of discovering lost parallelism in a benchmark.
• Uses import hooks plus CPython's warning path to catch GIL activation; GILEnabledError inherits BaseException, so even except Exception won't swallow it.
• python -m gilguard audits installed top-level packages in fresh interpreters. Supports targeted modules and JSON output; exits 1 when it finds an offender for CI.
• The audit misses extensions loaded lazily on first use. Exercise those paths in tests with gilguard installed early; one process can identify only its first GIL-flipping import.
• GILGUARD_ACTION=warn reports without stopping; off permits standard builds. Default mode raises on standard Python or an already-enabled GIL. PYTHON_GIL=0 prevents activation, so the guard cannot detect offenders there.
• Published on PyPI as 0.1.0. Install with uv pip install gilguard. Python 3.13+, MIT; no runtime dependencies.

Calvin #3: pip 26.3: pylock extras, and pip says plainly that untrusted wheels aren't safe

• pip 26.3 released Nov 2. Its security policy now says pip "has never considered installing untrusted wheels safe," because Python's import system is dynamic, so pip can't guarantee installing a wheel won't execute third-party code (#14412).
• The change: pip blocks unexpected imports during wheel installation "to avoid loading code from packages being replaced." It loads what it needs for installing and error reporting up front (PR #14247, merged Nov 2: https://github.com/pypa/pip/pull/14247).
• CLI vs. library use: from the command line, imports stay blocked until pip exits. Code that calls pip programmatically gets warnings after control returns.
• Rolled out in steps: pip 26.1 started warning ("Unexpected import of '...' after pip install started. pip 26.3 will enforce this behavior change"), and 26.3 turns it into an error. Tracking issue #13842 collected reports before enforcement: https://github.com/pypa/pip/issues/13842
• What tripped it in the wild: a .pth startup hook at Pradyun Gedam's workplace that registers an atexit handler to report interpreter usage metrics over HTTP (https://github.com/pypa/pip/issues/13842#issuecomment-4613463933), plus warnings involving lark_oapi and rich._emoji_codes.
• Escape-hatch debate: the author, Damian Shaw (notatallshaw), suggested appending module names to pip._internal.commands.install._EAGER_IMPORTS. Pradyun objected that this requires importing from pip._internal, that importing pip's install command is expensive (about 689 ms with no .pyc files and a cold filesystem cache), and that pip isn't necessarily installed in every environment. Shaw's reply: it "just moves where the import cost is," and turning the warning into an error is "crucial."
• Interrupted installs: pip now writes recovery metadata and reports recovery failures and where it kept backups. An interrupted uninstall may need manual recovery, and an interrupted --target install can leave a partial target directory.
• Also in 26.3: -r pylock.toml[extra1,extra2] for extras, --group pylock.toml:docs for non-default groups, --no-binary with pylock files, and pip refuses to follow an HTTP redirect to a file: URL.

Michael #4: All developer tools

HeyUtils is a collection of 306 free developer utilities in 41 categories, with no account or installation required. The full catalog covers data conversion, APIs, networking, DevOps, frontend work and binary protocols. Python developers get model generation and packaging helpers alongside the everyday formatters and decoders worth bookmarking.

• One bookmark for the tiny jobs that interrupt coding: inspect a payload, compare configs, decode a token or figure out a cron schedule.
• Data tools include JSON/YAML/TOML conversion, CSV joins, JSONPath and JMESPath testers, a jq playground, and a SQLite viewer with read-only queries.
• Python-specific options go beyond regex: generate dataclasses or Pydantic models from JSON, check PEP 440 versions, and inspect requirements.txt or pyproject.toml dependencies.
• The collection also covers JWT/OAuth debugging, DNS and TLS checks, Docker Compose, Kubernetes YAML, GitHub Actions, and frontend helpers such as color contrast checks.
• Most tools process input locally, according to the site. Network tools make requests after you start them and explain what they send; don't assume every page is offline.
• Generated models need review: sample data cannot describe a complete validation contract, and dataclass type hints do not validate incoming values.

Extras

Calvin:

• Coldframe: a stdlib-only honeypot that poses as a supermarket fridge controller** Michael:
• Announcing new Security Developer at the PSF
  • Brett Smith is joining the PSF as a Security Developer, a new role funded by Anthropic. He'll work with Seth Larson and Mike Fiedler on vulnerability response and PyPI malware removal, with more time for proactive work as the team's workload grows.
    • More paid security capacity for the Python and PyPI infrastructure we depend on every day.
    • The PSF reports 3-4x the volume of reports and CVEs for Python and pip compared with a year ago.
    • Malware published and removed from PyPI is up 60% year over year. That's a workload measure, not a claim that 60% more packages are malicious.
    • Planned work includes scaling PyPI's autonomous quarantine program and streamlining how the Python Security Response Team handles reports.
    • Smith brings software development and Linux administration experience, including work at W3C and Software Freedom Conservancy.

Joke: No papa