Leaderboard

v2.1 When installed, it shows up in the Effects > Text Formations > Text Fun Factory menu. This is now included in my plugin pack, you can download it there. Installer included. Go There Donate Note: This effect is GPU accelerated, over 1,770 lines of code, and requires Paint.NET v5.0.12+. The least you can do is give this post an "up vote". Here are some samples of what this plugin can produce in a matter of seconds: and the size. Works with the fonts already on your system. You control the overlap amount. Select a fill style: There are 49 built-in seamless textures you can use to fill your lettering, for example: or Using the clipboard, you can use any image you want. These images can be scaled (zoomed), rotated to any angle, and color corrected. Solid fills can take colors from your current or the default palette for each letter: Next, select your outline style, color, and size, including: or a colorful You can choose many shadow options, including color and direction: or All of the samples above show a fully customizable 3D style. If you don't like that, you can also go with: And, now for the FUN! or or Also, you can mix them all together! One last thing: You can swap the layering overlap direction so that later letters are on top of instead of behind the previous letter: What will you create with it? Fills: Outline: Shadow: 3D: Fun: History: v1.0 - Oct. 29 2023 - Downloaded 600 times

This update has a handful of small improvements and bugfixes, and many improvements and fixes for GPU effect plugin development. Get the Update There are two 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. 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. Change Log Changes since v5.0.9: New: Edit -> Paste now supports base64-encoded images, which enables copying images from Microsoft Teams (thanks @null54 for the implementation!) Fixed a rare bug that would cause selection tools to not work until the image was closed and reopened Fixed: All mouse cursors will now honor the Windows setting for adjusting the mouse pointer size Fixed a rare crash when rapidly undoing multiple actions New: Plugins can now access the built-in JPEG and PNG FileTypes through two new methods on IFileTypesService New: The Paint.NET Plugin API Documentation website is now live at https://paintdotnet.github.io/apidocs/ Fixed: All of the custom Direct2D effects now have runtime metadata (DisplayName, Author, Category, Description), which is useful for a UI that lets the user browse them (e.g. node editor) New: Added convenience constructors to many Direct2D effects so that they can be used without declaring a new local variable New: Added GaussianBlurMapEffect and BokehBlurMapEffect for use by GpuEffect plugins. They enable the blur radius to be controlled per-pixel through the use of a second input image (the "map") New: Added a RandomNoiseEffect that GpuEffect plugins can make use of Fixed various bugs with HlslBinaryFunctionEffect, HlslBinaryOperatorEffect, and HlslTernaryFunctionEffect (which can be used by GpuEffect plugins) Added Distance and Dot to the list of HlslBinaryFunctions Added Length and Mad (multiply-add) to the list of HlslTernaryFunctions Fixed the Environment property's runtime type when accessed from an EffectConfigForm (for BitmapEffects and GpuEffects with custom UIs) Fixed UIScaleFactor's methods for converting between DIPs and pixels Fixed ability to work with EffectConfigForms in the Visual Studio WinForms designer Updated the bundled AvifFileType to version 1.1.26 (thanks @null54!) Updated the bundled DdsFileTypePlus to version 1.12.6 (thanks @null54!) Updated the bundled WebPFileType to version 1.3.20. It now uses libwebp v1.3.2 which contains the fix for CVE-2023-4863/CVE-2023-5129 (thanks @null54!)

This is a small update that fixes some bugs, adds a new Latvian translation, and updates the bundled AvifFileType plugin. Get the Update There are two 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. 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. Change Log Changes since 5.0.12: New: Latvian (lv) translation Fixed the Colors window sometimes showing up at weird sizes if the system scaling (DPI) was changed between sessions Fixed a crash in the Simulate Color Depth plugin (reported by @toe_head2001) Updated the list of libraries/contributors in the About dialog with some libraries that got missed (mostly from Microsoft) Fixed some clipped/invisible text in the installer when going through the Custom flow Added the GPU driver version to Diagnostics info Fixed HistogramEffect's Bins property https://forums.getpaint.net/topic/124026-getting-an-error-when-trying-to-use-histogrameffect-codelab-sample/?do=findComment&comment=618040 Updated the bundled AvifFileType plugin to version 1.1.30.0 (thanks @null54!)

Hello everyone! We will be making this: Plugins needed: Dryad and Highlight (found in Red ochre's pack) Donut (found in Madjik's pack) Sharpen+ (by tanel) AA's Assistant (found in dpy's pack) Gaussian Blur-clamped (by toe_head) Feather (found in Boltbait's pack) Gaussian Blur - Built in Reticulation and Dragan Effect (found in ReMake's pack)

This is a small update with some quality-of-life improvements and bug fixes. Get the Update There are two 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. 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. Change Log Changes since v5.0.6: New: Ctrl+Shift+Page Up/Down can now be used to switch between tabs Improved: The selection highlight is now hidden when the Layer Properties dialog is open Improved: The Move Selection Tool will not be forced to commit its state when the image is being saved, thus preserving history entries Changed the icon for Contiguous mode (Magic Wand and Paint Bucket tools) to have better contrast with the icon for Global mode Fixed: Shortcut keys are now listed for the tooltips in the Layers and History windows and for the selection combine modes in the toolbar. The help text for the Magic Wand and Paint Bucket tools also notes that holding Shift will use Global mode. Fixed the Edit -> Copy and Copy Merged menu items from being incorrectly enabled when no image is open Fixed an issue where the selection highlight would not appear in some cases Fixed some rare rendering artifacts for GPU plugins when using the CPU for rendering Fixed an infinite loop when using BoltBait's Apply Mask twice, on two separate images with a different number of layers Removed the /setenv command-line parameter Updated the bundled DDSFileTypePlus plugin to v1.11.9.0 (thanks @null54!)

