Kornia-rs: A Low-Level 3D Computer Vision Library In Rust

Aditya Kumar; Andrew Shen; Edgar Riba; Gary Bradski; Jian Shi

REVIEW 4 major objections 4 minor 15 references

Kornia-rs: A Low-Level 3D Computer Vision Library In Rust

T0 review · 4 major / 4 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read A native Rust computer vision library claims 3–5× faster image transformations than existing Rust libraries and comparable speed to C++ wrappers.

desk verdict Useful native-Rust CV library with real engineering substance, but the headline 3–5x speedup is not yet reproducible from the paper; the benchmark section needs to be rewritten with concrete controls. read the letter →

arxiv 2505.12425 v1 pith:B7VQGV7Z submitted 2025-05-18 cs.CV

Edgar Riba , Jian Shi , Aditya Kumar , Andrew Shen , Gary Bradski This is my paper · ORCID

classification cs.CV

keywords Rustcomputervision3DtypedtensorsimageprocessingIterativeClosestPointzero-copyviewsPythonbindings

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper introduces kornia-rs, a computer vision library written entirely in native Rust, and claims it outperforms the existing native Rust library image-rs by 3 to 5 times on common image transformations such as resizing, flipping, and color conversion. Through Python bindings, the paper reports PNG decoding about 2.4 times faster than Pillow and nearly 2 times faster than TensorFlow or OpenCV, with JPEG decoding within about 10 percent of those libraries. Beyond 2D image processing, kornia-rs supplies native 3D operators, including point-cloud I/O, 3D geometry, and an Iterative Closest Point implementation, which the paper says fills a gap in the Rust ecosystem. The larger claim is that Rust's ownership model and type system can support a low-level, real-time, safety-critical vision library without sacrificing performance.

What carries the argument

The central mechanism is a statically typed tensor abstraction: `Tensor<T, N>` encodes element type and rank as compile-time constants, while `Image<T, C>` encodes bit depth and channel count, turning shape and format mismatches into compile-time errors instead of runtime assertions. Around this core, the library builds zero-copy view types for crops and slices, user-provided pre-allocated output buffers to avoid hidden allocations, and an allocator abstraction that lets CPU and future GPU backends share tensor logic. The paper credits this combination for both the safety guarantees and the measured speedups.

What would settle it

Run the same reported operations on a fixed image set, with kornia-rs, image-rs, and each Python baseline built from pinned source versions and identical release and optimization flags, enabling SIMD where supported; if kornia-rs no longer stays 3–5× faster than image-rs, the central performance claim fails.

Watch

Extended reading notes

Core claim

The paper's central claim is that kornia-rs, built from scratch in Rust, achieves a 3 to 5 times speedup over the native Rust library image-rs for geometric and color transformations, with the gap widening at higher resolutions. It also reports that its Python bindings deliver near-native throughput for image I/O, beating Pillow on PNG and JPEG decoding and matching TensorFlow and OpenCV within roughly 10 percent. Alongside these performance results, kornia-rs provides a set of 3D computer vision operators, including a standalone Iterative Closest Point implementation, which the paper argues are largely missing from the Rust ecosystem. The paper presents this as evidence that Rust can serve as a high-performance, memory-safe foundation for modern computer vision workloads.

Load-bearing premise

The load-bearing premise is that the benchmark comparison is fair to the baseline libraries; the paper does not report exact library versions, compiler flags, or SIMD settings, so an unrepresentative setup would erase the claimed 3–5× speedup.

Editorial extensions

If this is right

If the benchmark results hold, Rust-native image pipelines can achieve real-time performance for common transforms without wrapping C++ libraries.
The compile-time typed tensors would make whole classes of bugs, such as applying a color conversion to the wrong channel count or rank, impossible to build rather than discovered at runtime.
The Python bindings would give Python users native Rust throughput for image I/O without leaving their existing tooling.
The native 3D operators, especially ICP, would make safe Rust a practical option for point-cloud alignment in robotics and embedded systems.
Zero-copy views and pre-allocated buffers make latency more predictable, which matters for real-time control loops.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

