An OpenVX 1.3.1 implementation written in Rust. rustVX provides the complete OpenVX Vision Feature Set through a standard C API (libopenvx_ffi), enabling existing OpenVX applications to use a memory-safe, portable backend with no source changes.

rustVX passes the full Khronos OpenVX 1.3 Conformance Test Suite for both required profiles, plus an opt-in slice of the Enhanced Vision profile:

The remaining Enhanced Vision kernels (BilateralFilter, TensorOp, HOGCells, HOGFeatures, ControlFlow/Select, ScalarOperation) are tracked as follow-up phases. All implemented Enhanced Vision kernels are exercised in CI with -DOPENVX_USE_ENHANCED_VISION=ON.

Latest CTS run results are published on each push and pull request via the Actions tab.

rustVX/
├── openvx-core/       # Core framework: context, graph, node, types, C API
├── openvx-image/      # Image data object and channel operations
├── openvx-buffer/     # Generic buffer for intermediate data
├── openvx-vision/     # All vision kernels (filters, geometric, features, etc.)
├── openvx-ffi/        # C shared library (cdylib) exporting the full OpenVX API
├── include/VX/        # Standard OpenVX C headers
└── OpenVX-cts/        # Khronos Conformance Test Suite (git submodule)

The workspace compiles into a single shared library (libopenvx_ffi.so / .dylib / .dll) that any OpenVX application can link against.

# Clone with submodules
git clone --recurse-submodules https://github.com/kiritigowda/rustVX.git
cd rustVX

# Build the library
cargo build --release

The shared library is produced at:

The standard OpenVX 1.3 C headers are bundled in include/VX/ and can be passed to your C/C++ build directly.

Both openvx-core (host of the C-API kernel callbacks the OpenVX graph executor invokes) and openvx-vision (host of the public Rust API kernels) expose a matching opt-in feature set:

Build with the matching pair on each crate so the FFI graph path and the direct Rust API path both pick up the SIMD kernels:

cargo build --release -p openvx-ffi \
  --features "openvx-core/sse2 openvx-core/avx2 openvx-vision/sse2 openvx-vision/avx2"

Performance work targets AMD Zen (Ryzen / EPYC, Zen 2+) — that's what CI measures and what the Benchmark & compare numbers come from. Intel and ARM aren't penalised; the runtime dispatcher reads CPU flags, not vendor strings, so any host whose flags match the same gate runs the same path:

• AMD Zen 2+ (Ryzen 3000+, Threadripper 3000+, EPYC Rome / Milan / Genoa) → AVX2 kernels + -C target-cpu=x86-64-v3 auto-vec.
• Intel Haswell and later → same AVX2 path, parity with Zen.
• Older x86_64 (pre-AVX2) → SSE2 kernels + -C target-cpu=x86-64-v2.
• AArch64 (Apple Silicon, AWS Graviton, etc.) → NEON path.
• Anything else / no features → scalar slice loop (still ~50× faster than the original per-pixel kernels).

Dispatch lives in openvx-core::simd_kernels (FFI graph path) and openvx-vision::x86_64_simd (Rust API). CI auto-detects host flags; for a manual Zen-targeted build:

RUSTFLAGS="-C target-cpu=x86-64-v3" \
  cargo build --release -p openvx-ffi \
    --features "openvx-core/sse2 openvx-core/avx2 \
                openvx-vision/sse2 openvx-vision/avx2"

libopenvx_ffi exports the full vx* / vxu* symbol set defined by the standard OpenVX headers, so existing OpenVX code links against it with no source changes. A minimal example:

#include <VX/vx.h>

int main(void) {
    vx_context ctx = vxCreateContext();
    vx_graph   g   = vxCreateGraph(ctx);
    /* ... build graph, call vxVerifyGraph / vxProcessGraph ... */
    vxReleaseGraph(&g);
    vxReleaseContext(&ctx);
    return 0;
}

# Linux
gcc app.c -I rustVX/include -L rustVX/target/release -lopenvx_ffi -o app
LD_LIBRARY_PATH=rustVX/target/release ./app

For drop-in compatibility with build systems that look for libopenvx / libvxu (e.g. find_library(NAMES openvx vxu)), symlink the rustVX library to those names:

ln -s libopenvx_ffi.so target/release/libopenvx.so
ln -s libopenvx_ffi.so target/release/libvxu.so

The Khronos OpenVX Conformance Test Suite is included as a git submodule. Build and run it against the rustVX library:

# Build the CTS
cd OpenVX-cts
mkdir -p build && cd build
cmake .. \
  -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_POLICY_VERSION_MINIMUM=3.5 \
  -DCMAKE_C_STANDARD_LIBRARIES="-lm" \
  -DCMAKE_CXX_STANDARD_LIBRARIES="-lm" \
  -DOPENVX_INCLUDES="$(pwd)/../../include;$(pwd)/../include" \
  -DOPENVX_LIBRARIES="$(pwd)/../../target/release/libopenvx_ffi.so;m" \
  -DOPENVX_CONFORMANCE_VISION=ON
