# PopSift: A CUDA SIFT Implementation for Real-Time Feature Extraction

> PopSift is a CUDA implementation of the SIFT algorithm that stays close to Lowe's original paper. It is built for engineers who need GPU-accelerated keypoint extraction and are willing to accept NVIDIA-only hardware and a C++ build toolchain.

**alicevision/popsift** — PopSift is an implementation of the SIFT algorithm in CUDA.

- Repository: https://github.com/alicevision/popsift
- Website: https://popsift.readthedocs.io
- Stars: 501 · Forks: 123
- Language: Cuda
- License: MPL-2.0
- Published: 2026-09-17 · Updated: 2026-09-17 · Language: en
- Canonical page: https://hysenlabs.com/projects/alicevision-popsift

## What problem PopSift solves and who it is for

SIFT extracts scale-invariant keypoints and descriptors from images. The original algorithm is computationally heavy, and CPU implementations struggle to keep up with real-time video or large image batches. PopSift moves the SIFT pipeline onto the GPU using CUDA, and the README states it extracts features from an image in real time at least on an NVidia GTX 980 Ti GPU.

The intended user is a C++ developer working on computer vision, structure-from-motion, or image matching who has an NVIDIA GPU available. PopSift is not a Python library. The RELATED SEARCHES list includes "Popsift python" and "Pypopsift", but the repository itself provides no Python bindings. If you want Python, you would have to write your own bindings or look elsewhere. The project is developed within the POPART project, and its primary artifact is a C++ library called libpopsift.

A second audience is anyone who needs SIFT output that matches a specific reference implementation. The README says PopSift can be configured at runtime to generate results very similar to VLFeat or results closer to the SIFT implementation of the OpenCV extras. That configurability is unusual and matters when downstream code expects a particular descriptor distribution.

## How the CUDA SIFT pipeline works in PopSift

The caller creates a popart::Config struct, documented in src/sift/sift_conf.h, and instantiates a PopSift object from src/sift/popsift.h. Images are then submitted through enqueue(). A valid input is a single plane of grayscale values in host memory, either a pointer to unsigned char with a range of 0 to 255 or a pointer to float with a range of 0.0f to 1.0f.

The enqueue function returns a pointer to a SiftJob immediately and performs the feature extraction asynchronously. Only host memory limits how many images can be enqueued. The memory of the image passed to enqueue remains the caller's responsibility, which is a real constraint: you cannot free or reuse that buffer until the job completes. Calling SiftJob::get on the returned job blocks until features are extracted and returns them.

Features offer iterators over objects of type Feature, both documented in sift_extremum.h. Each feature represents a feature point in the input image coordinate system, providing X and Y coordinates and scale (sigma), plus several alternative descriptors. According to the README, about 15 percent of feature points should be expected to have two or more descriptors, following Lowe.

There is also a deprecated blocking API. In that path, init() must be called to pass image width and height to PopSift, followed by a call to executed() that takes image data and returns the extracted features. The README notes that execute() is synchronous and blocking. New code should use the asynchronous enqueue path.

## Building PopSift from source with CMake

PopSift depends on a host compiler that supports C++14 for CUDA SDK 9.0 or newer and C++11 for CUDA SDK 8, plus CUDA 8.0 or later. Boost 1.71 or newer is optional and only needed for the provided applications, with the components atomic, chrono, date-time, system and thread. DevIL (libdevil-dev) is optional and expands image format support beyond pgm.

The README gives this build sequence:

```bash
mkdir build && cd build
cmake ..
make
make install
```

Two build options are documented. PopSift_BUILD_EXAMPLES defaults to ON and controls the showcase applications. BUILD_SHARED_LIBS defaults to ON and selects shared libraries; set it to OFF for static.

The repository also contains a Dockerfile that builds from alicevision/popsift-deps. It accepts CUDA_TAG and OS_TAG build arguments, defaulting to 10.2 and 18.04. The README does not document rollback, so if a build fails after a dependency change you are on your own to reconstruct the previous state.

## Linking libpopsift into your own CMake project

The main artifact is libpopsift. To consume it from another CMake project, the README shows a find_package call against PopSiftConfig.cmake in <prefix>/lib/cmake/PopSift/, which exposes the target PopSift::popsift under the PopSift:: namespace:

```cmake
find_package(PopSift CONFIG REQUIRED)
add_executable(poptest yourfile.cpp)
target_link_libraries(poptest PUBLIC PopSift::popsift)
```

Then point CMake at the config file location on the command line:

```bash
cmake .. -DPopSift_DIR=<prefix>/lib/cmake/PopSift/
```

If PopSift_BUILD_EXAMPLES is ON, the test application popsift-demo is created. Calling popsift-demo without parameters shows the options. That is the fastest way to confirm the build produced a working binary before you write integration code.

## Where PopSift is the wrong tool

The hardware requirement is the first filter. PopSift compiles and works with NVidia cards of compute capability 3.0 or higher, including the GT 650M, but the code is developed with the compute capability 5.2 card GTX 980 Ti in mind. The README also warns that CUDA SDK 11 no longer supports compute capability 3.0, and 3.5 is still supported with deprecation warnings. If your deployment target is an older GPU paired with a newer toolkit, you may be unable to build at all.

