diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 1e1ddbc3..24a7c183 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -87,7 +87,7 @@ jobs:
       - name: Get Release Notes
         run: 'echo "$(git tag -l --format="%(contents:body)" $GITHUB_REF_NAME)" > RELEASE_NOTES'
       - name: Release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v2
         with:
           body_path: RELEASE_NOTES
           files: |
diff --git a/DoubleLoopCymbal/source/editor.hpp b/DoubleLoopCymbal/source/editor.hpp
index b7737df9..a377e01f 100644
--- a/DoubleLoopCymbal/source/editor.hpp
+++ b/DoubleLoopCymbal/source/editor.hpp
@@ -52,7 +52,7 @@ class Editor : public PlugEditor {
   {
     auto knob = new Knob<style>(
       CRect(left, top, left + height, top + height), this, tag, palette);
-    knob->setSlitWidth(2.0);
+    knob->setArcWidth(2.0);
     knob->setValueNormalized(controller->getParamNormalized(tag));
     knob->setDefaultValue(param->getDefaultNormalized(tag));
     frame->addView(knob);
diff --git a/NarrowingDelay/source/editor.hpp b/NarrowingDelay/source/editor.hpp
index aa339620..0b2cd937 100644
--- a/NarrowingDelay/source/editor.hpp
+++ b/NarrowingDelay/source/editor.hpp
@@ -39,7 +39,7 @@ class Editor : public PlugEditor {
   {
     auto knob = new Knob<style>(
       CRect(left, top, left + height, top + height), this, tag, palette);
-    knob->setSlitWidth(2.0);
+    knob->setArcWidth(2.0);
     knob->setValueNormalized(controller->getParamNormalized(tag));
     knob->setDefaultValue(param->getDefaultNormalized(tag));
     frame->addView(knob);
diff --git a/OrdinaryPhaser/source/editor.hpp b/OrdinaryPhaser/source/editor.hpp
index 4ec5bc68..7f0c4d49 100644
--- a/OrdinaryPhaser/source/editor.hpp
+++ b/OrdinaryPhaser/source/editor.hpp
@@ -39,7 +39,7 @@ class Editor : public PlugEditor {
   {
     auto knob = new Knob<style>(
       CRect(left, top, left + height, top + height), this, tag, palette);
-    knob->setSlitWidth(2.0);
+    knob->setArcWidth(2.0);
     knob->setValueNormalized(controller->getParamNormalized(tag));
     knob->setDefaultValue(param->getDefaultNormalized(tag));
     frame->addView(knob);
diff --git a/ParallelDetune/source/editor.hpp b/ParallelDetune/source/editor.hpp
index 12dcffee..27b26ec6 100644
--- a/ParallelDetune/source/editor.hpp
+++ b/ParallelDetune/source/editor.hpp
@@ -39,7 +39,7 @@ class Editor : public PlugEditor {
   {
     auto knob = new Knob<style>(
       CRect(left, top, left + height, top + height), this, tag, palette);
-    knob->setSlitWidth(2.0);
+    knob->setArcWidth(2.0);
     knob->setValueNormalized(controller->getParamNormalized(tag));
     knob->setDefaultValue(param->getDefaultNormalized(tag));
     frame->addView(knob);
diff --git a/SpectralPhaser/CMakeLists.txt b/SpectralPhaser/CMakeLists.txt
new file mode 100644
index 00000000..d1e62f53
--- /dev/null
+++ b/SpectralPhaser/CMakeLists.txt
@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 3.20)
+
+set(UHHYOU_USE_FFTW True)
+include(../common/cmake/non_simd.cmake)
+
+if(TEST_PLUGIN)
+  build_test("")
+else()
+  # VST 3 source files.
+  set(plug_sources
+    source/dsp/spectralfilter.cpp
+    source/parameter.cpp
+    source/gui/splashdraw.cpp
+    source/plugprocessor.cpp
+    source/editor.cpp
+    source/plugfactory.cpp)
+
+  build_vst3("${plug_sources}")
+endif()
diff --git a/SpectralPhaser/resource/7F624680B9F84549B086166F2C3061CA_snapshot.png b/SpectralPhaser/resource/7F624680B9F84549B086166F2C3061CA_snapshot.png
new file mode 100644
index 00000000..cef4eff7
Binary files /dev/null and b/SpectralPhaser/resource/7F624680B9F84549B086166F2C3061CA_snapshot.png differ
diff --git a/SpectralPhaser/resource/Info.plist b/SpectralPhaser/resource/Info.plist
new file mode 100644
index 00000000..561ab6c3
--- /dev/null
+++ b/SpectralPhaser/resource/Info.plist
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>NSHumanReadableCopyright</key>
+		<string>2018 Steinberg Media Technologies</string>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleExecutable</key>
+		<string>SpectralPhaser</string>
+		<key>CFBundleIconFile</key>
+		<string></string>
+		<key>CFBundleIdentifier</key>
+		<string>com.steinberg.vst3.SpectralPhaser</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>BNDL</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleVersion</key>
+		<string>1.0</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CSResourcesFileMapped</key>
+		<true />
+	</dict>
+</plist>
diff --git a/SpectralPhaser/resource/plug.rc b/SpectralPhaser/resource/plug.rc
new file mode 100644
index 00000000..128ff068
--- /dev/null
+++ b/SpectralPhaser/resource/plug.rc
@@ -0,0 +1,44 @@
+#include <windows.h>
+#include "../source/version.hpp"
+
+#define APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// Version
+/////////////////////////////////////////////////////////////////////////////
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION MAJOR_VERSION_INT,SUB_VERSION_INT,RELEASE_NUMBER_INT,BUILD_NUMBER_INT
+ PRODUCTVERSION MAJOR_VERSION_INT,SUB_VERSION_INT,RELEASE_NUMBER_INT,BUILD_NUMBER_INT
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x40004L
+ FILETYPE 0x1L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040004e4"
+        BEGIN
+            VALUE "FileVersion",      FULL_VERSION_STR"\0"
+            VALUE "ProductVersion",   FULL_VERSION_STR"\0"
+            VALUE "OriginalFilename", stringOriginalFilename"\0"
+            VALUE "FileDescription",  stringFileDescription"\0"
+            VALUE "InternalName",     stringFileDescription"\0"
+            VALUE "ProductName",      stringFileDescription"\0"
+            VALUE "CompanyName",      stringCompanyName"\0"
+            VALUE "LegalCopyright",   stringLegalCopyright"\0"
+            VALUE "LegalTrademarks",  stringLegalTrademarks"\0"
+            //VALUE "PrivateBuild",     " \0"
+            //VALUE "SpecialBuild",     " \0"
+            //VALUE "Comments",         " \0"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x400, 1252
+    END
+END
diff --git a/SpectralPhaser/source/dsp/dspcore.cpp b/SpectralPhaser/source/dsp/dspcore.cpp
new file mode 100644
index 00000000..cb3bba96
--- /dev/null
+++ b/SpectralPhaser/source/dsp/dspcore.cpp
@@ -0,0 +1,217 @@
+// Copyright Takamitsu Endo (ryukau@gmail.com).
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "../../../lib/juce_ScopedNoDenormal.hpp"
+
+#include "dspcore.hpp"
+
+#include <algorithm>
+#include <limits>
+#include <numeric>
+
+using Sample = DSPCore::Sample;
+
+void DSPCore::setup(double sampleRate)
+{
+  this->sampleRate = Sample(sampleRate);
+
+  SmootherCommon<Sample>::setSampleRate(sampleRate);
+
+  lfoSyncRate = EMAFilter<double>::secondToP(sampleRate, Sample(0.013));
+
+  reset();
+  startup();
+}
+
+size_t DSPCore::getLatency() { return spcParam.reportLatency ? spcParam.frmSize : 0; }
+
+#define ASSIGN_PARAMETER(METHOD)                                                         \
+  using ID = ParameterID::ID;                                                            \
+  const auto &pv = param.value;                                                          \
+                                                                                         \
+  SmootherCommon<Sample>::setTime(pv[ID::parameterSmoothingSecond]->getFloat());         \
+                                                                                         \
+  spcParam.sideChain = pv[ID::sideChainSwitch]->getInt();                                \
+  spcParam.reportLatency = pv[ID::reportLatency]->getInt();                              \
+  spcParam.frameSizeLog2 = pv[ID::frameSize]->getInt() + maxFrameSizeStart;              \
+  spcParam.frmSize = int(1) << spcParam.frameSizeLog2;                                   \
+  spcParam.transform = static_cast<TransformType>(pv[ID::transform]->getInt());          \
+  spcParam.maskWaveform = static_cast<MaskWaveform>(pv[ID::maskWaveform]->getInt());     \
+                                                                                         \
+  lfoWaveform = static_cast<LfoWaveform>(pv[ID::lfoWaveform]->getInt());                 \
+  lfoWaveMod.METHOD(pv[ID::lfoWaveMod]->getFloat());                                     \
+  lfoRate.METHOD(pv[ID::lfoRate]->getFloat() / sampleRate);                              \
+  lfoStereoPhaseOffset.METHOD(pv[ID::lfoStereoPhaseOffset]->getFloat());                 \
+  lfoInitialPhase.METHOD(pv[ID::lfoInitialPhase]->getFloat());                           \
+                                                                                         \
+  feedback.METHOD(pv[ID::feedback]->getFloat());                                         \
+  const auto spcShift = Sample(0.5) * pv[ID::spectralShift]->getFloat();                 \
+  spectralShift.METHOD(spcShift - std::floor(spcShift));                                 \
+  octaveDown.METHOD(pv[ID::octaveDown]->getFloat());                                     \
+                                                                                         \
+  constexpr Sample twopi = Sample(2) * std::numbers::pi_v<Sample>;                       \
+  maskMix.METHOD(pv[ID::maskMix]->getFloat());                                           \
+  maskPhase.METHOD(pv[ID::maskPhase]->getFloat());                                       \
+  maskFreq.METHOD(pv[ID::maskFreq]->getFloat() / spcParam.frmSize);                      \
+  maskThreshold.METHOD(pv[ID::maskThreshold]->getFloat());                               \
+  maskRotation.METHOD(pv[ID::maskRotation]->getFloat() * twopi);                         \
+  lfoToMaskMix.METHOD(pv[ID::lfoToMaskMix]->getFloat());                                 \
+  lfoToMaskPhase.METHOD(pv[ID::lfoToMaskPhase]->getFloat());                             \
+  lfoToMaskFreq.METHOD(pv[ID::lfoToMaskFreq]->getFloat());                               \
+  lfoToMaskThreshold.METHOD(pv[ID::lfoToMaskThreshold]->getFloat());                     \
+  lfoToMaskRotation.METHOD(pv[ID::lfoToMaskRotation]->getFloat() * twopi);               \
+  lfoToSpectralShift.METHOD(pv[ID::lfoToSpectralShift]->getFloat() * Sample(2));         \
+                                                                                         \
+  outputGain.METHOD(pv[ID::outputGain]->getFloat());                                     \
+  dryWetMix.METHOD(pv[ID::dryWetMix]->getFloat());
+
+void DSPCore::reset()
+{
+  ASSIGN_PARAMETER(reset);
+
+  lfoTargetFreq = getTempoSyncFrequency();
+  lfo.reset(lfoInitialPhase.getValue(), lfoTargetFreq);
+  for (auto &x : spc) x.reset(spcParam.frameSizeLog2);
+
+  startup();
+}
+
+void DSPCore::startup() {}
+
+void DSPCore::setParameters() { ASSIGN_PARAMETER(push); }
+
+// Output range is in [0, 1].
+inline Sample phaseToWave(Sample phase, Sample mod, LfoWaveform waveform)
+{
+  switch (waveform) {
+    case LfoWaveform::triSaw: {
+      constexpr Sample eps = std::numeric_limits<Sample>::epsilon();
+      const auto pw = mod * Sample(0.5) + Sample(0.5);
+      if (pw <= eps) return Sample(1) - phase;
+      if (pw >= Sample(1) - eps) return phase;
+      return phase < pw ? phase / pw : (Sample(1) - phase) / (Sample(1) - pw);
+    } break;
+  }
+  // LfoWaveform::sine
+  constexpr Sample twopi = Sample(2) * std::numbers::pi_v<Sample>;
+  return std::sin(twopi * (phase + mod * std::sin(twopi * phase)));
+}
+
+std::array<Sample, 2>
+DSPCore::processFrame(int frameIndex, Sample in0, Sample in1, Sample side0, Sample side1)
+{
+  lfoInitialPhase.process();
+
+  const auto processLfoSync = [&]() {
+    auto samplesElapsed = sampleRate * beatsElapsed * 60 / tempo;
+    auto targetPhase = Sample((samplesElapsed + frameIndex) * lfoTargetFreq);
+    targetPhase -= std::floor(targetPhase);
+    return lfo.processSync(
+      targetPhase + lfoInitialPhase.getValue(), lfoTargetFreq, lfoSyncRate);
+  };
+
+  auto modPhase0 = isPlaying ? processLfoSync() : lfo.process(lfoTargetFreq);
+  auto modPhase1 = modPhase0 + lfoStereoPhaseOffset.process();
+  modPhase1 -= std::floor(modPhase1);
+
+  lfoWaveMod.process();
+  auto mod0 = phaseToWave(modPhase0, lfoWaveMod.getValue(), lfoWaveform);
+  auto mod1 = phaseToWave(modPhase1, lfoWaveMod.getValue(), lfoWaveform);
+
+  spcParam.dryWetMix = dryWetMix.process();
+  spcParam.feedback = feedback.process();
+  spectralShift.process();
+  octaveDown.process();
+  maskMix.process();
+  maskPhase.process();
+  maskFreq.process();
+  maskThreshold.process();
+  maskRotation.process();
+  lfoToMaskMix.process();
+  lfoToMaskPhase.process();
+  lfoToMaskFreq.process();
+  lfoToMaskThreshold.process();
+  lfoToMaskRotation.process();
+  lfoToSpectralShift.process();
+  lfoToOctaveDown.process();
+
+  const auto modulateParam = [&](Sample unipoler) {
+    const auto bipoler = unipoler - Sample(0.5);
+
+    spcParam.spectralShift
+      = spectralShift.getValue() + lfoToSpectralShift.getValue() * bipoler;
+    spcParam.spectralShift = spcParam.spectralShift - std::floor(spcParam.spectralShift);
+    spcParam.octaveDown = octaveDown.getValue() + lfoToOctaveDown.getValue() * unipoler;
+    spcParam.octaveDown -= std::floor(spcParam.octaveDown);
+
+    spcParam.maskMix = std::clamp(
+      maskMix.getValue() + lfoToMaskMix.getValue() * bipoler, Sample(0), Sample(1));
+    spcParam.maskPhase = maskPhase.getValue() + lfoToMaskPhase.getValue() * unipoler;
+    spcParam.maskFreq
+      = maskFreq.getValue() * std::exp2(Sample(6) * lfoToMaskFreq.getValue() * unipoler);
+    spcParam.maskThreshold = std::clamp(
+      maskThreshold.getValue() + lfoToMaskThreshold.getValue() * unipoler, //
+      Sample(0), Sample(1));
+    spcParam.maskRotation
+      = maskRotation.getValue() + lfoToMaskRotation.getValue() * unipoler;
+  };
+
+  modulateParam(mod0);
+  auto sig0 = spc[0].process(in0, side0, spcParam);
+
+  modulateParam(mod1);
+  auto sig1 = spc[1].process(in1, side1, spcParam);
+
+  outputGain.process();
+  return {
+    outputGain.getValue() * sig0,
+    outputGain.getValue() * sig1,
+  };
+}
+
+void DSPCore::process(
+  const size_t length,
+  const float *in0,
+  const float *in1,
+  const float *side0,
+  const float *side1,
+  float *out0,
+  float *out1)
+{
+  ScopedNoDenormals scopedDenormals;
+
+  using ID = ParameterID::ID;
+  const auto &pv = param.value;
+
+  SmootherCommon<Sample>::setBufferSize(Sample(length));
+  lfoTargetFreq = getTempoSyncFrequency();
+
+  for (int i = 0; i < length; ++i) {
+    auto frame = processFrame(
+      i, Sample(in0[i]), Sample(in1[i]), Sample(side0[i]), Sample(side1[i]));
+    out0[i] = float(frame[0]);
+    out1[i] = float(frame[1]);
+  }
+}
+
+Sample DSPCore::getTempoSyncFrequency()
+{
+  using ID = ParameterID::ID;
+  const auto &pv = param.value;
+
+  auto lfoRate = pv[ID::lfoRate]->getDouble();
+  if (lfoRate > Scales::lfoRate.getMax()) return 0;
+
+  auto upper = (pv[ID::lfoTempoUpper]->getDouble() + double(1)) * timeSigLower;
+  auto lower = pv[ID::lfoTempoLower]->getDouble() + double(1);
+
+  //
+  // Simplified version of following expressions.
+  //
+  // ```
+  // syncBeat       = upper / (lower * lfoRate);
+  // secondsPerBeat = 60 / tempoInBpm;
+  // lfoFreq        = 1 / (syncBeat * secondPerBeat * sampleRate);
+  // ```
+  return Sample((tempo * lower * lfoRate) / (60 * upper * sampleRate));
+}
diff --git a/SpectralPhaser/source/dsp/dspcore.hpp b/SpectralPhaser/source/dsp/dspcore.hpp
new file mode 100644
index 00000000..bbe93448
--- /dev/null
+++ b/SpectralPhaser/source/dsp/dspcore.hpp
@@ -0,0 +1,77 @@
+// Copyright Takamitsu Endo (ryukau@gmail.com).
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include "../../../common/dsp/smoother.hpp"
+#include "../parameter.hpp"
+#include "spectralfilter.hpp"
+
+#include <limits>
+
+using namespace SomeDSP;
+using namespace Steinberg::Synth;
+
+class DSPCore {
+public:
+  using Sample = float;
+
+  GlobalParameter param;
+  bool isPlaying = false;
+  float tempo = 120.0f;
+  double beatsElapsed = 0.0f;
+  double timeSigUpper = 1.0;
+  double timeSigLower = 4.0;
+
+  void setup(double sampleRate);
+  void reset();
+  void startup();
+  size_t getLatency();
+  void setParameters();
+  void process(
+    const size_t length,
+    const float *in0,
+    const float *in1,
+    const float *side0,
+    const float *side1,
+    float *out0,
+    float *out1);
+
+private:
+  static constexpr size_t tableSize = size_t(1) << maxFrameSizeLog2;
+
+  std::array<Sample, 2>
+  processFrame(int frameIndex, Sample in0, Sample in1, Sample side0, Sample side1);
+  Sample getTempoSyncFrequency();
+
+  Sample sampleRate = 44100;
+  LfoWaveform lfoWaveform = LfoWaveform::sine;
+
+  ExpSmoother<Sample> lfoWaveMod;
+  ExpSmoother<Sample> lfoRate;
+  RotarySmoother<Sample> lfoStereoPhaseOffset;
+  RotarySmoother<Sample> lfoInitialPhase;
+  ExpSmoother<Sample> feedback;
+  ExpSmoother<Sample> spectralShift;
+  ExpSmoother<Sample> octaveDown;
+  ExpSmoother<Sample> maskMix;
+  ExpSmoother<Sample> maskPhase;
+  RotarySmoother<Sample> maskFreq;
+  ExpSmoother<Sample> maskThreshold;
+  ExpSmoother<Sample> maskRotation;
+  ExpSmoother<Sample> lfoToMaskMix;
+  ExpSmoother<Sample> lfoToMaskPhase;
+  ExpSmoother<Sample> lfoToMaskFreq;
+  ExpSmoother<Sample> lfoToMaskThreshold;
+  ExpSmoother<Sample> lfoToMaskRotation;
+  ExpSmoother<Sample> lfoToSpectralShift;
+  ExpSmoother<Sample> lfoToOctaveDown;
+  ExpSmoother<Sample> outputGain;
+  ExpSmoother<Sample> dryWetMix;
+
+  Sample lfoTargetFreq = 0;
+  Sample lfoSyncRate = Sample(0.0078125);
+  LfoPhase<Sample> lfo;
+  SpectralParameter spcParam;
+  std::array<SpectralProcessor<maxFrameSizeLog2>, 2> spc;
+};
diff --git a/SpectralPhaser/source/dsp/spectralfilter.cpp b/SpectralPhaser/source/dsp/spectralfilter.cpp
new file mode 100644
index 00000000..08c668ba
--- /dev/null
+++ b/SpectralPhaser/source/dsp/spectralfilter.cpp
@@ -0,0 +1,26 @@
+// (c) 2024 Takamitsu Endo
+//
+// This file is part of Uhhyou Plugins.
+//
+// Uhhyou Plugins is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Uhhyou Plugins is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Uhhyou Plugins.  If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+#include "spectralfilter.hpp"
+
+namespace SomeDSP {
+
+std::mutex fftwMutex;
+
+} // namespace SomeDSP
diff --git a/SpectralPhaser/source/dsp/spectralfilter.hpp b/SpectralPhaser/source/dsp/spectralfilter.hpp
new file mode 100644
index 00000000..12d8a089
--- /dev/null
+++ b/SpectralPhaser/source/dsp/spectralfilter.hpp
@@ -0,0 +1,509 @@
+// Copyright Takamitsu Endo (ryukau@gmail.com).
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include "../../../lib/fftw3/fftw3.h"
+#include "../parameter.hpp"
+#include "spectralmask.hpp"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <complex>
+#include <limits>
+#include <mutex>
+#include <numbers>
+#include <numeric>
+
+namespace SomeDSP {
+
+// `fftwMutex` is used to lock FFTW3 calls except `fftw*_execute`. In other words, FFTW3
+// isn't thread safe except `fftw*_execute` call.
+extern std::mutex fftwMutex;
+
+// Fast Walsh-Hadamard transform. In-place.
+template<typename T> void fwht(int N, T *seq, bool inverse = false)
+{
+  for (int h = 2; h <= N; h *= 2) {
+    int hf = h / 2;
+    for (int i = 0; i < N; i += h) {
+      for (int j = 0; j < hf; ++j) {
+        auto u = seq[i + j];
+        auto v = seq[i + j + hf];
+        seq[i + j] = u + v;
+        seq[i + j + hf] = u - v;
+      }
+    }
+  }
+  if (inverse) {
+    for (int i = 0; i < N; ++i) seq[i] /= N;
+  }
+}
+
+// Fast Walsh-Hadamard transform. Out-of-place.
+template<typename T> void fwht(int N, T *x, T *y, bool inverse = false)
+{
+  for (int h = 2; h <= N; h *= 2) {
+    int hf = h / 2;
+    for (int i = 0; i < N; i += h) {
+      for (int j = 0; j < hf; ++j) {
+        auto u = x[i + j];
+        auto v = x[i + j + hf];
+        y[i + j] = u + v;
+        y[i + j + hf] = u - v;
+      }
+    }
+  }
+  if (inverse) {
+    for (int i = 0; i < N; ++i) x[i] /= N;
+  }
+}
+
+// Out-of-place. No scaling on forward transform.
+template<typename T> void haarTransformForward(int N, T *x, T *y)
+{
+  std::fill(y, y + N, T(0));
+  y[0] = std::accumulate(x, x + N, T(0));
+
+  auto size = N;
+  auto half = size / 2;
+  auto start = 0;
+  for (int row = 1; row < N; ++row) {
+    for (int idx = 0; idx < size; ++idx) {
+      auto w = x[start + idx];
+      y[row] += idx < half ? w : -w;
+    }
+
+    start += size;
+    if (start >= N) {
+      start = 0;
+      size /= 2;
+      half /= 2;
+    }
+  }
+}
+
+// Out-of-place.
+template<typename T> void haarTransformBackward(int N, T *x, T *y)
+{
+  auto scaler = T(1) / T(N);
+
+  std::fill(y, y + N, scaler * x[0]);
+
+  auto size = N;
+  auto half = size / 2;
+  auto start = 0;
+  for (int row = 1; row < N; ++row) {
+    for (int idx = 0; idx < size; ++idx) {
+      auto w = scaler * x[row];
+      y[start + idx] += idx < half ? w : -w;
+    }
+
+    start += size;
+    if (start >= N) {
+      start = 0;
+      size /= 2;
+      half /= 2;
+      scaler *= 2;
+    }
+  }
+}
+
+inline int bitReversal(int n, int k)
+{
+  int r = 0;
+  for (int i = 0; i < k; ++i) r |= ((n >> i) & 1) << (k - i - 1);
+  return r;
+}
+
+inline int binaryToGrayCode(int n) { return n ^ (n >> 1); }
+
+inline int grayCodeToBinary(int n)
+{
+  int mask = n;
+  while (mask) {
+    mask >>= 1;
+    n ^= mask;
+  }
+  return n;
+}
+
+template<int maxFrameSizeLog2> struct SideChainMask {
+  static constexpr int maxFrameSize = int(1) << maxFrameSizeLog2;
+  static constexpr int maxSpectrumSize = maxFrameSize / 2 + 1;
+
+  float *bufW = nullptr;                  // buffer for write.
+  float *bufMask = nullptr;               // buffer for read.
+  std::complex<float> *spcMask = nullptr; // spectrum.
+
+  static constexpr int planIndexOffset = 2; // Starts from 2^2.
+  static constexpr int nPlan = maxFrameSizeLog2 - planIndexOffset + 1;
+  std::array<fftwf_plan, nPlan> forwardPlan;
+
+  SideChainMask()
+  {
+    const std::lock_guard<std::mutex> fftwLock(fftwMutex);
+
+    bufW = (float *)fftwf_malloc(sizeof(float) * maxFrameSize);
+    bufMask = (float *)fftwf_malloc(sizeof(float) * maxFrameSize);
+    spcMask = (std::complex<float> *)fftwf_malloc(
+      sizeof(std::complex<float>) * maxSpectrumSize);
+    for (int idx = 0; idx < nPlan; ++idx) {
+      const auto spc_ = reinterpret_cast<fftwf_complex *>(spcMask);
+      const int length = int(1) << (idx + 2);
+      forwardPlan[idx] = fftwf_plan_dft_r2c_1d(length, bufW, spc_, FFTW_ESTIMATE);
+    }
+
+    reset();
+  }
+
+  ~SideChainMask()
+  {
+    const std::lock_guard<std::mutex> fftwLock(fftwMutex);
+
+    for (auto &x : forwardPlan) fftwf_destroy_plan(x);
+    if (spcMask) fftwf_free(spcMask);
+    if (bufMask) fftwf_free(bufMask);
+    if (bufW) fftwf_free(bufW);
+  }
+
+  void reset(int indexOffset = 0)
+  {
+    std::fill(bufW, bufW + maxFrameSize, float(0));
+    std::fill(bufMask, bufMask + maxFrameSize, float(0));
+    std::fill(spcMask, spcMask + maxSpectrumSize, std::complex<float>{0, 0});
+  }
+
+  void push(float input, const int bufIndex) { bufW[bufIndex] = input; }
+  void processFft(const int planIndex) { fftwf_execute(forwardPlan[planIndex]); }
+  void processFwht(const int size) { fwht(size, bufW, bufMask, false); }
+  void processHaar(const int size) { haarTransformForward(size, bufW, bufMask); }
+};
+
+template<int maxFrameSizeLog2> struct SpectralDelay {
+public:
+  static constexpr int maxFrameSize = int(1) << maxFrameSizeLog2;
+  static constexpr int maxSpectrumSize = maxFrameSize / 2 + 1;
+
+  int bufIndex = 0;
+
+  float *bufW = nullptr;   // buffer for write.
+  float *bufR = nullptr;   // buffer for read.
+  float *bufTmp = nullptr; // temporary buffer.
+
+  std::complex<float> *spcSrc = nullptr; // source spectrum.
+  std::complex<float> *spcTmp = nullptr; // temporary spectrum.
+
+  std::array<float, maxFrameSize> mask{};
+
+  static constexpr int planIndexOffset = 2; // Starts from 2^2.
+  static constexpr int nPlan = maxFrameSizeLog2 - planIndexOffset + 1;
+  std::array<fftwf_plan, nPlan> forwardPlan;
+  std::array<fftwf_plan, nPlan> inversePlan;
+
+  SideChainMask<maxFrameSizeLog2> side;
+
+  SpectralDelay()
+  {
+    const std::lock_guard<std::mutex> fftwLock(fftwMutex);
+
+    bufW = (float *)fftwf_malloc(sizeof(float) * maxFrameSize);
+    bufR = (float *)fftwf_malloc(sizeof(float) * maxFrameSize);
+    bufTmp = (float *)fftwf_malloc(sizeof(float) * maxFrameSize);
+
+    constexpr int spcAllocSize = sizeof(std::complex<float>) * maxSpectrumSize;
+    spcSrc = (std::complex<float> *)fftwf_malloc(spcAllocSize);
+    spcTmp = (std::complex<float> *)fftwf_malloc(spcAllocSize);
+
+    for (int idx = 0; idx < nPlan; ++idx) {
+      const auto spc_ = reinterpret_cast<fftwf_complex *>(spcSrc);
+      const int length = int(1) << (idx + 2);
+      forwardPlan[idx] = fftwf_plan_dft_r2c_1d(length, bufW, spc_, FFTW_ESTIMATE);
+      inversePlan[idx] = fftwf_plan_dft_c2r_1d(length, spc_, bufR, FFTW_ESTIMATE);
+    }
+
+    reset();
+  }
+
+  ~SpectralDelay()
+  {
+    const std::lock_guard<std::mutex> fftwLock(fftwMutex);
+
+    for (auto &x : inversePlan) fftwf_destroy_plan(x);
+    for (auto &x : forwardPlan) fftwf_destroy_plan(x);
+
+    if (spcTmp) fftwf_free(spcTmp);
+    if (spcSrc) fftwf_free(spcSrc);
+
+    if (bufTmp) fftwf_free(bufTmp);
+    if (bufR) fftwf_free(bufR);
+    if (bufW) fftwf_free(bufW);
+  }
+
+  void reset(int indexOffset = 0)
+  {
+    bufIndex = indexOffset;
+    std::fill(bufW, bufW + maxFrameSize, float(0));
+    std::fill(bufR, bufR + maxFrameSize, float(0));
+    std::fill(bufTmp, bufTmp + maxFrameSize, float(0));
+    std::fill(spcSrc, spcSrc + maxSpectrumSize, std::complex<float>{0, 0});
+    std::fill(spcTmp, spcTmp + maxSpectrumSize, std::complex<float>{0, 0});
+    mask.fill({});
+    side.reset();
+  }
+
+  float process(float input, float sideIn, SpectralParameter &prm)
+  {
+    const auto output = bufR[bufIndex];
+    bufW[bufIndex] = input;
+    side.push(sideIn, bufIndex);
+    if (++bufIndex < prm.frmSize) return output;
+    bufIndex = 0;
+
+    const auto planIndex = prm.frameSizeLog2 - planIndexOffset;
+    fftwf_execute(forwardPlan[planIndex]);
+
+    const auto spectrumSize = prm.frmSize / 2 + 1;
+
+    if (prm.sideChain) {
+      side.processFft(planIndex);
+      const auto gain = float(1) / std::sqrt(float(prm.frmSize));
+      for (int idx = 0; idx < spectrumSize; ++idx) {
+        spcSrc[idx] *= std::abs(side.spcMask[idx]) * gain;
+      }
+    }
+
+    fillMask(spectrumSize, mask.data(), prm);
+
+    const int spcShift = prm.spectralShift * spectrumSize;
+    std::rotate(spcTmp, spcTmp + spcShift, spcTmp + spectrumSize);
+
+    spcTmp[0] *= float(1) - prm.octaveDown;
+
+    for (int idx = 0; idx < spectrumSize; ++idx) {
+      spcTmp[idx] *= prm.feedback;
+      const auto maskValue = mask[idx] > prm.maskThreshold
+        ? mask[idx] * std::polar(float(1), prm.maskRotation * mask[idx])
+        : float(0);
+
+      if ((idx & 1) == 0) {
+        auto value = spcTmp[idx];
+        spcTmp[idx] = (float(1) - prm.octaveDown) * value;
+        spcTmp[idx / 2] += prm.octaveDown * value;
+      } else {
+        auto value = spcTmp[idx];
+        spcTmp[idx] = (float(1) - prm.octaveDown) * value;
+        spcTmp[idx / 2] += prm.octaveDown * value / float(2);
+        spcTmp[idx / 2 + 1] += prm.octaveDown * value / float(2);
+      }
+
+      spcTmp[idx] += spcSrc[idx] / float(prm.frmSize) * maskValue;
+      spcSrc[idx] = spcTmp[idx];
+    }
+
+    fftwf_execute(inversePlan[planIndex]);
+    return output;
+  }
+
+  float processFwht(float input, float sideIn, SpectralParameter &prm)
+  {
+    const auto output = bufW[bufIndex];
+    bufW[bufIndex] = input;
+    side.push(sideIn, bufIndex);
+    if (++bufIndex < prm.frmSize) return output;
+    bufIndex = 0;
+
+    fwht(prm.frmSize, bufW, false);
+
+    if (prm.sideChain) {
+      side.processFwht(prm.frmSize);
+      for (int idx = 0; idx < prm.frmSize; ++idx) bufW[idx] *= side.bufMask[idx];
+    }
+
+    const int spcShift = prm.spectralShift * prm.frmSize;
+    std::rotate(bufR, bufR + spcShift, bufR + prm.frmSize);
+
+    fillMask(prm.frmSize, mask.data(), prm);
+
+    auto rotation = prm.maskRotation / float(2) / std::numbers::pi_v<float>;
+    rotation -= std::floor(rotation);
+    int rotIdx = int(prm.frmSize * rotation);
+
+    bufR[0] *= float(1) - prm.octaveDown;
+
+    for (int idx = 0; idx < prm.frmSize; ++idx) {
+      // Using an implementation detail that `prm.frmSize` is always 2^n.
+      const auto permSrc = (idx + rotIdx) & (prm.frmSize - 1);
+      const auto permuted = binaryToGrayCode(bitReversal(permSrc, prm.frameSizeLog2));
+      bufR[idx] *= prm.feedback;
+
+      if ((idx & 1) == 0) {
+        auto value = bufR[idx];
+        bufR[idx] = (float(1) - prm.octaveDown) * value;
+        bufR[idx / 2] += prm.octaveDown * value;
+      } else {
+        auto value = bufR[idx];
+        bufR[idx] = (float(1) - prm.octaveDown) * value;
+        bufR[idx / 2] += prm.octaveDown * value / float(2);
+        bufR[idx / 2 + 1] += prm.octaveDown * value / float(2);
+      }
+
+      bufR[idx] += bufW[permuted] * (mask[idx] > prm.maskThreshold ? mask[idx] : 0)
+        / float(prm.frmSize);
+      bufW[permuted] = bufR[idx];
+    }
+
+    fwht(prm.frmSize, bufW, false);
+    return output;
+  }
+
+  float processHaar(float input, float sideIn, SpectralParameter &prm)
+  {
+    const auto output = bufW[bufIndex];
+    bufW[bufIndex] = input;
+    side.push(sideIn, bufIndex);
+    if (++bufIndex < prm.frmSize) return output;
+    bufIndex = 0;
+
+    haarTransformForward(prm.frmSize, bufW, bufTmp);
+
+    if (prm.sideChain) {
+      side.processHaar(prm.frmSize);
+      for (int idx = 0; idx < prm.frmSize; ++idx) bufTmp[idx] *= side.bufMask[idx];
+    }
+
+    const int spcShift = prm.spectralShift * prm.frmSize;
+    std::rotate(bufR, bufR + spcShift, bufR + prm.frmSize);
+
+    auto rotation = prm.maskRotation / float(2) / std::numbers::pi_v<float>;
+    rotation -= std::floor(rotation);
+    int rotIdx = int(prm.frmSize * rotation);
+
+    bufR[0] *= float(1) - prm.octaveDown;
+
+    fillMask(prm.frmSize, mask.data(), prm);
+    for (int idx = 0; idx < prm.frmSize; ++idx) {
+      bufR[idx] *= prm.feedback;
+
+      if ((idx & 1) == 0) {
+        auto value = bufR[idx];
+        bufR[idx] = (float(1) - prm.octaveDown) * value;
+        bufR[idx / 2] += prm.octaveDown * value;
+      } else {
+        auto value = bufR[idx];
+        bufR[idx] = (float(1) - prm.octaveDown) * value;
+        bufR[idx / 2] += prm.octaveDown * value / float(2);
+        bufR[idx / 2 + 1] += prm.octaveDown * value / float(2);
+      }
+
+      const auto src
+        = std::lerp(bufTmp[idx], bufTmp[(idx + rotIdx) & (prm.frmSize - 1)], rotation);
+      bufR[idx] += src * (mask[idx] > prm.maskThreshold ? mask[idx] : 0);
+    }
+
+    haarTransformBackward(prm.frmSize, bufR, bufW);
+    return output;
+  }
+};
+
+template<int maxFrameSizeLog2> class SpectralProcessor {
+private:
+  static constexpr int maxFrameSize = int(1) << maxFrameSizeLog2;
+
+  int prevFrameSizeLog2 = 0;
+  int fadeIndex = 0;
+  std::array<float, maxFrameSize> latencyDelay{};
+  std::array<SpectralDelay<maxFrameSizeLog2>, 2> spc;
+
+public:
+  void reset(int frameSizeLog2)
+  {
+    prevFrameSizeLog2 = frameSizeLog2;
+    fadeIndex = 0;
+    latencyDelay.fill(0);
+
+    const auto length = int(1) << frameSizeLog2;
+    for (int i = 0; i < spc.size(); ++i) spc[i].reset((i * length) / spc.size());
+  }
+
+  float process(float input, float sideIn, SpectralParameter &prm)
+  {
+    if (prevFrameSizeLog2 != prm.frameSizeLog2) {
+      prevFrameSizeLog2 = prm.frameSizeLog2;
+      spc[0].bufIndex = 0;
+      spc[1].bufIndex = prm.frmSize / 2;
+      fadeIndex = 0;
+    }
+
+    std::array<float, 2> out{};
+    switch (prm.transform) {
+      default: { // case TransformType::fft
+        out[0] = spc[0].process(input, sideIn, prm);
+        out[1] = spc[1].process(input, sideIn, prm);
+      } break;
+      case TransformType::fwht: {
+        out[0] = spc[0].processFwht(input, sideIn, prm);
+        out[1] = spc[1].processFwht(input, sideIn, prm);
+      } break;
+      case TransformType::haar: {
+        out[0] = spc[0].processHaar(input, sideIn, prm);
+        out[1] = spc[1].processHaar(input, sideIn, prm);
+      } break;
+    }
+
+    constexpr auto twopi = float(2) * std::numbers::pi_v<float>;
+
+    if (fadeIndex >= prm.frmSize) fadeIndex = 0;
+    const auto crossFade
+      = float(0.5) + float(0.5) * std::cos(twopi * float(fadeIndex) / float(prm.frmSize));
+
+    const auto delayed = latencyDelay[fadeIndex];
+    latencyDelay[fadeIndex] = input;
+
+    ++fadeIndex;
+
+    const auto mixed = std::lerp(out[0], out[1], crossFade);
+    return prm.reportLatency ? std::lerp(delayed, mixed, prm.dryWetMix)
+                             : std::lerp(input, mixed, prm.dryWetMix);
+  }
+};
+
+template<typename Sample> struct LfoPhase {
+  Sample phase = 0;
+  Sample lfoFreq = 0;
+
+  void reset(Sample initialPhase, Sample targetFreq)
+  {
+    phase = initialPhase;
+    lfoFreq = targetFreq;
+  }
+
+  Sample processSync(Sample targetPhase, Sample targetFreq, Sample syncRate)
+  {
+    phase += lfoFreq;
+    phase -= std::floor(phase);
+
+    // Sync phase.
+    constexpr auto tolerance = Sample(1) / Sample(1024);
+    auto d1 = targetPhase - phase;
+    auto diff = d1 < 0 ? (d1 + 1 < -d1 ? d1 + 1 : d1) : (-(d1 - 1) < d1 ? d1 - 1 : d1);
+    auto absed = std::abs(diff);
+    phase += syncRate * (absed >= tolerance ? absed : diff);
+
+    // Sync freq.
+    lfoFreq += syncRate * (targetFreq - lfoFreq);
+
+    return phase;
+  }
+
+  Sample process(Sample freqNormalized)
+  {
+    auto output = phase;
+    phase += freqNormalized;
+    phase -= std::floor(phase);
+    return output;
+  }
+};
+
+} // namespace SomeDSP
diff --git a/SpectralPhaser/source/dsp/spectralmask.hpp b/SpectralPhaser/source/dsp/spectralmask.hpp
new file mode 100644
index 00000000..9d428f50
--- /dev/null
+++ b/SpectralPhaser/source/dsp/spectralmask.hpp
@@ -0,0 +1,86 @@
+// Copyright Takamitsu Endo (ryukau@gmail.com).
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include "../parameter.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <numbers>
+#include <random>
+
+namespace SomeDSP {
+
+struct SpectralParameter {
+  int sideChain = 0;     // 0: false, 1: true.
+  int reportLatency = 0; // 0: false, 1: true.
+  int frameSizeLog2 = 2;
+  int frmSize = 4;
+  TransformType transform = TransformType::fft;
+  MaskWaveform maskWaveform = MaskWaveform::cosine;
+  float dryWetMix = float(1);
+  float feedback = 0;
+  float spectralShift = 0;
+  float octaveDown = 0;
+  float maskMix = float(1);
+  float maskPhase = 0;
+  float maskFreq = 0;
+  float maskThreshold = 0;
+  float maskRotation = 0;
+};
+
+// Returns a gain for normalization.
+inline void fillMask(int maskSize, float *mask, SpectralParameter &prm)
+{
+  switch (prm.maskWaveform) {
+    default: { // case MaskWaveform::cosine: {
+      constexpr float twopi = float(2) * std::numbers::pi_v<float>;
+      float phase = prm.maskPhase;
+      for (int idx = 0; idx < maskSize; ++idx) {
+        phase -= std::floor(phase);
+        mask[idx] = std::cos(twopi * phase);
+        mask[idx] = std::lerp(float(1), mask[idx], prm.maskMix);
+        phase += prm.maskFreq;
+      }
+    } break;
+    case MaskWaveform::square: {
+      float phase = prm.maskPhase;
+      for (int idx = 0; idx < maskSize; ++idx) {
+        phase -= std::floor(phase);
+        mask[idx] = phase < float(0.5) ? float(1) : float(-1);
+        mask[idx] = std::lerp(float(1), mask[idx], prm.maskMix);
+        phase += prm.maskFreq;
+      }
+    } break;
+    case MaskWaveform::sawtoothUp: {
+      float phase = prm.maskPhase;
+      for (int idx = 0; idx < maskSize; ++idx) {
+        phase -= std::floor(phase);
+        mask[idx] = float(2) * phase - float(1);
+        mask[idx] = std::lerp(float(1), mask[idx], prm.maskMix);
+        phase += prm.maskFreq;
+      }
+    } break;
+    case MaskWaveform::sawtoothDown: {
+      float phase = prm.maskPhase;
+      for (int idx = 0; idx < maskSize; ++idx) {
+        phase -= std::floor(phase);
+        mask[idx] = float(1) - float(2) * phase;
+        mask[idx] = std::lerp(float(1), mask[idx], prm.maskMix);
+        phase += prm.maskFreq;
+      }
+    } break;
+    case MaskWaveform::noise: {
+      std::minstd_rand rng{unsigned(2048 * prm.maskFreq)};
+      std::uniform_real_distribution<float> dist{
+        float(1) + float(-2) * prm.maskMix, float(1)};
+
+      int startIndex = int((prm.maskPhase - std::floor(prm.maskPhase)) * maskSize);
+      for (int idx = startIndex; idx < maskSize; ++idx) mask[idx] = dist(rng);
+      for (int idx = 0; idx < startIndex; ++idx) mask[idx] = dist(rng);
+    } break;
+  }
+}
+
+} // namespace SomeDSP
diff --git a/SpectralPhaser/source/editor.cpp b/SpectralPhaser/source/editor.cpp
new file mode 100644
index 00000000..3426f7a0
--- /dev/null
+++ b/SpectralPhaser/source/editor.cpp
@@ -0,0 +1,257 @@
+// Copyright Takamitsu Endo (ryukau@gmail.com).
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "editor.hpp"
+#include "../../lib/pcg-cpp/pcg_random.hpp"
+#include "version.hpp"
+
+#include <algorithm>
+#include <random>
+
+namespace Steinberg {
+namespace Vst {
+
+using namespace VSTGUI;
+
+constexpr float uiTextSize = 12.0f;
+constexpr float pluginNameTextSize = 16.0f;
+constexpr float margin = 5.0f;
+constexpr float uiMargin = 20.0f;
+constexpr float labelHeight = 20.0f;
+constexpr float labelY = labelHeight + 2 * margin;
+constexpr float labelWidth = 120.0f;
+constexpr float labelWidthHalf = int(labelWidth / 2);
+constexpr float lfoKnobWidth = 2 * labelHeight;
+constexpr float groupLabelWidth = 2 * labelWidth + 2 * margin;
+
+constexpr int_least32_t defaultWidth
+  = int_least32_t(3 * uiMargin + 2 * groupLabelWidth + lfoKnobWidth);
+constexpr int_least32_t defaultHeight = int_least32_t(uiMargin + 13 * labelY);
+
+Editor::Editor(void *controller) : PlugEditor(controller)
+{
+  param = std::make_unique<Synth::GlobalParameter>();
+
+  viewRect = ViewRect{0, 0, int32(defaultWidth), int32(defaultHeight)};
+  setRect(viewRect);
+}
+
+ParamValue Editor::getPlainValue(ParamID id)
+{
+  auto normalized = controller->getParamNormalized(id);
+  return controller->normalizedParamToPlain(id, normalized);
+}
+
+void Editor::valueChanged(CControl *pControl)
+{
+  using ID = Synth::ParameterID::ID;
+
+  PlugEditor::valueChanged(pControl);
+
+  ParamID id = pControl->getTag();
+
+  if (id == ID::reportLatency) {
+    controller->getComponentHandler()->restartComponent(kLatencyChanged);
+    return;
+  }
+
+  if (id == ID::frameSize) {
+    if (int(getPlainValue(ID::reportLatency)) == 1) return;
+    controller->getComponentHandler()->restartComponent(kLatencyChanged);
+    return;
+  }
+}
+
+void Editor::updateUI(ParamID id, ParamValue normalized)
+{
+  PlugEditor::updateUI(id, normalized);
+}
+
+bool Editor::prepareUI()
+{
+  using ID = Synth::ParameterID::ID;
+  using Scales = Synth::Scales;
+  using Style = Uhhyou::Style;
+
+  constexpr auto top0 = int(uiMargin / 2);
+  constexpr auto left0 = uiMargin - margin;
+  constexpr auto left4 = left0 + 1 * groupLabelWidth + 4 * margin;
+  constexpr auto left8 = left0 + 2 * groupLabelWidth + 4 * margin + uiMargin;
+
+  constexpr auto mixTop0 = top0;
+  constexpr auto mixTop1 = mixTop0 + 1 * labelY;
+  constexpr auto mixTop2 = mixTop0 + 2 * labelY;
+  constexpr auto mixTop3 = mixTop0 + 3 * labelY;
+  constexpr auto mixLeft0 = left0;
+  constexpr auto mixLeft1 = mixLeft0 + labelWidth + 2 * margin;
+  addGroupLabel(mixLeft0, mixTop0, groupLabelWidth, labelHeight, uiTextSize, "Mix");
+
+  addLabel(mixLeft0, mixTop1, labelWidth, labelHeight, uiTextSize, "Output [dB]");
+  addTextKnob(
+    mixLeft1, mixTop1, labelWidth, labelHeight, uiTextSize, ID::outputGain, Scales::gain,
+    true, 5);
+  addLabel(mixLeft0, mixTop2, labelWidth, labelHeight, uiTextSize, "Dry/Wet");
+  addTextKnob(
+    mixLeft1, mixTop2, labelWidth, labelHeight, uiTextSize, ID::dryWetMix,
+    Scales::defaultScale, false, 5);
+  addToggleButton(
+    mixLeft0, mixTop3, labelWidth, labelHeight, uiTextSize, "Side Chain",
+    ID::sideChainSwitch);
+  addToggleButton(
+    mixLeft1, mixTop3, labelWidth, labelHeight, uiTextSize, "Latency", ID::reportLatency);
+
+  constexpr auto lfoTop0 = mixTop3 + 1 * labelY;
+  constexpr auto lfoTop1 = lfoTop0 + 1 * labelY;
+  constexpr auto lfoTop2 = lfoTop0 + 2 * labelY;
+  constexpr auto lfoTop3 = lfoTop0 + 3 * labelY;
+  constexpr auto lfoTop4 = lfoTop0 + 4 * labelY;
+  constexpr auto lfoTop5 = lfoTop0 + 5 * labelY;
+  constexpr auto lfoTop6 = lfoTop0 + 6 * labelY;
+  constexpr auto lfoLeft0 = left0;
+  constexpr auto lfoLeft1 = lfoLeft0 + labelWidth + 2 * margin;
+  addGroupLabel(lfoLeft0, lfoTop0, groupLabelWidth, labelHeight, uiTextSize, "LFO");
+
+  addLabel(lfoLeft0, lfoTop1, labelWidth, labelHeight, uiTextSize, "Waveform");
+  std::vector<std::string> lfoWaveformItems{
+    "Sine",           "Tri-Saw",        "- Reserved 3 -", "- Reserved 4 -",
+    "- Reserved 5 -", "- Reserved 6 -", "- Reserved 7 -", "- Reserved 8 -"};
+  addOptionMenu<Style::accent>(
+    lfoLeft1, lfoTop1, labelWidth, labelHeight, uiTextSize, ID::lfoWaveform,
+    lfoWaveformItems);
+  addLabel(lfoLeft0, lfoTop2, labelWidth, labelHeight, uiTextSize, "Wave Mod.");
+  addTextKnob(
+    lfoLeft1, lfoTop2, labelWidth, labelHeight, uiTextSize, ID::lfoWaveMod,
+    Scales::bipolarScale, false, 5);
+  addLabel(lfoLeft0, lfoTop3, labelWidth, labelHeight, uiTextSize, "Phase");
+  addRotaryTextKnob(
+    lfoLeft1, lfoTop3, labelWidth, labelHeight, uiTextSize, ID::lfoInitialPhase,
+    Scales::defaultScale, 5);
+  addLabel(lfoLeft0, lfoTop4, labelWidth, labelHeight, uiTextSize, "Stereo");
+  addRotaryTextKnob(
+    lfoLeft1, lfoTop4, labelWidth, labelHeight, uiTextSize, ID::lfoStereoPhaseOffset,
+    Scales::defaultScale, 5);
+  addLabel(lfoLeft0, lfoTop5, labelWidth, labelHeight, uiTextSize, "Rate");
+  addTextKnob(
+    lfoLeft1, lfoTop5, labelWidth, labelHeight, uiTextSize, ID::lfoRate, Scales::lfoRate,
+    false, 5);
+  addLabel(lfoLeft0, lfoTop6, labelWidth, labelHeight, uiTextSize, "Sync.");
+  addTextKnob(
+    lfoLeft1, lfoTop6, labelWidthHalf, labelHeight, uiTextSize, ID::lfoTempoUpper,
+    Scales::lfoTempoSync, false, 0, 1);
+  addTextKnob(
+    lfoLeft1 + labelWidthHalf, lfoTop6, labelWidthHalf, labelHeight, uiTextSize,
+    ID::lfoTempoLower, Scales::lfoTempoSync, false, 0, 1);
+
+  constexpr auto dlyTop0 = top0;
+  constexpr auto dlyTop1 = dlyTop0 + 1 * labelY;
+  constexpr auto dlyTop2 = dlyTop0 + 2 * labelY;
+  constexpr auto dlyTop3 = dlyTop0 + 3 * labelY;
+  constexpr auto dlyLeft0 = left4;
+  constexpr auto dlyLeft1 = dlyLeft0 + labelWidth + 2 * margin;
+  addGroupLabel(dlyLeft0, dlyTop0, groupLabelWidth, labelHeight, uiTextSize, "Delay");
+  addLabel(dlyLeft0, dlyTop1, labelWidth, labelHeight, uiTextSize, "Transform");
+  std::vector<std::string> transformItems{
+    "FFT",
+    "FWHT",
+    "Haar",
+    "- Reserved 4 -",
+    "- Reserved 5 -",
+    "- Reserved 6 -",
+    "- Reserved 7 -",
+    "- Reserved 8 -"};
+  addOptionMenu<Style::warning>(
+    dlyLeft1, dlyTop1, labelWidth, labelHeight, uiTextSize, ID::transform,
+    transformItems);
+  addLabel(dlyLeft0, dlyTop2, labelWidth, labelHeight, uiTextSize, "Frame Size");
+  std::vector<std::string> frameSizeItems;
+  for (size_t idx = 2; idx <= Synth::maxFrameSizeLog2; ++idx) {
+    frameSizeItems.push_back(std::to_string(size_t(1) << idx));
+  }
+  addOptionMenu<Style::warning>(
+    dlyLeft1, dlyTop2, labelWidth, labelHeight, uiTextSize, ID::frameSize,
+    frameSizeItems);
+  addLabel(dlyLeft0, dlyTop3, labelWidth, labelHeight, uiTextSize, "Feedback");
+  addTextKnob<Style::warning>(
+    dlyLeft1, dlyTop3, labelWidth, labelHeight, uiTextSize, ID::feedback,
+    Scales::feedback, false, 5);
+
+  constexpr auto maskTop0 = dlyTop3 + labelY;
+  constexpr auto maskTop1 = maskTop0 + 1 * labelY;
+  constexpr auto maskTop2 = maskTop0 + 2 * labelY;
+  constexpr auto maskTop3 = maskTop0 + 3 * labelY;
+  constexpr auto maskTop4 = maskTop0 + 4 * labelY;
+  constexpr auto maskTop5 = maskTop0 + 5 * labelY;
+  constexpr auto maskTop6 = maskTop0 + 6 * labelY;
+  constexpr auto maskTop7 = maskTop0 + 7 * labelY;
+  constexpr auto maskTop8 = maskTop0 + 8 * labelY;
+  constexpr auto maskTop9 = maskTop0 + 9 * labelY;
+  constexpr auto maskLeft0 = left4;
+  constexpr auto maskLeft1 = maskLeft0 + labelWidth + 2 * margin;
+  constexpr auto maskLeft2 = maskLeft1 + labelWidth + 2 * margin;
+  constexpr auto maskLeft2Knob = maskLeft2 + 2 * margin;
+  addGroupLabel(maskLeft0, maskTop0, groupLabelWidth, labelHeight, uiTextSize, "Mask");
+
+  addLabel(maskLeft2, maskTop1, lfoKnobWidth, labelHeight, uiTextSize, "LFO");
+
+  addLabel(maskLeft0, maskTop1, labelWidth, labelHeight, uiTextSize, "Waveform");
+  std::vector<std::string> maskWaveformItems{
+    "Cosine", "Square",         "Sawtooth Up",    "Sawtooth Down",
+    "Noise",  "- Reserved 6 -", "- Reserved 7 -", "- Reserved 8 -"};
+  addOptionMenu<Style::accent>(
+    maskLeft1, maskTop1, labelWidth, labelHeight, uiTextSize, ID::maskWaveform,
+    maskWaveformItems);
+  addLabel(maskLeft0, maskTop2, labelWidth, labelHeight, uiTextSize, "Mix");
+  addTextKnob(
+    maskLeft1, maskTop2, labelWidth, labelHeight, uiTextSize, ID::maskMix,
+    Scales::defaultScale, false, 5);
+  addSmallKnob(maskLeft2Knob, maskTop2, labelHeight, labelHeight, ID::lfoToMaskMix);
+  addLabel(maskLeft0, maskTop3, labelWidth, labelHeight, uiTextSize, "Phase");
+  addRotaryTextKnob(
+    maskLeft1, maskTop3, labelWidth, labelHeight, uiTextSize, ID::maskPhase,
+    Scales::defaultScale, 5);
+  addSmallKnob(maskLeft2Knob, maskTop3, labelHeight, labelHeight, ID::lfoToMaskPhase);
+  addLabel(maskLeft0, maskTop4, labelWidth, labelHeight, uiTextSize, "Freq.");
+  addTextKnob(
+    maskLeft1, maskTop4, labelWidth, labelHeight, uiTextSize, ID::maskFreq,
+    Scales::maskFreq, false, 5);
+  addSmallKnob(maskLeft2Knob, maskTop4, labelHeight, labelHeight, ID::lfoToMaskFreq);
+  addLabel(maskLeft0, maskTop5, labelWidth, labelHeight, uiTextSize, "Threshold");
+  addTextKnob(
+    maskLeft1, maskTop5, labelWidth, labelHeight, uiTextSize, ID::maskThreshold,
+    Scales::defaultScale, false, 5);
+  addSmallKnob(maskLeft2Knob, maskTop5, labelHeight, labelHeight, ID::lfoToMaskThreshold);
+  addLabel(maskLeft0, maskTop6, labelWidth, labelHeight, uiTextSize, "Rotation");
+  addTextKnob(
+    maskLeft1, maskTop6, labelWidth, labelHeight, uiTextSize, ID::maskRotation,
+    Scales::defaultScale, false, 5);
+  addSmallKnob(maskLeft2Knob, maskTop6, labelHeight, labelHeight, ID::lfoToMaskRotation);
+  addLabel(maskLeft0, maskTop7, labelWidth, labelHeight, uiTextSize, "Spectral Shift");
+  addTextKnob(
+    maskLeft1, maskTop7, labelWidth, labelHeight, uiTextSize, ID::spectralShift,
+    Scales::bipolarScale, false, 5);
+  addSmallKnob(maskLeft2Knob, maskTop7, labelHeight, labelHeight, ID::lfoToSpectralShift);
+  addLabel(maskLeft0, maskTop8, labelWidth, labelHeight, uiTextSize, "Octave Down");
+  addTextKnob(
+    maskLeft1, maskTop8, labelWidth, labelHeight, uiTextSize, ID::octaveDown,
+    Scales::defaultScale, false, 5);
+  addSmallKnob(maskLeft2Knob, maskTop8, labelHeight, labelHeight, ID::lfoToOctaveDown);
+
+  // Plugin name.
+  constexpr auto splashMargin = uiMargin - margin;
+  constexpr auto splashWidth = groupLabelWidth;
+  constexpr auto splashHeight = labelHeight;
+  constexpr auto splashTop = defaultHeight - splashHeight - uiMargin;
+  constexpr auto splashLeft = left0;
+  addSplashScreen(
+    splashLeft, splashTop, splashWidth, splashHeight, splashMargin, splashMargin,
+    defaultWidth - 2 * splashMargin, defaultHeight - 2 * splashMargin, pluginNameTextSize,
+    "SpectralPhaser");
+
+  // Probably this restartComponent() is redundant, but to make sure.
+  controller->getComponentHandler()->restartComponent(kLatencyChanged);
+
+  return true;
+}
+
+} // namespace Vst
+} // namespace Steinberg
diff --git a/SpectralPhaser/source/editor.hpp b/SpectralPhaser/source/editor.hpp
new file mode 100644
index 00000000..ff206313
--- /dev/null
+++ b/SpectralPhaser/source/editor.hpp
@@ -0,0 +1,42 @@
+// Copyright Takamitsu Endo (ryukau@gmail.com).
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include "../../common/gui/plugeditor.hpp"
+#include "parameter.hpp"
+
+namespace Steinberg {
+namespace Vst {
+
+using namespace VSTGUI;
+
+class Editor : public PlugEditor {
+public:
+  Editor(void *controller);
+
+  void valueChanged(CControl *pControl) override;
+  void updateUI(Vst::ParamID id, ParamValue normalized) override;
+
+  DELEGATE_REFCOUNT(VSTGUIEditor);
+
+protected:
+  template<Uhhyou::Style style = Uhhyou::Style::common>
+  auto addSmallKnob(CCoord left, CCoord top, CCoord width, CCoord height, ParamID tag)
+  {
+    auto knob = new Knob<style>(
+      CRect(left, top, left + height, top + height), this, tag, palette);
+    knob->setArcWidth(2.0);
+    knob->setValueNormalized(controller->getParamNormalized(tag));
+    knob->setDefaultValue(param->getDefaultNormalized(tag));
+    frame->addView(knob);
+    addToControlMap(tag, knob);
+    return knob;
+  }
+
+  ParamValue getPlainValue(ParamID id);
+  bool prepareUI() override;
+};
+
+} // namespace Vst
+} // namespace Steinberg
diff --git a/SpectralPhaser/source/fuid.hpp b/SpectralPhaser/source/fuid.hpp
new file mode 100644
index 00000000..eac80440
--- /dev/null
+++ b/SpectralPhaser/source/fuid.hpp
@@ -0,0 +1,16 @@
+// Copyright Takamitsu Endo (ryukau@gmail.com).
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include "pluginterfaces/base/funknown.h"
+
+namespace Steinberg {
+namespace Synth {
+
+// https://www.guidgenerator.com/
+static const FUID ProcessorUID(0x7F624680, 0xB9F84549, 0xB086166F, 0x2C3061CA);
+static const FUID ControllerUID(0x34025FDC, 0x80764544, 0xAC9B1E8A, 0x6DE38BAC);
+
+} // namespace Synth
+} // namespace Steinberg
diff --git a/SpectralPhaser/source/gui/splashdraw.cpp b/SpectralPhaser/source/gui/splashdraw.cpp
new file mode 100644
index 00000000..94283730
--- /dev/null
+++ b/SpectralPhaser/source/gui/splashdraw.cpp
@@ -0,0 +1,71 @@
+// Copyright Takamitsu Endo (ryukau@gmail.com).
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "../../../common/gui/splash.hpp"
+#include "../version.hpp"
+
+namespace Steinberg {
+namespace Vst {
+
+using namespace VSTGUI;
+
+void CreditView::draw(CDrawContext *pContext)
+{
+  pContext->setDrawMode(CDrawMode(CDrawModeFlags::kAntiAliasing));
+  CDrawContext::Transform t(
+    *pContext, CGraphicsTransform().translate(getViewSize().getTopLeft()));
+
+  const auto width = getWidth();
+  const auto height = getHeight();
+  const double borderWidth = 2.0;
+  const double halfBorderWidth = borderWidth / 2.0;
+
+  // Background.
+  pContext->setLineWidth(borderWidth);
+  pContext->setFillColor(pal.background());
+  pContext->drawRect(CRect(0.0, 0.0, width, height), kDrawFilled);
+
+  // Border.
+  pContext->setFrameColor(isMouseEntered ? pal.highlightMain() : pal.border());
+  pContext->drawRect(
+    CRect(
+      halfBorderWidth, halfBorderWidth, width - halfBorderWidth,
+      height - halfBorderWidth),
+    kDrawStroked);
+
+  // Text.
+  pContext->setFont(fontIdTitle);
+  pContext->setFontColor(pal.foreground());
+  pContext->drawString("SpectralPhaser " VERSION_STR, CPoint(20.0, 40.0));
+
+  pContext->setFont(fontIdText);
+  pContext->setFontColor(pal.foreground());
+  pContext->drawString("© 2024 Takamitsu Endo (ryukau@gmail.com)", CPoint(20.0f, 60.0f));
+
+  std::string leftText = R"(- Number & Knob -
+Shift + Left Drag|Fine Adjustment
+Ctrl + Left Click|Reset to Default
+Middle Click|Flip Min/Mid/Max
+Shift + Middle Click|Take Floor)";
+
+  std::string rightText = R"(Larger Frame Size may cause stuttering.
+
+To use as a vocoder,
++ Turn on Side Chain
++ Turn on Latency
++ Set Transform to FFT
++ Set Frame Size to 2048
+
+Have a nice day!)";
+
+  const float top0 = 100.0f;
+  const float lineHeight = 20.0f;
+  const float blockWidth = 120.0f;
+  drawTextBlock(pContext, 20.0f, top0, lineHeight, blockWidth, leftText);
+  drawTextBlock(pContext, 290.0f, 40.0f, lineHeight, blockWidth, rightText);
+
+  setDirty(false);
+}
+
+} // namespace Vst
+} // namespace Steinberg
diff --git a/SpectralPhaser/source/parameter.cpp b/SpectralPhaser/source/parameter.cpp
new file mode 100644
index 00000000..734c33f3
--- /dev/null
+++ b/SpectralPhaser/source/parameter.cpp
@@ -0,0 +1,35 @@
+// Copyright Takamitsu Endo (ryukau@gmail.com).
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "parameter.hpp"
+#include "../../common/dsp/constants.hpp"
+
+#include <limits>
+
+namespace Steinberg {
+namespace Synth {
+
+using namespace SomeDSP;
+
+UIntScale<double> Scales::boolScale(1);
+LinearScale<double> Scales::defaultScale(0.0, 1.0);
+LinearScale<double> Scales::bipolarScale(-1.0, 1.0);
+
+DecibelScale<double> Scales::parameterSmoothingSecond(-120.0, 40.0, true);
+
+DecibelScale<double> Scales::gain(-60.0, 60.0, true);
+
+UIntScale<double> Scales::transform(static_cast<int>(SomeDSP::TransformType::LENGTH) - 1);
+UIntScale<double> Scales::frameSize(maxFrameSizeLog2 - maxFrameSizeStart);
+DecibelScale<double> Scales::feedback(-60.0, 0.0, true);
+
+UIntScale<double>
+  Scales::maskWaveform(static_cast<int>(SomeDSP::MaskWaveform::LENGTH) - 1);
+DecibelScale<double> Scales::maskFreq(-20.0, 60.0, true);
+
+UIntScale<double> Scales::lfoWaveform(static_cast<int>(SomeDSP::LfoWaveform::LENGTH) - 1);
+UIntScale<double> Scales::lfoTempoSync(255);
+DecibelScale<double> Scales::lfoRate(-60.0, 60.0, true);
+
+} // namespace Synth
+} // namespace Steinberg
diff --git a/SpectralPhaser/source/parameter.hpp b/SpectralPhaser/source/parameter.hpp
new file mode 100644
index 00000000..94eb3aa1
--- /dev/null
+++ b/SpectralPhaser/source/parameter.hpp
@@ -0,0 +1,285 @@
+// Copyright Takamitsu Endo (ryukau@gmail.com).
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "../../common/parameterInterface.hpp"
+
+#ifdef TEST_DSP
+  #include "../../test/value.hpp"
+#else
+  #include "../../common/value.hpp"
+#endif
+
+constexpr size_t nReservedParameter = 256;
+constexpr size_t nReservedGuiParameter = 64;
+
+namespace SomeDSP {
+enum class TransformType : int {
+  fft,
+  fwht,
+  haar,
+  reserved3,
+  reserved4,
+  reserved5,
+  reserved6,
+  reserved7,
+  LENGTH
+};
+enum class MaskWaveform : int {
+  cosine,
+  square,
+  sawtoothUp,
+  sawtoothDown,
+  noise,
+  reserved5,
+  reserved6,
+  reserved7,
+  LENGTH
+};
+enum class LfoWaveform : int {
+  sine,
+  triSaw,
+  reserved2,
+  reserved3,
+  reserved4,
+  reserved5,
+  reserved6,
+  reserved7,
+  LENGTH
+};
+} // namespace SomeDSP
+
+namespace Steinberg {
+namespace Synth {
+
+constexpr size_t maxFrameSizeLog2 = 16;
+constexpr size_t maxFrameSizeStart = 2; // Start from 2^(maxFrameSizeStart).
+
+namespace ParameterID {
+enum ID {
+  bypass,
+
+  parameterSmoothingSecond,
+
+  outputGain,
+  dryWetMix,
+  sideChainSwitch,
+  reportLatency,
+
+  transform,
+  frameSize,
+  feedback,
+
+  maskWaveform,
+  maskMix,
+  maskPhase,
+  maskFreq,
+  maskThreshold,
+  maskRotation,
+  spectralShift,
+  octaveDown,
+
+  lfoWaveform,
+  lfoWaveMod,
+  lfoTempoUpper,
+  lfoTempoLower,
+  lfoRate,
+  lfoStereoPhaseOffset,
+  lfoInitialPhase,
+
+  lfoToMaskMix,
+  lfoToMaskPhase,
+  lfoToMaskFreq,
+  lfoToMaskThreshold,
+  lfoToMaskRotation,
+  lfoToSpectralShift,
+  lfoToOctaveDown,
+
+  reservedParameter0,
+  reservedGuiParameter0 = reservedParameter0 + nReservedParameter,
+
+  ID_ENUM_LENGTH = reservedGuiParameter0 + nReservedGuiParameter,
+  // ID_ENUM_GUI_START = ID_ENUM_LENGTH,
+};
+} // namespace ParameterID
+
+struct Scales {
+  static SomeDSP::UIntScale<double> boolScale;
+  static SomeDSP::LinearScale<double> defaultScale;
+  static SomeDSP::LinearScale<double> bipolarScale;
+
+  static SomeDSP::DecibelScale<double> parameterSmoothingSecond;
+
+  static SomeDSP::DecibelScale<double> gain;
+
+  static SomeDSP::UIntScale<double> transform;
+  static SomeDSP::UIntScale<double> frameSize;
+  static SomeDSP::DecibelScale<double> feedback;
+
+  static SomeDSP::UIntScale<double> maskWaveform;
+  static SomeDSP::DecibelScale<double> maskFreq;
+
+  static SomeDSP::UIntScale<double> lfoWaveform;
+  static SomeDSP::UIntScale<double> lfoTempoSync;
+  static SomeDSP::DecibelScale<double> lfoRate;
+};
+
+struct GlobalParameter : public ParameterInterface {
+  std::vector<std::unique_ptr<ValueInterface>> value;
+
+  GlobalParameter()
+  {
+    value.resize(ParameterID::ID_ENUM_LENGTH);
+
+    using Info = Vst::ParameterInfo;
+    using ID = ParameterID::ID;
+    using LinearValue = DoubleValue<SomeDSP::LinearScale<double>>;
+    using DecibelValue = DoubleValue<SomeDSP::DecibelScale<double>>;
+
+    value[ID::bypass] = std::make_unique<UIntValue>(
+      0, Scales::boolScale, "bypass", Info::kCanAutomate | Info::kIsBypass);
+
+    value[ID::parameterSmoothingSecond] = std::make_unique<DecibelValue>(
+      Scales::parameterSmoothingSecond.invmap(0.1), Scales::parameterSmoothingSecond,
+      "parameterSmoothingSecond", Info::kCanAutomate);
+
+    value[ID::outputGain] = std::make_unique<DecibelValue>(
+      Scales::gain.invmap(1.0), Scales::gain, "outputGain", Info::kCanAutomate);
+    value[ID::dryWetMix] = std::make_unique<LinearValue>(
+      Scales::defaultScale.invmap(0.75), Scales::defaultScale, "dryWetMix",
+      Info::kCanAutomate);
+    value[ID::sideChainSwitch] = std::make_unique<UIntValue>(
+      0, Scales::boolScale, "sideChainSwitch", Info::kCanAutomate);
+    value[ID::reportLatency] = std::make_unique<UIntValue>(
+      0, Scales::boolScale, "reportLatency", Info::kCanAutomate);
+
+    value[ID::transform] = std::make_unique<UIntValue>(
+      0, Scales::transform, "transform", Info::kCanAutomate);
+    value[ID::frameSize] = std::make_unique<UIntValue>(
+      10, Scales::frameSize, "frameSize", Info::kCanAutomate);
+    value[ID::feedback] = std::make_unique<DecibelValue>(
+      Scales::feedback.invmap(0.5), Scales::feedback, "feedback", Info::kCanAutomate);
+
+    value[ID::maskWaveform] = std::make_unique<UIntValue>(
+      0, Scales::maskWaveform, "maskWaveform", Info::kCanAutomate);
+    value[ID::maskMix] = std::make_unique<LinearValue>(
+      Scales::defaultScale.invmap(1), Scales::defaultScale, "maskMix",
+      Info::kCanAutomate);
+    value[ID::maskPhase] = std::make_unique<LinearValue>(
+      Scales::defaultScale.invmap(0), Scales::defaultScale, "maskPhase",
+      Info::kCanAutomate);
+    value[ID::maskFreq] = std::make_unique<DecibelValue>(
+      Scales::maskFreq.invmap(8), Scales::maskFreq, "maskFreq", Info::kCanAutomate);
+    value[ID::maskThreshold] = std::make_unique<LinearValue>(
+      Scales::defaultScale.invmap(0), Scales::defaultScale, "maskThreshold",
+      Info::kCanAutomate);
+    value[ID::maskRotation] = std::make_unique<LinearValue>(
+      Scales::defaultScale.invmap(0), Scales::defaultScale, "maskRotation",
+      Info::kCanAutomate);
+    value[ID::spectralShift] = std::make_unique<LinearValue>(
+      Scales::bipolarScale.invmap(0), Scales::bipolarScale, "spectralShift",
+      Info::kCanAutomate);
+    value[ID::octaveDown] = std::make_unique<LinearValue>(
+      Scales::defaultScale.invmap(0), Scales::defaultScale, "octaveDown",
+      Info::kCanAutomate);
+
+    value[ID::lfoWaveform] = std::make_unique<UIntValue>(
+      0, Scales::lfoWaveform, "lfoWaveform", Info::kCanAutomate);
+    value[ID::lfoWaveMod] = std::make_unique<LinearValue>(
+      Scales::bipolarScale.invmap(0), Scales::bipolarScale, "lfoWaveMod",
+      Info::kCanAutomate);
+    value[ID::lfoTempoUpper] = std::make_unique<UIntValue>(
+      0, Scales::lfoTempoSync, "lfoTempoUpper", Info::kCanAutomate);
+    value[ID::lfoTempoLower] = std::make_unique<UIntValue>(
+      0, Scales::lfoTempoSync, "lfoTempoLower", Info::kCanAutomate);
+    value[ID::lfoRate] = std::make_unique<DecibelValue>(
+      Scales::lfoRate.invmap(1.0), Scales::lfoRate, "lfoRate", Info::kCanAutomate);
+    value[ID::lfoStereoPhaseOffset] = std::make_unique<LinearValue>(
+      Scales::defaultScale.invmap(0), Scales::defaultScale, "lfoStereoPhaseOffset",
+      Info::kCanAutomate);
+    value[ID::lfoInitialPhase] = std::make_unique<LinearValue>(
+      Scales::defaultScale.invmap(0), Scales::defaultScale, "lfoInitialPhase",
+      Info::kCanAutomate);
+
+    value[ID::lfoToMaskMix] = std::make_unique<LinearValue>(
+      Scales::bipolarScale.invmap(0), Scales::bipolarScale, "lfoToMaskMix",
+      Info::kCanAutomate);
+    value[ID::lfoToMaskPhase] = std::make_unique<LinearValue>(
+      Scales::bipolarScale.invmap(0), Scales::bipolarScale, "lfoToMaskPhase",
+      Info::kCanAutomate);
+    value[ID::lfoToMaskFreq] = std::make_unique<LinearValue>(
+      Scales::bipolarScale.invmap(0), Scales::bipolarScale, "lfoToMaskFreq",
+      Info::kCanAutomate);
+    value[ID::lfoToMaskThreshold] = std::make_unique<LinearValue>(
+      Scales::bipolarScale.invmap(0), Scales::bipolarScale, "lfoToMaskThreshold",
+      Info::kCanAutomate);
+    value[ID::lfoToMaskRotation] = std::make_unique<LinearValue>(
+      Scales::bipolarScale.invmap(0), Scales::bipolarScale, "lfoToMaskRotation",
+      Info::kCanAutomate);
+    value[ID::lfoToSpectralShift] = std::make_unique<LinearValue>(
+      Scales::bipolarScale.invmap(0), Scales::bipolarScale, "lfoToSpectralShift",
+      Info::kCanAutomate);
+    value[ID::lfoToOctaveDown] = std::make_unique<LinearValue>(
+      Scales::bipolarScale.invmap(0), Scales::bipolarScale, "lfoToOctaveDown",
+      Info::kCanAutomate);
+
+    for (size_t idx = 0; idx < nReservedParameter; ++idx) {
+      auto indexStr = std::to_string(idx);
+      value[ID::reservedParameter0 + idx] = std::make_unique<LinearValue>(
+        Scales::defaultScale.invmap(0.0), Scales::defaultScale,
+        ("reservedParameter" + indexStr).c_str(), Info::kIsHidden);
+    }
+
+    for (size_t idx = 0; idx < nReservedGuiParameter; ++idx) {
+      auto indexStr = std::to_string(idx);
+      value[ID::reservedGuiParameter0 + idx] = std::make_unique<LinearValue>(
+        Scales::defaultScale.invmap(1.0), Scales::defaultScale,
+        ("reservedGuiParameter" + indexStr).c_str(), Info::kIsHidden);
+    }
+
+    for (size_t id = 0; id < value.size(); ++id) value[id]->setId(Vst::ParamID(id));
+  }
+
+#ifdef TEST_DSP
+  // Not used in DSP test.
+  double getDefaultNormalized(int32_t) { return 0.0; }
+
+#else
+  tresult setState(IBStream *stream)
+  {
+    IBStreamer streamer(stream, kLittleEndian);
+    for (auto &val : value)
+      if (val->setState(streamer)) return kResultFalse;
+    return kResultOk;
+  }
+
+  tresult getState(IBStream *stream)
+  {
+    IBStreamer streamer(stream, kLittleEndian);
+    for (auto &val : value)
+      if (val->getState(streamer)) return kResultFalse;
+    return kResultOk;
+  }
+
+  tresult addParameter(Vst::ParameterContainer &parameters)
+  {
+    for (auto &val : value)
+      if (val->addParameter(parameters)) return kResultFalse;
+    return kResultOk;
+  }
+
+  double getDefaultNormalized(int32_t tag) override
+  {
+    if (size_t(abs(tag)) >= value.size()) return 0.0;
+    return value[tag]->getDefaultNormalized();
+  }
+#endif
+};
+
+} // namespace Synth
+} // namespace Steinberg
diff --git a/SpectralPhaser/source/plugfactory.cpp b/SpectralPhaser/source/plugfactory.cpp
new file mode 100644
index 00000000..6b4bbfaf
--- /dev/null
+++ b/SpectralPhaser/source/plugfactory.cpp
@@ -0,0 +1,60 @@
+// Original by:
+// (c) 2018, Steinberg Media Technologies GmbH, All Rights Reserved
+//
+// Modified by:
+// Copyright Takamitsu Endo (ryukau@gmail.com).
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "pluginterfaces/vst/ivstaudioprocessor.h"
+#include "public.sdk/source/main/pluginfactory.h"
+
+#include "../../common/fxcontroller.hpp"
+#include "editor.hpp"
+#include "fuid.hpp"
+#include "parameter.hpp"
+#include "plugprocessor.hpp"
+#include "version.hpp"
+
+// Subcategory for this Plug-in (see PlugType in ivstaudioprocessor.h)
+#define stringSubCategory Steinberg::Vst::PlugType::kFxModulation
+
+BEGIN_FACTORY_DEF(stringCompanyName, stringCompanyWeb, stringCompanyEmail)
+
+DEF_CLASS2(
+  INLINE_UID_FROM_FUID(Steinberg::Synth::ProcessorUID),
+  PClassInfo::kManyInstances, // cardinality
+  kVstAudioEffectClass,       // the component category (do not changed this)
+  stringPluginName,           // here the Plug-in name (to be changed)
+  Vst::kDistributable,
+  stringSubCategory, // Subcategory for this Plug-in (to be changed)
+  FULL_VERSION_STR,  // Plug-in version (to be changed)
+  kVstVersionString, // SDK Version (do not changed this, use always this define)
+  Steinberg::Synth::PlugProcessor::createInstance)
+
+using Controller = Steinberg::Synth::PlugController<Vst::Editor, GlobalParameter>;
+
+DEF_CLASS2(
+  INLINE_UID_FROM_FUID(Steinberg::Synth::ControllerUID),
+  PClassInfo::kManyInstances,   // cardinality
+  kVstComponentControllerClass, // the Controller category (do not changed this)
+  stringPluginName
+  "Controller",      // controller name (could be the same than component name)
+  0,                 // not used here
+  "",                // not used here
+  FULL_VERSION_STR,  // Plug-in version (to be changed)
+  kVstVersionString, // SDK Version (do not changed this, use always this define)
+  Controller::createInstance)
+
+END_FACTORY
+
+//------------------------------------------------------------------------
+//  Module init/exit
+//------------------------------------------------------------------------
+
+//------------------------------------------------------------------------
+// called after library was loaded
+inline bool InitModule() { return true; }
+
+//------------------------------------------------------------------------
+// called after library is unloaded
+inline bool DeinitModule() { return true; }
diff --git a/SpectralPhaser/source/plugprocessor.cpp b/SpectralPhaser/source/plugprocessor.cpp
new file mode 100644
index 00000000..85e47ca9
--- /dev/null
+++ b/SpectralPhaser/source/plugprocessor.cpp
@@ -0,0 +1,158 @@
+// Original by:
+// (c) 2018, Steinberg Media Technologies GmbH, All Rights Reserved
+//
+// Modified by:
+// Copyright Takamitsu Endo (ryukau@gmail.com).
+//
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "plugprocessor.hpp"
+#include "fuid.hpp"
+
+#include "base/source/fstreamer.h"
+#include "pluginterfaces/base/ibstream.h"
+#include "pluginterfaces/vst/ivstaudioprocessor.h"
+#include "pluginterfaces/vst/ivstevents.h"
+#include "pluginterfaces/vst/ivstparameterchanges.h"
+
+namespace Steinberg {
+namespace Synth {
+
+PlugProcessor::PlugProcessor() { setControllerClass(ControllerUID); }
+
+tresult PLUGIN_API PlugProcessor::initialize(FUnknown *context)
+{
+  tresult result = AudioEffect::initialize(context);
+  if (result != kResultTrue) return result;
+
+  addAudioInput(STR16("StereoInput"), Vst::SpeakerArr::kStereo);
+  addAudioInput(STR16("SideChainInput"), Vst::SpeakerArr::kStereo, Vst::BusTypes::kAux);
+  addAudioOutput(STR16("StereoOutput"), Vst::SpeakerArr::kStereo);
+
+  return result;
+}
+
+tresult PLUGIN_API PlugProcessor::setBusArrangements(
+  Vst::SpeakerArrangement *inputs,
+  int32 numIns,
+  Vst::SpeakerArrangement *outputs,
+  int32 numOuts)
+{
+  if (numIns == 1 && numOuts == 1 && inputs[0] == outputs[0]) {
+    return AudioEffect::setBusArrangements(inputs, numIns, outputs, numOuts);
+  }
+  return kResultFalse;
+}
+
+uint32 PLUGIN_API PlugProcessor::getProcessContextRequirements()
+{
+  using Rq = Vst::IProcessContextRequirements;
+
+  return Rq::kNeedProjectTimeMusic & Rq::kNeedTempo & Rq::kNeedTransportState
+    & Rq::kNeedTimeSignature;
+}
+
+tresult PLUGIN_API PlugProcessor::setupProcessing(Vst::ProcessSetup &setup)
+{
+  dsp.setup(processSetup.sampleRate);
+  return AudioEffect::setupProcessing(setup);
+}
+
+tresult PLUGIN_API PlugProcessor::setActive(TBool state)
+{
+  if (state) {
+    dsp.setup(processSetup.sampleRate);
+  } else {
+    dsp.reset();
+    lastState = 0;
+  }
+  return AudioEffect::setActive(state);
+}
+
+uint32 PLUGIN_API PlugProcessor::getLatencySamples() { return uint32(dsp.getLatency()); }
+
+tresult PLUGIN_API PlugProcessor::process(Vst::ProcessData &data)
+{
+  using ID = ParameterID::ID;
+
+  // Read inputs parameter changes.
+  if (data.inputParameterChanges) {
+    int32 parameterCount = data.inputParameterChanges->getParameterCount();
+    for (int32 index = 0; index < parameterCount; index++) {
+      auto queue = data.inputParameterChanges->getParameterData(index);
+      if (!queue) continue;
+      Vst::ParamValue value;
+      int32 sampleOffset;
+      if (queue->getPoint(queue->getPointCount() - 1, sampleOffset, value) != kResultTrue)
+        continue;
+      size_t id = queue->getParameterId();
+      if (id < dsp.param.value.size()) dsp.param.value[id]->setFromNormalized(value);
+    }
+  }
+
+  if (data.processContext != nullptr) {
+    uint64_t state = data.processContext->state;
+    if (state & Vst::ProcessContext::kTempoValid) {
+      dsp.tempo = data.processContext->tempo;
+    }
+    if (state & Vst::ProcessContext::kProjectTimeMusicValid) {
+      dsp.beatsElapsed = data.processContext->projectTimeMusic;
+    }
+    if (state & Vst::ProcessContext::kTimeSigValid) {
+      dsp.timeSigLower = data.processContext->timeSigDenominator;
+      dsp.timeSigUpper = data.processContext->timeSigNumerator;
+    }
+    if (!dsp.isPlaying && (state & Vst::ProcessContext::kPlaying) != 0) {
+      dsp.startup();
+    }
+    dsp.isPlaying = state & Vst::ProcessContext::kPlaying;
+  }
+
+  dsp.setParameters();
+
+  if (data.numInputs == 0) return kResultOk;
+  if (data.numOutputs == 0) return kResultOk;
+  if (data.numSamples <= 0) return kResultOk;
+  if (data.numInputs >= 1 && data.inputs[0].numChannels < 2) return kResultOk;
+  if (data.numInputs >= 2 && data.inputs[1].numChannels < 2) return kResultOk;
+  if (data.outputs[0].numChannels < 2) return kResultOk;
+  if (data.symbolicSampleSize == Vst::kSample64) return kResultOk;
+
+  float *in0 = data.inputs[0].channelBuffers32[0];
+  float *in1 = data.inputs[0].channelBuffers32[1];
+
+  size_t sideIndex = data.numInputs <= 1 ? 0 : 1;
+  float *in2 = data.inputs[sideIndex].channelBuffers32[0];
+  float *in3 = data.inputs[sideIndex].channelBuffers32[1];
+
+  float *out0 = data.outputs[0].channelBuffers32[0];
+  float *out1 = data.outputs[0].channelBuffers32[1];
+  dsp.process((size_t)data.numSamples, in0, in1, in2, in3, out0, out1);
+
+  if (dsp.param.value[ParameterID::bypass]->getInt()) processBypass(data);
+
+  return kResultOk;
+}
+
+void PlugProcessor::processBypass(Vst::ProcessData &data)
+{
+  float **in = data.inputs[0].channelBuffers32;
+  float **out = data.outputs[0].channelBuffers32;
+  for (int32_t ch = 0; ch < data.inputs[0].numChannels; ch++) {
+    if (in[ch] != out[ch]) memcpy(out[ch], in[ch], data.numSamples * sizeof(float));
+  }
+}
+
+tresult PLUGIN_API PlugProcessor::setState(IBStream *state)
+{
+  if (!state) return kResultFalse;
+  return dsp.param.setState(state);
+}
+
+tresult PLUGIN_API PlugProcessor::getState(IBStream *state)
+{
+  return dsp.param.getState(state);
+}
+
+} // namespace Synth
+} // namespace Steinberg
diff --git a/SpectralPhaser/source/plugprocessor.hpp b/SpectralPhaser/source/plugprocessor.hpp
new file mode 100644
index 00000000..d74da310
--- /dev/null
+++ b/SpectralPhaser/source/plugprocessor.hpp
@@ -0,0 +1,57 @@
+// Original by:
+// (c) 2018, Steinberg Media Technologies GmbH, All Rights Reserved
+//
+// Modified by:
+// Copyright Takamitsu Endo (ryukau@gmail.com).
+//
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include "public.sdk/source/vst/vstaudioeffect.h"
+
+#include "dsp/dspcore.hpp"
+
+namespace Steinberg {
+namespace Synth {
+
+class PlugProcessor : public Vst::AudioEffect {
+public:
+  PlugProcessor();
+
+  tresult PLUGIN_API initialize(FUnknown *context) SMTG_OVERRIDE;
+  tresult PLUGIN_API setBusArrangements(
+    Vst::SpeakerArrangement *inputs,
+    int32 numIns,
+    Vst::SpeakerArrangement *outputs,
+    int32 numOuts) SMTG_OVERRIDE;
+  uint32 PLUGIN_API getProcessContextRequirements() SMTG_OVERRIDE;
+
+  tresult PLUGIN_API setupProcessing(Vst::ProcessSetup &setup) SMTG_OVERRIDE;
+  tresult PLUGIN_API setActive(TBool state) SMTG_OVERRIDE;
+  tresult PLUGIN_API process(Vst::ProcessData &data) SMTG_OVERRIDE;
+
+  tresult PLUGIN_API setState(IBStream *state) SMTG_OVERRIDE;
+  tresult PLUGIN_API getState(IBStream *state) SMTG_OVERRIDE;
+
+  uint32 PLUGIN_API getLatencySamples() SMTG_OVERRIDE;
+
+  static FUnknown *createInstance(void *)
+  {
+    return (Vst::IAudioProcessor *)new PlugProcessor();
+  }
+
+  void processBypass(Vst::ProcessData &data);
+
+protected:
+  inline int32 toDiscrete(Vst::ParamValue normalized, int32 stepCount)
+  {
+    return int32(std::min<double>(stepCount, normalized * (stepCount + 1.0)));
+  }
+
+  uint64_t lastState = 0;
+  DSPCore dsp;
+};
+
+} // namespace Synth
+} // namespace Steinberg
diff --git a/SpectralPhaser/source/version.hpp b/SpectralPhaser/source/version.hpp
new file mode 100644
index 00000000..72648aaa
--- /dev/null
+++ b/SpectralPhaser/source/version.hpp
@@ -0,0 +1,43 @@
+// Original by:
+// (c) 2018, Steinberg Media Technologies GmbH, All Rights Reserved
+//
+// Modified by:
+// Copyright Takamitsu Endo (ryukau@gmail.com).
+//
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include "pluginterfaces/base/fplatform.h"
+
+#define MAJOR_VERSION_STR "0"
+#define MAJOR_VERSION_INT 0
+
+#define SUB_VERSION_STR "1"
+#define SUB_VERSION_INT 1
+
+#define RELEASE_NUMBER_STR "0"
+#define RELEASE_NUMBER_INT 0
+
+#define BUILD_NUMBER_STR "0"
+#define BUILD_NUMBER_INT 0
+
+#define FULL_VERSION_STR                                                                 \
+  MAJOR_VERSION_STR "." SUB_VERSION_STR "." RELEASE_NUMBER_STR "." BUILD_NUMBER_STR
+
+#define VERSION_STR MAJOR_VERSION_STR "." SUB_VERSION_STR "." RELEASE_NUMBER_STR
+
+#define stringPluginName "SpectralPhaser"
+
+#define stringOriginalFilename "SpectralPhaser.vst3"
+#if SMTG_PLATFORM_64
+  #define stringFileDescription stringPluginName " VST3-SDK (64Bit)"
+#else
+  #define stringFileDescription stringPluginName " VST3-SDK"
+#endif
+#define stringCompanyName "Uhhyou\0"
+#define stringCompanyWeb ""
+#define stringCompanyEmail "ryukau@gmail.com"
+
+#define stringLegalCopyright "Copyright 2024 Takamitsu Endo"
+#define stringLegalTrademarks "VST is a trademark of Steinberg Media Technologies GmbH"
diff --git a/SpectralPhaser/test/testdsp.cpp b/SpectralPhaser/test/testdsp.cpp
new file mode 100644
index 00000000..125680ba
--- /dev/null
+++ b/SpectralPhaser/test/testdsp.cpp
@@ -0,0 +1,20 @@
+// Copyright Takamitsu Endo (ryukau@gmail.com).
+// SPDX-License-Identifier: GPL-3.0-only
+
+#define SET_PARAMETERS dsp->setParameters();
+
+#include "../../test/fxtester.hpp"
+#include "../source/dsp/dspcore.hpp"
+
+// CMake provides this macro, but just in case.
+#ifndef UHHYOU_PLUGIN_NAME
+  #define UHHYOU_PLUGIN_NAME "SpectralPhaser"
+#endif
+
+#define OUT_DIR_PATH "snd/" UHHYOU_PLUGIN_NAME
+
+int main()
+{
+  FxTester<DSPCore> tester(UHHYOU_PLUGIN_NAME, OUT_DIR_PATH);
+  return tester.isFinished ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/TestBedSynth/source/editor.hpp b/TestBedSynth/source/editor.hpp
index 40a46a45..b20868cd 100644
--- a/TestBedSynth/source/editor.hpp
+++ b/TestBedSynth/source/editor.hpp
@@ -72,7 +72,7 @@ class Editor : public PlugEditor {
   {
     auto knob
       = new Knob<style>(CRect(left, top, left + size, top + size), this, tag, palette);
-    knob->setSlitWidth(2.0);
+    knob->setArcWidth(2.0);
     knob->setValueNormalized(controller->getParamNormalized(tag));
     knob->setDefaultValue(param->getDefaultNormalized(tag));
     frame->addView(knob);
diff --git a/UltraSynth/source/editor.hpp b/UltraSynth/source/editor.hpp
index ea94116c..60d1d8f5 100644
--- a/UltraSynth/source/editor.hpp
+++ b/UltraSynth/source/editor.hpp
@@ -74,7 +74,7 @@ class Editor : public PlugEditor {
   {
     auto knob
       = new Knob<style>(CRect(left, top, left + size, top + size), this, tag, palette);
-    knob->setSlitWidth(2.0);
+    knob->setArcWidth(2.0);
     knob->setValueNormalized(controller->getParamNormalized(tag));
     knob->setDefaultValue(param->getDefaultNormalized(tag));
     frame->addView(knob);
@@ -98,7 +98,7 @@ class Editor : public PlugEditor {
   {
     auto knob = new Knob<style>(
       CRect(left, top, left + height, top + height), this, tag, palette);
-    knob->setSlitWidth(2.0);
+    knob->setArcWidth(2.0);
     knob->setValueNormalized(controller->getParamNormalized(tag));
     knob->setDefaultValue(param->getDefaultNormalized(tag));
     frame->addView(knob);
diff --git a/common/gui/knob.hpp b/common/gui/knob.hpp
index 116cc6c6..2955a8ff 100644
--- a/common/gui/knob.hpp
+++ b/common/gui/knob.hpp
@@ -118,7 +118,7 @@ class KnobBase : public CControl {
     event.consumed = true;
   }
 
-  void setSlitWidth(double width) { halfArcWidth = width / 2.0; }
+  void setArcWidth(double width) { halfArcWidth = width / 2.0; }
   void setDefaultTickLength(double length) { defaultTickLength = length; }
 
   void setSensitivity(double sensi, double lowSensi, double wheelSensi)
@@ -129,7 +129,7 @@ class KnobBase : public CControl {
   }
 
 protected:
-  CPoint mapValueToSlit(double normalized, double length)
+  CPoint mapValueToArc(double normalized, double length)
   {
     auto radian
       = (2.0 * normalized - 1.0) * Constants::pi * (180.0 - arcNotchHalf) / 180.0;
@@ -192,15 +192,15 @@ template<Uhhyou::Style style = Uhhyou::Style::common> class Knob : public KnobBa
         radius - halfArcWidth),
       (float)(90.0 + arcNotchHalf), (float)(90.0 - arcNotchHalf));
 
-    // Tick for default value. Sharing color and style with slit.
+    // Tick for default value. Sharing color and style with arc.
     auto tipLength = halfArcWidth - radius;
     pContext->setLineWidth(halfArcWidth / 2.0);
     pContext->drawLine(
-      mapValueToSlit(getDefaultValue() / getRange(), tipLength * defaultTickLength),
-      mapValueToSlit(getDefaultValue() / getRange(), tipLength));
+      mapValueToArc(getDefaultValue() / getRange(), tipLength * defaultTickLength),
+      mapValueToArc(getDefaultValue() / getRange(), tipLength));
 
     // Line from center to tip.
-    auto tip = mapValueToSlit(getValueNormalized(), tipLength);
+    auto tip = mapValueToArc(getValueNormalized(), tipLength);
     pContext->setFrameColor(pal.foreground());
     pContext->drawLine(CPoint(0.0, 0.0), tip);
 
@@ -370,12 +370,12 @@ class NumberKnob : public KnobBase {
         radius - halfArcWidth),
       (float)(90.0 + arcNotchHalf), (float)(90.0 - arcNotchHalf));
 
-    // Tick for default value. Sharing color and style with slit.
+    // Tick for default value. Sharing color and style with arc.
     auto tipLength = halfArcWidth - radius;
     pContext->setLineWidth(halfArcWidth / 2.0);
     pContext->drawLine(
-      mapValueToSlit(getDefaultValue() / getRange(), tipLength * defaultTickLength),
-      mapValueToSlit(getDefaultValue() / getRange(), tipLength));
+      mapValueToArc(getDefaultValue() / getRange(), tipLength * defaultTickLength),
+      mapValueToArc(getDefaultValue() / getRange(), tipLength));
 
     // Text.
     pContext->setFont(fontId);
@@ -392,7 +392,7 @@ class NumberKnob : public KnobBase {
       numberStr.c_str(), CRect(textLeft, textTop, textRight, textBottom));
 
     // Tip.
-    auto tip = mapValueToSlit(getValueNormalized(), tipLength);
+    auto tip = mapValueToArc(getValueNormalized(), tipLength);
     pContext->setFillColor(pal.foreground());
     pContext->drawEllipse(
       CRect(
diff --git a/common/gui/plugeditor.hpp b/common/gui/plugeditor.hpp
index 3635f582..a84e5baf 100644
--- a/common/gui/plugeditor.hpp
+++ b/common/gui/plugeditor.hpp
@@ -440,7 +440,7 @@ class PlugEditor : public VSTGUIEditor, public IControlListener, public IMouseOb
 
     auto knob = new Knob<style>(
       CRect(left, top + margin, left + width, top + width - margin), this, tag, palette);
-    knob->setSlitWidth(8.0);
+    knob->setArcWidth(8.0);
     knob->setValueNormalized(controller->getParamNormalized(tag));
     knob->setDefaultValue(param->getDefaultNormalized(tag));
     frame->addView(knob);
@@ -470,7 +470,7 @@ class PlugEditor : public VSTGUIEditor, public IControlListener, public IMouseOb
     auto knob = new NumberKnob<Scale, style>(
       CRect(left, top + margin, left + width, top + width - margin), this, tag,
       getFont(textSize), palette, scale, offset);
-    knob->setSlitWidth(8.0);
+    knob->setArcWidth(8.0);
     knob->setValueNormalized(controller->getParamNormalized(tag));
     knob->setDefaultValue(param->getDefaultNormalized(tag));
     frame->addView(knob);
@@ -498,7 +498,7 @@ class PlugEditor : public VSTGUIEditor, public IControlListener, public IMouseOb
     auto knob = new RotaryKnob<style>(
       CRect(left + margin, top + margin, left + width - margin, top + width - margin),
       this, tag, palette);
-    knob->setSlitWidth(8.0);
+    knob->setArcWidth(8.0);
     knob->setValueNormalized(controller->getParamNormalized(tag));
     knob->setDefaultValue(param->getDefaultNormalized(tag));
     frame->addView(knob);
diff --git a/common/gui/rotaryknob.hpp b/common/gui/rotaryknob.hpp
index ad597dcf..f0ca1d7f 100644
--- a/common/gui/rotaryknob.hpp
+++ b/common/gui/rotaryknob.hpp
@@ -153,7 +153,7 @@ class RotaryKnob : public RotaryKnobBase {
     pContext->setFillColor(pal.background());
     pContext->drawRect(CRect(0.0, 0.0, width, height), kDrawFilled);
 
-    // Slit.
+    // Arc.
     auto radius = center.x > center.y ? center.y : center.x;
     if constexpr (style == Uhhyou::Style::accent) {
       pContext->setFrameColor(isMouseEntered ? pal.highlightAccent() : pal.unfocused());
@@ -163,22 +163,22 @@ class RotaryKnob : public RotaryKnobBase {
       pContext->setFrameColor(isMouseEntered ? pal.highlightMain() : pal.unfocused());
     }
     pContext->setLineStyle(lineStyle);
-    pContext->setLineWidth(halfSlitWidth * 2.0);
+    pContext->setLineWidth(halfArcWidth * 2.0);
     pContext->drawEllipse(
       CRect(
-        halfSlitWidth - center.x, halfSlitWidth - center.y, center.x - halfSlitWidth,
-        center.y - halfSlitWidth),
+        halfArcWidth - center.x, halfArcWidth - center.y, center.x - halfArcWidth,
+        center.y - halfArcWidth),
       kDrawStroked);
 
-    // Tick for default value. Sharing color and style with slit.
-    auto tipLength = halfSlitWidth - radius;
-    pContext->setLineWidth(halfSlitWidth / 2.0);
+    // Tick for default value. Sharing color and style with arc.
+    auto tipLength = halfArcWidth - radius;
+    pContext->setLineWidth(halfArcWidth / 2.0);
     pContext->drawLine(
-      mapValueToSlit(getDefaultValue() / getRange(), tipLength * defaultTickLength),
-      mapValueToSlit(getDefaultValue() / getRange(), tipLength));
+      mapValueToArc(getDefaultValue() / getRange(), tipLength * defaultTickLength),
+      mapValueToArc(getDefaultValue() / getRange(), tipLength));
 
     // Line from center to tip.
-    auto tip = mapValueToSlit(getValueNormalized(), tipLength);
+    auto tip = mapValueToArc(getValueNormalized(), tipLength);
     pContext->setFrameColor(pal.foreground());
     pContext->drawLine(CPoint(0.0, 0.0), tip);
 
@@ -186,18 +186,18 @@ class RotaryKnob : public RotaryKnobBase {
     pContext->setFillColor(pal.foreground());
     pContext->drawEllipse(
       CRect(
-        tip.x - halfSlitWidth, tip.y - halfSlitWidth, tip.x + halfSlitWidth,
-        tip.y + halfSlitWidth),
+        tip.x - halfArcWidth, tip.y - halfArcWidth, tip.x + halfArcWidth,
+        tip.y + halfArcWidth),
       kDrawFilled);
 
     setDirty(false);
   }
 
-  void setSlitWidth(double width) { halfSlitWidth = width / 2.0; }
+  void setArcWidth(double width) { halfArcWidth = width / 2.0; }
   void setDefaultTickLength(double length) { defaultTickLength = length; }
 
 protected:
-  CPoint mapValueToSlit(double normalized, double length)
+  CPoint mapValueToArc(double normalized, double length)
   {
     auto radian = 2.0 * normalized * Constants::pi;
     return CPoint(-sin(radian) * length, cos(radian) * length);
@@ -205,8 +205,7 @@ class RotaryKnob : public RotaryKnobBase {
 
   const CLineStyle lineStyle{CLineStyle::kLineCapRound, CLineStyle::kLineJoinRound};
 
-  double halfSlitWidth = 4.0;
-  const double slitNotchHalf = 30.0; // Degree.
+  double halfArcWidth = 4.0;
   double defaultTickLength = 0.5;
 };