This is a GPU-accelerated effect that renders a blur (Gaussian or Bokeh) with a radius that increases as it gets further from the center of the image. This can be used to focus on a subject by blurring the area around it. I'm planning to make this a built-in effect starting with Paint.NET v5.1 (it still needs some usability work, IMO). For now, enjoy it as a plugin! NOTE: At higher radius and quality levels, this effect can be very GPU intensive! Download: IrisBlur.1.0.zip (source code is below!) This effect will be placed in the Blurs menu within Effects: Making use of the new GaussianBlurMapEffect and BokehBlurMapEffect, which are Direct2D effects available for all GPU plugins to use starting with Paint.NET v5.0.10, this effect creates a "blur map" consisting of a radial gradient that starts at 0 in the center and ramps up to the specified radius value at the edges. Here's an example using this freely licensed stock photograph (credit Sheng L): There's also a checkbox to reverse the blur, which produces a rather strange but interesting look. I'll use this other freely available stock photo (credit Joshua Rawson-Harris) as an example: Gamma can also be modified, just like with the built-in Gaussian and Bokeh blur effects. This can be used to accentuate the brightness of the blurred areas. When you crank up the gamma, you will probably also need to crank up the quality in order to avoid some rendering artifacts (just like you have to do with the built-in Gaussian and Bokeh blur effects, btw). Here are how the various blur and ramp parameters affect the blur radius. The x-axis is distance from the center of the image (or the modified center point), and the y-axis is the blur radius. The fovea value is used to specify the non-blurred region at the center, then the ramp length determines the length of the ramp between 0% and 100% blur, and then the ramp exponent determines how quickly the blur radius increases. Source Code and Developer Notes A "blur map" is an image where the alpha value of each pixel is used as the radius value, either directly or normalized in the range [0,1] and then scaled to the specified maximum blur radius (use the MapIsNormalized property to choose). See documentation links above for more information. It's important to note that the "blur map" effects are not limited to a radial gradient for the blur map. That's just what this Paint.NET GPU effect is doing. You could write your own GPU effect that uses a linear gradient (e.g. blurry at the top, in-focus at the bottom), or a sine-wave of some sorts, or just about anything. Want the blur radius to be proportional to the brightness? Then plug Environment.SourceImage into a GrayscaleEffect and then use that as the "map" input for the blur map effect. The blur map effects are implemented as approximations. It's computationally prohibitive to actually render each pixel with its own blur radius. Instead of doing that, several copies of the image are separately blurred at increasing blur radius values (the number of copies is determined by the quality slider, which is used to set the RadiusLevels or StandardDeviationLevels properties). Then, the blur map is used to select which 2 of these images should be cross-faded in order to produce an approximation of the correct blur radius at that pixel. It is not possible to avoid blurring any part of the image -- all pixels must be blurred at all levels, so the performance of these effects is greatly influenced by those two "levels" properties. Here's the source code so you can play around with it yourself. CodeLab v6.10+ is required.

