High-Performance Financial Graphics with Rust & Kotlin

A complete high-performance financial charting application built with Rust (for technical indicators) and Kotlin/Jetpack Compose (for UI). Features real-time cryptocurrency price data from Binance WebSocket API with blazing-fast native calculations.

🏗️ Architecture Overview

This project demonstrates a hybrid Rust/Kotlin architecture for maximum performance:

┌─────────────────────────────────────────────────────────────┐
│                    Jetpack Compose UI Layer                  │
│  • Candlestick Charts  • Volume Bars  • RSI Indicators      │
│  • Real-time Updates   • Smooth Animations                  │
└─────────────────────────────┬───────────────────────────────┘
                              │
┌─────────────────────────────▼───────────────────────────────┐
│                  Binance WebSocket Service                   │
│  • Real-time BTC/USDT Data  • Connection Management         │
│  • Trade Stream Processing  • State Flow Integration        │
└─────────────────────────────┬───────────────────────────────┘
                              │
┌─────────────────────────────▼───────────────────────────────┐
│                    Kotlin Business Layer                     │
│  • Data Models  • Business Logic  • Data Processing        │
└─────────────────────────────┬───────────────────────────────┘
                              │
              ┌───────────────▼───────────────┐
              │  TechnicalIndicators (Hybrid) │
              │  • JNI Bridge                 │
              │  • Native + Kotlin Fallback   │
              └───────────┬───────────────────┘
                          │
        ┌─────────────────┴─────────────────┐
        │                                   │
┌───────▼──────────┐              ┌─────────▼─────────┐
│  Rust Native     │              │  Kotlin Fallback  │
│  (Primary)       │              │  (Backup)         │
│  • 2-5x Faster   │              │  • Pure Kotlin    │
│  • Zero GC       │              │  • Always Works   │
│  • SIMD Optimized│              │  • Safe Fallback  │
└──────────────────┘              └───────────────────┘

🚀 Key Features

Performance

• 🦀 Rust-Powered Calculations: Technical indicators implemented in Rust for 2-5x performance boost
• Zero Garbage Collection: Native Rust code eliminates GC pauses during calculations
• SIMD Optimizations: Compiler auto-vectorization for tight computational loops
• Optimized for Large Datasets: Handles 1000+ candlesticks smoothly at 60 FPS
• Hybrid Architecture: Automatic fallback to Kotlin if native library unavailable
• Clean Architecture: Well-organized code following best practices
• 📊 Benchmarked: Comprehensive performance testing suite included (see benchmarks)

Technical Indicators

• Simple Moving Average (SMA): 20-period and 50-period
• Exponential Moving Average (EMA): 12-period and 26-period
• Relative Strength Index (RSI): 14-period with visual zones
• MACD: Moving Average Convergence Divergence with signal line and histogram

Real-time Data Integration

• Binance WebSocket: Live BTC/USDT trade data from Binance API
• Real-time Price Updates: Actual market data streaming via WebSocket
• Connection Management: Automatic connection handling and cleanup
• State Flow Integration: Reactive data flow using Kotlin StateFlow

UI Features

• Interactive Charts: Swipe to pan through historical data
• Live Price Updates: Real-time price data from Binance WebSocket
• Toggle Indicators: Enable/disable indicators on the fly
• Dark Theme: Material Design 3 dark theme
• Responsive Layout: Scrollable dashboard with multiple chart types
• Visual Feedback: Color-coded bullish/bearish candles and indicators

📦 Project Structure

