If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/niedev/RTranslator shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

GO — Healthy across all four use cases

• Last commit 1d ago
• 6 active contributors
• Apache-2.0 licensed
• Tests present
• ⚠ Single-maintainer risk — top contributor 87% of recent commits
• ⚠ No CI workflows detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live niedev/RTranslator repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/niedev/RTranslator.

What it runs against: a local clone of niedev/RTranslator — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in niedev/RTranslator | Confirms the artifact applies here, not a fork | | 2 | License is still Apache-2.0 | Catches relicense before you depend on it | | 3 | Default branch v2.00 exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 31 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of niedev/RTranslator. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/niedev/RTranslator.git
#   cd RTranslator
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of niedev/RTranslator and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "niedev/RTranslator(\\.git)?\\b" \\
  && ok "origin remote is niedev/RTranslator" \\
  || miss "origin remote is not niedev/RTranslator (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(Apache-2\\.0)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"Apache-2\\.0\"" package.json 2>/dev/null) \\
  && ok "license is Apache-2.0" \\
  || miss "license drift — was Apache-2.0 at generation time"

# 3. Default branch
git rev-parse --verify v2.00 >/dev/null 2>&1 \\
  && ok "default branch v2.00 exists" \\
  || miss "default branch v2.00 no longer exists"

# 4. Critical files exist
test -f "app/build.gradle" \\
  && ok "app/build.gradle" \\
  || miss "missing critical file: app/build.gradle"
test -f "app/src/main/AndroidManifest.xml" \\
  && ok "app/src/main/AndroidManifest.xml" \\
  || miss "missing critical file: app/src/main/AndroidManifest.xml"
test -f "app/src/main/cpp/CMakeLists.txt" \\
  && ok "app/src/main/cpp/CMakeLists.txt" \\
  || miss "missing critical file: app/src/main/cpp/CMakeLists.txt"
test -f "app/src/main/cpp/src/SentencePieceProcessorInterface.cpp" \\
  && ok "app/src/main/cpp/src/SentencePieceProcessorInterface.cpp" \\
  || miss "missing critical file: app/src/main/cpp/src/SentencePieceProcessorInterface.cpp"
test -f "app/src/main/assets/sentencepiece_bpe.model" \\
  && ok "app/src/main/assets/sentencepiece_bpe.model" \\
  || miss "missing critical file: app/src/main/assets/sentencepiece_bpe.model"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 31 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~1d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/niedev/RTranslator"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

RTranslator is an offline real-time translation app for Android that combines Meta's NLLB translation model and OpenAI's Whisper speech recognition (both running locally on-device) to enable peer-to-peer conversations between users speaking different languages. Three modes exist: Conversation mode connects two+ phones for simultaneous bidirectional audio translation with Bluetooth support; WalkieTalkie mode provides single-phone translation by detecting language and alternating speakers; Text Translation mode handles simple text input. All processing happens on-device with no cloud dependency. Android app structure: app/src/main/AndroidManifest.xml + resources in app/src/main/; native C++ code in app/src/main/cpp/ (CMakeLists.txt coordinates build); Java/Kotlin UI layer in app/src/main/java/; ML models in app/src/main/assets/ (sentencepiece_bpe.model). Gradle orchestrates Java+CMake build (build.gradle configures compilation for arm64-v8a). SWIG bindings (implied by SWIG file count) mediate JNI calls between Java and C++ translation/speech modules.

Android developers building privacy-focused multilingual communication features, or end-users in international teams/families who want real-time translation without cloud services or latency. Contributors would be familiar with Android NDK/C++ integration, machine learning model deployment, and audio processing on mobile devices.

Actively developed (v2.1.5 as of build.gradle, versionCode 25). The project has a substantial C++ codebase (8.3MB), proper CI templates in .github/, comprehensive issue templates, and a CONTRIBUTING.md file. However, no obvious public test results or automated CI/CD pipeline visible in the file list; maturity appears production-ready for core features but may lack battle-tested stability metrics.

