diff --git a/src/fx_chorus.cpp b/src/fx_chorus.cpp
index 8dd1d6b..0330a5e 100644
--- a/src/fx_chorus.cpp
+++ b/src/fx_chorus.cpp
@@ -2,16 +2,14 @@
 
 #include <cmath>
 
-#define CHORUS_BUFFER_SIZE 8192
-
 #define LFO1_MAX_FREQ 0.25f
 #define LFO2_MAX_FREQ 0.35f
 
-#define FULLSCALE_DEPTH_RATIO 384.0f
+#define FULLSCALE_DEPTH_RATIO 1536.0f
 
 Chorus::Chorus(float32_t sampling_rate) :
     FXElement(sampling_rate),
-    engine_(sampling_rate, LFO1_MAX_FREQ, LFO2_MAX_FREQ),
+    engine_(sampling_rate, 0.0f, 0.0f),
     rate_(0.0f),
     depth_(0.0f),
     fullscale_depth_(0.0f),
@@ -40,13 +38,13 @@ void Chorus::processSample(float32_t inL, float32_t inR, float32_t& outL, float3
     Engine::DelayLine<Memory, 0> line;
     Engine::Context c;
 
-    engine_.start(&c);
+    this->engine_.start(&c);
     
     // Update LFO.
-    float32_t sin_1 = this->lfo_[LFO_Index::Sin1]->process() * 4.0f;
-    float32_t cos_1 = this->lfo_[LFO_Index::Cos1]->process() * 4.0f;
-    float32_t sin_2 = this->lfo_[LFO_Index::Sin2]->process() * 4.0f;
-    float32_t cos_2 = this->lfo_[LFO_Index::Cos2]->process() * 4.0f;
+    float32_t sin_1 = this->lfo_[LFO_Index::Sin1]->process();
+    float32_t cos_1 = this->lfo_[LFO_Index::Cos1]->process();
+    float32_t sin_2 = this->lfo_[LFO_Index::Sin2]->process();
+    float32_t cos_2 = this->lfo_[LFO_Index::Cos2]->process();
 
     float32_t wet;
 
@@ -82,8 +80,12 @@ float32_t Chorus::getRate() const
 
 void Chorus::setDepth(float32_t depth)
 {
-    this->depth_ = constrain(depth, 0.0f, 1.0f);
-    this->fullscale_depth_ = this->depth_ * FULLSCALE_DEPTH_RATIO;
+    depth = constrain(depth, 0.0f, 1.0f);
+    if(this->depth_ != depth)
+    {
+        this->depth_ = depth;
+        this->fullscale_depth_ = this->depth_ * FULLSCALE_DEPTH_RATIO;
+    }
 }
 
 float32_t Chorus::getDepth() const
diff --git a/src/fx_orbitone.cpp b/src/fx_orbitone.cpp
index 4aa6571..7434e8d 100644
--- a/src/fx_orbitone.cpp
+++ b/src/fx_orbitone.cpp
@@ -2,99 +2,114 @@
 
 #include <cmath>
 
-OrbitoneParameter::OrbitoneParameter(float32_t sampling_rate, float32_t feedback) :
-    FXBase(sampling_rate),
-    feedback_(feedback)
-{
-}
+#define LFO_SLOW_MAX_FREQUENCY 1.0f
+#define LFO_FAST_MAX_FREQUENCY 8.8f
 
-OrbitoneParameter::~OrbitoneParameter()
-{
-}
+#define FULLSCALE_DEPTH_RATIO 256.0f
 
-void OrbitoneParameter::setFeedback(float32_t feedback)
+Orbitone::Orbitone(float32_t sampling_rate, float32_t rate, float32_t depth) : 
+    FXElement(sampling_rate),
+    engine_(sampling_rate, 0.0f, 0.0f),
+    depth_(0.0f),
+    fullscale_depth_(0.0f)
 {
-    this->feedback_ = constrain(feedback, 0.0f, 1.0f);
-}
+    this->lfo_[LFO_Index::Slow0  ] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_SLOW_MAX_FREQUENCY, 0.0f);
+    this->lfo_[LFO_Index::Slow120] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_SLOW_MAX_FREQUENCY, 2.0f * PI / 3.0);
+    this->lfo_[LFO_Index::Slow240] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_SLOW_MAX_FREQUENCY, 4.0f * PI / 3.0);
 
