╔═══════════════════════════════════════════════════════════╗
║ ║
║ ██████╗ ██╗ ███████╗ ██████╗████████╗██╗ ██╗███╗ ██╗███████╗ ║
║ ██╔══██╗██║ ██╔════╝██╔════╝╚══██╔══╝██║ ██║████╗ ██║██╔════╝ ║
║ ██████╔╝██║ █████╗ ██║ ██║ ██║ ██║██╔██╗ ██║█████╗ ║
║ ██╔═══╝ ██║ ██╔══╝ ██║ ██║ ██║ ██║██║╚██╗██║██╔══╝ ║
║ ██║ ███████╗███████╗╚██████╗ ██║ ╚██████╔╝██║ ╚████║███████╗ ║
║ ╚═╝ ╚══════╝╚══════╝ ╚═════╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝╚══════╝ ║
║ ║
╚═══════════════════════════════════════════════════════════╝
Professional-Grade Guitar Tuner • Ultra-Low-Latency Metronome • Comprehensive Chord Library
Plectune brings the sophisticated, physics-driven UI interactions of iOS to Android, combining professional-grade audio precision with a stunning Liquid Glass interface that feels like magic in your hands.
📥 Download Now • ✨ Features • 🎨 See It In Action • 🛠️ Tech Stack • 🤝 Contributing
- 🌟 Why Plectune?
- 📥 Download
- 🎨 Demo
- ✨ Features
- 💡 Design Philosophy
- 🔬 Behind the Scenes
- 🛠️ Tech Stack
- 📥 Installation
- 🏗️ Architecture
- 🗺️ Roadmap
- 🤝 Contributing
- ❓ FAQ
- 📄 License
- 🙏 Acknowledgments
- 👤 Author
|
Industry-standard YIN algorithm delivers professional-grade accuracy |
C++ Oboe engine ensures zero-drift, ultra-low-latency audio |
iOS-style Liquid Glass UI on Android—complex physics, simple interaction |
Unlike typical tuner apps, Plectune doesn't compromise. It's built by a musician who understands the frustration of lag, drift, and clunky interfaces. Every animation is physics-based, every interaction feels natural, and every audio calculation runs at peak efficiency.
The Bottom Line: Professional tools deserve professional design. Plectune delivers both.
🌟 Star us on GitHub if you believe Android apps can be both powerful and beautiful!
Requirements: Android 11+ (API 30+) • ~7 MB • No Ads • No Tracking • 100% Free
| 🎸 Tuner | ⏱️ Metronome | 🎼 Chords |
|---|---|---|
 |
 |
 |
