DEV Community: joe wang

Optimizing OCR Performance on Mobile: From 5 Seconds to Under 1 Second

joe wang — Sat, 21 Feb 2026 04:39:32 +0000

OCR on mobile needs to be fast. Users expect results in under 2 seconds. When I started building Screen Translator, our initial OCR pipeline took 4-5 seconds per screen capture. That's an eternity when you're trying to read a game menu or translate a chat message in real time.

Here's how we got it down to under 1 second on modern devices.

The Bottlenecks

Before optimizing, we profiled the pipeline:

Screen capture: ~200ms (MediaProjection API)
Image preprocessing: ~800ms 😱
OCR inference: ~2500ms 😱😱
Translation API call: ~500ms
UI rendering: ~100ms

Total: ~4100ms. Steps 2 and 3 were the obvious targets.

Optimization 1: Smart Image Downscaling

The biggest win came from not feeding full-resolution screenshots to the OCR engine.

fun optimizeForOCR(bitmap: Bitmap): Bitmap {
    val maxDimension = 1280 // Sweet spot for accuracy vs speed
    val scale = minOf(
        maxDimension.toFloat() / bitmap.width,
        maxDimension.toFloat() / bitmap.height,
        1f // Don't upscale
    )

    if (scale >= 1f) return bitmap

    return Bitmap.createScaledBitmap(
        bitmap,
        (bitmap.width * scale).toInt(),
        (bitmap.height * scale).toInt(),
        true // Bilinear filtering
    )
}

A 2400x1080 screenshot scaled to 1280x576 processes 3x faster with negligible accuracy loss for screen text.

Result: Image preprocessing dropped from 800ms to 250ms.

Optimization 2: Region of Interest (ROI) Detection

Why OCR the entire screen when the user only cares about a specific area?

fun detectTextRegions(bitmap: Bitmap): List<Rect> {
    // Convert to grayscale
    val gray = toGrayscale(bitmap)

    // Apply adaptive threshold
    val binary = adaptiveThreshold(gray)

    // Find contours and merge nearby text blocks
    val contours = findContours(binary)
    return mergeNearbyContours(contours, mergeDistance = 20)
}

By detecting text regions first (which is fast — ~50ms), we only run the expensive OCR on areas that actually contain text. For a typical app screen, this means processing 30-40% of the image instead of 100%.

Result: OCR inference dropped from 2500ms to ~800ms.

Optimization 3: ML Kit On-Device vs Cloud

We use Google ML Kit's on-device text recognition as the default. It's free, fast, and works offline. For CJK languages (Chinese, Japanese, Korean), we use the V2 API which has significantly better accuracy.

val recognizer = TextRecognition.getClient(
    when (scriptType) {
        ScriptType.LATIN -> TextRecognizerOptions.DEFAULT_OPTIONS
        ScriptType.CJK -> ChineseTextRecognizerOptions.Builder().build()
        ScriptType.KOREAN -> KoreanTextRecognizerOptions.Builder().build()
        ScriptType.JAPANESE -> JapaneseTextRecognizerOptions.Builder().build()
        ScriptType.DEVANAGARI -> DevanagariTextRecognizerOptions.Builder().build()
    }
)

The key insight: choose the right recognizer upfront. Running the Latin recognizer on Japanese text wastes time and gives garbage results. We detect the likely script from user settings and previous results.

Optimization 4: Background Threading with Coroutines

Never block the main thread. We use Kotlin coroutines with a dedicated dispatcher:

private val ocrDispatcher = Dispatchers.Default.limitedParallelism(2)

suspend fun processScreen(): TranslationResult = withContext(ocrDispatcher) {
    val capture = captureScreen()           // ~200ms
    val optimized = optimizeForOCR(capture)  // ~50ms
    val regions = detectTextRegions(optimized) // ~50ms

    // Process regions in parallel
    val results = regions.map { region ->
        async {
            val cropped = cropRegion(optimized, region)
            recognizeText(cropped)
        }
    }.awaitAll()

    // Translate in batch
    translateBatch(results)                  // ~400ms
}

Processing multiple text regions in parallel on multi-core devices gives us another 20-30% speedup.

Optimization 5: Caching

If the screen hasn't changed much, don't re-OCR everything.

