diff --git a/firmware/keira/src/apps/demos/combo.cpp b/firmware/keira/src/apps/demos/combo.cpp
new file mode 100644
index 00000000..c25bc817
--- /dev/null
+++ b/firmware/keira/src/apps/demos/combo.cpp
@@ -0,0 +1,207 @@
+#include "combo.h"
+#include "utils/combo/core/aggregator.h"
+#include "utils/combo/one_button.h"
+#include "utils/combo/one_hold_down_button.h"
+#include "utils/combo/sequence_buttons.h"
+#include "utils/combo/concurrent_buttons.h"
+
+#define SECONDS_FOR_EXIT 3
+
+using lilka::Alignment;
+using lilka::Button;
+
+uint8_t leftSecondsForExit = SECONDS_FOR_EXIT;
+bool exitApp = false;
+uint8_t currentScene = 0;
+
+void exit_process_handler(const Button button, const ButtonStage stage, uint16_t leftTimeToComplete) {
+    leftSecondsForExit = leftTimeToComplete / 1000;
+}
+
+void exit_reset_handler() {
+    leftSecondsForExit = SECONDS_FOR_EXIT;
+}
+
+void exit_completed_handler() {
+    exitApp = true;
+}
+
+void completed_handler() {
+    currentScene++;
+}
+
+ComboApp::ComboApp() : App("Combo") {
+    leftSecondsForExit = SECONDS_FOR_EXIT;
+    exitApp = false;
+    currentScene = 0;
+}
+
+void ComboApp::run() {
+    ComboAggregator comboAggregator;
+    lilka::Canvas buffer(canvas->width(), canvas->height());
+
+    ComboOneHoldDownButton comboExit(Button::SELECT, SECONDS_FOR_EXIT * 1000);
+    comboExit.setAutoReset(false);
+    comboExit.setCompletedEventHandler(exit_completed_handler);
+    comboExit.setResetEventHandler(exit_reset_handler);
+    comboExit.setProgressEventHandler(exit_process_handler);
+    comboAggregator.add(&comboExit);
+
+    ComboOneButton comboContinue(Button::START);
+    comboContinue.setAutoStart(false);
+    comboContinue.setAutoReset(false);
+    comboContinue.setCompletedEventHandler(completed_handler);
+    comboAggregator.add(&comboContinue);
+
+    ComboOneButton comboScene1PressA(Button::A);
+    comboScene1PressA.setAutoStart(false);
+    comboScene1PressA.setAutoReset(false);
+    comboScene1PressA.setCompletedEventHandler(completed_handler);
+    comboAggregator.add(&comboScene1PressA);
+
+    ComboOneHoldDownButton comboScene2HoldAny(Button::ANY, 1000);
+    comboScene2HoldAny.setAutoStart(false);
+    comboScene2HoldAny.setAutoReset(false);
+    comboScene2HoldAny.setCompletedEventHandler(completed_handler);
+    comboAggregator.add(&comboScene2HoldAny);
+
+    ComboConcurrentButtons comboScene3UpB({Button::UP, Button::B});
+    comboScene3UpB.setAutoStart(false);
+    comboScene3UpB.setAutoReset(false);
+    comboScene3UpB.setCompletedEventHandler(completed_handler);
+    comboAggregator.add(&comboScene3UpB);
+
+    ComboButtonSequence comboSequenceLast(
+        {Button::DOWN, Button::UP, Button::UP, Button::DOWN, Button::A, Button::B, Button::B, Button::A}
+    );
+    comboSequenceLast.setAutoStart(false);
+    comboSequenceLast.setAutoReset(false);
+    comboSequenceLast.setCompletedEventHandler(completed_handler);
+    comboAggregator.add(&comboSequenceLast);
+
+    while (!exitApp) {
+        lilka::State st = lilka::controller.getState();
+        comboAggregator.loop(st);
+
+        buffer.fillScreen(lilka::colors::Black);
+        mainUI(buffer, st);
+
+        switch (currentScene) {
+            case 0:
+                comboContinue.start();
+                scene_0(buffer, st);
+                break;
+            case 1:
+                comboScene1PressA.start();
+                scene_1(buffer, st);
+                break;
+            case 2:
+                comboScene2HoldAny.start();
+                scene_2(buffer, st);
+                break;
+            case 3:
+                comboScene3UpB.start();
+                scene_3(buffer, st);
+                break;
+            case 4:
+                comboSequenceLast.setTimeout(750);
+                comboSequenceLast.start();
+                scene_4(buffer, st, 750);
+                break;
+            case 5:
+                comboSequenceLast.setTimeout(500);
+                if (comboSequenceLast.isCompleted()) {
+                    comboSequenceLast.reset();
+                }
+                comboSequenceLast.start();
+                scene_4(buffer, st, 500);
+                break;
+            case 6:
+                comboSequenceLast.setTimeout(250);
+                if (comboSequenceLast.isCompleted()) {
+                    comboSequenceLast.reset();
+                }
+                comboSequenceLast.start();
+                scene_4(buffer, st, 250);
+                break;
+            case 7:
+                scene_final(buffer, st);
+                break;
+            default:
+                break;
+        }
+        canvas->drawCanvas(&buffer);
+        queueDraw();
+        vTaskDelay(1 / portTICK_PERIOD_MS);
+    }
+}
+
+void ComboApp::mainUI(lilka::Canvas& buffer, lilka::State& st) {
+    uint16_t hor_center = canvas->width() / 2;
+    lilka::display.setFont(FONT_10x20_MONO);
+    buffer.drawTextAligned("Demo Combo", hor_center, 20, Alignment::ALIGN_CENTER, Alignment::ALIGN_START);
+    lilka::display.setFont(FONT_8x13_MONO);
+    buffer.drawTextAligned(
+        "Для виходу затисніть",
+        hor_center,
+        canvas->height() - 40,
+        lilka::Alignment::ALIGN_CENTER,
+        lilka::Alignment::ALIGN_START
+    );
+
+    const char* pressByExitMessage = "[SELECT] на %d сек";
+    char pressByExit[strlen(pressByExitMessage)];
+    sprintf(pressByExit, pressByExitMessage, leftSecondsForExit);
+    buffer.drawTextAligned(
+        pressByExit, hor_center, canvas->height() - 20, Alignment::ALIGN_CENTER, Alignment::ALIGN_START
+    );
+}
+
+void ComboApp::scene_0(lilka::Canvas& buffer, lilka::State& st) {
+    uint16_t hor_center = canvas->width() / 2;
+    lilka::display.setFont(FONT_8x13_MONO);
+    buffer.drawTextAligned("Натисніть [START]", hor_center, 90, Alignment::ALIGN_CENTER, Alignment::ALIGN_START);
+
+    buffer.drawTextAligned("для продовження", hor_center, 110, Alignment::ALIGN_CENTER, Alignment::ALIGN_START);
+}
+
+void ComboApp::scene_1(lilka::Canvas& buffer, lilka::State& st) {
+    uint16_t hor_center = canvas->width() / 2;
+    lilka::display.setFont(FONT_8x13_MONO);
+    buffer.drawTextAligned("Натисніть", hor_center, 90, Alignment::ALIGN_CENTER, Alignment::ALIGN_START);
+
+    buffer.drawTextAligned("[A]", hor_center, 110, Alignment::ALIGN_CENTER, Alignment::ALIGN_START);
+}
+
+void ComboApp::scene_2(lilka::Canvas& buffer, lilka::State& st) {
+    uint16_t hor_center = canvas->width() / 2;
+    lilka::display.setFont(FONT_8x13_MONO);
+    buffer.drawTextAligned("Затисніть будь-яку", hor_center, 90, Alignment::ALIGN_CENTER, Alignment::ALIGN_START);
+
+    buffer.drawTextAligned("кнопку на 1 сек", hor_center, 110, Alignment::ALIGN_CENTER, Alignment::ALIGN_START);
+}
+
+void ComboApp::scene_3(lilka::Canvas& buffer, lilka::State& st) {
+    uint16_t hor_center = canvas->width() / 2;
+    lilka::display.setFont(FONT_8x13_MONO);
+    buffer.drawTextAligned("Натисніть разом", hor_center, 90, Alignment::ALIGN_CENTER, Alignment::ALIGN_START);
+
+    buffer.drawTextAligned("[UP] + [B]", hor_center, 110, Alignment::ALIGN_CENTER, Alignment::ALIGN_START);
+}
+
+void ComboApp::scene_4(lilka::Canvas& buffer, lilka::State& st, int timeout) {
+    uint16_t hor_center = canvas->width() / 2;
+    lilka::display.setFont(FONT_8x13_MONO);
+    buffer.drawTextAligned("DOWN,UP,UP,DOWN,A,B,B,A", hor_center, 90, Alignment::ALIGN_CENTER, Alignment::ALIGN_START);
+
+    const char* txt = "Таймаут %d мс";
+    char bf[100];
+    sprintf(bf, txt, timeout);
+    buffer.drawTextAligned(bf, hor_center, 110, Alignment::ALIGN_CENTER, Alignment::ALIGN_START);
+}
+
+void ComboApp::scene_final(lilka::Canvas& buffer, lilka::State& st) {
+    uint16_t hor_center = canvas->width() / 2;
+    lilka::display.setFont(FONT_8x13_MONO);
+    buffer.drawTextAligned("Кінець!", hor_center, 90, Alignment::ALIGN_CENTER, Alignment::ALIGN_START);
+}
diff --git a/firmware/keira/src/apps/demos/combo.h b/firmware/keira/src/apps/demos/combo.h
new file mode 100644
index 00000000..32bfaf9f
--- /dev/null
+++ b/firmware/keira/src/apps/demos/combo.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "app.h"
+
+class ComboApp : public App {
+public:
+    ComboApp();
+
+private:
+    void run() override;
+
+    void mainUI(lilka::Canvas& buffer, lilka::State& st);
+    void scene_0(lilka::Canvas& buffer, lilka::State& st);
+    void scene_1(lilka::Canvas& buffer, lilka::State& st);
+    void scene_2(lilka::Canvas& buffer, lilka::State& st);
+    void scene_3(lilka::Canvas& buffer, lilka::State& st);
+    void scene_4(lilka::Canvas& buffer, lilka::State& st, int timeout);
+    void scene_final(lilka::Canvas& buffer, lilka::State& st);
+};
diff --git a/firmware/keira/src/apps/launcher.cpp b/firmware/keira/src/apps/launcher.cpp
index d52cfe58..c7c7bfa0 100644
--- a/firmware/keira/src/apps/launcher.cpp
+++ b/firmware/keira/src/apps/launcher.cpp
@@ -20,6 +20,7 @@
 #include "demos/user_spi.h"
 #include "demos/scan_i2c.h"
 #include "demos/petpet.h"