This update includes another revamp of Image->Resize's resampling modes, gamma correction for key parts of the app, higher quality canvas rendering, and a host of other miscellaneous fixes and improvements. In addition, GPU-based effect plugins now default to rendering in linear gamma space (existing plugins are not affected, however!) and have better access to color management information. Gamma correction is important for maintaining luminance (brightness, basically) when an image is being processed or rendered. Sometimes this effect is subtle, but in some cases it can be quite pronounced. First up, in Image->Resize the resampling mode has been moved to the bottom into an Options section, along with a new "Use gamma correction" checkbox that defaults to enabled: The Move Selected Pixels tool has also been upgraded to support this for all resampling modes (although it's not applicable to Nearest Neighbor), and there is a new Gamma mode choice in the toolbar if you'd rather not use it for whatever reason: Speaking of which, there is a good test image for this over at https://forums.getpaint.net/topic/122409-feature-request-gamma-corrected-image-resizing/ . I'll be using the "128 / 187" image for the next two screenshots. Next up, all in-app thumbnails and the canvas itself are now using gamma correction. This ensures that luminance (aka brightness) is correctly maintained when you're zooming out on the image (and thumbnails are basically little zoom-outs of the image). Previously, the reduced size image would get darker in ways that we've all just kind of gotten used to over the years (but which is wrong 🙂). Without gamma correction, it looks like this in v5.0.3: With gamma correction in v5.0.4, it looks correct: This required a bunch of changes to how the canvas renders itself, so while I was in that code I also bumped up the quality of its rendering. When zooming in to an image, a type of antialiasing is now applied so that the pixelation effect appears more uniform. And when zooming out, multisampling is used to make the image looking smoother. There are a lot less aliasing artifacts. It's hard to show these effects in your browser because things will likely get resized and distorted, but I'll try. On the left is the original, a cloud bubble drawn into a 128x128 pixel space. Antialiasing was disabled and the brush size was set to 1. The next two images are zoomed at 267%, in v5.0.3 and then in v5.0.4. Notice how the pixelation effect is much more uniform in 5.0.4, eliminating the distortions you see in 5.0.3. If you'd like to read more about gamma correction and rendering in linear gamma space, here are some resources: Gamma error in picture scaling, by Eric Brasseur http://www.ericbrasseur.org/gamma.html GPU Gems 3 Chapter 24, The Importance of Being Linear https://developer.nvidia.com/gpugems/gpugems3/part-iv-image-effects/chapter-24-importance-being-linear Understanding Gamma Correction, Cambridge in Colour https://www.cambridgeincolour.com/tutorials/gamma-correction.htm Gamma correction, Wikipedia https://en.wikipedia.org/wiki/Gamma_correction John Carmack (of id Software, DOOM, and Quake fame) recently tweeted about how incorrect gamma correction negatively affected the 4K UHD release of The Martian: https://twitter.com/ID_AA_Carmack/status/1654528504724062217 Get the Update There are two 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. If you already have it installed, the update should happen automatically once Microsoft certifies the update, usually within the next day. 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 week or so, but you can also get it immediately by going to ⚙ Settings -> Updates -> Check Now. Offline Installers and Portable ZIPs are available over on GitHub. Change Log Changes since v5.0.3: Improved: Image->Resize has been updated The default resampling mode is now Bicubic, which has been updated to use the Catmull-Rom ("Catrom") cubic filter. This matches the Bicubic mode of the Move Selected Pixels tool (which uses Direct2D's "HighQualityCubic" mode). Added a new resampling mode, "Bicubic (Smooth)", which has no sharpening. It produces subjectively blurrier results, but is important for scenarios where you need to completely avoid the (usually) subtle ringing artifacts that other modes (Bicubic, Lanczos, and Adaptive) can introduce due to their added sharpness. "Adaptive (Best Quality)" has been renamed to "Adaptive (Sharp)" and is no longer the default resampling mode. It is still a very good choice when resizing photos, but whether you use Adaptive, Bicubic, or Lanczos is up to your own personal preference. A new option has been added, "Use gamma correction", which is enabled by default. The text box for typing in a percentage now accepts two digits past the decimal point, e.g. 35.79% Improved: Move Selected Pixels (free transform) has been updated New: Added a "Multisample Bilinear" sampling mode. This has a sharper look than Anisotropic and avoids the "ringing" artifacts that can be apparent when using Bicubic with high-contrast images (like screenshots). However, it doesn't usually work as well when reducing a selected area to a much smaller size. New: Added a "Gamma mode" button in the toolbar to toggle gamma correction on and off. The default is on, which improves the quality of rendering by preserving luminance (brightness). Fixed a bug when using Bicubic sampling that would result in added sharpening when resizing the selected area to 1/8th its original size or smaller Improved: The rendering quality of the canvas area has been greatly improved Gamma correction is now used for mipmap generation and compositing, ensuring consistent luminance (brightness) and higher quality antialiasing. Multisampling is now used for antialiasing, which eliminates pixelation distortions when zooming in, and greatly reduces aliasing artifacts when zooming out. Improved: Thumbnails within the app now use gamma correction, which ensures consistent luminance (brightness) New: GPU effects and plugins now support gamma correction, with linear gamma being the default rendering mode for new plugins. This can be changed by overriding OnInitializeRenderInfo() and setting the renderInfo.GpuEffectColorContext property to GpuEffectColorContext.WorkingSpace (the default is WorkingSpaceLinear) GPU effect plugins have better access to color management information via the IGpuEffectImage interface and its ColorContext property. All input images (e.g. Environment.SourceImage) are now provided via this interface. In addition to the built-in effects that already render with gamma correction, the following built-in effects now also render with gamma correction: Adjustments -> Exposure Blurs -> Fragment Blurs -> Motion Blur Blurs -> Radial Blur Blurs -> Zoom Blur Distort -> Bulge Distort -> Crystalize Distort -> Dents Distort -> Frosted Glass Distort -> Pixelate Distort -> Polar Inversion Distort -> Tile Reflection Distort -> Twist Layers -> Rotate/Zoom Object -> Drop Shadow Photo -> Straighten Render -> Julia Fractal Render -> Mandelbrot Fractal Fixed: Ctrl+G has been reinstated as the shortcut key for Image -> Rotate 90° Counter-Clockwise Fixed a rendering glitch in Effects -> Distort -> Dents that would sometimes result in rows or columns of incorrectly colored pixels Fixed: Some systems were having problems with Paint.NET not appearing in the "Open With" list in Windows File Explorer. This should now be fixed. Fixed: When installing an update, the desktop shortcut is no longer recreated. This means you can delete it without it reappearing after every update. This was a bug accidentally reintroduced back in Paint.NET v4.3. Increased the maximum zoom range from 1.5625% (1/64) -> 6,400% to 1% -> 10,000% Improved the reliability of the wrapper classes for Windows COM libraries (Direct2D, etc.) Improved the /ignoreCorruptPDNChunks command-line parameter to allow an additional type of corrupt PDN image to be partially recovered (thanks @null54!) Updated the bundled DDSFileTypePlus plugin to version 1.11.8.0, which adds gamma correction for mipmap generation (thanks @null54!) Updated the bundled AvifFileType plugin to version 1.1.25.0, which now uses a checkbox to enable lossless compression (thanks @null54!) Updated the bundled WebPFileType plugin to version 1.3.17.0, which reduces some confusion when using lossless compression (thanks @null54!)