| Real-time pitch tracking with living graph | Physics-based pulse visualizer | Interactive chord explorer |
- 🎵 YIN Pitch Detection: Utilizes the industry-standard YIN algorithm for high-precision pitch tracking with sub-cent accuracy
- 📊 Living Graph UI: A unique "snake trail" history graph that visualizes pitch stability over time—see exactly how stable your tuning is
- 🎸 Chromatic & Standard: Accurate detection for guitar, bass, ukulele, and other stringed instruments
- 🎨 Visual Feedback: Real-time needle gauge with color-coded tuning zones (flat/sharp/perfect)
- 🔊 Reference Tone Generator: Play standard pitch references to tune by ear
- 🚀 C++ Audio Engine: Powered by Google's Oboe library for ultra-low latency timing that won't drift—even after hours of use
- 🌊 Visual Pulse: A beautiful, wave-based visualizer that syncs perfectly with the beat
- 🎯 Interactive Tap Tempo: Tap to set your BPM naturally, with intelligent tempo averaging
- 🎼 Time Signatures: Comprehensive support from 1/4 to 12/4, perfect for complex compositions
- 🎨 Liquid Controls: Physics-based BPM slider with damped spring animations—feels like you're touching real material
- 📱 Haptic Feedback: Subtle vibration on each beat for tactile timing reference
- 📚 500+ Chords: Complete database of Major, Minor, 7th, Diminished, Augmented, Sus, and extended voicings
- 🎯 Interactive Charts: Browse chords by root note and quality with a smooth horizontal pager
- 🔊 Audio Playback: Hear how every chord sounds with integrated, high-quality playback
- 🎸 Fretboard Visualization: Clear, professionally-generated diagrams showing exact finger positions
- 🎨 Color-Coded Fingers: Visual indicators for which fingers to use (Index, Middle, Ring, Pinky)
- ⚡ Quick Search: Find any chord variation instantly
The crown jewel of Plectune—a complete reimagining of what Android UI can be.
- ✨ iOS-Style Physics: Implements complex blur, vibrancy, and light refraction effects typically exclusive to iOS
- 🌊 Interactive Components: Every button and slider feels organic, reacting to touch pressure and drag velocity
- 🎯 Damped Spring Animations: Natural, physics-accurate motion—no robotic easing curves
- 💎 Glass Morphism: Translucent, layered UI elements with realistic depth and material properties
- 🎨 Adaptive Theming: Dark and light modes that seamlessly blend with your content
- 👆 Pressure-Sensitive Feedback: Components respond to how hard you press, not just where
"Why should Android users settle for less elegant interactions just because we're not on iOS?"
Plectune's design philosophy centers on three core principles:
Real-world materials don't follow cubic bezier curves—they follow physics. Every interaction in Plectune uses damped spring simulations to create movement that feels natural and responsive. When you drag a slider, it doesn't just move linearly—it has inertia, drag, and subtle overshoot that your brain recognizes as authentic.
The Liquid Glass effect isn't just a visual trick—it's a complete simulation of how light interacts with translucent, refractive materials. Using advanced shader techniques and the Backdrop library, Plectune achieves:
- Real-time blur based on background content
- Vibrancy effects that enhance foreground elements
- Light refraction that responds to UI depth
- Material thickness variations that affect translucency
Beautiful UI means nothing if it stutters. Plectune achieves 60 FPS animations while running audio processing by:
- Offloading audio to native C++ threads
- Using Jetpack Compose's efficient recomposition
- Implementing custom gesture detectors that bypass unnecessary layers
- Leveraging hardware acceleration for all blur and shader effects
The Result: An app that feels impossibly smooth while doing the heavy computational work of professional audio analysis.
Most tuner apps use basic FFT (Fast Fourier Transform) for pitch detection. It works, but it struggles with:
- Harmonics: Guitar strings produce complex overtones that confuse FFT
- Low frequencies: Bass notes take too long to analyze accurately
- Noise: Background sound causes false readings
YIN (Yet another INtonation detector) solves these problems using autocorrelation with several clever optimizations:
- Difference Function: Measures signal difference at various time lags
- Cumulative Mean Normalized Difference: Normalizes to handle varying amplitudes
- Absolute Threshold: Finds the first minimum below a threshold for speed
- Parabolic Interpolation: Achieves sub-sample accuracy
The Result: Sub-cent accuracy even with noisy input, making Plectune suitable for professional use.
Metronomes seem simple—just play a click at regular intervals. But smartphone audio has latency (delay between code execution and sound output) that varies wildly:
- High-latency path: 100-400ms delay (unusable for timing)
- Low-latency path: 10-50ms delay (barely acceptable)
- Oboe with MMAP: 2-10ms delay (professional grade)
Plectune uses Google Oboe, a C++ library that:
- Automatically selects the lowest-latency audio path available on your device
- Uses AAudio on Android 8+ for MMAP (memory-mapped audio)
- Falls back to OpenSL ES on older devices
- Handles buffer underruns gracefully to prevent glitches
The metronome runs in a separate real-time thread with elevated priority, ensuring clicks are never late—even if the UI is busy rendering or the system is under load.
Creating the Liquid Glass effect required solving several non-trivial challenges:
Android's native RenderEffect.createBlurEffect() is GPU-accelerated, but doesn't support the selective blur needed for glass morphism.
Solution: Using the Backdrop library with custom shader composition:
MaterialBlur(
radius = 16.dp,
color = MaterialTheme.colorScheme.surfaceContainerHigh,
blend = BlendMode.Screen
)Android's default animators use easing functions, not physics.
Solution: Custom physics engine using second-order dynamics:
// Simplified version of the actual implementation
class DampedSpringAnimation(
val stiffness: Float = 200f, // How "tight" the spring is
val damping: Float = 0.7f, // How quickly motion settles
val mass: Float = 1f // Inertial resistance
)Standard Android touch events don't provide pressure information in a useful way.
Solution: Custom gesture detector that combines:
- Touch size (larger contact area = harder press)
- Movement velocity (affects momentum)
- Touch duration (long press increases "depth")
|
|
| Category | Details |
|---|---|
| Min SDK | 30 (Android 11) |
| Target SDK | 36 (Android 16) |
| JDK | 21 |
| Compose Version | Latest stable |
| Code Distribution | 95.2% Kotlin, 4.5% C++, 0.3% CMake |
|
🛠️ Development Tools
|
📱 Test Device
|
🎸 Optional
|
# 1️⃣ Clone the repository
git clone https://github.com/Quantum3600/Plectune.git
cd Plectune
# 2️⃣ Open in Android Studio
# File > Open > Select Plectune directory
# 3️⃣ Build the project (optional - Android Studio does this automatically)
./gradlew build
# 4️⃣ Run on device
# Connect your Android device
# Click the "Run" button in Android Studio
# Or use: ./gradlew installDebug- Launch Plectune on your device
- Grant microphone permission for the tuner
- Start with the Tuner tab - play a note and watch the magic happen!
- Try the Metronome - feel the physics-based interactions
- Explore Chords - browse and play your favorite chords
Plectune follows a clean MVI (Model-View-Intent) architecture pattern with clear separation of concerns:
📦 com.trishit.plectune
┣━━📂 feature # Feature modules (MVI architecture)
┃ ┣━━📂 tuner
┃ ┃ ┣━━📜 presentation # TunerScreen, TunerState, TunerIntent
┃ ┃ ┣━━📜 domain # YIN algorithm, pitch processing
┃ ┃ ┗━━📜 ui # Gauge, Graph, ToneGenerator
┃ ┣━━📂 metronome
┃ ┃ ┣━━📜 presentation # MetronomeScreen, State, Intent
┃ ┃ ┣━━📜 domain # BPM calculations, beat tracking
┃ ┃ ┗━━📜 native # C++ Oboe integration (JNI)
┃ ┗━━📂 chords
┃ ┣━━📜 presentation # ChordScreen, ChordState
┃ ┣━━📜 domain # Chord repository, audio playback
┃ ┗━━📜 ui # Fretboard views, chord diagrams
┃
┣━━📂 ui # Shared UI components
┃ ┣━━📂 components
┃ ┃ ┣━━📜 LiquidButton # Physics-based button
┃ ┃ ┣━━📜 LiquidSlider # Damped spring slider
┃ ┃ ┣━━📜 LiquidToggle # Animated toggle switch
┃ ┃ ┣━━📜 FretboardView # Guitar fretboard renderer
┃ ┃ ┣━━📜 TunerGauge # Circular pitch gauge
┃ ┃ ┗━━📜 LiquidBottomTabs # Glass morphism navigation
┃ ┣━━📂 utils
┃ ┃ ┣━━📜 DampedDragAnimation # Custom physics engine
┃ ┃ ┣━━📜 InteractiveHighlights # Pressure-sensitive effects
┃ ┃ ┗━━📜 DragGestureInspector # Touch event processing
┃ ┗━━📂 theme
┃ ┣━━📜 Color # Material 3 color schemes
┃ ┣━━📜 Type # Typography system
┃ ┗━━📜 Theme # App theme configuration
┃
┣━━📂 di # Dependency Injection
┃ ┗━━📜 AppModule # Koin modules
┃
┗━━📂 navigation # App navigation graph
┗━━📜 AppNavigation # Compose navigation setup
┌─────────────┐
│ View │ ──Intent──> │ ViewModel │
│ (Compose) │ │ (MVI) │
└─────────────┘ └─────────────┘
↑ │
│ ↓
│ ┌─────────────┐
└────State────────────│ Model │
│ (Domain) │
└─────────────┘
- User Interaction → Triggers an Intent (e.g.,
TunerIntent.StartListening) - ViewModel → Processes intent, updates state
- State → Emitted to the UI layer
- Compose → Recomposes based on new state
- MVI over MVVM: Unidirectional data flow prevents state inconsistencies
- Koin over Dagger: Simpler setup, faster builds, Kotlin-first
- Compose-only: No XML layouts, full declarative UI
- Native audio: C++ for performance-critical code paths
📱 v1.1 - Enhanced User Experience (Next Release)
- Custom Tuning Presets - Save favorite tunings (Drop D, DADGAD, etc.)
- Recording History - Track tuning sessions and progress
- Offline Chord PDF Export - Generate printable chord charts
- Widget Support - Quick access metronome widget
- Haptic Patterns - Custom vibration patterns for different time signatures
- Language Localization - Spanish, French, German, Japanese
🎨 v1.2 - Advanced Customization
- Theme Gallery - Multiple Liquid Glass color schemes
- Custom Chord Progressions - Save and practice chord sequences
- Advanced Tuner Modes - Strobe tuner, cents display
- Metronome Patterns - Polyrhythms and complex time signatures
- Audio Effects - Reverb and delay for chord playback
🔬 v2.0 - Pro Features (Long-term)
- Practice Mode - Structured practice sessions with tracking
- Backing Tracks - Play along with generated backing tracks
- Scale Library - Visual scale patterns and theory
- MIDI Support - Connect to external instruments
- Cloud Sync - Sync presets across devices
- Social Features - Share tunings and chord progressions
Have a feature idea? Open an issue with the enhancement label!
We welcome contributions from the community! Whether you're fixing bugs, adding features, or improving documentation, your help makes Plectune better.
- ⭐ Star this repo - Show your support!
- 🍴 Fork the repository
- 🔧 Create a feature branch -
git checkout -b feature/amazing-feature - ✨ Make your changes - Follow our coding standards
- ✅ Test thoroughly - Ensure everything works
- 📝 Commit your changes -
git commit -m 'Add amazing feature' - 🚀 Push to your fork -
git push origin feature/amazing-feature - 🎉 Open a Pull Request - Describe your changes clearly
Code Style
- Kotlin: Follow official Kotlin coding conventions
- Formatting: Use Android Studio's built-in formatter (Ctrl+Alt+L)
- Naming: Descriptive names, avoid abbreviations
- Comments: Explain why, not what (code should be self-documenting)
Commit Messages
Use conventional commit format:
<type>(<scope>): <subject>
[optional body]
[optional footer]
Types: feat, fix, docs, style, refactor, test, chore
Example:
feat(tuner): add custom tuning presets
- Implement preset storage using DataStore
- Add UI for preset selection
- Support 10+ common guitar tunings
Closes #42
Areas We Need Help With
- 🌐 Translations - Help localize Plectune
- 📱 UI/UX Design - Create mockups for new features
- 🐛 Bug Reports - Test and report issues
- 📚 Documentation - Improve guides and tutorials
- 🎨 Graphics - App icons, promotional materials
- 🎵 Music Theory - Enhance chord library and scales
A huge thank you to everyone who has contributed to Plectune!
❓ Why is the tuner not detecting my guitar?
Troubleshooting steps:
- Check microphone permission - Plectune needs mic access
- Play louder - Strum harder or move closer to your device
- Reduce background noise - Find a quieter environment
- Check string condition - Old, dead strings are harder to detect
- Try chromatic mode - More flexible than standard tuning
The YIN algorithm is very accurate but needs a clear, sustained tone to work properly.
❓ The metronome has slight latency. Why?
Audio latency depends on your device's hardware and Android version:
- Modern devices (Android 11+): 2-10ms latency (imperceptible)
- Older devices: Up to 50ms latency (noticeable)
Plectune uses Oboe to achieve the lowest possible latency your device supports. If you experience lag:
- Close background apps - Free up CPU resources
- Use wired headphones - Bluetooth adds 100-200ms latency
- Enable Developer Options - Disable absolute volume for better performance
❓ How does the Liquid Glass effect work?
The Liquid Glass UI is achieved through a combination of:
- Material blur - Real-time gaussian blur on background content
- Vibrancy effects - Color saturation and contrast adjustments
- Custom shaders - GLSL shaders for light refraction
- Physics animations - Damped spring simulations for natural motion
This is implemented using the kyant0/backdrop library, which Plectune helps demonstrate and test.
❓ Can I use Plectune for live performance?
Yes! Plectune is designed for professional use:
- Tuner: Sub-cent accuracy suitable for stage tuning
- Metronome: Ultra-low latency won't drift during long sessions
- Visual design: High-contrast UI visible in various lighting
Pro tips for live use:
- Keep your device charged (audio processing is CPU-intensive)
- Use wired headphones for the metronome (no Bluetooth latency)
- Adjust screen brightness for stage visibility
- Consider enabling "Do Not Disturb" to prevent interruptions
❓ Does Plectune collect any data?
No. Plectune:
- ✅ No analytics - We don't track usage
- ✅ No ads - 100% ad-free experience
- ✅ No network access - Works completely offline
- ✅ No account required - Use instantly without sign-up
- ✅ Open source - Review the code yourself
Your privacy is paramount. All audio processing happens on-device and nothing is ever transmitted.
❓ Will Plectune work on tablets and foldables?
Yes! Plectune is built with Jetpack Compose, which automatically adapts to different screen sizes. The UI scales elegantly from small phones to large tablets and foldables.
For the best experience on tablets:
- Landscape mode provides more space for visualizers
- Larger screens make the fretboard diagrams easier to read
- Multi-window mode is supported (e.g., tuner + chord reference side-by-side)
This project is licensed under the Apache License, Version 2.0.
Copyright 2026 Trishit Majumdar
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
✅ You CAN:
- Use Plectune for personal or commercial purposes
- Modify the source code
- Distribute your modifications
- Use the code in proprietary software
❗ You MUST:
- Include the original license and copyright notice
- State significant changes made to the code
🚫 You CANNOT:
- Hold the author liable for damages
- Use contributor names for endorsement without permission
For the full license text, see LICENSE or visit apache.org/licenses/LICENSE-2.0.
Plectune stands on the shoulders of giants. Huge thanks to:
- Kyant0 - Creator of the Backdrop library (AndroidLiquidGlass)
- This project serves as a comprehensive demo of replicating complex iOS liquid glass physics and blur effects on Android
- Also for the shapes library used for custom rendering
- Material Design Team - For the foundational design guidelines and Material 3 components
- Google Oboe Team - For enabling low-latency audio features required for professional-grade metronome functionality
- Alain de Cheveigné & Hideki Kawahara - Creators of the YIN pitch detection algorithm
- Open source audio community - For continuous research and improvements in mobile audio
- JetBrains - For Kotlin and the amazing tooling ecosystem
- Android Team - For Jetpack Compose and modern Android development tools
- Koin Contributors - For the lightweight dependency injection framework
- All open-source contributors - Who make projects like this possible
- Musicians everywhere - Who inspired the need for better mobile music tools
- Beta testers - Who provided invaluable feedback during development
- You! - For checking out Plectune and supporting open source
Trishit Majumdar (@Quantum3600)
Musician • Developer • Open Source Enthusiast
Found a bug? Have a feature idea? Just want to say hi?
- 🐛 Bug Reports: Open an issue
- 💡 Feature Requests: Request a feature
- 💬 Discussions: Join the conversation
- ⭐ Show Support: Star this repo
Made with ❤️, ☕, and Kotlin
🎵 Plectune - Because Your Music Deserves Better Tools 🎵
If you found this project helpful, consider giving it a ⭐ on GitHub!