diff --git a/Common/Cpp/Json/JsonObject.h b/Common/Cpp/Json/JsonObject.h
index 4fe2765c65..428f945e45 100644
--- a/Common/Cpp/Json/JsonObject.h
+++ b/Common/Cpp/Json/JsonObject.h
@@ -18,6 +18,13 @@ class JsonObject{
     JsonObject() = default;
     JsonObject(JsonObject&& x) = default;
     JsonObject& operator=(JsonObject&& x) = default;
+
+    bool operator==(const JsonObject& x){ // TODO: implement == properly. For JsonValue as well.
+        return dump() == x.dump();
+    }
+    bool operator!=(const JsonObject& x){
+        return !(*this == *this);
+    }
 private:
     //  Private to avoid accidental copying.
     JsonObject(const JsonObject& x);
diff --git a/Common/Cpp/StringTools.cpp b/Common/Cpp/StringTools.cpp
index dea0b877e0..7393412b86 100644
--- a/Common/Cpp/StringTools.cpp
+++ b/Common/Cpp/StringTools.cpp
@@ -6,6 +6,7 @@
 
 #include <stdint.h>
 #include <stdexcept>
+#include <vector>
 #include "StringTools.h"
 
 namespace PokemonAutomation{
@@ -48,6 +49,21 @@ size_t to_size_t(const std::string& str){
     }
 }
 
+std::vector<std::string> split(const std::string& str, const std::string& delimiter) {
+    std::vector<std::string> tokens;
+    size_t start = 0;
+    size_t end = str.find(delimiter);
+    
+    while (end != std::string::npos) {
+        tokens.push_back(str.substr(start, end - start));
+        start = end + delimiter.length();
+        end = str.find(delimiter, start);
+    }
+    
+    tokens.push_back(str.substr(start));
+    return tokens;
+}
+
 
 }
 }
diff --git a/Common/Cpp/StringTools.h b/Common/Cpp/StringTools.h
index fbd0fccfce..a5c42f1520 100644
--- a/Common/Cpp/StringTools.h
+++ b/Common/Cpp/StringTools.h
@@ -21,6 +21,8 @@ std::string strip(const std::string& str);
 // Parse str to size_t. Return SIZE_MAX if parsing fails
 size_t to_size_t(const std::string& str);
 
+std::vector<std::string> split(const std::string& str, const std::string& delimiter);
+
 }
 }
 #endif
diff --git a/Common/Qt/Options/BoxFloatWidget.cpp b/Common/Qt/Options/BoxFloatWidget.cpp
index 7e48aea3cb..9db2f7ba40 100644
--- a/Common/Qt/Options/BoxFloatWidget.cpp
+++ b/Common/Qt/Options/BoxFloatWidget.cpp
@@ -7,6 +7,7 @@
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QLabel>
+#include "Common/Cpp/StringTools.h"
 #include "BoxFloatWidget.h"
 
 //#include <iostream>