Single maintainer (Luca Martino as evident from copyright headers). Targets arm64-v8a ABI only (abiFilters in build.gradle), limiting device coverage. The massive native dependency footprint (model files like sentencepiece_bpe.model in assets, C++ code) creates potential for build brittleness and update friction. SWIG bindings (72KB) bridge Java-C++ but add complexity; no visible unit tests in app/src/androidTest/ beyond boilerplate ExampleInstrumentedTest.java.

No PR or commit history visible in provided file list, but active development implied by v2.1.5 release, TODO_LIST.md, and comprehensive CONTRIBUTING.md / pull_request_template.md. Likely focus areas: model optimization (sentencepiece config), Bluetooth audio handling refinement (Conversation mode), and language detection improvement (WalkieTalkie mode).

git clone https://github.com/niedev/RTranslator.git
cd RTranslator
# Requires Android SDK (compileSdkVersion 33), NDK (for C++ build), and Gradle
# Open in Android Studio or build via:
cd app && gradle assembleDebug

Daily commands: Android Studio: File → Open → select project root, then Run → Run 'app' (requires connected device/emulator with arm64 support). CLI: cd app && gradle installDebug && adb shell am start -n nie.translator.rtranslator/.MainActivity (after building). Emulator must support arm64-v8a ABI (Google APIs image preferred).

• app/build.gradle — Defines all dependencies (gRPC, SentencePiece, Android libraries) and build configuration; essential for understanding the translation engine and communication stack.
• app/src/main/AndroidManifest.xml — Declares all app activities, permissions (Bluetooth, audio, microphone), and services; required to understand app structure and platform capabilities.
• app/src/main/cpp/CMakeLists.txt — Configures the native C++ build for SentencePiece translation model compilation; critical for understanding offline translation implementation.
• app/src/main/cpp/src/SentencePieceProcessorInterface.cpp — JNI bridge between Java and SentencePiece C++ library; core interface for text tokenization and model inference.
• app/src/main/assets/sentencepiece_bpe.model — Pre-trained BPE model asset used for real-time translation; the actual translation model data bundled with the app.
• app/src/main/cpp/src/CacheContainerNative.cpp — Native caching layer for translation results; optimizes repeated translations and reduces model inference latency.

• Audio Capture & Speech-to-Text — Records audio from microphone or Bluetooth headset and converts to text strings.

Add Support for a New Language Pair

1. Train or obtain a new SentencePiece BPE model for the language pair (app/src/main/assets/sentencepiece_bpe.model (replace or add variant))
2. Update the native model loader in SentencePieceProcessorInterface to handle the new model format (app/src/main/cpp/src/SentencePieceProcessorInterface.cpp)
3. Add language selection logic in the UI activity (manifest declares activities, extend with language picker) (app/src/main/AndroidManifest.xml (declare new activity if needed))
4. Rebuild native C++ binaries to include the new model (app/src/main/cpp/CMakeLists.txt (ensure model is linked))

Optimize Translation Latency with Caching

1. Configure cache size and TTL in the native caching layer (app/src/main/cpp/src/CacheContainerNative.cpp)
2. Enable ProGuard inlining and optimization rules to reduce JNI call overhead (app/proguard-rules.pro)
3. Expose cache statistics through JNI interface for monitoring (app/src/main/cpp/src/SentencePieceProcessorInterface.cpp)

Add a New Communication Protocol (beyond gRPC)

1. Add the new networking library dependency alongside gRPC (app/build.gradle (grpcVersion = '1.11.0' section))
2. Implement protocol handlers in a new native module (app/src/main/cpp/src/ (create new .cc/.h file))
3. Declare new services or components in the manifest if needed (app/src/main/AndroidManifest.xml)
4. Rebuild CMakeLists.txt to include the new protocol module (app/src/main/cpp/CMakeLists.txt)

Improve Text Preprocessing for Better Translation Quality

