Enable GENAI with FetchContent or find_package() for client projects

.gitignore

@@ -8,13 +8,15 @@
 *obj/
 src/csharp/AssemblyInfo.cs
 /ort
-/build
 /build_*
+build*/
+/test/test_models/*
 /test/models/*
 /cache_models
 /onnxruntime-linux-x64-*
 *.csv
 .idea
+.venv
 cache_dir
 example-models
 *.onnx
@@ -46,4 +48,4 @@ examples/csharp/ModelChat/models
 /src/java/local.properties
 /src/java/build
 /src/java/CMakeFiles
-/src/java/CMakeCache.txt
+/src/java/CMakeCache.txt

CMakeLists.txt

@@ -8,9 +8,13 @@ else()
   cmake_minimum_required(VERSION 3.26)
 endif()
 
+include(cmake/version.cmake)
+
+project(Generators VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH} LANGUAGES C CXX)
+
+include(GNUInstallDirs)
 include(FetchContent)
 include(CMakeDependentOption)
-project(Generators LANGUAGES C CXX)
 
 # All Options should be defined in cmake/options.cmake This must be included before any other cmake file is included
 include(cmake/options.cmake)
@@ -98,7 +102,6 @@ endif()
 
 include(cmake/ortlib.cmake)
 
-
 include(cmake/external/onnxruntime_external_deps.cmake)
 # All Global variables, including GLOB, for the top level CMakeLists.txt should be defined here
 include(cmake/global_variables.cmake)
@@ -158,23 +161,36 @@ find_package(Threads REQUIRED)
 if(WIN32)
   add_library(onnxruntime-genai SHARED ${generator_srcs} "${GENERATORS_ROOT}/dll/onnxruntime-genai.rc")
   target_compile_definitions(onnxruntime-genai PRIVATE VERSION_INFO=\"${VERSION_INFO}\")
-  target_compile_definitions(onnxruntime-genai PRIVATE VERSION_MAJOR=${VERSION_MAJOR})
-  target_compile_definitions(onnxruntime-genai PRIVATE VERSION_MINOR=${VERSION_MINOR})
-  target_compile_definitions(onnxruntime-genai PRIVATE VERSION_PATCH=${VERSION_PATCH})
+  target_compile_definitions(onnxruntime-genai PRIVATE VERSION_MAJOR=${PROJECT_VERSION_MAJOR})
+  target_compile_definitions(onnxruntime-genai PRIVATE VERSION_MINOR=${PROJECT_VERSION_MINOR})
+  target_compile_definitions(onnxruntime-genai PRIVATE VERSION_PATCH=${PROJECT_VERSION_PATCH})
   target_compile_definitions(onnxruntime-genai PRIVATE VERSION_SUFFIX=${VERSION_SUFFIX})
   target_compile_definitions(onnxruntime-genai PRIVATE FILE_NAME=\"onnxruntime-genai.dll\")
 else()
   add_library(onnxruntime-genai SHARED ${generator_srcs})
+  set_target_properties(onnxruntime-genai PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR})
 endif()
 
+target_include_directories(onnxruntime-genai INTERFACE
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src> $<INSTALL_INTERFACE:include>)
+
 target_include_directories(onnxruntime-genai PRIVATE ${ORT_HEADER_DIR})
 target_include_directories(onnxruntime-genai PRIVATE ${onnxruntime_extensions_SOURCE_DIR}/shared/api)
 target_link_libraries(onnxruntime-genai PRIVATE onnxruntime_extensions)
 target_link_directories(onnxruntime-genai PRIVATE ${ORT_LIB_DIR})
 target_link_libraries(onnxruntime-genai PRIVATE Threads::Threads)
 
 # The genai library itself is always embedded in the shared library
-list(APPEND ortgenai_embed_libs "$<TARGET_FILE:onnxruntime-genai>")
+if(WIN32 OR ANDROID OR IOS)
+  list(APPEND ortgenai_embed_libs "$<TARGET_FILE:onnxruntime-genai>")
+else()
+  if (ENABLE_PYTHON)
+    list(APPEND python_embed_libs "$<TARGET_SONAME_FILE:onnxruntime-genai>")
+  endif()
+  if (ENABLE_JAVA)
+    list(APPEND java_embed_libs "$<TARGET_LINKER_FILE:onnxruntime-genai>")
+  endif()
+endif()
 
 # we keep the shared libraries disconnected on Android as they will come from separate AARs and we don't want to force
 # the ORT version to match in both.
@@ -191,7 +207,6 @@ if(APPLE)
 target_link_libraries(onnxruntime-genai PRIVATE "-framework Foundation" "-framework CoreML")
 endif()
 
-
 # Build all source files using CUDA as a separate shared library we dynamically load at runtime
 if((USE_CUDA OR USE_TRT_RTX) AND CMAKE_CUDA_COMPILER)
   # Suppress nvcc warnings:
@@ -241,9 +256,8 @@ if((USE_CUDA OR USE_TRT_RTX) AND CMAKE_CUDA_COMPILER)
   endif()
 endif()
 
-
 if(USE_GUIDANCE)
-  target_include_directories(onnxruntime-genai PUBLIC ${llguidance_SOURCE_DIR}/parser/)
+  target_include_directories(onnxruntime-genai PRIVATE ${llguidance_SOURCE_DIR}/parser/)
   target_link_libraries(onnxruntime-genai PRIVATE llguidance)
   if (WIN32)
     # bcrypt is needed for the rust std lib

benchmark/c/CMakeLists.txt

@@ -21,13 +21,7 @@ endif()
 
 add_executable(model_benchmark ${model_benchmark_srcs})
 
-target_include_directories(model_benchmark PRIVATE
-  ${CMAKE_CURRENT_SOURCE_DIR}
-  ${CMAKE_SOURCE_DIR}/src  # directory containing the ort_genai headers
-)
-
-target_link_libraries(model_benchmark PRIVATE onnxruntime-genai ${ONNXRUNTIME_LIB})
-
-target_link_directories(model_benchmark PRIVATE ${ORT_LIB_DIR})
+target_link_libraries(model_benchmark PRIVATE onnxruntime-genai)
+target_include_directories(model_benchmark PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${model_benchmark_srcs})

build.py

@@ -85,6 +85,7 @@ class HelpFormatter(argparse.ArgumentDefaultsHelpFormatter, argparse.RawDescript
 
     # Default to not building the language bindings
     parser.add_argument("--build_csharp", action="store_true", help="Build the C# API.")
+    parser.add_argument("--msbuild_extra_options", nargs="+", action="extend", default=[], help="Extra MSBuild properties (/p:key=value). Provide as key=value.")
     parser.add_argument("--build_java", action="store_true", help="Build Java bindings.")
     parser.add_argument(
         "--publish_java_maven_local",
@@ -403,9 +404,11 @@ def _get_csharp_properties(args: argparse.Namespace, ort_lib_dir: Path):
     )
     ort_lib_path = f"/p:OrtLibDir={ort_lib_dir}"
 
-    props = [configuration, platform, native_lib_path, ort_lib_path]
+    msbuild_extra_options = list(args.msbuild_extra_options)
+    if args.config == "Release" and not [opt for opt in msbuild_extra_options if 'IsReleaseBuild' in opt]:
+        msbuild_extra_options.append("IsReleaseBuild=True")
 
-    return props
+    return [configuration, platform, native_lib_path, ort_lib_path] + ["/p:" + option for option in msbuild_extra_options]
 
 
 def _run_android_tests(args: argparse.Namespace):
@@ -652,6 +655,9 @@ def _get_opencv_toolchain_file():
             )
             args.test = False
 
+    if util.is_windows() and 'Ninja' in args.cmake_generator:
+        command += ["--compile-no-warning-as-error"]
+
     if args.cmake_extra_defines != []:
         command += args.cmake_extra_defines
 
@@ -762,13 +768,18 @@ def build_examples(args: argparse.Namespace, env: dict[str, str]):
     Build the examples.
     """
     examples_dir = REPO_ROOT / "examples" / "c"
-    build_dir = examples_dir / "build"
-
-    if build_dir.exists():
-        log.info(f"Removing existing build directory: {build_dir}")
-        shutil.rmtree(build_dir)
-
-    build_dir.mkdir()
+    build_dir = examples_dir / "build" / args.config
+
+    # Removing the build directory will no longer work because of
+    # the FetchContent used in the examples. It creates the _deps/
+    # directory, which contains .git/ subdirectories. Removing those
+    # requires elevated privileges.
+    # if build_dir.exists():
+    #     log.info(f"Removing existing build directory: {build_dir}")
+    #     shutil.rmtree(build_dir)
+    #
+    # Do not need to create build dir manually. CMake will do that.
+    # build_dir.mkdir(parents=True)
 
     samples_to_build = [
         "-DMODEL_QA=ON",
@@ -778,31 +789,50 @@ def build_examples(args: argparse.Namespace, env: dict[str, str]):
         "-DNEMOTRON_SPEECH=ON"
     ]
 
-    ort_include_dir = REPO_ROOT / "ort" / "include"
-    ort_lib_dir = REPO_ROOT / "ort" / "lib"
-    oga_include_dir = REPO_ROOT / "src"
-    oga_lib_dir = args.build_dir
-    if util.is_windows():
-        # On Windows, the library files are in a subdirectory named after the configuration (e.g. Debug, Release, etc.)
-        oga_lib_dir = oga_lib_dir / args.config
+    cmake_prefix_path = args.build_dir.as_posix()
+    if args.ort_home:
+        cmake_prefix_path += ";" + (args.ort_home / args.config).as_posix()
+    else:
+        ortlib_src_dir = args.build_dir / "_deps" / "ortlib-src"
+        ort_include_dir = REPO_ROOT / "ort" / "include"
+        if not ort_include_dir.exists():
+            ort_include_dir = ortlib_src_dir / "build" / "native" / "include"
+        ortlib_runtimes_dir = ortlib_src_dir / "runtimes"
+        ort_lib_dir = REPO_ROOT / "ort" / "lib"
+        if not ort_lib_dir.exists():
+            if util.is_windows_arm() or (util.is_windows() and (args.arm64 or args.arm64ec)):
+                ort_lib_dir = ortlib_runtimes_dir / "win-arm64"
+            elif util.is_windows():
+                ort_lib_dir = ortlib_runtimes_dir / "win-x64"
+            elif args.android:
+                ort_lib_dir = ortlib_runtimes_dir / "android"
+            elif util.is_linux_arm() or (util.is_linux() and (args.arm64 or args.arm64ec)):
+                ort_lib_dir = ortlib_runtimes_dir / "linux-arm64"
+            elif util.is_linux():
+                ort_lib_dir = ortlib_runtimes_dir / "linux-x64"
+            elif util.is_mac() or args.macos:
+                ort_lib_dir = ortlib_runtimes_dir / "osx-arm64"
+            elif args.ios:
+                ort_lib_dir = ortlib_runtimes_dir / "ios"
+            elif not util.is_aix():
+                raise RuntimeError("'{}': unsupported operating system to build examples for".format(sys.platform))
+        samples_to_build += [
+            "-DORT_INCLUDE_DIR=" + ort_include_dir.as_posix(),
+            "-DORT_LIB_DIR=" + (ort_lib_dir / "native").as_posix()
+        ]
 
     cmake_command = (
         [
-            str(args.cmake_path),
+            args.cmake_path.as_posix(),
             "-S",
-            str(examples_dir),
+            examples_dir.as_posix(),
             "-B",
-            str(build_dir),
+            build_dir.as_posix(),
             "-G",
             args.cmake_generator,
+            "-DCMAKE_PREFIX_PATH=" + cmake_prefix_path
         ]
         + samples_to_build
-        + [
-            "-DORT_INCLUDE_DIR=" + str(ort_include_dir),
-            "-DORT_LIB_DIR=" + str(ort_lib_dir),
-            "-DOGA_INCLUDE_DIR=" + str(oga_include_dir),
-            "-DOGA_LIB_DIR=" + str(oga_lib_dir),
-        ]
     )
 
     if args.cmake_generator.startswith("Visual Studio"):
@@ -811,7 +841,7 @@ def build_examples(args: argparse.Namespace, env: dict[str, str]):
         elif args.arm64ec:
             cmake_command += ["-A", "ARM64EC"]
 
-    if args.cmake_extra_defines != []:
+    if args.cmake_extra_defines:
         cmake_command += args.cmake_extra_defines
 
     util.run(cmake_command, env=env)

cmake/global_variables.cmake

@@ -1,30 +1,6 @@
 # All Global variables for the top level CMakeLists.txt should be defined here
 
-# Define the Version Info
-file(READ "VERSION_INFO" ver)
-set(VERSION_INFO ${ver})
-
-# Example:
-# VERSION_INFO: 0.4.0-dev
-# VERSION_STR: 0.4.0
-# VERSION_SUFFIX: dev
-# VERSION_MAJOR: 0
-# VERSION_MINOR: 4
-# VERSION_PATCH: 0
-string(REPLACE "-" ";" VERSION_LIST ${VERSION_INFO})
-list(GET VERSION_LIST 0 VERSION_STR)
-# Check if it is a stable or dev version
-list(LENGTH VERSION_LIST VERSION_LIST_LENGTH)
-if(VERSION_LIST_LENGTH GREATER 1)
-    list(GET VERSION_LIST 1 VERSION_SUFFIX)
-else()
-    set(VERSION_SUFFIX "")  # Set VERSION_SUFFIX to empty if stable version
-endif()
-string(REPLACE "." ";" VERSION_LIST ${VERSION_STR})
-list(GET VERSION_LIST 0 VERSION_MAJOR)
-list(GET VERSION_LIST 1 VERSION_MINOR)
-list(GET VERSION_LIST 2 VERSION_PATCH)
-
+include_guard()
 
 # Define the project directories
 set(REPO_ROOT ${PROJECT_SOURCE_DIR})
@@ -102,8 +78,8 @@ if (IOS OR MAC_CATALYST)
 elseif (USE_WINML)
     message(STATUS "Using WinML, does NOT include ONNX Runtime library, is provied by Windows.")
 else()
-  if(NOT EXISTS "${ORT_LIB_DIR}/${ONNXRUNTIME_LIB}")
-    message(FATAL_ERROR "Expected the ONNX Runtime library to be found at ${ORT_LIB_DIR}/${ONNXRUNTIME_LIB}. Actual: Not found.")
+  if(NOT EXISTS "${ORT_BIN_DIR}/${ONNXRUNTIME_LIB}")
+    message(FATAL_ERROR "Expected the ONNX Runtime library to be found at ${ORT_BIN_DIR}/${ONNXRUNTIME_LIB}. Actual: Not found.")
   endif()
 endif()
 

cmake/onnxruntime-genai-config.cmake.in

@@ -0,0 +1,5 @@
+@PACKAGE_INIT@
+if (NOT TARGET onnxruntime::onnxruntime-genai)
+    include(${CMAKE_CURRENT_LIST_DIR}/onnxruntime-genai-targets.cmake)
+endif()
+check_required_components(onnxruntime-genai)