@@ -24,21 +25,6 @@ ConfigWidget* BoxFloatOption::make_QtWidget(QWidget& parent){
 
 
 
-std::vector<std::string> split(const std::string& str, const std::string& delimiter) {
-    std::vector<std::string> tokens;
-    size_t start = 0;
-    size_t end = str.find(delimiter);
-
-    while (end != std::string::npos) {
-        tokens.push_back(str.substr(start, end - start));
-        start = end + delimiter.length();
-        end = str.find(delimiter, start);
-    }
-
-    tokens.push_back(str.substr(start));
-    return tokens;
-}
-
 
 
 BoxFloatWidget::~BoxFloatWidget(){
@@ -167,7 +153,7 @@ BoxFloatWidget::BoxFloatWidget(QWidget& parent, BoxFloatOption& value)
     connect(
         m_array, &QLineEdit::editingFinished,
         this, [this](){
-            std::vector<std::string> all_coords = split(m_array->text().toStdString(), ", ");
+            std::vector<std::string> all_coords = StringTools::split(m_array->text().toStdString(), ", ");
             if (all_coords.size() != 4){
                 return;
             }
diff --git a/SerialPrograms/CMakeLists.txt b/SerialPrograms/CMakeLists.txt
index 3870f6d30d..c3fb86e5f9 100644
--- a/SerialPrograms/CMakeLists.txt
+++ b/SerialPrograms/CMakeLists.txt
@@ -701,6 +701,8 @@ file(GLOB MAIN_SOURCES
     Source/Controllers/JoystickTools.h
     Source/Controllers/KeyboardInput/GlobalQtKeyMap.cpp
     Source/Controllers/KeyboardInput/GlobalQtKeyMap.h
+    Source/Controllers/KeyboardInput/KeyboardEventHandler.cpp
+    Source/Controllers/KeyboardInput/KeyboardEventHandler.h
     Source/Controllers/KeyboardInput/KeyboardInput.cpp
     Source/Controllers/KeyboardInput/KeyboardInput.h
     Source/Controllers/KeyboardInput/KeyboardStateTracker.cpp
@@ -1119,6 +1121,8 @@ file(GLOB MAIN_SOURCES
     Source/NintendoSwitch/Programs/NintendoSwitch_PreventSleep.h
     Source/NintendoSwitch/Programs/NintendoSwitch_PushJoySticks.cpp
     Source/NintendoSwitch/Programs/NintendoSwitch_PushJoySticks.h
+    Source/NintendoSwitch/Programs/NintendoSwitch_RecordKeyboardController.cpp
+    Source/NintendoSwitch/Programs/NintendoSwitch_RecordKeyboardController.h
     Source/NintendoSwitch/Programs/NintendoSwitch_SnapshotDumper.cpp
     Source/NintendoSwitch/Programs/NintendoSwitch_SnapshotDumper.h
     Source/NintendoSwitch/Programs/NintendoSwitch_SwitchViewer.cpp
diff --git a/SerialPrograms/Source/Controllers/Controller.h b/SerialPrograms/Source/Controllers/Controller.h
index b411423ba9..fdde10270e 100644
--- a/SerialPrograms/Source/Controllers/Controller.h
+++ b/SerialPrograms/Source/Controllers/Controller.h
@@ -10,6 +10,7 @@
 #include "Common/Compiler.h"
 #include "Common/Cpp/AbstractLogger.h"
 #include "Common/Cpp/Time.h"
+#include "Controllers/KeyboardInput/KeyboardEventHandler.h"
 #include "Common/Cpp/CancellableScope.h"
 
 class QKeyEvent;
@@ -19,6 +20,7 @@ namespace PokemonAutomation{
 class RecursiveThrottler;
 enum class ControllerType;
 enum class ControllerPerformanceClass;
+enum class ControllerClass;
 
 
 
@@ -64,6 +66,7 @@ class AbstractController{
 
     virtual const char* name() = 0;
     virtual ControllerType controller_type() const = 0;
+    virtual ControllerClass controller_class() const = 0;
     virtual ControllerPerformanceClass performance_class() const = 0;
 
     //  If the controller is polled at a fixed interval, this is that interval.
@@ -203,6 +206,9 @@ class AbstractController{
     virtual void keyboard_release_all(){}
     virtual void keyboard_press(const QKeyEvent& event){}
     virtual void keyboard_release(const QKeyEvent& event){}
+
+    virtual void add_keyboard_listener(KeyboardEventHandler::KeyboardListener& keyboard_listener){};
+    virtual void remove_keyboard_listener(KeyboardEventHandler::KeyboardListener& keyboard_listener){};
 };
 
 
@@ -294,6 +300,7 @@ class ControllerContext final : public CancellableScope{
 };
 
 
+using AbstractControllerContext = ControllerContext<AbstractController>;
 
 using AbstractControllerContext = ControllerContext<AbstractController>;
 
diff --git a/SerialPrograms/Source/Controllers/ControllerTypeStrings.cpp b/SerialPrograms/Source/Controllers/ControllerTypeStrings.cpp
index 32dabd8766..6db5d5a748 100644
--- a/SerialPrograms/Source/Controllers/ControllerTypeStrings.cpp
+++ b/SerialPrograms/Source/Controllers/ControllerTypeStrings.cpp
@@ -32,6 +32,16 @@ const EnumStringMap<ControllerType> CONTROLLER_TYPE_STRINGS{
     {ControllerType::NintendoSwitch2_RightJoycon,           "NS2: Right Joycon"},
 };
 
+const EnumStringMap<ControllerClass>& CONTROLLER_CLASS_STRINGS(){
+    static EnumStringMap<ControllerClass> database{
+        {ControllerClass::NONE,                                  "none"},
+        {ControllerClass::LEFT_JOYCON,                           "left-joycon"},
+        {ControllerClass::RIGHT_JOYCON,                          "right-joycon"},
+        {ControllerClass::PRO_CONTROLLER,                        "pro-controller"},
+    };
+    return database;
+}
+
 
 
 
diff --git a/SerialPrograms/Source/Controllers/ControllerTypeStrings.h b/SerialPrograms/Source/Controllers/ControllerTypeStrings.h
index 49ea1b08b9..e92bc84e75 100644
--- a/SerialPrograms/Source/Controllers/ControllerTypeStrings.h
+++ b/SerialPrograms/Source/Controllers/ControllerTypeStrings.h
@@ -16,6 +16,7 @@ namespace PokemonAutomation{
 
 extern const EnumStringMap<ControllerInterface> CONTROLLER_INTERFACE_STRINGS;
 extern const EnumStringMap<ControllerType> CONTROLLER_TYPE_STRINGS;
+const EnumStringMap<ControllerClass>& CONTROLLER_CLASS_STRINGS();
 
 
 
diff --git a/SerialPrograms/Source/Controllers/ControllerTypes.h b/SerialPrograms/Source/Controllers/ControllerTypes.h
index b1beab859e..0478e6ee6f 100644
--- a/SerialPrograms/Source/Controllers/ControllerTypes.h
+++ b/SerialPrograms/Source/Controllers/ControllerTypes.h
@@ -44,6 +44,14 @@ enum class ControllerPerformanceClass{
     SysbotBase,
 };
 
+enum class ControllerClass{
+    NONE,
+    LEFT_JOYCON,
+    RIGHT_JOYCON,
+    PRO_CONTROLLER,
+    KEYBOARD,
+};
+
 
 
 
diff --git a/SerialPrograms/Source/Controllers/KeyboardInput/KeyboardEventHandler.cpp b/SerialPrograms/Source/Controllers/KeyboardInput/KeyboardEventHandler.cpp
new file mode 100644
index 0000000000..5b91e9b325
--- /dev/null
+++ b/SerialPrograms/Source/Controllers/KeyboardInput/KeyboardEventHandler.cpp
@@ -0,0 +1,47 @@
+/*  Keyboard Event Handler
+ *
+ */
+#include "Common/Cpp/ListenerSet.h"
+#include "Common/Cpp/Containers/Pimpl.tpp"
+#include "Controllers/KeyboardInput/KeyboardInput.h"
+#include "KeyboardEventHandler.h"
+
+namespace PokemonAutomation{
+
+
+
+struct KeyboardEventHandler::Data{
+    ListenerSet<KeyboardListener> m_listeners;
+};
+
+KeyboardEventHandler::KeyboardEventHandler()
+    : m_data(CONSTRUCT_TOKEN)
+{}
+
+KeyboardEventHandler::~KeyboardEventHandler() = default;
+
+void KeyboardEventHandler::add_listener(KeyboardListener& listener){
+    auto scope = m_lifetime_sanitizer.check_scope();
+    Data& data = *m_data;
+    data.m_listeners.add(listener);
+}
+void KeyboardEventHandler::remove_listener(KeyboardListener& listener){
+    auto scope = m_lifetime_sanitizer.check_scope();
+    Data& data = *m_data;
+    data.m_listeners.remove(listener);
+}
+
+void KeyboardEventHandler::report_keyboard_command_sent(WallClock time_stamp, const ControllerState& state){
+    auto scope = m_lifetime_sanitizer.check_scope();
+    Data& data = *m_data;
+    data.m_listeners.run_method_unique(&KeyboardListener::on_keyboard_command_sent, time_stamp, state);
+}
+
+void KeyboardEventHandler::report_keyboard_command_stopped(WallClock time_stamp){
+    auto scope = m_lifetime_sanitizer.check_scope();
+    Data& data = *m_data;
+    data.m_listeners.run_method_unique(&KeyboardListener::on_keyboard_command_stopped, time_stamp);
+}
+
+
+}
\ No newline at end of file
diff --git a/SerialPrograms/Source/Controllers/KeyboardInput/KeyboardEventHandler.h b/SerialPrograms/Source/Controllers/KeyboardInput/KeyboardEventHandler.h
new file mode 100644
index 0000000000..a4f68728b4
--- /dev/null
+++ b/SerialPrograms/Source/Controllers/KeyboardInput/KeyboardEventHandler.h
@@ -0,0 +1,46 @@
+/*  Keyboard Event Handler
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+
+#ifndef PokemonAutomation_Controllers_KeyboardEventHandler_H
+#define PokemonAutomation_Controllers_KeyboardEventHandler_H
+
+#include "Common/Cpp/Containers/Pimpl.h"
+#include "Common/Cpp/Time.h"
+#include "Common/Cpp/LifetimeSanitizer.h"
+
+namespace PokemonAutomation{
+
+class ControllerState;  // forward declaration to avoid circular dependency
+
+class KeyboardEventHandler{
+public:
+    KeyboardEventHandler();
+    virtual ~KeyboardEventHandler();
+
+    struct KeyboardListener{
+        virtual void on_keyboard_command_sent(WallClock time_stamp, const ControllerState& state) = 0;
+        virtual void on_keyboard_command_stopped(WallClock time_stamp) = 0;
+    };
+    void add_listener(KeyboardListener& listener);
+    void remove_listener(KeyboardListener& listener);
+
+protected:
+    //  Report that the keyboard state has changed. This will be pushed to
+    //  all listeners.
+    void report_keyboard_command_sent(WallClock time_stamp, const ControllerState& state);
+
+    void report_keyboard_command_stopped(WallClock time_stamp);
+
+private:
+    struct Data;
+    Pimpl<Data> m_data;
+
+    LifetimeSanitizer m_lifetime_sanitizer;
+};
+
+}
+#endif
\ No newline at end of file
diff --git a/SerialPrograms/Source/Controllers/KeyboardInput/KeyboardInput.h b/SerialPrograms/Source/Controllers/KeyboardInput/KeyboardInput.h
index 553f9eea90..1e396ceb31 100644
--- a/SerialPrograms/Source/Controllers/KeyboardInput/KeyboardInput.h
+++ b/SerialPrograms/Source/Controllers/KeyboardInput/KeyboardInput.h
@@ -11,9 +11,11 @@
 #include <thread>
 #include <condition_variable>
 #include <Qt>
+#include "Common/Cpp/Json/JsonObject.h"
 #include "Common/Cpp/Concurrency/SpinLock.h"
 #include "Controllers/Controller.h"
 #include "Controllers/KeyboardInput/GlobalQtKeyMap.h"
+#include "KeyboardEventHandler.h"
 #include "KeyboardStateTracker.h"
 
 class QKeyEvent;
@@ -36,6 +38,8 @@ class ControllerState{
     virtual bool operator!=(const ControllerState& x) const{ return !(*this == x); }
 
     virtual bool is_neutral() const = 0;
+
+    virtual JsonObject serialize_state() const {return JsonObject();};
 };
 
 
@@ -86,7 +90,7 @@ class KeyboardInputController{
 
 
 template <typename StateType, typename DeltaType>
-class KeyboardManager : public KeyboardInputController{
+class KeyboardManager : public KeyboardInputController, public KeyboardEventHandler{
 public:
     KeyboardManager(Logger& logger, AbstractController& controller)
         : KeyboardInputController(logger, true)
@@ -126,7 +130,9 @@ class KeyboardManager : public KeyboardInputController{
         if (m_controller == nullptr){
             return;
         }
+        WallClock time_stamp = current_time();
         m_controller->cancel_all_commands();
+        report_keyboard_command_stopped(time_stamp);
     }
     virtual void replace_on_next_command() override{
         WriteSpinLock lg(m_lock);
diff --git a/SerialPrograms/Source/Controllers/StandardHid/StandardHid_Keyboard_SerialPABotBase.h b/SerialPrograms/Source/Controllers/StandardHid/StandardHid_Keyboard_SerialPABotBase.h
index 6710814615..c386d2c14a 100644
--- a/SerialPrograms/Source/Controllers/StandardHid/StandardHid_Keyboard_SerialPABotBase.h
+++ b/SerialPrograms/Source/Controllers/StandardHid/StandardHid_Keyboard_SerialPABotBase.h
@@ -53,6 +53,9 @@ class SerialPABotBase_Keyboard final :
     virtual ControllerType controller_type() const override{
         return ControllerType::HID_Keyboard;
     }
+    virtual ControllerClass controller_class() const override{
+        return ControllerClass::KEYBOARD;
+    }
     virtual ControllerPerformanceClass performance_class() const override{
         return ControllerPerformanceClass::SerialPABotBase_Wired;
     }
diff --git a/SerialPrograms/Source/NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.cpp b/SerialPrograms/Source/NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.cpp
index 4622fdebf4..a894469561 100644
--- a/SerialPrograms/Source/NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.cpp
+++ b/SerialPrograms/Source/NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.cpp
@@ -118,6 +118,19 @@ void pbf_mash_button(JoyconContext& context, Button button, Milliseconds duratio
     ssf_mash1_button(context, button, duration);
 }
 
+void pbf_controller_state(
+    JoyconContext& context,
+    Button button,
+    uint8_t x, uint8_t y,
+    Milliseconds duration
+){
+    context->issue_full_controller_state(
+        &context,
+        button,
+        x, y,
+        duration
+    );
+}
 
 
 
diff --git a/SerialPrograms/Source/NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.h b/SerialPrograms/Source/NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.h
index 72cfbef749..ed607a457d 100644
--- a/SerialPrograms/Source/NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.h
+++ b/SerialPrograms/Source/NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.h
@@ -121,7 +121,12 @@ void pbf_press_button   (JoyconContext& context, Button button, Milliseconds hol
 void pbf_move_joystick  (JoyconContext& context, uint8_t x, uint8_t y, Milliseconds hold, Milliseconds release);
 void pbf_mash_button    (JoyconContext& context, Button button, Milliseconds duration);
 
-
+void pbf_controller_state(
+    JoyconContext& context,
+    Button button,
+    uint8_t x, uint8_t y,
+    Milliseconds duration
+);
 
 
 }
diff --git a/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ControllerButtons.cpp b/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ControllerButtons.cpp
index d0f7d29b70..02a55feecf 100644
--- a/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ControllerButtons.cpp
+++ b/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ControllerButtons.cpp
@@ -5,59 +5,156 @@
  */
 
 #include "NintendoSwitch_ControllerButtons.h"
+#include "Common/Cpp/EnumStringMap.h"
+#include "Common/Cpp/StringTools.h"
 
 namespace PokemonAutomation{
 namespace NintendoSwitch{
 
+const EnumStringMap<Button> BUTTON_STRINGS{
+    {Button::BUTTON_NONE,              "none"},
+    {Button::BUTTON_Y,                 "Y"},
+    {Button::BUTTON_B,                 "B"},
+    {Button::BUTTON_A,                 "A"},
+    {Button::BUTTON_X,                 "X"},
+    {Button::BUTTON_L,                 "L"},
+    {Button::BUTTON_R,                 "R"},
+    {Button::BUTTON_ZL,                "ZL"},
+    {Button::BUTTON_ZR,                "ZR"},
+    {Button::BUTTON_MINUS,             "-"},
+    {Button::BUTTON_PLUS,              "+"},
+    {Button::BUTTON_LCLICK,            "LJ"},
+    {Button::BUTTON_RCLICK,            "RJ"},
+    {Button::BUTTON_HOME,              "HOME"},
+    {Button::BUTTON_CAPTURE,           "CAPTURE"},
+    {Button::BUTTON_GR,                "GR"},
+    {Button::BUTTON_GL,                "GL"},
+    {Button::BUTTON_UP,                "Up"},
+    {Button::BUTTON_RIGHT,             "Right"},
+    {Button::BUTTON_DOWN,              "Down"},
+    {Button::BUTTON_LEFT,              "Left"},
+    {Button::BUTTON_LEFT_SL,           "Left-SL"},
+    {Button::BUTTON_LEFT_SR,           "Left-SR"},
+    {Button::BUTTON_RIGHT_SL,          "Right-SL"},
+    {Button::BUTTON_RIGHT_SR,          "Right-SR"},
+    {Button::BUTTON_C,                 "C"},
+};    
+
+const EnumStringMap<Button> BUTTON_CODE_STRINGS{
+    {Button::BUTTON_NONE,              "BUTTON_NONE"},
+    {Button::BUTTON_Y,                 "BUTTON_Y"},
+    {Button::BUTTON_B,                 "BUTTON_B"},
+    {Button::BUTTON_A,                 "BUTTON_A"},
+    {Button::BUTTON_X,                 "BUTTON_X"},
+    {Button::BUTTON_L,                 "BUTTON_L"},
+    {Button::BUTTON_R,                 "BUTTON_R"},
+    {Button::BUTTON_ZL,                "BUTTON_ZL"},
+    {Button::BUTTON_ZR,                "BUTTON_ZR"},
+    {Button::BUTTON_MINUS,             "BUTTON_MINUS"},
+    {Button::BUTTON_PLUS,              "BUTTON_PLUS"},
+    {Button::BUTTON_LCLICK,            "BUTTON_LCLICK"},
+    {Button::BUTTON_RCLICK,            "BUTTON_RCLICK"},
+    {Button::BUTTON_HOME,              "BUTTON_HOME"},
+    {Button::BUTTON_CAPTURE,           "BUTTON_CAPTURE"},
+    {Button::BUTTON_GR,                "BUTTON_GR"},
+    {Button::BUTTON_GL,                "BUTTON_GL"},
+    {Button::BUTTON_UP,                "BUTTON_UP"},
+    {Button::BUTTON_RIGHT,             "BUTTON_RIGHT"},
+    {Button::BUTTON_DOWN,              "BUTTON_DOWN"},
+    {Button::BUTTON_LEFT,              "BUTTON_LEFT"},
+    {Button::BUTTON_LEFT_SL,           "BUTTON_LEFT_SL"},
+    {Button::BUTTON_LEFT_SR,           "BUTTON_LEFT_SR"},
+    {Button::BUTTON_RIGHT_SL,          "BUTTON_RIGHT_SL"},
+    {Button::BUTTON_RIGHT_SR,          "BUTTON_RIGHT_SR"},
+    {Button::BUTTON_C,                 "BUTTON_C"},
+};  
+
 
 std::string button_to_string(Button button){
     std::string str;
-    if (button & BUTTON_Y)          str += "Y ";
-    if (button & BUTTON_B)          str += "B ";
-    if (button & BUTTON_A)          str += "A ";
-    if (button & BUTTON_X)          str += "X ";
-    if (button & BUTTON_L)          str += "L ";
-    if (button & BUTTON_R)          str += "R ";
-    if (button & BUTTON_ZL)         str += "ZL ";
-    if (button & BUTTON_ZR)         str += "ZR ";
-    if (button & BUTTON_MINUS)      str += "- ";
-    if (button & BUTTON_PLUS)       str += "+ ";
-    if (button & BUTTON_LCLICK)     str += "LJ ";
-    if (button & BUTTON_RCLICK)     str += "RJ ";
-    if (button & BUTTON_HOME)       str += "HOME ";
-    if (button & BUTTON_CAPTURE)    str += "CAPTURE ";
-    if (button & BUTTON_GR)         str += "GR ";
-    if (button & BUTTON_GL)         str += "GL ";
-    if (button & BUTTON_UP)         str += "Up ";
-    if (button & BUTTON_RIGHT)      str += "Right ";
-    if (button & BUTTON_DOWN)       str += "Down ";
-    if (button & BUTTON_LEFT)       str += "Left ";
-    if (button & BUTTON_LEFT_SL)    str += "Left-SL ";
-    if (button & BUTTON_LEFT_SR)    str += "Left-SR ";
-    if (button & BUTTON_RIGHT_SL)   str += "Right-SL ";
-    if (button & BUTTON_RIGHT_SR)   str += "Right-SR ";
-    if (button & BUTTON_C)          str += "C ";
+    for (auto iter = BUTTON_STRINGS.begin(); iter != BUTTON_STRINGS.end(); ++iter){
+        if (iter->first & button){
+            str += iter->second + " ";
+        }
+    }
+
     if (str.empty()){
-        str = "none";
+        str = BUTTON_STRINGS.get_string(BUTTON_NONE);
     }
     if (str.back() == ' '){
         str.pop_back();
     }
     return str;
 }
+
+Button string_to_button(std::string multi_button_string){
+    std::vector<std::string> string_vector = StringTools::split(multi_button_string, " ");
+    Button button_result = BUTTON_NONE;
+    for (const std::string& button_string : string_vector){
+        Button one_button = BUTTON_STRINGS.get_enum(button_string);
+        button_result |= one_button;
+    }
+
+    return button_result;
+}
+
+std::string button_to_code_string(Button button){
+    std::string str;
+    std::string logical_or = " | ";
+    for (auto iter = BUTTON_CODE_STRINGS.begin(); iter != BUTTON_CODE_STRINGS.end(); ++iter){
+        if (iter->first & button){
+            str += iter->second + logical_or;
+        }
+    }
+    
+    if (str.empty()){
+        str = BUTTON_CODE_STRINGS.get_string(BUTTON_NONE);
+    }
+    if (str.substr(str.size() - logical_or.size()) == logical_or){ // remove trailing " | "
+        str = str.substr(0, str.size() - logical_or.size());
+    }
+    return str;
+}
+
+const EnumStringMap<DpadPosition> DPAD_STRINGS{
+    {DpadPosition::DPAD_UP,              "up"},
+    {DpadPosition::DPAD_UP_RIGHT,        "up-right"},
+    {DpadPosition::DPAD_RIGHT,           "right"},
+    {DpadPosition::DPAD_DOWN_RIGHT,      "down-right"},
+    {DpadPosition::DPAD_DOWN,            "down"},
+    {DpadPosition::DPAD_DOWN_LEFT,       "down-left"},
+    {DpadPosition::DPAD_LEFT,            "left"},
+    {DpadPosition::DPAD_UP_LEFT,         "up-left"},
+    {DpadPosition::DPAD_NONE,            "none"},
+}; 
+
+const EnumStringMap<DpadPosition> DPAD_CODE_STRINGS{
+    {DpadPosition::DPAD_UP,              "DPAD_UP"},
+    {DpadPosition::DPAD_UP_RIGHT,        "DPAD_UP_RIGHT"},
+    {DpadPosition::DPAD_RIGHT,           "DPAD_RIGHT"},
+    {DpadPosition::DPAD_DOWN_RIGHT,      "DPAD_DOWN_RIGHT"},
+    {DpadPosition::DPAD_DOWN,            "DPAD_DOWN"},
+    {DpadPosition::DPAD_DOWN_LEFT,       "DPAD_DOWN_LEFT"},
+    {DpadPosition::DPAD_LEFT,            "DPAD_LEFT"},
+    {DpadPosition::DPAD_UP_LEFT,         "DPAD_UP_LEFT"},
+    {DpadPosition::DPAD_NONE,            "DPAD_NONE"},
+}; 
+
+
 std::string dpad_to_string(DpadPosition dpad){
-    switch (dpad){
-    case DPAD_UP            : return "up";
-    case DPAD_UP_RIGHT      : return "up-right";
-    case DPAD_RIGHT         : return "right";
-    case DPAD_DOWN_RIGHT    : return "down-right";
-    case DPAD_DOWN          : return "down";
-    case DPAD_DOWN_LEFT     : return "down-left";
-    case DPAD_LEFT          : return "left";
-    case DPAD_UP_LEFT       : return "up-left";
-    case DPAD_NONE          : return "none";
+    try {
+        return DPAD_STRINGS.get_string(dpad);
+    }catch (ParseException&){
+        return "unknown";
     }
-    return "unknown";
+}
+
+std::string dpad_to_code_string(DpadPosition dpad){
+    return DPAD_CODE_STRINGS.get_string(dpad);
+}
+
+DpadPosition string_to_dpad(std::string dpad_string){
+    return DPAD_STRINGS.get_enum(dpad_string);
 }
 
 
diff --git a/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ControllerButtons.h b/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ControllerButtons.h
index 1d5880c87e..e94096569a 100644
--- a/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ControllerButtons.h
+++ b/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ControllerButtons.h
@@ -64,6 +64,10 @@ inline constexpr void operator&=(Button& x, Button y){
 }
 
 std::string button_to_string(Button button);
+std::string button_to_code_string(Button button);
+
+// ASSUME: multi_button_string was generated by button_to_string()
+Button string_to_button(std::string multi_button_string);
 
 
 
@@ -82,6 +86,10 @@ enum DpadPosition : uint8_t{
 };
 
 std::string dpad_to_string(DpadPosition dpad);
+std::string dpad_to_code_string(DpadPosition dpad);
+
+// ASSUME: dpad_string was generated by dpad_to_string()
+DpadPosition string_to_dpad(std::string dpad_string);
 
 
 
diff --git a/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_Joycon.cpp b/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_Joycon.cpp
index 9b3fb427bd..6a1a573966 100644
--- a/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_Joycon.cpp
+++ b/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_Joycon.cpp
@@ -57,6 +57,7 @@ class JoyconController::KeyboardManager final :
         stop();
     }
     virtual void send_state(const ControllerState& state) override{
+        
         const JoyconState& switch_state = static_cast<const JoyconState&>(state);
 #if 0
         m_controller->logger().log(
@@ -71,6 +72,7 @@ class JoyconController::KeyboardManager final :
             return;
         }
         Milliseconds ticksize = m_controller->ticksize();
+        WallClock time_stamp = current_time();
         static_cast<JoyconController*>(m_controller)->issue_full_controller_state(
             nullptr,
             switch_state.buttons,
@@ -78,6 +80,7 @@ class JoyconController::KeyboardManager final :
             switch_state.joystick_y,
             ticksize == Milliseconds::zero() ? 2000ms : ticksize * 255
         );
+        report_keyboard_command_sent(time_stamp, switch_state);
     }
 };
 
@@ -106,7 +109,13 @@ void JoyconController::keyboard_release(const QKeyEvent& event){
     m_keyboard_manager->on_key_release(event);
 }
 
+void JoyconController::add_keyboard_listener(KeyboardEventHandler::KeyboardListener& keyboard_listener){
+    m_keyboard_manager->add_listener(keyboard_listener);
+}
 
+void JoyconController::remove_keyboard_listener(KeyboardEventHandler::KeyboardListener& keyboard_listener){
+    m_keyboard_manager->remove_listener(keyboard_listener);
+}
 
 
 
diff --git a/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_Joycon.h b/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_Joycon.h
index c69b22c636..a902f15870 100644
--- a/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_Joycon.h
+++ b/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_Joycon.h
@@ -9,6 +9,7 @@
 
 #include "Common/Cpp/Containers/Pimpl.h"
 #include "NintendoSwitch_ControllerButtons.h"
+#include "Controllers/ControllerTypes.h"
 #include "Controllers/Controller.h"
 
 namespace PokemonAutomation{
@@ -171,6 +172,9 @@ class JoyconController : public AbstractController{
     virtual void keyboard_press(const QKeyEvent& event) override;
     virtual void keyboard_release(const QKeyEvent& event) override;
 
+    virtual void add_keyboard_listener(KeyboardEventHandler::KeyboardListener& keyboard_listener) override;
+    virtual void remove_keyboard_listener(KeyboardEventHandler::KeyboardListener& keyboard_listener) override;
+
 
 private:
     class KeyboardManager;
@@ -187,6 +191,9 @@ class LeftJoycon : public JoyconController{
     virtual const char* name() override{
         return NAME;
     };
+    virtual ControllerClass controller_class() const override{
+        return ControllerClass::LEFT_JOYCON;
+    }    
 };
 class RightJoycon : public JoyconController{
 public:
@@ -196,6 +203,9 @@ class RightJoycon : public JoyconController{
     virtual const char* name() override{
         return NAME;
     };
+    virtual ControllerClass controller_class() const override{
+        return ControllerClass::RIGHT_JOYCON;
+    } 
 };
 
 
diff --git a/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ProController.cpp b/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ProController.cpp
index d011727ee8..b67b1d0e9a 100644
--- a/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ProController.cpp
+++ b/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ProController.cpp
@@ -12,6 +12,10 @@
 #include "NintendoSwitch_VirtualControllerState.h"
 #include "NintendoSwitch_ProController.h"
 
+// #include <iostream>
+// using std::cout;
+// using std::endl;
+
 namespace PokemonAutomation{
 
 //  Instantiate some template helper classes.
@@ -46,8 +50,9 @@ class ProController::KeyboardManager final :
     ~KeyboardManager(){
         stop();
     }
-    virtual void send_state(const ControllerState& state) override{
+    virtual void send_state(const ControllerState& state) override{        
         const ProControllerState& switch_state = static_cast<const ProControllerState&>(state);
+
 #if 0
         m_controller.logger().log(
             "VirtualController: (" + button_to_string(switch_state.buttons) +
@@ -63,6 +68,7 @@ class ProController::KeyboardManager final :
             return;
         }
         Milliseconds ticksize = m_controller->ticksize();
+        WallClock time_stamp = current_time();
         static_cast<ProController*>(m_controller)->issue_full_controller_state(
             nullptr,
             ticksize == Milliseconds::zero() ? 2000ms : ticksize * 255,
@@ -73,7 +79,11 @@ class ProController::KeyboardManager final :
             switch_state.right_x,
             switch_state.right_y
         );
+
+        report_keyboard_command_sent(time_stamp, switch_state);
     }
+
+
 };
 
 
@@ -84,7 +94,6 @@ ProController::ProController(Logger& logger)
 
 }
 ProController::~ProController(){
-
 }
 void ProController::stop() noexcept{
     m_keyboard_manager->stop();
@@ -101,8 +110,13 @@ void ProController::keyboard_release(const QKeyEvent& event){
     m_keyboard_manager->on_key_release(event);
 }
 
+void ProController::add_keyboard_listener(KeyboardEventHandler::KeyboardListener& keyboard_listener){
+    m_keyboard_manager->add_listener(keyboard_listener);
+}
 
-
+void ProController::remove_keyboard_listener(KeyboardEventHandler::KeyboardListener& keyboard_listener){
+    m_keyboard_manager->remove_listener(keyboard_listener);
+}
 
 
 
diff --git a/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ProController.h b/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ProController.h
index 0fa51b7d7d..4631306334 100644
--- a/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ProController.h
+++ b/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ProController.h
@@ -10,6 +10,7 @@
 #define PokemonAutomation_NintendoSwitch_Controller_H
 
 #include "Common/Cpp/Containers/Pimpl.h"
+#include "Controllers/ControllerTypes.h"
 #include "Controllers/Controller.h"
 #include "NintendoSwitch_ControllerButtons.h"
 
@@ -60,12 +61,14 @@ class ProController : public AbstractController{
     ProController(Logger& logger);
     virtual ~ProController();
 
-
 public:
     static const char NAME[];
     virtual const char* name() override{
         return NAME;
     };
+    virtual ControllerClass controller_class() const override{
+        return ControllerClass::PRO_CONTROLLER;
+    }
 
 
 protected:
@@ -226,6 +229,8 @@ class ProController : public AbstractController{
     virtual void keyboard_press(const QKeyEvent& event) override;
     virtual void keyboard_release(const QKeyEvent& event) override;
 
+    virtual void add_keyboard_listener(KeyboardEventHandler::KeyboardListener& keyboard_listener) override;
+    virtual void remove_keyboard_listener(KeyboardEventHandler::KeyboardListener& keyboard_listener) override;
 
 private:
     class KeyboardManager;
diff --git a/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_VirtualControllerState.cpp b/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_VirtualControllerState.cpp
index 6a82c41331..cf1be91660 100644
--- a/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_VirtualControllerState.cpp
+++ b/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_VirtualControllerState.cpp
@@ -63,6 +63,19 @@ bool ProControllerState::is_neutral() const{
         && right_y == 128;
 }
 
+JsonObject ProControllerState::serialize_state() const {
+    JsonObject obj;
+    obj["is_neutral"] = is_neutral();
+    obj["buttons"] = button_to_string(buttons);
+    obj["dpad"] = dpad_to_string(dpad);
+    obj["left_x"] = left_x;
+    obj["left_y"] = left_y;
+    obj["right_x"] = right_x;
+    obj["right_y"] = right_y;
+    
+    return obj;
+}
+
 
 void ProControllerDeltas::operator+=(const ProControllerDeltas& x){
     buttons |= x.buttons;
@@ -169,6 +182,15 @@ bool JoyconState::is_neutral() const{
         && joystick_y == 128;
 }
 
+JsonObject JoyconState::serialize_state() const {
+    JsonObject obj;
+    obj["is_neutral"] = is_neutral();
+    obj["buttons"] = button_to_string(buttons);
+    obj["joystick_x"] = joystick_x;
+    obj["joystick_y"] = joystick_y;
+    
+    return obj;
+}
 
 void JoyconDeltas::operator+=(const JoyconDeltas& x){
     buttons |= x.buttons;
diff --git a/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_VirtualControllerState.h b/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_VirtualControllerState.h
index ce09e9d59b..4c71de6268 100644
--- a/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_VirtualControllerState.h
+++ b/SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_VirtualControllerState.h
@@ -20,6 +20,8 @@ class ProControllerState : public ControllerState{
     virtual bool operator==(const ControllerState& x) const override;
     virtual bool is_neutral() const override;
 
+    virtual JsonObject serialize_state() const override;
+
 public:
     Button buttons = BUTTON_NONE;
     DpadPosition dpad = DPAD_NONE;
@@ -52,6 +54,8 @@ class JoyconState : public ControllerState{
     virtual bool operator==(const ControllerState& x) const override;
     virtual bool is_neutral() const override;
 
+    virtual JsonObject serialize_state() const override;
+
 public:
     Button buttons = BUTTON_NONE;
     uint8_t joystick_x = 128;
diff --git a/SerialPrograms/Source/NintendoSwitch/DevPrograms/BoxDraw.cpp b/SerialPrograms/Source/NintendoSwitch/DevPrograms/BoxDraw.cpp
index 66d604479a..630577fda2 100644
--- a/SerialPrograms/Source/NintendoSwitch/DevPrograms/BoxDraw.cpp
+++ b/SerialPrograms/Source/NintendoSwitch/DevPrograms/BoxDraw.cpp
@@ -7,6 +7,7 @@
 #include <optional>
 #include <mutex>
 #include "CommonFramework/VideoPipeline/VideoOverlayScopes.h"
+#include "Common/Cpp/StringTools.h"
 #include "BoxDraw.h"
 
 // #include <iostream>
@@ -144,25 +145,11 @@ void BoxDraw::update_box_coordinates(){
     BOX_COORDINATES.set(box_coord_string);
 }
 
-std::vector<std::string> split(const std::string& str, const std::string& delimiter) {
-    std::vector<std::string> tokens;
-    size_t start = 0;
-    size_t end = str.find(delimiter);
-    
-    while (end != std::string::npos) {
-        tokens.push_back(str.substr(start, end - start));
-        start = end + delimiter.length();
-        end = str.find(delimiter, start);
-    }
-    
-    tokens.push_back(str.substr(start));
-    return tokens;
-}
 
 
 void BoxDraw::update_individual_coordinates(){
     std::string box_coord_string = BOX_COORDINATES;
-    std::vector<std::string> all_coords = split(box_coord_string, ", ");
+    std::vector<std::string> all_coords = StringTools::split(box_coord_string, ", ");
 
     std::string x_string = all_coords[0];
     std::string y_string = all_coords[1];
diff --git a/SerialPrograms/Source/NintendoSwitch/DevPrograms/TestProgramSwitch.cpp b/SerialPrograms/Source/NintendoSwitch/DevPrograms/TestProgramSwitch.cpp
index a2c9f0676a..520d7334c8 100644
--- a/SerialPrograms/Source/NintendoSwitch/DevPrograms/TestProgramSwitch.cpp
+++ b/SerialPrograms/Source/NintendoSwitch/DevPrograms/TestProgramSwitch.cpp
@@ -264,12 +264,21 @@ void TestProgram::program(MultiSwitchProgramEnvironment& env, CancellableScope&
     ProControllerContext context(scope, console.controller<ProController>());
     VideoOverlaySet overlays(overlay);
 
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-    HomeMenuDetector detector(console);
-    detector.make_overlays(overlays);
 
+#if 1
+    // context.controller().monitor_keyboard_events();
+#endif
 
 
+#if 0
+
+    HomeMenuDetector detector(console);
+    detector.make_overlays(overlays);
+#endif
+
 
 #if 0
 //    auto screenshot = feed.snapshot();
diff --git a/SerialPrograms/Source/NintendoSwitch/NintendoSwitch_Panels.cpp b/SerialPrograms/Source/NintendoSwitch/NintendoSwitch_Panels.cpp
index dba29f1f55..820609ba67 100644
--- a/SerialPrograms/Source/NintendoSwitch/NintendoSwitch_Panels.cpp
+++ b/SerialPrograms/Source/NintendoSwitch/NintendoSwitch_Panels.cpp
@@ -19,6 +19,7 @@
 #include "Programs/NintendoSwitch_PreventSleep.h"
 #include "Programs/NintendoSwitch_FriendCodeAdder.h"
 #include "Programs/NintendoSwitch_FriendDelete.h"
+#include "Programs/NintendoSwitch_RecordKeyboardController.h"
 
 #include "DevPrograms/BoxDraw.h"
 #include "Programs/NintendoSwitch_SnapshotDumper.h"
@@ -61,6 +62,7 @@ std::vector<PanelEntry> PanelListFactory::make_panels() const{
     ret.emplace_back(make_single_switch_program<PreventSleep_Descriptor, PreventSleep>());
     ret.emplace_back(make_single_switch_program<FriendCodeAdder_Descriptor, FriendCodeAdder>());
     ret.emplace_back(make_single_switch_program<FriendDelete_Descriptor, FriendDelete>());
+    ret.emplace_back(make_single_switch_program<RecordKeyboardController_Descriptor, RecordKeyboardController>());
 
 //    ret.emplace_back("---- " + STRING_POKEMON + " Home ----");
 
diff --git a/SerialPrograms/Source/NintendoSwitch/Programs/NintendoSwitch_RecordKeyboardController.cpp b/SerialPrograms/Source/NintendoSwitch/Programs/NintendoSwitch_RecordKeyboardController.cpp
new file mode 100644
index 0000000000..4df405908b
--- /dev/null
+++ b/SerialPrograms/Source/NintendoSwitch/Programs/NintendoSwitch_RecordKeyboardController.cpp
@@ -0,0 +1,631 @@
+/*  Record Keyboard Controller
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include <QFile>
+#include "Common/Cpp/Json/JsonArray.h"
+#include "NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.h"
+#include "NintendoSwitch/Controllers/NintendoSwitch_ProController.h"
+#include "NintendoSwitch_RecordKeyboardController.h"
+#include "Controllers/ControllerTypeStrings.h"
+
+#include <iostream>
+using std::cout;
+using std::endl;
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+
+
+RecordKeyboardController_Descriptor::RecordKeyboardController_Descriptor()
+    : SingleSwitchProgramDescriptor(
+        "NintendoSwitch:RecordKeyboardController",
+        "Nintendo Switch", "Record Keyboard Controller",
+        "ComputerControl/blob/master/Wiki/Programs/NintendoSwitch/RecordKeyboardController.md",
+        "Record actions from the keyboard controller, then play it back.",
+        ProgramControllerClass::StandardController_NoRestrictions,
+        FeedbackType::NONE,
+        AllowCommandsWhenRunning::ENABLE_COMMANDS
+    )
+{}
+
+
+
+RecordKeyboardController::~RecordKeyboardController(){
+    
+}
+
+RecordKeyboardController::RecordKeyboardController() 
+    : MODE(
+        "<b>Mode:</b>",
+        {
+            {Mode::RECORD,   "record", "Record "},
+            {Mode::REPLAY,  "replay", "Replay"},
+            {Mode::CONVERT_JSON_TO_CODE,       "convert-to-code", "[For Developers] Convert json to code."},
+        },
+        LockMode::LOCK_WHILE_RUNNING,
+        Mode::RECORD
+    )
+    , FILE_NAME(
+        false,
+        "<b>File name:</b><br>"
+        "Name of the JSON file to read/write.", 
+        LockMode::LOCK_WHILE_RUNNING, 
+        "UserSettings/recording",
+        "<name of JSON file>"
+    )
+    , GENERATE_CPP_CODE_AFTER_RECORDING(
+        "<b>[For Developers]</b><br>"
+        "<b>Automatically generate C++ code:</b><br>"
+        "After recording, a text file with the C++ code will automatically be generated.<br>"
+        "The name of the text file will be as per \"File name\" above.",
+        LockMode::UNLOCK_WHILE_RUNNING,
+        false
+    )
+{
+    PA_ADD_OPTION(MODE);
+    PA_ADD_OPTION(FILE_NAME);
+    PA_ADD_OPTION(GENERATE_CPP_CODE_AFTER_RECORDING);
+}
+
+
+
+void RecordKeyboardController::program(SingleSwitchProgramEnvironment& env, CancellableScope& scope){
+    AbstractControllerContext context(scope, env.console.controller());
+    ControllerClass controller_class = env.console.controller().controller_class();
+
+    if (MODE == Mode::RECORD){
+        // check if given file name already exists. If it does, throw an error so we don't overwrite it.
+        std::string output_json_filename = std::string(FILE_NAME) + ".json";
+        QFile file(QString::fromStdString(output_json_filename));
+        if (file.open(QFile::ReadOnly)){
+            throw FileException(nullptr, PA_CURRENT_FUNCTION, "Given file name already exists. Choose a different file name.", output_json_filename);
+        }
+
+        context.controller().add_keyboard_listener(*this);
+
+        try{
+            context.wait_until_cancel();
+        }catch (ProgramCancelledException&){
+
+            JsonValue json = controller_history_to_json(env.console.logger(), controller_class);
+            json.dump(output_json_filename);
+            m_controller_history.clear();
+
+            if (GENERATE_CPP_CODE_AFTER_RECORDING){
+                json_to_cpp_code(env.console.logger(), json, FILE_NAME);
+            }
+
+            context.controller().remove_keyboard_listener(*this);
+            
+            throw;
+        }        
+        
+    }else if (MODE == Mode::REPLAY){
+        JsonValue json = load_json_file(std::string(FILE_NAME) + ".json");
+        json_to_pbf_actions(env, scope, json, controller_class);
+
+
+    }else if (MODE == Mode::CONVERT_JSON_TO_CODE){
+        JsonValue json = load_json_file(std::string(FILE_NAME) + ".json");
+        json_to_cpp_code(env.console.logger(), json, FILE_NAME);
+
+
+    }
+
+}
+
+void json_to_cpp_code(Logger& logger, const JsonValue& json, const std::string& output_file_name){
+    try{
+        const JsonObject& obj = json.to_object_throw();
+
+        std::string controller_class_string = obj.get_string_throw("controller_class");
+        cout << controller_class_string << endl;
+        ControllerClass controller_class = CONTROLLER_CLASS_STRINGS().get_enum(controller_class_string);
+
+        const JsonArray& history_json = obj.get_array_throw("history");
+
+        std::string output_text;
+        switch (controller_class){
+        case ControllerClass::PRO_CONTROLLER:
+            output_text = json_to_cpp_code_pro_controller(history_json);
+            break;
+        case ControllerClass::LEFT_JOYCON:
+        case ControllerClass::RIGHT_JOYCON:
+            output_text = json_to_cpp_code_joycon(history_json);
+            break;
+        default:
+            // generate empty text if ControllerClass is not one of the above
+            break;
+        }
+
+        QFile file(QString::fromStdString(output_file_name + ".txt"));
+        file.open(QIODevice::WriteOnly);
+        file.write(output_text.c_str(), output_text.size());
+
+    }catch (ParseException& e){
+        logger.log(e.message() + "\nJSON parsing error. Given JSON file doesn't match the expected format.", COLOR_RED);
+        throw ParseException(e.message() + "\nJSON parsing error. Given JSON file doesn't match the expected format.");
+    }
+}
+
+std::string json_to_cpp_code_pro_controller(const JsonArray& history){
+    std::string result;
+
+    json_to_pro_controller_state(history, 
+        [&](int64_t duration_in_ms){
+            result += "pbf_wait(context, " + std::to_string(duration_in_ms) + "ms);\n";
+        },
+        [&](NonNeutralControllerField non_neutral_field,
+            Button button, 
+            DpadPosition dpad, 
+            uint8_t left_x, 
+            uint8_t left_y, 
+            uint8_t right_x, 
+            uint8_t right_y, 
+            int64_t duration_in_ms
+        ){
+
+            switch (non_neutral_field){
+            case NonNeutralControllerField::BUTTON:
+                result += "pbf_press_button(context, " 
+                    + button_to_code_string(button) + ", " 
+                    + std::to_string(duration_in_ms) + "ms, 0ms);\n";
+                break;
+            case NonNeutralControllerField::DPAD:
+                result += "pbf_press_dpad(context, " 
+                    + dpad_to_code_string(dpad) + ", " 
+                    + std::to_string(duration_in_ms) + "ms, 0ms);\n";
+                break;
+            case NonNeutralControllerField::LEFT_JOYSTICK:
+                result += "pbf_move_left_joystick(context, " 
+                    + std::to_string(left_x) + ", " + std::to_string(left_y) + ", " 
+                    + std::to_string(duration_in_ms) + "ms, 0ms);\n";
+                break;
+            case NonNeutralControllerField::RIGHT_JOYSTICK:
+                result += "pbf_move_right_joystick(context, " 
+                    + std::to_string(right_x) + ", " + std::to_string(right_y) + ", "
+                    + std::to_string(duration_in_ms) + "ms, 0ms);\n";
+                break;
+            case NonNeutralControllerField::MULTIPLE:
+                result += "pbf_controller_state(context, " 
+                    + button_to_code_string(button) + ", " 
+                    + dpad_to_code_string(dpad) + ", " 
+                    + std::to_string(left_x) + ", " + std::to_string(left_y) + ", " 
+                    + std::to_string(right_x) + ", " + std::to_string(right_y) + ", " 
+                    + std::to_string(duration_in_ms) +"ms);\n";
+                break;
+            case NonNeutralControllerField::NONE:
+                result += "pbf_wait(context, " + std::to_string(duration_in_ms) + "ms);\n";
+                break;
+            default:
+                throw ParseException("Unexpected NonNeutralControllerField enum.");
+            }            
+        }
+    );
+    
+    cout << result << endl;
+    return result;
+
+}
+
+std::string json_to_cpp_code_joycon(const JsonArray& history){
+    std::string result;
+
+    json_to_joycon_state(history, 
+        [&](int64_t duration_in_ms){
+            result += "pbf_wait(context, " + std::to_string(duration_in_ms) + "ms);\n";
+        },
+        [&](NonNeutralControllerField non_neutral_field,
+            Button button, 
+            uint8_t x, 
+            uint8_t y, 
+            int64_t duration_in_ms
+        ){
+
+            switch (non_neutral_field){
+            case NonNeutralControllerField::BUTTON:
+                result += "pbf_press_button(context, " 
+                    + button_to_code_string(button) + ", " 
+                    + std::to_string(duration_in_ms) + "ms, 0ms);\n";
+                break;
+            case NonNeutralControllerField::JOYSTICK:
+                result += "pbf_move_left_joystick(context, " 
+                    + std::to_string(x) + ", " + std::to_string(y) + ", " 
+                    + std::to_string(duration_in_ms) + "ms, 0ms);\n";
+                break;
+            case NonNeutralControllerField::MULTIPLE:
+                result += "pbf_controller_state(context, " 
+                    + button_to_code_string(button) + ", " 
+                    + std::to_string(x) + ", " + std::to_string(y) + ", " 
+                    + std::to_string(duration_in_ms) +"ms);\n";
+                break;
+            case NonNeutralControllerField::NONE:
+                result += "pbf_wait(context, " + std::to_string(duration_in_ms) + "ms);\n";
+                break;
+            default:
+                throw ParseException("Unexpected NonNeutralControllerField enum.");
+            }            
+        }
+    );
+    
+    cout << result << endl;
+    return result;
+
+}
+
+
+void json_to_pbf_actions(SingleSwitchProgramEnvironment& env, CancellableScope& scope, const JsonValue& json, ControllerClass controller_class){
+    try{
+        const JsonObject& obj = json.to_object_throw();
+
+        std::string controller_class_string = obj.get_string_throw("controller_class");
+        ControllerClass controller_class_json = CONTROLLER_CLASS_STRINGS().get_enum(controller_class_string);
+        if (controller_class_json != controller_class){
+            throw UserSetupError(env.logger(), "Controller class in the JSON file does not match your current selected controller.");
+        }
+
+        const JsonArray& history_json = obj.get_array_throw("history");
+
+        switch (controller_class){
+        case ControllerClass::PRO_CONTROLLER:
+        {
+            ProControllerContext context(scope, env.console.controller<ProController>());
+            json_to_pbf_actions_pro_controller(context, history_json);
+            break;
+        }
+        case ControllerClass::LEFT_JOYCON:
+        case ControllerClass::RIGHT_JOYCON:
+        {
+            JoyconContext context(scope, env.console.controller<JoyconController>());
+            json_to_pbf_actions_joycon(context, history_json);
+            break;
+        }
+        default:
+            // do nothing if the ControllerClass is not one of the above.
+            break;
+        }
+
+    }catch (ParseException& e){
+        env.log(e.message() + "\nJSON parsing error. Given JSON file doesn't match the expected format.", COLOR_RED);
+        throw ParseException(e.message() + "\nJSON parsing error. Given JSON file doesn't match the expected format.");
+    }    
+
+}
+
+void json_to_pbf_actions_pro_controller(ProControllerContext& context, const JsonArray& history){
+
+    json_to_pro_controller_state(history, 
+        [&](int64_t duration_in_ms){
+            pbf_wait(context, Milliseconds(duration_in_ms));
+        },
+        [&](NonNeutralControllerField non_neutral_field,
+            Button button, 
+            DpadPosition dpad, 
+            uint8_t left_x, 
+            uint8_t left_y, 
+            uint8_t right_x, 
+            uint8_t right_y, 
+            int64_t duration_in_ms
+        ){
+            switch (non_neutral_field){
+            case NonNeutralControllerField::BUTTON:
+                pbf_press_button(context, button, Milliseconds(duration_in_ms), Milliseconds(0));
+                break;
+            case NonNeutralControllerField::DPAD:
+                pbf_press_dpad(context, dpad, Milliseconds(duration_in_ms), Milliseconds(0));
+                break;
+            case NonNeutralControllerField::LEFT_JOYSTICK:
+                pbf_move_left_joystick(context, left_x, left_y, Milliseconds(duration_in_ms), Milliseconds(0));
+                break;
+            case NonNeutralControllerField::RIGHT_JOYSTICK:
+                pbf_move_right_joystick(context, right_x, right_y, Milliseconds(duration_in_ms), Milliseconds(0));
+                break;
+            case NonNeutralControllerField::MULTIPLE:
+                pbf_controller_state(context, button, dpad, left_x, left_y, right_x, right_y, Milliseconds(duration_in_ms));
+                break;
+            case NonNeutralControllerField::NONE:
+                pbf_wait(context, Milliseconds(duration_in_ms));
+                break;
+            default:
+                throw ParseException("Unexpected NonNeutralControllerField enum.");
+            }            
+        }
+    );
+}
+
+void json_to_pbf_actions_joycon(JoyconContext& context, const JsonArray& history){
+
+    json_to_joycon_state(history, 
+        [&](int64_t duration_in_ms){
+            pbf_wait(context, Milliseconds(duration_in_ms));
+        },
+        [&](NonNeutralControllerField non_neutral_field,
+            Button button, 
+            uint8_t x, 
+            uint8_t y, 
+            int64_t duration_in_ms
+        ){
+            switch (non_neutral_field){
+            case NonNeutralControllerField::BUTTON:
+                pbf_press_button(context, button, Milliseconds(duration_in_ms), Milliseconds(0));
+                break;
+            case NonNeutralControllerField::JOYSTICK:
+                pbf_move_joystick(context, x, y, Milliseconds(duration_in_ms), Milliseconds(0));
+                break;
+            case NonNeutralControllerField::MULTIPLE:
+                pbf_controller_state(context, button, x, y, Milliseconds(duration_in_ms));
+                break;
+            case NonNeutralControllerField::NONE:
+                pbf_wait(context, Milliseconds(duration_in_ms));
+                break;
+            default:
+                throw ParseException("Unexpected NonNeutralControllerField enum.");
+            }            
+        }
+    );
+}
+
+
+NonNeutralControllerField get_non_neutral_pro_controller_field(Button button, DpadPosition dpad, uint8_t left_x, uint8_t left_y, uint8_t right_x, uint8_t right_y){
+    NonNeutralControllerField non_neutral_field = NonNeutralControllerField::NONE;
+    int8_t num_non_neutral_fields = 0;
+    if (button != BUTTON_NONE) { 
+        num_non_neutral_fields++;
+        // if (num_non_neutral_fields > 1){
+        //     return NonNeutralControllerField::MULTIPLE;
+        // }
+        non_neutral_field = NonNeutralControllerField::BUTTON; 
+    }
+
+    if (dpad != DPAD_NONE){
+        num_non_neutral_fields++;
+        if (num_non_neutral_fields > 1){
+            return NonNeutralControllerField::MULTIPLE;
+        }
+        non_neutral_field = NonNeutralControllerField::DPAD; 
+    }
+
+    if (left_x != STICK_CENTER || left_y != STICK_CENTER){
+        num_non_neutral_fields++;
+        if (num_non_neutral_fields > 1){
+            return NonNeutralControllerField::MULTIPLE;
+        }
+        non_neutral_field = NonNeutralControllerField::LEFT_JOYSTICK; 
+    }
+
+    if (right_x != STICK_CENTER || right_y != STICK_CENTER){
+        num_non_neutral_fields++;
+        if (num_non_neutral_fields > 1){
+            return NonNeutralControllerField::MULTIPLE;
+        }
+        non_neutral_field = NonNeutralControllerField::RIGHT_JOYSTICK; 
+    }
+
+    return non_neutral_field;
+}
+
+NonNeutralControllerField get_non_neutral_joycon_controller_field(Button button, uint8_t x, uint8_t y){
+    NonNeutralControllerField non_neutral_field = NonNeutralControllerField::NONE;
+    int8_t num_non_neutral_fields = 0;
+    if (button != BUTTON_NONE) { 
+        num_non_neutral_fields++;
+        // if (num_non_neutral_fields > 1){
+        //     return NonNeutralControllerField::MULTIPLE;
+        // }
+        non_neutral_field = NonNeutralControllerField::BUTTON; 
+    }
+
+    if (x != STICK_CENTER || y != STICK_CENTER){
+        num_non_neutral_fields++;
+        if (num_non_neutral_fields > 1){
+            return NonNeutralControllerField::MULTIPLE;
+        }
+        non_neutral_field = NonNeutralControllerField::JOYSTICK; 
+    }
+
+    return non_neutral_field;
+}
+
+
+
+void json_to_pro_controller_state(
+    const JsonArray& history, 
+    std::function<void(int64_t duration_in_ms)>&& neutral_action,
+    std::function<void(
+        NonNeutralControllerField non_neutral_field,
+        Button button, 
+        DpadPosition dpad, 
+        uint8_t left_x, 
+        uint8_t left_y, 
+        uint8_t right_x, 
+        uint8_t right_y, 
+        int64_t duration_in_ms
+    )>&& non_neutral_action
+){
+    for(size_t i = 0; i < history.size(); i++){
+        const JsonObject& snapshot = history[i].to_object_throw();
+        int64_t duration_in_ms = snapshot.get_integer_throw("duration_in_ms");
+        bool is_neutral = snapshot.get_boolean_throw("is_neutral");
+        if (is_neutral){
+            neutral_action(duration_in_ms);
+        }else{
+            std::string buttons_string = snapshot.get_string_throw("buttons");
+            std::string dpad_string = snapshot.get_string_throw("dpad");
+
+            Button button = string_to_button(buttons_string);
+            DpadPosition dpad = string_to_dpad(dpad_string);
+
+            int64_t left_x = snapshot.get_integer_throw("left_x");
+            int64_t left_y = snapshot.get_integer_throw("left_y");
+            int64_t right_x = snapshot.get_integer_throw("right_x");
+            int64_t right_y = snapshot.get_integer_throw("right_y");
+            
+            // ensure all x, y are within STICK_MIN/MAX
+            if (left_x > STICK_MAX || left_x < STICK_MIN || 
+                left_y > STICK_MAX || left_y < STICK_MIN || 
+                right_x > STICK_MAX || right_x < STICK_MIN || 
+                right_y > STICK_MAX || right_y < STICK_MIN)
+            {
+                throw ParseException("x or y values are outside of 0-255.");
+            }
+
+            NonNeutralControllerField non_neutral_field = get_non_neutral_pro_controller_field(button, dpad, left_x, left_y, right_x, right_y);
+
+            non_neutral_action(non_neutral_field, button, dpad, left_x, left_y, right_x, right_y, duration_in_ms);
+            
+        }
+
+    }
+
+}
+
+void json_to_joycon_state(
+    const JsonArray& history, 
+    std::function<void(int64_t duration_in_ms)>&& neutral_action,
+    std::function<void(
+        NonNeutralControllerField non_neutral_field,
+        Button button, 
+        uint8_t x, 
+        uint8_t y, 
+        int64_t duration_in_ms
+    )>&& non_neutral_action
+){
+    for(size_t i = 0; i < history.size(); i++){
+        const JsonObject& snapshot = history[i].to_object_throw();
+        int64_t duration_in_ms = snapshot.get_integer_throw("duration_in_ms");
+        bool is_neutral = snapshot.get_boolean_throw("is_neutral");
+        if (is_neutral){
+            neutral_action(duration_in_ms);
+        }else{
+            std::string buttons_string = snapshot.get_string_throw("buttons");
+
+            Button button = string_to_button(buttons_string);
+
+            int64_t x = snapshot.get_integer_throw("joystick_x");
+            int64_t y = snapshot.get_integer_throw("joystick_y");
+            
+            // ensure x, y are within STICK_MIN/MAX
+            if (x > STICK_MAX || x < STICK_MIN || 
+                y > STICK_MAX || y < STICK_MIN)
+            {
+                throw ParseException("x or y values are outside of 0-255.");
+            }
+
+            NonNeutralControllerField non_neutral_field = get_non_neutral_joycon_controller_field(button, x, y);
+
+            non_neutral_action(non_neutral_field, button, x, y, duration_in_ms);
+            
+        }
+
+    }
+
+}
+
+JsonValue RecordKeyboardController::controller_history_to_json(Logger& logger, ControllerClass controller_class){
+    if (m_controller_history.size() < 2){
+        // throw InternalProgramError(&logger, PA_CURRENT_FUNCTION, "RecordKeyboardController:: m_controller_history should have at least two entries, start and stop.");
+        logger.log("RecordKeyboardController:: We expected m_controller_history to have at least two entries, start and stop. Aborting.", COLOR_RED);
+        return JsonValue();
+    }
+    
+    JsonArray json_array;
+    ControllerStateSnapshot* prev_snapshot = &m_controller_history[0]; // the previous non-duplicate snapshot
+    WallClock initial_time_stamp = m_controller_history[0].time_stamp;
+
+    for (size_t i = 1; i < m_controller_history.size(); i++){ // start at index i = 1, since prev_snapshot starts at i=0 and we continue when current == previous.
+        ControllerStateSnapshot& snapshot = m_controller_history[i];
+        WallClock time_stamp = snapshot.time_stamp;
+        JsonObject& controller_state = snapshot.controller_state;
+        
+        WallClock prev_time_stamp = prev_snapshot->time_stamp;
+        JsonObject& prev_controller_state = prev_snapshot->controller_state;
+
+        if (controller_state == prev_controller_state){
+            continue;
+        }
+        
+        // Normalize each time stamp relative to the initial time stamp, and round to milliseconds.
+        // When only considering the distance between adjacent timestamps, you end up with drift due to rounding from nanoseconds to milliseconds, 
+
+        // example:
+        // Timestamps           Diff only comparing adjacent                Total time since start
+        // 12:00 1us            1.4us -> 1ms                                0ms
+        // 12:00 1401us         1.4us -> 1ms                                1ms
+        // 12:00 2801us         1.4us -> 1ms                                2ms
+        // 12:00 4201us         1.4us -> 1ms                                3ms
+        // 12:00 5601us         1.4us -> 1ms                                4ms
+        // 12:00 7001us         1.4us -> 1ms                                5ms
+        // 12:00 8401us         1.4us -> 1ms                                6ms
+        // 12:00 9801us         1.4us -> 1ms                                7ms
+        // 12:00 11201us                                                    8ms
+        // total time elapsed: 11.2ms vs 8ms
+
+        // Normalized timestamps		Diff using normalized timestamps    Total time since start
+        // 0ms                          1ms                                 0ms
+        // 1.4ms -> 1ms                 2ms	                                1ms
+        // 2.8ms -> 3ms                 1ms                                 3ms
+        // 4.2ms -> 4ms                 2ms                                 4ms
+        // 5.6ms -> 6ms                 1ms                                 6ms
+        // 7.0ms -> 7ms                 1ms                                 7ms
+        // 8.4ms -> 8ms                 2ms                                 8ms
+        // 9.8ms -> 10ms                1ms                                 10ms
+        // 11.2ms -> 11ms                                                   11ms
+        // total time elapsed: 11.2ms vs 11ms
+
+
+        Milliseconds current_timestamp_time_since_start = 
+            std::chrono::round<Milliseconds>(std::chrono::duration_cast<std::chrono::nanoseconds>(time_stamp - initial_time_stamp)); // find the time difference as nanoseconds, then round to milliseconds
+        Milliseconds prev_timestamp_time_since_start = 
+            std::chrono::round<Milliseconds>(std::chrono::duration_cast<std::chrono::nanoseconds>(prev_time_stamp - initial_time_stamp)); 
+        Milliseconds elapsed_time = current_timestamp_time_since_start - prev_timestamp_time_since_start;
+        int64_t duration = elapsed_time.count();
+
+        // cout << std::to_string(duration) << endl;
+        // cout << prev_controller_state.dump() << endl;
+        JsonObject recording = prev_controller_state.clone();
+        recording["duration_in_ms"] = duration;
+        json_array.push_back(std::move(recording));
+        prev_snapshot = &snapshot; // update the previous non-duplicate snapshot
+    }
+    
+    
+    JsonObject json_result;
+    json_result["controller_class"] = CONTROLLER_CLASS_STRINGS().get_string(controller_class);
+    json_result["history"] = JsonValue(std::move(json_array));
+
+    return json_result;
+
+}
+
+
+void RecordKeyboardController::on_keyboard_command_sent(WallClock time_stamp, const ControllerState& state){
+    cout << "keyboard_command_sent" << endl;
+    JsonObject serialized_state = state.serialize_state();
+    cout << serialized_state.dump(0) << endl;
+    
+    ControllerStateSnapshot state_snapshot = {
+        time_stamp,
+        std::move(serialized_state)
+    };
+    m_controller_history.emplace_back(std::move(state_snapshot));
+}
+void RecordKeyboardController::on_keyboard_command_stopped(WallClock time_stamp){
+    cout << "keyboard_command_stopped" << endl;
+    JsonObject obj;
+    obj["is_neutral"] = true;
+
+    ControllerStateSnapshot state_snapshot = {
+        time_stamp, 
+        std::move(obj)
+    };
+    m_controller_history.emplace_back(std::move(state_snapshot));
+}
+
+
+
+}
+}
+
diff --git a/SerialPrograms/Source/NintendoSwitch/Programs/NintendoSwitch_RecordKeyboardController.h b/SerialPrograms/Source/NintendoSwitch/Programs/NintendoSwitch_RecordKeyboardController.h
new file mode 100644
index 0000000000..e07e3652b0
--- /dev/null
+++ b/SerialPrograms/Source/NintendoSwitch/Programs/NintendoSwitch_RecordKeyboardController.h
@@ -0,0 +1,149 @@
+/*  Record Keyboard Controller
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#ifndef PokemonAutomation_NintendoSwitch_RecordKeyboardController_H
+#define PokemonAutomation_NintendoSwitch_RecordKeyboardController_H
+
+#include <functional>
+#include "Common/Cpp/Json/JsonObject.h"
+#include "Common/Cpp/Options/BooleanCheckBoxOption.h"
+#include "Common/Cpp/Options/StringOption.h"
+#include "NintendoSwitch/Controllers/NintendoSwitch_Joycon.h"
+#include "Controllers/KeyboardInput/KeyboardInput.h"
+#include "NintendoSwitch/NintendoSwitch_SingleSwitchProgram.h"
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+
+class ProControllerState;
+
+enum class NonNeutralControllerField {
+    BUTTON,
+    DPAD,
+    LEFT_JOYSTICK,
+    RIGHT_JOYSTICK,
+    JOYSTICK,
+    MULTIPLE,
+    NONE,
+};
+NonNeutralControllerField get_non_neutral_pro_controller_field(Button button, DpadPosition dpad, uint8_t left_x, uint8_t left_y, uint8_t right_x, uint8_t right_y);
+NonNeutralControllerField get_non_neutral_joycon_controller_field(Button button, uint8_t x, uint8_t y);
+
+// helper function that exposes the Pro Controller fields from the given JSON
+void json_to_pro_controller_state(
+    const JsonArray& history, 
+    std::function<void(int64_t duration_in_ms)>&& neutral_action,
+    std::function<void(
+        NonNeutralControllerField non_neutral_field,
+        Button button, 
+        DpadPosition dpad, 
+        uint8_t left_x, 
+        uint8_t left_y, 
+        uint8_t right_x, 
+        uint8_t right_y, 
+        int64_t duration_in_ms
+    )>&& non_neutral_action
+);
+
+// helper function that exposes the Joycon fields from the given JSON
+void json_to_joycon_state(
+    const JsonArray& history, 
+    std::function<void(int64_t duration_in_ms)>&& neutral_action,
+    std::function<void(
+        NonNeutralControllerField non_neutral_field,
+        Button button, 
+        uint8_t x, 
+        uint8_t y, 
+        int64_t duration_in_ms
+    )>&& non_neutral_action
+);
+
+// given the json, with the controller history, output a text file which represents C++ code.
+void json_to_cpp_code(Logger& logger, const JsonValue& json, const std::string& output_file_name);
+std::string json_to_cpp_code_pro_controller(const JsonArray& history_json);
+std::string json_to_cpp_code_joycon(const JsonArray& history);
+
+// given the json, with the controller history, run the controller actions using the pbf functions.
+void json_to_pbf_actions(SingleSwitchProgramEnvironment& env, CancellableScope& scope, const JsonValue& json, ControllerClass controller_class);
+void json_to_pbf_actions_pro_controller(ProControllerContext& context, const JsonArray& history);
+void json_to_pbf_actions_joycon(JoyconContext& context, const JsonArray& history);
+
+class RecordKeyboardController_Descriptor : public SingleSwitchProgramDescriptor{
+public:
+    RecordKeyboardController_Descriptor();
+};
+
+
+
+class RecordKeyboardController : public SingleSwitchProgramInstance, public KeyboardEventHandler::KeyboardListener{ 
+public:
+    ~RecordKeyboardController();
+    RecordKeyboardController();
+    
+
+    virtual void program(SingleSwitchProgramEnvironment& env, CancellableScope& scope) override;
+
+private:
+    // whenever a keyboard command is sent/stopped: 
+    // add to m_controller_history the time_stamp and the ControllerState serialized to JSON.
+    virtual void on_keyboard_command_sent(WallClock time_stamp, const ControllerState& state) override;
+    virtual void on_keyboard_command_stopped(WallClock time_stamp) override;
+
+    // convert m_controller_history to json
+    // remove adjacent duplicate controller states.
+    JsonValue controller_history_to_json(Logger& logger, ControllerClass controller_class);
+
+
+    // Examples for JsonObject controller_state:
+    // ProControllerState:
+        // {
+        //     "is_neutral": false
+        //     "buttons": "L R",
+        //     "dpad": "none",
+        //     "left_x": 100,
+        //     "left_y": 200,
+        //     "right_x": 128,
+        //     "right_y": 128,
+        // }
+    // JoyconState
+        // {
+        //     "is_neutral": false
+        //     "buttons": "L R",
+        //     "joystick_x": 100,
+        //     "joystick_x": 200,
+        // }
+    // Neutral controller: we know the controller is neutral, so no need for all the other button info
+        // {
+        //     "is_neutral": true
+        // }
+    struct ControllerStateSnapshot {
+        WallClock time_stamp;
+        JsonObject controller_state;
+    };
+
+private:
+    enum class Mode{
+        RECORD,
+        REPLAY,
+        CONVERT_JSON_TO_CODE,
+    };
+    EnumDropdownOption<Mode> MODE;
+    StringOption FILE_NAME;
+    BooleanCheckBoxOption GENERATE_CPP_CODE_AFTER_RECORDING;
+
+    std::vector<ControllerStateSnapshot> m_controller_history;
+    
+
+};
+
+
+
+}
+}
+#endif
+
+
+