본문으로 건너뛰기
effidevFlutter · Cloudflare 엣지 · 클라우드 비용 최적화

Flutter Rust Bridge v2: Rust 연동과 성능 검증 가이드

수정일

Flutter Rust Bridge v2 performance architecture diagram

핵심 요약

flutter_rust_bridge v2로 Dart·Rust 바인딩과 비동기·스트림 연동을 구성하는 방법. 데이터 복사와 호출 비용을 구분하고 앱에서 성능을 검증할 조건을 정리했다.

모바일 앱이 성능의 벽에 부딪힐 때

Flutter는 크로스 플랫폼 프레임워크 중 단연 뛰어난 렌더링 성능을 자랑한다. 하지만 대용량 이미지/비디오 처리, 온디바이스 AI 인퍼런스, 고성능 암호화 연산, 혹은 복잡한 바이너리 파싱을 Dart 단독으로 수행하려고 하면 금세 프레임 드랍과 메모리 고갈을 경험하게 된다.

전통적으로 Flutter 개발자들은 이러한 한계를 극복하기 위해 두 가지 길을 선택했다.

  1. MethodChannel (Platform Channel): 네이티브 Swift/Kotlin 코드를 호출하지만, 이진 직렬화/비직렬화 오버헤드로 인해 대용량 데이터 전송 시 병목이 발생한다.
  2. C/C++ FFI (Foreign Function Interface): 얇은 오버헤드로 높은 성능을 제공하지만, C/C++ 특유의 메모리 누수, 댕글링 포인터, 버퍼 오버플로우 위험에 상시 노출된다.

flutter_rust_bridge (FRB) v2는 이 두 가지 방식의 단점을 완전히 극복한 최신 해결책이다. Rust의 **메모리 안전성(Memory Safety)**과 Zero-Cost Abstraction을 활용하면서, Dart FFI 기반으로 직렬화 비용이 거의 없는 Zero-Copy 데이터 전송을 구현한다.

이 글에서는 FRB v2의 아키텍처 원리부터, C FFI 및 MethodChannel과의 성능 비교, 멀티플랫폼 프로젝트 설정, 비동기 스트리밍 및 Zero-Copy 메모리 공유 구현 방법까지 실전 코드로 상세히 다룬다.

MethodChannel vs C FFI vs flutter_rust_bridge v2 비교

세 가지 방식의 성능과 DX(개발자 경험) 차이를 명확히 비교해보자.

비교 항목 MethodChannel 전통적 C FFI flutter_rust_bridge v2
통신 메커니즘 Platform Channel (BinaryCodec) Dart FFI (Direct C pointer) Dart FFI + Auto Binding
데이터 전달 비용 코덱·데이터 크기에 따라 달라짐 포인터·버퍼 수명 관리 필요 타입·코덱·전달 방향에 따라 달라짐
메모리 관리 양쪽 런타임과 플러그인 구현 확인 할당·해제 소유권 확인 Rust 코드와 FFI 경계의 소유권 확인
비동기 처리 (Async) 지원 (Future) 수동 (Thread isolation 관리 필요) 자연스러운 async/await 및 Stream 연동
바인딩 코드 생성 수동 작성 ffigen 기반 자동/수동 flutter_rust_bridge_codegen 완전 자동화
대용량 데이터 전송 불리 (복사 2~3회 발생) 보통 (C 포인터 넘기기) 극도로 우수 (Pointer Zero-Copy)

대용량 데이터를 다룰 때는 연산 시간과 플랫폼 사이의 데이터 전달 비용을 따로 측정해야 한다. MethodChannel도 비동기로 호출할 수 있고, FRB를 쓴다고 UI 프레임 드롭이 자동으로 없어지지는 않는다.

FRB v2 내부 동작 원리: Zero-Copy 파이프라인

FRB v2가 뛰어난 성능을 내는 핵심 메커니즘은 Dart FFI와 Rust의 Vec<u8> 및 Uint8List 간의 메모리 레이아웃 호환성이다.

+------------------+                    +------------------+
|    Dart VM       |                    |   Rust Runtime   |
|                  |                    |                  |
|  [Uint8List]     |  --- Direct FFI -> |  [Slice &[u8]]   |
|  Pointer Address |  (No Serialization)|  Shared Buffer   |
+------------------+                    +------------------+
         |                                       |
         +----------------- Shared Memory -------+
  1. Rust 영역: Rust가 계산한 결과 데이터(Vec<u8>)를 C 호환 포인터로 노출한다.
  2. Dart FFI 영역: Dart는 메모리를 새로 복사(Copy)하지 않고, 해당 포인터를 직접 가리키는 Uint8List.view를 생성한다.
  3. 자동 메모리 해제: Dart의 Finalizer 또는 Rust의 Drop 트레이트와 연동되어 데이터 사용이 끝나면 메모리가 자동으로 해제된다.

