diff --git a/tasks/konstantinov_s_broadcast/common/include/common.hpp b/tasks/konstantinov_s_broadcast/common/include/common.hpp
new file mode 100644
index 0000000000..bfa6caacec
--- /dev/null
+++ b/tasks/konstantinov_s_broadcast/common/include/common.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "task/include/task.hpp"
+
+namespace konstantinov_s_broadcast {
+
+using TestType = std::tuple<int, std::string>;
+
+using ETypeInt = int;
+using ETypeFloat = float;
+using ETypeDouble = double;
+
+using EType = ETypeInt;
+using InType = std::vector<EType>;
+using OutType = InType;
+
+template <typename T>
+using BaseTask = ppc::task::Task<std::vector<T>, std::vector<T>>;
+
+}  // namespace konstantinov_s_broadcast
diff --git a/tasks/konstantinov_s_broadcast/info.json b/tasks/konstantinov_s_broadcast/info.json
new file mode 100644
index 0000000000..b0c7a6f67f
--- /dev/null
+++ b/tasks/konstantinov_s_broadcast/info.json
@@ -0,0 +1,9 @@
+{
+  "student": {
+    "first_name": "Семён",
+    "last_name": "Константинов",
+    "middle_name": "Анатольевич",
+    "group_number": "3823Б1ФИ3",
+    "task_number": "2"
+  }
+}
diff --git a/tasks/konstantinov_s_broadcast/mpi/include/ops_mpi.hpp b/tasks/konstantinov_s_broadcast/mpi/include/ops_mpi.hpp
new file mode 100644
index 0000000000..fa1971a72d
--- /dev/null
+++ b/tasks/konstantinov_s_broadcast/mpi/include/ops_mpi.hpp
@@ -0,0 +1,46 @@
+#pragma once
+#include <mpi.h>
+
+#include <vector>
+
+#include "konstantinov_s_broadcast/common/include/common.hpp"
+#include "task/include/task.hpp"
+
+namespace konstantinov_s_broadcast {
+
+template <typename T>
+class KonstantinovSBroadcastMPI : public BaseTask<T> {
+ public:
+  using InType = std::vector<T>;
+  using OutType = InType;
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kMPI;
+  }
+  explicit KonstantinovSBroadcastMPI(const InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+};
+
+template <typename T>
+constexpr MPI_Datatype GetMpiType();
+
+template <>
+constexpr MPI_Datatype GetMpiType<int>() {
+  return MPI_INT;
+}
+
+template <>
+constexpr MPI_Datatype GetMpiType<float>() {
+  return MPI_FLOAT;
+}
+
+template <>
+constexpr MPI_Datatype GetMpiType<double>() {
+  return MPI_DOUBLE;
+}
+
+}  // namespace konstantinov_s_broadcast
diff --git a/tasks/konstantinov_s_broadcast/mpi/src/ops_mpi.cpp b/tasks/konstantinov_s_broadcast/mpi/src/ops_mpi.cpp
new file mode 100644
index 0000000000..af692f2a34
--- /dev/null
+++ b/tasks/konstantinov_s_broadcast/mpi/src/ops_mpi.cpp
@@ -0,0 +1,101 @@
+#include "konstantinov_s_broadcast/mpi/include/ops_mpi.hpp"
+
+#include <mpi.h>
+
+#include <cstring>
+// #include<iostream>
+#include <algorithm>
+
+#include "konstantinov_s_broadcast/common/include/common.hpp"
+// #include "util/include/util.hpp"
+
+namespace konstantinov_s_broadcast {
+
+template <typename T>
+KonstantinovSBroadcastMPI<T>::KonstantinovSBroadcastMPI(const InType &in) {
+  this->SetTypeOfTask(GetStaticTypeOfTask());
+  this->GetInput() = in;
+  this->GetOutput().resize(this->GetInput().size());
+}
+
+template <typename T>
+bool KonstantinovSBroadcastMPI<T>::ValidationImpl() {
+  // std::cout << "\t\tValidation mpi\n";
+  return !this->GetInput().empty();
+}
+
+template <typename T>
+bool KonstantinovSBroadcastMPI<T>::PreProcessingImpl() {
+  return true;
+}
+
+template <typename T>
+bool KonstantinovSBroadcastMPI<T>::RunImpl() {
+  int prank = 0;
+  int pcount = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &prank);
+  MPI_Comm_size(MPI_COMM_WORLD, &pcount);
+
+  const int tag_count = 1;
+  const int tag_data = 2;
+
+  MPI_Datatype mpi_type = GetMpiType<T>();
+
+  T *odata = nullptr;
+
+  int root_prank = pcount - 1;
+  int k = std::min(2, pcount);  // k-арное дерево
+
+  // ранг процесса в дереве
+  int tree_rank = (prank - root_prank + pcount) % pcount;
+
+  // родитель в дереве
+  int parent_tree_rank = (tree_rank == 0) ? -1 : (tree_rank - 1) / k;
+  int parent_prank = (parent_tree_rank < 0) ? -1 : (parent_tree_rank + root_prank) % pcount;
+
+  int recv_count = 0;
+  // приём данных от родителя (корень читает доступные ему данные)
+  if (tree_rank == 0) {
+    auto &ibuffer = this->GetInput();
+    int elem_count = static_cast<int>(ibuffer.size());
+    odata = ibuffer.data();
+    recv_count = elem_count;
+    this->GetOutput() = ibuffer;
+  } else {
+    // std::cout << "Rank " << prank << " (t " << tree_rank << ") recv from "<< parent_prank << " (t " <<
+    // parent_tree_rank << ")\n";
+    MPI_Recv(&recv_count, 1, MPI_INT, parent_prank, tag_count, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    odata = new T[recv_count];
+    MPI_Recv(odata, recv_count, mpi_type, parent_prank, tag_data, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    memcpy(this->GetOutput().data(), odata, recv_count * sizeof(T));
+  }
+
+  // вычисляем потомков и рассылаем
+  // std::vector<int> child_pranks;
+  for (int i = 1; i <= k; ++i) {
+    int child_tree_rank = (k * tree_rank) + i;
+    if (child_tree_rank < pcount) {
+      int child_prank = (child_tree_rank + root_prank) % pcount;
+      // std::cout << "Rank " << prank << " (t " << tree_rank << ") send to " << ch << "\n";
+      MPI_Send(&recv_count, 1, MPI_INT, child_prank, tag_count, MPI_COMM_WORLD);
+      MPI_Send(odata, recv_count, mpi_type, child_prank, tag_data, MPI_COMM_WORLD);
+      // child_pranks.push_back(child_prank);
+    }
+  }
+  if (tree_rank != 0) {
+    delete[] odata;
+  }
+
+  // this->GetOutput() = ibuffer;
+  return true;
+}
+
+template <typename T>
+bool KonstantinovSBroadcastMPI<T>::PostProcessingImpl() {
+  return true;
+}
+template class KonstantinovSBroadcastMPI<ETypeInt>;
+template class KonstantinovSBroadcastMPI<ETypeFloat>;
+template class KonstantinovSBroadcastMPI<ETypeDouble>;
+
+}  // namespace konstantinov_s_broadcast
diff --git a/tasks/konstantinov_s_broadcast/report.md b/tasks/konstantinov_s_broadcast/report.md
new file mode 100644
index 0000000000..9a3129db0c
--- /dev/null
+++ b/tasks/konstantinov_s_broadcast/report.md
@@ -0,0 +1,57 @@
+# Передача от одного всем (broadcast)
+
+- Student: Константинов Семён Анатольевич, group 3823Б1ФИ3
+- Technology: SEQ | MPI
+- Variant: 1
+
+## 1. Introduction
+Эффективная рассылка данных от одного процесса всем остальным - важная часть в работе MPI, реализуемая функцией MPI_Bcast. Алгоритм пересылки данных можно повторить, взяв за основу идею k-арного дерева и используя только базовые операции `MPI_Recv` и `MPI_Send`.
+## 2. Problem Statement
+### Входные данные:
+- Ранг процесса, который будет корневым в дереве
+- Массив входных данных
+### Выходные данные:
+- Одинаковые массивы на всех процессах, совпадающие с входным массивом
+## 3. Baseline Algorithm (Sequential)
+Последовательный алгоритм не имеет смысла в контексте алгоритмов обмена данными между процессами. Реализовано копирование входного массива в выходной.
+
+## 4. Parallelization Scheme
+Алгоритм основан на k-арном дереве: каждый процесс из своего ранга процесса `prank`, ранга корня дерева `root_prank` и количества процессов `pcount` получает свой ранг в дереве `tree_rank = (prank - root_prank + pcount) % pcount`. Из тех же данных вычисляются ранги в дереве и ранги процесса у родителя процесса и каждого из от 0 до k детей процесса.
+```
+ parent_tree_rank = (tree_rank == 0) ? -1 : (tree_rank - 1) / k;
+ parent_prank = (parent_tree_rank < 0) ? -1 : (parent_tree_rank + root_prank) % pcount;
+ child_tree_rank = (k * tree_rank) + i<k;
+ child_prank = (child_tree_rank + root_prank) % pcount
+```
+Сначала процессы ожидают данные от своего родителя (сначала данные о размере массива с помощью MPI_Recv с тегом tag_count, затем сам массив с тегом tag_count). Уже имеющие данные (сначала только корень) отсылают их своим детям через MPI_Send с аналогичными тегами.
+Таким образом данные достигают всех процессов за log от числа процессов операций.
+
+## 5. Experimental Setup
+- Hardware/OS: ЦП AMD Ryzen 5 3600 6-Core Processor, 16 GB RAM, Windows 10 x64
+- Toolchain: Cmake 4.2.0, Visual Studio 2022, MSVC, x64 Release
+- Environment: PPC_NUM_THREADS=PPC_NUM_PROC=1/2/4/6/8/10/12/14/16/20/24/32/40/60/80, PPC_PERF_MAX_TIME=10000
+- Data: стабильная генерация тестовых данных разного размера, различный выбор корня дерева
+
+## 6. Results and Discussion
+
+### 6.1 Correctness
+Корректность проверяется сравнением входного и выходного массивов.
+Корректность проверена на векторах разных размеров.
+
+### 6.2 Performance
+Измерение производительности не имеет смысла, так как количество работы зависит от числа процессов, но оно было проведено.
+За эталон производительности взято время выполнения mpi версии на одном процессе.
+
+| Count | Time, s | Speedup | Efficiency |
+| ----- | ------- | ------- | ---------- |
+| 1     | 0.0260  | 1.00    | N/A        |
+| 2     | 0.0263  | 0.98    | 49.4%      |
+| 4     | 0.0422  | 0.61    | 15.4%      |
+| 8     | 0.0894  | 0.29    | 0.036%     |
+| 12    | 0.1256  | 0.207   | 0.017%     |
+| 24    | 0.2550  | 0.102   | 0.004%     |
+
+## 7. Conclusions
+Была разработана реализация алгоритма передачи данных от одного процесса на все. Реализация шаблонная, позволяет пересылать любые тривиально копируемые типы данных, алгоритм построения дерева позволяет выбрать любой процесс в качестве корня.
+## 8. References
+1. Курс лекций ННГУ "Параллельное программирование для кластерных систем"
\ No newline at end of file
diff --git a/tasks/konstantinov_s_broadcast/seq/include/ops_seq.hpp b/tasks/konstantinov_s_broadcast/seq/include/ops_seq.hpp
new file mode 100644
index 0000000000..323efa645f
--- /dev/null
+++ b/tasks/konstantinov_s_broadcast/seq/include/ops_seq.hpp
@@ -0,0 +1,25 @@
+#pragma once
+#include <vector>
+
+#include "konstantinov_s_broadcast/common/include/common.hpp"
+#include "task/include/task.hpp"
+
+namespace konstantinov_s_broadcast {
+template <typename T>
+class KonstantinovSBroadcastSEQ : public BaseTask<T> {
+ public:
+  using InType = std::vector<T>;
+  using OutType = InType;
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kSEQ;
+  }
+  explicit KonstantinovSBroadcastSEQ(const InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+};
+
+}  // namespace konstantinov_s_broadcast
diff --git a/tasks/konstantinov_s_broadcast/seq/src/ops_seq.cpp b/tasks/konstantinov_s_broadcast/seq/src/ops_seq.cpp
new file mode 100644
index 0000000000..227084a1b9
--- /dev/null
+++ b/tasks/konstantinov_s_broadcast/seq/src/ops_seq.cpp
@@ -0,0 +1,40 @@
+#include "konstantinov_s_broadcast/seq/include/ops_seq.hpp"
+
+// #include <iostream>
+// #include <numeric>
+#include <cstring>  // memcpy
+
+#include "konstantinov_s_broadcast/common/include/common.hpp"
+// #include "util/include/util.hpp"
+
+namespace konstantinov_s_broadcast {
+template <typename T>
+KonstantinovSBroadcastSEQ<T>::KonstantinovSBroadcastSEQ(const InType &in) {
+  this->SetTypeOfTask(GetStaticTypeOfTask());
+  this->GetInput() = in;
+  this->GetOutput().resize(this->GetInput().size());
+}
+template <typename T>
+bool KonstantinovSBroadcastSEQ<T>::ValidationImpl() {
+  // std::cout << "\t\tValidation seq\n";
+  return !this->GetInput().empty();
+}
+template <typename T>
+bool KonstantinovSBroadcastSEQ<T>::PreProcessingImpl() {
+  return true;
+}
+template <typename T>
+bool KonstantinovSBroadcastSEQ<T>::RunImpl() {
+  memcpy(this->GetOutput().data(), this->GetInput().data(), this->GetInput().size() * sizeof(T));
+  return true;
+}
+template <typename T>
+bool KonstantinovSBroadcastSEQ<T>::PostProcessingImpl() {
+  return true;
+}
+
+template class KonstantinovSBroadcastSEQ<ETypeInt>;
+template class KonstantinovSBroadcastSEQ<ETypeFloat>;
+template class KonstantinovSBroadcastSEQ<ETypeDouble>;
+
+}  // namespace konstantinov_s_broadcast
diff --git a/tasks/konstantinov_s_broadcast/settings.json b/tasks/konstantinov_s_broadcast/settings.json
new file mode 100644
index 0000000000..b1a0d52574
--- /dev/null
+++ b/tasks/konstantinov_s_broadcast/settings.json
@@ -0,0 +1,7 @@
+{
+  "tasks_type": "processes",
+  "tasks": {
+    "mpi": "enabled",
+    "seq": "enabled"
+  }
+}
diff --git a/tasks/konstantinov_s_broadcast/tests/.clang-tidy b/tasks/konstantinov_s_broadcast/tests/.clang-tidy
new file mode 100644
index 0000000000..ef43b7aa8a
--- /dev/null
+++ b/tasks/konstantinov_s_broadcast/tests/.clang-tidy
@@ -0,0 +1,13 @@
+InheritParentConfig: true
+
+Checks: >
+  -modernize-loop-convert,
+  -cppcoreguidelines-avoid-goto,
+  -cppcoreguidelines-avoid-non-const-global-variables,
+  -misc-use-anonymous-namespace,
+  -modernize-use-std-print,
+  -modernize-type-traits
+
+CheckOptions:
+  - key: readability-function-cognitive-complexity.Threshold
+    value: 50  # Relaxed for tests
diff --git a/tasks/konstantinov_s_broadcast/tests/functional/main.cpp b/tasks/konstantinov_s_broadcast/tests/functional/main.cpp
new file mode 100644
index 0000000000..de12fb9c81
--- /dev/null
+++ b/tasks/konstantinov_s_broadcast/tests/functional/main.cpp
@@ -0,0 +1,78 @@
+#include <gtest/gtest.h>
+#include <stb/stb_image.h>
+
+// #include <algorithm>
+#include <array>
+#include <cstddef>
+// #include <cstdint>
+// #include <numeric>
+// #include <stdexcept>
+#include <cstring>
+#include <string>
+#include <tuple>
+// #include <utility>
+// #include <vector>
+
+#include "konstantinov_s_broadcast/common/include/common.hpp"
+#include "konstantinov_s_broadcast/mpi/include/ops_mpi.hpp"
+#include "konstantinov_s_broadcast/seq/include/ops_seq.hpp"
+#include "util/include/func_test_util.hpp"
+#include "util/include/util.hpp"
+
+namespace konstantinov_s_broadcast {
+
+class KonstantinovSBroadcastTests : public ppc::util::BaseRunFuncTests<InType, OutType, TestType> {
+ public:
+  static std::string PrintTestParam(const TestType &test_param) {
+    return std::get<1>(test_param) + "_" + std::to_string(std::get<0>(test_param));
+  }
+
+ protected:
+  void SetUp() override {
+    TestType params = std::get<static_cast<std::size_t>(ppc::util::GTestParamIndex::kTestParams)>(GetParam());
+    const int insz = std::get<0>(params);
+    input_data_.resize(insz);
+    for (int i = 0; i < insz; ++i) {
+      input_data_[i] = i;
+    }
+  }
+
+  bool CheckTestOutputData(OutType &output_data) final {
+    // for(int i=0; i<input_data_.size();i++)
+    //   std::cout<<input_data_[i]<<" "<<output_data[i]<<"\n";
+    return 0 == memcmp(input_data_.data(), output_data.data(), input_data_.size() * sizeof(EType));
+  }
+
+  InType GetTestInputData() final {
+    return input_data_;
+  }
+
+ private:
+  InType input_data_;
+};
+
+namespace {
+
+TEST_P(KonstantinovSBroadcastTests, CustomBroadcast) {
+  ExecuteTest(GetParam());
+}
+
+const std::array<TestType, 4> kTestParam = {
+    std::make_tuple(1, "1"), std::make_tuple(2, "2"), std::make_tuple(10, "10"),
+    std::make_tuple(100, "100")};  // тесты с разным корнем дерева не получится создать (неизвестно колво процессов), но
+                                   // корнем выбирается последний процесс в самой реализации для разнообразия
+
+const auto kTestTasksList = std::tuple_cat(
+    ppc::util::AddFuncTask<KonstantinovSBroadcastMPI<EType>, InType>(kTestParam, PPC_SETTINGS_konstantinov_s_broadcast),
+    ppc::util::AddFuncTask<KonstantinovSBroadcastSEQ<EType>, InType>(kTestParam,
+                                                                     PPC_SETTINGS_konstantinov_s_broadcast));
+
+const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList);
+
+const auto kPerfTestName = KonstantinovSBroadcastTests::PrintFuncTestName<KonstantinovSBroadcastTests>;
+
+INSTANTIATE_TEST_SUITE_P(CustomBroadcastTests, KonstantinovSBroadcastTests, kGtestValues, kPerfTestName);
+
+}  // namespace
+
+}  // namespace konstantinov_s_broadcast
diff --git a/tasks/konstantinov_s_broadcast/tests/performance/main.cpp b/tasks/konstantinov_s_broadcast/tests/performance/main.cpp
new file mode 100644
index 0000000000..7d7405f171
--- /dev/null
+++ b/tasks/konstantinov_s_broadcast/tests/performance/main.cpp
@@ -0,0 +1,44 @@
+#include <gtest/gtest.h>
+
+#include <cstring>
+
+#include "konstantinov_s_broadcast/common/include/common.hpp"
+#include "konstantinov_s_broadcast/mpi/include/ops_mpi.hpp"
+#include "konstantinov_s_broadcast/seq/include/ops_seq.hpp"
+#include "util/include/perf_test_util.hpp"
+
+namespace konstantinov_s_broadcast {
+
+class KonstantinovSBroadcastTests : public ppc::util::BaseRunPerfTests<InType, OutType> {
+  const int kCount_ = 10000000;
+  InType input_data_;
+  // OutType result_right_{};
+
+  void SetUp() override {
+    input_data_.resize(kCount_, 1);
+  }
+
+  bool CheckTestOutputData(OutType &output_data) final {
+    return 0 == memcmp(input_data_.data(), output_data.data(), input_data_.size() * sizeof(EType));
+  }
+
+  InType GetTestInputData() final {
+    return input_data_;
+  }
+};
+
+TEST_P(KonstantinovSBroadcastTests, RunPerfModes) {
+  ExecuteTest(GetParam());
+}
+
+const auto kAllPerfTasks =
+    ppc::util::MakeAllPerfTasks<InType, KonstantinovSBroadcastMPI<EType>, KonstantinovSBroadcastSEQ<EType>>(
+        PPC_SETTINGS_konstantinov_s_broadcast);
+
+const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks);
+
+const auto kPerfTestName = KonstantinovSBroadcastTests::CustomPerfTestName;
+
+INSTANTIATE_TEST_SUITE_P(RunModeTests, KonstantinovSBroadcastTests, kGtestValues, kPerfTestName);
+
+}  // namespace konstantinov_s_broadcast