class OCRCache(private val maxSize: Int = 50) {
    private val cache = LruCache<Long, OCRResult>(maxSize)

    fun getOrProcess(bitmap: Bitmap, process: () -> OCRResult): OCRResult {
        val hash = computePerceptualHash(bitmap)
        cache.get(hash)?.let { return it }

        return process().also { cache.put(hash, it) }
    }

    private fun computePerceptualHash(bitmap: Bitmap): Long {
        // Downscale to 8x8, convert to grayscale, compute average
        // Compare each pixel to average -> 64-bit hash
        val small = Bitmap.createScaledBitmap(bitmap, 8, 8, true)
        // ... hash computation
    }
}

Perceptual hashing means slightly different screenshots (e.g., a blinking cursor) still hit the cache.

Result: Repeated translations are instant (~10ms).

Final Numbers

After all optimizations on a mid-range device (Snapdragon 695):

Step	Before	After
Screen capture	200ms	200ms
Image preprocessing	800ms	50ms
ROI detection	N/A	50ms
OCR inference	2500ms	400ms
Translation	500ms	400ms
UI rendering	100ms	50ms
Total	4100ms	~800ms

On flagship devices (Snapdragon 8 Gen 3), we're seeing 400-500ms total.

Key Takeaways

Profile first — don't guess where the bottleneck is
Downscale aggressively — screen text is high contrast, OCR handles lower resolution well
ROI detection is cheap and saves massive OCR time
Choose the right ML model for the script type
Cache everything — screens don't change that often
Parallelize where possible with coroutines

These techniques aren't specific to our app. If you're building anything with on-device OCR, these patterns will help.

If you want to see these optimizations in action, check out Screen Translator on Google Play.

What OCR performance challenges have you faced on mobile? Drop your experiences in the comments.

Android Foreground Services in 2026: What Changed and How to Adapt

joe wang — Sat, 21 Feb 2026 04:32:40 +0000

If you're an Android developer working with foreground services, 2026 has brought some significant changes you need to know about. Starting with Android 14 (API 34), Google introduced strict foreground service type requirements that affect how apps like screen translators, media players, and location trackers operate.

In this post, I'll walk through what changed, why it matters, and how we adapted our app — Screen Translator — to comply with the new rules.

What Changed in Android 14+

Before Android 14, you could start a foreground service without specifying a type. The system didn't care what your service was doing — as long as you showed a notification, you were good.

Android 14 changed that. Now, every foreground service must declare a foregroundServiceType in the manifest. If you don't, your app will crash with a MissingForegroundServiceTypeException.

Here are the available types:

<service
    android:name=".MyForegroundService"
    android:foregroundServiceType="mediaProjection|camera|microphone|location|dataSync|mediaPlayback|phoneCall|connectedDevice|remoteMessaging|health|systemExempted|shortService|specialUse"
    android:exported="false" />

You must pick the type(s) that match what your service actually does.

The MediaProjection Challenge

For apps that capture the screen — like Screen Translator — the relevant type is mediaProjection. This is one of the most restricted types because screen capture has obvious privacy implications.

Here's what you need to declare in your AndroidManifest.xml:

<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />

<service
    android:name=".ScreenCaptureService"
    android:foregroundServiceType="mediaProjection"
    android:exported="false" />

And when starting the service in Kotlin:

val serviceIntent = Intent(this, ScreenCaptureService::class.java)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
    startForegroundService(serviceIntent)
} else {
    startForegroundService(serviceIntent)
}

Inside the service, you must call startForeground() with the correct type:

override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
    val notification = createNotification()

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
        startForeground(
            NOTIFICATION_ID,
            notification,
            ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION
        )
    } else {
        startForeground(NOTIFICATION_ID, notification)
    }

    return START_STICKY
}

Android 15: Even More Restrictions

Android 15 (API 35) added another layer. Now, dataSync foreground services have a 6-hour time limit. After that, the system will stop your service. If your app relied on long-running data sync services, you need to rethink your architecture.

For screen translators, the key restriction is that mediaProjection services now require the user to grant permission every time the app starts a new session. You can no longer cache the MediaProjection token across app restarts.

// This no longer works in Android 15+
// val savedToken = sharedPrefs.getString("projection_token", null)

