diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
index 878f0862ac990..6101bbfc2b4c7 100644
--- a/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
@@ -121,10 +121,7 @@ Section 5.8.1 of the SYCL 2020 specification.  Note that deprecated attributes
 (such as `vec_type_hint`) are not included.
 
 ```c++
-namespace sycl {
-namespace ext {
-namespace oneapi {
-namespace experimental {
+namespace sycl::ext::oneapi::experimental {
 
 // Corresponds to reqd_work_group_size
 struct work_group_size_key {
@@ -185,10 +182,7 @@ template <> struct is_property_key<work_group_size_hint_key> : std::true_type {}
 template <> struct is_property_key<sub_group_size_key> : std::true_type {};
 template <> struct is_property_key<device_has_key> : std::true_type {};
 
-} // namespace experimental
-} // namespace oneapi
-} // namespace ext
-} // namespace sycl
+} // namespace sycl::ext::oneapi::experimental
 ```
 
 |===
@@ -320,6 +314,23 @@ class handler {
                                range<dimensions> workGroupSize,
                                PropertyList properties,
                                const WorkgroupFunctionType &kernelFunc);
+
+  // Available only if all properties in `PropertList` only have launch-related
+  // effects.
+  template <typename PropertyList>
+  void single_task(PropertyList properties, const kernel& kernelObject);
+
+  // Available only if all properties in `PropertList` only have launch-related
+  // effects.
+  template <int Dimensions, typename PropertyList>
+  void parallel_for(range<Dimensions> numWorkItems, PropertyList properties,
+                    const kernel& kernelObject);
+
+  // Available only if all properties in `PropertList` only have launch-related
+  // effects.
+  template <int Dimensions, typename PropertyList>
+  void parallel_for(nd_range<Dimensions> ndRange, PropertyList properties,
+                    const kernel& kernelObject);
 }
 }
 ```
diff --git a/sycl/doc/extensions/proposed/sycl_ext_intel_fpga_kernel_interface_properties.asciidoc b/sycl/doc/extensions/proposed/sycl_ext_intel_fpga_kernel_interface_properties.asciidoc
index 73bf4a6dfdb22..13cea0f399603 100644
--- a/sycl/doc/extensions/proposed/sycl_ext_intel_fpga_kernel_interface_properties.asciidoc
+++ b/sycl/doc/extensions/proposed/sycl_ext_intel_fpga_kernel_interface_properties.asciidoc
@@ -92,7 +92,8 @@ using the mechanism defined in sycl_ext_oneapi_kernel_properties.
 === Kernel Interface Properties
 
 ```c++