-inline float32_t OrbitoneParameter::getFeedback() const
-{
-    return this->feedback_;
-}
+    this->lfo_[LFO_Index::Fast0  ] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_FAST_MAX_FREQUENCY, 0.0f);
+    this->lfo_[LFO_Index::Fast120] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_FAST_MAX_FREQUENCY, 2.0f * PI / 3.0);
+    this->lfo_[LFO_Index::Fast240] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_FAST_MAX_FREQUENCY, 4.0f * PI / 3.0);
 
+    for(unsigned i = 0; i < 6; ++i)
+    {
+        this->lfo_[i]->setNormalizedFrequency(rate);
+    }
 
-
-// OrbitoneStage implementation
-OrbitoneStage::OrbitoneStage(float32_t sampling_rate, OrbitoneParameter* params, float32_t frequency, float32_t level) :
-    FXElement(sampling_rate),
-    params_(params),
-    lfo_(sampling_rate, LFO::Waveform::Sine, 0.0f, 20000.0f),
-    level_(level)
-{
-    this->lfo_.setFrequency(frequency);
-
-    this->x_[0] = this->x_[1] = 0.0f;
+    this->setDepth(depth);
 }
 
-OrbitoneStage::~OrbitoneStage()
+Orbitone::~Orbitone()
 {
+    for(unsigned i = 0; i < 6; ++i)
+    {
+        delete this->lfo_[i];
+    }
 }
 
-void OrbitoneStage::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
+void Orbitone::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
 {
-    // Generate a sine wave using the stage's oscillator
-    float32_t osc = this->level_ * this->lfo_.process();
-
-    // Apply feedback to the stage's input
-    outL = inL + inL * osc + this->params_->getFeedback() * this->x_[0];
-    outR = inR + inR * osc + this->params_->getFeedback() * this->x_[1];
+    typedef Engine::Reserve<2047, Engine::Reserve<2047> > Memory;
+    Engine::DelayLine<Memory, 0> line_l;
+    Engine::DelayLine<Memory, 1> line_r;
+    Engine::Context c;
+
+    this->engine_.start(&c);
+    
+    float32_t slow_0   = this->lfo_[LFO_Index::Slow0  ]->process();
+    float32_t slow_120 = this->lfo_[LFO_Index::Slow120]->process();
+    float32_t slow_240 = this->lfo_[LFO_Index::Slow240]->process();
+
+    float32_t fast_0   = this->lfo_[LFO_Index::Fast0  ]->process();
+    float32_t fast_120 = this->lfo_[LFO_Index::Fast120]->process();
+    float32_t fast_240 = this->lfo_[LFO_Index::Fast240]->process();
+      
+    float32_t a = this->fullscale_depth_ * 1.0f;
+    float32_t b = this->fullscale_depth_ * 0.1f;
+    
+    float32_t mod_1 = slow_0   * a + fast_0   * b;
+    float32_t mod_2 = slow_120 * a + fast_120 * b;
+    float32_t mod_3 = slow_240 * a + fast_240 * b;
+
+    float32_t wet = 0.0f;
+
+    // Sum L & R channel to send to chorus line.
+    c.read(inL, 1.0f);
+    c.write(line_l, 0.0f);
+    c.read(inR, 1.0f);
+    c.write(line_r, 0.0f);
+
+    c.interpolate(line_l, mod_1 + 1024, 0.33f);
+    c.interpolate(line_l, mod_2 + 1024, 0.33f);
+    c.interpolate(line_r, mod_3 + 1024, 0.33f);
+    c.write(wet, 0.0f);
+    outL = wet;
+    
+    c.interpolate(line_r, mod_1 + 1024, 0.33f);
+    c.interpolate(line_r, mod_2 + 1024, 0.33f);
+    c.interpolate(line_l, mod_3 + 1024, 0.33f);
+    c.write(wet, 0.0f);
+    outR = wet;
 }
 
