diff --git a/sycl/include/sycl/ext/oneapi/properties/new_properties.hpp b/sycl/include/sycl/ext/oneapi/properties/new_properties.hpp
new file mode 100644
index 0000000000000..a71e46b35ec13
--- /dev/null
+++ b/sycl/include/sycl/ext/oneapi/properties/new_properties.hpp
@@ -0,0 +1,399 @@
+//==-------- new_properties.hpp --- SYCL extended property list ------------==//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <array>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+#ifndef __SYCL_EBO
+#include <sycl/detail/defines_elementary.hpp>
+#endif
+
+namespace sycl {
+inline namespace _V1 {
+namespace ext::oneapi::experimental {
+namespace new_properties {
+namespace detail {
+template <typename... property_tys> struct properties_type_list;
+
+// Is used to implement `is_property_v`.
+struct property_key_tag_base {};
+} // namespace detail
+
+template <typename properties_type_list_ty, typename = void>
+class __SYCL_EBO properties;
+
+template <typename T> struct is_property_list : std::false_type {};
+template <typename PropListTy>
+struct is_property_list<properties<PropListTy>> : std::true_type {};
+template <typename T>
+inline constexpr bool is_property_list_v = is_property_list<T>::value;
+
+template <typename T>
+inline constexpr bool is_property_v =
+    std::is_base_of_v<detail::property_key_tag_base, T> &&
+    !is_property_list_v<T>;
+
+namespace detail {
+
+#if __has_builtin(__type_pack_element)
+template <int N, typename... Ts>
+using nth_type_t = __type_pack_element<N, Ts...>;
+#else
+template <int N, typename T, typename... Ts> struct nth_type {
+  using type = typename nth_type<N - 1, Ts...>::type;
+};
+
+template <typename T, typename... Ts> struct nth_type<0, T, Ts...> {
+  using type = T;
+};
+
+template <int N, typename... Ts>
+using nth_type_t = typename nth_type<N, Ts...>::type;
+#endif
+
+template <typename IdxSeq, typename... property_tys> struct properties_sorter;
+
+// Specialization to avoid zero-size array creation.
+template <> struct properties_sorter<std::integer_sequence<int>> {
+  using type = properties_type_list<>;
+};
+
+template <int... IdxSeq, typename... property_tys>
+struct properties_sorter<std::integer_sequence<int, IdxSeq...>,
+                         property_tys...> {
+  static constexpr auto sorted_indices = []() constexpr {
+    int idx = 0;
+    int N = sizeof...(property_tys);
+    // std::sort isn't constexpr until C++20. Also, it's possible there will be
+    // a compiler builtin to sort types, in which case we should start using it.
+    std::array to_sort{std::pair{property_tys::property_name, idx++}...};
+    auto swap_pair = [](auto &x, auto &y) constexpr {
+      auto tmp_first = x.first;
+      auto tmp_second = x.second;
+      x.first = y.first;
+      x.second = y.second;
+      y.first = tmp_first;
+      y.second = tmp_second;
+    };
+    for (int i = 0; i < N; ++i)
+      for (int j = i; j < N; ++j)
+        if (to_sort[j].first < to_sort[i].first)
+          swap_pair(to_sort[i], to_sort[j]);
+
+    std::array<int, sizeof...(property_tys)> sorted_indices{};
+    for (int i = 0; i < N; ++i)
+      sorted_indices[i] = to_sort[i].second;
+
+    return sorted_indices;
+  }();
+
+  using type = properties_type_list<
+      nth_type_t<sorted_indices[IdxSeq], property_tys...>...>;
+};
+
+// Need "universal template"
+// (https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2989r2.pdf) to
+// simplify this to a single template and support mixed type/non-type template
+// parameters in properties.
+template <typename> struct property_key_non_template : property_key_tag_base {};
+template <template <auto...> typename>
+struct property_key_value_template : property_key_tag_base {};
+template <template <typename...> typename>
+struct property_key_type_template : property_key_tag_base {};
+
+// Helpers to provide "uniform" access to the key.
+template <typename property>
+constexpr auto key() {
+  return property_key_non_template<property>{};
+}
+template <template <auto...> typename property>
+constexpr auto key() {
+  return property_key_value_template<property>{};
+}
+template <template <typename...> typename property>
+constexpr auto key() {
+  return property_key_type_template<property>{};
+}
+
+// NOTE: each property_t subclass must provide
+//
+// static constexpr std::string_view
+// property_name{"<fully-qualified-name-of-the-property"}
+//
+// member that will be used to sort the properties in the property list. That
+// way we can have a stable sorting order between device/custom-host compilers
+// for both properties provided by the implementation and the ones introduced by
+// users' applications/libraries.
+template <typename property_t,
+          typename property_key_t = property_key_non_template<property_t>>
+struct property_base : property_key_t {
+  using key_t = property_key_t;
+
+protected:
+  constexpr property_t get_property_impl(key_t = {}) const {
+    return *static_cast<const property_t *>(this);
+  }
+
+  // For key_t access in error reporting specialization.
+  template <typename, typename>
+  friend class __SYCL_EBO new_properties::properties;
+
+public:
+  static constexpr const char *ir_attribute_name = "";
+  static constexpr std::nullptr_t ir_attribute_value = nullptr;
+
+  // this_property_t is to disable ADL - properties{property{}} is inherited
+  // from property.
+
+  template <typename this_property_t, typename other_property_t>
+  friend constexpr std::enable_if_t<
+      std::is_same_v<this_property_t, property_t> &&
+          is_property_v<other_property_t>,
+      decltype(properties{std::declval<const this_property_t>(),
+                          std::declval<const other_property_t>()})>
+  operator+(const this_property_t &lhs, const other_property_t &rhs) {
+    return properties{lhs, rhs};
+  }
+};
+
+template <typename... property_tys>
+inline constexpr bool property_names_are_unique = []() constexpr {
+  if constexpr (sizeof...(property_tys) == 0) {
+    return true;
+  } else {
+    const std::array names = {property_tys::property_name...};
+    auto N = names.size();
+    for (int i = 0; i < N; ++i)
+      for (int j = i + 1; j < N; ++j)
+        if (names[i] == names[j])
+          return false;
+
+    return true;
+  }
+}();
+
+template <typename... property_tys>
+inline constexpr bool properties_are_sorted = []() constexpr {
+  if constexpr (sizeof...(property_tys) == 0) {
+    return true;
+  } else {
+    const std::array sort_names = {property_tys::property_name...};
+    // std::is_sorted isn't constexpr until C++20.
+    //
+    // Sorting is an implementation detail while uniqueness of the
+    // property_name's is an API restriction. This internal check actually
+    // combines both conditions as we expect that user error is handled before
+    // the internal `properties_are_sorted` assert is checked.
+    for (std::size_t idx = 1; idx < sort_names.size(); ++idx)
+      if (sort_names[idx - 1] >= sort_names[idx])
+        return false;
+    return true;
+  }
+}();
+
+} // namespace detail
+
+// Empty property list.
+template <> class __SYCL_EBO properties<detail::properties_type_list<>, void> {
+public:
+  template <typename> static constexpr bool has_property() { return false; }
+  template <template <auto...> typename> static constexpr bool has_property() {
+    return false;
+  }
+  template <template <typename...> typename>
+  static constexpr bool has_property() {
+    return false;
+  }
+
+  // TODO: How does this work without qualified name?
+  template <typename other_property_t>
+  friend constexpr std::enable_if_t<
+      is_property_v<other_property_t>,
+      properties<detail::properties_type_list<other_property_t>>>
+  operator+(const properties &, const other_property_t &rhs) {
+    return properties{rhs};
+  }
+};
+
+// Base implementation to provide nice user error in case of mis-use. Without it
+// an error "base class '<property>' specified more than once as a direct base
+// class" is reported prior to static_assert's error.
+template <typename... property_tys>
+class __SYCL_EBO properties<
+    detail::properties_type_list<property_tys...>,
+    std::enable_if_t<!detail::property_names_are_unique<property_tys...>>> {
+  static_assert((is_property_v<property_tys> && ...));
+
+  // This is a separate specialization to report an error, we can afford doing
+  // extra work to provide nice error message without sacrificing compile time
+  // on non-exceptional path. Let's find *a* pair of properties that failed the
+  // check. Note that there might be multiple duplicate names, we're only
+  // reporting one instance. Once user addresses that, the next pair will be
+  // reported.
+  static constexpr auto conflict = []() constexpr {
+    const std::array keys = {property_tys::property_name...};
+    auto N = keys.size();
+    for (int i = 0; i < N; ++i)
+      for (int j = i + 1; j < N; ++j)
+        if (keys[i] == keys[j])
+          return std::pair{i, j};
+  }();
+  using first_type = detail::nth_type_t<conflict.first, property_tys...>;
+  using second_type = detail::nth_type_t<conflict.second, property_tys...>;
+  static_assert(
+      !std::is_same_v<typename first_type::key_t, typename second_type::key_t>,
+      "Duplicate property!");
+  static_assert(first_type::property_name != second_type::property_name,
+                "Property name collision between different property keys!");
+  static_assert((is_property_v<property_tys> && ...));
+};
+
+// NOTE: Meta-function to implement CTAD rules isn't allowed to return
+// `properties<something>` and it's impossible to return a pack as well. As
+// such, we're forced to have an extra level of `detail::properties_type_list`
+// for the purpose of providing CTAD rules.
+template <typename... property_tys>
+class __SYCL_EBO properties<
+    detail::properties_type_list<property_tys...>,
+    std::enable_if_t<detail::property_names_are_unique<property_tys...>>>
+    : private property_tys... {
+  static_assert((is_property_v<property_tys> && ...));
+  static_assert(detail::properties_are_sorted<property_tys...>,
+                "Properties must be sorted!");
+  using property_tys::get_property_impl...;
+
+  template <typename, typename> friend class __SYCL_EBO properties;
+
+public:
+  template <typename... unsorted_property_tys,
+            typename = std::enable_if_t<
+                ((is_property_v<unsorted_property_tys> && ...)) &&
+                sizeof...(unsorted_property_tys) == sizeof...(property_tys)>>
+  constexpr properties(unsorted_property_tys... props)
+      : unsorted_property_tys(props)... {}
+
+  // Until we have "universal template", `has_property`/`get_property`
+  // implementations have to be duplicated for
+  // non-templated/value-templated/type-templated cases.
+
+  template <typename property> static constexpr bool has_property() {
+    return std::is_base_of_v<decltype(detail::key<property>()), properties>;
+  }
+
+  template <template <auto...> typename property>
+  static constexpr bool has_property() {
+    return std::is_base_of_v<decltype(detail::key<property>()), properties>;
+  }
+
+  template <template <typename...> typename property>
+  static constexpr bool has_property() {
+    return std::is_base_of_v<decltype(detail::key<property>()), properties>;
+  }
+
+  // In addition to the duplication mentioned above, do SFINAE-based dispatch
+  // between compile/run-time properties to enable "static" access when
+  // possible.
+  template <typename property>
+  static constexpr auto get_property() -> std::enable_if_t<
+      std::is_empty_v<decltype(std::declval<properties>().get_property_impl(
+          detail::key<property>()))>,
+      decltype(std::declval<properties>().get_property_impl(
+          detail::key<property>()))> {
+    return decltype(std::declval<properties>().get_property_impl(
+        detail::key<property>())){};
+  }
+
+  template <typename property>
+  constexpr auto get_property() const -> std::enable_if_t<
+      !std::is_empty_v<decltype(std::declval<properties>().get_property_impl(
+          detail::key<property>()))>,
+      decltype(std::declval<properties>().get_property_impl(
+          detail::key<property>()))> {
+    return get_property_impl(detail::key<property>());
+  }
+
+  template <template <auto...> typename property>
+  static constexpr auto get_property() -> std::enable_if_t<
+      std::is_empty_v<decltype(std::declval<properties>().get_property_impl(
+          detail::key<property>()))>,
+      decltype(std::declval<properties>().get_property_impl(
+          detail::key<property>()))> {
+    return decltype(std::declval<properties>().get_property_impl(
+        detail::key<property>())){};
+  }
+
+  template <template <auto...> typename property>
+  constexpr auto get_property() const -> std::enable_if_t<
+      !std::is_empty_v<decltype(std::declval<properties>().get_property_impl(
+          detail::key<property>()))>,
+      decltype(std::declval<properties>().get_property_impl(
+          detail::key<property>()))> {
+    return get_property_impl(detail::key<property>());
+  }
+
+  template <template <typename...> typename property>
+  static constexpr auto get_property() -> std::enable_if_t<
+      std::is_empty_v<decltype(std::declval<properties>().get_property_impl(
+          detail::key<property>()))>,
+      decltype(std::declval<properties>().get_property_impl(
+          detail::key<property>()))> {
+    return decltype(std::declval<properties>().get_property_impl(
+        detail::key<property>())){};
+  }
+
+  template <template <typename...> typename property>
+  constexpr auto get_property() const -> std::enable_if_t<
+      !std::is_empty_v<decltype(std::declval<properties>().get_property_impl(
+          detail::key<property>()))>,
+      decltype(std::declval<properties>().get_property_impl(
+          detail::key<property>()))> {
+    return get_property_impl(detail::key<property>());
+  }
+
+  // TODO: Use more effective insert sort for single-property insertion.
+
+  // Need to use qualified type to force CTAD instead of using *current*
+  // properties instantiation.
+  template <typename other_property_t>
+  friend constexpr std::enable_if_t<
+      is_property_v<other_property_t>,
+      decltype(ext::oneapi::experimental::new_properties::properties{
+          std::declval<property_tys>()..., std::declval<other_property_t>()})>
+  operator+(const properties &lhs, const other_property_t &rhs) {
+    return ext::oneapi::experimental::new_properties::properties{
+        static_cast<const property_tys &>(lhs)..., rhs};
+  }
+
+  template <typename... other_property_tys>
+  friend constexpr auto
+  operator+(const properties &lhs,
+            const ext::oneapi::experimental::new_properties::properties<
+                detail::properties_type_list<other_property_tys...>> &rhs) {
+    return ext::oneapi::experimental::new_properties::properties{
+        static_cast<const property_tys &>(lhs)...,
+        static_cast<const other_property_tys &>(rhs)...};
+  }
+};
+
+template <typename... unsorted_property_tys,
+          typename =
+              std::enable_if_t<((is_property_v<unsorted_property_tys> && ...))>>
+properties(unsorted_property_tys...)
+    -> properties<typename detail::properties_sorter<
+        std::make_integer_sequence<int, sizeof...(unsorted_property_tys)>,
+        unsorted_property_tys...>::type>;
+
+using empty_properties_t = decltype(properties{});
+} // namespace new_properties
+} // namespace ext::oneapi::experimental
+} // namespace _V1
+} // namespace sycl
diff --git a/sycl/include/sycl/ext/oneapi/properties/properties.hpp b/sycl/include/sycl/ext/oneapi/properties/properties.hpp
index 1c93e00dbe880..6281a0afa6683 100644
--- a/sycl/include/sycl/ext/oneapi/properties/properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/properties/properties.hpp
@@ -9,6 +9,7 @@
 #pragma once
 
 #include <sycl/detail/is_device_copyable.hpp>