1. Review and extend the Unicode normalization tables for additional scripts (app/src/main/cpp/data/nfkc.tsv or add new .tsv files)
2. Update the BPE model trainer or preprocessing logic (app/src/main/cpp/src/bpe_model_trainer.cc)
3. Rebuild the native library to apply new preprocessing rules (app/src/main/cpp/CMakeLists.txt)

• SentencePiece (C++ native library) — Provides offline, lightweight neural machine translation without cloud dependencies; BPE tokenization is efficient for multiple languages and resource-constrained Android devices.
• gRPC 1.11.0 — Enables low-latency peer-to-peer communication between phones; protobuf serialization is compact for bandwidth-constrained mobile networks.
• Android NDK / CMake — Compiles high-performance C++ translation engine to native ARM code; JNI bridges Java/Kotlin UI to SentencePiece model for real-time inference.
• Bluetooth Audio (Android manifest permission) — Allows seamless audio input from Bluetooth headsets during conversations; essential for hands-free translation in real-world scenarios.

• Offline-only translation (SentencePiece BPE model embedded in APK)

  • Why: Ensures privacy, zero latency, and works without internet connectivity.
  • Consequence: Model quality is limited by available on-device storage and computation; 600MB total codebase suggests model size is moderate (likely < 100MB). No ability to use larger, cloud-trained models.

• Single pre-trained BPE model in assets rather than multiple language-specific models

  • Why: Minimizes APK size and complexity; faster app startup.
  • Consequence: Translation quality may be sub-optimal for language pairs not heavily represented in the training data; harder to add new language pairs without retraining.

• Native C++ translation engine over pure Kotlin/Java

  • Why: SentencePiece C++ library is faster and battle-tested; JNI overhead acceptable for non-interactive inference.
  • Consequence: Increased build complexity (CMake, NDK); harder to debug; larger APK with binary bloat across ARM architectures.

• gRPC for peer-to-peer messaging instead of simpler HTTP/REST

  • Why: gRPC is faster, supports streaming, and is more suitable for mobile.
  • Consequence: Added dependency; slightly more complex connection setup for users.

• Cloud-based translation (app is fully offline)
• Support for real-time video translation
• Cross-platform desktop clients (Android-only)
• User authentication or server-side storage
• Support for languages beyond those in the SentencePiece training data

NDK version mismatch: CMakeLists.txt likely pins an NDK version; using a different NDK can break native compilation. arm64-v8a only: abiFilters in build.gradle locks to single ABI; many emulators/devices fail silently if not arm64 compatible. Model file licensing: sentencepiece_bpe.model and underlying NLLB/Whisper weights have specific licenses (Meta/OpenAI); redistributing or modifying may violate terms. Bluetooth state management: Android Bluetooth API is device-vendor inconsistent; Conversation mode may have latent issues on certain Samsung/OPPO devices. Asset bloat: Embedding large models increases APK size dramatically; ProGuard is disabled (minifyEnabled false), so app size optimization requires manual asset compression. JNI string encoding: SWIG-generated JNI boundary may have UTF-8 vs. UTF-16 encoding mismatches for non-Latin scripts; test with CJK languages.

• JNI (Java Native Interface) — RTranslator bridges Java UI with C++ ML models via JNI; understanding JNI method signatures, memory management, and string encoding is essential for debugging audio/translation pipeline failures.
• SWIG (Simplified Wrapper and Interface Generator) — Likely used to auto-generate JNI bindings between Java and C++ NLLB/Whisper code; reducing boilerplate but adding a code-generation step that can obscure errors.
• Speech Recognition (ASR) / Automatic Speech Recognition — Whisper performs real-time audio-to-text conversion on-device; accuracy and latency are critical to user experience; quantization and model selection directly impact phone performance.
• Neural Machine Translation (NMT) with Transformers — Meta NLLB is a Transformer-based sequence-to-sequence model; understanding attention mechanisms and beam search helps optimize latency and memory footprint on mobile.
• Bluetooth Audio Routing (A2DP / HFP) — Conversation mode pipes audio in/out over Bluetooth headsets; Android's audio subsystem is complex; debugging echo, latency, or codec mismatches requires knowledge of Bluetooth profiles.
• Model Quantization (INT8 / FP16) — Full-precision NLLB/Whisper models are too large for mobile; RTranslator likely uses quantized versions; understanding trade-offs between accuracy and speed/memory is critical for model updates.
• SentencePiece Tokenization — sentencepiece_bpe.model in assets tokenizes text for NLLB/Whisper; BPE (Byte-Pair Encoding) must match the model training; misalignment causes translation failures on edge-case inputs (punctuation, emojis).