-
-
-// Orbitone implementation
-Orbitone::Orbitone(float32_t sampling_rate, float32_t feedback) : 
-    FXElement(sampling_rate),
-    params_(sampling_rate, feedback)
+void Orbitone::setRate(float32_t rate)
 {
-    float32_t level = 1.0f;
-    for(unsigned i = 0; i < NUM_ORBITONR_STAGES; ++i)
+    rate = constrain(rate, 0.0f, 1.0f);
+    if(this->lfo_[LFO_Index::Slow0]->getNormalizedFrequency() != rate)
     {
-        float32_t frequency = 440.0 * pow(2.0f, (i - 1) / 12.0f);   // Sets the frequency of each stage to be a multiple of 440 Hz
-        level /= 2.0f;
-        this->stages_[i] = new OrbitoneStage(sampling_rate, &this->params_, frequency, level);
+        for(unsigned i = 0; i < 6; ++i)
+        {
+            this->lfo_[i]->setNormalizedFrequency(rate);
+        }
     }
 }
 
-Orbitone::~Orbitone()
+float32_t Orbitone::getRate() const
 {
-    for(unsigned i = 0; i < NUM_ORBITONR_STAGES; ++i)
-    {
-        delete this->stages_[i];
-    }
+    return this->lfo_[LFO_Index::Slow0]->getNormalizedFrequency();
 }
 
-void Orbitone::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
+void Orbitone::setDepth(float32_t depth)
 {
-    // Process the input sample through each stage of the phaser
-    float32_t sampleL = inL;
-    float32_t sampleR = inR;
-    for(unsigned s = 0; s < NUM_ORBITONR_STAGES; ++s)
+    depth = constrain(depth, 0.0f, 1.0f);
+    if(this->depth_ != depth)
     {
-        this->stages_[s]->processSample(sampleL, sampleR, sampleL, sampleR);
+        this->depth_ = depth;
+        this->fullscale_depth_ = this->depth_ * FULLSCALE_DEPTH_RATIO;
     }
-
-    // Modulate the output of the phaser using the LFO 
-    outL = sampleL;
-    outR = sampleR;
-}
-
-void Orbitone::setFeedback(float32_t feedback)
-{
-    this->params_.setFeedback(feedback);
 }
 
-float32_t Orbitone::getFeedback() const
+float32_t Orbitone::getDepth() const
 {
-    return this->params_.getFeedback();
+    return this->depth_;
 }
diff --git a/src/fx_orbitone.h b/src/fx_orbitone.h
index 0a54894..6c5dfd3 100644
--- a/src/fx_orbitone.h
+++ b/src/fx_orbitone.h
@@ -15,62 +15,45 @@
 // fx_orbitone.h
 //
 // Stereo Orbitone audio effects proposed in the context of the MiniDexed project
+// This audio effect is based on the Ensemble audio effect of the Rings Eurorack module by Mutable Instruments
 //
 #pragma once
 
 #include "fx_components.h"
-
-class OrbitoneStage;
-
-class OrbitoneParameter : public FXBase
-{
-    friend class OrbitoneStage;
-    DISALLOW_COPY_AND_ASSIGN(OrbitoneParameter);
-
-public:
-    OrbitoneParameter(float32_t sampling_rate, float32_t feedback = 0.5f);
-    virtual ~OrbitoneParameter();
-
-    void setFeedback(float32_t feedback);
-    inline float32_t getFeedback() const;
-
-private:
-    float32_t feedback_;        // Amount of feedback to apply to the stage's input (0.0 - 1.0)
-};
-
-class OrbitoneStage : public FXElement
-{
-    DISALLOW_COPY_AND_ASSIGN(OrbitoneStage);
-
-public:
-    OrbitoneStage(float32_t sampling_rate, OrbitoneParameter* params, float32_t frequency, float32_t level);
-    virtual ~OrbitoneStage();
-
-    virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
-
-private:
-    OrbitoneParameter* params_;
-    LFO lfo_;
-    float32_t level_;
-    float32_t x_[2];
-};
-
-#define NUM_ORBITONR_STAGES 4
+#include "fx_engine.hpp"
 
 class Orbitone : public FXElement
 {
     DISALLOW_COPY_AND_ASSIGN(Orbitone);
 
 public:
-    Orbitone(float32_t sampling_rate, float32_t feedback = 0.5f);
+    enum LFO_Index
+    {
+        Slow0 = 0,
+        Slow120,
+        Slow240,
+        Fast0,
+        Fast120,
+        Fast240
+    };
+
+    Orbitone(float32_t sampling_rate, float32_t rate = 0.5f, float32_t depth = 0.5f);
     virtual ~Orbitone();
 
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
-    void setFeedback(float32_t feedback);
-    float32_t getFeedback() const;
+    void setRate(float32_t rate);
+    float32_t getRate() const;
+
+    void setDepth(float32_t depth);
+    float32_t getDepth() const;
 
 private:
-    OrbitoneParameter params_;
-    OrbitoneStage* stages_[NUM_ORBITONR_STAGES];
+    typedef FxEngine<4096, FORMAT_16_BIT, false> Engine;
+    Engine engine_;
+
+    float32_t depth_;
+    float32_t fullscale_depth_;
+
+    LFO* lfo_[6];
 };