Hello everyone! We will be making this: Plugins needed: Invert Colors - Built in Gaussian Blur - Built in Paste Alpha-Fill from Clipboard-Feather-Bevel Object (found in Boltbait's pack) Texture Shader (by MJW) Edge Expander (by MJW) AA's Assistant (found in dpy's pack) Gaussian Blur-clamped (by toe_head) Emaps needed: Download from my Dropbox The first few steps are taken from MJW’s tutorial here. Used with his permission. Please note that the Texture Shader settings are unique for this example only. Another simple shape that works:

From wikipedia, under Scroll (art): "The scroll in art is an element of ornament and graphic design featuring spirals and rolling incomplete circle motifs, some of which resemble the edge-on view of a book or document in scroll form, though many types are plant-scrolls, which loosely represent plant forms such as vines, with leaves or flowers attached. Scrollwork is a term for some forms of decoration dominated by spiralling scrolls, today used in popular language for two-dimensional decorative flourishes and arabesques of all kinds, especially those with circular or spiralling shapes." This plugin will generate a variety of scroll ornament patterns any time you feel a craving for some sprawling spirals coming on. ScrollGenerator.zip contains the ScrollGenerator.DLL and (CodeLab-generated) Install_ScrollGenerator.bat that will install the plugin for you. After installation, look for Effects > Render > Scroll Ornament If you are interested, the code for the plugin can be found at: https://github.com/annayudovin/PDN-ScrollGeneratorPlugin Here are some screenshots: ScrollGenerator.zip

This is a small update that improves the sharpness of the canvas, and fixes a few other small issues. Get the Update There are two 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. 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. Change Log Changes since v5.0.5: Improved the sharpness of the canvas, which had gotten too blurry in 5.0.4 in some cases Added a "reset to default" button for Image->Resize's Resampling option Fixed a rendering artifact on the canvas where sometimes the transparency checkerboard would be visible at the bottom pixel of an image when it shouldn't be Fixed a glitch with the canvas zoom slider where it would draw the tracking thumb at the wrong position when the zoom level was at 10,000% Fixed a rare hang that could happen when opening an image

BoltBait GPU Accelerated Plugin Pack (for Paint.NET v5.0+) NOTE: If you're looking for my plugin pack for Paint.NET v4.3.12, go here, or Paint.NET v3.5.11, go here. If you're in here downloading the 5.0 version of Paint.NET, you're probably familiar with my plugin pack. I have spent the better part of the last 6 months rewriting most of my plugins from scratch... taking advantage of all the new toys @Rick Brewster has given us plugin authors in Paint.NET v5.0. He has completely rewritten the Effect system within Paint.NET v5.0 (Don't worry, all your favorite classic effects will still work.) adding new capabilities for the IndirectUI system and providing access to the GPU so that our effects can run VERY fast! What's New: I have rewritten more than 25 of my plugins so that they will now be GPU accelerated! While I was in there, I also added cool new features. Be sure to check your favorite plugin! Download: Download Donate How to install these plugins. I'm going through a really tough financial time right now. So, any donation no matter how small would be very much welcome! Download Contents: The following effects have been GPU accelerated Adjustment > Black and White Plus Adjustment > Color Balance Adjustment > Combined Adjustments Adjustment > Transparency Artistic > Dream Fill > from Clipboard Fill > from File Object > Apply Alpha Mask Object > Bevel Object Object > Feather Object Object > Inner Shadow Object > Outline Object Object > Switch Alpha to Gray (This is Create Alpha Mask) Object > Switch Gray to Alpha Photo > Level Horizon / Plum Bob Photo > Meme Maker Photo > Photo Adjustments Photo > Remove Dust Photo > Vignette Plus Render > Calendar Creator Render > Flames Selection > Bevel Selection Selection > Blur Selection Edge Selection > Feather Selection Selection > Inner Shadow Selection > Outline Selection Text Formations > Text Fun Factory Object > Drop Shadow Plus The following effects are classic flavor* Adjustment > Hue / Sat+ Flip Horizontal Flip Vertical Artistic > Oil Paint+ Artistic > Pastel Blurs > Gaussian Blur+ Color > Complementary Colors Object > Paste Alpha Photo > Seam Carving Photo > Sharpen Classic Photo > Sharpen Landscape Render > Chart / Graph Render > Dimensions Render > Gradients Render > Grid / Checkerboard Render > Polygon / Stars Stylize > Edge Detect Classic Stylize > Floyd-Steinberg Dithering Outdated plugins removed from my pack Adjustment > Temperature / Tint (now built-in) Text Formations > Creative Text Pro (now Text Fun Factory) Text Formations > Outlined / Gradient Text (now Text Fun Factory) I made a new Drop Shadow plugin! This pack also includes 57 shapes and 2 palettes. These are the ones I use. *Please post a vote for which of my "classic" effects you'd like to see GPU accelerated next. Screenshots of Various Effects: Outline Selection and Outline Object got some new features and the outlines look MUCH better than previous versions. Check out some of these new features: Bevel now has a shadow angle free choice and a hard edge option. Calendar Creator now has holiday highlighting. Enter your favorite birthdays! Many of my plugins utilize tabs for making the UI much smaller than before. For example, Text Fun Factory separates the UI into basic functions: The Photo > Level Horizon effect utilizes 2 tabs, one for marking the horizon and one for finalizing your image: Some old favorites have been rewritten for GPU acceleration: Enjoy! Also, for you luddites that refuse to use the installer, here's a zip file with all the DLL's in it: BoltBaitPack610DLLs.zip How to install Paint.NET plugins. NO SHAPES FOR YOU! How about giving this post an up vote ♥️?

A gift from me to you: Version 2.0 of the Text Fun Factory has been published! Until I put this in my plugin pack, you can download above! This is now available in my plugin pack. Go get it here: https://forums.getpaint.net/BoltBaitPluginPack

Most of my paint.net work is 3D model textures for realtime environments and I felt like sharing a picture of a small black hole effect I made recently. The engine doesn't support refraction so can't fake gravitational lensing unlike you could in Blender renders, but it still looks fun and hypnotic. https://i.imgur.com/D4VMxHo.jpg The accretion disk is a variety of motion blurred random shape filled layers, many gradients and (tube) obliques, on a disk model designed to be texture animated to look like rotating plasma. The event horizon is a Blender-rendered equirectangular gradient -- making spherical textures from scratch isn't really a job for paint.net -- colored and distorted in paint.net to match. The engine can't individually spin the 1000 rock particles (only the asteroid belts as whole objects), but I manually painted a normal map that simulates all the dust surfaces spinning in a circle and animate that instead, giving them pleasing glitter. A 5 sec video clip to see things in motion: https://i.imgur.com/cx3cZjo.mp4

This is a small update that fixes a handful of bugs, and updates both the AvifFileType and WebPFileType bundled plugins to include support for loading the first frame of an animation (similar to how GIF works). Get the Update There are two 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. 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. Change Log Changes since v5.0.10: Fixed: If an image file (such as .png or .jpg) is actually a WebP image, the WebPFileType will be used for loading instead of WIC's WebP codec (which doesn't work correctly) Fixed a crash when undoing brush strokes Fixed a rare crash in the updater UI when exiting the app Fixed a crash that was preventing CodeLab's UI Preview functionality from working Updated the bundled DdsFileTypePlus plugin to v1.12.8.0. It now supports DDS files from S.T.A.L.K.E.R.: Shadow of Chernobyl, and has fixed BC5 Signed saving (thanks @null54!)

