Empezar

Inferencia de Ultralytics para Rust

Ultralytics Inference GitHub Ultralytics Inference Crates.io Ultralytics Inference docs.rs Ultralytics Inference Downloads Ultralytics Inference MSRV

Ultralytics Inference es una biblioteca de inferencia YOLO de alto rendimiento y una herramienta de línea de comandos escrita en Rust. Ejecuta modelos ONNX exportados mediante ONNX Runtime para generar predicciones rápidas y seguras en cuanto a la memoria en imágenes, vídeos, cámaras web y flujos, sin necesidad de ejecutar Python durante la inferencia.

El proyecto se distribuye como un único crate, ultralytics-inference, que puedes usar de dos maneras: como CLI para predicciones rápidas y trabajos por lotes, o como biblioteca integrada directamente en tu aplicación Rust. Admite todas las tareas de Ultralytics y una amplia variedad de backends de hardware mediante una interfaz de dispositivo uniforme. Para la inferencia en navegador, el mismo repositorio publica el paquete npm @ultralytics/yolo; consulta su guía de configuración.

¿Por qué usar Rust para la inferencia?#

  • Rendimiento nativo y tamaño reducido. Se compila en un binario nativo sin intérprete, ideal para servidores, contenedores y dispositivos periféricos.
  • Seguridad de memoria. El modelo de propiedad de Rust elimina categorías enteras de errores en tiempo de ejecución sin necesidad de un recolector de basura.
  • Todas las tareas de YOLO. Detecta, segmenta, realiza segmentación semántica y estimación de profundidad, clasifica, estima la pose y detecta OBB desde una sola API, además de ofrecer OCR de texto en escenas e inferencia por teselas para imágenes grandes.
  • Amplia compatibilidad con hardware. CPU, además de proveedores de ejecución CUDA, TensorRT, CoreML, OpenVINO, DirectML, ROCm, MIGraphX y XNNPACK seleccionados en el momento de la compilación, y modelos IR nativos de OpenVINO.
  • Preprocesamiento en la GPU. Un kernel CUDA fusionado opcional ejecuta letterbox, normalización y conversión del formato de datos en la GPU, y pasa el resultado al modelo sin sacarlo del dispositivo.
  • Descarga automática. Los nombres conocidos de modelos YOLO, los modelos OCR y los recursos de ejemplo se descargan automáticamente la primera vez que se usan.
  • El mismo resultado que en Python. Las máscaras, los contornos de las máscaras y los resultados dibujados siguen el paquete de Python de Ultralytics, por lo que --save genera la misma imagen que plot().
¿Buscas el paquete de Python?

Esta página describe el crate independiente de Rust. Para el flujo de trabajo de Python (entrenamiento, validación, exportación y predicción), consulta la guía de inicio rápido principal y el modo de predicción. Exporta cualquier modelo de Ultralytics a ONNX con la integración de ONNX y ejecútalo aquí.

Instalación#

Se requiere Rust 1.92 o posterior. La función de vídeo también requiere que FFmpeg 6 a 9 esté instalado en el sistema.

# Install the command-line tool from crates.io
cargo install ultralytics-inference

# Or with GPU support compiled in
cargo install ultralytics-inference --features cuda,tensorrt

El binario se coloca en ~/.cargo/bin/ultralytics-inference (Linux y macOS) o en %USERPROFILE%\.cargo\bin\ en Windows.

Inicio rápido de la CLI#

La CLI ofrece un subcomando predict. Si no se indican argumentos, descarga un modelo de detección nano y unas imágenes de ejemplo, ejecuta la inferencia y guarda los resultados anotados en runs/detect/predict.

# Detect on the built-in samples (downloads model and images)
ultralytics-inference predict

# Detect on your own image
ultralytics-inference predict --model yolo26n.onnx --source image.jpg

# Segmentation (auto-downloads yolo26n-seg.onnx)
ultralytics-inference predict --task segment --source image.jpg

# Pose on a video, shown live in a window
ultralytics-inference predict --task pose --source video.mp4 --show

# Depth estimation (auto-downloads yolo26n-depth.onnx)
ultralytics-inference predict --task depth --source image.jpg

# Tune thresholds and filter to specific classes
ultralytics-inference predict --source image.jpg --conf 0.5 --iou 0.45 --classes "0,1,2"