If the speedups generalize beyond the reported operations and hardware, a natural next test is whether Rust-native vision can close the gap with optimized C++ SIMD libraries on larger workloads, not just Python wrappers.
The ecosystem-gap claim rests on an informal scan of existing libraries; a systematic survey of Rust crates for 3D operations would show how much of the gap is truly unfilled.
The benchmark outcome could be sensitive to the baseline libraries' optimization settings, so a fair comparison should pin compiler flags and versions for all sides; the reported numbers are a starting point, not a final ranking.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

You should know: this is a legitimate engineering contribution, but the headline performance number is not yet falsifiable from the paper. The design ideas are real and the library appears useful; the benchmarks are too thin for the claim.

What's new: kornia-rs is a from-scratch native Rust CV library, not a wrapper. The typed tensor system with compile-time rank checking, zero-copy views, and pre-allocated buffers are well-known ideas but are genuinely a new packaging for the Rust CV community. The modular crate layout and the inclusion of 3D operators, including a native ICP, fill a real gap. Python bindings with claimed negligible overhead also have practical value. This is not algorithmic novelty; it's a systems contribution, and that's fine.

The paper's weak spot is exactly where the stress test points: the 3–5x speedup over image-rs rests on plots with no error bars, no exact library versions, no compiler flags or target-cpu settings, and no benchmark harness or commit hash. Only one native baseline is used. For resize, no interpolation method is specified; if kornia-rs uses a cheaper kernel, the speedup measures algorithm choice, not library efficiency. The "Kornia-rs TurboJPEG" path in the I/O comparison is a C library, so that number is not evidence about pure Rust. None of this proves the claims are wrong—they're plausible—but the paper needs to supply the controls.

The claim about a "significant gap" in 3D Rust CV is asserted without a survey; a quick check of the crate ecosystem would strengthen or qualify it.

I also note the paper says it averages 1000 iterations but gives no variance. That's easy to fix and changes the credibility a lot.

Who's this for: practitioners doing Rust-based robotics, embedded vision, or real-time pipelines. They'll get the most value. It deserves a serious referee because the library itself is a concrete artifact and the performance question is checkable. For peer review, I'd tell the authors: publish the benchmark code with a commit hash, specify interpolation kernels and build flags, run more native baselines, and add error bars. Then the 3–5x claim becomes testable. Without those, the abstract oversells.

My verdict: conditional accept/present as a systems paper, with benchmark reproducibility as the condition.

Referee Report

4 major / 4 minor

Summary. The paper introduces kornia-rs, an open-source computer vision library written in native Rust, and argues that its design choices—compile-time tensor ranks, strongly-typed image structs, zero-copy views, and pre-allocated buffers—provide memory safety without runtime overhead. The central empirical claim is that kornia-rs is 3-5x faster than image-rs for common image transformations (horizontal flip, resize, RGB-to-gray), and that through its Python bindings it decodes PNG/JPEG images faster than or comparably to PIL, OpenCV, and TensorFlow. The paper further claims to fill a gap in the Rust ecosystem by providing 3D operators (point cloud I/O, geometry, ICP), and illustrates integrations with robotics frameworks. The manuscript is a systems description with a benchmark section, but the benchmark methodology is currently too underspecified to substantiate the headline performance numbers.

Significance. If the performance claims are validated, kornia-rs would be a valuable addition to the Rust computer vision ecosystem, which indeed lacks a comprehensive native library with both 2D and 3D functionality. The design ideas, especially compile-time tensor ranks and explicit output buffers, are well-motivated for real-time and embedded applications, and the open-source availability is a strength. However, the paper's key evidence, the 3-5x speedup, rests on benchmarks that are not reproducible from the manuscript, and the 3D component has no quantitative evaluation. The significance is therefore conditional on completing these validations.

major comments (4)