• facebookresearch/nllb — Official Meta NLLB repository; source of the translation model and baseline for on-device quantization strategies RTranslator may employ.
• openai/whisper — Official OpenAI Whisper speech recognition repo; upstream source for the model RTranslator bundles; relevant for updating model versions and understanding inference optimization.
• google/mediapipe — Google's framework for on-device ML inference on mobile; alternative/complementary approach to RTranslator's direct JNI for deploying NLLB/Whisper with less manual NDK work.
• mozilla/firefox-translations — Similar offline translation use-case for browsers; shares philosophy of privacy-first, on-device ML; reference for UI/UX patterns in real-time translation apps.
• Systran/nmt-android — Earlier Android NMT implementation; potential historical reference for RTranslator's architectural decisions and trade-offs.

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add instrumented tests for core translation pipeline (app/src/androidTest)

The repo has an empty ExampleInstrumentedTest.java but no actual tests for the translation engine. Given that RTranslator uses native C++ code (sentencepiece_bpe.model, CMakeLists.txt) and JNI bindings, there's critical value in adding instrumented tests that verify: (1) model loading from assets, (2) JNI bridge functionality, (3) translation output quality with sample inputs. This prevents regressions when updating the native translation models or dependencies.

• [ ] Replace app/src/androidTest/java/nie/translator/rtranslator/ExampleInstrumentedTest.java with actual test cases
• [ ] Add tests for native model initialization from app/src/main/assets/sentencepiece_bpe.model
• [ ] Add integration tests that call the JNI translation methods and verify non-empty output
• [ ] Document expected test outputs in README or test comments for maintainability

Add GitHub Actions workflow for automated release builds and APK signing

The repo has signing config in build.gradle (release block with signingConfigs.debug), but no CI/CD workflow in .github/workflows/ to automate builds. With version management already in place (versionCode 25, versionName '2.1.5'), adding a GitHub Actions workflow would: (1) automatically build release APKs on tag pushes, (2) validate compileSdkVersion 33 and targetSdkVersion 32 compatibility, (3) catch build failures before release, (4) support sideloading documentation (Sideloading.md exists but lacks automated release process).

• [ ] Create .github/workflows/build-release.yml that triggers on git tags matching v*
• [ ] Configure gradle build step with release buildType and proper SDK versions from build.gradle
• [ ] Add artifact upload to GitHub Releases for each successful build
• [ ] Document the tagging/release workflow in CONTRIBUTING.md to guide contributors

Add unit tests for Bluetooth and network communication layers (new test module)

The README describes 'Conversation mode' that requires Bluetooth headset connection and peer-to-peer connection with another phone. However, there are no visible tests in the file structure for the Bluetooth/networking code. This is critical for a real-time translation app where audio/data sync bugs directly impact usability. Create a dedicated test module to verify: (1) Bluetooth connection state management, (2) audio stream handling, (3) connection handshake protocol between two phones.

• [ ] Create app/src/test/java/nie/translator/rtranslator/bluetooth/ directory for local unit tests
• [ ] Create app/src/androidTest/java/nie/translator/rtranslator/bluetooth/ directory for instrumented tests
• [ ] Add mocked Bluetooth adapter tests for connection/disconnection lifecycle
• [ ] Add integration tests for peer discovery and connection request/acceptance flow
• [ ] Update CONTRIBUTING.md with instructions for running these specific test suites