// You must request a new MediaProjection each time
val mediaProjectionManager = getSystemService(MEDIA_PROJECTION_SERVICE) as MediaProjectionManager
val captureIntent = mediaProjectionManager.createScreenCaptureIntent()
startActivityForResult(captureIntent, REQUEST_CODE)

How Screen Translator Adapted

When building Screen Translator, we had to make several architectural changes:

Declared the correct service type: We use mediaProjection for screen capture and specialUse for our floating bubble overlay service.
Handled the per-session permission flow: Instead of caching the projection token, we now guide users through a clean permission flow each time they start a translation session.
Optimized service lifecycle: We stop the foreground service as soon as the user dismisses the floating bubble, rather than keeping it running in the background.
Graceful degradation: On older Android versions, we fall back to the simpler foreground service API without type declarations.

fun startCaptureService(resultCode: Int, data: Intent) {
    val serviceIntent = Intent(context, ScreenCaptureService::class.java).apply {
        putExtra("resultCode", resultCode)
        putExtra("data", data)
    }

    ContextCompat.startForegroundService(context, serviceIntent)
}

Common Pitfalls

Here are mistakes I've seen developers make:

Declaring types you don't use: Google Play will reject your app if you declare camera or location foreground service types but don't actually use those capabilities.
Not handling the permission dialog: On Android 14+, the MediaProjection permission dialog looks different and includes a "single app" vs "entire screen" option. Make sure your app handles both cases.
Forgetting the notification channel: Foreground services still require a notification, and on Android 13+ you need the POST_NOTIFICATIONS permission too.

Testing Tips

Test your foreground service changes on multiple API levels:

// In your test setup
@Test
fun testForegroundServiceType() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
        // Verify service type is declared correctly
        val serviceInfo = packageManager.getServiceInfo(
            ComponentName(context, ScreenCaptureService::class.java),
            PackageManager.GET_META_DATA
        )
        assertTrue(
            serviceInfo.foregroundServiceType and 
            ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION != 0
        )
    }
}

Wrapping Up

The foreground service changes in Android 14 and 15 are significant, but they make sense from a user privacy perspective. As developers, we need to be explicit about what our services do and why they need to run in the foreground.

If you're building an app that uses screen capture, OCR, or floating overlays, these changes will directly affect you. Plan your migration early and test thoroughly across API levels.

For a real-world example of an app that handles all of this, check out Screen Translator on Google Play — it's a floating bubble translator that uses MediaProjection for OCR-based screen translation.

Have questions about foreground services or MediaProjection? Drop a comment below — happy to help!

How to Handle Vertical Japanese Text in Android OCR

joe wang — Sat, 21 Feb 2026 02:40:43 +0000

Japanese text can be written vertically (tategaki, 縦書き) — top-to-bottom, right-to-left columns. This is the standard layout in manga, many games, and traditional Japanese documents. If you're building an OCR-based translation tool for Android, handling vertical text is one of the trickiest challenges you'll face.

The Problem

Most OCR engines are optimized for horizontal left-to-right text. When you feed them a manga page with vertical Japanese text, you get:

Garbled character order
Merged text from adjacent columns
Missing characters at column boundaries
Completely wrong reading direction

Detection Strategies

1. Aspect Ratio Analysis

Vertical text blocks tend to be taller than wide. If a detected text region has a height-to-width ratio > 2:1, it's likely vertical text.

2. Character Spacing Patterns

In vertical text, characters are stacked with consistent vertical spacing. Analyze the spatial distribution of detected characters — if they cluster along vertical axes, rotate the region 90° before OCR.

3. ML Kit's Built-in Support

Google's ML Kit (used in many Android OCR apps) has improved vertical text support in recent versions. The TextRecognition API with the Japanese script recognizer handles vertical text reasonably well out of the box.

Practical Solution: Screen Translator's Approach

In Screen Translator, we handle vertical Japanese text with a multi-step pipeline:

Capture — MediaProjection API captures the screen
Pre-process — Detect text regions and analyze orientation
Rotate if needed — Vertical regions get rotated 90° CW
OCR — Run text recognition on normalized images
Post-process — Reorder characters to correct reading order
Translate — Send properly ordered text to translation API

Tips for Developers