위 그림은 복사를 줄이는 전달 방식의 개념도다. 모든 타입과 호출이 같은 경로를 쓰는 것은 아니며, 실제 복사·직렬화·할당 여부는 생성된 바인딩과 코덱을 확인해야 한다.

1단계: 개발 환경 설정 및 프로젝트 구조

FRB v2는 CLI 도구를 통해 바인딩 생성을 완전 자동화한다.

필수 도구 설치

# 1. Rust 설치 (이미 설치되어 있다면 업데이트)
rustup update

# 2. flutter_rust_bridge_codegen CLI 설치
cargo install 'flutter_rust_bridge_codegen@^2.0.0'

# 3. C/C++ 툴체인 및 LLVM 확인 (iOS/Android 크로스컴파일용)
# macOS 사용자의 경우 Xcode Command Line Tools 필요
xcode-select --install

새 프로젝트 생성 또는 기존 프로젝트 적용

기존 Flutter 프로젝트 루트 경로에서 다음 명령어를 실행하면 필요한 Rust 템플릿 파일이 자동으로 생성된다.

cd my_flutter_app

# flutter_rust_bridge 통합 명령어 실행
flutter_rust_bridge_codegen integrate

명령어가 완료되면 프로젝트 루트에 rust/ 디렉터리가 생성되고 pubspec.yaml 및 Cargo.toml 파일이 자동으로 업데이트된다.

my_flutter_app/
├── lib/
│   ├── src/
│   │   └── rust/               # 자동 생성되는 Dart 바인딩 코드
│   │       ├── api/
│   │       └── frb_generated.dart
│   └── main.dart
├── rust/                       # Rust 소스 코드 디렉터리
│   ├── Cargo.toml
│   └── src/
│       ├── api/
│       │   └── simple.rs      # 비즈니스 로직 작성 파일
│       └── frb_generated.rs    # 자동 생성되는 Rust 매개체 코드
└── pubspec.yaml

2단계: Rust 비즈니스 로직 작성 (v2 신규 구문)

FRB v2의 가장 큰 매력은 Rust 코드를 작성할 때 별도의 FFI 보일러플레이트를 작성할 필요가 없다는 점이다. 일반적인 Rust 함수나 struct를 작성하고 pub 키워드만 붙이면 Dart에서 그대로 클래스 및 함수로 인식된다.

rust/src/api/simple.rs 파일에 고성능 데이터 처리 모듈을 구현해보자.

// rust/src/api/simple.rs

use flutter_rust_bridge::frb;

// 1. 단순 동기 함수
#[frb(sync)] // sync 어노테이션 추가 시 Dart에서 Future 없이 즉시 반환
pub fn greet(name: String) -> String {
    format!("Hello, {name}! Powered by Rust v2.")
}

// 2. 비동기 블로킹 연산 (이미지 필터링 / 암호화 등)
pub async fn compute_heavy_hash(data: Vec<u8>) -> String {
    // Rust 백그라운드 스레드풀에서 무거운 연산 수행
    use sha2::{Sha256, Digest};
    let mut hasher = Sha256::new();
    hasher.update(&data);
    let result = hasher.finalize();
    format!("{:x}", result)
}

// 3. Complex Struct & Method 바인딩
pub struct ImageProcessor {
    pub width: u32,
    pub height: u32,
    pixels: Vec<u8>,
}

impl ImageProcessor {
    // 생성자
    pub fn new(width: u32, height: u32) -> Self {
        let size = (width * height * 4) as usize;
        Self {
            width,
            height,
            pixels: vec![0; size],
        }
    }

    // Zero-Copy 이미지 그레이스케일 변환 메서드
    pub fn apply_grayscale(&mut self) {
        for chunk in self.pixels.chunks_mut(4) {
            let r = chunk[0] as u32;
            let g = chunk[1] as u32;
            let b = chunk[2] as u32;
            let gray = ((r * 30 + g * 59 + b * 11) / 100) as u8;
            chunk[0] = gray;
            chunk[1] = gray;
            chunk[2] = gray;
        }
    }

    // 처리된 raw 픽셀 반환
    pub fn get_pixels(&self) -> Vec<u8> {
        this.pixels.clone()
    }
}

3단계: 코드 생성기 실행 및 Dart 연동

