diff --git a/allure-cucumber8-jvm/README.md b/allure-cucumber8-jvm/README.md
new file mode 100644
index 000000000..1eefabd14
--- /dev/null
+++ b/allure-cucumber8-jvm/README.md
@@ -0,0 +1,50 @@
+# allure-cucumber8-jvm
+
+Cucumber JVM 8 plugin for Allure Java.
+
+Use this module when your BDD tests run on Cucumber JVM 8 and you want features, scenarios, hooks, steps, tags, attachments, and examples to appear in Allure Report.
+
+This adapter mirrors `allure-cucumber7-jvm` and reads Gherkin line numbers from the Cucumber 8 messages API. `Location.getLine()` is a Java `int` there. Bytecode compiled against the cucumber 7 `Long getLine()` descriptor throws `NoSuchMethodError` on this runtime.
+
+## Supported Versions
+
+- Allure Java 3.x requires Java 17 or newer.
+- This module targets Cucumber JVM 8.x.
+- The test suite validates against Cucumber JVM 8.0.4.
+
+## Installation
+
+Gradle:
+
+```kotlin
+dependencies {
+    testImplementation(platform("io.qameta.allure:allure-bom:<allure-version>"))
+    testImplementation("io.qameta.allure:allure-cucumber8-jvm")
+}
+```
+
+Maven, with `allure-bom` imported in dependency management:
+
+```xml
+<dependency>
+    <groupId>io.qameta.allure</groupId>
+    <artifactId>allure-cucumber8-jvm</artifactId>
+    <scope>test</scope>
+</dependency>
+```
+
+## Setup
+
+Register the plugin with Cucumber:
+
+```java
+@CucumberOptions(plugin = "io.qameta.allure.cucumber8jvm.AllureCucumber8Jvm")
+```
+
+You can also pass the plugin through your Cucumber runner or build tool configuration.
+
+## Report Output
+
+- Features, scenarios, scenario outlines, examples, hooks, and steps.
+- Cucumber attachments and write events.
+- Labels, links, parameters, status, and status details from tags and annotations.
diff --git a/allure-cucumber8-jvm/build.gradle.kts b/allure-cucumber8-jvm/build.gradle.kts
new file mode 100644
index 000000000..607b71d47
--- /dev/null
+++ b/allure-cucumber8-jvm/build.gradle.kts
@@ -0,0 +1,30 @@
+description = "Allure CucumberJVM 8.0"
+
+val cucumberVersion = "8.0.4"
+
+dependencies {
+    implementation("org.slf4j:slf4j-api")
+    api(project(":allure-java-commons"))
+    compileOnly(platform("io.cucumber:cucumber-bom:$cucumberVersion"))
+    compileOnly("io.cucumber:cucumber-plugin")
+    compileOnly("io.cucumber:gherkin")
+    testImplementation("commons-io:commons-io")
+    testImplementation(platform("io.cucumber:cucumber-bom:$cucumberVersion"))
+    testImplementation("io.cucumber:cucumber-core")
+    testImplementation("io.cucumber:cucumber-java")
+    testImplementation("io.cucumber:gherkin")
+    testImplementation("io.github.glytching:junit-extensions")
+    testImplementation("org.assertj:assertj-core")
+    testImplementation("org.junit.jupiter:junit-jupiter-api")
+    testImplementation("org.slf4j:slf4j-simple")
+    testImplementation(project(":allure-assertj"))
+    testImplementation(project(":allure-java-commons-test"))
+    testImplementation(project(":allure-junit-platform"))
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+}
+
+tasks.test {
+    useJUnitPlatform()
+    systemProperty("allure.test.cucumber.version", cucumberVersion)
+}
diff --git a/allure-cucumber8-jvm/src/main/java/io/qameta/allure/cucumber8jvm/AllureCucumber8Jvm.java b/allure-cucumber8-jvm/src/main/java/io/qameta/allure/cucumber8jvm/AllureCucumber8Jvm.java
new file mode 100644
index 000000000..d979fee9d
--- /dev/null
+++ b/allure-cucumber8-jvm/src/main/java/io/qameta/allure/cucumber8jvm/AllureCucumber8Jvm.java
@@ -0,0 +1,602 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm;
+
+import io.cucumber.messages.types.Envelope;
+import io.cucumber.messages.types.Examples;
+import io.cucumber.messages.types.Feature;
+import io.cucumber.messages.types.Scenario;
+import io.cucumber.messages.types.TableCell;
+import io.cucumber.messages.types.TableRow;
+import io.cucumber.messages.types.TestRunHookFinished;
+import io.cucumber.messages.types.TestStepResultStatus;
+import io.cucumber.plugin.ConcurrentEventListener;
+import io.cucumber.plugin.event.DataTableArgument;
+import io.cucumber.plugin.event.EmbedEvent;
+import io.cucumber.plugin.event.EventHandler;
+import io.cucumber.plugin.event.EventPublisher;
+import io.cucumber.plugin.event.HookTestStep;
+import io.cucumber.plugin.event.HookType;
+import io.cucumber.plugin.event.PickleStepTestStep;
+import io.cucumber.plugin.event.Result;
+import io.cucumber.plugin.event.Step;
+import io.cucumber.plugin.event.StepArgument;
+import io.cucumber.plugin.event.TestCase;
+import io.cucumber.plugin.event.TestCaseFinished;
+import io.cucumber.plugin.event.TestCaseStarted;
+import io.cucumber.plugin.event.TestRunFinished;
+import io.cucumber.plugin.event.TestRunStarted;
+import io.cucumber.plugin.event.TestSourceRead;
+import io.cucumber.plugin.event.TestStepFinished;
+import io.cucumber.plugin.event.TestStepStarted;
+import io.cucumber.plugin.event.WriteEvent;
+import io.qameta.allure.Allure;
+import io.qameta.allure.AllureExternalKey;
+import io.qameta.allure.AllureLifecycle;
+import io.qameta.allure.AttachmentOptions;
+import io.qameta.allure.cucumber8jvm.testsourcemodel.TestSourcesModelProxy;
+import io.qameta.allure.model.FixtureResult;
+import io.qameta.allure.model.Parameter;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.StatusDetails;
+import io.qameta.allure.model.StepResult;
+import io.qameta.allure.model.TestResult;
+
+import java.io.ByteArrayInputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import static io.qameta.allure.util.ResultsUtils.createGlobalError;
+import static io.qameta.allure.util.ResultsUtils.createParameter;
+import static io.qameta.allure.util.ResultsUtils.createTitlePath;
+import static io.qameta.allure.util.ResultsUtils.createTitlePathFromSourcePath;
+import static io.qameta.allure.util.ResultsUtils.getStatus;
+import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
+import static io.qameta.allure.util.ResultsUtils.md5;
+
+/**
+ * Reports Cucumber JVM 8 execution to Allure.
+ *
+ * <p>Add this plugin to the Cucumber runtime so feature, scenario, step, hook, and attachment events are converted into Allure results. Use the default lifecycle for normal runs or pass one explicitly for embedded runners and tests.</p>
+ */
+@SuppressWarnings(
+    {
+            "ClassDataAbstractionCoupling",
+            "ClassFanOutComplexity",
+            "PMD.TooManyMethods",
+            "PMD.GodClass",
+    }
+)
+public class AllureCucumber8Jvm implements ConcurrentEventListener {
+
+    private static final String COLON = ":";
+    private static final String CSV_DELIMITER = ",";
+    private static final String CSV_QUOTE = "\"";
+    private static final String CSV_ESCAPED_QUOTE = CSV_QUOTE + CSV_QUOTE;
+    private static final String NEW_LINE = "\n";
+    private static final String CARRIAGE_RETURN = "\r";
+    private static final String UNDEFINED_STEP_MESSAGE = "Undefined Step. Please add step definition";
+
+    private final AllureLifecycle lifecycle;
+
+    private final TestSourcesModelProxy testSources = new TestSourcesModelProxy();
+
+    private final AtomicBoolean scenarioStarted = new AtomicBoolean();
+
+    private final EventHandler<TestRunStarted> runStartedHandler = event -> scenarioStarted.set(false);
+    private final EventHandler<TestSourceRead> featureStartedHandler = this::handleFeatureStartedHandler;
+    private final EventHandler<TestCaseStarted> caseStartedHandler = this::handleTestCaseStarted;
+    private final EventHandler<TestCaseFinished> caseFinishedHandler = this::handleTestCaseFinished;
+    private final EventHandler<TestStepStarted> stepStartedHandler = this::handleTestStepStarted;
+    private final EventHandler<TestStepFinished> stepFinishedHandler = this::handleTestStepFinished;
+    private final EventHandler<WriteEvent> writeEventHandler = this::handleWriteEvent;
+    private final EventHandler<EmbedEvent> embedEventHandler = this::handleEmbedEvent;
+    private final EventHandler<TestRunFinished> runFinishedHandler = this::handleTestRunFinished;
+    private final EventHandler<Envelope> envelopeHandler = this::handleEnvelope;
+
+    private final Map<UUID, String> hookStepContainerUuid = new ConcurrentHashMap<>();
+
+    private static final String TEXT_PLAIN = "text/plain";
+    private static final String CUCUMBER_WORKING_DIR = Paths.get("").toUri().getSchemeSpecificPart();
+
+    /**
+     * Creates an Allure cucumber8 jvm with default configuration.
+     */
+    @SuppressWarnings("unused")
+    public AllureCucumber8Jvm() {
+        this(Allure.getLifecycle());
+    }
+
+    /**
+     * Creates an Allure cucumber8 jvm with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     */
+    public AllureCucumber8Jvm(final AllureLifecycle lifecycle) {
+        this.lifecycle = lifecycle;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setEventPublisher(final EventPublisher publisher) {
+        publisher.registerHandlerFor(TestRunStarted.class, runStartedHandler);
+        publisher.registerHandlerFor(TestSourceRead.class, featureStartedHandler);
+
+        publisher.registerHandlerFor(TestCaseStarted.class, caseStartedHandler);
+        publisher.registerHandlerFor(TestCaseFinished.class, caseFinishedHandler);
+
+        publisher.registerHandlerFor(TestStepStarted.class, stepStartedHandler);
+        publisher.registerHandlerFor(TestStepFinished.class, stepFinishedHandler);
+
+        publisher.registerHandlerFor(WriteEvent.class, writeEventHandler);
+        publisher.registerHandlerFor(EmbedEvent.class, embedEventHandler);
+        publisher.registerHandlerFor(TestRunFinished.class, runFinishedHandler);
+        // Cucumber 8 emits @BeforeAll and @AfterAll failures as messages. The
+        // plugin TestRunFinished result has no throwable for those hooks.
+        publisher.registerHandlerFor(Envelope.class, envelopeHandler);
+    }
+
+    private static AllureExternalKey scopeKey(final String uuid) {
+        return AllureExternalKey.of(AllureCucumber8Jvm.class, "scope", uuid);
+    }
+
+    private static AllureExternalKey testKey(final String uuid) {
+        return AllureExternalKey.of(AllureCucumber8Jvm.class, "test", uuid);
+    }
+
+    private static AllureExternalKey fixtureKey(final String uuid) {
+        return AllureExternalKey.of(AllureCucumber8Jvm.class, "fixture", uuid);
+    }
+
+    private static AllureExternalKey stepKey(final String uuid) {
+        return AllureExternalKey.of(AllureCucumber8Jvm.class, "step", uuid);
+    }
+
+    private void handleFeatureStartedHandler(final TestSourceRead event) {
+        testSources.addTestSourceReadEvent(event.getUri(), event);
+    }
+
+    private void handleTestCaseStarted(final TestCaseStarted event) {
+        scenarioStarted.set(true);
+        final TestCase testCase = event.getTestCase();
+        final Feature feature = testSources.getFeature(testCase.getUri());
+
+        final Deque<String> tags = new LinkedList<>(testCase.getTags());
+        final LabelBuilder labelBuilder = new LabelBuilder(feature, testCase, tags);
+
+        final String name = testCase.getName();
+
+        // the same way full name is generated for
+        // org.junit.platform.engine.support.descriptor.ClasspathResourceSource
+        // to support io.qameta.allure.junitplatform.AllurePostDiscoveryFilter
+        final String fullName = getTestCaseLocation(testCase);
+
+        final String testCaseUuid = testCase.getId().toString();
+
+        final List<String> titlePath = createTitlePathFromSourcePath(getTestCaseUri(testCase));
+        titlePath.addAll(createTitlePath(feature.getName()));
+
+        final TestResult result = new TestResult()
+                .setUuid(testCaseUuid)
+                .setTestCaseId(getTestCaseId(testCase))
+                .setFullName(fullName)
+                .setTitlePath(titlePath)
+                .setName(name)
+                .setLabels(labelBuilder.getScenarioLabels())
+                .setLinks(labelBuilder.getScenarioLinks());
+
+        final Scenario scenarioDefinition = testSources.getScenarioDefinition(
+                testCase.getUri(),
+                testCase.getLocation().getLine()
+        );
+
+        if (scenarioDefinition.getExamples() != null) {
+            result.getParameters().addAll(getExamplesAsParameters(scenarioDefinition, testCase));
+        }
+
+        final String description = Stream.of(feature.getDescription(), scenarioDefinition.getDescription())
+                .filter(Objects::nonNull)
+                .filter(s -> !s.isEmpty())
+                .collect(Collectors.joining(NEW_LINE));
+
+        if (!description.isEmpty()) {
+            result.setDescription(description);
+        }
+
+        final AllureExternalKey testKey = testKey(testCaseUuid);
+        lifecycle.scheduleTest(testKey, result);
+        lifecycle.addDefaultLabels(testKey, labelBuilder.getDefaultLabels());
+        lifecycle.startTest(testKey);
+    }
+
+    /**
+     * Reports an error outside an individual scenario as an error of the run.
+     *
+     * <p>A failed scenario also makes the run-finished result unsuccessful, but its error stays on the
+     * {@link TestCaseFinished} event and the run-finished result has no throwable. Only a throwable here represents
+     * a failure such as a run-level hook that has no scenario result of its own.</p>
+     */
+    private void handleTestRunFinished(final TestRunFinished event) {
+        final Result result = event.getResult();
+        if (Objects.isNull(result) || Objects.isNull(result.getError())) {
+            return;
+        }
+        writeRunLevelError(result.getError());
+    }
+
+    /**
+     * Cucumber 8 returns a failed {@code @BeforeAll} or {@code @AfterAll} from the runner and emits
+     * {@link TestRunHookFinished} instead of attaching that throwable to {@link TestRunFinished}.
+     */
+    private void handleEnvelope(final Envelope envelope) {
+        envelope.getTestRunHookFinished().ifPresent(finished -> {
+            if (finished.getResult().getStatus() != TestStepResultStatus.FAILED) {
+                return;
+            }
+            final io.cucumber.messages.types.Exception exception = finished.getResult().getException().orElse(null);
+            final String detail = finished.getResult().getMessage()
+                    .or(() -> Optional.ofNullable(exception)
+                            .flatMap(io.cucumber.messages.types.Exception::getMessage))
+                    .orElse("failed");
+            // Keep Cucumber's original exception details in the global error when no Throwable is
+            // available from the plugin API. The messages API carries the serialized stack trace.
+            final String stackTrace = Optional.ofNullable(exception)
+                    .flatMap(io.cucumber.messages.types.Exception::getStackTrace)
+                    .orElse(null);
+            final RuntimeException failure = new RuntimeException(
+                    stackTrace == null || stackTrace.isBlank() ? detail : detail + "\\n" + stackTrace
+            );
+            writeRunLevelError(failure);
+        });
+    }
+
+    private void writeRunLevelError(final Throwable failure) {
+        final String context = scenarioStarted.get()
+                ? "Cucumber test run failed"
+                : "Cucumber test run failed, scenarios did not run";
+        lifecycle.writeGlobals(createGlobalError(context, failure));
+    }
+
+    private void handleTestCaseFinished(final TestCaseFinished event) {
+        final TestCase testCase = event.getTestCase();
+        final Feature feature = testSources.getFeature(testCase.getUri());
+        final String uuid = testCase.getId().toString();
+        final Result result = event.getResult();
+        final Status status = translateTestCaseStatus(result);
+        final StatusDetails statusDetails = translateStatusDetails(result);
+
+        final TagParser tagParser = new TagParser(feature, testCase);
+        statusDetails
+                .setFlaky(tagParser.isFlaky())
+                .setMuted(tagParser.isMuted())
+                .setKnown(tagParser.isKnown());
+
+        final AllureExternalKey testKey = testKey(uuid);
+        lifecycle.updateTest(
+                testKey, testResult -> testResult
+                        .setStatus(status)
+                        .setStatusDetails(statusDetails)
+        );
+
+        lifecycle.stopTest(testKey);
+        lifecycle.writeTest(testKey);
+    }
+
+    private void handleTestStepStarted(final TestStepStarted event) {
+        final TestCase testCase = event.getTestCase();
+        if (event.getTestStep() instanceof HookTestStep) {
+            final HookTestStep hook = (HookTestStep) event.getTestStep();
+
+            if (isFixtureHook(hook)) {
+                handleStartFixtureHook(testCase, hook);
+            } else {
+                handleStartStepHook(testCase, hook);
+            }
+        } else if (event.getTestStep() instanceof PickleStepTestStep) {
+            handleStartPickleStep(testCase, (PickleStepTestStep) event.getTestStep());
+        }
+    }
+
+    private void handleStartPickleStep(final TestCase testCase,
+                                       final PickleStepTestStep pickleStep) {
+        final String uuid = testCase.getId().toString();
+        final Step step = pickleStep.getStep();
+
+        final StepResult stepResult = new StepResult()
+                .setName(step.getKeyword() + step.getText())
+                .setStart(System.currentTimeMillis());
+
+        final AllureExternalKey stepKey = stepKey(pickleStep.getId().toString());
+        lifecycle.setCurrent(testKey(uuid));
+        lifecycle.startStep(stepKey, stepResult);
+
+        final StepArgument stepArgument = step.getArgument();
+        if (stepArgument instanceof DataTableArgument) {
+            final DataTableArgument dataTableArgument = (DataTableArgument) stepArgument;
+            createDataTableAttachment(stepKey, dataTableArgument);
+        }
+    }
+
+    private void handleStartStepHook(final TestCase testCase,
+                                     final HookTestStep hook) {
+        final String uuid = testCase.getId().toString();
+        final StepResult stepResult = new StepResult()
+                .setName(hook.getCodeLocation())
+                .setStart(System.currentTimeMillis());
+
+        lifecycle.setCurrent(testKey(uuid));
+        lifecycle.startStep(stepKey(hook.getId().toString()), stepResult);
+    }
+
+    private void handleStartFixtureHook(final TestCase testCase,
+                                        final HookTestStep hook) {
+        final String uuid = testCase.getId().toString();
+
+        final UUID hookId = hook.getId();
+        final String containerUuid = hookStepContainerUuid
+                .computeIfAbsent(hookId, unused -> UUID.randomUUID().toString());
+
+        final AllureExternalKey scopeKey = scopeKey(containerUuid);
+        lifecycle.registerScope(scopeKey);
+        lifecycle.addTestToScope(scopeKey, testKey(uuid));
+
+        final FixtureResult hookResult = new FixtureResult()
+                .setName(hook.getCodeLocation());
+
+        final String fixtureUuid = hookId.toString();
+        final AllureExternalKey fixtureKey = fixtureKey(fixtureUuid);
+        if (hook.getHookType() == HookType.BEFORE) {
+            lifecycle.startBeforeFixture(scopeKey, fixtureKey, hookResult);
+        } else {
+            lifecycle.startAfterFixture(scopeKey, fixtureKey, hookResult);
+        }
+    }
+
+    private void handleTestStepFinished(final TestStepFinished event) {
+        if (event.getTestStep() instanceof HookTestStep) {
+            final HookTestStep hook = (HookTestStep) event.getTestStep();
+            if (isFixtureHook(hook)) {
+                handleStopHookStep(event.getResult(), hook);
+            } else {
+                handleStopStep(event.getTestCase(), event.getResult(), hook.getId());
+            }
+        } else if (event.getTestStep() instanceof PickleStepTestStep) {
+            final PickleStepTestStep pickleStep = (PickleStepTestStep) event.getTestStep();
+            handleStopStep(event.getTestCase(), event.getResult(), pickleStep.getId());
+        }
+    }
+
+    private static boolean isFixtureHook(final HookTestStep hook) {
+        return hook.getHookType() == HookType.BEFORE || hook.getHookType() == HookType.AFTER;
+    }
+
+    private void handleWriteEvent(final WriteEvent event) {
+        // user output is genuinely ambient: it lands under whatever executable is current,
+        // and is silently skipped (unsupported executables) — no key to address it by
+        lifecycle.getCurrentExecutableKey().ifPresent(
+                key -> lifecycle.addAttachment(
+                        key,
+                        "Text output",
+                        TEXT_PLAIN,
+                        new ByteArrayInputStream(Objects.toString(event.getText()).getBytes(StandardCharsets.UTF_8)),
+                        AttachmentOptions.empty()
+                )
+        );
+    }
+
+    private void handleEmbedEvent(final EmbedEvent event) {
+        lifecycle.getCurrentExecutableKey().ifPresent(
+                key -> lifecycle.addAttachment(
+                        key,
+                        event.name,
+                        event.getMediaType(),
+                        new ByteArrayInputStream(event.getData()),
+                        AttachmentOptions.empty()
+                )
+        );
+    }
+
+    private String getTestCaseLocation(final TestCase testCase) {
+        return getTestCaseUri(testCase) + COLON + testCase.getLocation().getLine();
+    }
+
+    private String getTestCaseId(final TestCase testCase) {
+        final String testCaseId = getTestCaseUri(testCase) + COLON + testCase.getName();
+        return md5(testCaseId);
+    }
+
+    private String getTestCaseUri(final TestCase testCase) {
+        final String testCaseUri = testCase.getUri().getSchemeSpecificPart();
+        if (testCaseUri.startsWith(CUCUMBER_WORKING_DIR)) {
+            return testCaseUri.substring(CUCUMBER_WORKING_DIR.length());
+        }
+        return testCaseUri;
+    }
+
+    private Status translateTestCaseStatus(final Result testCaseResult) {
+        switch (testCaseResult.getStatus()) {
+            case FAILED:
+                return getStatus(testCaseResult.getError())
+                        .orElse(Status.FAILED);
+            case PASSED:
+                return Status.PASSED;
+            case SKIPPED:
+            case PENDING:
+                return Status.SKIPPED;
+            case AMBIGUOUS:
+            case UNDEFINED:
+                return Status.BROKEN;
+            default:
+                return null;
+        }
+    }
+
+    private StatusDetails translateStatusDetails(final Result result) {
+        if (result.getStatus() == io.cucumber.plugin.event.Status.UNDEFINED) {
+            return new StatusDetails().setMessage(UNDEFINED_STEP_MESSAGE);
+        }
+        return getStatusDetails(result.getError())
+                .orElseGet(StatusDetails::new);
+    }
+
+    private List<Parameter> getExamplesAsParameters(
+                                                    final Scenario scenario,
+                                                    final TestCase localCurrentTestCase) {
+
+        final Optional<Examples> maybeExample = scenario.getExamples().stream()
+                .filter(
+                        example -> example.getTableBody().stream()
+                                .anyMatch(row -> row.getLocation().getLine() == localCurrentTestCase.getLocation().getLine())
+                )
+                .findFirst();
+
+        if (!maybeExample.isPresent()) {
+            return Collections.emptyList();
+        }
+
+        final Examples examples = maybeExample.get();
+
+        final Optional<TableRow> maybeRow = examples.getTableBody().stream()
+                .filter(example -> example.getLocation().getLine() == localCurrentTestCase.getLocation().getLine())
+                .findFirst();
+
+        if (!maybeRow.isPresent()) {
+            return Collections.emptyList();
+        }
+
+        final TableRow row = maybeRow.get();
+        final int size = row.getCells().size();
+
+        final List<String> headerNames = examples.getTableHeader()
+                .map(TableRow::getCells)
+                .map(
+                        rows -> rows.stream()
+                                .map(TableCell::getValue)
+                                .collect(Collectors.toList())
+                )
+                .orElse(null);
+
+        return IntStream.range(0, size)
+                .mapToObj(index -> {
+                    final String name = Objects.nonNull(headerNames)
+                            ? headerNames.get(index)
+                            : "arg" + index;
+                    final String value = row.getCells().get(index).getValue();
+                    return createParameter(name, value);
+                })
+                .collect(Collectors.toList());
+    }
+
+    private void createDataTableAttachment(final AllureExternalKey stepKey,
+                                           final DataTableArgument dataTableArgument) {
+        // the data table belongs to the step this adapter just started — address it by key
+        lifecycle.addAttachment(
+                stepKey,
+                "Data table",
+                "text/csv",
+                new ByteArrayInputStream(toCsv(dataTableArgument).getBytes(StandardCharsets.UTF_8)),
+                AttachmentOptions.empty()
+        );
+    }
+
+    private static String toCsv(final DataTableArgument dataTableArgument) {
+        final List<List<String>> rowsInTable = dataTableArgument.cells();
+        final StringBuilder dataTableCsv = new StringBuilder();
+        for (List<String> columns : rowsInTable) {
+            if (!columns.isEmpty()) {
+                final String rowValue = columns.stream()
+                        .map(value -> {
+                            final String text = Objects.toString(value, "");
+                            if (text.contains(CSV_DELIMITER)
+                                    || text.contains(CSV_QUOTE)
+                                    || text.contains(NEW_LINE)
+                                    || text.contains(CARRIAGE_RETURN)) {
+                                return CSV_QUOTE + text.replace(CSV_QUOTE, CSV_ESCAPED_QUOTE) + CSV_QUOTE;
+                            }
+                            return text;
+                        })
+                        .collect(Collectors.joining(CSV_DELIMITER, "", NEW_LINE));
+                dataTableCsv.append(rowValue);
+            }
+        }
+        return dataTableCsv.toString();
+    }
+
+    private void handleStopHookStep(final Result eventResult,
+                                    final HookTestStep hook) {
+        final String containerUuid = hookStepContainerUuid.get(hook.getId());
+        if (Objects.isNull(containerUuid)) {
+            // maybe throw an exception?
+            return;
+        }
+
+        final String uuid = hook.getId().toString();
+
+        final Status status = translateTestCaseStatus(eventResult);
+        final StatusDetails statusDetails = getStatusDetails(eventResult.getError())
+                .orElseGet(StatusDetails::new);
+
+        final AllureExternalKey fixtureKey = fixtureKey(uuid);
+        lifecycle.updateFixture(
+                fixtureKey, result -> result
+                        .setStatus(status)
+                        .setStatusDetails(statusDetails)
+        );
+        lifecycle.stopFixture(fixtureKey);
+
+        lifecycle.writeScope(scopeKey(containerUuid));
+    }
+
+    private void handleStopStep(final TestCase testCase,
+                                final Result eventResult,
+                                final UUID stepId) {
+        final Feature feature = testSources.getFeature(testCase.getUri());
+
+        final Status stepStatus = translateTestCaseStatus(eventResult);
+
+        final StatusDetails statusDetails = translateStatusDetails(eventResult);
+
+        final TagParser tagParser = new TagParser(feature, testCase);
+        statusDetails
+                .setFlaky(tagParser.isFlaky())
+                .setMuted(tagParser.isMuted())
+                .setKnown(tagParser.isKnown());
+
+        final AllureExternalKey stepKey = stepKey(stepId.toString());
+        lifecycle.updateStep(
+                stepKey,
+                stepResult -> stepResult
+                        .setStatus(stepStatus)
+                        .setStatusDetails(statusDetails)
+        );
+        lifecycle.stopStep(stepKey);
+    }
+}
diff --git a/allure-cucumber8-jvm/src/main/java/io/qameta/allure/cucumber8jvm/LabelBuilder.java b/allure-cucumber8-jvm/src/main/java/io/qameta/allure/cucumber8jvm/LabelBuilder.java
new file mode 100644
index 000000000..6bcaa3931
--- /dev/null
+++ b/allure-cucumber8-jvm/src/main/java/io/qameta/allure/cucumber8jvm/LabelBuilder.java
@@ -0,0 +1,210 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm;
+
+import io.cucumber.messages.types.Feature;
+import io.cucumber.plugin.event.TestCase;
+import io.qameta.allure.model.Label;
+import io.qameta.allure.model.Link;
+import io.qameta.allure.util.ResultsUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Deque;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static io.qameta.allure.util.ResultsUtils.createFeatureLabel;
+import static io.qameta.allure.util.ResultsUtils.createFrameworkLabel;
+import static io.qameta.allure.util.ResultsUtils.createHostLabel;
+import static io.qameta.allure.util.ResultsUtils.createLabel;
+import static io.qameta.allure.util.ResultsUtils.createLanguageLabel;
+import static io.qameta.allure.util.ResultsUtils.createStoryLabel;
+import static io.qameta.allure.util.ResultsUtils.createSuiteLabel;
+import static io.qameta.allure.util.ResultsUtils.createThreadLabel;
+
+/**
+ * Scenario labels and links builder.
+ */
+@SuppressWarnings({"CyclomaticComplexity", "MultipleStringLiterals", "PMD.CognitiveComplexity"})
+final class LabelBuilder {
+    private static final Logger LOGGER = LoggerFactory.getLogger(LabelBuilder.class);
+    private static final String COMPOSITE_TAG_DELIMITER = "=";
+
+    private static final String SEVERITY = "@SEVERITY";
+    private static final String ISSUE_LINK = "@ISSUE";
+    private static final String TMS_LINK = "@TMSLINK";
+    private static final String PLAIN_LINK = "@LINK";
+    private static final String OWNER = "@OWNER";
+
+    private final List<Label> scenarioLabels = new ArrayList<>();
+    private final List<Label> defaultLabels = new ArrayList<>();
+    private final List<Link> scenarioLinks = new ArrayList<>();
+
+    LabelBuilder(final Feature feature, final TestCase scenario, final Deque<String> tags) {
+        final TagParser tagParser = new TagParser(feature, scenario);
+
+        while (tags.peek() != null) {
+            final String tag = tags.remove();
+
+            if (tag.contains(COMPOSITE_TAG_DELIMITER)) {
+
+                final String[] tagParts = tag.split(COMPOSITE_TAG_DELIMITER, 2);
+                if (tagParts.length < 2 || Objects.isNull(tagParts[1]) || tagParts[1].isEmpty()) {
+                    // skip empty tags, e.g. '@tmsLink=', to avoid formatter errors
+                    continue;
+                }
+
+                final String tagKey = tagParts[0].toUpperCase();
+                final String tagValue = tagParts[1];
+
+                // Handle composite named links
+                if (tagKey.startsWith(PLAIN_LINK + ".")) {
+                    tryHandleNamedLink(tag);
+                    continue;
+                }
+
+                switch (tagKey) {
+                    case SEVERITY:
+                        scenarioLabels.add(ResultsUtils.createSeverityLabel(tagValue.toLowerCase()));
+                        break;
+                    case TMS_LINK:
+                        scenarioLinks.add(ResultsUtils.createTmsLink(tagValue));
+                        break;
+                    case ISSUE_LINK:
+                        scenarioLinks.add(ResultsUtils.createIssueLink(tagValue));
+                        break;
+                    case PLAIN_LINK:
+                        scenarioLinks.add(ResultsUtils.createLink(null, tagValue, tagValue, null));
+                        break;
+                    case OWNER:
+                        scenarioLabels.add(ResultsUtils.createOwnerLabel(tagValue));
+                        break;
+                    default:
+                        LOGGER.warn("Composite tag {} is not supported. adding it as RAW", tagKey);
+                        scenarioLabels.add(getTagLabel(tag));
+                        break;
+                }
+            } else if (tagParser.isPureSeverityTag(tag)) {
+                scenarioLabels.add(ResultsUtils.createSeverityLabel(tag.substring(1)));
+            } else if (!tagParser.isResultTag(tag)) {
+                scenarioLabels.add(getTagLabel(tag));
+            }
+        }
+
+        final String featureName = feature.getName();
+        final URI uri = scenario.getUri();
+
+        scenarioLabels.addAll(ResultsUtils.getProvidedLabels());
+        scenarioLabels.addAll(
+                Arrays.asList(
+                        createHostLabel(),
+                        createThreadLabel(),
+                        createFrameworkLabel("cucumber8jvm"),
+                        createLanguageLabel("java"),
+                        createLabel("gherkin_uri", uri.toString())
+                )
+        );
+
+        defaultLabels.addAll(
+                Arrays.asList(
+                        createFeatureLabel(featureName),
+                        createStoryLabel(scenario.getName()),
+                        createSuiteLabel(featureName)
+                )
+        );
+
+        featurePackage(uri.toString(), featureName)
+                .map(ResultsUtils::createPackageLabel)
+                .ifPresent(scenarioLabels::add);
+    }
+
+    List<Label> getScenarioLabels() {
+        return scenarioLabels;
+    }
+
+    List<Label> getDefaultLabels() {
+        return defaultLabels;
+    }
+
+    List<Link> getScenarioLinks() {
+        return scenarioLinks;
+    }
+
+    private Label getTagLabel(final String tag) {
+        return ResultsUtils.createTagLabel(tag.substring(1));
+    }
+
+    /**
+     * Handle composite named links.
+     *
+     * @param tagString Full tag name and value
+     */
+    private void tryHandleNamedLink(final String tagString) {
+        final String namedLinkPatternString = PLAIN_LINK + "\\.(\\w+-?)+=(\\w+([-_])?)+";
+        final Pattern namedLinkPattern = Pattern.compile(namedLinkPatternString, Pattern.CASE_INSENSITIVE);
+
+        if (namedLinkPattern.matcher(tagString).matches()) {
+            final String type = tagString.split(COMPOSITE_TAG_DELIMITER)[0].split("[.]")[1];
+            final String name = tagString.split(COMPOSITE_TAG_DELIMITER)[1];
+            scenarioLinks.add(ResultsUtils.createLink(null, name, null, type));
+        } else {
+            LOGGER.warn(
+                    "Composite named tag {} does not match regex {}. Skipping", tagString,
+                    namedLinkPatternString
+            );
+        }
+    }
+
+    private Optional<String> featurePackage(final String uriString, final String featureName) {
+        final Optional<URI> maybeUri = safeUri(uriString);
+        if (!maybeUri.isPresent()) {
+            return Optional.empty();
+        }
+        URI uri = maybeUri.get();
+
+        if (!uri.isOpaque()) {
+            final URI work = new File("").toURI();
+            uri = work.relativize(uri);
+        }
+        final String schemeSpecificPart = uri.normalize().getSchemeSpecificPart();
+        final Stream<String> folders = Stream.of(schemeSpecificPart.replaceAll("\\.", "_").split("/"));
+        final Stream<String> name = Stream.of(featureName);
+        return Optional.of(
+                Stream.concat(folders, name)
+                        .filter(Objects::nonNull)
+                        .filter(s -> !s.isEmpty())
+                        .collect(Collectors.joining("."))
+        );
+    }
+
+    private static Optional<URI> safeUri(final String uri) {
+        try {
+            return Optional.of(URI.create(uri));
+        } catch (Exception e) {
+            LOGGER.debug("could not parse feature uri {}", uri, e);
+        }
+        return Optional.empty();
+    }
+}
diff --git a/allure-cucumber8-jvm/src/main/java/io/qameta/allure/cucumber8jvm/TagParser.java b/allure-cucumber8-jvm/src/main/java/io/qameta/allure/cucumber8jvm/TagParser.java
new file mode 100644
index 000000000..ca62a9eee
--- /dev/null
+++ b/allure-cucumber8-jvm/src/main/java/io/qameta/allure/cucumber8jvm/TagParser.java
@@ -0,0 +1,71 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm;
+
+import io.cucumber.messages.types.Feature;
+import io.cucumber.plugin.event.TestCase;
+import io.qameta.allure.SeverityLevel;
+
+import java.util.Arrays;
+
+/**
+ * Parser for tags.
+ */
+class TagParser {
+    private static final String FLAKY = "@FLAKY";
+    private static final String KNOWN = "@KNOWN";
+    private static final String MUTED = "@MUTED";
+
+    private final Feature feature;
+    private final TestCase scenario;
+
+    TagParser(final Feature feature, final TestCase scenario) {
+        this.feature = feature;
+        this.scenario = scenario;
+    }
+
+    boolean isFlaky() {
+        return getStatusDetailByTag(FLAKY);
+    }
+
+    boolean isMuted() {
+        return getStatusDetailByTag(MUTED);
+    }
+
+    boolean isKnown() {
+        return getStatusDetailByTag(KNOWN);
+    }
+
+    private boolean getStatusDetailByTag(final String tagName) {
+        return scenario.getTags().stream()
+                .anyMatch(tag -> tag.equalsIgnoreCase(tagName))
+                || feature.getTags().stream()
+                        .anyMatch(tag -> tag.getName().equalsIgnoreCase(tagName));
+    }
+
+    boolean isResultTag(final String tag) {
+        return Arrays.asList(FLAKY, KNOWN, MUTED)
+                .contains(tag.toUpperCase());
+    }
+
+    boolean isPureSeverityTag(final String tag) {
+        return Arrays.stream(SeverityLevel.values())
+                .map(SeverityLevel::value)
+                .map(value -> "@" + value)
+                .anyMatch(value -> value.equalsIgnoreCase(tag));
+    }
+
+}
diff --git a/allure-cucumber8-jvm/src/main/java/io/qameta/allure/cucumber8jvm/testsourcemodel/TestSourcesModel.java b/allure-cucumber8-jvm/src/main/java/io/qameta/allure/cucumber8jvm/testsourcemodel/TestSourcesModel.java
new file mode 100644
index 000000000..4dbdd608c
--- /dev/null
+++ b/allure-cucumber8-jvm/src/main/java/io/qameta/allure/cucumber8jvm/testsourcemodel/TestSourcesModel.java
@@ -0,0 +1,189 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm.testsourcemodel;
+
+import io.cucumber.gherkin.GherkinParser;
+import io.cucumber.messages.types.Background;
+import io.cucumber.messages.types.Envelope;
+import io.cucumber.messages.types.Examples;
+import io.cucumber.messages.types.Feature;
+import io.cucumber.messages.types.FeatureChild;
+import io.cucumber.messages.types.GherkinDocument;
+import io.cucumber.messages.types.RuleChild;
+import io.cucumber.messages.types.Scenario;
+import io.cucumber.messages.types.Source;
+import io.cucumber.messages.types.SourceMediaType;
+import io.cucumber.messages.types.Step;
+import io.cucumber.messages.types.TableRow;
+import io.cucumber.plugin.event.TestSourceRead;
+
+import java.net.URI;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+final class TestSourcesModel {
+    private final Map<URI, TestSourceRead> pathToReadEventMap = new HashMap<>();
+    private final Map<URI, GherkinDocument> pathToAstMap = new HashMap<>();
+    private final Map<URI, Map<Integer, AstNode>> pathToNodeMap = new HashMap<>();
+
+    static Scenario getScenarioDefinition(final AstNode astNode) {
+        AstNode candidate = astNode;
+        while (candidate != null && !(candidate.node instanceof Scenario)) {
+            candidate = candidate.parent;
+        }
+        return candidate == null ? null : (Scenario) candidate.node;
+    }
+
+    void addTestSourceReadEvent(final URI path, final TestSourceRead event) {
+        pathToReadEventMap.put(path, event);
+    }
+
+    Feature getFeature(final URI path) {
+        if (!pathToAstMap.containsKey(path)) {
+            parseGherkinSource(path);
+        }
+        if (pathToAstMap.containsKey(path)) {
+            return pathToAstMap.get(path).getFeature().orElse(null);
+        }
+        return null;
+    }
+
+    private void parseGherkinSource(final URI path) {
+        if (!pathToReadEventMap.containsKey(path)) {
+            return;
+        }
+        final String source = pathToReadEventMap.get(path).getSource();
+
+        final GherkinParser parser = GherkinParser.builder()
+                .build();
+
+        final Stream<Envelope> envelopes = parser.parse(
+                Envelope.of(new Source(path.toString(), source, SourceMediaType.TEXT_X_CUCUMBER_GHERKIN_PLAIN))
+        );
+
+        // TODO: What about empty gherkin docs?
+        final GherkinDocument gherkinDocument = envelopes
+                .map(Envelope::getGherkinDocument)
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .findFirst()
+                .orElse(null);
+
+        pathToAstMap.put(path, gherkinDocument);
+        final Map<Integer, AstNode> nodeMap = new HashMap<>();
+
+        // TODO: What about gherkin docs with no features?
+        final Feature feature = gherkinDocument.getFeature().get();
+        final AstNode currentParent = new AstNode(feature, null);
+        for (FeatureChild child : feature.getChildren()) {
+            processFeatureDefinition(nodeMap, child, currentParent);
+        }
+        pathToNodeMap.put(path, nodeMap);
+
+    }
+
+    private void processFeatureDefinition(
+                                          final Map<Integer, AstNode> nodeMap, final FeatureChild child, final AstNode currentParent) {
+        child.getBackground().ifPresent(background -> processBackgroundDefinition(nodeMap, background, currentParent));
+        child.getScenario().ifPresent(scenario -> processScenarioDefinition(nodeMap, scenario, currentParent));
+        child.getRule().ifPresent(rule -> {
+            final AstNode childNode = new AstNode(rule, currentParent);
+            nodeMap.put(messageLine(rule.getLocation()), childNode);
+            rule.getChildren().forEach(ruleChild -> processRuleDefinition(nodeMap, ruleChild, childNode));
+        });
+    }
+
+    private void processBackgroundDefinition(
+                                             final Map<Integer, AstNode> nodeMap, final Background background, final AstNode currentParent) {
+        final AstNode childNode = createAstNode(background, currentParent);
+        nodeMap.put(messageLine(background.getLocation()), childNode);
+        for (Step step : background.getSteps()) {
+            nodeMap.put(messageLine(step.getLocation()), createAstNode(step, childNode));
+        }
+    }
+
+    private void processScenarioDefinition(
+                                           final Map<Integer, AstNode> nodeMap, final Scenario child, final AstNode currentParent) {
+        final AstNode childNode = createAstNode(child, currentParent);
+        nodeMap.put(messageLine(child.getLocation()), childNode);
+        for (Step step : child.getSteps()) {
+            nodeMap.put(messageLine(step.getLocation()), createAstNode(step, childNode));
+        }
+        if (!child.getExamples().isEmpty()) {
+            processScenarioOutlineExamples(nodeMap, child, childNode);
+        }
+    }
+
+    private void processRuleDefinition(
+                                       final Map<Integer, AstNode> nodeMap, final RuleChild child, final AstNode currentParent) {
+        child.getBackground().ifPresent(background -> processBackgroundDefinition(nodeMap, background, currentParent));
+        child.getScenario().ifPresent(scenario -> processScenarioDefinition(nodeMap, scenario, currentParent));
+    }
+
+    private void processScenarioOutlineExamples(
+                                                final Map<Integer, AstNode> nodeMap, final Scenario scenarioOutline, final AstNode parent) {
+        for (Examples examples : scenarioOutline.getExamples()) {
+            final AstNode examplesNode = createAstNode(examples, parent);
+            // TODO: Can tables without headers even exist?
+            final TableRow headerRow = examples.getTableHeader().get();
+            final AstNode headerNode = createAstNode(headerRow, examplesNode);
+            nodeMap.put(messageLine(headerRow.getLocation()), headerNode);
+            for (int i = 0; i < examples.getTableBody().size(); ++i) {
+                final TableRow examplesRow = examples.getTableBody().get(i);
+                final AstNode expandedScenarioNode = createAstNode(examplesRow, examplesNode);
+                nodeMap.put(messageLine(examplesRow.getLocation()), expandedScenarioNode);
+            }
+        }
+    }
+
+    /**
+     * Cucumber messages v34 types {@code Location.line} as a Java {@code int}.
+     * Calling the cucumber 7 {@code Long getLine()} descriptor throws
+     * {@code NoSuchMethodError} on this runtime.
+     */
+    private static int messageLine(final io.cucumber.messages.types.Location location) {
+        return location.getLine();
+    }
+
+    AstNode getAstNode(final URI path, final int line) {
+        if (!pathToNodeMap.containsKey(path)) {
+            parseGherkinSource(path);
+        }
+        if (pathToNodeMap.containsKey(path)) {
+            return pathToNodeMap.get(path).get(line);
+        }
+        return null;
+    }
+
+    private AstNode createAstNode(final Object node, final AstNode astNode) {
+        return new AstNode(node, astNode);
+    }
+
+    /**
+     * A node of the parsed Gherkin document tree, linked to its parent for upward traversal.
+     */
+    private static class AstNode {
+        private final Object node;
+        private final AstNode parent;
+
+        AstNode(final Object node, final AstNode parent) {
+            this.node = node;
+            this.parent = parent;
+        }
+    }
+}
diff --git a/allure-cucumber8-jvm/src/main/java/io/qameta/allure/cucumber8jvm/testsourcemodel/TestSourcesModelProxy.java b/allure-cucumber8-jvm/src/main/java/io/qameta/allure/cucumber8jvm/testsourcemodel/TestSourcesModelProxy.java
new file mode 100644
index 000000000..a2891cab3
--- /dev/null
+++ b/allure-cucumber8-jvm/src/main/java/io/qameta/allure/cucumber8jvm/testsourcemodel/TestSourcesModelProxy.java
@@ -0,0 +1,110 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm.testsourcemodel;
+
+import io.cucumber.gherkin.GherkinDialect;
+import io.cucumber.gherkin.GherkinDialectProvider;
+import io.cucumber.messages.types.Feature;
+import io.cucumber.messages.types.Scenario;
+import io.cucumber.plugin.event.TestSourceRead;
+
+import java.net.URI;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Compatibility proxy around Cucumber feature source storage.
+ *
+ * <p>The proxy hides version-specific Cucumber source model APIs from the reporting plugin. Integrations use it to add source-read events and resolve feature, scenario, and step keyword metadata during execution.</p>
+ */
+public class TestSourcesModelProxy {
+
+    private final Map<URI, TestSourceRead> pathToReadEventMap = new HashMap<>();
+    private final TestSourcesModel testSources;
+
+    /**
+     * Creates a test sources model proxy with default configuration.
+     */
+    public TestSourcesModelProxy() {
+        this.testSources = new TestSourcesModel();
+    }
+
+    /**
+     * Adds the test source read event.
+     *
+     * @param path the path to read from or write to
+     * @param event the framework event to process
+     */
+    public void addTestSourceReadEvent(final URI path, final TestSourceRead event) {
+        this.pathToReadEventMap.put(path, event);
+        testSources.addTestSourceReadEvent(path, event);
+    }
+
+    /**
+     * Returns the feature.
+     *
+     * @param path the path to read from or write to
+     * @return the feature
+     */
+    public Feature getFeature(final URI path) {
+        return testSources.getFeature(path);
+    }
+
+    /**
+     * Returns the scenario definition.
+     *
+     * @param path the path to read from or write to
+     * @param line the source line number to resolve
+     * @return the scenario definition
+     */
+    public Scenario getScenarioDefinition(final URI path, final int line) {
+        return TestSourcesModel.getScenarioDefinition(testSources.getAstNode(path, line));
+    }
+
+    /**
+     * Returns the keyword from source.
+     *
+     * @param uri the feature file URI
+     * @param stepLine the feature file line number of the step
+     * @return the keyword from source
+     */
+    public String getKeywordFromSource(final URI uri, final int stepLine) {
+        return this.getKeywordFromSourceInternal(uri, stepLine);
+    }
+
+    private String getKeywordFromSourceInternal(final URI uri, final int stepLine) {
+        final Feature feature = getFeature(uri);
+        if (feature != null) {
+            final TestSourceRead event = this.getTestSourceReadEvent(uri);
+            final String trimmedSourceLine = Objects.requireNonNull(event).getSource().split("\n")[stepLine - 1].trim();
+            final GherkinDialect dialect = new GherkinDialectProvider(feature.getLanguage()).getDefaultDialect();
+            for (String keyword : dialect.getStepKeywords()) {
+                if (trimmedSourceLine.startsWith(keyword)) {
+                    return keyword;
+                }
+            }
+        }
+        return "";
+    }
+
+    private TestSourceRead getTestSourceReadEvent(final URI uri) {
+        if (this.pathToReadEventMap.containsKey(uri)) {
+            return pathToReadEventMap.get(uri);
+        }
+        return null;
+    }
+}
diff --git a/allure-cucumber8-jvm/src/main/java/module-info.java b/allure-cucumber8-jvm/src/main/java/module-info.java
new file mode 100644
index 000000000..7d1e38527
--- /dev/null
+++ b/allure-cucumber8-jvm/src/main/java/module-info.java
@@ -0,0 +1,24 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+module io.qameta.allure.cucumber8jvm {
+    requires transitive io.qameta.allure.commons;
+    requires io.cucumber.plugin;
+    requires io.cucumber.gherkin;
+    requires io.cucumber.messages;
+    requires org.slf4j;
+
+    exports io.qameta.allure.cucumber8jvm;
+}
diff --git a/allure-cucumber8-jvm/src/main/resources/META-INF/aop-ajc.xml b/allure-cucumber8-jvm/src/main/resources/META-INF/aop-ajc.xml
new file mode 100644
index 000000000..09e38300c
--- /dev/null
+++ b/allure-cucumber8-jvm/src/main/resources/META-INF/aop-ajc.xml
@@ -0,0 +1,7 @@
+<aspectj>
+    <weaver options="-warn:none -Xlint:ignore"/>
+    <aspects>
+        <aspect name="io.qameta.allure.aspects.StepsAspects"/>
+        <aspect name="io.qameta.allure.aspects.AttachmentsAspects"/>
+    </aspects>
+</aspectj>
diff --git a/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/AllureCucumber8JvmTest.java b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/AllureCucumber8JvmTest.java
new file mode 100644
index 000000000..bd08652a7
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/AllureCucumber8JvmTest.java
@@ -0,0 +1,1067 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm;
+
+import io.cucumber.core.eventbus.EventBus;
+import io.cucumber.core.feature.FeatureParser;
+import io.cucumber.core.feature.FeatureWithLines;
+import io.cucumber.core.options.CommandlineOptionsParser;
+import io.cucumber.core.options.RuntimeOptions;
+import io.cucumber.core.resource.ClassLoaders;
+import io.cucumber.core.runtime.FeaturePathFeatureSupplier;
+import io.cucumber.core.runtime.Runtime;
+import io.cucumber.core.runtime.TimeServiceEventBus;
+import io.github.glytching.junit.extension.system.SystemProperty;
+import io.github.glytching.junit.extension.system.SystemPropertyExtension;
+import io.qameta.allure.Description;
+import io.qameta.allure.Step;
+import io.qameta.allure.model.Attachment;
+import io.qameta.allure.model.FixtureResult;
+import io.qameta.allure.model.GlobalError;
+import io.qameta.allure.model.Label;
+import io.qameta.allure.model.Link;
+import io.qameta.allure.model.Parameter;
+import io.qameta.allure.model.Stage;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.StatusDetails;
+import io.qameta.allure.model.StepResult;
+import io.qameta.allure.model.TestResult;
+import io.qameta.allure.model.TestResultContainer;
+import io.qameta.allure.test.AllureFeatures;
+import io.qameta.allure.test.AllureResults;
+import io.qameta.allure.test.IsolatedLifecycle;
+import io.qameta.allure.test.RunUtils;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.parallel.ResourceLock;
+
+import java.time.Clock;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.UUID;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+import static io.qameta.allure.util.ResultsUtils.PACKAGE_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.PARENT_SUITE_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.SUB_SUITE_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.SUITE_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.TEST_CLASS_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.TEST_METHOD_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.md5;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.tuple;
+import static org.junit.jupiter.api.parallel.ResourceAccessMode.READ_WRITE;
+import static org.junit.jupiter.api.parallel.Resources.SYSTEM_PROPERTIES;
+@IsolatedLifecycle
+class AllureCucumber8JvmTest {
+
+    private static final String EXPECTED_CUCUMBER_VERSION_PROPERTY = "allure.test.cucumber.version";
+    private static final String UNDEFINED_STEP_MESSAGE = "Undefined Step. Please add step definition";
+
+    @AllureFeatures.Base
+    @Test
+    void shouldSetName() {
+        final AllureResults results = runFeature("features/simple.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getName)
+                .containsExactlyInAnyOrder("Add a to b");
+        assertThat(testResults.get(0).getTitlePath())
+                .containsExactly("src", "test", "resources", "features", "simple.feature", "Simple feature");
+    }
+
+    @AllureFeatures.PassedTests
+    @Test
+    void shouldSetStatus() {
+        final AllureResults results = runFeature("features/simple.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getName, TestResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Add a to b", Status.PASSED)
+                );
+    }
+
+    /**
+     * A failed scenario keeps the failure on its own result and is not duplicated as an error of the test run.
+     */
+    @AllureFeatures.FailedTests
+    @Test
+    @Description
+    void shouldSetFailedStatus() {
+        final AllureResults results = runFeature("features/failed.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getStatus)
+                .containsExactlyInAnyOrder(Status.FAILED);
+        assertThat(getGlobalErrors(results))
+                .as("the scenario result already represents this failure")
+                .isEmpty();
+    }
+
+    @AllureFeatures.FailedTests
+    @Test
+    void shouldSetStatusDetails() {
+        final AllureResults results = runFeature("features/failed.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getStatusDetails)
+                .extracting(StatusDetails::getMessage)
+                .containsExactlyInAnyOrder("expecting 15 to be equal to 123");
+    }
+
+    @AllureFeatures.BrokenTests
+    @Test
+    void shouldSetBrokenStatus() {
+        final AllureResults results = runFeature("features/broken.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getStatus)
+                .containsExactlyInAnyOrder(Status.BROKEN);
+    }
+
+    @AllureFeatures.Stages
+    @Test
+    void shouldSetStage() {
+        final AllureResults results = runFeature("features/simple.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getStage)
+                .containsExactlyInAnyOrder(Stage.FINISHED);
+    }
+
+    @AllureFeatures.Timings
+    @Test
+    void shouldSetStart() {
+        final long before = Instant.now().toEpochMilli();
+        final AllureResults results = runFeature("features/simple.feature");
+        final long after = Instant.now().toEpochMilli();
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getStart)
+                .allMatch(v -> v >= before && v <= after);
+    }
+
+    @AllureFeatures.Timings
+    @Test
+    void shouldSetStop() {
+        final long before = Instant.now().toEpochMilli();
+        final AllureResults results = runFeature("features/simple.feature");
+        final long after = Instant.now().toEpochMilli();
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getStop)
+                .allMatch(v -> v >= before && v <= after);
+    }
+
+    @AllureFeatures.FullName
+    @Test
+    void shouldSetFullName() {
+        final AllureResults results = runFeature("features/simple.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getFullName)
+                .containsExactlyInAnyOrder("src/test/resources/features/simple.feature:3");
+    }
+
+    @AllureFeatures.Descriptions
+    @Test
+    void shouldSetDescription() {
+        final AllureResults results = runFeature("features/description.feature");
+
+        final String expected = "This is description for current feature.\n"
+                + "It should appear on each scenario in report";
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getDescription)
+                .containsExactlyInAnyOrder(
+                        expected,
+                        expected
+                );
+    }
+
+    @AllureFeatures.Descriptions
+    @Test
+    void shouldSetScenarioDescription() {
+        final AllureResults results = runFeature("features/scenario_description.feature");
+
+        final String expected = "This is description for current feature.\n"
+                + "It should appear on each scenario in report";
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getDescription)
+                .containsExactlyInAnyOrder(
+                        expected + "\n    scenario description 1",
+                        expected + "\n    scenario description 2"
+                );
+    }
+
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAddDataTableAttachment() {
+        final AllureResults results = runFeature("features/datatable.feature");
+
+        final List<Attachment> attachments = results.getAttachmentsRecursively();
+
+        assertThat(attachments)
+                .extracting(Attachment::getName, Attachment::getType)
+                .containsExactlyInAnyOrder(
+                        tuple("Data table", "text/csv")
+                );
+
+        final Attachment dataTableAttachment = attachments.iterator().next();
+        assertThat(dataTableAttachment.getSource())
+                .endsWith(".csv");
+        assertThat(results.getAttachments())
+                .containsKeys(dataTableAttachment.getSource());
+
+        assertThat(results.getAttachmentContentAsString(dataTableAttachment))
+                .isEqualTo(
+                        "name,login,email\n"
+                                + "Viktor,clicman,clicman@ya.ru\n"
+                                + "Viktor2,clicman2,clicman2@ya.ru\n"
+                                + "\"Comma, User\",\"quote \"\"login\"\"\",comma@example.org\n"
+                );
+
+    }
+
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAddAttachments() {
+        final AllureResults results = runFeature("features/attachments.feature");
+
+        final List<Attachment> attachments = results.getAttachmentsRecursively();
+
+        assertThat(attachments)
+                .extracting(Attachment::getName, Attachment::getType)
+                .containsExactlyInAnyOrder(
+                        tuple("TextAttachment", "text/plain"),
+                        tuple("ImageAttachment", "image/png")
+                );
+
+        final List<String> attachmentContents = attachments.stream()
+                .map(results::getAttachmentContentAsString)
+                .toList();
+
+        assertThat(attachmentContents)
+                .containsExactlyInAnyOrder("text attachment", "image attachment");
+    }
+
+    @AllureFeatures.Steps
+    @Test
+    void shouldAddBackgroundSteps() {
+        final AllureResults results = runFeature("features/background.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+
+        assertThat(testResults)
+                .hasSize(1)
+                .flatExtracting(TestResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly(
+                        "Given cat is sad",
+                        "And cat is murmur",
+                        "When Pet the cat",
+                        "Then Cat is happy"
+                );
+    }
+
+    @AllureFeatures.Parameters
+    @Test
+    void shouldAddParametersFromExamples() {
+        final AllureResults results = runFeature("features/examples.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+
+        assertThat(testResults)
+                .hasSize(2);
+
+        assertThat(testResults.get(0).getParameters())
+                .hasSize(3);
+
+        assertThat(testResults.get(1).getParameters())
+                .hasSize(3);
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue)
+                .containsExactlyInAnyOrder(
+                        tuple("a", "1"), tuple("b", "3"), tuple("result", "4"),
+                        tuple("a", "2"), tuple("b", "4"), tuple("result", "6")
+                );
+
+    }
+
+    @AllureFeatures.Parameters
+    @Test
+    void shouldHandleMultipleExamplesPerOutline() {
+        final AllureResults results = runFeature("features/multi-examples.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+
+        assertThat(testResults)
+                .hasSize(2);
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue)
+                .containsExactlyInAnyOrder(
+                        tuple("a", "1"), tuple("b", "3"), tuple("result", "4"),
+                        tuple("a", "2"), tuple("b", "4"), tuple("result", "6")
+                );
+    }
+
+    @AllureFeatures.Parameters
+    @Test
+    void shouldSupportTaggedExamplesBlocks() {
+        final AllureResults results = runFeature("features/multi-examples.feature", "--tags", "@ExamplesTag2");
+
+        final List<TestResult> testResults = results.getTestResults();
+
+        assertThat(testResults)
+                .hasSize(1);
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getName, Label::getValue)
+                .contains(
+                        tuple("tag", "ExamplesTag2")
+                );
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue)
+                .containsExactlyInAnyOrder(
+                        tuple("a", "2"), tuple("b", "4"), tuple("result", "6")
+                );
+    }
+
+    @AllureFeatures.MarkerAnnotations
+    @Test
+    void shouldAddTags() {
+        final AllureResults results = runFeature("features/tags.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getName, Label::getValue)
+                .contains(
+                        tuple("tag", "FeatureTag"),
+                        tuple("tag", "good")
+                );
+    }
+
+    @AllureFeatures.MarkerAnnotations
+    @Test
+    void shouldRecordFlakyMutedAndKnown() {
+        final AllureResults results = runFeature("features/status-tags.feature");
+
+        assertThat(results.getTestResults())
+                .extracting(TestResult::getStatusDetails)
+                .allSatisfy(details -> {
+                    assertThat(details.isFlaky()).isTrue();
+                    assertThat(details.isMuted()).isTrue();
+                    assertThat(details.isKnown()).isTrue();
+                });
+    }
+
+    /**
+     * Metadata tags must replace Cucumber's generated hierarchy defaults so report generation cannot place the
+     * same scenario under both hierarchies.
+     */
+    @Description
+    @Test
+    void shouldPreferMetadataTagHierarchyOverDefaults() {
+        assertThat(Runtime.class.getPackage().getImplementationVersion())
+                .as("Cucumber runtime version")
+                .isEqualTo(System.getProperty(EXPECTED_CUCUMBER_VERSION_PROPERTY));
+
+        final AllureResults results = runFeature("features/metadata-tags.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .hasSize(3)
+                .allSatisfy(testResult -> {
+                    assertThat(testResult.getLabels())
+                            .filteredOn(
+                                    label -> PARENT_SUITE_LABEL_NAME.equals(label.getName())
+                                            || SUITE_LABEL_NAME.equals(label.getName())
+                                            || SUB_SUITE_LABEL_NAME.equals(label.getName())
+                            )
+                            .extracting(Label::getName, Label::getValue)
+                            .containsExactlyInAnyOrder(
+                                    tuple(PARENT_SUITE_LABEL_NAME, "Cucumber"),
+                                    tuple(SUITE_LABEL_NAME, "Petstore"),
+                                    tuple(SUB_SUITE_LABEL_NAME, "CRUD")
+                            );
+                    assertThat(testResult.getLabels())
+                            .filteredOn(label -> "tag".equals(label.getName()))
+                            .extracting(Label::getValue)
+                            .doesNotContain(
+                                    "allure.label.parentSuite:Cucumber",
+                                    "allure.label.suite:Petstore",
+                                    "allure.label.subSuite:CRUD"
+                            );
+                });
+    }
+
+    @AllureFeatures.Links
+    @ExtendWith(SystemPropertyExtension.class)
+    @SystemProperty(
+            name = "allure.link.issue.pattern",
+            value = "https://example.org/issue/{}"
+    )
+    @SystemProperty(
+            name = "allure.link.tms.pattern",
+            value = "https://example.org/tms/{}"
+    )
+    @Test
+    void shouldAddLinks() {
+        final AllureResults results = runFeature("features/tags.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getLinks)
+                .extracting(Link::getName, Link::getType, Link::getUrl)
+                .contains(
+                        tuple("OAT-4444", "tms", "https://example.org/tms/OAT-4444"),
+                        tuple("BUG-22400", "issue", "https://example.org/issue/BUG-22400")
+                );
+    }
+
+    @AllureFeatures.MarkerAnnotations
+    @Test
+    void shouldAddBddLabels() {
+        final AllureResults results = runFeature("features/tags.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getName, Label::getValue)
+                .contains(
+                        tuple("feature", "Test Simple Scenarios"),
+                        tuple("story", "Add a to b")
+                );
+    }
+
+    @AllureFeatures.Timeline
+    @Test
+    void shouldAddThreadHostLabels() {
+        final AllureResults results = runFeature("features/tags.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getName)
+                .contains("host", "thread");
+    }
+
+    @AllureFeatures.MarkerAnnotations
+    @Test
+    void shouldAddCommonLabels() {
+        final AllureResults results = runFeature("features/tags.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getName, Label::getValue)
+                .contains(
+                        tuple(PACKAGE_LABEL_NAME, "src.test.resources.features.tags_feature.Test Simple Scenarios"),
+                        tuple(SUITE_LABEL_NAME, "Test Simple Scenarios")
+                );
+
+        // scenarios are not represented by code, so the code-location labels stay unknown
+        assertThat(testResults)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getName)
+                .doesNotContain(TEST_CLASS_LABEL_NAME, TEST_METHOD_LABEL_NAME);
+    }
+
+    /**
+     * An undefined step breaks the scenario and carries a useful explanation; later steps stay skipped.
+     */
+    @AllureFeatures.BrokenTests
+    @AllureFeatures.Steps
+    @Test
+    @Description
+    void shouldProcessUndefinedSteps() {
+        final AllureResults results = runFeature("features/undefined.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getName, TestResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Step is not defined", Status.BROKEN)
+                );
+
+        final TestResult testResult = testResults.get(0);
+        assertThat(testResult.getStatusDetails().getMessage())
+                .isEqualTo(UNDEFINED_STEP_MESSAGE);
+
+        final List<StepResult> steps = testResult.getSteps();
+        assertThat(steps)
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly(
+                        tuple("Given a is 5", Status.PASSED),
+                        tuple("When step is undefined", Status.BROKEN),
+                        tuple("Then b is 10", Status.SKIPPED)
+                );
+        assertThat(steps.get(1).getStatusDetails().getMessage())
+                .isEqualTo(UNDEFINED_STEP_MESSAGE);
+    }
+
+    /**
+     * An undefined final step still breaks both the step and its scenario.
+     */
+    @AllureFeatures.BrokenTests
+    @AllureFeatures.Steps
+    @Test
+    @Description
+    void shouldProcessUndefinedLastStep() {
+        final AllureResults results = runFeature("features/undefined-last.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getName, TestResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Last step is not defined", Status.BROKEN)
+                );
+
+        final TestResult testResult = testResults.get(0);
+        assertThat(testResult.getStatusDetails().getMessage())
+                .isEqualTo(UNDEFINED_STEP_MESSAGE);
+
+        final List<StepResult> steps = testResult.getSteps();
+        assertThat(steps)
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly(
+                        tuple("Given a is 5", Status.PASSED),
+                        tuple("When step is undefined", Status.BROKEN)
+                );
+        assertThat(steps.get(1).getStatusDetails().getMessage())
+                .isEqualTo(UNDEFINED_STEP_MESSAGE);
+    }
+
+    @AllureFeatures.SkippedTests
+    @AllureFeatures.Steps
+    @Test
+    void shouldProcessPendingExceptionsInSteps() {
+        final AllureResults results = runFeature("features/pending.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getStatus)
+                .containsExactlyInAnyOrder(Status.SKIPPED);
+
+        assertThat(testResults.get(0).getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Given a is 5", Status.PASSED),
+                        tuple("When step is yet to be implemented", Status.SKIPPED),
+                        tuple("Then b is 10", Status.SKIPPED)
+                );
+    }
+
+    @AllureFeatures.Base
+    @Test
+    void shouldSupportDryRunForSimpleFeatures() {
+        final AllureResults results = runFeature("features/simple.feature", "--dry-run");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getName, TestResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Add a to b", Status.PASSED)
+                );
+
+        assertThat(testResults.get(0).getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Given a is 5", Status.PASSED),
+                        tuple("And b is 10", Status.PASSED),
+                        tuple("When I add a to b", Status.PASSED),
+                        tuple("Then result is 15", Status.PASSED)
+                );
+    }
+
+    @AllureFeatures.Fixtures
+    @AllureFeatures.Base
+    @Test
+    void shouldSupportDryRunForHooks() {
+        final AllureResults results = runFeature(
+                "features/hooks.feature", "--dry-run", "-t",
+                "@WithHooks or @BeforeHookWithException or @AfterHookWithException"
+        );
+
+        final TestResult tr1 = results.getTestResultByName("Simple scenario with Before and After hooks");
+
+        assertThat(results.getTestResultContainersForTestResult(tr1))
+                .flatExtracting(TestResultContainer::getBefores)
+                .extracting(FixtureResult::getName, FixtureResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("io.qameta.allure.cucumber8jvm.samples.HookSteps.beforeHook()", Status.PASSED)
+                );
+
+        assertThat(results.getTestResultContainersForTestResult(tr1))
+                .flatExtracting(TestResultContainer::getAfters)
+                .extracting(FixtureResult::getName, FixtureResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("io.qameta.allure.cucumber8jvm.samples.HookSteps.afterHook()", Status.PASSED)
+                );
+
+        assertThat(tr1.getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Given a is 7", Status.PASSED),
+                        tuple("And b is 8", Status.PASSED),
+                        tuple("When I add a to b", Status.PASSED),
+                        tuple("Then result is 15", Status.PASSED)
+                );
+    }
+
+    @AllureFeatures.History
+    @Test
+    void shouldPersistHistoryIdForScenarios() {
+        final AllureResults results = runFeature("features/simple.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults.get(0).getHistoryId())
+                .isEqualTo(md5(md5("src/test/resources/features/simple.feature:Add a to b")));
+    }
+
+    @AllureFeatures.History
+    @Test
+    void shouldPersistHistoryIdForExamples() {
+        final AllureResults results = runFeature("features/examples.feature", "--threads", "2");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getHistoryId)
+                .containsExactlyInAnyOrder(
+                        md5(
+                                md5("src/test/resources/features/examples.feature:Scenario with Positive Examples")
+                                        + "a1b3result4"
+                        ),
+                        md5(
+                                md5("src/test/resources/features/examples.feature:Scenario with Positive Examples")
+                                        + "a2b4result6"
+                        )
+                );
+    }
+
+    @AllureFeatures.History
+    @Test
+    void shouldPersistDifferentHistoryIdComparedToTheSameTestCaseInDifferentLocation() {
+        final AllureResults results1 = runFeature("features/simple.feature");
+        final AllureResults results2 = runFeature("features/same/simple.feature");
+
+        assertThat(results1.getTestResults().get(0).getHistoryId())
+                .isNotEqualTo(results2.getTestResults().get(0).getHistoryId());
+    }
+
+    @AllureFeatures.History
+    @Test
+    void shouldSetTestCaseIdForScenarios() {
+        final AllureResults results = runFeature("features/simple.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getName, TestResult::getTestCaseId)
+                .containsExactlyInAnyOrder(
+                        tuple(
+                                "Add a to b",
+                                md5("src/test/resources/features/simple.feature:Add a to b")
+                        )
+                );
+    }
+
+    @AllureFeatures.History
+    @Test
+    void shouldSetTestCaseIdForExamples() {
+        final AllureResults results = runFeature("features/examples.feature", "--threads", "2");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getName, TestResult::getTestCaseId)
+                .containsExactlyInAnyOrder(
+                        tuple(
+                                "Scenario with Positive Examples",
+                                md5("src/test/resources/features/examples.feature:Scenario with Positive Examples")
+                        ),
+                        tuple(
+                                "Scenario with Positive Examples",
+                                md5("src/test/resources/features/examples.feature:Scenario with Positive Examples")
+                        )
+                );
+    }
+
+    @AllureFeatures.Parallel
+    @Test
+    void shouldProcessScenariosInParallelMode() {
+        final AllureResults results = runFeature("features/parallel.feature", "--threads", "3");
+
+        final List<TestResult> testResults = results.getTestResults();
+
+        assertThat(testResults)
+                .hasSize(3);
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsSubsequence(
+                        "Given a is 1",
+                        "And b is 3",
+                        "When I add a to b",
+                        "Then result is 4"
+                );
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsSubsequence(
+                        "Given a is 2",
+                        "And b is 4",
+                        "When I add a to b",
+                        "Then result is 6"
+                );
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsSubsequence(
+                        "Given a is 7",
+                        "And b is 8",
+                        "When I add a to b",
+                        "Then result is 15"
+                );
+    }
+
+    @AllureFeatures.Fixtures
+    @AllureFeatures.Stages
+    @Test
+    void shouldDisplayHooksAsStages() {
+        final AllureResults results = runFeature(
+                "features/hooks.feature", "-t",
+                "@WithHooks or @BeforeHookWithException or @AfterHookWithException"
+        );
+
+        final TestResult tr1 = results.getTestResultByName("Simple scenario with Before and After hooks");
+        final TestResult tr2 = results.getTestResultByName("Simple scenario with Before hook with Exception");
+        final TestResult tr3 = results.getTestResultByName("Simple scenario with After hook with Exception");
+
+        assertThat(tr1.getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Given a is 7", Status.PASSED),
+                        tuple("And b is 8", Status.PASSED),
+                        tuple("When I add a to b", Status.PASSED),
+                        tuple("Then result is 15", Status.PASSED)
+                );
+
+        assertThat(results.getTestResultContainersForTestResult(tr1))
+                .flatExtracting(TestResultContainer::getBefores)
+                .extracting(FixtureResult::getName, FixtureResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("io.qameta.allure.cucumber8jvm.samples.HookSteps.beforeHook()", Status.PASSED)
+                );
+
+        assertThat(results.getTestResultContainersForTestResult(tr1))
+                .flatExtracting(TestResultContainer::getAfters)
+                .extracting(FixtureResult::getName, FixtureResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("io.qameta.allure.cucumber8jvm.samples.HookSteps.afterHook()", Status.PASSED)
+                );
+
+        assertThat(tr2.getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Given a is 7", Status.SKIPPED),
+                        tuple("And b is 8", Status.SKIPPED),
+                        tuple("When I add a to b", Status.SKIPPED),
+                        tuple("Then result is 15", Status.SKIPPED)
+                );
+
+        assertThat(results.getTestResultContainersForTestResult(tr2))
+                .flatExtracting(TestResultContainer::getBefores)
+                .extracting(FixtureResult::getName, FixtureResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("io.qameta.allure.cucumber8jvm.samples.HookSteps.beforeHookWithException()", Status.FAILED)
+                );
+
+        assertThat(tr3.getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Given a is 7", Status.PASSED),
+                        tuple("And b is 8", Status.PASSED),
+                        tuple("When I add a to b", Status.PASSED),
+                        tuple("Then result is 15", Status.PASSED)
+                );
+
+        assertThat(results.getTestResultContainersForTestResult(tr3))
+                .flatExtracting(TestResultContainer::getAfters)
+                .extracting(FixtureResult::getName, FixtureResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("io.qameta.allure.cucumber8jvm.samples.HookSteps.afterHookWithException()", Status.FAILED)
+                );
+
+    }
+
+    /**
+     * A failed Cucumber {@code @BeforeAll} hook is an error of the run. No scenario result is invented because the
+     * hook prevents every selected scenario from starting. Cucumber 8 reports that hook on a message envelope and
+     * {@code Runtime.run()} returns.
+     */
+    @AllureFeatures.Fixtures
+    @AllureFeatures.BrokenTests
+    @Test
+    @Description
+    void shouldReportBrokenBeforeAllAsGlobalError() {
+        final AllureResults results = runFeature(
+                "features/simple.feature",
+                "--glue", "io.qameta.allure.cucumber8jvm.runhooks.beforeall"
+        );
+
+        assertThat(results.getTestResults())
+                .as("the run-level hook failed before a scenario could start")
+                .isEmpty();
+        assertThat(getGlobalErrors(results))
+                .extracting(GlobalError::getMessage)
+                .singleElement()
+                .asString()
+                .contains("Cucumber test run failed, scenarios did not run: Exception in @BeforeAll")
+                .contains("BrokenBeforeAllHooks.beforeAll");
+    }
+
+    /**
+     * A failed Cucumber {@code @AfterAll} hook is an error of the run, while scenarios completed before the hook
+     * keep their own results. Cucumber 8 reports that hook on a message envelope and {@code Runtime.run()} returns.
+     */
+    @AllureFeatures.Fixtures
+    @AllureFeatures.BrokenTests
+    @Test
+    @Description
+    void shouldReportBrokenAfterAllAsGlobalError() {
+        final AllureResults results = runFeature(
+                "features/simple.feature",
+                "--glue", "io.qameta.allure.cucumber8jvm.runhooks.afterall"
+        );
+
+        assertThat(results.getTestResults())
+                .extracting(TestResult::getName, TestResult::getStatus)
+                .containsExactly(tuple("Add a to b", Status.PASSED));
+        assertThat(getGlobalErrors(results))
+                .extracting(GlobalError::getMessage)
+                .singleElement()
+                .asString()
+                .contains("Cucumber test run failed: Exception in @AfterAll")
+                .contains("BrokenAfterAllHooks.afterAll");
+    }
+
+    /**
+     * An ambiguous step breaks the scenario and preserves the matching step definitions and exception trace
+     * on both results; later steps stay skipped.
+     */
+    @AllureFeatures.BrokenTests
+    @AllureFeatures.Steps
+    @Test
+    @Description
+    void shouldHandleAmbigiousStepsExceptions() {
+        final AllureResults results = runFeature("features/ambigious.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getName, TestResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Simple scenario with ambigious steps", Status.BROKEN)
+                );
+
+        final TestResult testResult = testResults.get(0);
+        final StatusDetails statusDetails = testResult.getStatusDetails();
+        assertThat(statusDetails.getMessage())
+                .contains(
+                        "\"ambigious step present\" matches more than one step definition",
+                        "AmbigiousSteps.ambigious_1()",
+                        "AmbigiousSteps.ambigious_2()"
+                );
+        assertThat(statusDetails.getTrace())
+                .contains("io.cucumber.core.runner.AmbiguousStepDefinitionsException:", "\tat ");
+
+        final List<StepResult> steps = testResult.getSteps();
+        assertThat(steps)
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly(
+                        tuple("When ambigious step present", Status.BROKEN),
+                        tuple("Then something bad should happen", Status.SKIPPED)
+                );
+        final StatusDetails stepStatusDetails = steps.get(0).getStatusDetails();
+        assertThat(stepStatusDetails.getMessage())
+                .isEqualTo(statusDetails.getMessage());
+        assertThat(stepStatusDetails.getTrace())
+                .isEqualTo(statusDetails.getTrace());
+    }
+
+    @ResourceLock(
+            value = SYSTEM_PROPERTIES,
+            mode = READ_WRITE
+    )
+    @SystemProperty(
+            name = "allure.label.x-provided",
+            value = "cucumberjvm7-test-provided"
+    )
+    @Test
+    void shouldSupportProvidedLabels() {
+        final AllureResults results = runFeature("features/simple.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .hasSize(1)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getName, Label::getValue)
+                .contains(
+                        tuple("x-provided", "cucumberjvm7-test-provided")
+                );
+    }
+
+    @Test
+    void shouldSupportRuntimeApiInStepsWhenHooksAreUsed() {
+        final AllureResults results = runFeature("features/runtimeapi.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+
+        assertThat(testResults)
+                .hasSize(1)
+                .flatExtracting(TestResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly(
+                        "When step 1",
+                        "When step 2",
+                        "And step 3",
+                        "Then step 4",
+                        "And step 5"
+                );
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getLinks)
+                .extracting(Link::getName, Link::getUrl)
+                .containsExactly(
+                        tuple("step1", "https://example.org/step1"),
+                        tuple("step2", "https://example.org/step2"),
+                        tuple("step3", "https://example.org/step3"),
+                        tuple("step4", "https://example.org/step4"),
+                        tuple("step5", "https://example.org/step5")
+                );
+    }
+
+    @AllureFeatures.History
+    @AllureFeatures.Parameters
+    @Test
+    void shouldCalculateIdsFromRuntimeParametersAtTestEnd() {
+        final AllureResults results = runFeature("features/runtimeapi.feature");
+
+        final TestResult testResult = results.getTestResults().get(0);
+        assertThat(testResult.getParameters())
+                .extracting(Parameter::getName, Parameter::getValue, Parameter::getExcluded)
+                .containsExactlyInAnyOrder(
+                        tuple("runtime", "value", null),
+                        tuple("excluded", "ignored", true)
+                );
+        assertThat(testResult.getTestCaseId())
+                .isEqualTo(
+                        md5(
+                                "src/test/resources/features/runtimeapi.feature:Scenario with Runtime API usage"
+                        )
+                );
+        assertThat(testResult.getHistoryId())
+                .isEqualTo(
+                        md5(
+                                md5(
+                                        "src/test/resources/features/runtimeapi.feature:Scenario with Runtime API usage"
+                                ) + "runtimevalue"
+                        )
+                );
+    }
+
+    @SystemProperty(
+            name = "cucumber.junit-platform.naming-strategy",
+            value = "long"
+    )
+    @Step
+    private AllureResults runFeature(final String featureResource,
+                                     final String... moreOptions) {
+
+        return runFeature(featureResource, Runtime::run, moreOptions);
+    }
+
+    private AllureResults runFeature(final String featureResource,
+                                     final Consumer<Runtime> run,
+                                     final String... moreOptions) {
+
+        return RunUtils.runTests(lifecycle -> {
+            final AllureCucumber8Jvm cucumber8jvm = new AllureCucumber8Jvm(lifecycle);
+            final Supplier<ClassLoader> classLoader = ClassLoaders::getDefaultClassLoader;
+            final List<String> opts = new ArrayList<>(
+                    Arrays.asList(
+                            "--glue", "io.qameta.allure.cucumber8jvm.samples",
+                            "--no-summary"
+                    )
+            );
+            opts.addAll(Arrays.asList(moreOptions));
+            final FeatureWithLines featureWithLines = FeatureWithLines.parse("src/test/resources/" + featureResource);
+            final RuntimeOptions options = new CommandlineOptionsParser(System.out)
+                    .parse(opts.toArray(new String[]{})).addFeature(featureWithLines).build();
+
+            final EventBus bus = new TimeServiceEventBus(Clock.systemUTC(), UUID::randomUUID);
+            final FeatureParser parser = new FeatureParser(bus::generateId);
+            final FeaturePathFeatureSupplier supplier = new FeaturePathFeatureSupplier(classLoader, options, parser);
+
+            final Runtime runtime = Runtime.builder()
+                    .withClassLoader(classLoader)
+                    .withRuntimeOptions(options)
+                    .withAdditionalPlugins(cucumber8jvm)
+                    .withFeatureSupplier(supplier)
+                    .build();
+
+            run.accept(runtime);
+        });
+    }
+
+    private static List<GlobalError> getGlobalErrors(final AllureResults results) {
+        return results.getGlobals().stream()
+                .flatMap(globals -> globals.getErrors().stream())
+                .collect(Collectors.toList());
+    }
+
+}
diff --git a/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/runhooks/afterall/BrokenAfterAllHooks.java b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/runhooks/afterall/BrokenAfterAllHooks.java
new file mode 100644
index 000000000..65e68493f
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/runhooks/afterall/BrokenAfterAllHooks.java
@@ -0,0 +1,29 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm.runhooks.afterall;
+
+import io.cucumber.java.AfterAll;
+
+public final class BrokenAfterAllHooks {
+
+    private BrokenAfterAllHooks() {
+    }
+
+    @AfterAll
+    public static void afterAll() {
+        throw new RuntimeException("Exception in @AfterAll");
+    }
+}
diff --git a/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/runhooks/beforeall/BrokenBeforeAllHooks.java b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/runhooks/beforeall/BrokenBeforeAllHooks.java
new file mode 100644
index 000000000..dab42fb2a
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/runhooks/beforeall/BrokenBeforeAllHooks.java
@@ -0,0 +1,29 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm.runhooks.beforeall;
+
+import io.cucumber.java.BeforeAll;
+
+public final class BrokenBeforeAllHooks {
+
+    private BrokenBeforeAllHooks() {
+    }
+
+    @BeforeAll
+    public static void beforeAll() {
+        throw new RuntimeException("Exception in @BeforeAll");
+    }
+}
diff --git a/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/AmbigiousSteps.java b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/AmbigiousSteps.java
new file mode 100644
index 000000000..f31d9a6fb
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/AmbigiousSteps.java
@@ -0,0 +1,36 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm.samples;
+
+import io.cucumber.java.en.Then;
+import io.cucumber.java.en.When;
+public class AmbigiousSteps {
+
+    @When("^ambigious step (.+)$")
+    public void ambigious_1() {
+        // nothing here
+    }
+
+    @When("^ambigious step ([a-z]+)$")
+    public void ambigious_2() {
+        // nothing here
+    }
+
+    @Then("^something bad should happen")
+    public void somethingBadStep() {
+        //nothing here
+    }
+}
diff --git a/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/AttachmentSteps.java b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/AttachmentSteps.java
new file mode 100644
index 000000000..89cdf052d
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/AttachmentSteps.java
@@ -0,0 +1,39 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm.samples;
+
+import io.cucumber.java.Before;
+import io.cucumber.java.Scenario;
+import io.cucumber.java.en.Given;
+
+public class AttachmentSteps {
+    private Scenario scenario;
+
+    @Before("@attachments")
+    public void setup(Scenario scenario) {
+        this.scenario = scenario;
+    }
+
+    @Given("step with scenario write")
+    public void stepWithScenarioWrite() {
+        scenario.attach("text attachment".getBytes(), "text/plain", "TextAttachment");
+    }
+
+    @Given("step with scenario embed")
+    public void stepWithScenarioEmbed() {
+        scenario.attach("image attachment".getBytes(), "image/png", "ImageAttachment");
+    }
+}
diff --git a/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/BackgroundFeatureSteps.java b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/BackgroundFeatureSteps.java
new file mode 100644
index 000000000..d08e4bb05
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/BackgroundFeatureSteps.java
@@ -0,0 +1,39 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm.samples;
+
+import io.cucumber.java.en.Given;
+import io.cucumber.java.en.Then;
+import io.cucumber.java.en.When;
+public class BackgroundFeatureSteps {
+
+    @Given("^cat is sad$")
+    public void catIsSad() {
+    }
+
+    @Given("^cat is murmur$")
+    public void catIsMurMur() {
+    }
+
+    @When("^pet the cat$")
+    public void petTheCat() {
+    }
+
+    @Then("^cat is happy$")
+    public void catIsHappy() {
+    }
+
+}
diff --git a/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/BrokenFeatureSteps.java b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/BrokenFeatureSteps.java
new file mode 100644
index 000000000..8c9e33d31
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/BrokenFeatureSteps.java
@@ -0,0 +1,26 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm.samples;
+
+import io.cucumber.java.en.Given;
+public class BrokenFeatureSteps {
+
+    @Given("^everything is broken$")
+    public void everythingIsBroken() {
+        throw new RuntimeException("Oops");
+    }
+
+}
diff --git a/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/DatatableFeatureSteps.java b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/DatatableFeatureSteps.java
new file mode 100644
index 000000000..5ced2b0d6
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/DatatableFeatureSteps.java
@@ -0,0 +1,27 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm.samples;
+
+import io.cucumber.datatable.DataTable;
+import io.cucumber.java.en.Given;
+@SuppressWarnings("unused")
+public class DatatableFeatureSteps {
+
+    @Given("^users are:$")
+    public void usersAre(DataTable table) {
+    }
+
+}
diff --git a/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/HookSteps.java b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/HookSteps.java
new file mode 100644
index 000000000..02d201212
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/HookSteps.java
@@ -0,0 +1,60 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm.samples;
+
+import io.cucumber.java.After;
+import io.cucumber.java.Before;
+import org.assertj.core.api.Assertions;
+public class HookSteps {
+
+    @Before("@WithHooks")
+    public void beforeHook() {
+        // nothing
+    }
+
+    @After("@WithHooks")
+    public void afterHook() {
+        // nothing
+    }
+
+    @Before("@BeforeHookWithException")
+    public void beforeHookWithException() {
+        Assertions.fail("Exception in Hook step");
+    }
+
+    @After("@AfterHookWithException")
+    public void afterHookWithException() {
+        Assertions.fail("Exception in Hook step");
+    }
+
+    @Before("@bp")
+    public void beforePassed() {
+    }
+
+    @Before("@bf")
+    public void beforeFailed() {
+        throw new AssertionError("This hook should fail");
+    }
+
+    @After("@ap")
+    public void afterPassed() {
+    }
+
+    @After("@af")
+    public void afterFailed() {
+        throw new AssertionError("This hook should fail");
+    }
+}
diff --git a/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/PendingSteps.java b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/PendingSteps.java
new file mode 100644
index 000000000..79f0d6091
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/PendingSteps.java
@@ -0,0 +1,28 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm.samples;
+
+import io.cucumber.java.PendingException;
+import io.cucumber.java.en.Given;
+public class PendingSteps {
+
+    @Given("^step is yet to be implemented$")
+    public void stepIsYetToBeImplemented() {
+        // Write code here that turns the phrase above into concrete actions
+        throw new PendingException();
+    }
+
+}
diff --git a/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/RuntimeApiSteps.java b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/RuntimeApiSteps.java
new file mode 100644
index 000000000..752a0eb04
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/RuntimeApiSteps.java
@@ -0,0 +1,81 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm.samples;
+
+import io.cucumber.java.Before;
+import io.cucumber.java.en.And;
+import io.cucumber.java.en.Then;
+import io.cucumber.java.en.When;
+import io.qameta.allure.Allure;
+public class RuntimeApiSteps {
+
+    @Before("@beforeScenario")
+    public void beforeScenario() {
+        // nothing
+    }
+
+    @Before("@beforeFeature")
+    public void beforeFeature() {
+        // nothing
+    }
+
+    @When("^step 1$")
+    public void step1() {
+        Allure.parameter("runtime", "value");
+        Allure.parameter("excluded", "ignored", true);
+        Allure.step("step1 nested");
+        Allure.link("step1", "https://example.org/step1");
+        Allure.getLifecycle().getCurrentRootKey().ifPresent(key -> {
+            System.out.println("step1: " + key);
+        });
+    }
+
+    @When("^step 2$")
+    public void step2() {
+        Allure.step("step2 nested");
+        Allure.link("step2", "https://example.org/step2");
+        Allure.getLifecycle().getCurrentRootKey().ifPresent(key -> {
+            System.out.println("step2: " + key);
+        });
+    }
+
+    @And("^step 3$")
+    public void step3() {
+        Allure.step("step3 nested");
+        Allure.link("step3", "https://example.org/step3");
+        Allure.getLifecycle().getCurrentRootKey().ifPresent(key -> {
+            System.out.println("step3: " + key);
+        });
+    }
+
+    @Then("^step 4$")
+    public void step4() {
+        Allure.step("step4 nested");
+        Allure.link("step4", "https://example.org/step4");
+        Allure.getLifecycle().getCurrentRootKey().ifPresent(key -> {
+            System.out.println("step4: " + key);
+        });
+    }
+
+    @And("^step 5$")
+    public void step5() {
+        Allure.step("step5 nested");
+        Allure.link("step5", "https://example.org/step5");
+        Allure.getLifecycle().getCurrentRootKey().ifPresent(key -> {
+            System.out.println("step5: " + key);
+        });
+    }
+}
diff --git a/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/SimpleFeatureSteps.java b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/SimpleFeatureSteps.java
new file mode 100644
index 000000000..6ad4fe7f2
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/java/io/qameta/allure/cucumber8jvm/samples/SimpleFeatureSteps.java
@@ -0,0 +1,51 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber8jvm.samples;
+
+import io.cucumber.java.en.Given;
+import io.cucumber.java.en.Then;
+import io.cucumber.java.en.When;
+import org.assertj.core.api.Assertions;
+public class SimpleFeatureSteps {
+
+    private int a;
+    private int b;
+    private int c;
+
+    @Given("^a is (\\d+)$")
+    public void a_is(int arg1) {
+        this.a = arg1;
+    }
+
+    @Given("^b is (\\d+)$")
+    public void b_is(int arg1) {
+        this.b = arg1;
+    }
+
+    @When("^I add a to b$")
+    public void i_add_a_to_b() {
+        this.c = this.a + this.b;
+    }
+
+    @Then("^result is (\\d+)$")
+    public void result_is(int arg1) {
+        // use manual fail for more stable message format
+        if (this.c != arg1) {
+            Assertions.fail("expecting %d to be equal to %d", this.c, arg1);
+        }
+    }
+
+}
diff --git a/allure-cucumber8-jvm/src/test/resources/allure.properties b/allure-cucumber8-jvm/src/test/resources/allure.properties
new file mode 100644
index 000000000..bf879dea0
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/allure.properties
@@ -0,0 +1,4 @@
+allure.model.indentOutput=true
+allure.results.directory=build/allure-results
+allure.label.epic=#project.description#
+allure.label.module=allure-cucumber8-jvm
diff --git a/allure-cucumber8-jvm/src/test/resources/features/ambigious.feature b/allure-cucumber8-jvm/src/test/resources/features/ambigious.feature
new file mode 100644
index 000000000..921223a39
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/ambigious.feature
@@ -0,0 +1,5 @@
+Feature: Feature with ambigious steps
+
+  Scenario: Simple scenario with ambigious steps
+    When ambigious step present
+    Then something bad should happen
diff --git a/allure-cucumber8-jvm/src/test/resources/features/attachments.feature b/allure-cucumber8-jvm/src/test/resources/features/attachments.feature
new file mode 100644
index 000000000..1585fbe81
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/attachments.feature
@@ -0,0 +1,8 @@
+@attachments
+Feature: Feature with attachments
+
+  Scenario: Simple scenario with a text attachment
+    Given step with scenario write
+
+  Scenario: Simple scenario with an image attachment
+    Given step with scenario embed
\ No newline at end of file
diff --git a/allure-cucumber8-jvm/src/test/resources/features/background.feature b/allure-cucumber8-jvm/src/test/resources/features/background.feature
new file mode 100644
index 000000000..307f10267
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/background.feature
@@ -0,0 +1,9 @@
+Feature: Test Scenarios with backgrounds
+
+  Background:
+    Given cat is sad
+    And cat is murmur
+
+  Scenario: Scenario with background
+    When Pet the cat
+    Then Cat is happy
diff --git a/allure-cucumber8-jvm/src/test/resources/features/broken.feature b/allure-cucumber8-jvm/src/test/resources/features/broken.feature
new file mode 100644
index 000000000..42bd7ba4f
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/broken.feature
@@ -0,0 +1,4 @@
+Feature: Simple feature
+
+  Scenario: Exception during step
+    Given everything is broken
diff --git a/allure-cucumber8-jvm/src/test/resources/features/datatable.feature b/allure-cucumber8-jvm/src/test/resources/features/datatable.feature
new file mode 100644
index 000000000..35fe82242
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/datatable.feature
@@ -0,0 +1,8 @@
+Feature: Test Scenarios with Data Tables
+
+  Scenario: Simple data table
+    Given users are:
+      | name    | login    | email          |
+      | Viktor  | clicman  | clicman@ya.ru  |
+      | Viktor2 | clicman2 | clicman2@ya.ru |
+      | Comma, User | quote "login" | comma@example.org |
diff --git a/allure-cucumber8-jvm/src/test/resources/features/description.feature b/allure-cucumber8-jvm/src/test/resources/features/description.feature
new file mode 100644
index 000000000..935b6731a
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/description.feature
@@ -0,0 +1,17 @@
+Feature: Descriptions feature
+
+This is description for current feature.
+It should appear on each scenario in report
+
+  Scenario: Add a to b (1)
+    Given a is 5
+    And b is 10
+    When I add a to b
+    Then result is 15
+
+  Scenario: Add a to b (2)
+    Given a is 1
+    And b is 2
+    When I add a to b
+    Then result is 3
+
diff --git a/allure-cucumber8-jvm/src/test/resources/features/examples.feature b/allure-cucumber8-jvm/src/test/resources/features/examples.feature
new file mode 100644
index 000000000..ecba7b79e
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/examples.feature
@@ -0,0 +1,11 @@
+Feature: Test Scenarios with Examples
+
+  Scenario Outline: Scenario with Positive Examples
+    Given a is <a>
+    And b is <b>
+    When I add a to b
+    Then result is <result>
+    Examples:
+      | a | b | result |
+      | 1 | 3 | 4      |
+      | 2 | 4 | 6      |
diff --git a/allure-cucumber8-jvm/src/test/resources/features/failed.feature b/allure-cucumber8-jvm/src/test/resources/features/failed.feature
new file mode 100644
index 000000000..a70f8ec79
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/failed.feature
@@ -0,0 +1,7 @@
+Feature: Simple feature
+
+  Scenario: Add a to b
+    Given a is 5
+    And b is 10
+    When I add a to b
+    Then result is 123
diff --git a/allure-cucumber8-jvm/src/test/resources/features/hooks.feature b/allure-cucumber8-jvm/src/test/resources/features/hooks.feature
new file mode 100644
index 000000000..aca3f5b1b
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/hooks.feature
@@ -0,0 +1,98 @@
+Feature: Scenarios with hooks
+
+  @WithHooks
+  Scenario: Simple scenario with Before and After hooks
+    Given a is 7
+    And b is 8
+    When I add a to b
+    Then result is 15
+
+  @BeforeHookWithException
+  Scenario: Simple scenario with Before hook with Exception
+    Given a is 7
+    And b is 8
+    When I add a to b
+    Then result is 15
+
+  @AfterHookWithException
+  Scenario: Simple scenario with After hook with Exception
+    Given a is 7
+    And b is 8
+    When I add a to b
+    Then result is 15
+
+  @bp @af @bp_sf_af
+  Scenario: Scenario with good before and bad after but failed
+    Given a is 1
+    And b is 1
+    When I add a to b
+    Then result is 3
+
+
+  @bf @ap @bf_ap
+  Scenario: Scenario with bad before and good after
+    Given a is 1
+    And b is 1
+    When I add a to b
+    Then result is 2
+
+
+  @bf @af @bf_af
+  Scenario: Scenario with bad before and bad after
+    Given a is 1
+    And b is 1
+    When I add a to b
+    Then result is 2
+
+
+  @bp @af @bp_af
+  Scenario: Scenario with bad after
+    Given a is 1
+    And b is 1
+    When I add a to b
+    Then result is 2
+
+
+  @bp @ap @bp_sf_ap
+  Scenario: Scenario with good before and good after but failed
+    Given a is 1
+    And b is 1
+    When I add a to b
+    Then result is 3
+
+
+  @bp @af @bp_su_af
+  Scenario: Step is not implemented with bad after
+    Given hello my friend
+
+
+  @bp @ap @bp_su_ap
+  Scenario: Step is not implemented
+    Given hello my friend
+
+
+  @bp @ap @bp_suf_ap
+  Scenario: Step is not implemented
+    Given hello my friend
+    Given a is 1
+    And b is 1
+    When I add a to b
+    Then result is 3
+
+
+  @bp @ap @bp_spu_ap
+  Scenario: Step is not implemented
+    Given a is 1
+    And b is 1
+    When I add a to b
+    Then result is 2
+    Given hello my friend
+
+
+  @bp @ap @bp_sfu_ap
+  Scenario: Step is not implemented
+    Given a is 1
+    And b is 1
+    When I add a to b
+    Then result is 3
+    Given hello my friend
diff --git a/allure-cucumber8-jvm/src/test/resources/features/metadata-tags.feature b/allure-cucumber8-jvm/src/test/resources/features/metadata-tags.feature
new file mode 100644
index 000000000..63bb5bb52
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/metadata-tags.feature
@@ -0,0 +1,16 @@
+@allure.label.parentSuite:Cucumber
+@allure.label.suite:Petstore
+@allure.label.subSuite:CRUD
+Feature: Arithmetic_operations
+
+  Scenario Outline: Addition
+    Given a is <a>
+    And b is <b>
+    When I add a to b
+    Then result is <result>
+
+    Examples:
+      | a | b | result |
+      | 1 | 1 | 2      |
+      | 2 | 1 | 3      |
+      | 2 | 7 | 9      |
diff --git a/allure-cucumber8-jvm/src/test/resources/features/multi-examples.feature b/allure-cucumber8-jvm/src/test/resources/features/multi-examples.feature
new file mode 100644
index 000000000..04fb2cfef
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/multi-examples.feature
@@ -0,0 +1,17 @@
+Feature: Test Scenarios with  multiple Examples
+
+  Scenario Outline: Scenario with Multiple Examples
+    Given a is <a>
+    And b is <b>
+    When I add a to b
+    Then result is <result>
+
+    @ExamplesTag1
+    Examples:
+      | a | b | result |
+      | 1 | 3 | 4      |
+
+    @ExamplesTag2
+    Examples:
+      | a | b | result |
+      | 2 | 4 | 6      |
\ No newline at end of file
diff --git a/allure-cucumber8-jvm/src/test/resources/features/parallel.feature b/allure-cucumber8-jvm/src/test/resources/features/parallel.feature
new file mode 100644
index 000000000..a99d46839
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/parallel.feature
@@ -0,0 +1,17 @@
+Feature: Parallel execution of pickles
+
+  Scenario Outline: Simple scenario outline with examples
+    Given a is <a>
+    And b is <b>
+    When I add a to b
+    Then result is <result>
+    Examples:
+      | a | b | result |
+      | 1 | 3 | 4      |
+      | 2 | 4 | 6      |
+
+  Scenario: Simple scenario
+    Given a is 7
+    And b is 8
+    When I add a to b
+    Then result is 15
diff --git a/allure-cucumber8-jvm/src/test/resources/features/pending.feature b/allure-cucumber8-jvm/src/test/resources/features/pending.feature
new file mode 100644
index 000000000..5ad9c3438
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/pending.feature
@@ -0,0 +1,6 @@
+Feature: Simple feature with Pending steps
+
+  Scenario: Step is not implemented
+    Given a is 5
+    When step is yet to be implemented
+    Then b is 10
diff --git a/allure-cucumber8-jvm/src/test/resources/features/runtimeapi.feature b/allure-cucumber8-jvm/src/test/resources/features/runtimeapi.feature
new file mode 100644
index 000000000..ec43eccb7
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/runtimeapi.feature
@@ -0,0 +1,10 @@
+@beforeFeature
+Feature: Should support runtime API in all steps
+
+  @beforeScenario
+  Scenario: Scenario with Runtime API usage
+    When step 1
+    When step 2
+    And step 3
+    Then step 4
+    And step 5
diff --git a/allure-cucumber8-jvm/src/test/resources/features/same/simple.feature b/allure-cucumber8-jvm/src/test/resources/features/same/simple.feature
new file mode 100644
index 000000000..c5b5f2b5f
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/same/simple.feature
@@ -0,0 +1,7 @@
+Feature: Simple feature
+
+  Scenario: Add a to b
+    Given a is 5
+    And b is 10
+    When I add a to b
+    Then result is 15
diff --git a/allure-cucumber8-jvm/src/test/resources/features/scenario_description.feature b/allure-cucumber8-jvm/src/test/resources/features/scenario_description.feature
new file mode 100644
index 000000000..fe49efe31
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/scenario_description.feature
@@ -0,0 +1,19 @@
+Feature: Descriptions feature
+
+This is description for current feature.
+It should appear on each scenario in report
+
+  Scenario: Add a to b (1)
+    scenario description 1
+    Given a is 5
+    And b is 10
+    When I add a to b
+    Then result is 15
+
+  Scenario: Add a to b (2)
+    scenario description 2
+    Given a is 1
+    And b is 2
+    When I add a to b
+    Then result is 3
+
diff --git a/allure-cucumber8-jvm/src/test/resources/features/simple.feature b/allure-cucumber8-jvm/src/test/resources/features/simple.feature
new file mode 100644
index 000000000..c5b5f2b5f
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/simple.feature
@@ -0,0 +1,7 @@
+Feature: Simple feature
+
+  Scenario: Add a to b
+    Given a is 5
+    And b is 10
+    When I add a to b
+    Then result is 15
diff --git a/allure-cucumber8-jvm/src/test/resources/features/status-tags.feature b/allure-cucumber8-jvm/src/test/resources/features/status-tags.feature
new file mode 100644
index 000000000..0b384f226
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/status-tags.feature
@@ -0,0 +1,9 @@
+@muted
+Feature: Status tags
+
+  @flaky @known
+  Scenario: Marked scenario
+    Given a is 5
+    And b is 10
+    When I add a to b
+    Then result is 15
diff --git a/allure-cucumber8-jvm/src/test/resources/features/tags.feature b/allure-cucumber8-jvm/src/test/resources/features/tags.feature
new file mode 100644
index 000000000..2632623ee
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/tags.feature
@@ -0,0 +1,13 @@
+@FeatureTag
+@tmsLink=OAT-4444
+@flaky
+@issue=BUG-22400
+Feature: Test Simple Scenarios
+
+  @good
+  Scenario: Add a to b
+    Given a is 5
+    And b is 10
+    When I add a to b
+    Then result is 15
+
diff --git a/allure-cucumber8-jvm/src/test/resources/features/undefined-last.feature b/allure-cucumber8-jvm/src/test/resources/features/undefined-last.feature
new file mode 100644
index 000000000..2e518889b
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/undefined-last.feature
@@ -0,0 +1,5 @@
+Feature: Simple feature with an undefined last step
+
+  Scenario: Last step is not defined
+    Given a is 5
+    When step is undefined
diff --git a/allure-cucumber8-jvm/src/test/resources/features/undefined.feature b/allure-cucumber8-jvm/src/test/resources/features/undefined.feature
new file mode 100644
index 000000000..39475ff7d
--- /dev/null
+++ b/allure-cucumber8-jvm/src/test/resources/features/undefined.feature
@@ -0,0 +1,6 @@
+Feature: Simple feature with undefined steps
+
+  Scenario: Step is not defined
+    Given  a is 5
+    When step is undefined
+    Then b is 10
diff --git a/allure-jpms-tests/build.gradle.kts b/allure-jpms-tests/build.gradle.kts
index 9229092a8..7e0d348cc 100644
--- a/allure-jpms-tests/build.gradle.kts
+++ b/allure-jpms-tests/build.gradle.kts
@@ -23,6 +23,7 @@ dependencies {
     publishedJars(project(":allure-assertj"))
     publishedJars(project(":allure-awaitility"))
     publishedJars(project(":allure-cucumber7-jvm"))
+    publishedJars(project(":allure-cucumber8-jvm"))
     publishedJars(project(":allure-descriptions-javadoc"))
     publishedJars(project(":allure-grpc"))
     publishedJars(project(":allure-hamcrest"))
@@ -66,7 +67,7 @@ dependencies {
     consumerJars("net.javacrumbs.json-unit:json-unit:5.1.2")
     // Exercise JsonUnit with either consumer-selected JSON provider.
     consumerJars("com.fasterxml.jackson.core:jackson-databind")
-    consumerJars("com.google.code.gson:gson:2.14.0")
+    consumerJars("com.google.code.gson:gson:2.11.0")
     consumerJars("com.google.errorprone:error_prone_annotations:2.50.0")
     consumerJars("org.spockframework:spock-core:2.4-groovy-5.0")
     consumerJars("org.apache.groovy:groovy:5.1.2")
diff --git a/settings.gradle.kts b/settings.gradle.kts
index e358c0c6f..0fce393dd 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -5,6 +5,7 @@ include("allure-awaitility")
 include("allure-bom")
 include("allure-citrus")
 include("allure-cucumber7-jvm")
+include("allure-cucumber8-jvm")
 include("allure-descriptions-javadoc")
 include("allure-grpc")
 include("allure-hamcrest")