Non-NVIDIA hardware is out. There is no CPU fallback documented, and no OpenCL or ROCm path in the repository. If you need to run SIFT on a machine without a CUDA-capable GPU, PopSift cannot help.

The asynchronous API has a sharp edge. Because the caller retains ownership of the input image buffer, a program that enqueues and then mutates or frees that buffer can produce incorrect results. The README does not describe a copy-into-library mode. The deprecated execute() path avoids this by blocking, at the cost of throughput.

Finally, the project's own README acknowledges that there is at least one SIFT implementation that is vastly faster, but it makes considerable sacrifices in terms of accuracy and compatibility. If raw speed is your only metric and descriptor fidelity does not matter, PopSift is not the fastest option available.

## PopSift compared with OpenCV and VLFeat SIFT

OpenCV's SIFT implementation and VLFeat's are the natural reference points, and PopSift positions itself relative to both. The difference is in the execution model and the compatibility target. OpenCV's SIFT runs on the CPU by default and is widely available through Python bindings, which is why "How can I use the SIFT detector in OpenCV?" appears in the search questions. PopSift has no Python bindings in the repository, so the OpenCV path is the practical choice if you are working in Python.

VLFeat is a CPU library with a mature SIFT implementation. PopSift's README states that users can configure it at runtime to generate results very similar to VLFeat. That means PopSift can act as a drop-in accelerator for a VLFeat-based pipeline, provided you accept the GPU dependency and the C++ integration work. The trade-off is that you now manage CUDA versions, driver compatibility and GPU memory alongside your existing stack.

The honest summary is that PopSift trades portability for throughput and fidelity to Lowe's paper. OpenCV and VLFeat trade throughput for reach. If your pipeline already runs on CPU and meets its latency budget, moving to PopSift adds build and deployment complexity for a speed gain you may not need.

## Licence, patent history and upgrade cost

PopSift is licensed under MPL v2. The README is explicit that the PopSift license only concerns the PopSift source code and does not release users from any requirements that may arise from patents. SIFT was patented in the United States from 1999-03-08 to 2020-03-28, and the README links to the patent. That patent term has expired, but the README's wording is a reminder that the project does not offer legal cover. This is not legal advice; check your own situation.

MPL v2 is file-level copyleft. Modifications to PopSift's own files must be shared under the same license, but code that merely links against libpopsift can remain under other terms. That is a meaningful difference from GPL for a library meant to be embedded.

On upgrade cost: the release history is uneven. v1.0.0-rc2 and v1.0.0-rc3 landed in October 2020, and the next listed release is v0.10.0 in October 2025. The version numbering does not follow a simple ascending line, so pinning to a specific tag and reading CHANGES.md before upgrading is the sensible approach. The last push to the repository was on 2026-09-09. The README does not document a migration guide between releases.

## Conclusion

Adopt PopSift if you need a faithful SIFT implementation on an NVIDIA GPU and can build a C++14 project with CUDA 8.0 or newer. Do not adopt it if you need CPU-only operation, non-NVIDIA hardware, or a Python-native API, because the repository provides no Python bindings. Before committing, verify that your GPU compute capability is at least 3.0, that your CUDA toolkit still supports that target, and that the descriptor compatibility mode you need (VLFeat-like or OpenCV-like) is available in the version you build. The project's own README states that it tries to stick closely to Lowe's paper, so if you need a different accuracy profile, check the runtime configuration in src/sift/sift_conf.h first.

## FAQ

### Can you explain how SIFT works?

SIFT extracts scale-invariant keypoints from an image and assigns descriptors to them. PopSift follows David Lowe's 2004 paper closely, and its README states that each feature gives X and Y coordinates, a scale (sigma), and several alternative descriptors.

### Is SIFT still patented?

The PopSift README states that SIFT was patented in the United States from 1999-03-08 to 2020-03-28, so that term has expired. The README also notes that the PopSift license only covers the source code and does not release users from any requirements that may arise from patents.

### How do I extract SIFT features from an image?

With PopSift, you create a popart::Config struct and a PopSift object, then call enqueue() with a single plane of grayscale values in host memory, either unsigned char from 0 to 255 or float from 0.0f to 1.0f. The call returns a SiftJob, and SiftJob::get blocks until features are returned.

### How can I use the SIFT detector in OpenCV?

PopSift is not an OpenCV module, but its README states it can be configured at runtime to produce results closer to the SIFT implementation of the OpenCV extras. If you want OpenCV's own SIFT detector, PopSift does not provide it; the two are separate codebases.

## Sources

- [alicevision/popsift on GitHub](https://github.com/alicevision/popsift)
- [License: MPL-2.0](https://github.com/alicevision/popsift/blob/develop/LICENSE)
- [Project website](https://popsift.readthedocs.io)
- [README](https://github.com/alicevision/popsift/blob/develop/README.md)
- [Releases](https://github.com/alicevision/popsift/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/alicevision-popsift