\ No newline at end of file
diff --git a/src/minidexed.cpp b/src/minidexed.cpp
index 914aee0..73d0868 100644
--- a/src/minidexed.cpp
+++ b/src/minidexed.cpp
@@ -187,8 +187,9 @@ CMiniDexed::CMiniDexed (CConfig *pConfig, CInterruptSystem *pInterrupt,
 
 	// FXChain > Orbitone parameters
 	this->SetParameter(ParameterFXChainOrbitoneEnable, 1);
-	this->SetParameter(ParameterFXChainOrbitoneWet, 50);
-	this->SetParameter(ParameterFXChainOrbitoneFeedback, 65);
+	this->SetParameter(ParameterFXChainOrbitoneWet, 80);
+	this->SetParameter(ParameterFXChainOrbitoneRate, 40);
+	this->SetParameter(ParameterFXChainOrbitoneDepth, 50);
 
 	// FXChain > Phaser parameters
 	this->SetParameter(ParameterFXChainPhaserEnable, 1);
@@ -854,10 +855,16 @@ void CMiniDexed::SetParameter (TParameter Parameter, int nValue)
 		this->fx_rack->getOrbitone()->setWetLevel(nValue / 99.0f);
 		this->m_FXSpinLock.Release();
 		break;
-	case ParameterFXChainOrbitoneFeedback: 
+	case ParameterFXChainOrbitoneRate: 
 		nValue = constrain((int)nValue, 0, 99);
 		this->m_FXSpinLock.Acquire();
-		this->fx_rack->getOrbitone()->setFeedback(nValue / 99.0f);
+		this->fx_rack->getOrbitone()->setRate(nValue / 99.0f);
+		this->m_FXSpinLock.Release();
+		break;
+	case ParameterFXChainOrbitoneDepth: 
+		nValue = constrain((int)nValue, 0, 99);
+		this->m_FXSpinLock.Acquire();
+		this->fx_rack->getOrbitone()->setDepth(nValue / 99.0f);
 		this->m_FXSpinLock.Release();
 		break;
 	
@@ -1401,7 +1408,8 @@ bool CMiniDexed::DoSavePerformance (void)
 	this->m_PerformanceConfig.SetFXChainFlangerFeedback(this->m_nParameter[ParameterFXChainFlangerFeedback]);
 	this->m_PerformanceConfig.SetFXChainOrbitoneEnable(!!this->m_nParameter[ParameterFXChainOrbitoneEnable]);
 	this->m_PerformanceConfig.SetFXChainOrbitoneWet(this->m_nParameter[ParameterFXChainOrbitoneWet]);
-	this->m_PerformanceConfig.SetFXChainOrbitoneFeedback(this->m_nParameter[ParameterFXChainOrbitoneFeedback]);
+	this->m_PerformanceConfig.SetFXChainOrbitoneRate(this->m_nParameter[ParameterFXChainOrbitoneRate]);
+	this->m_PerformanceConfig.SetFXChainOrbitoneDepth(this->m_nParameter[ParameterFXChainOrbitoneDepth]);
 	this->m_PerformanceConfig.SetFXChainPhaserEnable(!!this->m_nParameter[ParameterFXChainPhaserEnable]);
 	this->m_PerformanceConfig.SetFXChainPhaserWet(this->m_nParameter[ParameterFXChainPhaserWet]);
 	this->m_PerformanceConfig.SetFXChainPhaserRate(this->m_nParameter[ParameterFXChainPhaserRate]);
@@ -1828,7 +1836,8 @@ void CMiniDexed::LoadPerformanceParameters(void)
 		this->SetParameter(ParameterFXChainFlangerFeedback, this->m_PerformanceConfig.GetFXChainFlangerFeedback());
 		this->SetParameter(ParameterFXChainOrbitoneEnable, this->m_PerformanceConfig.GetFXChainOrbitoneEnable());
 		this->SetParameter(ParameterFXChainOrbitoneWet, this->m_PerformanceConfig.GetFXChainOrbitoneWet());
-		this->SetParameter(ParameterFXChainOrbitoneFeedback, this->m_PerformanceConfig.GetFXChainOrbitoneFeedback());
+		this->SetParameter(ParameterFXChainOrbitoneRate, this->m_PerformanceConfig.GetFXChainOrbitoneRate());
+		this->SetParameter(ParameterFXChainOrbitoneDepth, this->m_PerformanceConfig.GetFXChainOrbitoneDepth());
 		this->SetParameter(ParameterFXChainPhaserEnable, this->m_PerformanceConfig.GetFXChainPhaserEnable());
 		this->SetParameter(ParameterFXChainPhaserWet, this->m_PerformanceConfig.GetFXChainPhaserWet());
 		this->SetParameter(ParameterFXChainPhaserRate, this->m_PerformanceConfig.GetFXChainPhaserRate());
diff --git a/src/minidexed.h b/src/minidexed.h
index 15970ce..98d5dc1 100644
--- a/src/minidexed.h
+++ b/src/minidexed.h
@@ -168,7 +168,8 @@ public:
 		// FXChain > Orbitone parameters
 		ParameterFXChainOrbitoneEnable,
 		ParameterFXChainOrbitoneWet,
-		ParameterFXChainOrbitoneFeedback,
+		ParameterFXChainOrbitoneRate,
+		ParameterFXChainOrbitoneDepth,
 
 		// FXChain > Phaser parameters
 		ParameterFXChainPhaserEnable,
diff --git a/src/performance.ini b/src/performance.ini
index 54924e5..3b7a662 100644
--- a/src/performance.ini
+++ b/src/performance.ini
@@ -300,8 +300,9 @@ FXChainFlangerRate=15
 FXChainFlangerDepth=10
 FXChainFlangerFeedback=20
 FXChainOrbitoneEnable=0
-FXChainOrbitoneWet=50
-FXChainOrbitoneFeedback=65
+FXChainOrbitoneWet=80
+FXChainOrbitoneRate=40
+FXChainOrbitoneDepth=50
 FXChainPhaserEnable=0
 FXChainPhaserWet=50
 FXChainPhaserRate=5
diff --git a/src/performanceconfig.cpp b/src/performanceconfig.cpp
index 8a7b76c..bb54c29 100644
--- a/src/performanceconfig.cpp
+++ b/src/performanceconfig.cpp
@@ -176,8 +176,9 @@ bool CPerformanceConfig::Load (void)
 	this->m_nFXChainFlangerDepth = this->m_Properties.GetNumber("FXChainFlangerDepth", 10);
 	this->m_nFXChainFlangerFeedback = this->m_Properties.GetNumber("FXChainFlangerFeedback", 20);
 	this->m_bFXChainOrbitoneEnable = this->m_Properties.GetNumber("FXChainOrbitoneEnable", 1);
-	this->m_nFXChainOrbitoneWet = this->m_Properties.GetNumber("FXChainOrbitoneWet", 50);
-	this->m_nFXChainOrbitoneFeedback = this->m_Properties.GetNumber("FXChainOrbitoneFeedback", 65);
+	this->m_nFXChainOrbitoneWet = this->m_Properties.GetNumber("FXChainOrbitoneWet", 80);
+	this->m_nFXChainOrbitoneRate = this->m_Properties.GetNumber("FXChainOrbitoneRate", 40);
+	this->m_nFXChainOrbitoneDepth = this->m_Properties.GetNumber("FXChainOrbitoneDepth", 50);
 	this->m_bFXChainPhaserEnable = this->m_Properties.GetNumber("FXChainPhaserEnable", 1);
 	this->m_nFXChainPhaserWet = this->m_Properties.GetNumber("FXChainPhaserWet", 50);
 	this->m_nFXChainPhaserRate = this->m_Properties.GetNumber("FXChainPhaserRate", 5);
@@ -332,8 +333,9 @@ bool CPerformanceConfig::Save (void)
 	this->m_Properties.SetNumber("FXChainFlangerFeedback", m_nFXChainFlangerFeedback);
 	this->m_Properties.SetNumber("FXChainOrbitoneEnable", m_bFXChainOrbitoneEnable ? 1 : 0);
 	this->m_Properties.SetNumber("FXChainOrbitoneWet", m_nFXChainOrbitoneWet);
-	this->m_Properties.SetNumber("FXChainOrbitoneFeedback", m_nFXChainOrbitoneFeedback ? 1 : 0);
-	this->m_Properties.SetNumber("FXChainPhaserEnable", m_bFXChainPhaserEnable);
+	this->m_Properties.SetNumber("FXChainOrbitoneRate", m_nFXChainOrbitoneRate);
+	this->m_Properties.SetNumber("FXChainOrbitoneDepth", m_nFXChainOrbitoneDepth);
+	this->m_Properties.SetNumber("FXChainPhaserEnable", m_bFXChainPhaserEnable ? 1 : 0);
 	this->m_Properties.SetNumber("FXChainPhaserWet", m_nFXChainPhaserWet);
 	this->m_Properties.SetNumber("FXChainPhaserRate", m_nFXChainPhaserRate);
 	this->m_Properties.SetNumber("FXChainPhaserResonance", m_nFXChainPhaserResonance);
@@ -1084,9 +1086,14 @@ unsigned CPerformanceConfig::GetFXChainOrbitoneWet(void) const
 	return this->m_nFXChainOrbitoneWet;
 }
 
