diff --git a/Allure.NUnit/Core/AllureNUnitHelper.cs b/Allure.NUnit/Core/AllureNUnitHelper.cs
index 2d0ed1a6..911f38df 100644
--- a/Allure.NUnit/Core/AllureNUnitHelper.cs
+++ b/Allure.NUnit/Core/AllureNUnitHelper.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.ComponentModel;
 using System.Linq;
 using System.Text;
 using Allure.Net.Commons;
@@ -96,6 +95,7 @@ internal static TestResult CreateTestResult(ITest test)
             var testResult = new TestResult
             {
                 name = test.Name,
+                titlePath = EnumerateNamesFromTestFixtureToRoot(test).Reverse().ToList(),
                 labels = new List<Label>
                 {
                     Label.Thread(),
@@ -135,6 +135,16 @@ TestStatus.Failed when IsBroken(result) => Status.broken,
             };
         }
 
+        static IEnumerable<string> EnumerateNamesFromTestFixtureToRoot(ITest test)
+        {
+            for (ITest suite = GetTestFixture(test); suite is not null; suite = suite.Parent)
+                yield return suite switch
+                {
+                    TestAssembly a => a.Assembly?.GetName()?.Name ?? a.Name,
+                    _ => suite.Name,
+                };
+        }
+
         TestResultContainer CreateTestContainer() =>
             new()
             {
@@ -236,17 +246,17 @@ static string GetClassName(string classFullName)
         static TestFixture GetTestFixture(ITest test)
         {
             var currentTest = test;
-    
+
             while (currentTest != null)
             {
                 if (currentTest is TestFixture testFixture)
                 {
                     return testFixture;
                 }
-        
+
                 currentTest = currentTest.Parent;
             }
-            
+
             throw new InvalidOperationException(
                 $"Could not find TestFixture in the hierarchy for test: {test.FullName}. " +
                 $"Test type: {test.GetType().Name}"
diff --git a/Allure.Net.Commons.Tests/FunctionTests/IdTests.cs b/Allure.Net.Commons.Tests/FunctionTests/IdTests.cs
index 0a66fc21..045f6eb7 100644
--- a/Allure.Net.Commons.Tests/FunctionTests/IdTests.cs
+++ b/Allure.Net.Commons.Tests/FunctionTests/IdTests.cs
@@ -20,17 +20,48 @@ public void TestUUIDGeneration()
         );
     }
 
-    [TestCase(typeof(IdTests), "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests")]
-    [TestCase(typeof(ClassWithoutNamespace), "Allure.Net.Commons.Tests:ClassWithoutNamespace")]
-    [TestCase(typeof(MyClass), "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass")]
-    [TestCase(typeof(MyClass<>), "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass`1[T]")]
-    [TestCase(typeof(MyClass<string>), "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass`1[System.String]")]
+    [TestCase(
+        typeof(IdTests),
+        "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests",
+        TestName = "FullNameOfNonGenericClass"
+    )]
+    [TestCase(
+        typeof(ClassWithoutNamespace),
+        "Allure.Net.Commons.Tests:ClassWithoutNamespace",
+        TestName = "FullNameOfClassWithNoNamespace"
+    )]
+    [TestCase(
+        typeof(MyClass),
+        "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass",
+        TestName = "FullNameOfNestedClass"
+    )]
+    [TestCase(
+        typeof(MyClass<>),
+        "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass`1[T]",
+        TestName = "FullNameOfNestedGenericClassDefinition"
+    )]
+    [TestCase(
+        typeof(MyClass<string>),
+        "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass`1[System.String]",
+        TestName = "FullNameOfNestedConstructedGenericClass"
+    )]
     [TestCase(
         typeof(MyClass<MyClass<string, int>, MyClass<MyClass>>),
         "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass`2[" +
             "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass`2[System.String,System.Int32]," +
             "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass`1[" +
-                "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass]]"
+                "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass]]",
+        TestName = "FullNameOfComplexConstructedGenericClass"
+    )]
+    [TestCase(
+        typeof(MyClass<>.Nested),
+        "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass`1+Nested[T]",
+        TestName = "FullNameOfNestedClassOfGenericClassDefinition"
+    )]
+    [TestCase(
+        typeof(MyClass<int>.Nested),
+        "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass`1+Nested[System.Int32]",
+        TestName = "FullNameOfNestedClassOfConstructedGenericClass"
     )]
     public void TestFullNameFromClass(Type targetClass, string expectedFullName)
     {
@@ -55,6 +86,7 @@ internal void MethodWithArgumentOfGenericUserType<T>(MyClass<T> _) { }
 
     class MyClass<T>
     {
+        public class Nested { }
         internal void GenericMethodOfGenericClass<V>(List<T> _, List<V> __) { }
     }
 
@@ -63,13 +95,13 @@ class MyClass<T1, T2> { }
     [TestCase(
         nameof(MyClass.ParameterlessMethod),
         "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass.ParameterlessMethod()",
-        TestName = "ParameterlessMethod"
+        TestName = "FullNameOfParameterlessMethod"
     )]
     [TestCase(
         nameof(MyClass.MethodWithParameterOfBuiltInType),
         "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass" +
             ".MethodWithParameterOfBuiltInType(System.Int32)",
-        TestName = "MethodWithParameterOfBuiltInType"
+        TestName = "FullNameOfMethodWithParameterOfBuiltInType"
     )]
     [TestCase(
         nameof(MyClass.MethodWithParameterOfUserType),
@@ -77,7 +109,7 @@ class MyClass<T1, T2> { }
             ".MethodWithParameterOfUserType(" +
                 "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass" +
             ")",
-        TestName = "MethodWithParameterOfUserType"
+        TestName = "FullNameOfMethodWithParameterOfUserType"
     )]
     [TestCase(
         nameof(MyClass.MethodWithTwoParameters),
@@ -86,25 +118,25 @@ class MyClass<T1, T2> { }
                 "System.Int32," +
                 "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass" +
             ")",
-        TestName = "MethodWithTwoParameters"
+        TestName = "FullNameOfMethodWithTwoParameters"
     )]
     [TestCase(
         nameof(MyClass.MethodWithRefParameter),
         "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass" +
             ".MethodWithRefParameter(System.Int32&)",
-        TestName = "MethodWithRefParameter"
+        TestName = "FullNameOfMethodWithRefParameter"
     )]
     [TestCase(
         nameof(MyClass.MethodWithGenericParameter),
         "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass" +
             ".MethodWithGenericParameter[T]()",
-        TestName = "MethodWithGenericParameter"
+        TestName = "FullNameOfMethodWithGenericParameter"
     )]
     [TestCase(
         nameof(MyClass.MethodWithArgumentOfGenericType),
         "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass" +
             ".MethodWithArgumentOfGenericType[T](T)",
-        TestName = "MethodWithArgumentOfGenericType"
+        TestName = "FullNameOfMethodWithArgumentOfGenericType"
     )]
     [TestCase(
         nameof(MyClass.MethodWithArgumentOfTypeParametrizedByGenericType),
@@ -112,7 +144,7 @@ class MyClass<T1, T2> { }
             ".MethodWithArgumentOfTypeParametrizedByGenericType[T](" +
                 "System.Collections.Generic.Dictionary`2[System.Int32,T]" +
             ")",
-        TestName = "MethodWithArgumentOfTypeParametrizedByGenericType"
+        TestName = "FullNameOfMethodWithArgumentOfTypeParametrizedByGenericType"
     )]
     [TestCase(
         nameof(MyClass.MethodWithArgumentOfGenericUserType),
@@ -120,7 +152,7 @@ class MyClass<T1, T2> { }
             ".MethodWithArgumentOfGenericUserType[T](" +
                 "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.IdTests+MyClass`1[T]" +
             ")",
-        TestName = "MethodWithArgumentOfGenericUserType"
+        TestName = "FullNameOfMethodWithArgumentOfGenericUserType"
     )]
     public void FullNameFromMethod(string methodName, string expectedFullName)
     {
diff --git a/Allure.Net.Commons.Tests/FunctionTests/TitlePathTests.cs b/Allure.Net.Commons.Tests/FunctionTests/TitlePathTests.cs
new file mode 100644
index 00000000..33731329
--- /dev/null
+++ b/Allure.Net.Commons.Tests/FunctionTests/TitlePathTests.cs
@@ -0,0 +1,124 @@
+using System;
+using System.Collections.Generic;
+using Allure.Net.Commons.Functions;
+using NUnit.Framework;
+
+namespace Allure.Net.Commons.Tests.FunctionTests;
+
+class TitlePathTests
+{
+    [TestCase(
+        typeof(TitlePathTests),
+        "Allure.Net.Commons.Tests",
+        "Allure",
+        "Net",
+        "Commons",
+        "Tests",
+        "FunctionTests",
+        "TitlePathTests",
+        TestName = "Outmost type with namespave"
+    )]
+    [TestCase(
+        typeof(ClassWithoutNamespace),
+        "Allure.Net.Commons.Tests",
+        "ClassWithoutNamespace",
+        TestName = "Outmost type no namespace"
+    )]
+    [TestCase(
+        typeof(MyClass),
+        "Allure.Net.Commons.Tests",
+        "Allure",
+        "Net",
+        "Commons",
+        "Tests",
+        "FunctionTests",
+        "TitlePathTests+MyClass",
+        TestName = "Nested class"
+    )]
+    [TestCase(
+        typeof(MyClass<>),
+        "Allure.Net.Commons.Tests",
+        "Allure",
+        "Net",
+        "Commons",
+        "Tests",
+        "FunctionTests",
+        "TitlePathTests+MyClass`1[T]",
+        TestName = "Nested generic class definition"
+    )]
+    [TestCase(
+        typeof(MyClass<string>),
+        "Allure.Net.Commons.Tests",
+        "Allure",
+        "Net",
+        "Commons",
+        "Tests",
+        "FunctionTests",
+        "TitlePathTests+MyClass`1[System.String]",
+        TestName = "Nested constructed generic class - system type alias"
+    )]
+    [TestCase(
+        typeof(MyClass<DateTime>),
+        "Allure.Net.Commons.Tests",
+        "Allure",
+        "Net",
+        "Commons",
+        "Tests",
+        "FunctionTests",
+        "TitlePathTests+MyClass`1[System.DateTime]",
+        TestName = "Nested constructed generic class - system type"
+    )]
+    [TestCase(
+        typeof(MyClass<ClassWithoutNamespace>),
+        "Allure.Net.Commons.Tests",
+        "Allure",
+        "Net",
+        "Commons",
+        "Tests",
+        "FunctionTests",
+        "TitlePathTests+MyClass`1[Allure.Net.Commons.Tests:ClassWithoutNamespace]",
+        TestName = "Nested constructed generic class - custom type"
+    )]
+    [TestCase(
+        typeof(MyClass<MyClass<string, int>, MyClass<MyClass>>),
+        "Allure.Net.Commons.Tests",
+        "Allure",
+        "Net",
+        "Commons",
+        "Tests",
+        "FunctionTests",
+        "TitlePathTests+MyClass`2[" +
+            "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.TitlePathTests+MyClass`2[System.String,System.Int32]," +
+            "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.TitlePathTests+MyClass`1[" +
+                "Allure.Net.Commons.Tests:Allure.Net.Commons.Tests.FunctionTests.TitlePathTests+MyClass]]",
+        TestName = "Nested constructed generic class - complex"
+    )]
+    public void TestTitlePathByClass(Type targetClass, params string[] expectedTitlePath)
+    {
+        Assert.That(
+            IdFunctions.CreateTitlePath(targetClass),
+            Is.EqualTo(expectedTitlePath)
+        );
+    }
+
+    class MyClass
+    {
+        internal void ParameterlessMethod() { }
+        internal void MethodWithParameterOfBuiltInType(int _) { }
+        internal void MethodWithParameterOfUserType(MyClass _) { }
+        internal void MethodWithTwoParameters(int _, MyClass __) { }
+        internal void MethodWithRefParameter(ref int _) { }
+        internal void MethodWithGenericParameter<T>() { }
+        internal void MethodWithArgumentOfGenericType<T>(T _) { }
+        internal void MethodWithArgumentOfTypeParametrizedByGenericType<T>(Dictionary<int, T> _) { }
+        internal void MethodWithArgumentOfGenericUserType<T>(MyClass<T> _) { }
+    }
+
+    class MyClass<T>
+    {
+        public class Nested<G> { }
+        internal void GenericMethodOfGenericClass<V>(List<T> _, List<V> __) { }
+    }
+
+    class MyClass<T1, T2> { }
+}
\ No newline at end of file
diff --git a/Allure.Net.Commons/Functions/IdFunctions.cs b/Allure.Net.Commons/Functions/IdFunctions.cs
index aed70834..611ba8b8 100644
--- a/Allure.Net.Commons/Functions/IdFunctions.cs
+++ b/Allure.Net.Commons/Functions/IdFunctions.cs
@@ -18,16 +18,61 @@ public static class IdFunctions
     public static string CreateUUID() => Guid.NewGuid().ToString();
 
     /// <summary>
-    /// Creates a fully-qualified class name that uniquely identifies a given
-    /// class.
+    /// Creates a titlePath: a path to a test class in a tree of test results.
     /// </summary>
+    /// <param name="type">A type representing a test class</param>
     /// <remarks>
-    /// A fully-qualified name of a type includes the assembly name, the
-    /// namespace and the class name (can be a nested class).
+    /// A titlePath consists of:
+    /// <list type="bullet">
+    /// <item>assembly name</item>
+    /// <item>elements of namespace</item>
+    /// <item>name of type (including its declaring types, if any)</item>
+    /// <item>type parameters (for generic type definitions)</item>
+    /// <item>type arguments (for constructed generic types)</item>
+    /// </list>
+    /// </remarks>
+    public static List<string> CreateTitlePath(Type type)
+    {
+        static IEnumerable<string> ExpandNestness(Type type)
+        {
+            for (; type.IsNested; type = type.DeclaringType)
+                yield return type.Name;
+            yield return type.Name;
+        }
+
+        var assemblyName = type.Assembly.GetName().Name;
+        var namespaceParts = (type.Namespace ?? "").Split('.').Where(s => s.Length > 0);
+        var typeName = string.Join("+", ExpandNestness(type).Reverse());
+        var typeArguments = type.GetGenericArguments();
+        var typeArgumentsText = SerializeTypeParameterTypeList(typeArguments);
+
+        return [
+            assemblyName,
+            .. namespaceParts,
+            typeName + typeArgumentsText,
+        ];
+    }
+
+    /// <summary>
+    /// Creates a name that uniquely identifies a given type.
+    /// </summary>
+    /// <remarks>
+    /// A fully-qualified name of a type includes:
+    /// <list type="bullet">
+    /// <item>assembly name</item>
+    /// <item>namespace (if any)</item>
+    /// <item>name of type (including its declaring types, if any)</item>
+    /// <item>type parameters (for generic type definitions)</item>
+    /// <item>type arguments (for constructed generic types)</item>
+    /// </list>
+    /// Unlike <see cref="Type.FullName"/>, it doesn't include assembly
+    /// versions and other metadata that can be subject to change.
+    /// Unlike <see cref="Type.ToString"/>, it includes assembly names to
+    /// the name of the type and its type arguments, which prevents collisions
+    /// in some scenarios.
     /// </remarks>
-    /// <param name="targetClass">The type of a class.</param>
-    public static string CreateFullName(Type targetClass) =>
-        SerializeNonParameterClass(targetClass);
+    public static string CreateFullName(Type type) =>
+        SerializeNonParameterType(type);
 
     /// <summary>
     /// Creates a string that unuquely identifies a given method.
@@ -142,10 +187,10 @@ static string SerializeType(Type type)
         {
             return type.Name;
         }
-        return SerializeNonParameterClass(type);
+        return SerializeNonParameterType(type);
     }
 
-    static string SerializeNonParameterClass(Type type) =>
+    static string SerializeNonParameterType(Type type) =>
         GetUniqueTypeName(type) + SerializeTypeParameterTypeList(
             type.GetGenericArguments()
         );
@@ -156,14 +201,14 @@ static string GetUniqueTypeName(Type type) =>
             : GetTypeNameWithAssembly(type);
 
     static string ConstructFullName(Type type) =>
-        type.DeclaringType is null
-            ? ConstructFullNameOfRootClass(type)
-            : ConstructFullNameOfNestedClass(type);
+        type.IsNested
+            ? ConstructFullNameOfNestedType(type)
+            : ConstructFullNameOfOutmostType(type);
 
-    static string ConstructFullNameOfNestedClass(Type type) =>
+    static string ConstructFullNameOfNestedType(Type type) =>
         ConstructFullName(type.DeclaringType) + "+" + type.Name;
 
-    static string ConstructFullNameOfRootClass(Type type) =>
+    static string ConstructFullNameOfOutmostType(Type type) =>
         string.IsNullOrEmpty(type.Namespace)
             ? type.Name
             : $"{type.Namespace}.{type.Name}";
diff --git a/Allure.Net.Commons/Model/allure2.Designer.cs b/Allure.Net.Commons/Model/allure2.Designer.cs
index 0eb29af6..8b9b08cf 100644
--- a/Allure.Net.Commons/Model/allure2.Designer.cs
+++ b/Allure.Net.Commons/Model/allure2.Designer.cs
@@ -609,6 +609,8 @@ public partial class TestResult : ExecutableItem
 
         private string _rerunOf;
 
+        private List<string> _titlePath;
+
         private string _fullName;
 
         private List<Label> _labels;
@@ -618,6 +620,7 @@ public partial class TestResult : ExecutableItem
 
         public TestResult()
         {
+            this._titlePath = new List<string>();
             this._links = new List<Link>();
             this._labels = new List<Label>();
         }
@@ -670,6 +673,18 @@ public string rerunOf
             }
         }
 