+#include <sycl/ext/oneapi/properties/new_properties.hpp>
 #include <sycl/ext/oneapi/properties/property.hpp>       // for IsRuntimePr...
 #include <sycl/ext/oneapi/properties/property_utils.hpp> // for Sorted, Mer...
 #include <sycl/ext/oneapi/properties/property_value.hpp> // for property_value
diff --git a/sycl/test/extensions/properties/new_properties.cpp b/sycl/test/extensions/properties/new_properties.cpp
new file mode 100644
index 0000000000000..54c7481ec1f67
--- /dev/null
+++ b/sycl/test/extensions/properties/new_properties.cpp
@@ -0,0 +1,244 @@
+// RUN: %clangxx -fsycl -fsyntax-only %s
+
+#define __SYCL_EBO
+#include <sycl/ext/oneapi/properties/new_properties.hpp>
+#include <sycl/detail/type_traits.hpp>
+
+using namespace sycl::ext::oneapi::experimental::new_properties;
+
+template <typename property_key_t> constexpr auto generate_property_key_name() {
+#if defined(__clang__) || defined(__GNUC__)
+  return __PRETTY_FUNCTION__;
+#elif defined(_MSC_VER)
+  return __FUNCSIG__;
+#else
+#error "Unsupported compiler"
+#endif
+}
+
+template <typename property_t,
+          typename property_key_t =
+              detail::property_key_non_template<property_t>>
+struct named_property_base
+    : public detail::property_base<property_t, property_key_t> {
+  static constexpr std::string_view property_name =
+      generate_property_key_name<property_key_t>();
+};
+
+namespace test_sorting {
+// Treat each instantiation as a separate property by not providing a common
+// key.
+template <int N> struct Property : named_property_base<Property<N>> {};
+static_assert(
+    std::is_same_v<decltype(properties{Property<3>{}, Property<2>{}}),
+                   decltype(properties{Property<2>{}, Property<3>{}})>);
+} // namespace test_sorting
+
+namespace test {
+struct property1 : named_property_base<property1> {};
+
+template <int N>
+struct property2
+    : named_property_base<property2<N>,
+                          detail::property_key_value_template<property2>> {};
+struct property3 : named_property_base<property3> {
+  property3(int x) : x(x) {}
+  int x;
+};
+
+void test() {
+  property1 p1;
+  property2<42> p2;
+  property3 p3{11};
+
+  properties pl1{p1, p2, p3};
+  properties pl2{p3};
+
+  static_assert(pl1.has_property<property1>());
+  static_assert(!pl2.has_property<property1>());
+
+  static_assert(pl1.has_property<property2>());
+  static_assert(!pl2.has_property<property2>());
+
+  static_assert(pl1.has_property<property3>());
+  static_assert(pl2.has_property<property3>());
+}
+} // namespace test
+
+namespace bench {
+template <int N> struct property : named_property_base<property<N>> {
+  static constexpr int value() { return N; }
+};
+
+template <int... N> void test(std::integer_sequence<int, N...>) {
+  properties pl{property<N>{}...};
+  static_assert((pl.template has_property<property<N>>() && ...));
+  static_assert(
+      ((pl.template get_property<property<N>>().value() == N) && ...));
+}
+} // namespace bench
+
+namespace test_operator_plus {
+template <int N> struct property : named_property_base<property<N>> {};
+
+constexpr properties pl1{property<1>{}, property<2>{}, property<3>{}};
+constexpr properties pl2 = pl1 + properties{property<4>{}};
+static_assert(!pl1.has_property<property<4>>());
+static_assert(pl2.has_property<property<2>>());
+static_assert(pl2.has_property<property<4>>());
+} // namespace test_operator_plus
+
+namespace test_compile_prop_in_runtime_list {
+template <int N>
+struct ct_prop
+    : named_property_base<ct_prop<N>,
+                          detail::property_key_value_template<ct_prop>> {
+  static constexpr auto value() { return N; }
+};
+struct rt_prop : named_property_base<rt_prop> {
+  rt_prop(int N) : x(N) {}
+
+  int x;
+
+  constexpr auto value() { return x; }
+};
+void test() {
+  int x = 42;
+  properties pl{ct_prop<42>{}, rt_prop{x}};
+  constexpr auto p = pl.get_property<ct_prop>();
+  static_assert(std::is_same_v<decltype(p), const ct_prop<42>>);
+  static_assert(p.value() == 42);
+}
+} // namespace test_compile_prop_in_runtime_list
+
+namespace test_static_get_property {
+  struct ct_prop : named_property_base<ct_prop> {};
+  struct rt_prop : named_property_base<rt_prop> {
+    int x;
+  };
+  void test() {
+    properties pl{ct_prop{}, rt_prop{}};
+    constexpr auto c = decltype(pl)::get_property<ct_prop>();
+    auto r = pl.get_property<rt_prop>();
+  }
+}
+
+namespace properties_validation_example {
+struct prop : named_property_base<prop> {};
+struct prop2 : named_property_base<prop2> {};
+
+template <typename> struct foo;
+template <typename... property_tys>
+struct foo<properties<detail::properties_type_list<property_tys...>>> {
+  template <typename... key_tys> static constexpr bool bar(key_tys...) {
+    return ((sycl::detail::check_type_in_v<typename property_tys::key_t,
+                                           key_tys...> &&
+             ...));
+  }
+};
+constexpr properties pl{prop{}};
+using ty = std::remove_const_t<decltype(pl)>;
+static_assert(foo<ty>::bar(detail::key<prop>()));
+static_assert(foo<ty>::bar(detail::key<prop>(), detail::key<prop2>()));
+static_assert(foo<empty_properties_t>::bar(detail::key<prop>()));
+static_assert(!foo<ty>::bar(detail::key<prop2>()));
+
+// static_assert(all_properties_in_v<ty, prop>);
+// static_assert(all_properties_in_v<empty_properties_t, prop>);
+// static_assert(!all_properties_in_v<ty, prop2>);
+} // namespace properties_validation_example
+
+namespace test_combine_op {
+struct prop : named_property_base<prop> {};
+struct prop2 : named_property_base<prop2> {};
+using pl = decltype(properties{prop{}, prop2{}});
+
+static_assert(std::is_same_v<pl, decltype(prop{} + prop2{})>);
+static_assert(std::is_same_v<pl, decltype(prop2{} + prop{})>);
+static_assert(std::is_same_v<decltype(properties{prop{}}),
+                             decltype(empty_properties_t{} + prop{})>);
+static_assert(
+    std::is_same_v<pl, decltype(empty_properties_t{} + prop{} + prop2{})>);
+static_assert(
+    std::is_same_v<pl, decltype(empty_properties_t{} + prop2{} + prop{})>);
+
+static_assert(std::is_same_v<pl, decltype(properties{prop{}} + prop2{})>);
+static_assert(std::is_same_v<pl, decltype(properties{prop2{}} + prop{})>);
+
+static_assert(std::is_same_v<decltype(properties{prop{}} + prop2{}), pl>);
+}
+
+namespace test_inheritance_visibility {
+template <int N> struct prop : named_property_base<prop<N>> {
+  static constexpr int value = N;
+};
+
+template <typename T, typename = void> struct has_value : std::false_type {};
+template <typename T>
+struct has_value<T, std::void_t<decltype(T::value)>> : std::true_type {};
+template <typename T> inline constexpr bool has_value_v = has_value<T>::value;
+
+constexpr properties pl1{prop<1>{}};
+constexpr properties pl2{prop<1>{}, prop<2>{}};
+
+static_assert(has_value_v<prop<1>>);
+static_assert(!has_value_v<decltype(pl1)>);
+static_assert(!has_value_v<decltype(pl2)>);
+}
+
+namespace implicit_key {
+struct non_template_prop : named_property_base<non_template_prop> {};
+template <int N>
+struct prop
+    : named_property_base<prop<N>, detail::property_key_value_template<prop>> {
+  static constexpr int value = N;
+};
+constexpr properties pl1{non_template_prop{}};
+constexpr properties pl2{prop<42>{}};
+static_assert(pl1.has_property<non_template_prop>());
+static_assert(!pl1.has_property<prop>());
+static_assert(!pl2.has_property<non_template_prop>());
+static_assert(pl2.has_property<prop>());
+static_assert(!empty_properties_t::has_property<non_template_prop>());
+static_assert(!empty_properties_t::has_property<prop>());
+
+constexpr auto p1 = pl1.get_property<non_template_prop>();
+static_assert(std::is_same_v<decltype(p1), const non_template_prop>);
+constexpr auto p2 = pl2.get_property<prop>();
+static_assert(std::is_same_v<decltype(p2), const prop<42>>);
+} // namespace implicit_key
+
+int main() {
+  test::test();
+  bench::test(std::make_integer_sequence<int, 45>{});
+  // More than that fails with clang, e.g.
+  // clang-format off
+  // new_properties.cpp:165:10: note: in instantiation of function template specialization 'bench::test<0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+  //       13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
+  //       52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67>' requested here
+  //   165 |   bench::test(std::make_integer_sequence<int, 68>{});
+  //       |          ^
+  // /usr/lib/gcc/x86_64-linux-gnu/12/../../../../include/c++/12/bits/char_traits.h:367:7: note: constexpr evaluation hit maximum step limit;
+  //       possible infinite loop?
+  //   367 |       {
+  //       |       ^
+  // /usr/lib/gcc/x86_64-linux-gnu/12/../../../../include/c++/12/bits/char_traits.h:382:12: note: in call to 'lt(__PRETTY_FUNCTION__[22],
+  //       __PRETTY_FUNCTION__[22])'
+  //   382 |               if (lt(__s1[__i], __s2[__i]))
+  //       |                   ^~~~~~~~~~~~~~~~~~~~~~~~
+  // /usr/lib/gcc/x86_64-linux-gnu/12/../../../../include/c++/12/string_view:320:14: note: in call to 'compare(&__PRETTY_FUNCTION__[0],
+  //       &__PRETTY_FUNCTION__[0], 71)'
+  //   320 |         int __ret = traits_type::compare(this->_M_str, __str._M_str, __rlen);
+  //       |                     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  // /usr/lib/gcc/x86_64-linux-gnu/12/../../../../include/c++/12/string_view:596:14: note: in call to '__x.compare({71, &__PRETTY_FUNCTION__[0]})'
+  //   596 |     { return __x.compare(__y) < 0; }
+  //       |              ^~~~~~~~~~~~~~~~
+  // /iusers/aeloviko/sycl/sycl/include/sycl/ext/oneapi/properties/properties.hpp:78:13: note: in call to 'operator<<char,
+  //       std::char_traits<char>>({71, &__PRETTY_FUNCTION__[0]}, {71, &__PRETTY_FUNCTION__[0]})'
+  //    78 |         if (to_sort[j].first < to_sort[i].first)
+  //       |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  // clang-format on
+  // bench::test(std::make_integer_sequence<int, 100>{});
+
+  properties empty_props{};
+}
diff --git a/sycl/test/extensions/properties/new_properties_gist.cpp b/sycl/test/extensions/properties/new_properties_gist.cpp
new file mode 100644
index 0000000000000..7c84a8529132e
--- /dev/null
+++ b/sycl/test/extensions/properties/new_properties_gist.cpp
@@ -0,0 +1,73 @@
+// RUN: %clangxx -fsycl -fsyntax-only %s
+
+#include <sycl/ext/oneapi/properties/new_properties.hpp>
+
+#include <cassert>
+
+using namespace sycl::ext::oneapi::experimental::new_properties;
+
+namespace feature_one {
+struct foo : detail::property_base<foo> {
+  static constexpr std::string_view property_name{"feature_one::foo"};
+};
+} // namespace feature_one
+
+namespace feature_two {
+template <int N>
+struct foo
+    : detail::property_base<foo<N>, detail::property_key_value_template<foo>> {
+  static constexpr std::string_view property_name{"feature_two::foo"};
+
+  static constexpr auto value = N;
+
+  static constexpr const char *ir_attribute_name = "sycl-foo";
+  static constexpr int ir_attribute_value = N;
+};
+
+struct bar : detail::property_base<bar> {
+  static constexpr std::string_view property_name{"feature_two::bar"};
+  int value;
+
+  bar(int x) : value(x) {};
+};
+
+template <typename T>
+struct xyz
+    : detail::property_base<xyz<T>, detail::property_key_type_template<xyz>> {
+  static constexpr std::string_view property_name{"feature_two::xyz"};
+
+  using type = T;
+
+  template <typename OtherT>
+  friend constexpr bool operator==(const xyz &, const feature_two::xyz<OtherT> &) {
+    return std::is_same_v<T, OtherT>;
+  }
+};
+} // namespace feature_two
+
+void foo() {
+  properties pl1{feature_one::foo{}, feature_two::foo<42>{},
+                 feature_two::bar{43}};
+
+  static_assert(pl1.has_property<feature_one::foo>());
+  static_assert(pl1.has_property<feature_two::foo>());
+  static_assert(pl1.has_property<feature_two::bar>());
+
+  // compile-time properties have "static" get_feature:
+  constexpr auto f1_foo = pl1.get_property<feature_one::foo>();
+  constexpr auto f2_foo = pl1.get_property<feature_two::foo>();
+  // run-time property:
+  auto f2_bar = pl1.get_property<feature_two::bar>();
+
+  static_assert(f2_foo.value == 42);
+  assert(f2_bar.value == 43);
+
+  static_assert(!pl1.has_property<feature_two::xyz>());
+
+  auto pl2 = pl1 + feature_two::xyz<float>{};
+  static_assert(pl2.has_property<feature_two::xyz>());
+  constexpr auto f2_xyz = pl2.get_property<feature_two::xyz>();
+  static_assert(std::is_same_v<decltype(f2_xyz)::type, float>);
+  static_assert(f2_xyz == feature_two::xyz<float>{});
+  static_assert(!(f2_xyz == feature_two::xyz<int>{}));
+}
diff --git a/sycl/test/extensions/properties/new_properties_llvm_ir.cpp b/sycl/test/extensions/properties/new_properties_llvm_ir.cpp
new file mode 100644
index 0000000000000..c09087254f0e2
--- /dev/null
+++ b/sycl/test/extensions/properties/new_properties_llvm_ir.cpp
@@ -0,0 +1,57 @@
+// RUN: %clangxx -fsycl -fsycl-device-only -O0 -emit-llvm -S %s -o - | FileCheck %s
+
+// CHECK: @fg_int = linkonce_odr dso_local addrspace(1) global %struct.fake_device_global { i32 43 }, align 4 #[[ATTR:[0-9]*]]
+// CHECK: attributes #[[ATTR]] = { "llvm-ir-prop"="42" }
+
+#include <sycl/ext/oneapi/properties/new_properties.hpp>
+
+using namespace sycl::ext::oneapi::experimental::new_properties;
+
+template <typename property_key_t> constexpr auto generate_property_key_name() {
+#if defined(__clang__) || defined(__GNUC__)
+  return __PRETTY_FUNCTION__;
+#elif defined(_MSC_VER)
+  return __FUNCSIG__;
+#else
+#error "Unsupported compiler"
+#endif
+}
+
+template <typename property_t,
+          typename property_key_t =
+              detail::property_key_non_template<property_t>>
+struct named_property_base
+    : public detail::property_base<property_t, property_key_t> {
+  static constexpr std::string_view property_name =
+      generate_property_key_name<property_key_t>();
+};
+
+template <int N>
+struct prop
+    : named_property_base<prop<N>, detail::property_key_value_template<prop>> {
+  static constexpr const char *ir_attribute_name = "llvm-ir-prop";
+  static constexpr int ir_attribute_value = N;
+};
+
+struct property_withour_ir_attribute
+    : named_property_base<property_withour_ir_attribute> {};
+
+template <typename T, typename PropListTy> struct fake_device_global;
+template <typename T, typename... property_tys>
+struct
+    [[__sycl_detail__::global_variable_allowed,
+      __sycl_detail__::add_ir_attributes_global_variable(
+          property_tys::ir_attribute_name...,
+          property_tys::
+              ir_attribute_value...)]] fake_device_global<T,
+                                                          properties<detail::properties_type_list<
+                                                              property_tys...>>> {
+  T value;
+};
+
+constexpr auto pl = properties{prop<42>{}, property_withour_ir_attribute{}};
+using pl_t = std::remove_const_t<decltype(pl)>;
+
+fake_device_global<int, pl_t> fg_int{43};
+
+SYCL_EXTERNAL auto foo() { (void)fg_int; }
diff --git a/sycl/test/extensions/properties/new_properties_negative.cpp b/sycl/test/extensions/properties/new_properties_negative.cpp
new file mode 100644
index 0000000000000..a2a8a23586799
--- /dev/null
+++ b/sycl/test/extensions/properties/new_properties_negative.cpp
@@ -0,0 +1,69 @@
+// RUN: %clangxx -fsycl -fsyntax-only %s -Xclang -verify -Xclang -verify-ignore-unexpected=note
+
+#include <sycl/ext/oneapi/properties/new_properties.hpp>
+
+#include <tuple>
+
+using namespace sycl::ext::oneapi::experimental::new_properties;
+
+using mock_property_sort_key_t = int;
+
+template <typename property_key_t> constexpr auto generate_property_key_name() {
+#if defined(__clang__) || defined(__GNUC__)
+  return __PRETTY_FUNCTION__;
+#elif defined(_MSC_VER)
+  return __FUNCSIG__;
+#else
+#error "Unsupported compiler"
+#endif
+}
+
+template <typename property_t,
+          typename property_key_t =
+              detail::property_key_non_template<property_t>>
+struct named_property_base
+    : public detail::property_base<property_t, property_key_t> {
+  static constexpr std::string_view property_name =
+      generate_property_key_name<property_key_t>();
+};
+
+template <int N> struct property : named_property_base<property<N>> {};
+
+template <int N>
+struct property_with_key
+    : named_property_base<
+          property_with_key<N>,
+          detail::property_key_value_template<property_with_key>> {};
+
+namespace library_a {
+struct prop : detail::property_base<prop> {
+  // Wrong, violates the extension specification! Property name must include
+  // library namespace to avoid collisions with other libraries!
+  static constexpr std::string_view property_name{"prop"};
+};
+}
+namespace library_b {
+struct prop : detail::property_base<prop> {
+  // Wrong, violates the extension specification! Property name must include
+  // library namespace to avoid collisions with other libraries!
+  static constexpr std::string_view property_name{"prop"};
+};
+}
+
+void test() {
+  // expected-error@sycl/ext/oneapi/properties/new_properties.hpp:* {{static assertion failed due to requirement '!std::is_same_v<sycl::ext::oneapi::experimental::new_properties::detail::property_key_non_template<property<1>>, sycl::ext::oneapi::experimental::new_properties::detail::property_key_non_template<property<1>>>': Duplicate property!}}
+  std::ignore = properties{property<1>{}, property<1>{}};
+
+  constexpr properties pl{property<1>{}, property<2>{}};
+  // expected-error@sycl/ext/oneapi/properties/new_properties.hpp:* {{static assertion failed due to requirement '!std::is_same_v<sycl::ext::oneapi::experimental::new_properties::detail::property_key_non_template<property<2>>, sycl::ext::oneapi::experimental::new_properties::detail::property_key_non_template<property<2>>>': Duplicate property!}}
+  std::ignore = pl + properties{property<2>{}};
+
+  // Unfortunately, C++ front end doesn't use qualified name for "prop" below...
+  // expected-error@sycl/ext/oneapi/properties/new_properties.hpp:* {{static assertion failed due to requirement 'prop::property_name != prop::property_name': Property name collision between different property keys!}}
+  std::ignore = properties{library_a::prop{}, library_b::prop{}};
+
+  // expected-error@sycl/ext/oneapi/properties/new_properties.hpp:* {{static assertion failed due to requirement '!std::is_same_v<sycl::ext::oneapi::experimental::new_properties::detail::property_key_value_template<property_with_key>, sycl::ext::oneapi::experimental::new_properties::detail::property_key_value_template<property_with_key>>': Duplicate property!}}
+  std::ignore = properties{property_with_key<1>{}, property_with_key<2>{}};
+}
+
+
diff --git a/sycl/test/extensions/properties/new_properties_open_question.cpp b/sycl/test/extensions/properties/new_properties_open_question.cpp
new file mode 100644
index 0000000000000..c7d3c50201c7c
--- /dev/null
+++ b/sycl/test/extensions/properties/new_properties_open_question.cpp
@@ -0,0 +1,205 @@
+// RUN: %clangxx -fsycl -fsyntax-only %s
+
+#include <sycl/ext/oneapi/properties/new_properties.hpp>
+
+using namespace sycl::ext::oneapi::experimental::new_properties;
+
+template <typename property_key_t> constexpr auto generate_property_key_name() {
+#if defined(__clang__) || defined(__GNUC__)
+  return __PRETTY_FUNCTION__;
+#elif defined(_MSC_VER)
+  return __FUNCSIG__;
+#else
+#error "Unsupported compiler"
+#endif
+}
+template <typename property_t,
+          typename property_key_t =
+              detail::property_key_non_template<property_t>>
+struct named_property_base
+    : public detail::property_base<property_t, property_key_t> {
+  static constexpr std::string_view property_name =
+      generate_property_key_name<property_key_t>();
+};
+
+template <template <auto...> typename Foo, typename PropList>
+auto foo(PropList props = {}) {
+  static_assert(props.template has_property<Foo>());
+  static_assert(props.template get_property<Foo>().value == 42);
+}
+
+namespace approach_one {
+// Don't provide `inline constexpr` property variables at all, they don't
+// provide enough benefits now that `property_value` thing was eliminated.
+
+template <int N>
+struct prop
+    : named_property_base<prop<N>, detail::property_key_value_template<prop>> {
+  static constexpr int value = N;
+};
+struct other_prop : named_property_base<other_prop> {};
+
+void bar() {
+  foo<prop>(properties{prop<42>{}});
+  foo<prop>(properties{prop<42>{}, other_prop{}});
+}
+} // namespace approach_one
+
+namespace approach_two {
+// Keep providing `inline constexpr` "shortcuts".
+template <int N>
+struct prop_property
+    : named_property_base<prop_property<N>,
+                          detail::property_key_value_template<prop_property>> {
+  static constexpr int value = N;
+};
+struct other_prop_property : named_property_base<other_prop_property> {};
+
+template <int N> inline constexpr prop_property<N> prop{};
+inline constexpr other_prop_property other_prop{};
+
+void bar() {
+  // Still need `properties` here.
+  foo<prop_property>(properties{prop<42>});
+  foo<prop_property>(properties{prop<42>, other_prop});
+}
+} // namespace approach_two
+namespace approach_three {
+// Use operator+ to create `properties` property list from individual
+// properties.
+template <int N>
+struct prop_property
+    : named_property_base<prop_property<N>,
+                          detail::property_key_value_template<prop_property>> {
+  static constexpr int value = N;
+};
+struct other_prop_property : named_property_base<other_prop_property> {};
+
+template <int N> inline constexpr prop_property<N> prop{};
+inline constexpr other_prop_property other_prop{};
+
+void bar() {
+  // Unary `+` has a bit of hacky feeling...
+  // foo(+prop<42>);
+
+  // More than one property in a property list looks very natural.
+  // Alternatively, that can be `operator|` but it has no unary version.
+  foo<prop_property>(prop<42> + other_prop);
+}
+} // namespace approach_three
+
+namespace approach_four {
+// "Duck-typing" - make individual properties behave almost like a property
+// list.
+
+// This will be part of the implementation's `detail::property_base` but I'm
+// keeping it in the test for now until the future direction is chosen.
+template <typename property_t,
+          typename property_key_t =
+              detail::property_key_non_template<property_t>>
+struct adjusted_property_base
+    : public named_property_base<property_t, property_key_t> {
+  template <typename T> static constexpr bool has_property() {
+    return std::is_same_v<T, property_key_t>;
+  }
+  template <template <auto...> typename Property /* , something here */>
+  static constexpr bool has_property() { return true; }
+
+  // Technically it should be two version static/non-static depending on
+  // `std::is_empty_v<property_t>`, skipped here for brevity.
+  template <typename T,
+            typename = std::enable_if_t<std::is_same_v<T, property_key_t>>>
+  static constexpr property_t get_property() {
+    return property_t{};
+  }
+
+  template <template <auto...> typename Property /* , something here */>
+  static constexpr property_t get_property() {
+    return property_t{};
+  }
+};
+
+template <int N>
+struct prop_property : adjusted_property_base<
+                           prop_property<N>,
+                           detail::property_key_value_template<prop_property>> {
+  static constexpr int value = N;
+};
+struct other_prop_property : adjusted_property_base<other_prop_property> {};
+
+template <int N> inline constexpr prop_property<N> prop{};
+inline constexpr other_prop_property other_prop{};
+
+void bar() {
+  // "Duck-typing" here.
+  foo<prop_property>(prop<42>);
+
+  // Now nothing prevents us from using `operator|` here that someone might
+  // found more natural. Not doing for simplicity for now.
+  foo<prop_property>(prop<42> + other_prop);
+}
+
+// Problem:
+template <typename T, typename PropListTy> struct fake_device_global;
+template <typename T, typename... property_tys>
+struct
+    [[__sycl_detail__::global_variable_allowed,
+      __sycl_detail__::add_ir_attributes_global_variable(
+          // This attribute needs pack expansion and can't be made working with
+          // "duck-typing".
+          property_tys::ir_attribute_name...,
+          property_tys::
+              ir_attribute_value...)]] fake_device_global<T,
+                                                          properties<detail::properties_type_list<
+                                                              property_tys...>>> {
+  T value;
+};
+
+// Needs this:
+fake_device_global<int, decltype(properties{prop<42>})> fg_int1{43};
+
+#if 0
+// This fails. Note that "decltype" might be implicit through CTAD.
+fake_device_global<int, decltype(prop<42>)> fg_int{43};
+#endif
+} // namespace approach_four
+
+namespace approach_five {
+// Same as approach three but make shortcuts property lists instead of
+// individual properties.
+template <int N>
+struct prop_property
+    : named_property_base<prop_property<N>,
+                          detail::property_key_value_template<prop_property>> {
+  static constexpr int value = N;
+};
+struct other_prop_property : named_property_base<other_prop_property> {};
+
+template <int N> inline constexpr auto prop = properties{prop_property<N>{}};
+inline constexpr auto other_prop = properties{other_prop_property{}};
+
+void bar() {
+  foo<prop_property>(prop<42>);
+  foo<prop_property>(prop<42> + other_prop);
+}
+
+// Problem:
+struct rt_prop_property : named_property_base<rt_prop_property> {
+  int x;
+};
+
+// What should we do in the shortcut? On the other hand, maybe it's a more
+// generic problem and such shortcuts are impossible/meaningless for run-time
+// properties anyway.
+
+// Another side of the problem:
+template <int N> inline constexpr auto expected_behavior = prop_property<N>{};
+static_assert(expected_behavior<42>.value == 42);
+
+#if 0
+// This fails, `properties` don't expose individual property's interfaces.
+// Approach six - modify `properties` to use "public" inheritance from a
+// property + expose its ctors.
+static_assert(prop<42>.value == 42);
+#endif
+}
diff --git a/sycl/test/include_deps/sycl_detail_core.hpp.cpp b/sycl/test/include_deps/sycl_detail_core.hpp.cpp
index d7141579c0f48..22126c64b1110 100644
--- a/sycl/test/include_deps/sycl_detail_core.hpp.cpp
+++ b/sycl/test/include_deps/sycl_detail_core.hpp.cpp
@@ -138,6 +138,7 @@
 // CHECK-NEXT: ext/oneapi/properties/property_value.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_utils.hpp
 // CHECK-NEXT: ext/oneapi/properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/properties/new_properties.hpp
 // CHECK-NEXT: ext/oneapi/experimental/graph.hpp
 // CHECK-NEXT: handler.hpp
 // CHECK-NEXT: detail/cl.h