-unsigned CPerformanceConfig::GetFXChainOrbitoneFeedback(void) const
+unsigned CPerformanceConfig::GetFXChainOrbitoneRate(void) const
 {
-	return this->m_nFXChainOrbitoneFeedback;
+	return this->m_nFXChainOrbitoneRate;
+}
+
+unsigned CPerformanceConfig::GetFXChainOrbitoneDepth(void) const
+{
+	return this->m_nFXChainOrbitoneDepth;
 }
 
 bool CPerformanceConfig::GetFXChainPhaserEnable(void) const
@@ -1254,9 +1261,14 @@ void CPerformanceConfig::SetFXChainOrbitoneWet(unsigned nValue)
 	this->m_nFXChainOrbitoneWet = nValue;
 }
 
-void CPerformanceConfig::SetFXChainOrbitoneFeedback(unsigned nValue)
+void CPerformanceConfig::SetFXChainOrbitoneRate(unsigned nValue)
+{
+	this->m_nFXChainOrbitoneRate = nValue;
+}
+
+void CPerformanceConfig::SetFXChainOrbitoneDepth(unsigned nValue)
 {
-	this->m_nFXChainOrbitoneFeedback = nValue;
+	this->m_nFXChainOrbitoneDepth = nValue;
 }
 
 void CPerformanceConfig::SetFXChainPhaserEnable(bool bValue)