RustAndAndroid/
├── rust/                                 # 🦀 Rust implementation
│   ├── Cargo.toml                       # Rust dependencies & config
│   ├── .cargo/config.toml               # Android NDK linker settings
│   └── src/
│       ├── lib.rs                       # JNI bindings for Kotlin interop
│       └── indicators.rs                # Native indicator algorithms
│
├── app/src/
│   ├── main/
│   │   ├── java/com/davthecoder/financial/
│   │   │   ├── MainActivity.kt          # Financial dashboard UI
│   │   │   ├── BinanceWebSocketService.kt # Real-time Binance WebSocket
│   │   │   ├── Indicators.kt            # Data processing layer
│   │   │   ├── TechnicalIndicators.kt   # Hybrid Rust/Kotlin indicators
│   │   │   ├── FinanceCharts.kt         # Compose chart components
│   │   │   └── ui/theme/                # App theming
│   │   └── jniLibs/                     # Compiled Rust libraries
│   │       ├── arm64-v8a/
│   │       ├── armeabi-v7a/
│   │       ├── x86_64/
│   │       └── x86/
│   ├── test/                            # Unit tests (JVM)
│   │   └── BenchmarkTest.kt             # Kotlin-only benchmarks
│   └── androidTest/                     # Instrumented tests (Device)
│       └── BenchmarkInstrumentedTest.kt # Rust vs Kotlin benchmarks
│
├── build-rust.sh                        # Rust build script
├── run-benchmarks.sh                    # Automated benchmark runner
├── RUST_MIGRATION.md                    # Detailed Rust integration docs
├── BENCHMARKING.md                      # Benchmark how-to guide
├── BENCHMARK_REPORT.md                  # Detailed performance analysis
├── BENCHMARK_SUMMARY.md                 # Quick benchmark reference
└── README.md                            # This file

🛠️ Prerequisites

Before building this project, ensure you have the following installed:

Android Development Environment

• Android Studio: Latest stable version (Hedgehog or newer recommended)
• Android SDK: API Level 26 or higher
• Android NDK: Version 21 or higher (for Rust compilation)
• JDK: Version 11 or higher

Rust Toolchain (Required for building native libraries)

• Rust: Install from rustup.rs

  curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

• Android Targets: Install after Rust setup

  rustup target add aarch64-linux-android
  rustup target add armv7-linux-androideabi
  rustup target add x86_64-linux-android
  rustup target add i686-linux-android

🔨 Building the Project

Step 1: Build Rust Libraries

# Compile Rust for all Android architectures and copy to jniLibs
./build-rust.sh

This will:

• ✅ Compile Rust code for arm64-v8a, armeabi-v7a, x86_64, x86
• ✅ Copy .so libraries to app/src/main/jniLibs/
• ✅ Verify Android NDK configuration

Step 2: Build Android App

# Via command line:
./gradlew assembleDebug

# Or via Android Studio: Build > Make Project

Step 3: Run on Device/Emulator

# Via command line:
./gradlew installDebug

# Or via Android Studio: Run > Run 'app'

Note: If you skip Step 1, the app will automatically fall back to pure Kotlin implementations (slightly slower but fully functional)

✅ Verification

After building, verify everything is working correctly:

Android App Builds Without Errors

./gradlew assembleDebug

Should complete with BUILD SUCCESSFUL

App Runs and Displays Charts

• Launch the app on a device/emulator
• Verify you see:
  • ✅ Financial Chart Demo header
  • ✅ Current BTC/USDT price card with real-time updates
  • ✅ Indicators toggles (SMA 20, SMA 50, EMA 12, RSI, Volume)
  • ✅ Candlestick chart with price data
  • ✅ Volume chart (if enabled)
  • ✅ RSI indicator chart (if enabled)

Indicators Working

• Toggle indicators on/off and verify:
  • ✅ Lines appear/disappear on the chart
  • ✅ No crashes or errors
  • ✅ Charts remain smooth and responsive

Real-time Updates

• Watch the price card update every 2 seconds
• Verify the last candlestick updates dynamically

💡 How It Works

1. Technical Indicators (Rust Native + Kotlin Fallback)

The TechnicalIndicators.kt object provides a hybrid implementation:

object TechnicalIndicators {
    private var useNative = true

    init {
        try {
            System.loadLibrary("financial_indicators") // Load Rust library
        } catch (e: UnsatisfiedLinkError) {
            useNative = false // Fall back to Kotlin
        }
    }

    // Native Rust methods (via JNI)
    @JvmStatic
    private external fun calculateSMANative(data: FloatArray, period: Int): FloatArray