Always test with real manga pages, not just synthetic test images
Japanese text in games often uses custom fonts that reduce OCR accuracy
Furigana (small reading aids above kanji) can confuse OCR — consider filtering by text size
Mixed horizontal/vertical layouts (common in manga) need per-region orientation detection

Results

With proper vertical text handling, OCR accuracy on manga pages jumps from ~40% to ~85%+ for clean digital scans. The key insight is that text orientation detection must happen before OCR, not after.

If you're working on similar problems, I'd love to hear your approach. Drop a comment below!

Screen Translator is a free floating overlay translator for Android that handles vertical Japanese text, manga, games, and more: Google Play

Why OCR for CJK Languages Is Still a Hard Problem in 2026 — And How I'm Tackling It

joe wang — Fri, 20 Feb 2026 18:46:38 +0000

If you've ever tried to build an OCR system that handles Chinese, Japanese, or Korean text, you know the pain. Latin-script OCR has been "good enough" for years, but CJK languages? Still a minefield in 2026.

I've been working on Screen Translator, an Android app that uses a floating bubble to OCR and translate on-screen text in real time. Building it forced me to confront every ugly corner of CJK text recognition. Here's what I learned.

The Character Set Problem

English has 26 letters. Chinese has over 50,000 characters in common use (GB18030 standard). Japanese mixes three scripts — Hiragana, Katakana, and Kanji — sometimes in the same sentence. Korean Hangul has 11,172 possible syllable blocks.

For an OCR engine, this means:

Massive classification space: Instead of distinguishing ~70 characters (upper/lower + digits + punctuation), you're classifying among tens of thousands
Visually similar characters: 土/士, 末/未, 己/已/巳 — these differ by a single pixel-level stroke
Mixed scripts: A Japanese game UI might show "HP回復アイテム" — that's Latin, Kanji, and Katakana in one string

Why Standard OCR Pipelines Struggle

Most OCR pipelines follow: Detection → Recognition → Post-processing.

For CJK, each step has unique failure modes:

Detection

CJK text can be vertical or horizontal. Game UIs love vertical text. Manga reads right-to-left. Most detection models are trained on horizontal Latin text and simply miss vertical CJK layouts.

Recognition

The standard CRNN (CNN + RNN + CTC) architecture works well for Latin scripts but struggles with CJK because:

# Simplified comparison
Latin: Fixed-width character assumption mostly works
CJK: Character width varies dramatically
     Full-width: ＡＢＣ (each takes 2x space)
     Half-width: ABC
     Mixed: 「Hello世界」

The CTC (Connectionist Temporal Classification) loss function assumes characters appear in sequence without overlap. CJK characters in stylized fonts (especially in games and manga) often break this assumption.

Post-processing

For English, you can use dictionary lookup and language models to fix OCR errors. "teh" → "the" is trivial. But for Chinese, a single wrong character can completely change meaning:

大人 (adult) vs 犬人 (not a word — but OCR might produce it)
Context-based correction requires much larger language models

What Actually Works in 2026

After months of iteration, here's what I found effective:

1. Multi-scale text detection

Using a CRAFT-like detector with explicit vertical text support. Training data must include vertical Japanese manga panels and Chinese calligraphy-style game text.

2. Attention-based recognition over CTC

Transformer-based recognition models handle variable-width CJK characters much better than CTC-based approaches. The attention mechanism naturally handles the alignment problem.

3. Script-aware preprocessing

Before feeding text to the recognizer, detect the dominant script and adjust:

def preprocess_for_script(image, detected_script):
    if detected_script in ['ja', 'zh']:
        # CJK benefits from higher resolution input
        image = upscale(image, factor=2)
        # Binarization helps with stylized game fonts
        image = adaptive_threshold(image)
    if is_vertical(image):
        image = rotate_90(image)
    return image

4. Game/Manga-specific fine-tuning

Generic OCR models fail on stylized text. Fine-tuning on screenshots from actual games and manga pages made a huge difference in my app's accuracy.

The Real-World Test

The ultimate test for Screen Translator was Japanese gacha games. These combine:

Stylized fonts with outlines and shadows
Text over complex backgrounds (character art, particle effects)
Mixed Japanese/English/numbers
Small text in UI elements

Getting reliable OCR in this environment required all the techniques above, plus aggressive image preprocessing to isolate text from backgrounds.

