Versie 5.2 van het teken- en beeldbewerkingsprogramma Paint.NET is uitgekomen. Dit slaat een brug tussen het met Windows meegeleverde Paint en dure, maar zeer uitgebreide programma's als Adobe Photoshop en Corel Photo Paint. Het programma is gratis via de website van de maker op te halen, en kan voor een kleine vergoeding ook via de Windows Store worden verkregen. Versie 5.2 heeft onder meer een nieuw plug-insysteem voor bestandstypes, een nieuwe layer rendering engine, ondersteuning voor HDR tone mapping, acht nieuwe effecten en is er experimentele ondersteuning voor Wine, waardoor het programma nu ook op Linux en macOS kan worden gebruikt. De complete releasenotes kunnen hieronder worden gevonden.
Paint.NET 5.2 is now available!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 SystemThe 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, andSurfaceclasses 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 asIFileTypeDocument<TPixel>andILayer<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 NuGetBoth 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 EngineThe 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 SupportThere 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.
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.
New EffectsThis 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.
Experimental Wine Support
- 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.
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).
/i/1215530165.png?f=thumbmedium)
/u/452542/crop57b8a2dd1446b_cropped.png?f=community)