    // Public API with automatic fallback
    fun calculateSMA(data: FloatArray, period: Int): FloatArray {
        return if (useNative) {
            try {
                calculateSMANative(data, period) // 🦀 Rust (2-3x faster)
            } catch (e: Exception) {
                calculateSMAKotlin(data, period)  // Fallback
            }
        } else {
            calculateSMAKotlin(data, period)      // Pure Kotlin
        }
    }

    // Similar pattern for EMA, RSI, MACD...
}

Rust Implementation (rust/src/indicators.rs):

pub fn calculate_sma(data: &[f32], period: usize) -> Vec<f32> {
    // Highly optimized, zero-allocation hot path
    // SIMD auto-vectorization by compiler
    // No garbage collection overhead
}

2. Real-time Data Integration

BinanceWebSocketService.kt provides live cryptocurrency data from Binance:

class BinanceWebSocketService {
    val connectionState: StateFlow<ConnectionState>
    val tradeData: StateFlow<TradeData?>
    
    suspend fun connect() {
        // Connects to Binance WebSocket and streams BTC/USDT trades
        // Updates tradeData flow with real-time prices
    }
    
    suspend fun disconnect() {
        // Cleanly closes WebSocket connection
    }
}

3. Data Processing Layer

Indicators.kt provides a clean data processing API:

object Indicators {
    fun calculateSMA(data: FloatArray, period: Int): FloatArray {
        return TechnicalIndicators.calculateSMA(data, period) // Uses Rust or Kotlin
    }

    fun processChartData(candles: List<CandleStick>): ChartData {
        val closePrices = candles.map { it.close }.toFloatArray()

        // All calculations use Rust if available (2-5x faster)
        val sma20 = calculateSMA(closePrices, 20)
        val sma50 = calculateSMA(closePrices, 50)
        val rsi = calculateRSI(closePrices, 14)
        val macdData = calculateMACD(closePrices, 12, 26, 9)

        return ChartData(candles, sma20, sma50, rsi, macdData, ...)
    }
}

4. Compose UI Components

FinanceCharts.kt renders charts using Canvas for smooth 60 FPS performance:

@Composable
fun CandlestickChart(chartData: ChartData, ...) {
    Canvas(modifier = ...) {
        // Direct drawing to Canvas for maximum performance
        chartData.candles.forEach { candle ->
            drawCandlestick(candle, ...)
        }
    }
}

5. Financial Dashboard

MainActivity.kt orchestrates everything:

• Connects to Binance WebSocket for real-time data
• Processes indicators using Rust (with Kotlin fallback)
• Updates UI in real-time with live price data at 60 FPS
• Handles user interactions (toggle indicators, pan charts)
• Zero-latency indicator calculations thanks to native Rust

🎨 Customization

Adding New Indicators

1. Implement in Rust (rust/src/indicators.rs):

pub fn calculate_bollinger_bands(
    data: &[f32],
    period: usize,
    std_dev: f32
) -> Vec<f32> {
    // Native implementation
    // Returns [upper, middle, lower, ...]
}

2. Add JNI Binding (rust/src/lib.rs):

#[no_mangle]
pub extern "C" fn Java_com_davthecoder_financial_TechnicalIndicators_calculateBollingerBandsNative(
    env: JNIEnv,
    _class: JClass,
    data: JFloatArray,
    period: i32,
    std_dev: f32,
) -> jfloatArray {
    // JNI marshaling
}

3. Update Kotlin (TechnicalIndicators.kt):

@JvmStatic
private external fun calculateBollingerBandsNative(
    data: FloatArray, period: Int, stdDev: Float
): FloatArray

fun calculateBollingerBands(data: FloatArray, period: Int, stdDev: Float): FloatArray {
    return if (useNative) {
        try {
            calculateBollingerBandsNative(data, period, stdDev)
        } catch (e: Exception) {
            calculateBollingerBandsKotlin(data, period, stdDev)
        }
    } else {
        calculateBollingerBandsKotlin(data, period, stdDev)
    }
}

4. Build and Test:

./build-rust.sh
./gradlew assembleDebug