• Add unit tests to app/src/androidTest/java/nie/translator/rtranslator/ for Java components (currently only ExampleInstrumentedTest.java skeleton exists); target: JUnit tests for audio pipeline and translation result formatting.
• Document the SWIG bridging layer in app/src/main/cpp/CONTRIBUTING.md with concrete examples of how Java calls invoke C++ NLLB/Whisper inference; currently no mention of JNI conventions or signature generation.
• Create a Makefile or shell script wrapper around gradle assembleDebug to simplify first-time builds for contributors without Android Studio; reduces setup friction (similar to Sideloading.md but for development).

The RTranslator application has several critical security concerns that require immediate attention. The most critical issues are: (1) using debug signing for release builds, (2) disabling code obfuscation/minification, (3) using a severely outdated gRPC library from 2018. These vulnerabilities expose the app to reverse engineering, unauthorized modification, and known remote code execution exploits. The targetSdkVersion is also below current standards. Immediate action is needed to

• High · Outdated gRPC Dependency — app/build.gradle (grpcVersion = '1.11.0'). The project uses gRPC version 1.11.0, which was released in 2018 and contains multiple known security vulnerabilities. This version is severely outdated and lacks security patches for issues affecting remote code execution, denial of service, and protocol vulnerabilities. Fix: Update gRPC to the latest stable version (1.60.0 or newer). Review release notes for breaking changes and test thoroughly after upgrading.
• High · Debug Build Configuration in Release — app/build.gradle (release buildType configuration). The release build is signed with a debug signing configuration (signingConfig signingConfigs.debug). This allows unauthorized modifications and installation of tampered APKs, compromising app integrity and enabling malware injection. Fix: Create and use a proper release signing configuration with a secure keystore. Never use debug signing for release builds.
• High · Code Obfuscation Disabled in Release — app/build.gradle (minifyEnabled false in release). minifyEnabled is set to false in the release build configuration. This leaves all source code and logic exposed to reverse engineering, making it trivial to extract translation algorithms, keys, or proprietary logic. Fix: Enable minifyEnabled and configure ProGuard/R8 rules to obfuscate code. Test the obfuscated release build thoroughly for runtime issues.
• Medium · Outdated Support Library Version — app/build.gradle (supportLibraryVersion = '1.0.0'). Support library version 1.0.0 is from 2018 and may contain deprecated or vulnerable components. AndroidX should be used instead. Fix: Migrate to AndroidX (androidx.* packages) and use the latest versions of required libraries.
• Medium · Target SDK Below Recommended Level — app/build.gradle (targetSdkVersion 32). targetSdkVersion is set to 32, which is below current Google Play requirements (34+). This may result in rejection from app stores and indicates the app doesn't comply with modern Android security standards. Fix: Update targetSdkVersion to 34 or higher and implement required Android 14+ features and permissions.
• Medium · Resource Shrinking Disabled — app/build.gradle (shrinkResources false). shrinkResources is set to false in release builds. Unused resources are included in the final APK, increasing attack surface and making reverse engineering slightly easier. Fix: Enable shrinkResources in release builds: shrinkResources true. Test that all required resources are retained.
• Low · Incomplete Lint Configuration — app/build.gradle (lintOptions block). The lintOptions block in build.gradle appears incomplete (ends abruptly with no closing braces visible). This may cause build configuration issues and missed lint warnings about potential bugs. Fix: Complete the lintOptions configuration. Consider adding specific rules to catch potential security issues: disable 'MissingTranslation' or configure appropriate warning levels.
• Low · Single ABI Filter Limits Device Compatibility — app/build.gradle (abiFilters 'arm64-v8a'). abiFilters is set to only 'arm64-v8a', excluding devices with 32-bit ARM, x86, and x86_64 architectures. While this may be intentional, it limits app reach and may exclude some users. Fix: Review if this is intentional. If broader device support is needed, add additional ABI filters: abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.