make -j$(nproc)

# Run all tests
export LD_LIBRARY_PATH=$(pwd)/../../target/release
export VX_TEST_DATA_PATH=$(pwd)/../test_data/
./bin/vx_test_conformance

# Build the CTS
cd OpenVX-cts
mkdir -p build && cd build
cmake .. \
  -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_POLICY_VERSION_MINIMUM=3.5 \
  -DOPENVX_INCLUDES="$(pwd)/../../include;$(pwd)/../include" \
  -DOPENVX_LIBRARIES="$(pwd)/../../target/release/libopenvx_ffi.dylib" \
  -DOPENVX_CONFORMANCE_VISION=ON
make -j$(sysctl -n hw.ncpu)

# Run all tests
export DYLD_LIBRARY_PATH=$(pwd)/../../target/release
export VX_TEST_DATA_PATH=$(pwd)/../test_data/
./bin/vx_test_conformance

# Build the CTS
cd OpenVX-cts
mkdir build; cd build
cmake .. `
  -DCMAKE_BUILD_TYPE=Release `
  -DCMAKE_POLICY_VERSION_MINIMUM=3.5 `
  -DOPENVX_INCLUDES="$PWD\..\..\include;$PWD\..\include" `
  -DOPENVX_LIBRARIES="$PWD\..\..\target\release\openvx_ffi.dll.lib" `
  -DOPENVX_CONFORMANCE_VISION=ON
cmake --build . --config Release

# Run all tests
$env:PATH = "$PWD\..\..\target\release;$env:PATH"
$env:VX_TEST_DATA_PATH = "$PWD\..\test_data\"
.\bin\Release\vx_test_conformance.exe

Use the --filter flag to run a subset of tests:

# Run only filter tests
./bin/vx_test_conformance --filter="Gaussian3x3.*:Median3x3.*:Box3x3.*"

# Run only feature detection tests
./bin/vx_test_conformance --filter="HarrisCorners.*:FastCorners.*:vxCanny.*"

Beyond the Khronos CTS, rustVX has its own Rust-side test and benchmark suites:

# Run all unit and integration tests
cargo test --workspace --release

# Run the Criterion micro-benchmarks for vision kernels
cargo bench -p openvx-vision

End-to-end performance is also tracked against the Khronos OpenVX sample implementation on every CI run via openvx-mark; see the Benchmark & compare job in the Actions tab for the latest comparison report.

GitHub Actions builds and runs the full CTS on every push and pull request. The workflow splits the suite into parallel jobs for faster feedback:

Job	Test categories	Pipeline status
baseline	GraphBase, Logging, SmokeTest, Target
graph	Graph framework (cycles, virtual data, multi-run, replicate node), GraphCallback, GraphDelay, GraphROI, UserNode
data-objects	Scalar, Array, ObjectArray, Matrix, Convolution, Distribution, LUT, Histogram
image-ops	Image, CopyImagePatch, MapImagePatch, CreateImageFromChannel, Remap
vision-color	ColorConvert, ChannelExtract, ChannelCombine, ConvertDepth
vision-filters	Box, Gaussian, Median, Dilate, Erode, Sobel, Magnitude, Phase, NonLinearFilter, Convolve, EqualizeHistogram
vision-arithmetic	Add, Subtract, Multiply, Bitwise (And/Or/Xor/Not), WeightedAverage, Threshold
vision-geometric	Scale, WarpAffine, WarpPerspective, Remap, HalfScaleGaussian
vision-features	HarrisCorners, FastCorners, Canny
vision-statistics	MeanStdDev, MinMaxLoc, Integral
vision-pyramid	GaussianPyramid, LaplacianPyramid, LaplacianReconstruct, OptFlowPyrLK
enhanced-vision	Copy, NonMaxSuppression, HoughLinesP, MatchTemplate, LBP, Min, Max (106 tests)

See the Actions tab for full run history.

Contributions, bug reports, and feature requests are welcome.

• Found a bug or have a question? Open an issue.
• Want to contribute a fix or new kernel? Fork the repo, create a topic branch, and open a pull request against main. CI must pass — both the Khronos CTS jobs and the rustVX-vs-Khronos benchmark comparison run on every PR.
• Please make sure cargo fmt, cargo clippy --workspace --all-targets, and cargo test --workspace pass locally before submitting.

This project is licensed under the MIT License.

The OpenVX logo is a trademark of The Khronos Group Inc. The vector logo file in docs/openvx-logo.svg is sourced from Wikimedia Commons and is included for identification purposes only.