Kornia is a differentiable computer vision library that provides a rich set of differentiable image processing and geometric vision algorithms. Built on top of PyTorch, Kornia integrates seamlessly into existing AI workflows, allowing you to leverage powerful batch transformations, auto-differentiation and GPU acceleration. Whether you're working on image transformations, augmentations, or AI-driven image processing, Kornia equips you with the tools you need to bring your ideas to life.
📢 Direction: Kornia is becoming the reference implementation and executable specification for differentiable computer vision and geometry in the PyTorch ecosystem — explicit conventions, conformance tests, and honest benchmarks over API growth. Read the Roadmap.
When to use Kornia
Kornia pays off where a hand-written version gets long or fragile, or where the alternatives leave the GPU:
- Breadth. 1,200+ public operators, most with no torchvision equivalent: camera models and
- Per-sample parameters in one batched call.
gaussian_blur2d(x, (9, 9), sigma)takes a(B, 2)sigma;
rotate takes a (B,) angle, warp_affine / warp_perspective take (B, 2, 3) / (B, 3, 3) matrices and
adjust_brightness a (B,) factor. torchvision's functional ops apply one parameter per call. From Kornia 0.9.1,
a sigma tensor and the enhancement value checks (gamma, contrast, solarize) are validated on the device, so a
CUDA call, or an MPS call on PyTorch ≥ 2.13, needs no host synchronization for them.
- Batched minimal solvers and robust estimation.
find_fundamental(x1, x2, method="7POINT")solves(B, 7, 2)
(B, 3, 3, 3), with zero matrices in the unused slots; the 8-point,
5-point essential (find_essential), DLT homography and PnP (solve_pnp_dlt) solvers are there too. RANSAC
(homography, fundamental and essential models) samples and scores hypotheses on the device; by default its
refinement and final selection run on the host in float64, and compile=True (PyTorch ≥ 2.14, CPU and CUDA) runs
the whole estimation as one compiled graph on the device.
- Differentiable geometry. Depth to 3D and back (
depth_to_3d_v2,unproject_points,project_points),
warp_frame_depth, remap, camera models with Brown–Conrady and Kannala–Brandt distortion, and Lie groups (So3,
Se3) keep gradients with respect to depth, pose and camera parameters.
- Annotated augmentation.
AugmentationSequentialapplies one sampled transform to images, masks, boxes and
- Local features on the GPU. SIFT and HardNet, DISK, ALIKED, XFeat, DeDoDe, LoFTR and LightGlue, with
- Morphology with arbitrary structuring elements on batched tensors.
- Compiles and exports. Nearly all probed operator configurations run under
torch.compileand match eager,
- Fast where it is designed to be: batched tensors on a GPU. In the published 0.9.0 flagship benchmarks (RTX 4090,
torch.compile takes several of them past 100×. On the small
overlap with torchvision on the same GPU, eager Kornia is slower; compiled Kornia is faster for hue, color jitter
and Gaussian blur and still slower for flips, crops and brightness. OpenCV wins single-image uint8 CPU work.
Results vary with hardware and workload; every number, win and loss is published on the
performance page.
These operators run on the input's device with no NumPy round trip, and most are differentiable; robust estimation
(RANSAC) and the extraction methods of learned features such as DeDoDe and XFeat run without gradients. For a
single fixed-parameter operation, such as one blur or one resize, a few lines of PyTorch or torchvision are just as
good.
Key Components
- Differentiable Image Processing
- Advanced Augmentations
- AI Models
See here for some of the methods that we support! (>500 ops in total !)
| Category | Methods/Models |
|----------------------------|---------------------------------------------------------------------------------------------------------------------|
| Image Processing | - Color conversions (RGB, Grayscale, HSV, etc.)
- Geometric transformations (Affine, Homography, Resizing, etc.)
- Filtering (Gaussian blur, Median blur, etc.)
- Edge detection (Sobel, Canny, etc.)
- Morphological operations (Erosion, Dilation, etc.) |
| Augmentation | - Random cropping, Erasing
- Random geometric transformations (Affine, flipping, Fish Eye, Perspective, Thin plate spline, Elastic)
- Random noises (Gaussian, Median, Motion, Box, Rain, Snow, Salt and Pepper)
- Random color jittering (Contrast, Brightness, CLAHE, Equalize, Gamma, Hue, Invert, JPEG, Plasma, Posterize, Saturation, Sharpness, Solarize)
- Random MixUp, CutMix, Mosaic, Transplantation, etc. |
| Feature Detection | - Detector (Harris, GFTT, Hessian, DoG, KeyNet, DISK and DeDoDe)
- Descriptor (SIFT, HardNet, TFeat, HyNet, SOSNet, and LAFDescriptor)
- Matching (nearest neighbor, mutual nearest neighbor, geometrically aware matching, AdaLAM LightGlue, and LoFTR) |
| Geometry | - Camera models and calibration
- Stereo vision (epipolar geometry, disparity, etc.)
- Homography estimation
- Depth estimation from disparity
- 3D transformations |
| Deep Learning Layers | - Custom convolution layers
- Recurrent layers for vision tasks
- Loss functions (e.g., SSIM, PSNR, etc.)
- Vision-specific optimizers |
| Photometric Functions | - Photometric loss functions
- Photometric augmentations |
| Filtering | - Bilateral filtering
- DexiNed
- Dissolving
- Guided Blur
- Laplacian
- Gaussian
- Non-local means
- Sobel
- Unsharp masking |
| Color | - Color space conversions
- Brightness/contrast adjustment
- Gamma correction |
| Stereo Vision | - Disparity estimation
- Depth estimation
- Rectification |
| Image Registration | - Affine and homography-based registration
- Image alignment using feature matching |
| Pose Estimation | - Essential and Fundamental matrix estimation
- PnP problem solvers
- Pose refinement |
| Optical Flow | - Farneback optical flow
- Dense optical flow
- Sparse optical flow |
| 3D Vision | - Depth estimation
- Point cloud operations
|
| Image Denoising | - Gaussian noise removal
- Poisson noise removal |
| Edge Detection | - Sobel operator
- Canny edge detection | |
| Transformations | - Rotation
- Translation
- Scaling
- Shearing |
| Loss Functions | - SSIM (Structural Similarity Index Measure)
- PSNR (Peak Signal-to-Noise Ratio)
- Cauchy
- Charbonnier
- Depth Smooth
- Dice
- Hausdorff
- Tversky
- Welsch
| |
| Morphological Operations| - Dilation
- Erosion
- Opening
- Closing |
CUDA and Half-Precision Support
The module table below counts entries in the Linux CPU known-failure manifests
(cpu_float16.txt,
cpu_bfloat16.txt), pinned to Python 3.11 and PyTorch 2.15.0.
There are 243 float16 and 256 bfloat16 recorded failures. These are parametrized test cases, not counts of
unsupported functions. The remaining work is tracked in #4153.
No CI job covers CUDA or MPS half precision; CPU results do not establish support on those backends.
| Module | float16 | bfloat16 | Known failures (fp16 / bf16) | Notes |
|--------|:-------:|:--------:|:----------------------------:|-------|
| kornia.color | ✅ | ✅ | 0 / 0 | Lab/Luv conversions and rgb255_to_normals compute half inputs in float32 and return the input dtype |
| kornia.filters | ✅ | ✅ | 0 / 0 | Canny, Gaussian kernels/blur and CPU FFT convolution compute half inputs in float32 and return the input dtype |
| kornia.enhance | ✅ | ✅ | 0 / 0 | ZCA keeps half-input fitted state in float32; whitening and JPEG return the input dtype after float32 computation |
| kornia.morphology | ✅ | ✅ | 0 / 0 | |
| kornia.augmentation | ⚠️ | ⚠️ | 59 / 48 | float16: container autocast/runtime errors and accuracy; both dtypes: 3D backward and random-generator accuracy |
| kornia.geometry.transform | ⚠️ | ⚠️ | 31 / 31 | Rotation matrices, affine/perspective warps and homography-warper accuracy |
| kornia.geometry.camera | ⚠️ | ⚠️ | 13 / 23 | Projection, distortion round trips and stereo reprojection; includes test-side dtype assertions |
| kornia.geometry.calibration | ⚠️ | ⚠️ | 13 / 12 | solve_pnp_dlt rejects half inputs; undistort_points accuracy |
| kornia.geometry.epipolar | ⚠️ | ⚠️ | 36 / 36 | Essential-matrix decomposition/motion and KRt_from_projection lack CPU half kernels; fundamental-matrix accuracy |
| kornia.geometry.homography | ⚠️ | ⚠️ | 10 / 16 | DLT solver accuracy, including iterated and line-based variants |
| kornia.geometry.liegroup | ✅ | ✅ | 0 / 0 | So2/Se2 reject bfloat16 rotation construction: PyTorch has no complex bfloat16 dtype; these expected errors/skips are outside the manifests |
| kornia.geometry.solvers | ✅ | ✅ | 0 / 0 | |
| kornia.geometry.subpix | ⚠️ | ⚠️ | 6 / 3 | SpatialSoftArgmax2d and ConvQuadInterp3d accuracy; bfloat16: render_gaussian2d accuracy |
| kornia.geometry.conversions | ⚠️ | ⚠️ | 65 / 65 | Angle-axis, quaternion and rotation-matrix accuracy; includes tests/integration/test_conversions.py |
| kornia.geometry.ransac | ⚠️ | ⚠️ | 2 / 2 | Essential-model fitting raises in epipolar solvers |
| kornia.geometry (other) | ⚠️ | ⚠️ | 6 / 13 | Box-transform and depth accuracy |
| kornia.image | ⚠️ | ⚠️ | 2 / 2 | Circle/ellipse polygon-fill comparisons use vertices and reference masks computed in half precision |
| kornia.losses | ✅ | ⚠️ | 0 / 2 | bfloat16: total-variation accuracy |
| kornia.feature | ✅ | ✅ | 0 / 0 | Matching uses a manual cdist fallback for half dtypes; LightGlue's float16 tests are skipped |
| kornia.metrics | ✅ | ✅ | 0 / 0 | |
| kornia.models | ✅ | ⚠️ | 0 / 1 | bfloat16: RT-DETR RepVGG fusion accuracy |
| contrib, core, io, onnx, sensors, tracking, utils | ✅ | ⚠️ | 0 / 2 | bfloat16: histogram matching and _torch_svd_cast accuracy |
✅ No entries in the CPU known-failure manifest ⚠️ Has recorded CPU failures. Neither symbol promises complete dtype support: skips, expected exceptions and source-level xfails are outside these counts. Some operators compute internally in float32 or float64 and return the input dtype.
Observed CPU CI outcomes:
The scheduled run at 93f1376e, 2026-10-21
used Linux x86_64, Python 3.11 and PyTorch 2.14.0, without slow or compile tests:
| Run | Passed | Failed | Skipped | XFAIL (all) | XPASS | Strict manifest entries | |-----|-------:|-------:|--------:|------------:|------:|------------------------:| | CPU float16 | 23905 | 0 | 5132 | 284 | 4 | 250 | | CPU bfloat16 | 23726 | 0 | 5286 | 309 | 4 | 274 |
Each job also deselected 3 ONNX conformance tests. XFAIL totals include both the strict manifest entries and source-level expected failures. The 4 XPASSes in each successful job are non-strict expected failures that passed; a passing manifest entry makes verification fail, as do a changed exception, a skipped entry or a stale node ID. A green job therefore means the recorded baseline reproduced, even though known failures and skips remain. These totals describe the linked revision; the module table describes the checked-in manifests.
Verify the complete CPU profiles in the pinned environment with:
KORNIA_TEST_OPTIMIZER= pixi run test-module tests/ --verify-known-failures --known-failure-profile=cpu-float16
KORNIA_TEST_OPTIMIZER= pixi run test-module tests/ --verify-known-failures --known-failure-profile=cpu-bfloat16pixi run test-half is an unseeded CPU sweep, without the strict profile baseline. See
TESTING.md for focused checks and baseline maintenance.
CUDA support and measurement limits:
Kornia accepts CUDA tensors for GPU acceleration, subject to each operator's dtype and backend limitations. There is no blocking CUDA CI job or checked-in CUDA known-failure manifest, so the CPU xfail counts above do not provide a current CUDA pass rate. The previous local measurements are retained here as historical evidence only:
| Historical run (f8449854, 2026-09-23) | Passed | Failed | Skipped |
|------------------------------------------------|-------:|-------:|--------:|
| CUDA float32 | 12193 | 22 | 3957 |
| CUDA float16 | 11738 | 451 | 3983 |
| CUDA bfloat16 | 11736 | 500 | 3936 |
These used an RTX 4090, Python 3.11 and PyTorch 2.14.0+cu130. Source-marked xfails were excluded. Half tests ran
in-process with KORNIA_TEST_IN_SUBPROCESS=1, followed by isolated retries of failures; two homography tests were
deselected. They are not a measurement of the current branch. Those two tests (TestFindHomographyDLT::test_nocrash
and test_nocrash_lu) now pass locally in all three CUDA dtypes at 649b3f86d; a fresh full CUDA sweep is needed
before quoting new totals.
For CUDA half tests, use --isolate-half-precision so each test gets a fresh process. They are skipped by default
without it; selecting a half dtype alone does not exercise CUDA half support:
pixi run test-module tests/color/ --device=cuda --dtype=float16,bfloat16 --isolate-half-precisionSee the full precision guide for details.
Sponsorship
Kornia is an open-source project that is developed and maintained by volunteers. Whether you're using it for research or commercial purposes, consider sponsoring or collaborating with us. Your support will help ensure Kornia's growth and ongoing innovation. Reach out to us today and be a part of shaping the future of this exciting initiative!
Installation
From pip
pip install korniaSome features (ONNX, Stable Diffusion dissolving) need extra packages; see Optional extras.
Other installation options
From source with editable mode
pip install -e .For development with Pixi (Recommended)
For development, Kornia uses pixi for fast Python package management and environment management. The project includes a pixi.toml configuration file for reproducible dependency management.
# Install pixi (if not already installed)
curl -fsSL https://pixi.sh/install.sh | bash
# Create the Pixi environment and install development dependencies
pixi install
pixi run -e default install
# Run tests
pixi run test
# For CUDA development
pixi run -e cuda install
pixi run -e cuda test-cuda
These commands set up a complete development environment with all dependencies. For more details on dependency management and available tasks, see CONTRIBUTING.md.
From Github url (latest version)
pip install git+https://github.com/kornia/korniaQuick Start
Kornia is not just another computer vision library — it's your gateway to effortless Computer Vision and AI.
Get started with Kornia image transformation and augmentation!
import numpy as np
import kornia_rs as kr
from kornia.augmentation import AugmentationSequential, RandomAffine, RandomBrightness
from kornia.filters import StableDiffusionDissolving
Load and prepare your image
img: np.ndarray = kr.read_image_any("img.jpeg")
img = kr.resize(img, (256, 256), interpolation="bilinear")
alternatively, load image with PIL
img = Image.open("img.jpeg").resize((256, 256))
img = np.array(img)
img = np.stack([img] * 2) # batch images
Define an augmentation pipeline
augmentation_pipeline = AugmentationSequential(RandomAffine((-45.0, 45.0), p=1.0), RandomBrightness((0.0, 1.0), p=1.0))
Leveraging StableDiffusion models
dslv_op = StableDiffusionDissolving()
img = augmentation_pipeline(img)
dslv_op(img, step_number=500)
dslv_op.save("Kornia-enhanced.jpg")
Find out Kornia ONNX models with ONNXSequential!
import numpy as np
from kornia.onnx import ONNXSequential
Chain ONNX models from HuggingFace repo and your own local model together
onnx_seq = ONNXSequential(
"hf://operators/kornia.geometry.transform.flips.Hflip",
"hf://models/kornia.models.detection.rtdetr_r18vd_640x640", # Or you may use "YOUR_OWN_MODEL.onnx"
)
Prepare some input data
input_data = np.random.randn(1, 3, 384, 512).astype(np.float32)
Perform inference
outputs = onnx_seq(input_data)
Print the model outputs
print(outputs)
Export a new ONNX model that chains up all three models together!
onnx_seq.export("chained_model.onnx")Call For Contributors
If kornia is useful to you and you would like to help, contributions of many kinds are welcome: code, bug reports, benchmarks, documentation, questions, answers, and examples. The maintainers have limited time, so we cannot promise that every proposal or pull request will be reviewed or merged.
Strengthen the Core (Priority)
Kornia's differentiated value is its geometry core: warping and sampling, homographies, cameras, epipolar geometry, rotations and Lie groups, and geometry-consistent augmentation. The highest-impact contributions make that core more trustworthy — see the Roadmap for the full picture. Great entry points:
- Benchmark results from your hardware: run the benchmark suite with
--contributeand send the JSON — CUDA numbers from diverse GPUs are especially useful. - Convention pinning tests and conformance vectors for core geometry operations.
- Corrective error messages: upgrade bare shape assertions into errors that state what was wrong, what was expected, and which convention applies.
- Classical vision in the core domain: camera intrinsic calibration, fiducial markers (ArUco/ChArUco), classical tracking, dense stereo, and Hough transforms. An early design discussion can be useful for work of this size.
AI Models
The model zoo is currently frozen for expansion while maintainer bandwidth concentrates on the core. Shipped models (LoFTR, LightGlue, DISK, DeDoDe, SAM, and friends) stay available and maintained, and model work approved before the freeze (Efficient LoFTR, SANDesc) will be completed under its existing scope. New integrations — including VLM/VLA models — require a named maintainer sponsor who accepts ongoing ownership of the integration; a contributor implementation alone cannot reopen the surface. See the Roadmap for the reasoning and the reopen condition.
Documentation And Tutorial Optimization
Kornia's foundation lies in its extensive collection of classic computer vision operators, providing robust tools for image processing, feature extraction, and geometric transformations. We continuously seek for contributors to help us improve our documentation and present nice tutorials to our users.
Cite
If you are using kornia in your research-related documents, it is recommended that you cite the paper. See more in CITATION.
@inproceedings{eriba2019kornia,
author = {E. Riba, D. Mishkin, D. Ponsa, E. Rublee and G. Bradski},
title = {Kornia: an Open Source Differentiable Computer Vision Library for PyTorch},
booktitle = {Winter Conference on Applications of Computer Vision},
year = {2020},
url = {https://arxiv.org/pdf/1910.02190.pdf}
}Contributing
See CONTRIBUTING.md for our social contract, development setup, and technical guidelines. Participation is subject to the Code of Conduct.
Community
- Discord: talk with people who use and develop kornia. Join the server
- GitHub Issues: report bugs and propose concrete changes. Open an issue
- GitHub Discussions: ask questions and discuss implementations, research, and ideas. Join a discussion
Made with contrib.rocks.
License
Kornia is released under the Apache 2.0 license. See the LICENSE file for more information.