QSAI MESH VPN

A next-generation Android VPN & Router system with Smart Server Validation and Wi-Fi hotspot sharing to bypass strict network firewalls.

Comment

Inspiration

In an era where digital privacy is constantly under threat and internet censorship is becoming increasingly sophisticated, relying on a single VPN protocol is no longer enough. We noticed a significant gap in the market: advanced protocols like V2Ray (with XTLS-Reality) and WireGuard are incredibly powerful for bypassing restrictions, but their client apps are often fragmented, highly technical, and intimidating for average users.

QSAI MESH was inspired by the vision of bridging this gap. We wanted to build a "Swiss Army knife" of VPN clients—a universal, beautifully designed, and intelligent mesh network application that seamlessly unifies the world's most robust tunneling protocols under one intuitive roof.

What it does

QSAI MESH is a next-generation, multi-protocol VPN and proxy client for Android. It abstracts complex network engineering into a simple "Tap to Connect" experience.

Key features include:

  • Multi-Protocol Engine: Supports connections via V2Ray (vmess/vless), WireGuard, and native OpenVPN3.
  • Frictionless Onboarding: Users can import server configurations instantly by scanning a QR code (powered by ML Kit) or pasting links directly from their clipboard.
  • Real-time Analytics: Monitors live upload/download speeds and connection health.
  • Seamless Authentication & Billing: Integrated with a Supabase backend for secure user management and Google Play Billing for in-app subscriptions.
  • Modern UI/UX: A stunning, reactive interface built entirely with Jetpack Compose.

How I built it

The application was engineered from the ground up prioritizing modern Android architecture, performance, and security:

  • Frontend & Architecture: We used 100% Kotlin and Jetpack Compose for a fluid, reactive user interface. The app follows an MVVM architecture, utilizing Hilt for dependency injection, Coroutines/Flows for asynchronous operations, and Room Database for local configuration storage.
  • Core Networking: This is where the heavy lifting happens. We integrated three distinct networking engines:
    • V2Ray Core: Implemented via libv2ray.aar to support advanced Xray configurations and Reality masking.
    • WireGuard: Integrated the official Android tunnel library for high-speed, modern cryptography.
    • OpenVPN3: Compiled natively using C++/CMake and the Android NDK, custom-configured to support 16 KB page alignment for compatibility with the latest Android 15 devices.
  • Tools & Hardware APIs: Integrated CameraX alongside Google ML Kit for blazing-fast, secure on-device QR code scanning without relying on outdated libraries.
  • Backend: Leveraged the Supabase Kotlin SDK (postgrest-kt, realtime-kt) for seamless database management, user authentication, and subscription tracking.

Challenges I ran into

  • Native Library Orchestration: Integrating three different low-level networking cores (V2Ray, WireGuard, OpenVPN3) into a single app was a massive challenge. Managing the NDK, CMake configurations, and JNI bindings—specifically ensuring 16 KB page alignment for the latest ARM64 architectures—required deep dives into C++ build systems.
  • State Management: Keeping the UI perfectly synchronized with the asynchronous, unpredictable states of multiple VPN tunnels (Connecting, Authenticating, Connected, Disconnected) required meticulously crafted Kotlin Flows to avoid memory leaks or UI freezing.
  • Dependency Conflicts: Balancing complex dependencies like Supabase, CameraX, Billing, and legacy native binaries while keeping the APK size optimized and avoiding build-time collisions.

Accomplishments that I'm proud of

  • Unified Protocol Experience: Successfully abstracting highly complex configurations (like vless links) so that a user simply scans a QR code and connects, completely unaware of the heavy native C++ lifting happening in the background.
  • Performance & Polish: Achieving a crash-free, butter-smooth UI using Jetpack Compose that feels premium and responsive, even when handling intense network routing.
  • Future-Proof Infrastructure: Setting up a robust Supabase backend alongside an easily extensible Android architecture, meaning we can scale users and add new protocols rapidly.

What I learned

Building QSAI MESH was a masterclass in advanced Android development. I deeply expanded my knowledge of:

  • Bridging the gap between JVM and native C++ code using the Android NDK and CMake.
  • The inner workings of network tunneling, routing, and modern proxy protocols like V2Ray/XTLS.
  • Advanced Jetpack Compose UI state management and custom layout design.
  • Integrating and securing backend-as-a-service (BaaS) platforms like Supabase natively in Kotlin.

What's next for QSAI MESH

  • Cross-Platform Expansion: Porting the business logic to Kotlin Multiplatform (KMP) to launch iOS and Desktop versions.
  • Split Tunneling (App Routing): Allowing users to select exactly which apps bypass the VPN and which are routed through it.
  • True Mesh Networking: Implementing peer-to-peer (P2P) mesh capabilities where devices can securely route traffic through one another, maximizing censorship resistance.
  • Smart Protocol Selection: Implementing an AI-driven feature that automatically tests and switches to the best-performing protocol based on the user's current network restrictions.

Built With

Share this project:

Updates