burhanrashid52/PhotoEditor: an Android canvas editor library, not an app

What burhanrashid52/PhotoEditor actually is, and who it is for

The README describes it as "A Photo Editor library with simple, easy support for image editing using Paints, Text, Filters, Emoji and Sticker like stories." The word library is doing the work here. There is no APK to hand to a user, no hosted editor, and no PC or macOS build. The repository contains an app/ module, but it is the sample that demonstrates the photoeditor/ module, which is the artifact published to Maven Central.

The audience is narrow and specific: Android developers building an app where the user marks up a photo. Typical cases are a chat app that lets people draw on a screenshot, a field service app where a technician circles a damaged part, or a social feature that adds captions and stickers before upload. If you are an end user searching for a free photo editor, this project will not help you. If you are an Android developer who has been wiring up a custom View, a bitmap, touch handling and an undo stack by hand, this replaces that work.

The floor is API 21+, which the README states in its badges. That is worth checking against your own minSdk before you start, because it constrains how far back you can support.

How the PhotoEditorView and builder fit together

The architecture is a custom View plus a controller object, and the split matters when you are deciding where to put your code. PhotoEditorView goes into your XML layout. It exposes a source property that returns an ImageView, so image loading stays your responsibility: the README shows setting a drawable directly and notes you can load from resources, file, or an image loader such as Picasso or Glide. The library does not fetch images for you.

PhotoEditor is built from a Context and that view through PhotoEditor.Builder. The builder takes four documented settings. setPinchTextScalable() controls whether inserted text can be pinched to zoom, and defaults to true. setClipSourceImage() clips the drawing brush to the source image and defaults to false, which means by default strokes can extend past the photo bounds. setDefaultTextTypeface() and setDefaultEmojiTypeface() set the fonts used when text or emoji is added, and the README's example loads one from ResourcesCompat.getFont and the other from an asset file named emojione-android.ttf.

Everything after that is method calls on the PhotoEditor instance: setBrushDrawingMode to toggle drawing, addShape for brush, line, oval, rectangle and arrow, setBrushSize in pixels, plus undo, redo, delete and save. The feature list also names pinch to scale and rotate for views, and filter effects applied through MediaEffect. The state lives in the view hierarchy and the controller, so your Activity or Fragment is mostly forwarding user actions into these calls.

Installing PhotoEditor from Maven Central and drawing a first stroke

The README gives one dependency line for the app module's Gradle file, and notes that you can instead import the :photoeditor module from the sample if you need to customize it. The published version at the time of writing is 3.1.1.

implementation 'com.burhanrashid52:photoeditor:3.1.1'

Next, the view goes in your layout. The README's example sets the initial image with the app:photo_src attribute, which accepts a drawable or a color resource.

<ja.burhanrashid52.photoeditor.PhotoEditorView
    android:id="@+id/photoEditorView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    app:photo_src="@drawable/got_s" />

If the image is not known at layout time, resolve the view and set it on the source ImageView, which is what the README shows for loading from resources, a file, or an image library.

mPhotoEditorView = findViewById(R.id.photoEditorView)
mPhotoEditorView.source.setImageResource(R.drawable.paris_tower)

Then construct the editor. The README's example passes a font from resources and an emoji font from assets, and both can be omitted if you do not need custom typefaces.

mPhotoEditor = PhotoEditor.Builder(this, mPhotoEditorView)
    .setPinchTextScalable(pinchTextScalable)
    .setDefaultTextTypeface(mTextRobotoTf)
    .setDefaultEmojiTypeface(mEmojiTypeFace)
    .build()

After that, drawing is one call: setBrushDrawingMode(true), then setBrushSize and addShape to pick a stroke type. The README documents a shape list of brush, line, oval, rectangle and arrow. What you should see is the view accepting touch strokes; what you will not see is a toolbar, because the library ships no UI chrome. Buttons for brush, text, undo and save are yours to build, and the sample app is the reference for how that is usually arranged.