See RUST_MIGRATION.md for detailed documentation.

Styling Charts

Modify ChartColors in FinanceCharts.kt:

object ChartColors {
    val bullish = Color(0xFF26A69A)  // Customize colors
    val bearish = Color(0xFFEF5350)
    // ...
}

🧪 Testing

Unit Tests

# Run unit tests
./gradlew test

# Run with coverage
./gradlew testDebugUnitTest

Instrumented Tests (Android)

./gradlew connectedAndroidTest

Performance Benchmarks

# Run comprehensive benchmark suite
./run-benchmarks.sh

# View detailed results
cat BENCHMARK_REPORT.md        # Full analysis
cat BENCHMARK_SUMMARY.md       # Quick reference
cat BENCHMARKING.md            # How-to guide

The benchmark suite tests:

• ✅ SMA, EMA, RSI, MACD performance
• ✅ Rust vs Kotlin comparison
• ✅ Real-world data patterns (BTC prices)
• ✅ Multiple dataset sizes (100 to 10,000 points)
• ✅ Full chart processing scenarios

See BENCHMARKING.md for detailed instructions.

🔍 Debugging

Debugging Kotlin Code

1. Set breakpoints in any Kotlin file (TechnicalIndicators.kt, MainActivity.kt, etc.)
2. Click the Debug button in Android Studio
3. Inspect variables and step through code as normal

Debugging Rust Code

For debugging native Rust code:

1. Add println!() or log!() statements in Rust
2. View output in Android Logcat
3. For advanced debugging, use lldb with Android NDK

Verifying Native Library Usage

Check logcat on app startup:

# If Rust library loaded successfully:
adb logcat | grep "TechnicalIndicators"
# Should show: Using native Rust implementation

# If fallback to Kotlin:
# Should show: Failed to load native library, using Kotlin fallback

Performance Profiling

Use Android Studio Profiler to analyze:

• CPU usage during indicator calculations
• Memory allocation patterns
• UI rendering performance

📚 Further Reading

Rust & JNI

• Rust JNI Crate Documentation
• Android NDK Guide
• Rust Book - FFI Chapter

Android & Kotlin

• Kotlin Documentation
• Jetpack Compose Canvas
• Android Performance Best Practices

Technical Analysis

• Technical Analysis Indicators
• Financial Algorithms Reference

Project Documentation

• RUST_MIGRATION.md - Detailed Rust integration guide

🤝 Contributing

Contributions are welcome! Areas for improvement:

• Rust Indicators: Additional technical indicators (Bollinger Bands, Stochastic, etc.)
• Performance: Benchmarking suite comparing Rust vs Kotlin implementations
• Testing: Comprehensive unit tests for Rust and Kotlin code
• Features:
  • Pinch-to-zoom gesture support
  • Multiple cryptocurrency pairs support
  • Historical data persistence (Room, SQLite)
  • Custom indicator builder
• Infrastructure:
  • CI/CD for automated Rust builds
  • Cross-compilation for iOS (via Rust)
  • WebSocket reconnection logic

📄 License

This project is provided as-is for educational and demonstration purposes.

🙏 Acknowledgments

• Rust Team: For an incredible systems programming language with zero-cost abstractions
• Kotlin Team: For an excellent modern programming language
• Android Team: For Jetpack Compose and modern Android development
• JNI Community: For making native interop possible and well-documented
• Financial Analysis Community: For standardized indicator algorithms
• Binance: For providing free WebSocket API access

👨‍💻 Developer

David Cruz Anaya
🌐 www.davthecoder.com

---

Built with ❤️ using Rust 🦀, Kotlin, and Jetpack Compose

For questions or issues, please open a GitHub issue.

🚀 Quick Start Summary

# 1. Install Rust and Android targets
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustup target add aarch64-linux-android armv7-linux-androideabi x86_64-linux-android i686-linux-android

# 2. Build Rust libraries
./build-rust.sh

# 3. Build and run Android app
./gradlew installDebug

# 4. Enjoy blazing-fast technical indicators! 🔥