Lessons for Fellow Developers

If you're building anything that touches CJK OCR:

Don't assume horizontal text — support vertical from day one
Test on real content — synthetic training data alone won't cut it for games/manga
Character-level confidence matters — when OCR confidence is low on a CJK character, it's better to show the user than to guess wrong
Translation quality depends on OCR quality — garbage in, garbage out. A mistranslation from bad OCR is worse than showing "recognition failed"

I'm still iterating on Screen Translator's OCR pipeline. If you're working on similar problems or have found good approaches for CJK text recognition, I'd love to hear about it in the comments.

You can try the app here: Screen Translator on Google Play

What's your experience with CJK OCR? Have you found any tricks that work well for specific use cases? Let me know below.

How I Built a Floating Bubble OCR Translator for Android — Lessons Learned

joe wang — Fri, 20 Feb 2026 18:28:12 +0000

As a solo Android developer, I spent the last few months building a floating bubble OCR translator. The idea was simple: tap a bubble on your screen, select any text area, and get an instant translation — without leaving whatever app you're in.

Here's what I learned along the way, and some technical challenges that might help if you're building something similar.

Why a Floating Bubble?

Most translation apps require you to switch contexts. Copy text, open the translator, paste, read the result, switch back. For use cases like reading manga, playing foreign-language games, or chatting on international messaging apps, this flow is painfully slow.

A floating bubble overlay stays on top of everything. One tap, drag to select, instant result. The UX difference is massive.

The Technical Stack

Language: Kotlin
OCR Engine: ML Kit for on-device text recognition
Translation: Google ML Kit Translation API (on-device models)
Overlay: Android's SYSTEM_ALERT_WINDOW permission
Screen Capture: MediaProjection API

Challenge 1: Getting the Overlay Right

Android's overlay permission (SYSTEM_ALERT_WINDOW) is one of those things that sounds simple but has a ton of edge cases:

On Android 10+, you need to explicitly request the permission via Settings.ACTION_MANAGE_OVERLAY_PERMISSION
Some OEMs (looking at you, Xiaomi and OPPO) have additional overlay restrictions
The bubble needs to be draggable but also respond to taps — handling the touch event delegation correctly took more iterations than I'd like to admit

The key insight: use WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE for the bubble itself, but switch to a focusable window when the selection overlay is active.

Challenge 2: OCR on CJK Languages

ML Kit's text recognition works great for Latin scripts out of the box. But for Japanese, Chinese, and Korean — which are the primary use cases for screen translation — you need the CJK-specific models.

Some gotchas:

Vertical text: Japanese manga is written vertically. ML Kit handles this, but you need to configure the recognizer for Japanese specifically
Mixed scripts: Manga often mixes kanji, hiragana, katakana, and sometimes romaji in the same panel
Small text: OCR accuracy drops significantly with small text. I added a zoom hint in the UI to encourage users to zoom in before capturing

Challenge 3: Screen Capture Performance

Using MediaProjection to capture the screen is straightforward, but performance matters:

// Capture only the selected region, not the full screen
val bitmap = Bitmap.createBitmap(
    fullScreenBitmap,
    selectionRect.left,
    selectionRect.top,
    selectionRect.width(),
    selectionRect.height()
)

Cropping to just the selected area before running OCR makes a huge difference in processing time. On a mid-range phone, full-screen OCR takes 800ms+, but a cropped manga panel takes ~200ms.

Challenge 4: Translation Quality

On-device translation models are convenient (no API costs, works offline), but the quality varies. For Japanese → English, the results are "good enough" for understanding context, but not publication-quality.

I found that keeping the source text visible alongside the translation helps users who know some of the source language fill in the gaps.

The Result

The app is called Screen Translator and it's live on Google Play:

👉 Screen Translator on Google Play

Main use cases people are finding:

Reading raw manga without waiting for fan translations
Playing Japanese/Korean/Chinese mobile games
Translating chat messages in foreign-language messaging apps
Reading foreign social media posts

What I'd Do Differently

Start with CJK support from day one — I initially built for Latin scripts and retrofitted CJK support. Should have been the other way around given the target audience.
Battery optimization earlier — Screen capture + OCR + translation is battery-hungry. I should have implemented smart capture intervals from the start.
User onboarding — The overlay permission flow confuses a lot of users. A step-by-step tutorial on first launch would have saved me a lot of support emails.