diff --git a/src/performanceconfig.h b/src/performanceconfig.h
index e568197..d9af2f7 100644
--- a/src/performanceconfig.h
+++ b/src/performanceconfig.h
@@ -135,7 +135,8 @@ public:
 	unsigned GetFXChainFlangerFeedback(void) const;
 	bool GetFXChainOrbitoneEnable(void) const;
 	unsigned GetFXChainOrbitoneWet(void) const;
-	unsigned GetFXChainOrbitoneFeedback(void) const;
+	unsigned GetFXChainOrbitoneRate(void) const;
+	unsigned GetFXChainOrbitoneDepth(void) const;
 	bool GetFXChainPhaserEnable(void) const;
 	unsigned GetFXChainPhaserWet(void) const;
 	unsigned GetFXChainPhaserRate(void) const;
@@ -170,7 +171,8 @@ public:
 	void SetFXChainFlangerFeedback(unsigned nValue);
 	void SetFXChainOrbitoneEnable(bool bValue);
 	void SetFXChainOrbitoneWet(unsigned nValue);
-	void SetFXChainOrbitoneFeedback(unsigned nValue);
+	void SetFXChainOrbitoneRate(unsigned nValue);
+	void SetFXChainOrbitoneDepth(unsigned nValue);
 	void SetFXChainPhaserEnable(bool bValue);
 	void SetFXChainPhaserWet(unsigned nValue);
 	void SetFXChainPhaserRate(unsigned nValue);