+#include "demos/combo.h"
 #include "gpiomanager.h"
 #include "tamagotchi/tamagotchi.h"
 #include "lua/luarunner.h"
@@ -68,7 +69,8 @@ ITEM_LIST app_items = {
         {ITEM_APP("Клавіатура", KeyboardApp),
          ITEM_APP("Тест SPI", UserSPIApp),
          ITEM_APP("I2C-сканер", ScanI2CApp),
-         ITEM_APP("GPIO-менеджер", GPIOManagerApp)},
+         ITEM_APP("GPIO-менеджер", GPIOManagerApp),
+         ITEM_APP("Combo", ComboApp)},
     ),
     ITEM_APP("ЛілТрекер", LilTrackerApp),
     ITEM_APP("Летріс", LetrisApp),
diff --git a/firmware/keira/src/utils/combo/concurrent_buttons.cpp b/firmware/keira/src/utils/combo/concurrent_buttons.cpp
new file mode 100644
index 00000000..98c74044
--- /dev/null
+++ b/firmware/keira/src/utils/combo/concurrent_buttons.cpp
@@ -0,0 +1,120 @@
+#include "concurrent_buttons.h"
+
+ComboConcurrentButtons::ComboConcurrentButtons(std::initializer_list<Button> buttonList) :
+    ComboBase(),
+    NUM_BUTTONS(buttonList.size() ? buttonList.size() : 1),
+    buttons(new Button[NUM_BUTTONS]),
+    progressEventHandler(nullptr) {
+    initButtons(buttonList);
+}
+
+ComboConcurrentButtons::~ComboConcurrentButtons() {
+    buttons.reset();
+    progressEventHandler = nullptr;
+}
+
+void ComboConcurrentButtons::initButtons(std::initializer_list<Button> buttonList) {
+    if (buttonList.size()) {
+        auto it = buttonList.begin();
+        for (size_t i = 0; i < NUM_BUTTONS && it != buttonList.end(); ++i, ++it) {
+            buttons[i] = *it;
+        }
+    } else {
+        buttons[0] = Button::ANY;
+    }
+    buttonStage.changeButtonAndReset(Button::ANY);
+}
+
+void ComboConcurrentButtons::onProgress() {
+    if (!progressEventHandler) {
+        return;
+    }
+    progressEventHandler(NUM_BUTTONS, buttons.get(), buttonStage.getStage());
+}
+
+void ComboConcurrentButtons::loopAction(State& state) {
+    if (buttonStage.isReleased()) {
+        return;
+    }
+    const _StateButtons& buttonStates = *reinterpret_cast<const _StateButtons*>(&state);
+    switch (buttonStage.getStage()) {
+        case WAITING:
+            checkAllButtonsPressed(buttonStates);
+            break;
+        case PRESSED:
+            checkAllButtonsReleased(buttonStates);
+            break;
+        case RELEASED:
+        default:
+            break;
+    }
+}
+
+void ComboConcurrentButtons::resetAction() {
+    buttonStage.reset();
+}
+
+bool ComboConcurrentButtons::isTargetButton(size_t buttonIndex) {
+    for (size_t i = 0; i < NUM_BUTTONS; i++) {
+        if (buttons[i] == Button::ANY || buttonIndex == buttons[i]) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool ComboConcurrentButtons::isNonTargetButtonsPressed(const _StateButtons& buttonStates) {
+    if (!buttonStates[Button::ANY].pressed) {
+        return false;
+    }
+    size_t size = Button::COUNT - 1; // exclude ANY button
+    for (size_t i = 0; i < size; i++) {
+        if (buttonStates[i].pressed && !isTargetButton(i)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void ComboConcurrentButtons::checkAllButtonsPressed(const _StateButtons& buttonStates) {
+    if (isNonTargetButtonsPressed(buttonStates)) {
+        return;
+    }
+    bool allButtonsPressed = true;
+    bool anyButtonJustPressed = false;
+    for (size_t i = 0; i < NUM_BUTTONS; i++) {
+        const ButtonState& bs = buttonStates[buttons[i]];
+        if (!bs.pressed) {
+            allButtonsPressed = false;
+            break;
+        }
+        if (bs.justPressed) {
+            anyButtonJustPressed = true;
+        }
+    }
+    if (allButtonsPressed && anyButtonJustPressed) {
+        buttonStage.setStage(PRESSED);
+        onProgress();
+        complete();
+    }
+}
+
+void ComboConcurrentButtons::checkAllButtonsReleased(const _StateButtons& buttonStates) {
+    bool allButtonsReleased = true;
+    bool anyButtonJustReleased = false;
+    for (size_t i = 0; i < NUM_BUTTONS; i++) {
+        const ButtonState& bs = buttonStates[buttons[i]];
+        if (bs.pressed) {
+            allButtonsReleased = false;
+            break;
+        }
+        if (bs.justReleased) {
+            anyButtonJustReleased = true;
+        }
+    }
+    if (allButtonsReleased && anyButtonJustReleased) {
+        buttonStage.setStage(RELEASED);
+        onProgress();
+        checkAutoReset();
+    }
+}
diff --git a/firmware/keira/src/utils/combo/concurrent_buttons.h b/firmware/keira/src/utils/combo/concurrent_buttons.h
new file mode 100644
index 00000000..dfe8ac70
--- /dev/null
+++ b/firmware/keira/src/utils/combo/concurrent_buttons.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "core/core.h"
+#include "core/stage.h"
+
+using ComboConcurrentButtonsProgressEventHandler =
+    void (*)(const size_t numOfButtons, const Button buttons[], const ButtonStage stage);
+
+class ComboConcurrentButtons : public ComboBase {
+public:
+    ComboConcurrentButtons(std::initializer_list<Button> buttonList);
+    ~ComboConcurrentButtons();
+
+    void setProgressEventHandler(ComboConcurrentButtonsProgressEventHandler handler) {
+        progressEventHandler = handler;
+    }
+
+private:
+    const size_t NUM_BUTTONS;
+    std::unique_ptr<Button[]> buttons;
+    ComboButtonStage buttonStage;
+    ComboConcurrentButtonsProgressEventHandler progressEventHandler;
+
+    void initButtons(std::initializer_list<Button> buttonList);
+    bool isTargetButton(size_t buttonIndex);
+    bool isNonTargetButtonsPressed(const _StateButtons& buttonStates);
+    void checkAllButtonsPressed(const _StateButtons& buttonStates);
+    void checkAllButtonsReleased(const _StateButtons& buttonStates);
+    void onProgress();
+    void loopAction(State& state) override;
+    void resetAction() override;
+};
diff --git a/firmware/keira/src/utils/combo/core/aggregator.h b/firmware/keira/src/utils/combo/core/aggregator.h
new file mode 100644
index 00000000..26e735d2
--- /dev/null
+++ b/firmware/keira/src/utils/combo/core/aggregator.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <vector>
+#include "core.h"
+
+class ComboAggregator {
+public:
+    ComboAggregator() = default;
+    ~ComboAggregator() {
+        combos.clear();
+    }
+    void loop(State& state) {
+        for (auto combo : combos) {
+            combo->loop(state);
+        }
+    }
+    void add(ComboBase* combo) {
+        if (std::find(combos.begin(), combos.end(), combo) == combos.end()) {
+            combos.push_back(combo);
+        }
+    }
+    void remove(ComboBase* combo) {
+        auto newEnd = std::remove(combos.begin(), combos.end(), combo);
+        combos.erase(newEnd, combos.end());
+    }
+    void clear() {
+        combos.clear();
+    }
+
+private:
+    std::vector<ComboBase*> combos;
+};
diff --git a/firmware/keira/src/utils/combo/core/core.h b/firmware/keira/src/utils/combo/core/core.h
new file mode 100644
index 00000000..f3bb9ad5
--- /dev/null
+++ b/firmware/keira/src/utils/combo/core/core.h
@@ -0,0 +1,110 @@
+#pragma once
+
+#include <lilka.h>
+
+using lilka::_StateButtons;
+using lilka::Button;
+using lilka::ButtonState;
+using lilka::State;
+
+using ComboCompletedEventHandler = void (*)(void);
+using ComboResetEventHandler = void (*)(void);
+
+class ComboBase {
+public:
+    ComboBase() :
+        completed(false),
+        started(false),
+        autoStart(true),
+        autoReset(true),
+        completedEventHandler(nullptr),
+        resetEventHandler(nullptr) {
+    }
+    ~ComboBase() {
+        completedEventHandler = nullptr;
+        resetEventHandler = nullptr;
+    }
+    bool isCompleted() {
+        return completed;
+    };
+    bool isStarted() {
+        return started;
+    }
+    void start() {
+        started = true;
+    }
+    bool isAutoStart() {
+        return autoStart;
+    }
+    void setAutoStart(bool autoStart) {
+        this->autoStart = autoStart;
+    }
+    bool isAutoReset() {
+        return autoReset;
+    }
+    void setAutoReset(bool autoReset) {
+        this->autoReset = autoReset;
+    }
+    void setCompletedEventHandler(ComboCompletedEventHandler handler) {
+        completedEventHandler = handler;
+    }
+    void setResetEventHandler(ComboResetEventHandler handler) {
+        resetEventHandler = handler;
+    }
+    void loop(State& state) {
+        if (!isStarted() && isAutoStart()) {
+            start();
+        }
+        if (isStarted()) {
+            loopAction(state);
+        }
+    };
+    void reset() {
+        started = false;
+        completed = false;
+        resetAction();
+    };
+    static bool isNonTargetButtonPressed(Button target, const _StateButtons& buttonStates) {
+        bool anyButtonPressed = buttonStates[Button::ANY].pressed;
+        if (!anyButtonPressed || target == Button::ANY) {
+            return false;
+        }
+        size_t size = Button::COUNT - 1; // exclude ANY button
+        for (size_t i = 0; i < size; i++) {
+            if (i == target) {
+                continue;
+            }
+            if (buttonStates[i].pressed) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+protected:
+    void complete() {
+        if (!completed) {
+            completed = true;
+            onCompleted();
+        }
+    }
+    void onCompleted() {
+        if (completedEventHandler) completedEventHandler();
+    }
+    void onReset() {
+        if (resetEventHandler) resetEventHandler();
+    }
+    void checkAutoReset() {
+        if (isAutoReset()) {
+            reset();
+        }
+    }
+
+    virtual void loopAction(State& state) = 0;
+    virtual void resetAction() = 0;
+
+private:
+    bool completed, started, autoStart, autoReset;
+    ComboCompletedEventHandler completedEventHandler;
+    ComboResetEventHandler resetEventHandler;
+};
diff --git a/firmware/keira/src/utils/combo/core/stage.h b/firmware/keira/src/utils/combo/core/stage.h
new file mode 100644
index 00000000..2e5f957b
--- /dev/null
+++ b/firmware/keira/src/utils/combo/core/stage.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <lilka.h>
+
+using lilka::Button;
+
+typedef enum { WAITING = 0, PRESSED, RELEASED } ButtonStage;
+
+class ComboButtonStage {
+public:
+    ComboButtonStage() : button(Button::ANY), stage(WAITING) {
+    }
+    virtual void reset() {
+        stage = WAITING;
+    }
+    virtual void changeButtonAndReset(Button btn) {
+        button = btn;
+        reset();
+    }
+    inline Button getButton() {
+        return button;
+    }
+    inline ButtonStage getStage() {
+        return stage;
+    }
+    void setStage(ButtonStage bs) {
+        stage = bs;
+    }
+    bool isWaiting() {
+        return stage == WAITING;
+    }
+    bool isPressed() {
+        return stage == PRESSED;
+    }
+    bool isReleased() {
+        return stage == RELEASED;
+    }
+
+private:
+    Button button;
+    ButtonStage stage;
+};
\ No newline at end of file
diff --git a/firmware/keira/src/utils/combo/core/stage_time.h b/firmware/keira/src/utils/combo/core/stage_time.h
new file mode 100644
index 00000000..dce7cf2f
--- /dev/null
+++ b/firmware/keira/src/utils/combo/core/stage_time.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include "stage.h"
+
+class ComboButtonWithTimeStage : public ComboButtonStage {
+public:
+    ComboButtonWithTimeStage() : pressTime(0), releaseTime(0), prevReleaseTime(0) {
+    }
+    void reset() override {
+        ComboButtonStage::reset();
+        prevReleaseTime = releaseTime;
+        pressTime = releaseTime = 0;
+    }
+    void changeButtonAndReset(Button btn) override {
+        ComboButtonStage::changeButtonAndReset(btn);
+    }
+    void setPressedStage(uint32_t time) {
+        setStage(PRESSED);
+        pressTime = time ? time : millis();
+    }
+    void setReleasedStage(uint32_t time) {
+        setStage(RELEASED);
+        releaseTime = time ? time : millis();
+    }
+    uint32_t getPressTime() {
+        return pressTime;
+    }
+    uint32_t getReleaseTime() {
+        return releaseTime;
+    }
+    uint32_t getPrevReleaseTime() {
+        return prevReleaseTime;
+    }
+
+private:
+    uint32_t pressTime, releaseTime, prevReleaseTime;
+};
\ No newline at end of file
diff --git a/firmware/keira/src/utils/combo/one_button.cpp b/firmware/keira/src/utils/combo/one_button.cpp
new file mode 100644
index 00000000..4f36f8ef
--- /dev/null
+++ b/firmware/keira/src/utils/combo/one_button.cpp
@@ -0,0 +1,47 @@
+#include "one_button.h"
+
+ComboOneButton::ComboOneButton(Button button) : ComboBase(), progressEventHandler(nullptr) {
+    buttonStage.changeButtonAndReset(button);
+}
+
+ComboOneButton::~ComboOneButton() {
+    progressEventHandler = nullptr;
+}
+
+void ComboOneButton::onProgress() {
+    if (!progressEventHandler) {
+        return;
+    }
+    progressEventHandler(buttonStage.getButton(), buttonStage.getStage());
+}
+
+void ComboOneButton::loopAction(State& state) {
+    if (buttonStage.isReleased()) {
+        return;
+    }
+    const _StateButtons& buttonStates = *reinterpret_cast<const _StateButtons*>(&state);
+    const ButtonState& bs = buttonStates[buttonStage.getButton()];
+    switch (buttonStage.getStage()) {
+        case WAITING:
+            if (bs.justPressed) {
+                buttonStage.setStage(PRESSED);
+                onProgress();
+                complete();
+            }
+            break;
+        case PRESSED:
+            if (bs.justReleased) {
+                buttonStage.setStage(RELEASED);
+                onProgress();
+                checkAutoReset();
+            }
+            break;
+        case RELEASED:
+        default:
+            break;
+    }
+}
+
+void ComboOneButton::resetAction() {
+    buttonStage.reset();
+}
diff --git a/firmware/keira/src/utils/combo/one_button.h b/firmware/keira/src/utils/combo/one_button.h
new file mode 100644
index 00000000..427607a4
--- /dev/null
+++ b/firmware/keira/src/utils/combo/one_button.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "core/core.h"
+#include "core/stage.h"
+
+using ComboOneButtonProgressEventHandler = void (*)(const Button button, const ButtonStage stage);
+
+class ComboOneButton : public ComboBase {
+public:
+    explicit ComboOneButton(Button button);
+    ~ComboOneButton();
+
+    void setProgressEventHandler(ComboOneButtonProgressEventHandler handler) {
+        progressEventHandler = handler;
+    }
+
+private:
+    ComboButtonStage buttonStage;
+    ComboOneButtonProgressEventHandler progressEventHandler;
+    void onProgress();
+    void loopAction(State& state) override;
+    void resetAction() override;
+};
\ No newline at end of file
diff --git a/firmware/keira/src/utils/combo/one_hold_down_button.cpp b/firmware/keira/src/utils/combo/one_hold_down_button.cpp
new file mode 100644
index 00000000..fb6e915d
--- /dev/null
+++ b/firmware/keira/src/utils/combo/one_hold_down_button.cpp
@@ -0,0 +1,83 @@
+#include "one_hold_down_button.h"
+
+ComboOneHoldDownButton::ComboOneHoldDownButton(Button button, uint16_t holdDownTime, bool checkNonTargetButtons) :
+    ComboBase(),
+    progressEventHandler(nullptr),
+    holdDownTime(holdDownTime),
+    checkNonTargetButtons(checkNonTargetButtons) {
+    buttonStage.changeButtonAndReset(button);
+}
+
+ComboOneHoldDownButton::~ComboOneHoldDownButton() {
+    progressEventHandler = nullptr;
+}
+
+void ComboOneHoldDownButton::onProgress() {
+    if (!progressEventHandler) {
+        return;
+    }
+    uint16_t leftTimeToComplete = holdDownTime;
+    if (buttonStage.getPressTime()) {
+        uint32_t delta = millis() - buttonStage.getPressTime();
+        if (delta >= holdDownTime) {
+            leftTimeToComplete = 0;
+        } else {
+            leftTimeToComplete = holdDownTime - delta;
+        }
+    }
+    progressEventHandler(buttonStage.getButton(), buttonStage.getStage(), leftTimeToComplete);
+}
+
+bool ComboOneHoldDownButton::isTimeUp() {
+    if (buttonStage.getPressTime()) {
+        return (millis() - buttonStage.getPressTime()) >= holdDownTime;
+    }
+    return false;
+}
+
+void ComboOneHoldDownButton::loopAction(State& state) {
+    if (buttonStage.isReleased()) {
+        return;
+    }
+    const _StateButtons& buttonStates = *reinterpret_cast<const _StateButtons*>(&state);
+    if (checkNonTargetButtons && buttonStage.isPressed() && !isCompleted() &&
+        isNonTargetButtonPressed(buttonStage.getButton(), buttonStates)) {
+        resetAction();
+        onReset();
+        return;
+    }
+    const ButtonState& bs = buttonStates[buttonStage.getButton()];
+    switch (buttonStage.getStage()) {
+        case WAITING:
+            if (bs.justPressed) {
+                buttonStage.setPressedStage(bs.time);
+                onProgress();
+            }
+            break;
+        case PRESSED:
+            if (!isCompleted()) {
+                onProgress();
+                if (isTimeUp()) {
+                    complete();
+                }
+            }
+            if (bs.justReleased) {
+                if (isCompleted()) {
+                    buttonStage.setReleasedStage(bs.time);
+                    onProgress();
+                    checkAutoReset();
+                } else {
+                    resetAction();
+                    onReset();
+                }
+            }
+            break;
+        case RELEASED:
+        default:
+            break;
+    }
+}
+
+void ComboOneHoldDownButton::resetAction() {
+    buttonStage.reset();
+}
diff --git a/firmware/keira/src/utils/combo/one_hold_down_button.h b/firmware/keira/src/utils/combo/one_hold_down_button.h
new file mode 100644
index 00000000..db72d718
--- /dev/null
+++ b/firmware/keira/src/utils/combo/one_hold_down_button.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "core/core.h"
+#include "core/stage_time.h"
+
+using ComboOneHoldDownButtonProgressEventHandler =
+    void (*)(const Button button, const ButtonStage stage, uint16_t leftTimeToComplete);
+
+class ComboOneHoldDownButton : public ComboBase {
+public:
+    ComboOneHoldDownButton(Button button, uint16_t holdDownTime, bool checkNonTargetButtons = true);
+    ~ComboOneHoldDownButton();
+
+    void setProgressEventHandler(ComboOneHoldDownButtonProgressEventHandler handler) {
+        progressEventHandler = handler;
+    }
+
+private:
+    const uint16_t holdDownTime;
+    const bool checkNonTargetButtons;
+    ComboButtonWithTimeStage buttonStage;
+    ComboOneHoldDownButtonProgressEventHandler progressEventHandler;
+    bool isTimeUp();
+    void onProgress();
+    void loopAction(State& state) override;
+    void resetAction() override;
+};
\ No newline at end of file
diff --git a/firmware/keira/src/utils/combo/sequence_buttons.cpp b/firmware/keira/src/utils/combo/sequence_buttons.cpp
new file mode 100644
index 00000000..6e79b1dc
--- /dev/null
+++ b/firmware/keira/src/utils/combo/sequence_buttons.cpp
@@ -0,0 +1,114 @@
+#include "sequence_buttons.h"
+
+#define DEFAULT_TIMEOUT 750
+
+ComboButtonSequence::ComboButtonSequence(std::initializer_list<Button> buttonList) :
+    ComboBase(),
+    NUM_BUTTONS(buttonList.size() ? buttonList.size() : 1),
+    buttonIndex(0),
+    buttons(new Button[NUM_BUTTONS]),
+    progressEventHandler(nullptr),
+    firstComboButtonAlreadyPressed(false),
+    timeout(DEFAULT_TIMEOUT) {
+    initButtons(buttonList);
+}
+
+ComboButtonSequence::~ComboButtonSequence() {
+    buttons.reset();
+    progressEventHandler = nullptr;
+}
+
+void ComboButtonSequence::initButtons(std::initializer_list<Button> buttonList) {
+    if (buttonList.size()) {
+        auto it = buttonList.begin();
+        for (size_t i = 0; i < NUM_BUTTONS && it != buttonList.end(); ++i, ++it) {
+            buttons[i] = *it;
+        }
+    } else {
+        buttons[0] = Button::ANY;
+    }
+    buttonStage.changeButtonAndReset(buttons[0]);
+}
+
+void ComboButtonSequence::onProgress() {
+    if (!progressEventHandler) {
+        return;
+    }
+    progressEventHandler(buttonIndex, buttonStage.getButton(), buttonStage.getStage());
+}
+
+void ComboButtonSequence::loopAction(State& state) {
+    if (areAllButtonsProcessed()) {
+        return;
+    }
+    const _StateButtons& buttonStates = *reinterpret_cast<const _StateButtons*>(&state);
+    if (firstComboButtonAlreadyPressed && !isCompleted()) {
+        if (buttonStage.isWaiting() && isTimeout(buttonStage.getPrevReleaseTime()) ||
+            buttonStage.isPressed() && isTimeout(buttonStage.getPressTime()) ||
+            isNonTargetButtonPressed(buttonStage.getButton(), buttonStates)) {
+            resetAction();
+            onReset();
+            return;
+        }
+    }
+
+    const ButtonState& bs = buttonStates[buttonStage.getButton()];
+    switch (buttonStage.getStage()) {
+        case WAITING:
+            if (bs.justPressed) {
+                firstComboButtonAlreadyPressed = true;
+                buttonStage.setPressedStage(bs.time);
+                onProgress();
+                if (isLastButtonProcessed()) {
+                    complete();
+                }
+            }
+            break;
+        case PRESSED:
+            if (bs.justReleased) {
+                buttonStage.setReleasedStage(bs.time);
+                onProgress();
+                selectNextButtonForProcessing();
+                if (areAllButtonsProcessed()) {
+                    checkAutoReset();
+                }
+            }
+            break;
+        case RELEASED:
+        default:
+            break;
+    }
+}
+
+void ComboButtonSequence::resetAction() {
+    firstComboButtonAlreadyPressed = false;
+    buttonIndex = 0;
+    buttonStage.changeButtonAndReset(buttons[buttonIndex]);
+}
+
+bool ComboButtonSequence::isLastButtonProcessed() {
+    return buttonIndex == NUM_BUTTONS - 1;
+}
+
+bool ComboButtonSequence::areAllButtonsProcessed() {
+    return buttonIndex >= NUM_BUTTONS;
+}
+
+void ComboButtonSequence::selectNextButtonForProcessing() {
+    if (areAllButtonsProcessed()) {
+        return;
+    }
+    if (isLastButtonProcessed()) {
+        buttonIndex = NUM_BUTTONS;
+        return;
+    }
+    buttonStage.changeButtonAndReset(buttons[++buttonIndex]);
+}
+
+bool ComboButtonSequence::isTimeout(uint32_t time) {
+    return (millis() - time) >= timeout;
+}
+
+void ComboButtonSequence::setTimeout(uint16_t timeout) {
+    this->timeout = timeout;
+}
diff --git a/firmware/keira/src/utils/combo/sequence_buttons.h b/firmware/keira/src/utils/combo/sequence_buttons.h
new file mode 100644
index 00000000..e489aa9c
--- /dev/null
+++ b/firmware/keira/src/utils/combo/sequence_buttons.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include "core/core.h"
+#include "core/stage_time.h"
+
+using ComboButtonSequenceProgressEventHandler =
+    void (*)(const size_t buttonIndex, const Button button, const ButtonStage stage);
+
+class ComboButtonSequence : public ComboBase {
+public:
+    ComboButtonSequence(std::initializer_list<Button> buttonList);
+    ~ComboButtonSequence();
+
+    void setProgressEventHandler(ComboButtonSequenceProgressEventHandler handler) {
+        progressEventHandler = handler;
+    }
+    void setTimeout(uint16_t time);
+
+private:
+    const size_t NUM_BUTTONS;
+    std::unique_ptr<Button[]> buttons;
+    size_t buttonIndex;
+    bool firstComboButtonAlreadyPressed;
+    uint16_t timeout;
+    ComboButtonWithTimeStage buttonStage;
+    ComboButtonSequenceProgressEventHandler progressEventHandler;
+
+    void initButtons(std::initializer_list<Button> buttonList);
+    void selectNextButtonForProcessing();
+    bool areAllButtonsProcessed();
+    bool isLastButtonProcessed();
+    bool isTimeout(uint32_t time);
+    void onProgress();
+    void loopAction(State& state) override;
+    void resetAction() override;
+};
\ No newline at end of file