-namespace sycl::ext::intel::experimental {
+namespace sycl::ext {
+namespace intel::experimental {
 
 enum class streaming_interface_options_enum {
   accept_downstream_stall,
@@ -167,11 +168,16 @@ inline constexpr fpga_cluster_key::value_t<
 inline constexpr fpga_cluster_key::value_t<
   fpga_cluster_options_enum::stall_free_clusters> stall_free_clusters;
 
-template <> struct is_property_key<streaming_interface_key> : std::true_type {};
-template <> struct is_property_key<register_map_interface_key> : std::true_type {};
-template <> struct is_property_key<fpga_cluster_key> : std::true_type {};
+} // intel::experimental
 
-} // namespace sycl::ext::intel::experimental
+namespace oneapi::experimental {
+
+template <> struct is_property_key<intel::experimental::streaming_interface_key> : std::true_type {};
+template <> struct is_property_key<intel::experimental::register_map_interface_key> : std::true_type {};
+template <> struct is_property_key<intel::experimental::fpga_cluster_key> : std::true_type {};
+
+} // intel::experimental
+} // namespace sycl::ext
 ```
 
 |===
diff --git a/sycl/include/sycl/detail/kernel_properties.hpp b/sycl/include/sycl/detail/kernel_properties.hpp
index cd1b9ef7929a2..4258b594bc69a 100644
--- a/sycl/include/sycl/detail/kernel_properties.hpp
+++ b/sycl/include/sycl/detail/kernel_properties.hpp
@@ -45,6 +45,7 @@ struct PropertyMetaInfo<sycl::detail::register_alloc_mode_key::value_t<Mode>> {
   static constexpr const char *name = "sycl-register-alloc-mode";
   static constexpr sycl::detail::register_alloc_mode_enum value = Mode;
 };
+
 } // namespace detail
 } // namespace ext::oneapi::experimental
 } // namespace _V1
diff --git a/sycl/include/sycl/ext/intel/experimental/fpga_kernel_properties.hpp b/sycl/include/sycl/ext/intel/experimental/fpga_kernel_properties.hpp
index 7628fb40bf4ca..85b125aa127cd 100644
--- a/sycl/include/sycl/ext/intel/experimental/fpga_kernel_properties.hpp
+++ b/sycl/include/sycl/ext/intel/experimental/fpga_kernel_properties.hpp
@@ -104,6 +104,15 @@ struct is_property_key_of<
     : std::true_type {};
 
 namespace detail {
+template <intel::experimental::streaming_interface_options_enum option>
+struct HasCompileTimeEffect<
+    intel::experimental::streaming_interface_key::value_t<option>>
+    : std::true_type {};
+template <intel::experimental::register_map_interface_options_enum option>
+struct HasCompileTimeEffect<
+    intel::experimental::register_map_interface_key::value_t<option>>
+    : std::true_type {};
+
 template <intel::experimental::streaming_interface_options_enum Stall_Free>
 struct PropertyMetaInfo<
     intel::experimental::streaming_interface_key::value_t<Stall_Free>> {
diff --git a/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp b/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp
index e46ab88c43172..cd805dcd8e082 100644
--- a/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp
@@ -240,6 +240,19 @@ template <> struct is_property_key<work_item_progress_key> : std::true_type {};
 
 namespace detail {
 
+template <size_t... Dims>
+struct HasCompileTimeEffect<work_group_size_key::value_t<Dims...>>
+    : std::true_type {};
+template <size_t... Dims>
+struct HasCompileTimeEffect<work_group_size_hint_key::value_t<Dims...>>
+    : std::true_type {};
+template <uint32_t Size>
+struct HasCompileTimeEffect<sub_group_size_key::value_t<Size>>
+    : std::true_type {};
+template <sycl::aspect... Aspects>
+struct HasCompileTimeEffect<device_has_key::value_t<Aspects...>>
+    : std::true_type {};
+
 template <size_t Dim0, size_t... Dims>
 struct PropertyMetaInfo<work_group_size_key::value_t<Dim0, Dims...>> {
   static constexpr const char *name = "sycl-work-group-size";
diff --git a/sycl/include/sycl/ext/oneapi/properties/property.hpp b/sycl/include/sycl/ext/oneapi/properties/property.hpp
index f8c365240a706..f196242b808ba 100644
--- a/sycl/include/sycl/ext/oneapi/properties/property.hpp
+++ b/sycl/include/sycl/ext/oneapi/properties/property.hpp
@@ -266,6 +266,8 @@ template <typename PropertyT> struct PropertyMetaInfo {
   static constexpr std::nullptr_t value = nullptr;
 };
 
+template <typename> struct HasCompileTimeEffect : std::false_type {};
+
 } // namespace detail
 
 template <typename T>
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 117217eb685d0..5e99c6d9c74a5 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -265,6 +265,18 @@ struct GetMergedKernelProperties<
       PropertiesT, get_method_properties>;
 };
 
+// Checks that none of the properties in the property list has compile-time
+// effects on the kernel.
+template <typename T>
+struct NoPropertyHasCompileTimeKernelEffect : std::false_type {};
+template <typename... Ts>
+struct NoPropertyHasCompileTimeKernelEffect<
+    ext::oneapi::experimental::detail::properties_t<Ts...>> {
+  static constexpr bool value =
+      !(ext::oneapi::experimental::detail::HasCompileTimeEffect<Ts>::value ||
+        ... || false);
+};
+
 #if __SYCL_ID_QUERIES_FIT_IN_INT__
 template <typename T, typename ValT>
 typename std::enable_if_t<std::is_same<ValT, size_t>::value ||
@@ -970,28 +982,11 @@ class __SYCL_EXPORT handler {
     }
   }
 
-  /// Process kernel properties.
+  /// Process runtime kernel properties.
   ///
   /// Stores information about kernel properties into the handler.
-  template <
-      typename KernelName,
-      typename PropertiesT = ext::oneapi::experimental::empty_properties_t>
-  void processProperties(PropertiesT Props) {
-    using KI = detail::KernelInfo<KernelName>;
-    static_assert(
-        ext::oneapi::experimental::is_property_list<PropertiesT>::value,
-        "Template type is not a property list.");
-    static_assert(
-        !PropertiesT::template has_property<
-            sycl::ext::intel::experimental::fp_control_key>() ||
-            (PropertiesT::template has_property<
-                 sycl::ext::intel::experimental::fp_control_key>() &&
-             KI::isESIMD()),
-        "Floating point control property is supported for ESIMD kernels only.");
-    static_assert(
-        !PropertiesT::template has_property<
-            sycl::ext::oneapi::experimental::indirectly_callable_key>(),
-        "indirectly_callable property cannot be applied to SYCL kernels");
+  template <typename PropertiesT>
+  void processLaunchProperties(PropertiesT Props) {
     if constexpr (PropertiesT::template has_property<
                       sycl::ext::intel::experimental::cache_config_key>()) {
       auto Config = Props.template get_property<
@@ -1042,6 +1037,32 @@ class __SYCL_EXPORT handler {
     checkAndSetClusterRange(Props);
   }
 
+  /// Process kernel properties.
+  ///
+  /// Stores information about kernel properties into the handler.
+  template <
+      typename KernelName,
+      typename PropertiesT = ext::oneapi::experimental::empty_properties_t>
+  void processProperties(PropertiesT Props) {
+    using KI = detail::KernelInfo<KernelName>;
+    static_assert(
+        ext::oneapi::experimental::is_property_list<PropertiesT>::value,
+        "Template type is not a property list.");
+    static_assert(
+        !PropertiesT::template has_property<
+            sycl::ext::intel::experimental::fp_control_key>() ||
+            (PropertiesT::template has_property<
+                 sycl::ext::intel::experimental::fp_control_key>() &&
+             KI::isESIMD()),
+        "Floating point control property is supported for ESIMD kernels only.");
+    static_assert(
+        !PropertiesT::template has_property<
+            sycl::ext::oneapi::experimental::indirectly_callable_key>(),
+        "indirectly_callable property cannot be applied to SYCL kernels");
+
+    processLaunchProperties(Props);
+  }
+
   /// Checks whether it is possible to copy the source shape to the destination
   /// shape(the shapes are described by the accessor ranges) by using
   /// copying by regions of memory and not copying element by element
@@ -1440,12 +1461,15 @@ class __SYCL_EXPORT handler {
   ///
   /// \param NumWorkItems is a range defining indexing space.
   /// \param Kernel is a SYCL kernel function.
-  template <int Dims>
-  void parallel_for_impl(range<Dims> NumWorkItems, kernel Kernel) {
+  /// \param Properties is the properties.
+  template <int Dims, typename PropertiesT>
+  void parallel_for_impl(range<Dims> NumWorkItems, PropertiesT Props,
+                         kernel Kernel) {
     throwIfActionIsCreated();
     MKernel = detail::getSyclObjImpl(std::move(Kernel));
     detail::checkValueRange<Dims>(NumWorkItems);
     setNDRangeDescriptor(std::move(NumWorkItems));
+    processLaunchProperties<PropertiesT>(Props);
     setType(detail::CGType::Kernel);
     setNDRangeUsed(false);
     extractArgsAndReqs();
@@ -2125,28 +2149,22 @@ class __SYCL_EXPORT handler {
   ///
   /// \param Kernel is a SYCL kernel object.
   void single_task(kernel Kernel) {
-    throwIfActionIsCreated();
-    // Ignore any set kernel bundles and use the one associated with the kernel
-    setHandlerKernelBundle(Kernel);
-    // No need to check if range is out of INT_MAX limits as it's compile-time
-    // known constant
-    setNDRangeDescriptor(range<1>{1});
-    MKernel = detail::getSyclObjImpl(std::move(Kernel));
-    setType(detail::CGType::Kernel);
-    extractArgsAndReqs();
-    MKernelName = getKernelName();
+    single_task(ext::oneapi::experimental::empty_properties_t{}, Kernel);
   }
 
   void parallel_for(range<1> NumWorkItems, kernel Kernel) {
-    parallel_for_impl(NumWorkItems, Kernel);
+    parallel_for_impl(NumWorkItems,
+                      ext::oneapi::experimental::empty_properties_t{}, Kernel);
   }
 
   void parallel_for(range<2> NumWorkItems, kernel Kernel) {
-    parallel_for_impl(NumWorkItems, Kernel);
+    parallel_for_impl(NumWorkItems,
+                      ext::oneapi::experimental::empty_properties_t{}, Kernel);
   }
 
   void parallel_for(range<3> NumWorkItems, kernel Kernel) {
-    parallel_for_impl(NumWorkItems, Kernel);
+    parallel_for_impl(NumWorkItems,
+                      ext::oneapi::experimental::empty_properties_t{}, Kernel);
   }
 
   /// Defines and invokes a SYCL kernel function for the specified range and
@@ -2180,14 +2198,8 @@ class __SYCL_EXPORT handler {
   /// well as offset.
   /// \param Kernel is a SYCL kernel function.
   template <int Dims> void parallel_for(nd_range<Dims> NDRange, kernel Kernel) {
-    throwIfActionIsCreated();
-    MKernel = detail::getSyclObjImpl(std::move(Kernel));
-    detail::checkValueRange<Dims>(NDRange);
-    setNDRangeDescriptor(std::move(NDRange));
-    setType(detail::CGType::Kernel);
-    setNDRangeUsed(true);
-    extractArgsAndReqs();
-    MKernelName = getKernelName();
+    parallel_for(NDRange, ext::oneapi::experimental::empty_properties_t{},
+                 Kernel);
   }
 
   /// Defines and invokes a SYCL kernel function.
@@ -2573,6 +2585,95 @@ class __SYCL_EXPORT handler {
         NumWorkGroups, WorkGroupSize, Props, KernelFunc);
   }
 
+  /// Invokes a SYCL kernel.
+  ///
+  /// Executes exactly once. The kernel invocation method has no functors and
+  /// cannot be called on host.
+  ///
+  /// \param Kernel is a SYCL kernel object.
+  /// \param Props is the properties for the launch.
+  template <typename PropertiesT>
+  std::enable_if_t<ext::oneapi::experimental::is_property_list_v<PropertiesT>,
+                   void>
+  single_task(PropertiesT Props, kernel Kernel) {
+    static_assert(
+        detail::NoPropertyHasCompileTimeKernelEffect<PropertiesT>::value,
+        "This kernel enqueue function does not allow properties with "
+        "compile-time kernel effects.");
+    throwIfActionIsCreated();
+    // Ignore any set kernel bundles and use the one associated with the kernel
+    setHandlerKernelBundle(Kernel);
+    // No need to check if range is out of INT_MAX limits as it's compile-time
+    // known constant
+    setNDRangeDescriptor(range<1>{1});
+    processLaunchProperties(Props);
+    MKernel = detail::getSyclObjImpl(std::move(Kernel));
+    setType(detail::CGType::Kernel);
+    extractArgsAndReqs();
+    MKernelName = getKernelName();
+  }
+
+  template <typename PropertiesT>
+  std::enable_if_t<ext::oneapi::experimental::is_property_list_v<PropertiesT>,
+                   void>
+  parallel_for(range<1> NumWorkItems, PropertiesT Props, kernel Kernel) {
+    static_assert(
+        detail::NoPropertyHasCompileTimeKernelEffect<PropertiesT>::value,
+        "This kernel enqueue function does not allow properties with "
+        "compile-time kernel effects.");
+    parallel_for_impl(NumWorkItems, Props, Kernel);
+  }
+
+  template <typename PropertiesT>
+  std::enable_if_t<ext::oneapi::experimental::is_property_list_v<PropertiesT>,
+                   void>
+  parallel_for(range<2> NumWorkItems, PropertiesT Props, kernel Kernel) {
+    static_assert(
+        detail::NoPropertyHasCompileTimeKernelEffect<PropertiesT>::value,
+        "This kernel enqueue function does not allow properties with "
+        "compile-time kernel effects.");
+    parallel_for_impl(NumWorkItems, Props, Kernel);
+  }
+
+  template <typename PropertiesT>
+  std::enable_if_t<ext::oneapi::experimental::is_property_list_v<PropertiesT>,
+                   void>
+  parallel_for(range<3> NumWorkItems, PropertiesT Props, kernel Kernel) {
+    static_assert(
+        detail::NoPropertyHasCompileTimeKernelEffect<PropertiesT>::value,
+        "This kernel enqueue function does not allow properties with "
+        "compile-time kernel effects.");
+    parallel_for_impl(NumWorkItems, Props, Kernel);
+  }
+
+  /// Defines and invokes a SYCL kernel function for the specified range and
+  /// offsets.
+  ///
+  /// The SYCL kernel function is defined as SYCL kernel object.
+  ///
+  /// \param NDRange is a ND-range defining global and local sizes as
+  /// well as offset.
+  /// \param Props is the properties for the launch.
+  /// \param Kernel is a SYCL kernel function.
+  template <int Dims, typename PropertiesT>
+  std::enable_if_t<ext::oneapi::experimental::is_property_list_v<PropertiesT>,
+                   void>
+  parallel_for(nd_range<Dims> NDRange, PropertiesT Props, kernel Kernel) {
+    static_assert(
+        detail::NoPropertyHasCompileTimeKernelEffect<PropertiesT>::value,
+        "This kernel enqueue function does not allow properties with "
+        "compile-time kernel effects.");
+    throwIfActionIsCreated();
+    MKernel = detail::getSyclObjImpl(std::move(Kernel));
+    detail::checkValueRange<Dims>(NDRange);
+    setNDRangeDescriptor(std::move(NDRange));
+    processLaunchProperties(Props);
+    setType(detail::CGType::Kernel);
+    setNDRangeUsed(true);
+    extractArgsAndReqs();
+    MKernelName = getKernelName();
+  }
+
   // Clean up KERNELFUNC macro.
 #undef _KERNELFUNCPARAM
 
diff --git a/sycl/test/extensions/properties/kernel_properties_negative.cpp b/sycl/test/extensions/properties/kernel_properties_negative.cpp
new file mode 100644
index 0000000000000..965b8e62e4c36
--- /dev/null
+++ b/sycl/test/extensions/properties/kernel_properties_negative.cpp
@@ -0,0 +1,99 @@
+// RUN: %clangxx -ferror-limit=0 %fsycl-host-only -fsyntax-only -Xclang -verify -Xclang -verify-ignore-unexpected=note,warning %s
+
+// Negative tests for kernel properties.
+
+#include <sycl/sycl.hpp>
+
+namespace oneapi = sycl::ext::oneapi::experimental;
+
+extern sycl::kernel TestKernel;
+
+int main() {
+  sycl::queue Q{};
+
+  oneapi::properties props1{oneapi::sub_group_size<8>};
+  oneapi::properties props2{
+      oneapi::sub_group_size<8>,
+      oneapi::work_group_progress<oneapi::forward_progress_guarantee::parallel,
+                                  oneapi::execution_scope::root_group>};
+
+  Q.submit([&](sycl::handler &CGH) {
+    // expected-error-re@sycl/handler.hpp:* {{static assertion failed due to requirement {{.*}} This kernel enqueue function does not allow properties with compile-time kernel effects.}}
+    CGH.single_task(props1, TestKernel);
+  });
+
+  Q.submit([&](sycl::handler &CGH) {
+    // expected-error-re@sycl/handler.hpp:* {{static assertion failed due to requirement {{.*}} This kernel enqueue function does not allow properties with compile-time kernel effects.}}
+    CGH.single_task(props2, TestKernel);
+  });
+
+  Q.submit([&](sycl::handler &CGH) {
+    // expected-error-re@sycl/handler.hpp:* {{static assertion failed due to requirement {{.*}} This kernel enqueue function does not allow properties with compile-time kernel effects.}}
+    CGH.parallel_for(sycl::range<1>{1}, props1, TestKernel);
+  });
+
+  Q.submit([&](sycl::handler &CGH) {
+    // expected-error-re@sycl/handler.hpp:* {{static assertion failed due to requirement {{.*}} This kernel enqueue function does not allow properties with compile-time kernel effects.}}
+    CGH.parallel_for(sycl::range<1>{1}, props2, TestKernel);
+  });
+
+  Q.submit([&](sycl::handler &CGH) {
+    // expected-error-re@sycl/handler.hpp:* {{static assertion failed due to requirement {{.*}} This kernel enqueue function does not allow properties with compile-time kernel effects.}}
+    CGH.parallel_for(sycl::range<2>{1, 1}, props1, TestKernel);
+  });
+
+  Q.submit([&](sycl::handler &CGH) {
+    // expected-error-re@sycl/handler.hpp:* {{static assertion failed due to requirement {{.*}} This kernel enqueue function does not allow properties with compile-time kernel effects.}}
+    CGH.parallel_for(sycl::range<2>{1, 1}, props2, TestKernel);
+  });
+
+  Q.submit([&](sycl::handler &CGH) {
+    // expected-error-re@sycl/handler.hpp:* {{static assertion failed due to requirement {{.*}} This kernel enqueue function does not allow properties with compile-time kernel effects.}}
+    CGH.parallel_for(sycl::range<3>{1, 1, 1}, props1, TestKernel);
+  });
+
+  Q.submit([&](sycl::handler &CGH) {
+    // expected-error-re@sycl/handler.hpp:* {{static assertion failed due to requirement {{.*}} This kernel enqueue function does not allow properties with compile-time kernel effects.}}
+    CGH.parallel_for(sycl::range<3>{1, 1, 1}, props2, TestKernel);
+  });
+
+  Q.submit([&](sycl::handler &CGH) {
+    // expected-error-re@sycl/handler.hpp:* {{static assertion failed due to requirement {{.*}} This kernel enqueue function does not allow properties with compile-time kernel effects.}}
+    CGH.parallel_for(sycl::nd_range<1>{sycl::range<1>{1}, sycl::range<1>{1}},
+                     props1, TestKernel);
+  });
+
+  Q.submit([&](sycl::handler &CGH) {
+    // expected-error-re@sycl/handler.hpp:* {{static assertion failed due to requirement {{.*}} This kernel enqueue function does not allow properties with compile-time kernel effects.}}
+    CGH.parallel_for(sycl::nd_range<1>{sycl::range<1>{1}, sycl::range<1>{1}},
+                     props2, TestKernel);
+  });
+
+  Q.submit([&](sycl::handler &CGH) {
+    // expected-error-re@sycl/handler.hpp:* {{static assertion failed due to requirement {{.*}} This kernel enqueue function does not allow properties with compile-time kernel effects.}}
+    CGH.parallel_for(
+        sycl::nd_range<2>{sycl::range<2>{1, 1}, sycl::range<2>{1, 1}}, props1,
+        TestKernel);
+  });
+
+  Q.submit([&](sycl::handler &CGH) {
+    // expected-error-re@sycl/handler.hpp:* {{static assertion failed due to requirement {{.*}} This kernel enqueue function does not allow properties with compile-time kernel effects.}}
+    CGH.parallel_for(
+        sycl::nd_range<2>{sycl::range<2>{1, 1}, sycl::range<2>{1, 1}}, props2,
+        TestKernel);
+  });
+
+  Q.submit([&](sycl::handler &CGH) {
+    // expected-error-re@sycl/handler.hpp:* {{static assertion failed due to requirement {{.*}} This kernel enqueue function does not allow properties with compile-time kernel effects.}}
+    CGH.parallel_for(
+        sycl::nd_range<3>{sycl::range<3>{1, 1, 1}, sycl::range<3>{1, 1, 1}},
+        props1, TestKernel);
+  });
+
+  Q.submit([&](sycl::handler &CGH) {
+    // expected-error-re@sycl/handler.hpp:* {{static assertion failed due to requirement {{.*}} This kernel enqueue function does not allow properties with compile-time kernel effects.}}
+    CGH.parallel_for(
+        sycl::nd_range<3>{sycl::range<3>{1, 1, 1}, sycl::range<3>{1, 1, 1}},
+        props2, TestKernel);
+  });
+}
diff --git a/sycl/test/extensions/properties/properties_kernel.cpp b/sycl/test/extensions/properties/properties_kernel.cpp
index 3868c23f7535c..dfad5f9c638e9 100644
--- a/sycl/test/extensions/properties/properties_kernel.cpp
+++ b/sycl/test/extensions/properties/properties_kernel.cpp
@@ -42,6 +42,15 @@ int main() {
   static_assert(is_property_key<sub_group_size_key>::value);
   static_assert(is_property_key<device_has_key>::value);
 
+  static_assert(sycl::ext::oneapi::experimental::detail::HasCompileTimeEffect<
+                work_group_size_key::value_t<1>>::value);
+  static_assert(sycl::ext::oneapi::experimental::detail::HasCompileTimeEffect<
+                work_group_size_hint_key::value_t<1>>::value);
+  static_assert(sycl::ext::oneapi::experimental::detail::HasCompileTimeEffect<
+                sub_group_size_key::value_t<28>>::value);
+  static_assert(sycl::ext::oneapi::experimental::detail::HasCompileTimeEffect<
+                device_has_key::value_t<aspect::fp64>>::value);
+
   static_assert(is_property_value<decltype(work_group_size<1>)>::value);
   static_assert(is_property_value<decltype(work_group_size<2, 2>)>::value);
   static_assert(is_property_value<decltype(work_group_size<3, 3, 3>)>::value);
diff --git a/sycl/test/extensions/properties/properties_kernel_fpga.cpp b/sycl/test/extensions/properties/properties_kernel_fpga.cpp
index 2acd767c386ae..da3d0e8aa2637 100644
--- a/sycl/test/extensions/properties/properties_kernel_fpga.cpp
+++ b/sycl/test/extensions/properties/properties_kernel_fpga.cpp
@@ -16,6 +16,17 @@ int main() {
   static_assert(oneapi::experimental::is_property_key<
                 intel::experimental::pipelined_key>::value);
 
+  // Check that oneapi::experimental::detail::HasCompileTimeEffect is
+  // correctly specialized
+  static_assert(oneapi::experimental::detail::HasCompileTimeEffect<
+                intel::experimental::register_map_interface_key::value_t<
+                    intel::experimental::register_map_interface_options_enum::
+                        wait_for_done_write>>::value);
+  static_assert(oneapi::experimental::detail::HasCompileTimeEffect<
+                intel::experimental::register_map_interface_key::value_t<
+                    intel::experimental::register_map_interface_options_enum::
+                        wait_for_done_write>>::value);
+
   // Check that oneapi::experimental::is_property_value is correctly specialized
   static_assert(oneapi::experimental::is_property_value<
                 decltype(intel::experimental::streaming_interface<
diff --git a/sycl/unittests/Extensions/CMakeLists.txt b/sycl/unittests/Extensions/CMakeLists.txt
index 285e2a5ebd675..b276d509fcc6a 100644
--- a/sycl/unittests/Extensions/CMakeLists.txt
+++ b/sycl/unittests/Extensions/CMakeLists.txt
@@ -13,6 +13,7 @@ add_sycl_unittest(ExtensionsTests OBJECT
   EnqueueFunctionsEvents.cpp
   DiscardEvent.cpp
   ProfilingTag.cpp
+  KernelProperties.cpp
 )
 
 add_subdirectory(CommandGraph)
diff --git a/sycl/unittests/Extensions/KernelProperties.cpp b/sycl/unittests/Extensions/KernelProperties.cpp
new file mode 100644
index 0000000000000..ffd38ee6bed13
--- /dev/null
+++ b/sycl/unittests/Extensions/KernelProperties.cpp
@@ -0,0 +1,140 @@
+//==----------------------- KernelProperties.cpp ---------------------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <helpers/PiMock.hpp>
+#include <helpers/TestKernel.hpp>
+
+#include <gtest/gtest.h>
+
+#include <sycl/detail/core.hpp>
+#include <sycl/kernel_bundle.hpp>
+
+namespace oneapiext = sycl::ext::oneapi::experimental;
+
+namespace {
+
+inline pi_result after_piKernelGetInfo(pi_kernel kernel,
+                                       pi_kernel_info param_name,
+                                       size_t param_value_size,
+                                       void *param_value,
+                                       size_t *param_value_size_ret) {
+  constexpr char MockKernel[] = "TestKernel";
+  if (param_name == PI_KERNEL_INFO_FUNCTION_NAME) {
+    if (param_value) {
+      assert(param_value_size == sizeof(MockKernel));
+      std::memcpy(param_value, MockKernel, sizeof(MockKernel));
+    }
+    if (param_value_size_ret)
+      *param_value_size_ret = sizeof(MockKernel);
+  }
+  return PI_SUCCESS;
+}
+
+class KernelPropertiesTests : public ::testing::Test {
+public:
+  KernelPropertiesTests()
+      : Mock{}, Q{sycl::context(Mock.getPlatform()), sycl::default_selector_v} {
+  }
+
+  inline sycl::kernel GetTestKernel() {
+    auto KB = sycl::get_kernel_bundle<sycl::bundle_state::executable>(
+        Q.get_context());
+    return KB.get_kernel<TestKernel<>>();
+  }
+
+  template <typename FuncT> void RunForwardProgressTest(const FuncT &F) {
+    sycl::kernel K = GetTestKernel();
+
+    try {
+      F(K);
+      FAIL() << "Exception was expected.";
+    } catch (sycl::exception &E) {
+      // Intention of this test is to ensure that properties without kernel
+      // effects are applied correctly through the interface. For forward
+      // progress we can do this by expecting that the kernel reports that it is
+      // using an unsupported forward progress.
+      ASSERT_EQ(E.code(),
+                sycl::make_error_code(sycl::errc::feature_not_supported));
+    }
+  }
+
+protected:
+  void SetUp() override {
+    Mock.redefineAfter<sycl::detail::PiApiKind::piKernelGetInfo>(
+        after_piKernelGetInfo);
+  }
+
+  sycl::unittest::PiMock Mock;
+  sycl::queue Q;
+};
+
+oneapiext::properties ForwardProgressProp{oneapiext::work_group_progress<
+    oneapiext::forward_progress_guarantee::parallel,
+    oneapiext::execution_scope::root_group>};
+
+TEST_F(KernelPropertiesTests, SingleTaskKernelObjForwardProgress) {
+  RunForwardProgressTest([&](sycl::kernel &K) {
+    Q.submit(
+        [&](sycl::handler &CGH) { CGH.single_task(ForwardProgressProp, K); });
+  });
+}
+
+TEST_F(KernelPropertiesTests, ParallelForRange1DKernelObjForwardProgress) {
+  RunForwardProgressTest([&](sycl::kernel &K) {
+    Q.submit([&](sycl::handler &CGH) {
+      CGH.parallel_for(sycl::range<1>{1}, ForwardProgressProp, K);
+    });
+  });
+}
+
+TEST_F(KernelPropertiesTests, ParallelForRange2DKernelObjForwardProgress) {
+  RunForwardProgressTest([&](sycl::kernel &K) {
+    Q.submit([&](sycl::handler &CGH) {
+      CGH.parallel_for(sycl::range<2>{1, 1}, ForwardProgressProp, K);
+    });
+  });
+}
+
+TEST_F(KernelPropertiesTests, ParallelForRange3DKernelObjForwardProgress) {
+  RunForwardProgressTest([&](sycl::kernel &K) {
+    Q.submit([&](sycl::handler &CGH) {
+      CGH.parallel_for(sycl::range<3>{1, 1, 1}, ForwardProgressProp, K);
+    });
+  });
+}
+
+TEST_F(KernelPropertiesTests, ParallelForNDRange1DKernelObjForwardProgress) {
+  RunForwardProgressTest([&](sycl::kernel &K) {
+    Q.submit([&](sycl::handler &CGH) {
+      CGH.parallel_for(sycl::nd_range<1>{sycl::range<1>{1}, sycl::range<1>{1}},
+                       ForwardProgressProp, K);
+    });
+  });
+}
+
+TEST_F(KernelPropertiesTests, ParallelForNDRange2DKernelObjForwardProgress) {
+  RunForwardProgressTest([&](sycl::kernel &K) {
+    Q.submit([&](sycl::handler &CGH) {
+      CGH.parallel_for(
+          sycl::nd_range<2>{sycl::range<2>{1, 1}, sycl::range<2>{1, 1}},
+          ForwardProgressProp, K);
+    });
+  });
+}
+
+TEST_F(KernelPropertiesTests, ParallelForNDRange3DKernelObjForwardProgress) {
+  RunForwardProgressTest([&](sycl::kernel &K) {
+    Q.submit([&](sycl::handler &CGH) {
+      CGH.parallel_for(
+          sycl::nd_range<3>{sycl::range<3>{1, 1, 1}, sycl::range<3>{1, 1, 1}},
+          ForwardProgressProp, K);
+    });
+  });
+}
+
+} // namespace