# Run a whole folder on the GPU in half precision
ultralytics-inference predict --source images/ --device cuda:0 --quantize 16

# Tile a large aerial image into overlapping 640 px windows to find small objects
ultralytics-inference predict --model yolo26n-obb.onnx --source aerial.jpg --tile 640

# Read scene text (auto-downloads yolo26n-text.onnx and the PaddleOCR models)
ultralytics-inference predict --ocr --source sign.jpg

# Thicker lines, no confidences in labels
ultralytics-inference predict --source image.jpg --line-width 4 --show-conf false

Todas las opciones de predict:

IndicadorPredeterminadoDescripción
--model, -myolo26n.onnxRuta a un modelo ONNX o una exportación de OpenVINO; los nombres conocidos de YOLO se descargan automáticamente.
--taskdetectUno de detect, segment, semantic, depth, classify, pose, obb; selecciona el modelo nano si se omite --model.
--source, -smuestraImagen, directorio, patrón glob, vídeo, índice de cámara web, flujo o URL.
--conf0.25Umbral de confianza.
--iou0.5Umbral de IoU para la supresión no máxima.
--max-det300Número máximo de detecciones por imagen.
--imgszmetadatos del modeloTamaño de imagen para la inferencia.
--rect [<BOOL>]trueInferencia rectangular con relleno mínimo.
--tile [<TILE>]desactivadoTamaño de las teselas para la inferencia con ventanas solapadas; si se indica --tile sin valor, se usa --imgsz. Consulta la inferencia por teselas.
--retina-masksfalseGenera las máscaras de segmentación al tamaño original de la imagen, en vez de al tamaño de inferencia.
--ocrfalseLee el texto de cada cuadro, cuadro orientado o máscara con PaddleOCR; si no se especifica --model, se ejecuta yolo26n-text.onnx. Consulta el OCR.
--batch1Tamaño del lote para la inferencia.
--quantizeprecisión del modeloPrecisión de inferencia: 8, 16, 32, int8, fp16, fp32, w8a8, w16a16, w32a32, w8a16 o w8a32.
--save [<BOOL>]trueGuarda los resultados anotados en runs/<task>/predict.
--save-framesfalseGuarda fotogramas individuales para la entrada de vídeo en lugar de un archivo de vídeo.
--save-jsonfalseGuarda PNG de mapas de clases de segmentación semántica.
--showfalseMuestra los resultados en una ventana.
--show-labels [<BOOL>]trueMuestra los nombres de clase en las etiquetas de los cuadros.
--show-conf [<BOOL>]trueMuestra las confianzas en las etiquetas de los cuadros.
--show-boxes [<BOOL>]trueDibuja los cuadros y sus etiquetas.
--line-widthdesde el tamaño de la imagenAncho de línea de los cuadros en píxeles, que también determina el tamaño de las etiquetas.
--deviceautomáticoDispositivo de ejecución, por ejemplo, cpu, cuda:0, tensorrt:0, coreml, intel:gpu, directml:0, rocm:0, migraphx:0, xnnpack.
--verbose [<BOOL>]trueImprime los resultados y los tiempos de cada imagen.
--classestodoFiltra las detecciones por ID de clase, por ejemplo, 0, "0,1,2" o "[0, 1, 2]".

[<BOOL>] indica una opción cuyo valor es opcional: si la escribes sin valor (--rect), se establece en true, y --rect false la desactiva. La opción antigua --half sigue aceptándose, se asigna a --quantize 16 y muestra la misma advertencia de obsolescencia que el paquete de Python.

Guía de inicio rápido de la biblioteca#

Carga un modelo y ejecuta una predicción. Los metadatos del modelo, como los nombres de las clases, el tipo de tarea y el tamaño de imagen, se leen automáticamente del archivo ONNX.

use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Metadata (classes, task, imgsz) is parsed from the model.
    let mut model = YOLOModel::load("yolo26n.onnx")?;

    let results = model.predict("image.jpg")?;

    for result in &results {
        if let Some(boxes) = &result.boxes {
            for i in 0..boxes.len() {
                let class_id = boxes.cls()[i] as usize;
                let conf = boxes.conf()[i];
                let name = result.names.get(&class_id).map_or("unknown", |s| s.as_str());
                println!("{name} {conf:.2}");
            }
        }
    }

    Ok(())
}

Usa InferenceConfig para controlar los umbrales, el tamaño de imagen, la precisión y el dispositivo con una API basada en un generador:

use ultralytics_inference::{Device, InferenceConfig, Quantization, YOLOModel};

let config = InferenceConfig::new()
    .with_confidence(0.5)
    .with_iou(0.45)
    .with_imgsz(640, 640)
    .with_device(Device::Cuda(0))
    .with_quantize(Quantization::Fp16);

let mut model = YOLOModel::load_with_config("yolo26n.onnx", config)?;
let results = model.predict("image.jpg")?;

Cada tarea rellena un campo distinto de Results. Cada pestaña de abajo contiene un programa completo y ejecutable; el modelo y las entradas de ejemplo se descargan automáticamente en la primera ejecución. Sustituye predict_default() por predict("image.jpg") para ejecutarlo con tus propios archivos.

use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = YOLOModel::load("yolo26n.onnx")?;
    let results = model.predict_default()?;

    for result in &results {
        if let Some(boxes) = &result.boxes {
            println!("{} detections", boxes.len());
            let xyxy = boxes.xyxy(); // rows of [x1, y1, x2, y2]
            for i in 0..boxes.len() {
                let class_id = boxes.cls()[i] as usize;
                let name = result.names.get(&class_id).map_or("unknown", |s| s.as_str());
                println!("  {name} {:.2} {:?}", boxes.conf()[i], xyxy.row(i).to_vec());
            }
        }
    }

    Ok(())
}

Tareas compatibles#

Se admiten todas las tareas de Ultralytics. Si omites --model, se descarga automáticamente el modelo nano correspondiente a la tarea seleccionada.

Tarea--taskSalidaModelo predeterminado
DeteccióndetectCajas delimitadoras y clasesyolo26n.onnx
Segmentación de instanciassegmentCajas y máscaras por instanciayolo26n-seg.onnx
Segmentación semánticasemanticMapa de clases por píxelyolo26n-sem.onnx
Estimación de profundidaddepthMapa de profundidad por píxel en metrosyolo26n-depth.onnx
ClasificaciónclassifyProbabilidades de claseyolo26n-cls.onnx
PoseposeCajas y puntos claveyolo26n-pose.onnx
Cajas orientadasobbCajas delimitadoras giradasyolo26n-obb.onnx

--ocr añade la lectura de texto en escenas a cualquier modelo de detección, segmentación u OBB; si no se especifica --model, se ejecuta el detector de texto yolo26n-text.onnx. Consulta el OCR de texto en escenas.

Compatibilidad de modelos#

Cualquier modelo de Ultralytics exportado a ONNX se puede cargar desde un archivo local. La descarga automática está disponible para los nombres de modelo estándar YOLO26, YOLO11 y YOLOv8, en los tamaños n, s, m, l y x:

Familia de modelosVariantes descargables automáticamente
YOLO26yolo26{n,s,m,l,x}.onnx, -seg, -sem, -depth, -cls, -pose, -obb y -text
YOLO11yolo11{n,s,m,l,x}.onnx, -seg, -cls, -pose y -obb
YOLOv8yolov8{n,s,m,l,x}.onnx, -seg, -cls, -pose y -obb

La segmentación semántica (-sem), la estimación de profundidad (-depth) y los detectores de texto en escenas -text solo están disponibles en YOLO26. El reconocedor PP-OCRv6_medium_rec.onnx y el clasificador de orientación PP-LCNet_x0_25_textline_ori.onnx de PaddleOCR que usa --ocr (Apache-2.0) también se descargan automáticamente. Los modelos de detección RT-DETR también funcionan, pero no se descargan automáticamente: primero, exporta uno a ONNX. Las exportaciones IR nativas de OpenVINO funcionan con la funcionalidad openvino-native; consulta Modelos IR de OpenVINO.

Fuentes de entrada#

El argumento --source (y el tipo Source en la biblioteca) admite muchos tipos de entrada, que se detectan automáticamente a partir de la cadena:

FuenteEjemploNotas
Imagenimage.jpgArchivo único.
Directorioimages/Todas las imágenes de la carpeta.
Globimages/*.jpgPatrón de estilo shell.
Vídeovideo.mp4Requiere la característica video.
Cámara web0Requiere la característica video.
Flujortsp://...Requiere la característica video.
URLhttps://example.com/image.jpgDescarga remota de imágenes.

Inferencia por teselas#

Las imágenes grandes con objetos pequeños, como las fotos aéreas o de satélite, se pueden dividir en ventanas solapadas y combinar después en un único resultado, igual que con el argumento tile de Python. Las ventanas se solapan un 20 %, los cuadros se proyectan de nuevo en la imagen original y los duplicados se eliminan por clase. Con una exportación de lote dinámico, --batch procesa varias ventanas en una sola llamada de inferencia. Se admiten todas las tareas.

# 640 px windows; a bare --tile uses --imgsz
ultralytics-inference predict --model yolo26n-obb.onnx --source aerial.jpg --tile 640
use ultralytics_inference::{InferenceConfig, YOLOModel};

// with_tile(0) uses the inference size
let config = InferenceConfig::new().with_tile(640);
let mut model = YOLOModel::load_with_config("yolo26n.onnx", config)?;
let results = model.predict("aerial.jpg")?;

OCR de texto en escenas#

Los detectores YOLO26-Text encuentran palabras en forma de cuadros orientados y TextRecognizer las lee con PP-OCRv6 de PaddleOCR, el mismo reconocedor que la solución de OCR de Python. También funcionan los cuadros de los modelos de detección y las máscaras de los modelos de segmentación: las máscaras se leen a partir del rectángulo de área mínima que rodea su contorno y conservan el contorno como polígono. Cada recorte se gira para dejarlo en posición vertical; si el clasificador de orientación detecta que el texto está boca abajo, se vuelve a leer tras girarlo. Los textos se devuelven en orden de lectura. El reconocedor se ejecuta en el dispositivo del detector.

# Auto-downloads yolo26n-text.onnx and the PaddleOCR models
ultralytics-inference predict --ocr --source sign.jpg

# Any size of the text detector, on the GPU
ultralytics-inference predict --ocr --model yolo26x-text.onnx --source sign.jpg --device cuda:0

El ejemplo de la biblioteca carga la imagen con el crate image, así que añádelo junto al paquete con cargo add image.

use ultralytics_inference::YOLOModel;
use ultralytics_inference::ocr::{DEFAULT_ORIENTATION, DEFAULT_RECOGNIZER, TextRecognizer};

let mut detector = YOLOModel::load("yolo26n-text.onnx")?;
let mut ocr = TextRecognizer::new(&detector, DEFAULT_RECOGNIZER, DEFAULT_ORIENTATION)?;
let image = image::open("sign.jpg")?;
let result = detector.predict_image(&image, "sign.jpg".into())?.remove(0);
for text in ocr.read(&image, &result)? {
    println!("{} {:.2} {:?}", text.text, text.confidence, text.polygon);
}

predict --ocr dibuja cada texto igual que la solución de Python, y también se le aplican --line-width, --show-labels y --show-conf.

Dispositivos y proveedores de ejecución#

Los backends de GPU y aceleradores se compilan como características de Cargo y se seleccionan en tiempo de ejecución con --device (CLI) o Device (biblioteca). Si no especificas un dispositivo, los proveedores compilados se registran en un orden de preferencia fijo (primero TensorRT, luego CUDA, etc.), por lo que una compilación con solo las características predeterminadas se ejecuta en CPU.

Cadena del dispositivoVariante de DeviceCaracterística de compilaciónHardware
cpuDevice::CpuintegradoCualquier CPU
cuda:0Device::Cuda(0)cudaGPU NVIDIA
tensorrt:0Device::TensorRt(0)tensorrtGPU NVIDIA optimizada
coremlDevice::CoreMlcoremlApple Silicon / macOS
intel:cpuDevice::IntelCpuopenvino o openvino-nativeCPU Intel
intel:gpuDevice::IntelGpuopenvino o openvino-nativeGPU Intel
intel:npuDevice::IntelNpuopenvino o openvino-nativeNPU Intel
directml:0Device::DirectMl(0)directmlGPU Windows
rocm:0Device::Rocm(0)rocmGPU AMD
migraphx:0Device::MiGraphX(0)migraphxGPU de AMD (Linux x64)
xnnpackDevice::XnnpackxnnpackCPU optimizada
# Build the CLI with the providers you need
cargo install ultralytics-inference --features cuda,tensorrt

Modelos IR de OpenVINO#

Con la funcionalidad openvino-native, --model también acepta una exportación nativa de OpenVINO, el archivo .xml o la carpeta de yolo export format=openvino, y la ejecuta mediante el entorno de ejecución de OpenVINO en lugar de ONNX Runtime. Todas las tareas se ejecutan en intel:cpu, intel:gpu y intel:npu, y la biblioteca la carga con YOLOModel::load("yolo26n_openvino_model"). No hace falta instalar OpenVINO para compilar; el entorno de ejecución se carga al abrir el primer modelo. Consulta la guía de OpenVINO para configurar el sistema.

yolo export model=yolo26n.pt format=openvino # add quantize=16, quantize=8, dynamic=True, or batch=4
ultralytics-inference predict --model yolo26n_openvino_model --source bus.jpg --device intel:gpu

Aceleración de GPU y preprocesamiento con CUDA#

En hardware de NVIDIA, la funcionalidad cuda habilita el proveedor de ejecución CUDA, y tensorrt añade el proveedor TensorRT para optimizar aún más (incluye cuda, que también ejecuta el reconocedor OCR). Para conseguir la menor latencia de inferencia posible, la funcionalidad cuda-preprocess traslada el preprocesamiento a la GPU.

cuda-preprocess ejecuta el redimensionamiento letterbox, la normalización y la conversión de disposición de HWC a CHW como un único kernel CUDA fusionado; después, pasa el resultado al modelo como un tensor del dispositivo sin copia. El fotograma sin procesar de 8 bits se sigue transfiriendo a la GPU mediante un búfer de preparación fijado en las GPU discretas; el kernel elimina el redimensionamiento, la normalización y la conversión de disposición en la CPU, así como la transferencia independiente del tensor preprocesado, algo especialmente importante para los lotes de alto rendimiento y los flujos en tiempo real.

# Build with fused GPU preprocessing (implies cuda + tensorrt)
cargo build --release --features cuda-preprocess

La ruta rápida se utiliza automáticamente, sin cambios en la API, cuando se cumplen todas estas condiciones: la funcionalidad está incluida en la compilación, el dispositivo es CUDA, TensorRT o no está especificado, la tarea es detección, segmentación, segmentación semántica (solo imágenes individuales), estimación de profundidad, pose u OBB, y el modelo usa entradas FP32. Está habilitada de forma predeterminada y se puede desactivar para cada modelo:

use ultralytics_inference::{Device, InferenceConfig};

let config = InferenceConfig::new()
    .with_device(Device::TensorRt(0))
    .with_cuda_preprocess(false); // force CPU preprocessing
Ajusta tu kit de herramientas CUDA

cuda-preprocess requiere un kit de herramientas CUDA compatible en tiempo de compilación y usa NVRTC en tiempo de ejecución para el kernel de preprocesamiento fusionado. Consulta la guía de aceleración de CUDA y TensorRT para conocer los requisitos de versión y cómo solucionar problemas.

Características de Cargo#

Las características se habilitan en tiempo de compilación. Las características predeterminadas cubren la anotación y la visualización en directo.

CaracterísticaPredeterminadoFinalidad
annotatesíDibuja cuadros, máscaras, puntos clave, etiquetas y textos OCR; es necesario para --save.
visualizesíVisualización en ventana en tiempo real para --show.
videonoLee y escribe archivos de vídeo (requiere FFmpeg 6 a 9).
cudanoProveedor de ejecución de NVIDIA CUDA.
tensorrtnoProveedor de ejecución TensorRT de NVIDIA (incluye cuda).
cuda-preprocessnoPreprocesamiento fusionado en la GPU (implica cuda, tensorrt; necesita el kit de herramientas de CUDA).
coremlnoProveedor de ejecución de Apple CoreML.
openvinonoProveedor de ejecución OpenVINO de Intel (Linux y Windows x64).
openvino-nativenoModelos IR nativos de OpenVINO (.xml) mediante el entorno de ejecución de OpenVINO.
rocmnoProveedor de ejecución ROCm de AMD (necesita tu propia compilación de ONNX Runtime).
migraphxnoProveedor de ejecución MIGraphX de AMD (Linux x64).
directmlnoProveedor de ejecución de Windows DirectML.
xnnpacknoProveedor de ejecución XNNPACK para inferencias optimizadas en CPU.

Los grupos de conveniencia agrupan proveedores relacionados: nvidia (cuda, tensorrt), amd (rocm, migraphx), intel (openvino, onednn), mobile (nnapi, coreml, qnn) y all (annotate, visualize, video). También están disponibles los proveedores adicionales onednn, nnapi, qnn, acl, tvm, rknpu, cann, webgpu y azure.

Habilita las características al instalar la CLI o añadir la biblioteca:

cargo install ultralytics-inference --features video
cargo install ultralytics-inference --features cuda,tensorrt
[dependencies]
ultralytics-inference = { version = "0.0.58", features = ["video"] }

Salida y guardado#

De forma predeterminada, las predicciones se anotan y se guardan en un directorio de ejecución cuyo nombre se incrementa automáticamente:

runs/
└── detect/
    └── predict/          # then predict2, predict3, ...
        └── image.jpg     # annotated result

La subcarpeta coincide con la tarea (runs/segment/, runs/pose/, etc.). Para las fuentes de vídeo, la salida anotada se guarda como archivo de vídeo; pasa --save-frames para guardar fotogramas individuales. Para la tarea semantic, --save-json guarda PNG de mapas de clases por píxel en una subcarpeta results/. Para la tarea depth, el mapa de profundidad coloreado se superpone a la imagen de origen, igual que en la salida plot() de Ultralytics Python. Para guardar imágenes y vídeos anotados se requiere la característica annotate; la exportación de PNG de mapas de clases semánticas no la requiere. La entrada y salida de vídeo requieren la característica video.

El dibujo sigue el comportamiento de Python Results.plot(): el ancho de línea es, de forma predeterminada, el 0,3 % del lado medio de la imagen (al menos 2 px); las etiquetas se colocan encima de cada cuadro o dentro de él cuando no hay espacio, y las máscaras de instancia se mezclan del mismo modo, por lo que las imágenes guardadas coinciden con las de Python. --line-width, --show-labels, --show-conf y --show-boxes funcionan igual que los argumentos de Python con esos mismos nombres. En la biblioteca, pásalos mediante AnnotateOptions:

use ultralytics_inference::annotate::{AnnotateOptions, annotate_image_with_options};

let options = AnnotateOptions {
    line_width: Some(3),
    show_conf: false,
    ..Default::default()
};
let annotated = annotate_image_with_options(&image, &results[0], &options);

Las máscaras de segmentación se generan al tamaño de inferencia, igual que en Python; pasa --retina-masks (o InferenceConfig::with_retina_masks(true)) para generarlas al tamaño original de la imagen.

Preguntas frecuentes#

  • No. La crate ejecuta directamente los modelos ONNX exportados mediante ONNX Runtime. Python solo es necesario si antes entrenas o exportas modelos con el paquete Ultralytics.

  • Cualquier modelo YOLO de Ultralytics exportado a ONNX, incluidos YOLO26, YOLO11 y YOLOv8. Los nombres de modelos conocidos se descargan automáticamente; también puedes indicar en --model cualquier archivo .onnx local.

  • Exporta desde el paquete Python, por ejemplo, con la integración de ONNX, o deja que la CLI descargue automáticamente un modelo nano estándar para la tarea elegida durante la primera ejecución.

  • Sí. --ocr lee el texto en escenas con un detector YOLO26-Text y PaddleOCR, como la solución de OCR de Python, y también funciona con los cuadros o las máscaras de tus propios modelos de detección y segmentación. Consulta el OCR de texto en escenas.

  • Usa la inferencia por teselas: --tile 640 divide la imagen en ventanas solapadas de 640 px y combina las detecciones en un único resultado.

  • Sí, con la función video activada y FFmpeg 6 a 9 instalado en el sistema. Esto es compatible con archivos de vídeo, cámaras web y transmisiones RTSP/RTMP/HTTP.

  • Ambas están activadas de forma predeterminada. annotate dibuja recuadros, máscaras, puntos clave y etiquetas de clase en la imagen, y es necesaria para que --save escriba los resultados anotados. visualize abre una ventana en directo para --show. Para obtener una compilación más ligera y sin interfaz gráfica que solo devuelva resultados mediante programación, desactívalas con cargo build --no-default-features (y vuelve a activar las funciones que necesites).

  • Esta página ofrece una descripción general. La referencia completa de la API, desglosada por tipo, con todas las estructuras, métodos y opciones de configuración públicas, está publicada en docs.rs y se genera directamente a partir del código fuente.

Comentarios

Haz una pregunta, comparte tus resultados o ayuda a otra persona.