diff --git a/plugins/Cardinal/src/HostParameters-Map.cpp b/plugins/Cardinal/src/HostParameters-Map.cpp
index edfa93c..eed89b5 100644
--- a/plugins/Cardinal/src/HostParameters-Map.cpp
+++ b/plugins/Cardinal/src/HostParameters-Map.cpp
@@ -63,8 +63,8 @@ struct HostParametersMap : TerminalModule {
     uint8_t learningId = UINT8_MAX;
 
     CardinalPluginContext* const pcontext;
-    bool parametersChanged[kModuleParameters] = {};
-    float parameterValues[kModuleParameters];
+    bool parametersChanged[kModuleParameterCount] = {};
+    float parameterValues[kModuleParameterCount];
     bool bypassed = false;
     bool firstRun = true;
     uint32_t lastProcessCounter = 0;
@@ -135,7 +135,7 @@ struct HostParametersMap : TerminalModule {
         if (isBypassed())
             return;
 
-        for (uint32_t i = 0; i < kModuleParameters; ++i)
+        for (uint32_t i = 0; i < kModuleParameterCount; ++i)
         {
             if (d_isEqual(pcontext->parameters[i], parameterValues[i]))
                 continue;
@@ -161,7 +161,7 @@ struct HostParametersMap : TerminalModule {
 
             // Validate hostParamId
             const uint8_t hostParamId = mappings[id].hostParamId;
-            if (hostParamId >= kModuleParameters)
+            if (hostParamId >= kModuleParameterCount)
                 continue;
 
             // Set filter from param value if filter is uninitialized
@@ -350,7 +350,7 @@ struct ParameterIndexQuantity : Quantity {
         return 0;
     }
     float getMaxValue() override {
-        return kModuleParameters - 1;
+        return kModuleParameterCount - 1;
     }
     float getDefaultValue() override {
         return 0;
@@ -360,7 +360,7 @@ struct ParameterIndexQuantity : Quantity {
     }
     void setValue(float value) override {
         v = math::clamp(value, getMinValue(), getMaxValue());
-        mapping.hostParamId = math::clamp(static_cast<int>(v + 0.5f), 0, kModuleParameters - 1);
+        mapping.hostParamId = math::clamp(static_cast<int>(v + 0.5f), 0, kModuleParameterCount - 1);
     }
     float getDisplayValue() override {
         return mapping.hostParamId + 1;
@@ -437,7 +437,7 @@ struct HostParametersMapChoice : CardinalLedDisplayChoice {
             if (ParamWidget* const touchedParam = APP->scene->rack->touchedParam)
             {
                 APP->scene->rack->touchedParam = nullptr;
-                DISTRHO_SAFE_ASSERT_RETURN(mapping.hostParamId < kModuleParameters,);
+                DISTRHO_SAFE_ASSERT_RETURN(mapping.hostParamId < kModuleParameterCount,);
 
                 const int64_t moduleId = touchedParam->module->id;
                 const int paramId = touchedParam->paramId;
@@ -453,7 +453,7 @@ struct HostParametersMapChoice : CardinalLedDisplayChoice {
         text.clear();
 
         // mapped
-        if (module->mappings[id].hostParamId < kModuleParameters)
+        if (module->mappings[id].hostParamId < kModuleParameterCount)
             text += string::f("P%02d: ", module->mappings[id].hostParamId + 1);
         if (module->mappings[id].paramHandle.moduleId >= 0)
             text += getParamName();
diff --git a/plugins/Cardinal/src/HostParameters.cpp b/plugins/Cardinal/src/HostParameters.cpp
index a2e57ae..97c8912 100644
--- a/plugins/Cardinal/src/HostParameters.cpp
+++ b/plugins/Cardinal/src/HostParameters.cpp
@@ -28,15 +28,15 @@ struct HostParameters : TerminalModule {
         NUM_INPUTS
     };
     enum OutputIds {
-        NUM_OUTPUTS = 24
+        NUM_OUTPUTS = kModuleParameterCount
     };
     enum LightIds {
         NUM_LIGHTS
     };
 
     CardinalPluginContext* const pcontext;
-    rack::dsp::SlewLimiter parameters[kModuleParameters];
-    bool parametersConnected[kModuleParameters] = {};
+    rack::dsp::SlewLimiter parameters[kModuleParameterCount];
+    bool parametersConnected[kModuleParameterCount] = {};
     bool bypassed = false;
     bool smooth = true;
     uint32_t lastProcessCounter = 0;
@@ -59,7 +59,7 @@ struct HostParameters : TerminalModule {
             bypassed = isBypassed();
             lastProcessCounter = processCounter;
 
-            for (uint32_t i=0; i<kModuleParameters; ++i)
+            for (uint32_t i=0; i<kModuleParameterCount; ++i)
             {
                 const bool connected = outputs[i].isConnected();
 
@@ -74,7 +74,7 @@ struct HostParameters : TerminalModule {
         if (bypassed)
             return;
 
-        for (uint32_t i=0; i<kModuleParameters; ++i)
+        for (uint32_t i=0; i<kModuleParameterCount; ++i)
         {
             if (parametersConnected[i])
                 outputs[i].setVoltage(smooth ? parameters[i].process(args.sampleTime, pcontext->parameters[i])
@@ -89,7 +89,7 @@ struct HostParameters : TerminalModule {
     {
         const double fall = 1.0 / (double(pcontext->bufferSize) / e.sampleRate);
 
-        for (uint32_t i=0; i<kModuleParameters; ++i)
+        for (uint32_t i=0; i<kModuleParameterCount; ++i)
         {
             parameters[i].reset();
             parameters[i].setRiseFall(fall, fall);
diff --git a/plugins/Cardinal/src/plugincontext.hpp b/plugins/Cardinal/src/plugincontext.hpp
index b88ce0d..f7fcc03 100644
--- a/plugins/Cardinal/src/plugincontext.hpp
+++ b/plugins/Cardinal/src/plugincontext.hpp
@@ -33,7 +33,7 @@ END_NAMESPACE_DGL
 
 START_NAMESPACE_DISTRHO
 
-static constexpr const uint32_t kModuleParameters = 24;
+static constexpr const uint32_t kModuleParameterCount = 24;
 
 enum CardinalVariant {
     kCardinalVariantMain,
@@ -57,7 +57,7 @@ struct MidiEvent {
 struct CardinalPluginContext : rack::Context {
     uint32_t bufferSize, processCounter;
     double sampleRate;
-    float parameters[kModuleParameters];
+    float parameters[kModuleParameterCount];
     CardinalVariant variant;
     bool bypassed, playing, reset, bbtValid;
     int32_t bar, beat, beatsPerBar, beatType;
diff --git a/src/CardinalMini/DistrhoPluginInfo.h b/src/CardinalMini/DistrhoPluginInfo.h
index 7a6b206..786c9fe 100644
--- a/src/CardinalMini/DistrhoPluginInfo.h
+++ b/src/CardinalMini/DistrhoPluginInfo.h
@@ -42,8 +42,8 @@
 #define DISTRHO_UI_DEFAULT_WIDTH          1000
 #define DISTRHO_UI_DEFAULT_HEIGHT         600
 #define DISTRHO_PLUGIN_IS_SYNTH           0
-#define DISTRHO_PLUGIN_NUM_INPUTS         CARDINAL_NUM_AUDIO_INPUTS
-#define DISTRHO_PLUGIN_NUM_OUTPUTS        CARDINAL_NUM_AUDIO_OUTPUTS
+#define DISTRHO_PLUGIN_NUM_INPUTS         CARDINAL_NUM_AUDIO_INPUTS + 5
+#define DISTRHO_PLUGIN_NUM_OUTPUTS        CARDINAL_NUM_AUDIO_OUTPUTS + 5
 #define DISTRHO_PLUGIN_WANT_MIDI_INPUT    1
 #define DISTRHO_PLUGIN_WANT_MIDI_OUTPUT   1
 #define DISTRHO_PLUGIN_WANT_FULL_STATE    1
diff --git a/src/CardinalPlugin.cpp b/src/CardinalPlugin.cpp
index b3b60d4..bcf760d 100644
--- a/src/CardinalPlugin.cpp
+++ b/src/CardinalPlugin.cpp
@@ -38,6 +38,7 @@
 # include "extra/Thread.hpp"
 #endif
 
+#include <cfloat>
 #include <list>
 
 #include "CardinalCommon.hpp"
@@ -54,25 +55,8 @@
 
 #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
 # include "extra/ScopedValueSetter.hpp"
-# include "WindowParameters.hpp"
-#else
-# define kWindowParameterCount 0
 #endif
 
-enum CardinalStates {
-    kCardinalStatePatch,
-    kCardinalStateScreenshot,
-    kCardinalStateComment,
-   #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
-    kCardinalStateModuleInfos,
-    kCardinalStateWindowSize,
-   #endif
-   #if CARDINAL_VARIANT_MINI
-    kCardinalStateParamChange,
-   #endif
-    kCardinalStateCount
-};
-
 extern const std::string CARDINAL_VERSION;
 
 namespace rack {
@@ -194,10 +178,13 @@ class CardinalPlugin : public CardinalBasePlugin
     // real values, not VCV interpreted ones
     float fWindowParameters[kWindowParameterCount];
    #endif
+   #if CARDINAL_VARIANT_MINI
+    float fMiniReportValues[kCardinalParameterCountAtMini - kCardinalParameterStartMini];
+   #endif
 
 public:
     CardinalPlugin()
-        : CardinalBasePlugin(kModuleParameters + kWindowParameterCount + 1, 0, kCardinalStateCount),
+        : CardinalBasePlugin(kCardinalParameterCount, 0, kCardinalStateCount),
          #ifdef DISTRHO_OS_WASM
           fInitializer(new Initializer(this, static_cast<const CardinalBaseUI*>(nullptr))),
          #else
@@ -225,6 +212,14 @@ public:
         fWindowParameters[kWindowParameterInvertZoom] = 0.0f;
         fWindowParameters[kWindowParameterSqueezeModulePositions] = 1.0f;
        #endif
+       #if CARDINAL_VARIANT_MINI
+        std::memset(fMiniReportValues, 0, sizeof(fMiniReportValues));
+        fMiniReportValues[kCardinalParameterMiniTimeBar - kCardinalParameterStartMini] = 1;
+        fMiniReportValues[kCardinalParameterMiniTimeBeat - kCardinalParameterStartMini] = 1;
+        fMiniReportValues[kCardinalParameterMiniTimeBeatsPerBar - kCardinalParameterStartMini] = 4;
+        fMiniReportValues[kCardinalParameterMiniTimeBeatType - kCardinalParameterStartMini] = 4;
+        fMiniReportValues[kCardinalParameterMiniTimeBeatsPerMinute - kCardinalParameterStartMini] = 120;
+       #endif
 
         // create unique temporary path for this instance
         try {
@@ -384,17 +379,23 @@ protected:
 
     void initAudioPort(const bool input, uint32_t index, AudioPort& port) override
     {
-       #if CARDINAL_VARIANT_MAIN
-        if (index < 8)
+       #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_MINI
+        static_assert(CARDINAL_NUM_AUDIO_INPUTS == CARDINAL_NUM_AUDIO_OUTPUTS, "inputs == outputs");
+
+        if (index < CARDINAL_NUM_AUDIO_INPUTS)
         {
+           #if CARDINAL_VARIANT_MINI
+            port.groupId = kPortGroupStereo;
+           #else
             port.groupId = index / 2;
+           #endif
         }
         else
         {
             port.hints = kAudioPortIsCV | kCVPortHasPositiveUnipolarRange | kCVPortHasScaledRange | kCVPortIsOptional;
-            index -= 8;
+            index -= CARDINAL_NUM_AUDIO_INPUTS;
         }
-       #elif CARDINAL_VARIANT_MINI || CARDINAL_VARIANT_NATIVE || CARDINAL_VARIANT_FX || CARDINAL_VARIANT_SYNTH
+       #elif CARDINAL_VARIANT_NATIVE || CARDINAL_VARIANT_FX || CARDINAL_VARIANT_SYNTH
         if (index < 2)
             port.groupId = kPortGroupStereo;
        #endif
@@ -429,7 +430,7 @@ protected:
 
     void initParameter(const uint32_t index, Parameter& parameter) override
     {
-        if (index < kModuleParameters)
+        if (index < kCardinalParameterCountAtModules)
         {
             parameter.name = "Parameter ";
             parameter.name += String(index + 1);
@@ -447,181 +448,326 @@ protected:
             return;
         }
 
-        if (index == kModuleParameters)
+        if (index == kCardinalParameterBypass)
         {
             parameter.initDesignation(kParameterDesignationBypass);
             return;
         }
 
        #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
-        switch (index - kModuleParameters - 1)
+        if (index < kCardinalParameterCountAtWindow)
         {
-        case kWindowParameterShowTooltips:
-            parameter.name = "Show tooltips";
-            parameter.symbol = "tooltips";
-            parameter.hints = kParameterIsAutomatable|kParameterIsInteger|kParameterIsBoolean;
-            parameter.ranges.def = 1.0f;
-            parameter.ranges.min = 0.0f;
-            parameter.ranges.max = 1.0f;
-            break;
-        case kWindowParameterCableOpacity:
-            parameter.name = "Cable opacity";
-            parameter.symbol = "cableOpacity";
-            parameter.unit = "%";
-            parameter.hints = kParameterIsAutomatable;
-            parameter.ranges.def = 50.0f;
-            parameter.ranges.min = 0.0f;
-            parameter.ranges.max = 100.0f;
-            break;
-        case kWindowParameterCableTension:
-            parameter.name = "Cable tension";
-            parameter.symbol = "cableTension";
-            parameter.unit = "%";
-            parameter.hints = kParameterIsAutomatable;
-            parameter.ranges.def = 75.0f;
-            parameter.ranges.min = 0.0f;
-            parameter.ranges.max = 100.0f;
-            break;
-        case kWindowParameterRackBrightness:
-            parameter.name = "Room brightness";
-            parameter.symbol = "rackBrightness";
-            parameter.unit = "%";
-            parameter.hints = kParameterIsAutomatable;
-            parameter.ranges.def = 100.0f;
-            parameter.ranges.min = 0.0f;
-            parameter.ranges.max = 100.0f;
-            break;
-        case kWindowParameterHaloBrightness:
-            parameter.name = "Light Bloom";
-            parameter.symbol = "haloBrightness";
-            parameter.unit = "%";
-            parameter.hints = kParameterIsAutomatable;
-            parameter.ranges.def = 25.0f;
-            parameter.ranges.min = 0.0f;
-            parameter.ranges.max = 100.0f;
-            break;
-        case kWindowParameterKnobMode:
-            parameter.name = "Knob mode";
-            parameter.symbol = "knobMode";
-            parameter.hints = kParameterIsAutomatable|kParameterIsInteger;
-            parameter.ranges.def = 0.0f;
-            parameter.ranges.min = 0.0f;
-            parameter.ranges.max = 2.0f;
-            parameter.enumValues.count = 3;
-            parameter.enumValues.restrictedMode = true;
-            parameter.enumValues.values = new ParameterEnumerationValue[3];
-            parameter.enumValues.values[0].label = "Linear";
-            parameter.enumValues.values[0].value = 0.0f;
-            parameter.enumValues.values[1].label = "Absolute rotary";
-            parameter.enumValues.values[1].value = 1.0f;
-            parameter.enumValues.values[2].label = "Relative rotary";
-            parameter.enumValues.values[2].value = 2.0f;
-            break;
-        case kWindowParameterWheelKnobControl:
-            parameter.name = "Scroll wheel knob control";
-            parameter.symbol = "knobScroll";
-            parameter.hints = kParameterIsAutomatable|kParameterIsInteger|kParameterIsBoolean;
+            switch (index - kCardinalParameterStartWindow)
+            {
+            case kWindowParameterShowTooltips:
+                parameter.name = "Show tooltips";
+                parameter.symbol = "tooltips";
+                parameter.hints = kParameterIsAutomatable|kParameterIsInteger|kParameterIsBoolean;
+                parameter.ranges.def = 1.0f;
+                parameter.ranges.min = 0.0f;
+                parameter.ranges.max = 1.0f;
+                break;
+            case kWindowParameterCableOpacity:
+                parameter.name = "Cable opacity";
+                parameter.symbol = "cableOpacity";
+                parameter.unit = "%";
+                parameter.hints = kParameterIsAutomatable;
+                parameter.ranges.def = 50.0f;
+                parameter.ranges.min = 0.0f;
+                parameter.ranges.max = 100.0f;
+                break;
+            case kWindowParameterCableTension:
+                parameter.name = "Cable tension";
+                parameter.symbol = "cableTension";
+                parameter.unit = "%";
+                parameter.hints = kParameterIsAutomatable;
+                parameter.ranges.def = 75.0f;
+                parameter.ranges.min = 0.0f;
+                parameter.ranges.max = 100.0f;
+                break;
+            case kWindowParameterRackBrightness:
+                parameter.name = "Room brightness";
+                parameter.symbol = "rackBrightness";
+                parameter.unit = "%";
+                parameter.hints = kParameterIsAutomatable;
+                parameter.ranges.def = 100.0f;
+                parameter.ranges.min = 0.0f;
+                parameter.ranges.max = 100.0f;
+                break;
+            case kWindowParameterHaloBrightness:
+                parameter.name = "Light Bloom";
+                parameter.symbol = "haloBrightness";
+                parameter.unit = "%";
+                parameter.hints = kParameterIsAutomatable;
+                parameter.ranges.def = 25.0f;
+                parameter.ranges.min = 0.0f;
+                parameter.ranges.max = 100.0f;
+                break;
+            case kWindowParameterKnobMode:
+                parameter.name = "Knob mode";
+                parameter.symbol = "knobMode";
+                parameter.hints = kParameterIsAutomatable|kParameterIsInteger;
+                parameter.ranges.def = 0.0f;
+                parameter.ranges.min = 0.0f;
+                parameter.ranges.max = 2.0f;
+                parameter.enumValues.count = 3;
+                parameter.enumValues.restrictedMode = true;
+                parameter.enumValues.values = new ParameterEnumerationValue[3];
+                parameter.enumValues.values[0].label = "Linear";
+                parameter.enumValues.values[0].value = 0.0f;
+                parameter.enumValues.values[1].label = "Absolute rotary";
+                parameter.enumValues.values[1].value = 1.0f;
+                parameter.enumValues.values[2].label = "Relative rotary";
+                parameter.enumValues.values[2].value = 2.0f;
+                break;
+            case kWindowParameterWheelKnobControl:
+                parameter.name = "Scroll wheel knob control";
+                parameter.symbol = "knobScroll";
+                parameter.hints = kParameterIsAutomatable|kParameterIsInteger|kParameterIsBoolean;
+                parameter.ranges.def = 0.0f;
+                parameter.ranges.min = 0.0f;
+                parameter.ranges.max = 1.0f;
+                break;
+            case kWindowParameterWheelSensitivity:
+                parameter.name = "Scroll wheel knob sensitivity";
+                parameter.symbol = "knobScrollSensitivity";
+                parameter.hints = kParameterIsAutomatable|kParameterIsLogarithmic;
+                parameter.ranges.def = 1.0f;
+                parameter.ranges.min = 0.1f;
+                parameter.ranges.max = 10.0f;
+                break;
+            case kWindowParameterLockModulePositions:
+                parameter.name = "Lock module positions";
+                parameter.symbol = "lockModules";
+                parameter.hints = kParameterIsAutomatable|kParameterIsInteger|kParameterIsBoolean;
+                parameter.ranges.def = 0.0f;
+                parameter.ranges.min = 0.0f;
+                parameter.ranges.max = 1.0f;
+                break;
+            case kWindowParameterUpdateRateLimit:
+                parameter.name = "Update rate limit";
+                parameter.symbol = "rateLimit";
+                parameter.hints = kParameterIsAutomatable|kParameterIsInteger;
+                parameter.ranges.def = 0.0f;
+                parameter.ranges.min = 0.0f;
+                parameter.ranges.max = 2.0f;
+                parameter.enumValues.count = 3;
+                parameter.enumValues.restrictedMode = true;
+                parameter.enumValues.values = new ParameterEnumerationValue[3];
+                parameter.enumValues.values[0].label = "None";
+                parameter.enumValues.values[0].value = 0.0f;
+                parameter.enumValues.values[1].label = "2x";
+                parameter.enumValues.values[1].value = 1.0f;
+                parameter.enumValues.values[2].label = "4x";
+                parameter.enumValues.values[2].value = 2.0f;
+                break;
+            case kWindowParameterBrowserSort:
+                parameter.name = "Browser sort";
+                parameter.symbol = "browserSort";
+                parameter.hints = kParameterIsAutomatable|kParameterIsInteger;
+                parameter.ranges.def = 3.0f;
+                parameter.ranges.min = 0.0f;
+                parameter.ranges.max = 5.0f;
+                parameter.enumValues.count = 6;
+                parameter.enumValues.restrictedMode = true;
+                parameter.enumValues.values = new ParameterEnumerationValue[6];
+                parameter.enumValues.values[0].label = "Updated";
+                parameter.enumValues.values[0].value = 0.0f;
+                parameter.enumValues.values[1].label = "Last used";
+                parameter.enumValues.values[1].value = 1.0f;
+                parameter.enumValues.values[2].label = "Most used";
+                parameter.enumValues.values[2].value = 2.0f;
+                parameter.enumValues.values[3].label = "Brand";
+                parameter.enumValues.values[3].value = 3.0f;
+                parameter.enumValues.values[4].label = "Name";
+                parameter.enumValues.values[4].value = 4.0f;
+                parameter.enumValues.values[5].label = "Random";
+                parameter.enumValues.values[5].value = 5.0f;
+                break;
+            case kWindowParameterBrowserZoom:
+                parameter.name = "Browser zoom";
+                parameter.symbol = "browserZoom";
+                parameter.hints = kParameterIsAutomatable;
+                parameter.unit = "%";
+                parameter.ranges.def = 50.0f;
+                parameter.ranges.min = 25.0f;
+                parameter.ranges.max = 200.0f;
+                parameter.enumValues.count = 7;
+                parameter.enumValues.restrictedMode = true;
+                parameter.enumValues.values = new ParameterEnumerationValue[7];
+                parameter.enumValues.values[0].label = "25";
+                parameter.enumValues.values[0].value = 25.0f;
+                parameter.enumValues.values[1].label = "35";
+                parameter.enumValues.values[1].value = 35.0f;
+                parameter.enumValues.values[2].label = "50";
+                parameter.enumValues.values[2].value = 50.0f;
+                parameter.enumValues.values[3].label = "71";
+                parameter.enumValues.values[3].value = 71.0f;
+                parameter.enumValues.values[4].label = "100";
+                parameter.enumValues.values[4].value = 100.0f;
+                parameter.enumValues.values[5].label = "141";
+                parameter.enumValues.values[5].value = 141.0f;
+                parameter.enumValues.values[6].label = "200";
+                parameter.enumValues.values[6].value = 200.0f;
+                break;
+            case kWindowParameterInvertZoom:
+                parameter.name = "Invert zoom";
+                parameter.symbol = "invertZoom";
+                parameter.hints = kParameterIsAutomatable|kParameterIsInteger|kParameterIsBoolean;
+                parameter.ranges.def = 0.0f;
+                parameter.ranges.min = 0.0f;
+                parameter.ranges.max = 1.0f;
+                break;
+            case kWindowParameterSqueezeModulePositions:
+                parameter.name = "Auto-squeeze module positions";
+                parameter.symbol = "squeezeModules";
+                parameter.hints = kParameterIsAutomatable|kParameterIsInteger|kParameterIsBoolean;
+                parameter.ranges.def = 1.0f;
+                parameter.ranges.min = 0.0f;
+                parameter.ranges.max = 1.0f;
+                break;
+            }
+        }
+       #endif
+
+       #if CARDINAL_VARIANT_MINI
+        switch (index)
+        {
+        case kCardinalParameterMiniAudioIn1:
+            parameter.name = "Report Audio Input 1";
+            parameter.symbol = "r_audio_in_1";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
             parameter.ranges.def = 0.0f;
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 1.0f;
             break;
-        case kWindowParameterWheelSensitivity:
-            parameter.name = "Scroll wheel knob sensitivity";
-            parameter.symbol = "knobScrollSensitivity";
-            parameter.hints = kParameterIsAutomatable|kParameterIsLogarithmic;
-            parameter.ranges.def = 1.0f;
-            parameter.ranges.min = 0.1f;
+        case kCardinalParameterMiniAudioIn2:
+            parameter.name = "Report Audio Input 2";
+            parameter.symbol = "r_audio_in_2";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
+            parameter.ranges.def = 0.0f;
+            parameter.ranges.min = 0.0f;
+            parameter.ranges.max = 1.0f;
+            break;
+        case kCardinalParameterMiniCVIn1:
+            parameter.name = "Report CV Input 1";
+            parameter.symbol = "r_cv_in_1";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
+            parameter.ranges.def = -10.0f;
+            parameter.ranges.min = 0.0f;
             parameter.ranges.max = 10.0f;
             break;
-        case kWindowParameterLockModulePositions:
-            parameter.name = "Lock module positions";
-            parameter.symbol = "lockModules";
-            parameter.hints = kParameterIsAutomatable|kParameterIsInteger|kParameterIsBoolean;
-            parameter.ranges.def = 0.0f;
+        case kCardinalParameterMiniCVIn2:
+            parameter.name = "Report CV Input 2";
+            parameter.symbol = "r_cv_in_2";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
+            parameter.ranges.def = -10.0f;
             parameter.ranges.min = 0.0f;
-            parameter.ranges.max = 1.0f;
+            parameter.ranges.max = 10.0f;
             break;
-        case kWindowParameterUpdateRateLimit:
-            parameter.name = "Update rate limit";
-            parameter.symbol = "rateLimit";
-            parameter.hints = kParameterIsAutomatable|kParameterIsInteger;
-            parameter.ranges.def = 0.0f;
+        case kCardinalParameterMiniCVIn3:
+            parameter.name = "Report CV Input 3";
+            parameter.symbol = "r_cv_in_3";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
+            parameter.ranges.def = -10.0f;
             parameter.ranges.min = 0.0f;
-            parameter.ranges.max = 2.0f;
-            parameter.enumValues.count = 3;
-            parameter.enumValues.restrictedMode = true;
-            parameter.enumValues.values = new ParameterEnumerationValue[3];
-            parameter.enumValues.values[0].label = "None";
-            parameter.enumValues.values[0].value = 0.0f;
-            parameter.enumValues.values[1].label = "2x";
-            parameter.enumValues.values[1].value = 1.0f;
-            parameter.enumValues.values[2].label = "4x";
-            parameter.enumValues.values[2].value = 2.0f;
+            parameter.ranges.max = 10.0f;
             break;
-        case kWindowParameterBrowserSort:
-            parameter.name = "Browser sort";
-            parameter.symbol = "browserSort";
-            parameter.hints = kParameterIsAutomatable|kParameterIsInteger;
-            parameter.ranges.def = 3.0f;
+        case kCardinalParameterMiniCVIn4:
+            parameter.name = "Report CV Input 4";
+            parameter.symbol = "r_cv_in_4";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
+            parameter.ranges.def = -10.0f;
             parameter.ranges.min = 0.0f;
-            parameter.ranges.max = 5.0f;
-            parameter.enumValues.count = 6;
-            parameter.enumValues.restrictedMode = true;
-            parameter.enumValues.values = new ParameterEnumerationValue[6];
-            parameter.enumValues.values[0].label = "Updated";
-            parameter.enumValues.values[0].value = 0.0f;
-            parameter.enumValues.values[1].label = "Last used";
-            parameter.enumValues.values[1].value = 1.0f;
-            parameter.enumValues.values[2].label = "Most used";
-            parameter.enumValues.values[2].value = 2.0f;
-            parameter.enumValues.values[3].label = "Brand";
-            parameter.enumValues.values[3].value = 3.0f;
-            parameter.enumValues.values[4].label = "Name";
-            parameter.enumValues.values[4].value = 4.0f;
-            parameter.enumValues.values[5].label = "Random";
-            parameter.enumValues.values[5].value = 5.0f;
+            parameter.ranges.max = 10.0f;
             break;
-        case kWindowParameterBrowserZoom:
-            parameter.name = "Browser zoom";
-            parameter.symbol = "browserZoom";
-            parameter.hints = kParameterIsAutomatable;
-            parameter.unit = "%";
-            parameter.ranges.def = 50.0f;
-            parameter.ranges.min = 25.0f;
-            parameter.ranges.max = 200.0f;
-            parameter.enumValues.count = 7;
-            parameter.enumValues.restrictedMode = true;
-            parameter.enumValues.values = new ParameterEnumerationValue[7];
-            parameter.enumValues.values[0].label = "25";
-            parameter.enumValues.values[0].value = 25.0f;
-            parameter.enumValues.values[1].label = "35";
-            parameter.enumValues.values[1].value = 35.0f;
-            parameter.enumValues.values[2].label = "50";
-            parameter.enumValues.values[2].value = 50.0f;
-            parameter.enumValues.values[3].label = "71";
-            parameter.enumValues.values[3].value = 71.0f;
-            parameter.enumValues.values[4].label = "100";
-            parameter.enumValues.values[4].value = 100.0f;
-            parameter.enumValues.values[5].label = "141";
-            parameter.enumValues.values[5].value = 141.0f;
-            parameter.enumValues.values[6].label = "200";
-            parameter.enumValues.values[6].value = 200.0f;
-            break;
-        case kWindowParameterInvertZoom:
-            parameter.name = "Invert zoom";
-            parameter.symbol = "invertZoom";
-            parameter.hints = kParameterIsAutomatable|kParameterIsInteger|kParameterIsBoolean;
-            parameter.ranges.def = 0.0f;
+        case kCardinalParameterMiniCVIn5:
+            parameter.name = "Report CV Input 5";
+            parameter.symbol = "r_cv_in_5";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
+            parameter.ranges.def = -10.0f;
             parameter.ranges.min = 0.0f;
-            parameter.ranges.max = 1.0f;
+            parameter.ranges.max = 10.0f;
             break;
-        case kWindowParameterSqueezeModulePositions:
-            parameter.name = "Auto-squeeze module positions";
-            parameter.symbol = "squeezeModules";
-            parameter.hints = kParameterIsAutomatable|kParameterIsInteger|kParameterIsBoolean;
+        case kCardinalParameterMiniTimeFlags:
+            parameter.name = "Report Time Flags";
+            parameter.symbol = "r_time_flags";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
+            parameter.ranges.def = 0x0;
+            parameter.ranges.min = 0x0;
+            parameter.ranges.max = 0x7;
+            break;
+        case kCardinalParameterMiniTimeBar:
+            parameter.name = "Report Time Bar";
+            parameter.symbol = "r_time_bar";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
             parameter.ranges.def = 1.0f;
+            parameter.ranges.min = 1.0f;
+            parameter.ranges.max = FLT_MAX;
+            break;
+        case kCardinalParameterMiniTimeBeat:
+            parameter.name = "Report Time Beat";
+            parameter.symbol = "r_time_beat";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
+            parameter.ranges.def = 1.0f;
+            parameter.ranges.min = 1.0f;
+            parameter.ranges.max = 128.0f;
+            break;
+        case kCardinalParameterMiniTimeBeatsPerBar:
+            parameter.name = "Report Time Beats Per Bar";
+            parameter.symbol = "r_time_beatsPerBar";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
+            parameter.ranges.def = 4.0f;
             parameter.ranges.min = 0.0f;
-            parameter.ranges.max = 1.0f;
+            parameter.ranges.max = 128.0f;
+            break;
+        case kCardinalParameterMiniTimeBeatType:
+            parameter.name = "Report Time Beat Type";
+            parameter.symbol = "r_time_beatType";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
+            parameter.ranges.def = 4.0f;
+            parameter.ranges.min = 0.0f;
+            parameter.ranges.max = 128.0f;
+            break;
+        case kCardinalParameterMiniTimeFrame:
+            parameter.name = "Report Time Frame";
+            parameter.symbol = "r_time_frame";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
+            parameter.ranges.def = 0.0f;
+            parameter.ranges.min = 0.0f;
+            parameter.ranges.max = FLT_MAX;
+            break;
+        case kCardinalParameterMiniTimeBarStartTick:
+            parameter.name = "Report Time BarStartTick";
+            parameter.symbol = "r_time_barStartTick";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
+            parameter.ranges.def = 0.0f;
+            parameter.ranges.min = 0.0f;
+            parameter.ranges.max = FLT_MAX;
+            break;
+        case kCardinalParameterMiniTimeBeatsPerMinute:
+            parameter.name = "Report Time Beats Per Minute";
+            parameter.symbol = "r_time_bpm";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
+            parameter.ranges.def = 20.0f;
+            parameter.ranges.min = 120.0f;
+            parameter.ranges.max = 999.0f;
+            break;
+        case kCardinalParameterMiniTimeTick:
+            parameter.name = "Report Time Tick";
+            parameter.symbol = "r_time_tick";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
+            parameter.ranges.def = 0.0f;
+            parameter.ranges.min = 0.0f;
+            parameter.ranges.max = 8192.0f;
+            break;
+        case kCardinalParameterMiniTimeTicksPerBeat:
+            parameter.name = "Report Time Ticks Per Beat";
+            parameter.symbol = "r_time_ticksPerBeat";
+            parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
+            parameter.ranges.def = 0.0f;
+            parameter.ranges.min = 0.0f;
+            parameter.ranges.max = 8192.0f;
             break;
         }
        #endif
@@ -708,19 +854,21 @@ protected:
     float getParameterValue(uint32_t index) const override
     {
         // host mapped parameters
-        if (index < kModuleParameters)
+        if (index < kCardinalParameterCountAtModules)
             return context->parameters[index];
 
         // bypass
-        if (index == kModuleParameters)
+        if (index == kCardinalParameterBypass)
             return context->bypassed ? 1.0f : 0.0f;
 
        #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
-        // window related parameters
-        index -= kModuleParameters + 1;
+        if (index < kCardinalParameterCountAtWindow)
+            return fWindowParameters[index - kCardinalParameterStartWindow];
+       #endif
 
-        if (index < kWindowParameterCount)
-            return fWindowParameters[index];
+       #if CARDINAL_VARIANT_MINI
+        if (index < kCardinalParameterCountAtMini)
+            return fMiniReportValues[index - kCardinalParameterStartMini];
        #endif
 
         return 0.0f;
@@ -729,26 +877,23 @@ protected:
     void setParameterValue(uint32_t index, float value) override
     {
         // host mapped parameters
-        if (index < kModuleParameters)
+        if (index < kCardinalParameterCountAtModules)
         {
             context->parameters[index] = value;
             return;
         }
 
         // bypass
-        if (index == kModuleParameters)
+        if (index == kCardinalParameterBypass)
         {
             context->bypassed = value > 0.5f;
             return;
         }
 
        #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
-        // window related parameters
-        index -= kModuleParameters + 1;
-
-        if (index < kWindowParameterCount)
+        if (index < kCardinalParameterCountAtWindow)
         {
-            fWindowParameters[index] = value;
+            fWindowParameters[index - kCardinalParameterStartWindow] = value;
             return;
         }
        #endif
@@ -1044,10 +1189,28 @@ protected:
                 context->ticksPerClock = timePos.bbt.ticksPerBeat / timePos.bbt.beatType;
                 context->ticksPerFrame = 1.0 / samplesPerTick;
                 context->tickClock = std::fmod(timePos.bbt.tick, context->ticksPerClock);
+               #if CARDINAL_VARIANT_MINI
+                fMiniReportValues[kCardinalParameterMiniTimeBar - kCardinalParameterStartMini] = timePos.bbt.bar;
+                fMiniReportValues[kCardinalParameterMiniTimeBeat - kCardinalParameterStartMini] = timePos.bbt.beat;
+                fMiniReportValues[kCardinalParameterMiniTimeBeatsPerBar - kCardinalParameterStartMini] = timePos.bbt.beatsPerBar;
+                fMiniReportValues[kCardinalParameterMiniTimeBeatType - kCardinalParameterStartMini] = timePos.bbt.beatType;
+                fMiniReportValues[kCardinalParameterMiniTimeBarStartTick - kCardinalParameterStartMini] = timePos.bbt.barStartTick;
+                fMiniReportValues[kCardinalParameterMiniTimeBeatsPerMinute - kCardinalParameterStartMini] = timePos.bbt.beatsPerMinute;
+                fMiniReportValues[kCardinalParameterMiniTimeTick - kCardinalParameterStartMini] = timePos.bbt.tick;
+                fMiniReportValues[kCardinalParameterMiniTimeTicksPerBeat - kCardinalParameterStartMini] = timePos.bbt.ticksPerBeat;
+               #endif
             }
 
             context->reset = reset;
             fNextExpectedFrame = timePos.playing ? timePos.frame + frames : 0;
+
+           #if CARDINAL_VARIANT_MINI
+            const int flags = (timePos.playing ? 0x1 : 0x0)
+                            | (timePos.bbt.valid ? 0x2 : 0x0)
+                            | (reset ? 0x4 : 0x0);
+            fMiniReportValues[kCardinalParameterMiniTimeFlags - kCardinalParameterStartMini] = flags;
+            fMiniReportValues[kCardinalParameterMiniTimeFrame - kCardinalParameterStartMini] = timePos.frame / getSampleRate();
+           #endif
         }
 
         // separate buffers, use them
@@ -1062,8 +1225,8 @@ protected:
            #if DISTRHO_PLUGIN_NUM_INPUTS != 0
             for (int i=0; i<DISTRHO_PLUGIN_NUM_INPUTS; ++i)
             {
-               #if CARDINAL_VARIANT_MAIN
-                // can be null on main variant
+               #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_MINI
+                // can be null on main and mini variants
                 if (inputs[i] != nullptr)
                #endif
                     std::memcpy(fAudioBufferCopy[i], inputs[i], sizeof(float)*frames);
@@ -1077,13 +1240,18 @@ protected:
 
         for (int i=0; i<DISTRHO_PLUGIN_NUM_OUTPUTS; ++i)
         {
-           #if CARDINAL_VARIANT_MAIN
-            // can be null on main variant
+           #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_MINI
+            // can be null on main and mini variants
             if (outputs[i] != nullptr)
            #endif
                 std::memset(outputs[i], 0, sizeof(float)*frames);
         }
 
+        #if CARDINAL_VARIANT_MINI
+        for (int i=0; i<DISTRHO_PLUGIN_NUM_INPUTS; ++i)
+            fMiniReportValues[i] = context->dataIns[i][0];
+        #endif
+
         if (bypassed)
         {
             if (fWasBypassed != bypassed)
diff --git a/src/CardinalUI.cpp b/src/CardinalUI.cpp
index 6852146..7bacf2b 100644
--- a/src/CardinalUI.cpp
+++ b/src/CardinalUI.cpp
@@ -704,7 +704,7 @@ public:
             return;
         }
 
-        setParameterValue(kModuleParameters + param + 1, value * mult);
+        setParameterValue(kCardinalParameterStartWindow + param, value * mult);
     }
 
 protected:
@@ -718,7 +718,7 @@ protected:
     void parameterChanged(const uint32_t index, const float value) override
     {
         // host mapped parameters
-        if (index < kModuleParameters)
+        if (index < kCardinalParameterCountAtModules)
         {
            #if CARDINAL_VARIANT_MINI
             context->parameters[index] = value;
@@ -727,7 +727,7 @@ protected:
         }
 
         // bypass
-        if (index == kModuleParameters)
+        if (index == kCardinalParameterBypass)
         {
            #if CARDINAL_VARIANT_MINI
             context->bypassed = value > 0.5f;
@@ -735,89 +735,147 @@ protected:
             return;
         }
 
-        switch (index - kModuleParameters - 1)
+        if (index < kCardinalParameterCountAtWindow)
         {
-        case kWindowParameterShowTooltips:
-            windowParameters.tooltips = value > 0.5f;
-            break;
-        case kWindowParameterCableOpacity:
-            windowParameters.cableOpacity = value / 100.0f;
-            break;
-        case kWindowParameterCableTension:
-            windowParameters.cableTension = value / 100.0f;
-            break;
-        case kWindowParameterRackBrightness:
-            windowParameters.rackBrightness = value / 100.0f;
-            break;
-        case kWindowParameterHaloBrightness:
-            windowParameters.haloBrightness = value / 100.0f;
-            break;
-        case kWindowParameterKnobMode:
-            switch (static_cast<int>(value + 0.5f))
+            switch (index - kCardinalParameterStartWindow)
             {
-            case 0:
-                windowParameters.knobMode = rack::settings::KNOB_MODE_LINEAR;
+            case kWindowParameterShowTooltips:
+                windowParameters.tooltips = value > 0.5f;
                 break;
-            case 1:
-                windowParameters.knobMode = rack::settings::KNOB_MODE_ROTARY_ABSOLUTE;
+            case kWindowParameterCableOpacity:
+                windowParameters.cableOpacity = value / 100.0f;
                 break;
-            case 2:
-                windowParameters.knobMode = rack::settings::KNOB_MODE_ROTARY_RELATIVE;
+            case kWindowParameterCableTension:
+                windowParameters.cableTension = value / 100.0f;
                 break;
-            }
-            break;
-        case kWindowParameterWheelKnobControl:
-            windowParameters.knobScroll = value > 0.5f;
-            break;
-        case kWindowParameterWheelSensitivity:
-            windowParameters.knobScrollSensitivity = value / 1000.0f;
-            break;
-        case kWindowParameterLockModulePositions:
-            windowParameters.lockModules = value > 0.5f;
-            break;
-        case kWindowParameterUpdateRateLimit:
-            windowParameters.rateLimit = static_cast<int>(value + 0.5f);
-            rateLimitStep = 0;
-            break;
-        case kWindowParameterBrowserSort:
-            windowParameters.browserSort = static_cast<int>(value + 0.5f);
-            break;
-        case kWindowParameterBrowserZoom:
-            // round up to nearest valid value
-            {
-                float rvalue = value - 1.0f;
+            case kWindowParameterRackBrightness:
+                windowParameters.rackBrightness = value / 100.0f;
+                break;
+            case kWindowParameterHaloBrightness:
+                windowParameters.haloBrightness = value / 100.0f;
+                break;
+            case kWindowParameterKnobMode:
+                switch (static_cast<int>(value + 0.5f))
+                {
+                case 0:
+                    windowParameters.knobMode = rack::settings::KNOB_MODE_LINEAR;
+                    break;
+                case 1:
+                    windowParameters.knobMode = rack::settings::KNOB_MODE_ROTARY_ABSOLUTE;
+                    break;
+                case 2:
+                    windowParameters.knobMode = rack::settings::KNOB_MODE_ROTARY_RELATIVE;
+                    break;
+                }
+                break;
+            case kWindowParameterWheelKnobControl:
+                windowParameters.knobScroll = value > 0.5f;
+                break;
+            case kWindowParameterWheelSensitivity:
+                windowParameters.knobScrollSensitivity = value / 1000.0f;
+                break;
+            case kWindowParameterLockModulePositions:
+                windowParameters.lockModules = value > 0.5f;
+                break;
+            case kWindowParameterUpdateRateLimit:
+                windowParameters.rateLimit = static_cast<int>(value + 0.5f);
+                rateLimitStep = 0;
+                break;
+            case kWindowParameterBrowserSort:
+                windowParameters.browserSort = static_cast<int>(value + 0.5f);
+                break;
+            case kWindowParameterBrowserZoom:
+                // round up to nearest valid value
+                {
+                    float rvalue = value - 1.0f;
 
-                if (rvalue <= 25.0f)
-                    rvalue = -2.0f;
-                else if (rvalue <= 35.0f)
-                    rvalue = -1.5f;
-                else if (rvalue <= 50.0f)
-                    rvalue = -1.0f;
-                else if (rvalue <= 71.0f)
-                    rvalue = -0.5f;
-                else if (rvalue <= 100.0f)
-                    rvalue = 0.0f;
-                else if (rvalue <= 141.0f)
-                    rvalue = 0.5f;
-                else if (rvalue <= 200.0f)
-                    rvalue = 1.0f;
-                else
-                    rvalue = 0.0f;
+                    if (rvalue <= 25.0f)
+                        rvalue = -2.0f;
+                    else if (rvalue <= 35.0f)
+                        rvalue = -1.5f;
+                    else if (rvalue <= 50.0f)
+                        rvalue = -1.0f;
+                    else if (rvalue <= 71.0f)
+                        rvalue = -0.5f;
+                    else if (rvalue <= 100.0f)
+                        rvalue = 0.0f;
+                    else if (rvalue <= 141.0f)
+                        rvalue = 0.5f;
+                    else if (rvalue <= 200.0f)
+                        rvalue = 1.0f;
+                    else
+                        rvalue = 0.0f;
 
-                windowParameters.browserZoom = rvalue;
+                    windowParameters.browserZoom = rvalue;
+                }
+                break;
+            case kWindowParameterInvertZoom:
+                windowParameters.invertZoom = value > 0.5f;
+                break;
+            case kWindowParameterSqueezeModulePositions:
+                windowParameters.squeezeModules = value > 0.5f;
+                break;
+            default:
+                return;
             }
-            break;
-        case kWindowParameterInvertZoom:
-            windowParameters.invertZoom = value > 0.5f;
-            break;
-        case kWindowParameterSqueezeModulePositions:
-            windowParameters.squeezeModules = value > 0.5f;
-            break;
-        default:
+
+            WindowParametersSetValues(context->window, windowParameters);
             return;
         }
 
-        WindowParametersSetValues(context->window, windowParameters);
+       #if CARDINAL_VARIANT_MINI
+        if (index < kCardinalParameterCountAtMiniBuffers)
+        {
+            float* const buffer = *const_cast<float**>(&context->dataIns[index - kCardinalParameterStartMiniBuffers]);
+            buffer[0] = value;
+            return;
+        }
+
+        switch (index)
+        {
+        case kCardinalParameterMiniTimeFlags: {
+            const int32_t flags = static_cast<int32_t>(value + 0.5f);
+            context->playing = flags & 0x1;
+            context->bbtValid = flags & 0x2;
+            context->reset = flags & 0x4;
+            return;
+        }
+        case kCardinalParameterMiniTimeBar:
+            context->bar = static_cast<int32_t>(value + 0.5f);
+            return;
+        case kCardinalParameterMiniTimeBeat:
+            context->beat = static_cast<int32_t>(value + 0.5f);
+            return;
+        case kCardinalParameterMiniTimeBeatsPerBar:
+            context->beatsPerBar = static_cast<int32_t>(value + 0.5f);
+            return;
+        case kCardinalParameterMiniTimeBeatType:
+            context->beatType = static_cast<int32_t>(value + 0.5f);
+            context->ticksPerClock = context->ticksPerBeat / context->beatType;
+            context->tickClock = std::fmod(context->tick, context->ticksPerClock);
+            return;
+        case kCardinalParameterMiniTimeFrame:
+            context->frame = static_cast<uint64_t>(value * context->sampleRate + 0.5f);
+            return;
+        case kCardinalParameterMiniTimeBarStartTick:
+            context->barStartTick = value;
+            return;
+        case kCardinalParameterMiniTimeBeatsPerMinute:
+            context->beatsPerMinute = value;
+            context->ticksPerFrame = 1.0 / (60.0 * context->sampleRate / context->beatsPerMinute / context->ticksPerBeat);
+            return;
+        case kCardinalParameterMiniTimeTick:
+            context->tick = value;
+            context->tickClock = std::fmod(context->tick, context->ticksPerClock);
+            return;
+        case kCardinalParameterMiniTimeTicksPerBeat:
+            context->ticksPerBeat = value;
+            context->ticksPerClock = context->ticksPerBeat / context->beatType;
+            context->ticksPerFrame = 1.0 / (60.0 * context->sampleRate / context->beatsPerMinute / context->ticksPerBeat);
+            context->tickClock = std::fmod(context->tick, context->ticksPerClock);
+            return;
+        }
+       #endif
     }
 
     void stateChanged(const char* const key, const char* const value) override
diff --git a/src/PluginContext.hpp b/src/PluginContext.hpp
index 1217c69..6a4db83 100644
--- a/src/PluginContext.hpp
+++ b/src/PluginContext.hpp
@@ -28,6 +28,12 @@
 #include "CardinalRemote.hpp"
 #include "DistrhoPlugin.hpp"
 
+#if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
+# include "WindowParameters.hpp"
+#else
+# define kWindowParameterCount 0
+#endif
+
 #ifndef HEADLESS
 # include "DistrhoUI.hpp"
 #else
@@ -43,7 +49,7 @@ START_NAMESPACE_DISTRHO
 
 // -----------------------------------------------------------------------------------------------------------
 
-static constexpr const uint kModuleParameters = 24;
+static constexpr const uint kModuleParameterCount = 24;
 
 enum CardinalVariant {
     kCardinalVariantMain,
@@ -53,6 +59,74 @@ enum CardinalVariant {
     kCardinalVariantSynth,
 };
 
+enum CardinalParameters {
+    kCardinalParameterCountAtModules = kModuleParameterCount,
+    kCardinalParameterBypass = kCardinalParameterCountAtModules,
+  #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
+    kCardinalParameterStartWindow,
+    kCardinalParameterCountAtWindow = kCardinalParameterStartWindow + kWindowParameterCount,
+   #if CARDINAL_VARIANT_MINI
+    kCardinalParameterStartMini = kCardinalParameterCountAtWindow,
+    kCardinalParameterStartMiniBuffers = kCardinalParameterStartMini,
+    kCardinalParameterMiniAudioIn1 = kCardinalParameterStartMiniBuffers,
+    kCardinalParameterMiniAudioIn2,
+    kCardinalParameterMiniCVIn1,
+    kCardinalParameterMiniCVIn2,
+    kCardinalParameterMiniCVIn3,
+    kCardinalParameterMiniCVIn4,
+    kCardinalParameterMiniCVIn5,
+    kCardinalParameterCountAtMiniBuffers,
+    kCardinalParameterStartMiniTime = kCardinalParameterCountAtMiniBuffers,
+    kCardinalParameterMiniTimeFlags = kCardinalParameterStartMiniTime,
+    kCardinalParameterMiniTimeBar,
+    kCardinalParameterMiniTimeBeat,
+    kCardinalParameterMiniTimeBeatsPerBar,
+    kCardinalParameterMiniTimeBeatType,
+    kCardinalParameterMiniTimeFrame,
+    kCardinalParameterMiniTimeBarStartTick,
+    kCardinalParameterMiniTimeBeatsPerMinute,
+    kCardinalParameterMiniTimeTick,
+    kCardinalParameterMiniTimeTicksPerBeat,
+    kCardinalParameterCountAtMiniTime,
+    kCardinalParameterCountAtMini = kCardinalParameterCountAtMiniTime,
+    kCardinalParameterCount = kCardinalParameterCountAtMini
+   #else
+    kCardinalParameterCount = kCardinalParameterCountAtWindow
+   #endif
+  #else
+    kCardinalParameterCount
+  #endif
+};
+
+enum CardinalStates {
+    kCardinalStatePatch,
+    kCardinalStateScreenshot,
+    kCardinalStateComment,
+   #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
+    kCardinalStateModuleInfos,
+    kCardinalStateWindowSize,
+   #endif
+   #if CARDINAL_VARIANT_MINI
+    kCardinalStateParamChange,
+   #endif
+    kCardinalStateCount
+};
+
+static_assert(kCardinalParameterBypass == kModuleParameterCount, "valid parameter indexes");
+#if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
+static_assert(kCardinalParameterStartWindow == kModuleParameterCount + 1, "valid parameter indexes");
+static_assert(kCardinalParameterStartWindow == kCardinalParameterBypass + 1, "valid parameter indexes");
+static_assert(kCardinalParameterCountAtWindow == kModuleParameterCount + kWindowParameterCount + 1, "valid parameter indexes");
+#endif
+#if CARDINAL_VARIANT_MINI
+static_assert(0 == kCardinalParameterStartMini - kCardinalParameterMiniAudioIn1, "valid parameter indexes");
+static_assert(kCardinalParameterStartMini == kCardinalParameterCountAtWindow, "valid parameter indexes");
+static_assert(kCardinalParameterStartMini == kCardinalParameterBypass + kWindowParameterCount + 1, "valid parameter indexes");
+static_assert(kCardinalParameterStartMini == kModuleParameterCount + kWindowParameterCount + 1, "valid parameter indexes");
+static_assert(kCardinalParameterCountAtWindow == kModuleParameterCount + kWindowParameterCount + 1, "valid parameter indexes");
+static_assert(DISTRHO_PLUGIN_NUM_INPUTS == kCardinalParameterCountAtMiniBuffers - kCardinalParameterStartMiniBuffers, "valid parameter indexes");
+#endif
+
 class UI;
 
 // -----------------------------------------------------------------------------------------------------------
@@ -60,7 +134,7 @@ class UI;
 struct CardinalPluginContext : rack::Context {
     uint32_t bufferSize, processCounter;
     double sampleRate;
-    float parameters[kModuleParameters];
+    float parameters[kModuleParameterCount];
     CardinalVariant variant;
     bool bypassed, playing, reset, bbtValid;
     int32_t bar, beat, beatsPerBar, beatType;