+        public List<string> titlePath
+        {
+            get
+            {
+                return this._titlePath;
+            }
+            set
+            {
+                this._titlePath = value;
+            }
+        }
+
         public string fullName
         {
             get
diff --git a/Allure.Net.Commons/Model/allure2.xsd b/Allure.Net.Commons/Model/allure2.xsd
index 2a8a9dec..debad1c2 100644
--- a/Allure.Net.Commons/Model/allure2.xsd
+++ b/Allure.Net.Commons/Model/allure2.xsd
@@ -55,6 +55,7 @@
 
                     <xsd:element name="rerunOf" type="xsd:string"/>
 
+                    <xsd:element name="titlePath" type="ns:Ids"/>
                     <xsd:element name="fullName" type="xsd:string"/>
                     <xsd:element name="labels" type="ns:Labels" minOccurs="0"/>
                     <xsd:element name="links" type="ns:Links" minOccurs="0"/>
diff --git a/Allure.Reqnroll/Functions/MappingFunctions.cs b/Allure.Reqnroll/Functions/MappingFunctions.cs
index 6f1f6f5d..0bb58b0b 100644
--- a/Allure.Reqnroll/Functions/MappingFunctions.cs
+++ b/Allure.Reqnroll/Functions/MappingFunctions.cs
@@ -305,6 +305,7 @@ static TestResult CreateTestResultInternal(
         new()
         {
             uuid = IdFunctions.CreateUUID(),
+            titlePath = CreateTitlePath(featureAssembly, featureInfo),
             fullName = CreateFullName(
                 featureAssembly,
                 featureInfo,
@@ -378,6 +379,20 @@ static byte[] GetCsvFileContent(Table dataTable)
         return ms.ToArray();
     }
 
+    internal static List<string> CreateTitlePath(
+        Assembly featureAssembly,
+        FeatureInfo featureInfo
+    ) => [
+        featureAssembly.GetName().Name,
+        ..featureInfo.FolderPath.Split(
+            Path.DirectorySeparatorChar,
+            Path.AltDirectorySeparatorChar
+        ).Where((v) => !string.IsNullOrEmpty(v)),
+        string.IsNullOrEmpty(featureInfo.Title)
+            ? "Feature"
+            : featureInfo.Title,
+    ];
+
     static bool TreatAsVerticalArgumentTable(
         IReadOnlyList<string> header,
         Regex? nameRegex,
diff --git a/Allure.SpecFlow/PluginHelper.cs b/Allure.SpecFlow/PluginHelper.cs
index 188c7ebf..be192edb 100644
--- a/Allure.SpecFlow/PluginHelper.cs
+++ b/Allure.SpecFlow/PluginHelper.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
@@ -93,6 +94,7 @@ internal static void StartTestCase(
             {
                 name = title,
                 description = scenarioInfo.Description,
+                titlePath = CreateTitlePath(testRunnerManager, featureInfo),
                 labels = new List<Label>
                 {
                     Label.Thread(),
@@ -290,6 +292,20 @@ string parametersHash
             testResult.fullName = scenarioTitle;
         }
 
+        static List<string> CreateTitlePath(
+            ITestRunnerManager testRunnerManager,
+            FeatureInfo featureInfo
+        ) => [
+            testRunnerManager.TestAssembly.GetName().Name,
+            ..featureInfo.FolderPath.Split(
+                Path.DirectorySeparatorChar,
+                Path.AltDirectorySeparatorChar
+            ).Where(v => !string.IsNullOrEmpty(v)),
+            string.IsNullOrEmpty(featureInfo.Title)
+                ? "Feature"
+                : featureInfo.Title,
+        ];
+
         static string CreateFullName(
             ITestRunnerManager testRunnerManager,
             FeatureInfo featureInfo,
diff --git a/Allure.Xunit/AllureXunitHelper.cs b/Allure.Xunit/AllureXunitHelper.cs
index 1f7fc7b1..c8985488 100644
--- a/Allure.Xunit/AllureXunitHelper.cs
+++ b/Allure.Xunit/AllureXunitHelper.cs
@@ -128,9 +128,11 @@ string displayName
         )
         {
             var testMethod = testCase.TestMethod;
+            var testClass = testMethod.TestClass.Class.ToRuntimeType();
             var testResult = new TestResult
             {
                 name = BuildName(testCase),
+                titlePath = IdFunctions.CreateTitlePath(testClass),
                 labels = new()
                 {
                     Label.Thread(),