From 42d253b3f7aa3f67852d6fed2abcc32e2e5a13a8 Mon Sep 17 00:00:00 2001
From: Young Han <younghan@meta.com>
Date: Wed, 25 Mar 2026 14:57:23 -0700
Subject: [PATCH 1/3] Add streaming Silero VAD runner for real-time speech
 detection

Add a new `silero_vad_stream_runner` CLI that reads 16kHz mono
float32 PCM from stdin and outputs per-frame speech probabilities
via a simple line protocol (`PROB <time> <probability>`). This
enables real-time VAD as a subprocess for apps like the Voxtral
Realtime macOS dictation app.

Changes:
- Add `reset_stream()` and `process_frame()` to SileroVadRunner
  for stateful frame-by-frame inference with persistent LSTM state
- Add `stream_main.cpp` as the streaming CLI entry point
- Update CMakeLists.txt to build both `silero_vad_runner` (offline)
  and `silero_vad_stream_runner` (streaming) targets
- Remove unnecessary `extension_llm_runner` dependency that caused
  build conflicts with sentencepiece headers
- Update Makefile `silero-vad-cpu` target to build both runners
  with `-DEXECUTORCH_BUILD_EXTENSION_LLM_RUNNER=OFF`
- Update README with streaming usage and architecture docs

Authored with assistance from Claude.

Made-with: Cursor
---
 Makefile                                      |  11 +-
 examples/models/silero_vad/CMakeLists.txt     |  42 ++++-
 examples/models/silero_vad/README.md          |  45 ++++-
 .../models/silero_vad/silero_vad_runner.cpp   | 156 +++++++++---------
 .../models/silero_vad/silero_vad_runner.h     |  25 +++
 examples/models/silero_vad/stream_main.cpp    |  81 +++++++++
 6 files changed, 262 insertions(+), 98 deletions(-)
 create mode 100644 examples/models/silero_vad/stream_main.cpp

diff --git a/Makefile b/Makefile
index 0f34c2e8b50..33f8d9bff4e 100644
--- a/Makefile
+++ b/Makefile
@@ -296,18 +296,21 @@ voxtral_realtime-cuda:
 	@echo "  Binary: cmake-out/examples/models/voxtral_realtime/voxtral_realtime_runner"
 
 silero-vad-cpu:
-	@echo "==> Building and installing ExecuTorch..."
-	cmake --workflow --preset llm-release
-	@echo "==> Building Silero VAD runner (CPU)..."
+	@echo "==> Configuring and installing ExecuTorch (without LLM runner)..."
+	cmake --preset llm-release -DEXECUTORCH_BUILD_EXTENSION_LLM_RUNNER=OFF
+	cmake --build cmake-out --parallel "$$(sysctl -n hw.ncpu)"
+	cmake --install cmake-out
+	@echo "==> Building Silero VAD runners (CPU)..."
 	cmake -DCMAKE_BUILD_TYPE=Release \
 		-DCMAKE_FIND_ROOT_PATH=$(CURDIR)/cmake-out \
 		-DCMAKE_PREFIX_PATH=$(CURDIR)/cmake-out \
 		-S examples/models/silero_vad \
 		-B cmake-out/examples/models/silero_vad
-	cmake --build cmake-out/examples/models/silero_vad --target silero_vad_runner
+	cmake --build cmake-out/examples/models/silero_vad --target silero_vad_runner silero_vad_stream_runner
 	@echo ""
 	@echo "✓ Build complete!"
 	@echo "  Binary: cmake-out/examples/models/silero_vad/silero_vad_runner"
+	@echo "  Binary: cmake-out/examples/models/silero_vad/silero_vad_stream_runner"
 
 llama-cpu:
 	@echo "==> Building and installing ExecuTorch..."
diff --git a/examples/models/silero_vad/CMakeLists.txt b/examples/models/silero_vad/CMakeLists.txt
index 7f2af2571ec..92986b82588 100644
--- a/examples/models/silero_vad/CMakeLists.txt
+++ b/examples/models/silero_vad/CMakeLists.txt
@@ -29,11 +29,11 @@ if(NOT _executorch_imported)
   executorch_target_link_options_shared_lib(executorch)
 endif()
 
-set(link_libraries executorch gflags)
+set(common_link_libraries executorch gflags)
 
 # Common ops for all builds
 if(TARGET optimized_native_cpu_ops_lib)