Rust 코드를 수정했다면 codegen을 실행하여 Dart 인터페이스 코드를 최신화한다.

# 코드 생성기 실행
flutter_rust_bridge_codegen generate

이제 Flutter 앱(lib/main.dart)에서 초기화 후 즉시 Rust 함수를 호출할 수 있다.

// lib/main.dart
import 'package:flutter/material.dart';
import 'package:my_flutter_app/src/rust/api/simple.dart';
import 'package:my_flutter_app/src/rust/frb_generated.dart';

Future<void> main() async {
  // 1. Rust 런타임 및 FFI 바인딩 초기화 (앱 시작 시 1회 호출)
  await RustLib.init();
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: const Text('Flutter + Rust FRB v2')),
        body: const BenchmarkScreen(),
      ),
    );
  }
}

class BenchmarkScreen extends StatefulWidget {
  const BenchmarkScreen({super.key});

  @override
  State<BenchmarkScreen> createState() => _BenchmarkScreenState();
}

class _BenchmarkScreenState extends State<BenchmarkScreen> {
  String _status = '대기 중';
  String _hashResult = '';
  double _executionTimeMs = 0;

  Future<void> _runBenchmark() async {
    setState(() {
      _status = '연산 진행 중...';
    });

    // 10MB 테스트 바이너리 데이터 생성
    final dummyData = List<int>.generate(10 * 1024 * 1024, (i) => i % 256);

    final stopwatch = Stopwatch()..start();

    // Rust 비동기 함수 호출 (Dart의 Event Loop를 전혀 블로킹하지 않음)
    final hash = await computeHeavyHash(data: Uint8List.fromList(dummyData));

    stopwatch.stop();

    setState(() {
      _status = '연산 완료!';
      _hashResult = hash;
      _executionTimeMs = stopwatch.elapsedMicroseconds / 1000.0;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: const EdgeInsets.all(16.0),
      child: Column(
        crossAxisAlignment: CrossAlignment.start,
        children: [
          Text('상태: $_status', style: Theme.of(context).textTheme.titleMedium),
          const SizedBox(height: 12),
          ElevatedButton(
            onPressed: _runBenchmark,
            child: const Text('10MB 데이터 SHA-256 연산 실행'),
          ),
          const SizedBox(height: 16),
          Text('소요 시간: ${_executionTimeMs.toStringAsFixed(2)} ms'),
          const SizedBox(height: 8),
          SelectableText('해시 결과: $_hashResult'),
        ],
      ),
    );
  }
}

4단계: 실시간 데이터 스트리밍 (Rust Stream -> Dart Stream)

FRB v2는 Rust의 센서 데이터 수집, 웹소켓 수신, 지속적 연산 결과를 Dart Stream으로 전달하는 강력한 Stream 바인딩을 제공한다.

Rust 측 Stream 송신기 구현

// rust/src/api/stream_example.rs

use flutter_rust_bridge::frb;
use crate::frb_generated::StreamSink;
use std::thread;
use std::time::Duration;

pub struct SensorData {
    pub timestamp: i64,
    pub value: f64,
}

// StreamSink를 인자로 받으면 자동으로 Dart Stream으로 변환됨
pub fn start_sensor_stream(sink: StreamSink<SensorData>) {
    thread::spawn(move || {
        let mut count = 0;
        loop {
            thread::sleep(Duration::from_millis(100)); // 10Hz 데이터 수집
            count += 1;
            
            let data = SensorData {
                timestamp: chrono::Utc::now().timestamp_millis(),
                value: (count as f64 * 0.1).sin(),
            };

            // Dart로 실시간 스트림 데이터 전송
            if sink.add(data).is_err() {
                // Dart 구독자가 cancel() 호출 시 에러가 발생하여 루프 종료
                break;
            }
        }
    });
}

Dart 측 Stream 구독 구현

// lib/sensor_widget.dart
import 'dart:async';
import 'package:flutter/material.dart';
import 'package:my_flutter_app/src/rust/api/stream_example.dart';

class SensorWidget extends StatefulWidget {
  const SensorWidget({super.key});

  @override
  State<SensorWidget> createState() => _SensorWidgetState();
}

class _SensorWidgetState extends State<SensorWidget> {
  StreamSubscription<SensorData>? _subscription;
  double _currentValue = 0.0;

  @override
  void initState() {
    super.initState();
    // Rust에서 생성된 Stream 구독 시작
    _subscription = startSensorStream().listen((data) {
      setState(() {
        _currentValue = data.value;
      });
    });
  }