Where PhotoEditor stops being the right tool

The most common mismatch is expecting an app. Nothing in the README describes a standalone product, a web editor, or a desktop build, and the download link it offers points to a Google Drive folder rather than an app store listing. Anyone arriving from a search for a free photo editor for PC or Mac is in the wrong repository.

The second limitation is the UI gap. The feature list is a list of capabilities, not screens. Text entry, color pickers, brush size sliders, the sticker picker and the save flow all have to be built around the library. That is a deliberate boundary and a reasonable one for a library, but it means the integration cost is not the dependency line; it is the editor screen.

Third, image loading is delegated. If you set the source image and then call save without accounting for how the loader applies transformations, the saved result may not match what the user saw. The README does not document that interaction, so it is something to verify against your own loader rather than assume.

Finally, there is no documented rollback path for the version migrations. The README covers the AndroidX move in v.1.0.0 and the Kotlin move in v.2.0.0, and for the AndroidX case it points at Google's migration guide and says you can roll back to v.0.4.0. For later releases the README is silent on downgrading, so treat an upgrade as one-way unless you check the CHANGELOG.

PhotoEditor compared with building on a general image library

The realistic alternative is not another Android editor SDK so much as composing the pieces yourself: take an image loading and transformation library for decoding and display, and write your own canvas, touch handling, text placement and undo stack on top. The difference in approach is where the state lives. With PhotoEditor, the view owns the edits and the controller exposes undo, redo, delete and save over them, so you get that state machine for free and inherit its choices, including the default of not clipping brush strokes to the source image. Building it yourself means every one of those behaviours is a decision you make and a bug you own.

A second alternative, for teams that want the whole editing screen rather than the engine, is to import the :photoeditor module from the sample and fork it, which the README explicitly offers as a path for further customization. That trades upgrade simplicity for control: you stop tracking the published artifact and start maintaining a copy.

The trade-off is honest either way. PhotoEditor is a canvas and a command surface, not a product. If your editing needs are one brush and a save button, the dependency is probably more than you need. If they are text, emoji, stickers, filters, shapes and undo, writing that yourself is a multi-week job.

Maintenance, versions and the MIT licence

The repository is not archived, and the last push was on 2026-09-17, the same day as the v.3.1.1 release titled "Text Selection Position". The previous release, v.3.1.0, landed on 2026-03-14, and v.3.0.2 on 2024-03-04. That spacing is worth reading plainly: this is a project that moves in bursts, with a long quiet stretch between 3.0.2 and 3.1.0 and then two releases within six months. It is maintained, but not on a schedule you can plan a sprint around.

Upgrade cost depends on which version you are on. The README states that v.1.0.0 moved to AndroidX and dropped the older support library with no API changes, and that v.2.0.0 migrated fully to Kotlin with no breaking API changes between it and v.1.5.1. Java users are pointed at v.1.5.1. Nothing in the README describes breaking changes for 3.x, but the CHANGELOG.md file at the repository root is where those would be recorded, and it is the first thing to read before bumping the dependency.

The licence is MIT. That is permissive: it allows use in closed-source apps provided the copyright notice and permission notice are preserved, and it comes with no warranty. This is a description of the licence text, not legal advice; if your organisation has a policy on third-party notices, route it through that process rather than relying on this paragraph.

Editorial conclusion

Adopt it if you are shipping an Android app and want canvas editing inside your own UI: the Maven Central coordinate com.burhanrashid52:photoeditor:3.1.1 and a PhotoEditorView in your layout is most of the setup. Do not adopt it if you want a finished editor app, an online editor, or anything outside Android, because the repository only ships an Android library and a sample module. Before committing, verify that the API level 21 floor matches your minSdk, confirm which of the four builder flags you actually need, and check the CHANGELOG for the 3.1.0 to 3.1.1 text selection change.

Frequently asked questions

Official sources

1. burhanrashid52/PhotoEditor on GitHub
2. Issues
3. License: MIT
4. README
5. Releases