-  list(APPEND link_libraries optimized_native_cpu_ops_lib cpublas eigen_blas)
+  list(APPEND common_link_libraries optimized_native_cpu_ops_lib cpublas eigen_blas)
   get_target_property(_is_imported optimized_native_cpu_ops_lib IMPORTED)
   if(NOT _is_imported)
     executorch_target_link_options_shared_lib(optimized_native_cpu_ops_lib)
@@ -46,7 +46,7 @@ if(TARGET xnnpack_backend)
   if(TARGET kleidiai)
     list(APPEND xnnpack_backend_libs kleidiai)
   endif()
-  list(APPEND link_libraries ${xnnpack_backend_libs})
+  list(APPEND common_link_libraries ${xnnpack_backend_libs})
   get_target_property(_xnnpack_imported xnnpack_backend IMPORTED)
   if(NOT _xnnpack_imported)
     executorch_target_link_options_shared_lib(xnnpack_backend)
@@ -55,14 +55,24 @@ endif()
 
 # Needed for cpuinfo where it uses android specific log lib
 if(ANDROID)
-  list(APPEND link_libraries log)
+  list(APPEND common_link_libraries log)
 endif()
 
 # Add the required ExecuTorch extensions
+set(silero_runner_link_libraries ${common_link_libraries})
 list(
   APPEND
-  link_libraries
-  extension_llm_runner
+  silero_runner_link_libraries
+  extension_module
+  extension_data_loader
+  extension_tensor
+  extension_flat_tensor
+)
+
+set(silero_stream_link_libraries ${common_link_libraries})
+list(
+  APPEND
+  silero_stream_link_libraries
   extension_module
   extension_data_loader
   extension_tensor
@@ -80,5 +90,23 @@ endif()
 target_include_directories(
   silero_vad_runner PUBLIC ${_common_include_directories}
 )
-target_link_libraries(silero_vad_runner PUBLIC ${link_libraries})
+target_link_libraries(silero_vad_runner PUBLIC ${silero_runner_link_libraries})
 target_compile_options(silero_vad_runner PUBLIC ${_common_compile_options})
+
+add_executable(silero_vad_stream_runner stream_main.cpp silero_vad_runner.cpp)
+if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+  target_link_options_gc_sections(silero_vad_stream_runner)
+  if(NOT APPLE AND NOT MSVC)
+    target_link_options(silero_vad_stream_runner PRIVATE "LINKER:-s")
+  endif()
+endif()
+
+target_include_directories(
+  silero_vad_stream_runner PUBLIC ${_common_include_directories}
+)
+target_link_libraries(
+  silero_vad_stream_runner PUBLIC ${silero_stream_link_libraries}
+)
+target_compile_options(
+  silero_vad_stream_runner PUBLIC ${_common_compile_options}
+)
diff --git a/examples/models/silero_vad/README.md b/examples/models/silero_vad/README.md
index 0b7d6d9c9f5..5a3ed4fd78b 100644
--- a/examples/models/silero_vad/README.md
+++ b/examples/models/silero_vad/README.md
@@ -9,14 +9,17 @@ Voice activity detection answers "when is someone speaking" — the model output
 ```bash
 # Export to .pte
 cd examples/models/silero_vad
-python export_silero_vad.py --jit-model /path/to/silero_vad.jit
+python export_silero_vad.py \
+    --jit-model /path/to/silero_vad.jit \
+    --backend xnnpack \
+    --output-dir ./silero_vad_xnnpack
 
-# Build the C++ runner (from repo root)
+# Build the C++ runners (from repo root)
 make silero-vad-cpu
 
-# Run VAD
+# Run WAV-based VAD
 ./cmake-out/examples/models/silero_vad/silero_vad_runner \
-    --model_path examples/models/silero_vad/silero_vad_exports/silero_vad.pte \
+    --model_path examples/models/silero_vad/silero_vad_xnnpack/silero_vad.pte \
     --audio_path /path/to/audio.wav
 ```
 
@@ -67,9 +70,9 @@ python export_silero_vad.py --jit-model /path/to/silero-vad/src/silero_vad/data/
 | `--backend` | `portable` or `xnnpack` (default: `xnnpack`) |
 | `--output-dir` | Output directory (default: `./silero_vad_exports`) |
 
-Output: `silero_vad_exports/silero_vad.pte` (~2 MB).
+Output: `silero_vad_xnnpack/silero_vad.pte` (~1.2 MB with XNNPACK, may vary by export settings).
 
-## C++ Runner
+## C++ Runners
 
 ### Build
 
@@ -79,16 +82,44 @@ From the repository root:
 make silero-vad-cpu
 ```
 
-Binary: `cmake-out/examples/models/silero_vad/silero_vad_runner`
+This builds:
+
+- `cmake-out/examples/models/silero_vad/silero_vad_runner`
+- `cmake-out/examples/models/silero_vad/silero_vad_stream_runner`
+
+The build configures and installs ExecuTorch first, then builds the two Silero VAD binaries from `examples/models/silero_vad/`.
 
 ### Arguments
 
+#### `silero_vad_runner`
+
 | Argument | Description |
 |----------|-------------|
 | `--model_path` | Path to `.pte` file (default: `silero_vad.pte`) |
 | `--audio_path` | Path to input WAV file (16kHz mono, required) |
 | `--threshold` | Speech probability threshold, 0.0–1.0 (default: `0.5`) |
 
+#### `silero_vad_stream_runner`
+
+| Argument | Description |
+|----------|-------------|
+| `--model_path` | Path to `.pte` file (default: `silero_vad.pte`) |
+
+The stream runner reads 16kHz mono `float32` PCM from `stdin` and prints:
+
+```text
+READY
+PROB <time_seconds> <probability>
+```
+
+Example:
+
+```bash
+ffmpeg -i input.wav -ar 16000 -ac 1 -f f32le -nostats -loglevel error pipe:1 | \
+  ./cmake-out/examples/models/silero_vad/silero_vad_stream_runner \
+    --model_path examples/models/silero_vad/silero_vad_xnnpack/silero_vad.pte
+```
+
 ### How It Works
 
 The model processes audio in 512-sample chunks (32ms at 16kHz). Each chunk is prepended with 64 samples of context from the previous chunk, forming a 576-sample input. The model carries an LSTM hidden state across chunks and outputs a single speech probability per chunk.
diff --git a/examples/models/silero_vad/silero_vad_runner.cpp b/examples/models/silero_vad/silero_vad_runner.cpp
index 77eaea868e4..18c6f549004 100644
--- a/examples/models/silero_vad/silero_vad_runner.cpp
+++ b/examples/models/silero_vad/silero_vad_runner.cpp
@@ -43,6 +43,80 @@ SileroVadRunner::SileroVadRunner(const std::string& model_path) {
   context_size_ = cs.ok() ? cs.get()[0].toInt() : 64;
   input_size_ = window_size_ + context_size_;
   frame_duration_ = static_cast<double>(window_size_) / sample_rate_;
+  reset_stream();
+}
+
+void SileroVadRunner::reset_stream() {
+  stream_state_data_.assign(static_cast<size_t>(2 * kHiddenDim), 0.0f);
+  stream_context_.assign(static_cast<size_t>(context_size_), 0.0f);
+  stream_input_.assign(static_cast<size_t>(input_size_), 0.0f);
+  stream_frame_index_ = 0;
+}
+
+float SileroVadRunner::process_frame(
+    const float* audio_data,
+    int64_t num_samples) {
+  int64_t chunk_len = std::min(window_size_, num_samples);
+
+  std::memcpy(
+      stream_input_.data(),
+      stream_context_.data(),
+      static_cast<size_t>(context_size_) * sizeof(float));
+
+  if (chunk_len > 0) {
+    std::memcpy(
+        stream_input_.data() + context_size_,
+        audio_data,
+        static_cast<size_t>(chunk_len) * sizeof(float));
+  }
+  if (chunk_len < window_size_) {
+    std::memset(
+        stream_input_.data() + context_size_ + chunk_len,
+        0,
+        static_cast<size_t>(window_size_ - chunk_len) * sizeof(float));
+  }
+
+  auto input_tensor = from_blob(
+      stream_input_.data(),
+      {1, static_cast<::executorch::aten::SizesType>(input_size_)},
+      ::executorch::aten::ScalarType::Float);
+  auto state_tensor = from_blob(
+      stream_state_data_.data(),
+      {2, 1, static_cast<::executorch::aten::SizesType>(kHiddenDim)},
+      ::executorch::aten::ScalarType::Float);
+
+  auto result = model_->execute(
+      "forward", std::vector<EValue>{input_tensor, state_tensor});
+  ET_CHECK_MSG(result.ok(), "Silero VAD forward failed.");
+
+  auto& outputs = result.get();
+  float prob = outputs[0].toTensor().const_data_ptr<float>()[0];
+
+  auto new_state = outputs[1].toTensor();
+  std::memcpy(
+      stream_state_data_.data(),
+      new_state.const_data_ptr<float>(),
+      static_cast<size_t>(2 * kHiddenDim) * sizeof(float));
+
+  if (chunk_len >= context_size_) {
+    std::memcpy(
+        stream_context_.data(),
+        audio_data + chunk_len - context_size_,
+        static_cast<size_t>(context_size_) * sizeof(float));
+  } else if (chunk_len > 0) {
+    int64_t keep = context_size_ - chunk_len;
+    std::memmove(
+        stream_context_.data(),
+        stream_context_.data() + chunk_len,
+        static_cast<size_t>(keep) * sizeof(float));
+    std::memcpy(
+        stream_context_.data() + keep,
+        audio_data,
+        static_cast<size_t>(chunk_len) * sizeof(float));
+  }
+
+  stream_frame_index_++;
+  return prob;
 }
 
 SileroVadRunner::Result SileroVadRunner::detect(
@@ -50,14 +124,7 @@ SileroVadRunner::Result SileroVadRunner::detect(
     int64_t num_samples,
     float threshold,
     SegmentCallback segment_cb) {
-  // LSTM state: (2, 1, 128) — [h, c]
-  std::vector<float> state_data(static_cast<size_t>(2 * kHiddenDim), 0.0f);
-
-  // Context: previous chunk's last context_size_ samples
-  std::vector<float> context(static_cast<size_t>(context_size_), 0.0f);
-
-  // Input buffer: [context | chunk] = input_size_ samples
-  std::vector<float> input(static_cast<size_t>(input_size_));
+  reset_stream();
 
   bool speech_active = false;
   int64_t speech_start_frame = 0;
@@ -66,78 +133,7 @@ SileroVadRunner::Result SileroVadRunner::detect(
   int num_segments = 0;
 
   for (int64_t offset = 0; offset < num_samples; offset += window_size_) {
-    int64_t chunk_len = std::min(window_size_, num_samples - offset);
-
-    // Build input: [context | chunk]
-    std::memcpy(
-        input.data(),
-        context.data(),
-        static_cast<size_t>(context_size_) * sizeof(float));
-
-    if (chunk_len == window_size_) {
-      std::memcpy(
-          input.data() + context_size_,
-          audio_data + offset,
-          static_cast<size_t>(window_size_) * sizeof(float));
-    } else {
-      // Pad the last partial chunk with zeros
-      std::memcpy(
-          input.data() + context_size_,
-          audio_data + offset,
-          static_cast<size_t>(chunk_len) * sizeof(float));
-      std::memset(
-          input.data() + context_size_ + chunk_len,
-          0,
-          static_cast<size_t>(window_size_ - chunk_len) * sizeof(float));
-    }
-
-    auto input_tensor = from_blob(
-        input.data(),
-        {1, static_cast<::executorch::aten::SizesType>(input_size_)},
-        ::executorch::aten::ScalarType::Float);
-    auto state_tensor = from_blob(
-        state_data.data(),
-        {2, 1, static_cast<::executorch::aten::SizesType>(kHiddenDim)},
-        ::executorch::aten::ScalarType::Float);
-
-    auto result = model_->execute(
-        "forward", std::vector<EValue>{input_tensor, state_tensor});
-    if (!result.ok()) {
-      ET_LOG(
-          Error,
-          "forward failed at offset %lld.",
-          static_cast<long long>(offset));
-      break;
-    }
-
-    auto& outputs = result.get();
-    float prob = outputs[0].toTensor().const_data_ptr<float>()[0];
-
-    // Update LSTM state
-    auto new_state = outputs[1].toTensor();
-    std::memcpy(
-        state_data.data(),
-        new_state.const_data_ptr<float>(),
-        static_cast<size_t>(2 * kHiddenDim) * sizeof(float));
-
-    // Update context from current chunk
-    if (chunk_len >= context_size_) {
-      std::memcpy(
-          context.data(),
-          audio_data + offset + chunk_len - context_size_,
-          static_cast<size_t>(context_size_) * sizeof(float));
-    } else {
-      // Shift existing context and append partial chunk
-      int64_t keep = context_size_ - chunk_len;
-      std::memmove(
-          context.data(),
-          context.data() + chunk_len,
-          static_cast<size_t>(keep) * sizeof(float));
-      std::memcpy(
-          context.data() + keep,
-          audio_data + offset,
-          static_cast<size_t>(chunk_len) * sizeof(float));
-    }
+    float prob = process_frame(audio_data + offset, num_samples - offset);
 
     // Threshold-based speech detection
     if (prob > threshold) {
diff --git a/examples/models/silero_vad/silero_vad_runner.h b/examples/models/silero_vad/silero_vad_runner.h
index d8e1373bc21..7a10d4080ce 100644
--- a/examples/models/silero_vad/silero_vad_runner.h
+++ b/examples/models/silero_vad/silero_vad_runner.h
@@ -52,10 +52,30 @@ class SileroVadRunner {
       float threshold,
       SegmentCallback segment_cb);
 
+  void reset_stream();
+
+  float process_frame(const float* audio_data, int64_t num_samples);
+
   double frame_duration() const {
     return frame_duration_;
   }
 
+  int64_t sample_rate() const {
+    return sample_rate_;
+  }
+
+  int64_t window_size() const {
+    return window_size_;
+  }
+
+  int64_t context_size() const {
+    return context_size_;
+  }
+
+  int64_t stream_frame_index() const {
+    return stream_frame_index_;
+  }
+
  private:
   std::unique_ptr<::executorch::extension::Module> model_;
 
@@ -66,6 +86,11 @@ class SileroVadRunner {
   double frame_duration_;
 
   static constexpr int64_t kHiddenDim = 128;
+
+  std::vector<float> stream_state_data_;
+  std::vector<float> stream_context_;
+  std::vector<float> stream_input_;
+  int64_t stream_frame_index_ = 0;
 };
 
 } // namespace silero_vad
diff --git a/examples/models/silero_vad/stream_main.cpp b/examples/models/silero_vad/stream_main.cpp
new file mode 100644
index 00000000000..cf511ea8de6
--- /dev/null
+++ b/examples/models/silero_vad/stream_main.cpp
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// Streaming CLI entry point for Silero VAD.
+//
+// Reads 16kHz mono float32 PCM from stdin, runs the model frame-by-frame, and
+// writes a simple line protocol to stdout:
+//   READY
+//   PROB <time_seconds> <probability>
+
+#include <array>
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+#include <vector>
+
+#include <gflags/gflags.h>
+
+#include <executorch/runtime/platform/log.h>
+
+#include "silero_vad_runner.h"
+
+DEFINE_string(model_path, "silero_vad.pte", "Path to Silero VAD model (.pte).");
+
+int main(int argc, char** argv) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+
+  silero_vad::SileroVadRunner runner(FLAGS_model_path);
+  runner.reset_stream();
+
+  std::cout << std::fixed << std::setprecision(3);
+  std::cout << "READY" << std::endl;
+
+  std::array<char, 4096> read_buf{};
+  std::vector<char> pending_bytes;
+  std::vector<float> pending_samples;
+  pending_bytes.reserve(4096);
+  pending_samples.reserve(static_cast<size_t>(runner.window_size() * 2));
+
+  while (true) {
+    std::cin.read(read_buf.data(), read_buf.size());
+    std::streamsize read_count = std::cin.gcount();
+    if (read_count <= 0) {
+      break;
+    }
+
+    pending_bytes.insert(
+        pending_bytes.end(), read_buf.begin(), read_buf.begin() + read_count);
+
+    size_t float_bytes = pending_bytes.size() / sizeof(float) * sizeof(float);
+    size_t float_count = float_bytes / sizeof(float);
+    size_t prior_sample_count = pending_samples.size();
+    pending_samples.resize(prior_sample_count + float_count);
+
+    std::memcpy(
+        pending_samples.data() + prior_sample_count,
+        pending_bytes.data(),
+        float_bytes);
+    pending_bytes.erase(pending_bytes.begin(), pending_bytes.begin() + float_bytes);
+
+    while (pending_samples.size() >=
+           static_cast<size_t>(runner.window_size())) {
+      float prob =
+          runner.process_frame(pending_samples.data(), runner.window_size());
+      double timestamp =
+          static_cast<double>(runner.stream_frame_index()) *
+          runner.frame_duration();
+      std::cout << "PROB " << timestamp << " " << prob << std::endl;
+      pending_samples.erase(
+          pending_samples.begin(),
+          pending_samples.begin() + runner.window_size());
+    }
+  }
+
+  return 0;
+}

From cfff2f0439049434becac5129a6f9fe46f0cc52d Mon Sep 17 00:00:00 2001
From: Young Han <younghan@meta.com>
Date: Tue, 31 Mar 2026 14:03:46 -0700
Subject: [PATCH 2/3] Silero VAD: fix stream runner formatting

Adjust `stream_main.cpp` to match the formatter output so the remaining lintrunner failure is resolved without changing behavior.

Authored with assistance from Claude.

Made-with: Cursor
---
 examples/models/silero_vad/stream_main.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/examples/models/silero_vad/stream_main.cpp b/examples/models/silero_vad/stream_main.cpp
index cf511ea8de6..03569443f07 100644
--- a/examples/models/silero_vad/stream_main.cpp
+++ b/examples/models/silero_vad/stream_main.cpp
@@ -61,14 +61,14 @@ int main(int argc, char** argv) {
         pending_samples.data() + prior_sample_count,
         pending_bytes.data(),
         float_bytes);
-    pending_bytes.erase(pending_bytes.begin(), pending_bytes.begin() + float_bytes);
+    pending_bytes.erase(
+        pending_bytes.begin(), pending_bytes.begin() + float_bytes);
 
     while (pending_samples.size() >=
            static_cast<size_t>(runner.window_size())) {
       float prob =
           runner.process_frame(pending_samples.data(), runner.window_size());
-      double timestamp =
-          static_cast<double>(runner.stream_frame_index()) *
+      double timestamp = static_cast<double>(runner.stream_frame_index()) *
           runner.frame_duration();
       std::cout << "PROB " << timestamp << " " << prob << std::endl;
       pending_samples.erase(

From 0468e1cc28d99fc63399e66dce705bdf854770bd Mon Sep 17 00:00:00 2001
From: Young Han <younghan@meta.com>
Date: Tue, 31 Mar 2026 14:21:11 -0700
Subject: [PATCH 3/3] Silero VAD: fix CMake formatting

Rewrite the silero VAD runner link-library lists to match cmake-format so the remaining lintrunner failure is cleared without changing build behavior.

Authored with assistance from Claude.

Made-with: Cursor
---
 examples/models/silero_vad/CMakeLists.txt | 22 +++++++---------------
 1 file changed, 7 insertions(+), 15 deletions(-)

diff --git a/examples/models/silero_vad/CMakeLists.txt b/examples/models/silero_vad/CMakeLists.txt
index 92986b82588..4ed81b19d84 100644
--- a/examples/models/silero_vad/CMakeLists.txt
+++ b/examples/models/silero_vad/CMakeLists.txt
@@ -33,7 +33,9 @@ set(common_link_libraries executorch gflags)
 
 # Common ops for all builds
 if(TARGET optimized_native_cpu_ops_lib)
-  list(APPEND common_link_libraries optimized_native_cpu_ops_lib cpublas eigen_blas)
+  list(APPEND common_link_libraries optimized_native_cpu_ops_lib cpublas
+       eigen_blas
+  )
   get_target_property(_is_imported optimized_native_cpu_ops_lib IMPORTED)
   if(NOT _is_imported)
     executorch_target_link_options_shared_lib(optimized_native_cpu_ops_lib)
@@ -60,23 +62,13 @@ endif()
 
 # Add the required ExecuTorch extensions
 set(silero_runner_link_libraries ${common_link_libraries})
-list(
-  APPEND
-  silero_runner_link_libraries
-  extension_module
-  extension_data_loader
-  extension_tensor
-  extension_flat_tensor
+list(APPEND silero_runner_link_libraries extension_module extension_data_loader
+     extension_tensor extension_flat_tensor
 )
 
 set(silero_stream_link_libraries ${common_link_libraries})
-list(
-  APPEND
-  silero_stream_link_libraries
-  extension_module
-  extension_data_loader
-  extension_tensor
-  extension_flat_tensor
+list(APPEND silero_stream_link_libraries extension_module extension_data_loader
+     extension_tensor extension_flat_tensor
 )
 
 add_executable(silero_vad_runner main.cpp silero_vad_runner.cpp)