[Section III] The central performance claim ('3 to 5 times speedup') is not reproducible from the information provided. The paper gives only the CPU model (AMD Ryzen 7 5800X), 32GB RAM, Python 3.12, and 'averaged over 1000 iterations,' but omits the exact versions or commit hashes of kornia-rs and image-rs, the Rust toolchain version, compiler flags (e.g., opt-level, target-cpu, LTO), SIMD feature enablement, the benchmark harness source code, and the input images used. Please provide a benchmark repository with pinned dependencies, explicit build configuration, and raw measurements including variance so that the speedup can be independently verified.
[Figure 1a] The resize benchmarks do not state the interpolation algorithm used by each library. If kornia-rs uses a cheaper kernel (e.g., nearest-neighbor) while image-rs uses a higher-order default (e.g., Lanczos3), the reported 3-5x speedup would measure algorithm choice rather than library efficiency. Please specify the exact resize algorithm, filter parameters, and bit depth for each operation, and ideally include comparisons at matched algorithm and quality settings.
[Figure 1b] The JPEG decoding comparison includes a 'Kornia-rs TurboJPEG' path, which is a wrapper around the C TurboJPEG library. Since the paper's contribution is a native Rust library, the headline 'comparable performance to C++ wrapper-based libraries' should be based on the pure-Rust JPEG decoder ('Kornia-rs Raw JPEG') or the text must clearly separate wrapper-based and native results. Please clarify which path underlies the stated decoding numbers and do not conflate the two.
[Section IV-A] The only evaluation of the ICP module is a qualitative figure of point cloud alignment (Figure 2). Since the paper claims to fill a gap in 3D computer vision in Rust, the 3D module needs at least a quantitative correctness check—for example, alignment error on a known ground-truth transformation, convergence criteria, and timing—and ideally a comparison against an existing implementation such as Open3D or PCL. Without this, the 3D contribution is not demonstrated.

minor comments (4)

[Section I] The instruction 'cargo install kornia' is incorrect for adding a library dependency; cargo install is for binary executables. Use 'cargo add kornia' or point readers to the crates.io page.
[Snippet 1] The tensor creation example contains a syntax error: '[1 f32, 2, 3, 4]' should likely be '[1.0f32, 2.0, 3.0, 4.0]'. Also, the comment says 'msea' while the variable is 'mse'; please fix the typo.
[Figure 1] The figure labels contain spacing artifacts ('K ornia-rs', 'Image-rs', 'T urboJPEG') and some legends are difficult to read; please clean up the figure text and improve the resolution.
[Section I] The assertion that kornia-rs fills a 'significant gap in the Rust ecosystem' would be stronger with a brief survey of existing Rust 3D crates (e.g., pointcloud, easy-cv, or bindings to Open3D) and a clear explanation of why they are incomplete; currently the claim is unsupported by citations.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: kornia-rs presents external benchmark measurements and system descriptions; no claim reduces to its own inputs by construction.

full rationale

The paper's central claims are (1) architectural features of a Rust computer vision library and (2) empirical speed comparisons against external libraries such as image-rs, PIL, OpenCV, and TensorFlow. These are measurements, not derivations: the reported 3-5x speedup is an observed ratio of timings, not a quantity obtained by fitting a parameter to a subset of data and then predicting the same subset. No equation in the paper defines a predicted quantity in terms of an input quantity, and no result is justified by invoking a prior uniqueness theorem or by importing an ansatz through citation. The only self-citation, Kornia [7], appears as a contextual pointer to an existing Python CV library in the introduction; it is not used to justify the performance claim, the 3D-functionality claim, or any numerical result. The lack of benchmark harness details, exact library versions, compiler flags, and interpolation specifications is a reproducibility and correctness concern, but a missing control does not make the comparison circular: the baselines are independent external libraries, and nothing in the paper's argument reduces to itself by construction. Therefore no circular step is identified, and the appropriate score is 0.

Assumptions & free parameters 0 free parameters · 3 assumptions · 0 invented entities

The central claim is an engineering performance claim. The library introduces no new mathematical entities or free parameters. The load-bearing axioms are domain assumptions about Rust's safety and zero-cost abstractions, the fairness of the benchmark setup, and the existence of a gap in the Rust CV ecosystem. These are not proven in the paper and would need independent verification.

assumptions (3)

domain assumption Rust's ownership model and type system provide memory safety and thread safety with zero runtime overhead.
The paper's safety claims rely on this property of Rust, which is well-established in the programming language community but is not proven in this paper.
domain assumption The benchmark configuration is fair and representative for all compared libraries.
The 3-5x speedup claim depends on fair comparison; the paper lacks details on versions, build flags, and SIMD utilization.
domain assumption The Rust ecosystem lacks a comprehensive native 3D computer vision library.
The paper asserts a gap but provides no systematic survey of existing Rust CV libraries beyond a few examples.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Kornia-rs: A Low-Level 3D Computer Vision Library In Rust." pith.science (2026). https://pith.science/paper/B7VQGV7Z