The biggest visible change in this release are some touch-ups to the Colors window. The Primary/Secondary dropdown has been removed, and instead the color boxes themselves will indicate which is the active color. In addition, inconsistencies with left/right clicking for selecting colors have been ironed out. The Colors window will also remember whether it was expanded (More vs. Less) across app sessions. Another notable change is that, by popular request, the key to hold down for centered shape drawing and uniform resizing has been changed from Ctrl to Alt. This ensures it won't interfere with Ctrl + Mouse Wheel zooming. Get the Update There are two 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. 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. Change Log Changes since v5.0.7: Improved: The primary/secondary dropdown in the Colors window has been removed. The active color is now indicated in the color box itself. Improved: The Colors window will now remember whether it's in the expanded state (More vs. Less). Fixed: In the Colors window, left clicking in the color wheel or the color palette will always set the active color, and right clicking will always set the inactive color. This was not always consistent before. Changed: The key for centered shape drawing and uniform resizing has been changed from Ctrl to Alt so that it does not collide with zooming with the mouse (Ctrl + Mouse Wheel) Fixed: The keyboard shortcut for previous/next tab is now Ctrl + Page Up/Down, to match other applications New: You can now use Ctrl + Shift + Page Up/Down to move the current tab left or right Fixed: The printing UI is now run out-of-process, which should fix a slew of reliability problems (hangs, crashes) Fixed: The "Add Color" button in the Colors window was often showing the wrong color Fixed: Effects -> Noise -> Median was incorrectly causing transparent pixels (#00000000) to turn into slightly transparent, almost black (#01010101) New: Primitive structs (e.g. RectInt32, Vector4Float) now implement IParsable<T> (for plugin developers) Fixed: UnaryPixelOps.Invert now works correctly, which was broken in the 5.0 release (for plugin developers) Updated the bundled DDSFileTypePlus plugin to version 1.12.1.0, which, which improves support for swizzled BC3/DXT5 normal maps (e.g. DOOM 3), and support for loading textures with an incorrect DDS_PIXELFORMAT size (e.g. FlatOut 2) (thanks @null54!) Updated the bundled WebPFileType plugin to version 1.3.18.0 (thanks @null54!)

This plugin will take the brightness of the pixels in an image, and make them transparent based on the values from the GUI. located in Effects > Transparency It was created to take different exposure images and combine them into a sort of HDR image. It's pretty simple in concept so I'll give an example of how I use the plugin. High, Mid, and Low exposure images: On the high-exposure image, I make the bright pixels transparent so that I have detail in the dark areas. And on the low-exposure image, I make the dark pixels transparent so that I have detail in the bright areas. Then I merge those layers (just "Normal" layer blend mode) onto the mid-exposure image. In the end, I have a photo with more dynamic range than what my basic phone camera could have gotten just on it's own. Download: SelectiveTransparency.zip CodeLabs Code:

Here is a new build of Smudge with the following changes: Added support for loading ABR files A few changes that should fix some of the high DPI issues Optimized the brush loading code Removed the dependency on BinaryFormatter Download replaced by the build at: https://forums.getpaint.net/topic/10634-smudge/?do=findComment&comment=612876 Source Code: https://github.com/0xC0000054/pdn-smudge

I have updated my plugin pack. Object Shadow Pro is back, baby! (Only, now it's called Object > Drop Shadow+ and it is GPU accelerated. Enjoy!) I also added Text Formations > Text Fun Factory into the pack. Check this one out. You're gonna love it!

This is a GPU effect plugin I've been tinkering with for the last year or so. It's based on the P² Quantile Estimator algorithm as described in these 4 blogs posts: Part 1 Part 2 Part 3 Part 4 This effect will show up in Effects -> Artistic -> Median Sketch. I'm planning to include this in Paint.NET v5.1 once it is released, but for now you can enjoy it as a plugin! Download: MedianSketch.zip Source Code is also available. My initial goal was to port Effects -> Noise -> Median to the GPU, as @BoltBait wanted it for use in the effects he was porting to PDN 5.0 and the new GPU effects system. However, this fell apart quickly because shaders cannot allocate the block of memory needed to grab an arbitrary number of samples, sort them, and then pick the middle (median) value. (Not only is it not possible, it would need an ungodly amount of memory since every pixel executes in parallel to the other pixels.) Instead I needed a median approximation algorithm, one that uses a small fixed amount of memory, operating on a "stream" of values where you don't/can't know or store all of the samples at once. I eventually found it in the blog posts linked to above. After a lot of experimentation, I was finally able to get it to work and to produce results that were almost identical to the regular median effect. However, it also required an INSANE amount of time to execute: compared to the CPU-based Median effect, this GPU-based approximation could easily take 100x longer to execute ... on a GeForce 4090! Things became much more manageable once I dialed down the number of samples and the rendering passes ("iterations"). It also produced a more artistic effect akin to some kind of coarse-grained brush stroke painting. You can think of this algorithm as taking a Monte Carlo approach to calculating a median. Instead of using all the pixels in the given radius, only a random subset of those pixels are used. Visually it reminds me a lot of how some newer games, like Cyperpunk 2077 and Alan Wake 2, do some of their path-traced rendering, especially for reflections (esp. Alan Wake 2's intentionally distorted mirrors). Instead of rendering all pixels at full fidelity, which is prohibitive for performance reasons, only some of the pixels are rendered and then the rest are guessed/interpolated/extrapolated. A high-end GPU is not required, but you will appreciate this effect more -- especially at the highest values for Radius and Iterations -- if you have a modern discrete GPU such as a GeForce 1060, AMD Radeon RX 580, or newer. Here's an example using a stock photo by Ali Pazani: Here's another example using a picture of a Ferrari. First screenshot is the original, then using Median Sketch at default settings, and then with the Percentile set to maximum: Another example of how this can create a brush stroke-y art effect:

Version 2.0.0.1 posted. This fixes an issue where Assemblies were loaded incorrectly, and could then cause a crash in CodeLab.

Time for this plugin to be released! Yay!!

This is a small update that fixes a few important bugs. Get the Update There are two 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. 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. Change Log Changes since v5.0.8: Fixed: When using Alt+Tab, the internal state of the Alt key could get 'stuck' when the Shapes or Line/Curve tool was active, causing the next shape or line/curve to be drawn from the center Fixed: Sliders were not responding to the mouse wheel (regression in 5.0.8) Fixed the DeviceEffect.Properties.Min/MaxInputCount properties, which were throwing an ArgumentException (for plugin authors) Fixed a rare crash at app exit due to a race condition in the auto-updater Fixed a rare crash when the system resumes from sleep mode, due to a race condition in DWM reporting whether composition is enabled Fixed a rare crash when using copy+paste due to .NET Runtime issue #84994 https://github.com/dotnet/runtime/issues/84994 Updated the bundled DDSFileTypePlus plugin to v1.12.2.0, which fixes the inability to save on ARM64 systems (thanks @null54!) Updated the bundled WebPFileType plugin to v1.3.19.0, which fixes the inability to save on ARM64 systems (thanks @null54!)

I have coordinated with @SodiumEnglish to add "Permanent Links" to the Plugin Index. Below the search filters, there is now a button that creates a link based on your set parameters. The button will create links like this: https://forums.getpaint.net/PluginIndex?keywords=Grid&author=All+Authors+&type=1&status=7&compat=3&order=title&menu=All+Menus+&release=0 If you only care about certain search parameters, you can omit the other parameters from the URL. If you do omit a parameter, the default value of that parameter will be used. So, you have sorter links like these: https://forums.getpaint.net/PluginIndex?author=toe_head2001 https://forums.getpaint.net/PluginIndex?keywords=Grid

128x128

Release version 3.3.5, which updates G'MIC to version 3.3.5.

I know @toe_head2001 has an excellent graph paper plugin, however, it doesn't include labels and shape drawing. So, I rolled my own. I won't publish this as his is better than mine. But, I thought someone might find it interesting as it is GPU accelerated. CodeLab source for BBGraphPaper.cs : I use this when helping my kids with their geometry homework. Since the script is just for my own use, it doesn't have a lot of error checking. And, I haven't bothered to go back and clean it up. // you've been warned! Each shape gets a different color. The first shape gets color index 2, red. Then, each shape after that gets the next color from the default color palette. EDIT: Download v2.1 below!

Version 2.1! Just a little clean up of the UI... Added a few more controls to change colors and other options. My son really finds this helpful in his Geometry class. Often, problems will be something like, "You have a triangle with points A(-5,0) B(2,6) and C(6,-2)..." etc. This gives him a quick way to create his drawing for working the problem. This is why I wrote this plugin. Another use for this plugin is to make simple dot-to-dot puzzles for children. Here's one I made: Anyway, NOW I'm done tinkering with this! BBGraphPaper.zip Enjoy.

Fixed in version 1.1.29. Release version 1.1.29, which fixes loading images with a restricted ICC color profile.

It will remember the settings for an effect until you exit Paint.NET. I'm considering a feature that would add some kind of save/load/undo/redo toolbar at the bottom of most effects and adjustments (those that are IndirectUI-based). It wouldn't be available until sometime later next year, however.

I joined an October drawing challenge back in October, but I only did sketches everyday since a full illustration would take too long. Now, I am finishing those sketches one by one. I almost forgot. New birthday, new profile pic (new self-portrait):

Hello, I saw this type of image some time ago and there is post about it. There is a little tutorial on how to create it. https://forums.getpaint.net/topic/116863-simulate-old-bw-photo-printing-system/?do=findComment&comment=573950

Effects->Color->Vector Rotation (Axis-Angle) Effects->Color->Vector Rotation (Euler) Effects->Color->Vector Cross Product Download: F_ColorVectorRotations.zip Description: I've been geeking about quaternions and color space conversions recently, which led me to wonder what happens if you interpret one image's pixels as 3-dimensional vectors and another image's as quaternions, then rotate the first one's pixels. There's three methods available: Axis-angle representation - each color determines a 3D axis, and its intensity or alpha the angle. Euler angles - each color component determines amount of rotation around each of the 3D axes. Vector cross product - each color determines a second vector and does a cross product (straight quaternion multiplication). First two produce similar effects but are mathematically different, with axis-angle being the "less messy" option. Cross product generally turns things black or does crazy things, with little chill. Some demo images: a picture of northern lights with a simple horizontal gradient used for rotation, with an embedded kitty with a radial gradient. You're of course not restricted to gradients, but too detailed images might get quite intense. The second last image is just 2 applications of the angle filters on a horizontal blue-magenta-red gradient+black-white gradient. Finally, a comparison of all the filters in the bundle on the same photo. Settings, axis-angle & Euler: Rotation source layer: can be either the current layer, the layer above, or layer below. If the layer doesn't exist, there's no effect. Euler works better with a single layer than axis-angle, so the latter defaults to below instead of current. Target vector offset: changes the zero value that's used to interpret the target layer's colors into vectors. For example, offset 0 means RGB 255, 127, 0 is interpreted as the same vector, but offset 127 means it's taken as 128, 0, -127 instead. Rotation vector offset: same as above, but for the rotation angles/axis. Works kind of like a hue adjustment, and loops around at the extremes. Angle multiplier: by default a value of 255 on the rotation layer is interpreted as one full rotation (which means it has no effect), but the multiplier changes the number of cycles per 255 units. (Euler style) Rotation order: when doing 3D Euler rotations the order matters, so you can choose the order the color channels' rotations are applied. Pick the one that looks the nicest. (Axis-angle style) Source alpha as angle: by default the rotation angle is taken as the maximum value of the RGB components, but alpha on the rotation source layer can be used instead. Negative values as inverse color: rotations can make the color components negative and by default the absolute value is used, i.e. -255 G would be taken as +255 G. When this setting is enabled, -255 G will instead become +255 R, +255 B. Cross product: Second vector layer: either the layer below or above, since the cross product of anything by itself is black and that's boring. Intensity scaling: cross product has a hard time doing "subtle", so the intensity can be scaled to source image intensity or so that the highest RGB component is maxed out. Negative values as inverse color: same as angle styles. Notes: The tool uses a limited layer picker because the built in one in CodeLab often gets stuck if working on multiple documents or the number of layers changes. With axis-angle you're likely to need 2 layers to get good effects: rotating a vector around itself does nothing (point a finger forward, turn your hand upside down around the finger's axis: the finger still points forward) and the other adjustments help only so much. As mentioned above, cross product requires 2 layers: there're no logical adjustments I can think of to make it work with just a single layer without producing all black pixels. Try combining the effects with a slightly altered duplicate of the same layer, e.g. duplicate, do a zoom blur and then color rotate. Version History: V1.2: Added cross product, even if it's arguably not quite the same thing as a true rotation. Fixed an error in the negative values as inverse colors -setting: the negative value was never zeroed out properly. V1.1: Renamed the first effect to Vector Rotation (Euler), added the Axis-Angle variant. Added the negative values as inverse colors -setting.

I have been thinking about creating a plugin called "Color Unmixer" to answer exactly these questions of reverse engineering. Sadly, I've not yet gotten around to think of a good custom UI. But luckily, having had those plans means I have a good understanding of how it should work, and I can do for you by hand what the plugin should've done if it existed already. So... here we go! The Maths, the Basics, and You Finding the semi-transparent overlay color boils down to a system of 4 linear equations that you can solve if you have two pixels with distinct known background colors "b1" and "b2" that were overlain by the same unknown semi-transparent foreground color "f". That is, as long as both colors were overlain by the same foreground color at the same opacity, you can mathematically calculate that foreground color and its opacity. Your image has several of these pairs, so it should be possible to work out the color. But first of all, one thing I noticed right away: the outlines are not affected by the glass, i.e. the oval outline of the eyes stays black, no matter if it should be "under" the blue tint or highlight or not under the glasses at all. So my guess is those outlines were on a separate layer ABOVE the glasses. But that's probably something you remembered anyway. For the other bits, there's 4 pairs for both the highlight and the tint on the glasses. I've marked them red, yellow, lime and blue here (the 3rd lime marker is in the top right). Any "pair" consists of one of the base colors (outside of the glasses) and then either the corresponding part on the tinted or highlighted part of the glasses, respectively. Having 4 pairs per unknown overlay color is cool, because we can use two to determine the color and its opacity, and the other two to check if our calculations "add up" (literally) as a sanity check. But first, here's the actual formula what the visible mixed color "m" becomes when a semi-transparent foreground color "f" is overlayed over the background color "b": mc = bc + (fc - bc) * falpha / 255 This formula is applied per channel "c". For example, for the red channel, the formula would be: mred = bred + (fred - bred) * falpha / 255 The keen-eyed can probably also see why we need 2 pixel pairs: since we want to know the semi-transparent foreground color, we have to re-arrange that formula to solve for the f's (more on that later). But we have to make a choice: we can either solve for the red channel value fred, or for the alpha channel value falpha. Any m/b pair will produce three equations, one for each channel, and we can use those to solve for fred, fgreen and fblue respectively. But we then need a fourth equation from a different pair to also give us some formula we can instead re-arrange to solve for falpha. With all that being said, there's two snags we need to pay attention to: Snag 1: If the values for a color channel between background color and resulting mixed color match, that means the foreground color used the same color value (or maybe a really close one with very low opacity) for that channel, but we cannot use that equation any longer to solve for falpha. This makes sense; if you overlay "some amount of redness" with "any transparency of same amount of redness", the resulting mix will still have that same redness value to it, no matter the actual transparency. [Side note: this is also visible from the formula. If mred = bred, that means the calculation must've been "mred = bred + [something that equals 0]". This can either mean that falpha was 0, which is not really interesting, because I think we agree the overlay was probably not 100% transparent, or "fred - bred = 0", which means "fred = bred", and that's what we stated when we said that background and foreground use the same red value, or "(fred - bred) * falpha / 255" is so small it gets rounded to 0.] Snag 2: This one is not as obvious from the formula, but becomes clear once you start crunching numbers. RGB colors are discrete values, that is: integers. The formula works perfect for floating values, where mixed red values like 15.7311248 would be a possibility. Alas, in the actual image the red value is probably either 15 or more likely 16. That's something we need to keep in mind, and it is the reason why many online maths solvers might probably say that the system of equations cannot be solved, because with all that rounding, the results between channels or different pairs etc. just not quite "line up" when calculating forwards and backwards again. But we'll deal with that later. The Highlights But now: to the actual solving! Let's start with the highlight color first, so the pairs are going to be the background colors from outside the glasses plus the respective color from inside the glasses where these have a highlight. For the blue pair, both m and b are #FFFFFF. As per snag 1, we cannot use that to determine the highlight falpha, but at least it's probably safe to assume it was "some transparency of clean #FFFFFF white". We'll use the yellow pair to find that alpha value: The background color for the yellow markers (iris) is b = #56C3F6, the mixed result on the glass is m = #89D5F9. Let's use the red channel, since it exhibits the most intense value change from bred = 56hex to mred = 89hex, which equals bred = 86 to mred = 137 in decimal numbers. Now let's re-arrange our formula to solve for falpha: mc = bc + (fc - bc) * falpha / 255 mc - bc = (fc - bc) * falpha / 255 (mc - bc) / (fc - bc) = falpha / 255 (mc - bc) / (fc - bc) * 255 = falpha There we have it, we can use this formula to get falpha: falpha = (mc - bc) / (fc - bc) * 255 Inserting the values for mred = 137, bred = 86 and fred = 255 (which, remember, we deduced from the "clean white"), we get 76.95266272189..., so basically 77. Hence we predict the highlight color to be "#FFFFFF with a transparency of 77". Let's test our theory by applying the original formula "mc = bc + (fc - bc) * falpha / 255" to the lime pair. Here are the known values for the lime pair (where "m" is the one located in the highlight, not the tint): b = #FBD574 = rgb(251, 213, 116) m = #FCE29E = rgb(252, 226, 158) f = rgba(255, 255, 255, 77) Now we plug the values for b and f into the formula, and see if that correctly predicts m: mred = 251 + (255 - 251) * 77 / 255 = 252.21 mgreen = 213 + (255 - 213) * 77 / 255 = 225.68 mblue = 116 + (255 - 116) * 77 / 255 = 157.97 And sure enough, if we round those values to whole numbers, we get m = rgb(252, 226, 158). Now for the red pair: b = #FCEDDA = rgb(252, 237, 218) m = #FDF2E5 = rgb(253, 242, 229) mred = 252 + (255 - 252) * 77 / 255 = 252.91 mgreen = 237 + (255 - 237) * 77 / 255 = 242.44 mblue = 218 + (255 - 218) * 77 / 255 = 229.17 Again, rounding those values to whole numbers, we correctly get m = rgb(253, 242, 229). Hooray, the highlight color is indeed "#FFFFFF with a transparency of 77", just like we predicted earlier. Yay for Maths! The Blue Tint Now let's do the same thing for the blue tint. This time, it's going to require a little bit more effort, since the tint color isn't obvious already. But worry not, it's the same maths like for falpha, but we're re-arranging the original equation to solve for fc instead of falpha, and then use that formula for red, green, and blue: mc = bc + (fc - bc) * falpha / 255 mc - bc = (fc - bc) * falpha / 255 (mc - bc) * 255 = (fc - bc) * falpha (mc - bc) * 255 / falpha = fc - bc (mc - bc) * 255 / falpha + bc = fc We can use this formula to get fc: fc = (mc - bc) * 255 / falpha + bc Let's use it on the yellow pair. Here are the known values: b = #56C3F6 = rgb(86, 195, 246) m = #3C93F9 = rgb(60, 147, 249) Plugging in those two colors for all three channels, we get three equations which are only dependent on falpha: fred = (60 - 86) * 255 / falpha + 86 fgreen = (147 - 195) * 255 / falpha + 195 fblue = (249 - 246) * 255 / falpha + 246 From the blue pair, we get these known values: b = #FFFFFF = rgb(255, 255, 255) m = #B2BDFF = rgb(178, 189, 255) This gives these equations: fred = (178 - 255) * 255 / falpha + 255 fgreen = (189 - 255) * 255 / falpha + 255 fblue = (255 - 255) * 255 / falpha + 255 Since we know (or rather: require) all equations come from the same f (i.e.: with the same fred, and the same falpha), we can essentially solve for falpha by equating yellow's fred and the blue's fred, and then re-arrange the resulting equation to solve for falpha: fred = (60 - 86) * 255 / falpha + 86 fred = (178 - 255) * 255 / falpha + 255 (60 - 86) * 255 / falpha + 86 = (178 - 255) * 255 / falpha + 255 -26 * 255 / falpha + 86 = -77 * 255 / falpha + 255 -26 * 255 / falpha = -77 * 255 / falpha + 169 51 * 255 / falpha = 169 51 * 255 = 169 * falpha 51 * 255 / 169 = falpha falpha = 76.95266272189349 Hey! That value looks awfully familiar, doesn't it? Yep, we landed on the same result as with the highlight color earlier. In hindsight, it's probably not too surprising that we got the same transparency value of "77" for both parts of the glass. The glasses were probably created on a separate layer using opaque colors and a uniform layer transparency of 77. But now we know for sure (and I could include the steps to calculate falpha for a non-trivial case). Anyway, back to the original "yellow equations". Now that we have confirmed that falpha is indeed 77, we can complete those equations and hopefully get our foreground color. So here goes nothing: fred = (60 - 86) * 255 / 77 + 86 = -0.10 fgreen = (147 - 195) * 255 / 77 + 195 = 36.04 fblue = (249 - 246) * 255 / 77 + 246 = 255.94 Here we have a classic example of snag 2. The "known" values were rounded, so reversing the operation has lead to slight deviations from the original colors. We get negative values such as -0.10, or values like 255.94, which would get rounded to 256 and thereby exceed the possible maximum of 255. But for now, let's reasonably assume f to be rgba(0, 36, 255, 77) and see where that assumption takes us. We can check it using the other two pairs - and that's why having such extra pairs for verification is so nice. Let's test red first. Known colors: b = #FCEDDA = rgb(252, 237, 218) m = #B0B0E5 = rgb(176, 176, 229) Assuming f = rgba(0, 36, 255, 77), the formula suggests: mred = 252 + (0 - 252) * 77 / 255 = 175.91 mgreen = 237 + (36 - 237) * 77 / 255 = 176.31 mblue = 218 + (255 - 218) * 77 / 255 = 229.17 Great news! These values check out for our observed m. Now, for our final test, we check the lime pair. Known colors: b = #FBD574 = rgb(251, 213, 116) m = #B0A09E = rgb(176, 160, 158) And one last time, assuming f = rgba(0, 36, 255, 77), the formula suggests: mred = 251 + (0 - 251) * 77 / 255 = 175.21 mgreen = 213 + (36 - 213) * 77 / 255 = 159.55 mblue = 116 + (255 - 116) * 77 / 255 = 157.97 Spot on! Nice. The Answer And there we have it. From using nothing but the final result and Maths, we can deduce: The glasses were made using a highlight color of #FFFFFF and a tint color of #0024FF, on a layer with "77" transparency. Cheers, Chris

I just updated the Apply Mask plugin. It should no longer crash if the number of layers changes and you press Ctrl+F to rerun the effect. It should now maintain the R, G, and B values for pixels who's Alpha drops to 0.