@@ -274,7 +276,8 @@ private:
 	unsigned m_nFXChainFlangerFeedback;
 	bool m_bFXChainOrbitoneEnable;
 	unsigned m_nFXChainOrbitoneWet;
-	unsigned m_nFXChainOrbitoneFeedback;
+	unsigned m_nFXChainOrbitoneRate;
+	unsigned m_nFXChainOrbitoneDepth;
 	bool m_bFXChainPhaserEnable;
 	unsigned m_nFXChainPhaserWet;
 	unsigned m_nFXChainPhaserRate;
diff --git a/src/test/fxrack_test.cpp b/src/test/fxrack_test.cpp
index 760b5a9..15a1bd9 100644
--- a/src/test/fxrack_test.cpp
+++ b/src/test/fxrack_test.cpp
@@ -189,16 +189,17 @@ int main()
     rack->getTube()->setWetLevel(1.0f);
     rack->getTube()->setOverdrive(1.0f);
 
-    rack->getChorus()->setEnable(true);
+    rack->getChorus()->setEnable(false);
     rack->getChorus()->setWetLevel(0.5f);
     rack->getChorus()->setRate(0.4f);
     rack->getChorus()->setDepth(0.5f);
     
     rack->getPhaser()->setEnable(false);
 
-    rack->getOrbitone()->setEnable(false);
+    rack->getOrbitone()->setEnable(true);
     rack->getOrbitone()->setWetLevel(0.8f);
-    rack->getOrbitone()->setFeedback(1.0f);
+    rack->getOrbitone()->setRate(0.4f);
+    rack->getOrbitone()->setDepth(0.5f);
 
     rack->getFlanger()->setEnable(false);
 
diff --git a/src/uimenu.cpp b/src/uimenu.cpp
index a1344c6..c2cd34b 100644
--- a/src/uimenu.cpp
+++ b/src/uimenu.cpp
@@ -188,7 +188,8 @@ const CUIMenu::TMenuItem CUIMenu::s_FXChainOrbitone[] =
 {
 	{"Enable", 	EditGlobalParameter, 	0, CMiniDexed::ParameterFXChainOrbitoneEnable},
 	{"Wet Lvl", EditGlobalParameter,	0, CMiniDexed::ParameterFXChainOrbitoneWet},
-	{"Feedbck", EditGlobalParameter,	0, CMiniDexed::ParameterFXChainOrbitoneFeedback},
+	{"Rate", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainOrbitoneRate},
+	{"Depth", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainOrbitoneDepth},
 	{0}
 };
 
@@ -333,7 +334,8 @@ const CUIMenu::TParameter CUIMenu::s_GlobalParameter[CMiniDexed::ParameterUnknow
 	// FXChain > Orbitone parameters
 	{0,	1,	1,	ToOnOff},	// ParameterFXChainOrbitoneEnable
 	{0,	99,	1},				// ParameterFXChainOrbitoneWet
-	{0,	99,	1},				// ParameterFXChainOrbitoneFeedback
+	{0,	99,	1},				// ParameterFXChainOrbitoneRate
+	{0,	99,	1},				// ParameterFXChainOrbitoneDepth
 
 	// FXChain > Phaser parameters
 	{0,	1,	1,	ToOnOff},	// ParameterFXChainPhaserEnable