@misc{pith2026250512425,
  author       = {Pith},
  title        = {Pith review of: Kornia-rs: A Low-Level 3D Computer Vision Library In Rust},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/B7VQGV7Z}},
  note         = {Machine review of arXiv:2505.12425}
}

read the original abstract

We present \textit{kornia-rs}, a high-performance 3D computer vision library written entirely in native Rust, designed for safety-critical and real-time applications. Unlike C++-based libraries like OpenCV or wrapper-based solutions like OpenCV-Rust, \textit{kornia-rs} is built from the ground up to leverage Rust's ownership model and type system for memory and thread safety. \textit{kornia-rs} adopts a statically-typed tensor system and a modular set of crates, providing efficient image I/O, image processing and 3D operations. To aid cross-platform compatibility, \textit{kornia-rs} offers Python bindings, enabling seamless and efficient integration with Rust code. Empirical results show that \textit{kornia-rs} achieves a 3~ 5 times speedup in image transformation tasks over native Rust alternatives, while offering comparable performance to C++ wrapper-based libraries. In addition to 2D vision capabilities, \textit{kornia-rs} addresses a significant gap in the Rust ecosystem by providing a set of 3D computer vision operators. This paper presents the architecture and performance characteristics of \textit{kornia-rs}, demonstrating its effectiveness in real-world computer vision applications.

Figures

Figures reproduced from arXiv: 2505.12425 by the authors.

