«Escribirlo en Rust» no convierte automáticamente un algoritmo de Flutter en un algoritmo más rápido. El código nativo puede ayudar cuando existe una librería consolidada, acceso específico a un SDK o una carga de cálculo que justifica la frontera. También introduce nuevos problemas: ownership de buffers, tipos de ABI, compilación por arquitectura, callbacks en el hilo correcto, crash nativo y una segunda cadena de herramientas.
La decisión de ingeniería no es Dart contra Rust. Es qué responsabilidad corresponde a cada runtime y cuánto cuesta atravesar la frontera. Este artículo utiliza Flutter 3.50 / Dart 3.14 y Rust 1.100 como baseline documental, sin presuponer que un proyecto ya está migrado a esas versiones. La documentación de interop de Flutter distingue enlaces directos generados por FFIgen/JNIgen y contratos multiplataforma generados por Pigeon. Los ejemplos son diseños y fragmentos revisables; no hay benchmark ejecutado ni cifras de rendimiento medidas.
El problema adecuado para cada herramienta
Pensemos en una app que procesa imágenes para un editor: la UI modifica parámetros, un filtro transforma millones de bytes y una API de plataforma guarda el archivo final. Hay al menos tres operaciones distintas:
- Estado de interfaz y reglas de producto. Encajan en Dart y en la arquitectura de estado de Flutter; no requieren un puente nativo.
- Transformación CPU-bound. Puede implementarse en Dart en un isolate, en C/C++ o en Rust; hay que medir antes de decidir.
- Acceso a un servicio del sistema. Puede requerir Android/iOS y un plugin de plataforma; no implica que ese SDK tenga que reescribirse en Rust.
Antes de incorporar código nativo, consideraría Uint8List, ByteData, APIs SIMD o bibliotecas existentes y un isolate para evitar bloquear el main isolate. Si el algoritmo de Dart cumple latencia, memoria y mantenibilidad, introducir FFI es complejidad sin una justificación demostrada.
Cuatro familias de interop que no son equivalentes
| Enfoque | Qué comunica | Mejor ajuste | Coste principal |
|---|---|---|---|
| Dart puro | Funciones/clases y mensajes entre isolates | Lógica multiplataforma y algoritmos suficientes en Dart | CPU, GC, copias entre isolates según datos y API |
| Platform Channels | Mensajes Dart ↔ implementación de host | API de plataforma existente, eventos y operaciones de grano grueso | Serialización y contrato de mensajes, threading/plataforma |
| Pigeon | Contratos tipados sobre comunicación de plataforma | Plugins de API multiplataforma que buscan evitar strings ad hoc | Generación, versionado de contrato y manejo de errores |
dart:ffi / FFIgen | Símbolos C ABI / bindings directos | Bibliotecas C, C++ con wrapper C, Rust con interfaz C | Punteros, memoria, lifecycle, build y ABI |
| JNIgen | Clases Java/Kotlin expuestas mediante JNI | Bibliotecas Android que exigen bindings Java directos | Referencias JNI, threads, permisos, lifecycle Android |
Flutter distingue el flujo bottom-up de FFIgen/JNIgen —partir de headers o clases existentes— del flujo top-down de Pigeon —diseñar primero un contrato neutral—. Pigeon usa Platform Channels en su modalidad estable documentada, mientras su modalidad de interop nativo directo figura explícitamente como preview. No se debe confundir «interop directo estable en Flutter 3.50» con «Pigeon native interop ya estable». Véase Pigeon.
Para C y Objective-C, el camino respaldado es FFIgen; para Java/Kotlin, JNIgen. Ninguno convierte por sí solo un API diseñado para el hilo de UI en una función segura de llamar desde un worker, ni resuelve automáticamente cómo liberar memoria compartida.
Una arquitectura de plugin con fronteras observables
Propondría separar tres niveles en una librería de procesamiento:
Flutter widgets / estado / gestos
│
├─ API idiomática de Dart (validación, errores, cancelación)
│ │
│ ├─ algoritmo Dart puro o isolate
│ ├─ plugin Platform Channel / Pigeon → API de sistema
│ └─ binding FFIgen → C ABI → biblioteca Rust/C++
│
└─ presentación del resultado + medición de frame timings
La capa de dominio debería recibir y devolver tipos concretos y manejar fallos sin conocer detalles de Pointer, JNIEnv o buffers ajenos. El plugin nativo debe declarar arquitectura/OS soportado, versión de ABI, mecanismos de carga y contrato de cancelación. Una interfaz uniforme permite comparar implementaciones sin cambiar simultáneamente la UI.
Desde Flutter 3.38, la guía oficial de FFI recomienda el template package_ffi con build hooks y native assets para nuevas integraciones. No significa que todos los plugins históricos necesiten migrar de inmediato: hay plugins existentes con configuración de Gradle, CocoaPods, CMake o binarios precompilados y requisitos específicos.
Ejemplo mínimo: un límite C ABI compartido por C++ y Rust
Supongamos una función que suma un buffer de bytes y devuelve un uint64_t. Este ejemplo sirve para explicar ownership, no para ganar un benchmark: el kernel es demasiado simple para justificar una librería nativa en una aplicación real.
/* include/checksum.h: firma pública estable para código nativo. */
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/* data debe apuntar a len bytes válidos durante la llamada.
len == 0 devuelve 0 sin leer el puntero. */
uint64_t checksum_bytes(const uint8_t *data, size_t len);
#ifdef __cplusplus
}
#endif
Una implementación en C++ puede conservar internamente clases, templates y optimizaciones, pero debe exponer una función extern "C": FFIgen no interpreta directamente el ABI de una clase C++ ni garantiza su layout o name mangling.
#include "checksum.h"
extern "C" uint64_t checksum_bytes(const uint8_t* data, size_t len) {
if (len == 0) return 0;
if (data == nullptr) return 0; // Error debe tratarse en el contrato real.
uint64_t sum = 0;
for (size_t i = 0; i < len; ++i) sum += data[i];
return sum;
}
Para Rust 2024, el equivalente exige una frontera de unsafe explícita y una política de error más rica en producción. Se asume que, salvo longitud cero, el puntero cumple las precondiciones documentadas:
use std::ffi::c_uchar;
/// # Safety
/// Si `len > 0`, `data` debe apuntar a `len` bytes válidos,
/// contiguos, inicializados y accesibles durante toda la llamada.
/// No debe existir una escritura concurrente incompatible.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn checksum_bytes(data: *const c_uchar, len: usize) -> u64 {
if len == 0 || data.is_null() {
return 0;
}
// SAFETY: lo garantiza el llamador mediante el contrato anterior.
let bytes = unsafe { std::slice::from_raw_parts(data, len) };
bytes.iter().map(|&byte| u64::from(byte)).sum()
}
No puede compilarse ambas implementaciones con el mismo símbolo dentro de una sola librería; son alternativas para builds comparables. En producción, el API debería distinguir NULL inválido de un resultado legítimo 0, definir límites de longitud y gestionar errores sin lanzar excepciones C++ o hacer panics que crucen sin control la ABI. Rust reduce ciertos fallos de memoria dentro de su código seguro, no vuelve segura una frontera FFI arbitraria. La Rustonomicon explica los requisitos de ABI, punteros y unwind.
¿Y el lado Dart?
El binding debe preservar tipos ABI (size_t, entero sin signo de 64 bits y uint8_t*) y comprobar que el buffer sigue vivo durante la llamada. Generar el binding con FFIgen a partir del header evita parte de la traducción manual, pero no comprueba la validez temporal de una dirección ni la inmutabilidad de memoria compartida. Un Uint8List ordinario no debe tratarse como un puntero C estable sin un mecanismo de interop que garantice sus condiciones; normalmente hay que crear o adquirir almacenamiento nativo, transferir bytes y liberarlo con su política correcta.
No se muestra una «solución» ficticia de malloc/free sin especificar qué runtime asignó el buffer: una regla esencial de FFI es que quien reserva memoria define cómo se libera, salvo un contrato explícito que indique otra cosa. La documentación de Dart FFI y la de NativeFinalizer permiten establecer el lifetime correcto. Los finalizers son un mecanismo de limpieza de último recurso y no sustituyen un dispose determinista cuando la API lo requiere.
Isolates, event loop y afinidad de hilos
Mover el cálculo a Rust no evita jank si Dart lo invoca sincrónicamente desde el main isolate y tarda decenas de milisegundos. Una función FFI sincrónica consume tiempo en el hilo que la llama. Tampoco basta con «usar Isolate.run» para cualquier biblioteca: deben revisarse afinidad de hilos de sus APIs nativas, inicialización de recursos, ownership y cómo llegan los resultados de vuelta.
Flutter distingue isolate principal, event loop y workers. En Android, muchas APIs exigen el hilo principal del host; en iOS, partes de UIKit también. Pigeon define contratos, pero no anula las reglas de ejecución de un SDK. Si el callback nativo llega de un hilo ajeno, las APIs de NativeCallable tienen modalidades y restricciones que deben leerse antes de capturar funciones Dart.
Una decisión correcta separa: thread que ejecuta el kernel, thread que maneja el mensaje, isolate que posee el estado y thread que permite la API del sistema. Son cuatro conceptos distintos aunque a veces coincidan físicamente.
¿Dónde encaja flutter_rust_bridge?
flutter_rust_bridge proporciona generación de bindings y patrones convenientes para APIs de Rust desde Flutter. Reduce boilerplate, pero añade su propia capa de codegen, tooling, versiones y ciclo de soporte. A la fecha de consulta del dossier, la release observada era v2.14.0-beta.2; no conviene elevar una beta a recomendación universal de producción sin probar toolchain, plataforma y modelo de errores.
Es una opción razonable cuando el equipo quiere exponer modelos y operaciones Rust más expresivos, pero no reemplaza el diseño de ownership, la validación de ABI, el control del thread correcto ni el test de empaquetado por plataforma. Para un API C muy pequeño, FFIgen + C ABI puede ser suficiente; para un SDK Android existente, JNIgen o un plugin pueden representar mejor la integración.
Cómo decidir si nativo vale la pena
La comparación debe considerar como mínimo cinco dimensiones:
| Dimensión | Pregunta medible |
|---|---|
| Correctness | ¿Los outputs coinciden byte a byte con una implementación de referencia en entradas, límites y errores? |
| Latencia | ¿Cuánto tardan p50/p95/p99 del kernel, del wrapper, del llamado FFI y del flujo UI completo? |
| Throughput | ¿Cuántos buffers procesamos por segundo con una concurrencia definida, sin desbordar memoria? |
| Memoria | ¿Cuánto se copia, reserva y retiene en Dart y en el heap nativo? |
| Integración | ¿Cuántas arquitecturas y plataformas compilan, se prueban y se mantienen con la misma semántica? |
No hay un ganador universal. Un algoritmo que pasa 1.000 veces por FFI con buffers minúsculos puede pagar más en preparación y copias que el kernel que quería acelerar. Otro que procesa un buffer grande en una sola operación puede amortizar ese coste. Un C++ rápido en un benchmark de CPU puede seguir ser peor elección si el build o el soporte multiplataforma consume más tiempo de ingeniería del que ahorra.
Protocolo de benchmark propuesto: Dart, Rust y C++
Estado: NO EJECUTADO. El objetivo sería comparar exactamente una transformación de bytes con tres kernels equivalentes, sin introducir optimizaciones distintas durante la primera medición.
- Corpus sintético con seed. Buffers de 1 KiB, 64 KiB, 1 MiB y 16 MiB, además de vacíos y longitudes no alineadas; registrar hash de entrada y output esperado.
- Correctness primero. Golden tests y property tests: límites, endianess, overflow, offsets, memoria vacía, entrada inválida y round-trip de llamadas.
- Versiones y entorno. Flutter/Dart, compilador Rust/C++, flags de optimización, AOT, NDK o Xcode, arquitectura, CPU, temperatura, OS y dispositivo físico. No extrapolar un simulador a un teléfono.
- Medición por capas.
T_total = T_prepare + T_boundary + T_kernel + T_return + T_dispose; comparar kernel nativo por separado del coste Dart de empaquetado. La fórmula define qué observar, no asume que los términos sean siempre medibles de forma independiente. - Warm-up y ruido. Repeticiones, políticas de caché, orden aleatorio de variantes, thermal throttling, frecuencia de CPU y variabilidad. Reportar distribuciones, no solo una media.
- UI real. Perfilar frame timings en modo profile sobre dispositivo apropiado; observar cuántos frames pierden presupuesto y si un isolate libera la UI. Evitar usar tiempos de debug como resultados de release.
- Ergonomía operativa. Registrar fallas de build, tamaño de artefactos, complejidad de CI, número de plataformas y carga de revisión de código.
Flutter DevTools Performance permite estudiar frames y timeline; no identifica automáticamente qué parte de una llamada FFI es lenta. Para memory bugs nativos, los sanitizers y herramientas deben seleccionarse por plataforma. La documentación reciente de Android NDK recomienda HWASan en dispositivos compatibles; no se debe prometer que AddressSanitizer clásico sea la opción soportada para cualquier Android actual.
Lifecycle y fallos de frontera
Una capa nativa agrega tipos de fallo que Dart no puede capturar como excepciones ordinarias. Un acceso inválido puede terminar el proceso. Los casos que deberían entrar en CI incluyen:
- Punteros nulos y longitudes extremas rechazados antes de entrar en funciones que esperan memoria válida.
- Callbacks que llegan desde threads diferentes y se entregan con el mecanismo correcto; cierre del recurso antes/después del callback.
- Cancelación de operaciones largas sin liberar memoria mientras un worker sigue leyéndola.
- Empaquetado y carga de librería en Android ARM64, iOS arm64 y demás targets realmente soportados, sin asumir que un build local equivale a todos.
- Panics, exceptions y errores nativos convertidos a un resultado estable; nunca presentar el crash como una excepción Dart recuperable.
- Pruebas de Unicode y de tipos/estructuras si el contrato expone algo más que buffers binarios simples.
El tamaño del bundle y la superficie de actualización cuentan en la decisión. Una dependencia nativa puede quedar anclada a un NDK, un SDK o una ABI que evoluciona; fijar versiones y probar el artefacto final tiene un coste real.
Integración con el resto del blog
En el artículo sobre entornos reproducibles se estudia qué resuelven los toolchains declarados. Para Flutter nativo esa preocupación se vuelve concreta: una compilación en CI requiere conocer el SDK de Flutter, la versión de Dart, Rust/C++, el compilador y el ABI de cada target. Las variables no versionadas hacen que «en mi máquina compila» sea una propiedad débil.
Y si el componente nativo se conecta con hardware —por ejemplo, una impresora de punto de venta— la frontera se vuelve más amplia: ya no solo importan CPU, memoria o JNI, sino transporte, firmware, códigos de página, estados físicos y reintentos. Ese problema se trata en ESC/POS: tickets térmicos fiables.
Conclusión
La interoperabilidad nativa bien diseñada empieza por una pregunta de dominio y un contrato verificable, no por la preferencia de lenguaje. Dart sigue siendo una alternativa seria para numerosos kernels; un isolate puede resolver el bloqueo de UI sin FFI; Pigeon y Platform Channels son adecuados para APIs de host; JNIgen y FFIgen acercan bibliotecas existentes con otras garantías y riesgos. Rust y C++ proporcionan herramientas potentes cuando su coste de integración está justificado.
Sin pruebas equivalentes de correctness, latencia, memoria y comportamiento de frames, hablar de «Rust 3× más rápido» sería publicidad, no ingeniería.
Referencias primarias
- Flutter: Native interop, bind native code y Pigeon.
- Flutter: FFIgen, JNIgen, isolates y Performance DevTools.
- Dart: FFI, NativeCallable y NativeFinalizer.
- Rustonomicon: FFI; flutter_rust_bridge.