Wrapping Up

Building an overlay-based Android app is a unique challenge. You're essentially building a mini-app that lives on top of the entire OS. The permission model, touch handling, and performance constraints are all different from a standard app.

If you're thinking about building something similar, feel free to ask questions in the comments. Happy to share more technical details about any specific part of the implementation.

I'm a solo dev building tools that help people break language barriers on mobile. If you find this interesting, check out the app and let me know what you think!

Best Screen Translation Apps for Android in 2026

joe wang — Fri, 20 Feb 2026 14:06:20 +0000

Need to translate text on your phone screen without switching apps? Whether you're playing foreign language games, reading untranslated manga, or chatting with someone in another language, a screen translation app can save you a lot of time.

I tested several screen translation apps for Android to find out which ones actually work well. Here's what I found.

What Is a Screen Translation App?

Unlike regular translation apps where you type or paste text, screen translation apps work directly on your screen. They use OCR (Optical Character Recognition) to detect text in any app — games, manga readers, social media, chat apps — and translate it without you having to leave what you're doing.

Most of them use a floating bubble or overlay that stays on top of other apps.

What I Tested For

OCR accuracy — Can it correctly recognize text, especially Japanese/Korean/Chinese?
Translation quality — How good are the translations?
Speed — How fast does it translate?
Ease of use — Is the floating bubble intuitive?
Language support — How many languages does it handle?
Price — Is it free or does it require a subscription?

The Apps

1. Screen Translator

Rating: ★★★★☆

Google Play Link

A floating bubble translator that works on any screen. Tap the bubble, it captures the screen, recognizes text via OCR, and shows the translation.

What I liked:

Clean floating bubble interface — doesn't get in the way
Good OCR for Japanese (including vertical text) and Korean
Works with games, manga readers, social media, chat apps
Supports 100+ languages
Free to use with ads, premium removes ads and adds features
Offline OCR scanning available

What could be better:

Translation speed could be slightly faster on older devices
Handwritten or heavily stylized text can be missed

Best for: Gamers playing Japanese/Korean games, manga readers, people browsing foreign social media.

2. Google Translate (Camera/Lens)

Rating: ★★★☆☆

The most well-known option. Google Translate's camera feature can translate text in real-time through your camera, and Google Lens can translate text in screenshots.

What I liked:

Free and pre-installed on most Android phones
Excellent translation quality (it's Google)
Camera mode works for physical text (signs, menus)

What could be better:

No floating bubble — you have to leave your current app
Can't translate directly on screen in other apps
Tedious workflow: screenshot → open Google Translate → import image
Not practical for gaming or manga reading

Best for: Translating physical text (signs, menus, documents) with your camera.

3. Papago

Rating: ★★★★☆

Developed by Naver (Korea's biggest search engine). Papago is excellent for Korean, Japanese, and Chinese translation.

What I liked:

Best Korean translation quality among all apps
Has an image translation feature
Clean interface

What could be better:

No floating bubble overlay for on-screen translation
Image translation requires taking a screenshot first
Limited to Asian languages (not great for European languages)

Best for: Korean language translation, especially for Korean learners.

4. Universal Copy

Rating: ★★★☆☆

Not a translator itself, but lets you copy text from any app (even apps that normally don't allow text selection). You can then paste the copied text into any translator.

What I liked:

Works system-wide
Useful for copying text from apps that block selection

What could be better:

Extra step required — copy then paste into translator
Doesn't work with text in images (no OCR)

Best for: Copying text from restrictive apps to use with your preferred translator.

Comparison Table

App	Floating Bubble	OCR	Game Translation	Manga Translation	Free	Offline
Screen Translator	✅	✅	✅	✅	✅ (with ads)	Partial
Google Translate	❌	✅ (camera only)	❌	❌	✅	✅
Papago	❌	✅ (screenshot)	❌	❌	✅	Partial
Universal Copy	❌	❌	❌	❌	✅	N/A

Which One Should You Use?

If you play foreign language games: Screen Translator — the floating bubble is essential for gaming since you can't easily switch apps mid-game.

If you read raw manga/manhwa: Screen Translator — OCR works on manga panels and handles vertical Japanese text.

If you need to translate physical text (menus, signs): Google Translate camera mode — point and translate.

If you're learning Korean: Papago — best Korean translation quality.

If you need to copy text from restrictive apps: Universal Copy + any translator.

My Recommendation

For most use cases — especially gaming, manga reading, and social media browsing — a floating bubble translator like Screen Translator gives you the best experience. Being able to translate without leaving your current app is a game-changer once you get used to it.

Google Translate is still the king for general translation quality, but its lack of a floating overlay makes it impractical for on-screen translation.

Have you tried any of these apps? Let me know which one works best for you in the comments!

How to Read Raw Manga and Manhwa Without Knowing Japanese or Korean

joe wang — Fri, 20 Feb 2026 14:02:17 +0000

You found an amazing manga series, but there's no English translation yet. Or the translation is 50 chapters behind. Sound familiar?

Reading raw (untranslated) manga and manhwa is frustrating when you can't read the language. But there are ways to enjoy these series without waiting months for fan translations.

The Raw Manga Problem

New manga chapters release in Japanese first. Popular series might get English translations within days, but many titles — especially niche ones — take weeks, months, or never get translated at all.

Korean manhwa and webtoons have the same issue. The Korean releases are always ahead of English versions.

If you're tired of waiting, here's how to read raw manga and manhwa right now.

Method 1: On-Screen Translation Apps

The fastest way to read raw manga on your phone. These apps use OCR (Optical Character Recognition) to detect text in manga panels and translate it in real-time.

How it works:

Open your manga reader app (Tachiyomi, MangaDex, etc.)
Enable the floating translator bubble
Navigate to the page you want to translate
Tap the bubble — it scans the page and translates all text

Why this works well for manga:

Handles both vertical text (Japanese manga) and horizontal text (Korean manhwa)
Works with any manga reader app
Translates speech bubbles, sound effects, and narration boxes
No need to take screenshots or switch apps

Screen Translator is one app that does this — it's free on Android and supports both Japanese vertical text and Korean horizontal text. The OCR is decent for clean manga text, though handwritten or stylized fonts can be tricky.

Best for: Catching up on untranslated chapters, reading niche series with no English release.

Method 2: Manga-Specific Translation Tools

Some tools are built specifically for manga translation:

Manga Translator (various apps) — dedicated manga translation with panel detection
Google Lens — point your camera at a physical manga page to translate

These can work, but most require you to take screenshots first, which breaks the reading flow.

Method 3: Wait for Fan Translations

The most common approach. Fan translation groups (scanlation groups) translate manga and manhwa for free.

Where to find fan translations:

MangaDex — largest fan translation aggregator
Webtoon (official) — for licensed Korean webtoons
Various scanlation group websites

The downside: You're always behind the latest chapters, and some series never get picked up.

Method 4: Machine Translation Aggregator Sites

Some websites automatically machine-translate raw manga. The quality varies wildly — sometimes readable, sometimes nonsensical.

Pros: Instant access to latest chapters
Cons: Translation quality is often poor, especially for nuanced dialogue

Comparing the Methods

Method	Speed	Quality	Effort	Cost
On-screen translator	Instant	Good (for clean text)	Very low	Free
Manga-specific tools	Fast	Good	Medium	Varies
Fan translations	Slow (days-weeks)	Best	None	Free
Machine translation sites	Instant	Poor-Medium	None	Free

Tips for Reading Raw Manga

Start with manhwa — Korean text is horizontal and generally easier for OCR to recognize than vertical Japanese text
Choose series with clean art — manga with lots of screen tones or busy backgrounds can interfere with text recognition
Learn common manga vocabulary — words like 何 (what), 俺 (I/me), 行く (go), 来い (come) appear constantly
Use translation for dialogue, skip sound effects — sound effects (onomatopoeia) are often untranslatable anyway
Read the raw first, then the translation — if a fan translation exists, read the raw chapter first with a translator, then compare with the official translation to improve your understanding

For Korean Manhwa / Webtoon Readers

Korean manhwa and webtoons are actually easier to translate than Japanese manga because:

Text is horizontal (standard reading direction)
Speech bubbles are usually clean with standard fonts
Less stylized text compared to Japanese manga

If you're reading Korean webtoons raw, an on-screen translator will give you pretty good results.

Conclusion

You don't have to wait for translations anymore. With on-screen translation tools, you can read raw manga and manhwa the day they release. The translation won't be perfect, but it's good enough to follow the story and enjoy the art.

For Android users, Screen Translator works well with most manga reader apps — just tap the floating bubble on any page to get an instant translation.

What raw manga or manhwa are you reading? Share your recommendations below!

How to Play Japanese Games Without Knowing Japanese (2026 Guide)

joe wang — Fri, 20 Feb 2026 14:00:52 +0000

If you've ever wanted to play a Japanese mobile game but gave up because you couldn't read the menus, quests, or story — you're not alone. Tons of amazing games never get an official English release, and even when they do, it can take months or years.

The good news? You don't need to learn Japanese to enjoy these games. Here are the practical methods that actually work in 2026.

Why Japanese Games Are Worth Playing

Japan produces some of the best mobile games in the world — gacha games like Fate/Grand Order, Monster Strike, and Granblue Fantasy have massive player bases. Many JRPGs, visual novels, and strategy games launch exclusively in Japan first.

The problem? Most of these games are entirely in Japanese. Menus, dialogue, quest descriptions, equipment stats — everything.

Method 1: Use a Floating Screen Translator

This is the most convenient method for mobile gamers. A floating screen translator sits on top of your game as a small bubble. When you need to translate something, you just tap the bubble — it captures the text on screen using OCR and translates it instantly.

How it works:

Open the translator app and enable the floating bubble
Launch your game
When you see Japanese text you can't read, tap the floating bubble
The app scans the screen, recognizes the text, and shows the translation

Pros:

Works with any game (no root or special setup needed)
Translates menus, dialogue, quests, equipment — anything on screen
No need to switch between apps or take screenshots
Supports Japanese, Korean, Chinese, and 100+ other languages

Cons:

Works best with static text (not ideal for fast-scrolling content)
Translation quality depends on the OCR accuracy

One app that does this well is Screen Translator — it's a free Android app with a floating bubble that translates any on-screen text. I've been using it for Japanese gacha games and it handles kanji recognition pretty well.

Method 2: Screenshot + Google Translate

The old-school method. Take a screenshot, open Google Translate, use the camera/image feature to translate.

Pros:

Free and widely available
Google Translate is decent for Japanese

Cons:

Extremely tedious — you have to leave the game every time
Breaks your flow, especially during story-heavy sections
Doesn't work well for games that block screenshots

Method 3: Learn Basic Gaming Japanese

If you're serious about Japanese games, learning some common gaming vocabulary helps a lot:

Japanese	Romaji	English
攻撃	kougeki	Attack
防御	bougyo	Defense
体力	tairyoku	HP / Stamina
スキル	sukiru	Skill
ガチャ	gacha	Gacha (lottery)
クエスト	kuesuto	Quest
装備	soubi	Equipment
強化	kyouka	Enhance / Upgrade

This won't help with story dialogue, but it makes navigating menus much easier.

Method 4: Community Translations and Wikis

For popular games, the English-speaking community often creates:

Fan-translated wikis with menu guides
Reddit threads explaining game mechanics
Discord servers with translation help channels

Check Reddit (r/gachagaming) and Discord for your specific game.

Which Method Should You Use?

Method	Best For	Effort Level
Floating translator	Casual play, multiple games	Low
Screenshot + Google Translate	Occasional translation	Medium
Learn gaming Japanese	Long-term players	High
Community wikis	Popular games only	Low

For most people, a floating screen translator is the best balance of convenience and coverage. You can play any game without preparation, and the translation is instant.

Tips for Playing Japanese Games

Start with games that have simple UI — puzzle games and rhythm games need less text
Use a translator for story sections — skip translating every menu once you memorize the layout
Join the game's English community — other players have already figured out most things
Don't try to translate everything — focus on quest objectives and important dialogue

Conclusion

Playing Japanese games without knowing Japanese is totally doable in 2026. Between floating translators, community resources, and basic vocabulary, you can enjoy almost any game regardless of the language barrier.

If you're on Android, give Screen Translator a try — the floating bubble makes it really easy to translate game screens on the fly.

What Japanese games are you playing? Drop a comment and let me know if you have any translation tips to share!