**Figure 2.** Point cloud alignment using kornia-rs ICP implemen [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

15 extracted references · 13 canonical work pages

[1]

The rust language,

N. D. Matsakis and F. S. Klock II, “The rust language,” in ACM SIGAda Ada Letters , vol. 34, pp. 103–104, ACM, 2014

work page 2014
[2]

The OpenCV Library,

G. Bradski, “The OpenCV Library,” Dr . Dobb’s Journal of Software Tools, 2000

2000
[3]

python- pillow/pillow: 11.2.1,

A. Murray, H. van Kemenade, wiredfool, J. A. Clark, A. Karpin- sky, O. Baranovi ˇc, C. Gohlke, Yay, J. Dufresne, M. Brett, DWesl, D. Schmidt, K. Kopachev, A. Houghton, REDxEYE, S. Mani, S. Landey, A. Koskela, R. Keith-Magee, J. Ware, vashek, Piolie, S. T., J. Douglas, U. Martinez, D. Caro, and S. Kossouho, “python- pillow/pillow: 11.2.1,” 2025

work page 2025
[4]

scikit-image: image processing in Python,

S. van der Walt, J. L. Sch ¨onberger, J. Nunez-Iglesias, F. Boulogne, J. D. Warner, N. Yager, E. Gouillart, T. Yu, and the scikit-image contributors, “scikit-image: image processing in Python,” PeerJ, vol. 2, p. e453, 6 2014

work page 2014
[5]

Open3d: A modern library for 3d data processing,

Q.-Y . Zhou, J. Park, and V . Koltun, “Open3d: A modern library for 3d data processing,” 2018

work page 2018
[6]

3D is here: Point Cloud Library (PCL),

R. B. Rusu and S. Cousins, “3D is here: Point Cloud Library (PCL),” in IEEE International Conference on Robotics and Automation (ICRA) , (Shanghai, China), IEEE, May 9-13 2011

work page 2011
[7]

Kornia: an open source differentiable computer vision library for pytorch,

E. Riba, D. Mishkin, E. R. D. Ponsa, and G. Bradski, “Kornia: an open source differentiable computer vision library for pytorch,” in Winter Conference on Applications of Computer Vision , 2020

work page 2020
[8]

Pytorch: An imperative style, high-performance deep learning library,

A. Paszke, “Pytorch: An imperative style, high-performance deep learning library,” arXiv preprint arXiv:1912.01703 , 2019

arXiv 1912

Show all 15 references

[9]

GitHub - image-rs/image: Encoding and decoding images in Rust

“GitHub - image-rs/image: Encoding and decoding images in Rust.” https://github.com/image-rs/image. [Accessed 20-04- 2025]

2025
[10]

ndarray: an N-dimensional array with array views, multidimensional slicing, and efficient operations

ndarray-rs contributors, “ndarray: an N-dimensional array with array views, multidimensional slicing, and efficient operations.” https: //github.com/rust-ndarray/ndarray. [Accessed 20-04- 2025]

2025
[11]

Copper: Purpose-built, rust-native software engine for robotics

G. Binet, “Copper: Purpose-built, rust-native software engine for robotics..” https://github.com/copper-project/ copper-rs, 2024. [Accessed 20-04-2025]

2024
[12]

Dora: A high-performance robotics dataflow framework

H. Xavier, “Dora: A high-performance robotics dataflow framework.” https://github.com/dora-rs/dora, 2023. Accessed: 2025- 04-20

2023
[13]

Candle: A lightweight machine learning framework in rust

Hugging Face, “Candle: A lightweight machine learning framework in rust.” https://github.com/huggingface/candle, 2023. Accessed: 2025-04-20

2023
[14]

Ort: Minimal accelerated machine learning runtime in rust

Pykeio Contributors, “Ort: Minimal accelerated machine learning runtime in rust.” https://github.com/pykeio/ort, 2024. Accessed: 2025-04-20

2024
[15]

TensorFlow: Large- scale machine learning on heterogeneous systems,

M. Abadi, A. Agarwal, P. Barham, E. Brevdo, Z. Chen, C. Citro, G. S. Corrado, A. Davis, J. Dean, M. Devin, S. Ghemawat, I. Goodfellow, A. Harp, G. Irving, M. Isard, Y . Jia, R. Jozefowicz, L. Kaiser, M. Kud- lur, J. Levenberg, D. Man ´e, R. Monga, S. Moore, D. Murray, C. Olah,...

2015

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.

[1] [1]

The rust language,

N. D. Matsakis and F. S. Klock II, “The rust language,” in ACM SIGAda Ada Letters , vol. 34, pp. 103–104, ACM, 2014

work page 2014

[2] [2]

The OpenCV Library,

G. Bradski, “The OpenCV Library,” Dr . Dobb’s Journal of Software Tools, 2000

2000

[3] [3]

python- pillow/pillow: 11.2.1,

A. Murray, H. van Kemenade, wiredfool, J. A. Clark, A. Karpin- sky, O. Baranovi ˇc, C. Gohlke, Yay, J. Dufresne, M. Brett, DWesl, D. Schmidt, K. Kopachev, A. Houghton, REDxEYE, S. Mani, S. Landey, A. Koskela, R. Keith-Magee, J. Ware, vashek, Piolie, S. T., J. Douglas, U. Martinez, D. Caro, and S. Kossouho, “python- pillow/pillow: 11.2.1,” 2025

work page 2025

[4] [4]

scikit-image: image processing in Python,

S. van der Walt, J. L. Sch ¨onberger, J. Nunez-Iglesias, F. Boulogne, J. D. Warner, N. Yager, E. Gouillart, T. Yu, and the scikit-image contributors, “scikit-image: image processing in Python,” PeerJ, vol. 2, p. e453, 6 2014

work page 2014

[5] [5]

Open3d: A modern library for 3d data processing,

Q.-Y . Zhou, J. Park, and V . Koltun, “Open3d: A modern library for 3d data processing,” 2018

work page 2018

[6] [6]

3D is here: Point Cloud Library (PCL),

R. B. Rusu and S. Cousins, “3D is here: Point Cloud Library (PCL),” in IEEE International Conference on Robotics and Automation (ICRA) , (Shanghai, China), IEEE, May 9-13 2011

work page 2011

[7] [7]

Kornia: an open source differentiable computer vision library for pytorch,

E. Riba, D. Mishkin, E. R. D. Ponsa, and G. Bradski, “Kornia: an open source differentiable computer vision library for pytorch,” in Winter Conference on Applications of Computer Vision , 2020

work page 2020

[8] [8]

Pytorch: An imperative style, high-performance deep learning library,

A. Paszke, “Pytorch: An imperative style, high-performance deep learning library,” arXiv preprint arXiv:1912.01703 , 2019

arXiv 1912