  @override
  void dispose() {
    // 위젯 파괴 시 Rust 측 백그라운드 루프도 자동 정지됨
    _subscription?.cancel();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Card(
      child: Padding(
        padding: const EdgeInsets.all(16.0),
        child: Column(
          children: [
            const Text('Rust 센서 실시간 스트리밍 (10Hz)'),
            Text(
              _currentValue.toStringAsFixed(4),
              style: Theme.of(context).textTheme.headlineMedium,
            ),
          ],
        ),
      ),
    );
  }
}

5단계: 멀티플랫폼 빌드 파이프라인 (Android, iOS, Desktop)

Rust 코드를 타겟 OS 바이너리로 교차 컴파일(Cross-compilation)하는 설정이다.

Android 빌드 설정 (cargo-ndk)

Android 타겟을 빌드하기 위해 cargo-ndk 플러그인을 활용한다.

# Android target 추가
rustup target add aarch64-linux-android armv7-linux-androideabi x86_64-linux-android i686-linux-android

# cargo-ndk 설치
cargo install cargo-ndk

android/app/build.gradle에 cargo 빌드 작업이 자동 연동되어 flutter run -d android 실행 시 자동으로 Rust 코드가 .so 동적 라이브러리로 컴파일되어 팩킹된다.

iOS 빌드 설정 (XCode Framework)

iOS 환경에서는 Rust 코드가 유니버설 정적 라이브러리(.a) 또는 XCFramework로 빌드되어 Xcode 프로젝트에 연결된다.

# iOS target 추가
rustup target add aarch64-apple-ios aarch64-apple-ios-sim x86_64-apple-ios

flutter_rust_bridge_codegen integrate가 생성한 ios/Runner.xcodeproj 빌드 스크립트에 의해 flutter build ios 명령만으로 Xcode 내부 빌드 단계와 Rust 컴파일이 동기화된다.

성능은 호출 비용과 연산 비용을 나눠 검증한다

기존 글의 100MB 암호화 성능표에는 측정 코드·의존성 버전·반복 횟수·원시 결과가 남아 있지 않다. 따라서 42ms나 C FFI 대비 10배라는 수치를 재현 가능한 실측으로 제시하지 않는다. FRB 자체도 Dart FFI를 사용하므로 서로 다른 암호화 구현의 시간을 곧바로 브리지 성능 차이라고 볼 수 없다.

공식 성능 안내는 CI에서 측정한 대시보드와 원시 시각화를 제공하며, 그 결과도 대략적인 참고 자료로 설명한다. 내 앱에서는 다음 조건을 맞춰 비교한다.

  1. Flutter·Dart·Rust·FRB 버전과 빌드 모드, 기기를 기록한다.
  2. 같은 알고리즘·입력·출력을 써서 빈 호출 비용, 데이터 전달 비용, Rust 연산 시간을 각각 잰다.
  3. 준비 실행 후 여러 번 반복하고 중앙값과 분산을 남긴다.
  4. UI 프레임 시간과 메모리 사용량도 함께 기록해 사용자가 체감하는 차이를 확인한다.

결론 및 생산성 체크리스트

flutter_rust_bridge v2는 Dart와 Rust를 연결하는 바인딩 작업을 줄이는 도구다. 성능 개선 폭은 옮기는 연산과 데이터 전달 방식에 따라 달라진다.

주요 이점 요약:

  • Zero-Copy 메모리 아키텍처: 데이터 전송 오버헤드가 극도로 낮다.
  • 개발 생산성: codegen이 Dart와 Rust 사이의 복잡한 FFI 보일러플레이트를 100% 자동 생성한다.
  • 소유권 관리: Rust의 타입과 소유권 체계를 활용하되, unsafe 코드와 외부 라이브러리의 FFI 경계는 따로 점검한다.

적용 권장 시나리오:

  1. 대용량 미디어(이미지, 아두이노/BLE 바이너리, 음성) 실시간 필터링 및 파싱
  2. 온디바이스 암호화/복호화 및 지갑(Wallet) 보안 연산
  3. SQLite/RocksDB 기반 대용량 임베디드 데이터베이스 직접 제어
  4. 온디바이스 AI/ML 파이프라인 (llama.cpp, ONNX 런타임 Rust 래핑)

모바일 앱의 유연한 UI 표현력과 Rust의 타협 없는 런타임 성능을 조합하여 최고 수준의 멀티플랫폼 애플리케이션을 구축해보자.

관련 글: Flutter Impeller 엔진과 Vulkan/Metal 렌더링 최적화에서 그래픽스 파이프라인 최적화 가이드도 함께 확인할 수 있다.

참고 자료