Introduction

Photoshop-style feathering is usually not one magic library feature. It is an effect built from masking and blur: soften the transition at the image boundary by gradually lowering alpha near the edges. On iOS and Android, the right solution is often a platform graphics API plus an alpha-mask or blur-based algorithm, not a single cross-platform "feather edge" button.

What Feathering Really Is

Feathering means the edge of the image becomes progressively transparent instead of ending abruptly. Technically, that is usually done by:

• creating an alpha mask with a soft falloff near the border
• or blurring a hard mask and using the result as transparency

That is why the effect feels similar to Photoshop: it is really a controlled edge fade.

A Simple Cross-Platform Mental Model

The reusable algorithm is:

1. create a full-opacity mask for the image
2. reduce mask opacity near the edges with a gradient or blur
3. multiply the image alpha by that mask

If you understand that model, the iOS and Android implementations make more sense.

iOS: Core Image or Core Graphics

On iOS, Core Image is a strong option when you want GPU-friendly image processing. A practical workflow is:

• build or load a mask image
• blur the mask if needed
• blend it with the source image

Example using Core Image concepts:

1import CoreImage
2import UIKit
3
4let context = CIContext()
5let source = CIImage(image: UIImage(named: "photo")!)!
6
7let maskFilter = CIFilter.radialGradient()
8maskFilter.center = CGPoint(x: source.extent.midX, y: source.extent.midY)
9maskFilter.radius0 = Float(min(source.extent.width, source.extent.height) * 0.35)
10maskFilter.radius1 = Float(min(source.extent.width, source.extent.height) * 0.5)
11
12let mask = maskFilter.outputImage!
13    .cropped(to: source.extent)
14
15let blend = CIFilter.blendWithMask()
16blend.inputImage = source
17blend.backgroundImage = CIImage(color: .clear).cropped(to: source.extent)
18blend.maskImage = mask
19
20let output = blend.outputImage!
21let cgImage = context.createCGImage(output, from: output.extent)!
22let result = UIImage(cgImage: cgImage)

This example uses a radial mask for demonstration, but the same idea can be adapted to edge-only feathering with gradient masks or custom mask images.

Android: Masking and Blur Effects

On Android, the same conceptual approach applies: create or draw a soft mask and composite it with the image.

At the framework level, a common route is:

• draw into a Bitmap
• use gradients or shaders for alpha falloff
• blend with Canvas and Paint

Example sketch:

1val output = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
2val canvas = Canvas(output)
3val paint = Paint(Paint.ANTI_ALIAS_FLAG)
4
5canvas.drawBitmap(sourceBitmap, 0f, 0f, null)
6
7val shader = LinearGradient(
8    0f, 0f, 100f, 0f,
9    intArrayOf(Color.TRANSPARENT, Color.BLACK),
10    null,
11    Shader.TileMode.CLAMP
12)
13
14paint.shader = shader
15paint.xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_IN)
16canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), paint)

In real code, you would usually build masks for all four edges or use a more symmetrical radial or rectangular falloff, but the principle is the same: the mask controls edge transparency.

Cross-Platform Library Option: OpenCV

If you want one shared algorithmic approach across iOS and Android, OpenCV is often the practical answer. It gives you image-processing primitives such as:

• Gaussian blur
• distance transforms
• masks and compositing helpers

That does not mean OpenCV has a single "Photoshop feather" API either. It means it gives you the low-level building blocks in a library that exists on both platforms.

Choose the Algorithm by the Effect You Want

Different feathering goals imply different masks:

• radial mask for vignette-like fades
• rectangular edge gradients for UI cards or compositing borders
• distance-transform masks for arbitrary cut-out shapes

If the image is already segmented, distance-from-edge based alpha falloff often gives the most Photoshop-like result because the fade follows the real cut-out contour instead of assuming a simple rectangle.

Common Pitfalls

The most common mistake is treating feathering as "just blur the image." That softens the entire image, not only the boundary. Another is looking for one library method that exactly matches Photoshop semantics when the effect is really composed from mask and blend operations. Developers also reach for outdated mobile graphics stacks instead of using current platform graphics APIs or a maintained cross-platform image library.

Summary

• Feathering is usually an alpha-mask effect, not a plain image blur.
• On iOS, Core Image and related graphics APIs are strong native building blocks.
• On Android, shaders, masks, and canvas compositing are the core tools.
• OpenCV is a reasonable cross-platform option when you want one shared algorithmic approach.
• Choose gradient masks, blur masks, or distance-based masks based on the visual effect you actually need.