diff --git a/src/common/settings.h b/src/common/settings.h
index b1bddb8955..29b888f102 100644
--- a/src/common/settings.h
+++ b/src/common/settings.h
@@ -14,6 +14,7 @@
 #include <utility>
 #include <vector>
 
+#include <input_common/main.h>
 #include "common/common_types.h"
 #include "common/settings_input.h"
 
@@ -499,6 +500,7 @@ struct Values {
 
     // Controls
     InputSetting<std::array<PlayerInput, 10>> players;
+    std::shared_ptr<InputCommon::InputSubsystem> inputSubsystem = NULL;
 
     Setting<bool> use_docked_mode{true, "use_docked_mode"};
 
@@ -512,9 +514,14 @@ struct Values {
                                             "motion_device"};
     BasicSetting<std::string> udp_input_servers{"127.0.0.1:26760", "udp_input_servers"};
 
+    BasicSetting<bool> tas_enable{false, "tas_enable"};
+    BasicSetting<bool> tas_reset{ false, "tas_reset" };
+    BasicSetting<bool> tas_record{ false, "tas_record" };
+
     BasicSetting<bool> mouse_panning{false, "mouse_panning"};
     BasicRangedSetting<u8> mouse_panning_sensitivity{10, 1, 100, "mouse_panning_sensitivity"};
     BasicSetting<bool> mouse_enabled{false, "mouse_enabled"};
+
     std::string mouse_device;
     MouseButtonsRaw mouse_buttons;
 
diff --git a/src/input_common/CMakeLists.txt b/src/input_common/CMakeLists.txt
index c4283a9526..dd13d948f7 100644
--- a/src/input_common/CMakeLists.txt
+++ b/src/input_common/CMakeLists.txt
@@ -21,6 +21,10 @@ add_library(input_common STATIC
     mouse/mouse_poller.h
     sdl/sdl.cpp
     sdl/sdl.h
+    tas/tas_input.cpp
+    tas/tas_input.h
+    tas/tas_poller.cpp
+    tas/tas_poller.h
     udp/client.cpp
     udp/client.h
     udp/protocol.cpp
diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index ff23230f00..4f170493ec 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -13,6 +13,8 @@
 #include "input_common/motion_from_button.h"
 #include "input_common/mouse/mouse_input.h"
 #include "input_common/mouse/mouse_poller.h"
+#include "input_common/tas/tas_input.h"
+#include "input_common/tas/tas_poller.h"
 #include "input_common/touch_from_button.h"
 #include "input_common/udp/client.h"
 #include "input_common/udp/udp.h"
@@ -60,6 +62,12 @@ struct InputSubsystem::Impl {
         Input::RegisterFactory<Input::MotionDevice>("mouse", mousemotion);
         mousetouch = std::make_shared<MouseTouchFactory>(mouse);
         Input::RegisterFactory<Input::TouchDevice>("mouse", mousetouch);
+
+        tas = std::make_shared<TasInput::Tas>();
+        tasbuttons = std::make_shared<TasButtonFactory>(tas);
+        Input::RegisterFactory<Input::ButtonDevice>("tas", tasbuttons);
+        tasanalog = std::make_shared<TasAnalogFactory>(tas);
+        Input::RegisterFactory<Input::AnalogDevice>("tas", tasanalog);
     }
 
     void Shutdown() {
@@ -94,12 +102,19 @@ struct InputSubsystem::Impl {
         mouseanalog.reset();
         mousemotion.reset();
         mousetouch.reset();
+
+        Input::UnregisterFactory<Input::ButtonDevice>("tas");
+        Input::UnregisterFactory<Input::AnalogDevice>("tas");
+
+        tasbuttons.reset();
+        tasanalog.reset();
     }
 
     [[nodiscard]] std::vector<Common::ParamPackage> GetInputDevices() const {
         std::vector<Common::ParamPackage> devices = {
             Common::ParamPackage{{"display", "Any"}, {"class", "any"}},
             Common::ParamPackage{{"display", "Keyboard/Mouse"}, {"class", "keyboard"}},
+            Common::ParamPackage{{"display", "TAS"}, {"class", "tas"}},
         };
 #ifdef HAVE_SDL2
         auto sdl_devices = sdl->GetInputDevices();
@@ -120,6 +135,9 @@ struct InputSubsystem::Impl {
         if (params.Get("class", "") == "gcpad") {
             return gcadapter->GetAnalogMappingForDevice(params);
         }
+        if (params.Get("class", "") == "tas") {
+            return tas->GetAnalogMappingForDevice(params);
+        }
 #ifdef HAVE_SDL2
         if (params.Get("class", "") == "sdl") {
             return sdl->GetAnalogMappingForDevice(params);
@@ -136,6 +154,9 @@ struct InputSubsystem::Impl {
         if (params.Get("class", "") == "gcpad") {
             return gcadapter->GetButtonMappingForDevice(params);
         }
+        if (params.Get("class", "") == "tas") {
+            return tas->GetButtonMappingForDevice(params);
+        }
 #ifdef HAVE_SDL2
         if (params.Get("class", "") == "sdl") {
             return sdl->GetButtonMappingForDevice(params);
@@ -174,9 +195,12 @@ struct InputSubsystem::Impl {
     std::shared_ptr<MouseAnalogFactory> mouseanalog;
     std::shared_ptr<MouseMotionFactory> mousemotion;
     std::shared_ptr<MouseTouchFactory> mousetouch;
+    std::shared_ptr<TasButtonFactory> tasbuttons;
+    std::shared_ptr<TasAnalogFactory> tasanalog;
     std::shared_ptr<CemuhookUDP::Client> udp;
     std::shared_ptr<GCAdapter::Adapter> gcadapter;
     std::shared_ptr<MouseInput::Mouse> mouse;
+    std::shared_ptr<TasInput::Tas> tas;
 };
 
 InputSubsystem::InputSubsystem() : impl{std::make_unique<Impl>()} {}
@@ -207,6 +231,14 @@ const MouseInput::Mouse* InputSubsystem::GetMouse() const {
     return impl->mouse.get();
 }
 
+TasInput::Tas* InputSubsystem::GetTas() {
+    return impl->tas.get();
+}
+
+const TasInput::Tas* InputSubsystem::GetTas() const {
+    return impl->tas.get();
+}
+
 std::vector<Common::ParamPackage> InputSubsystem::GetInputDevices() const {
     return impl->GetInputDevices();
 }
@@ -287,6 +319,22 @@ const MouseTouchFactory* InputSubsystem::GetMouseTouch() const {
     return impl->mousetouch.get();
 }
 
+TasButtonFactory* InputSubsystem::GetTasButtons() {
+    return impl->tasbuttons.get();
+}
+
+const TasButtonFactory* InputSubsystem::GetTasButtons() const {
+    return impl->tasbuttons.get();
+}
+
+TasAnalogFactory* InputSubsystem::GetTasAnalogs() {
+    return impl->tasanalog.get();
+}
+
+const TasAnalogFactory* InputSubsystem::GetTasAnalogs() const {
+    return impl->tasanalog.get();
+}
+
 void InputSubsystem::ReloadInputDevices() {
     if (!impl->udp) {
         return;
diff --git a/src/input_common/main.h b/src/input_common/main.h
index 5d6f26385f..1d06fc5f51 100644
--- a/src/input_common/main.h
+++ b/src/input_common/main.h
@@ -29,6 +29,10 @@ namespace MouseInput {
 class Mouse;
 }
 
+namespace TasInput {
+class Tas;
+}
+
 namespace InputCommon {
 namespace Polling {
 
@@ -64,6 +68,8 @@ class MouseButtonFactory;
 class MouseAnalogFactory;
 class MouseMotionFactory;
 class MouseTouchFactory;
+class TasButtonFactory;
+class TasAnalogFactory;
 class Keyboard;
 
 /**
@@ -103,6 +109,11 @@ public:
     /// Retrieves the underlying mouse device.
     [[nodiscard]] const MouseInput::Mouse* GetMouse() const;
 
+    /// Retrieves the underlying tas device.
+    [[nodiscard]] TasInput::Tas* GetTas();
+
+    /// Retrieves the underlying tas device.
+    [[nodiscard]] const TasInput::Tas* GetTas() const;
     /**
      * Returns all available input devices that this Factory can create a new device with.
      * Each returned ParamPackage should have a `display` field used for display, a class field for
@@ -168,6 +179,18 @@ public:
     /// Retrieves the underlying udp touch handler.
     [[nodiscard]] const MouseTouchFactory* GetMouseTouch() const;
 
+    /// Retrieves the underlying tas button handler.
+    [[nodiscard]] TasButtonFactory* GetTasButtons();
+
+    /// Retrieves the underlying tas button handler.
+    [[nodiscard]] const TasButtonFactory* GetTasButtons() const;
+
+    /// Retrieves the underlying tas touch handler.
+    [[nodiscard]] TasAnalogFactory* GetTasAnalogs();
+
+    /// Retrieves the underlying tas touch handler.
+    [[nodiscard]] const TasAnalogFactory* GetTasAnalogs() const;
+
     /// Reloads the input devices
     void ReloadInputDevices();
 
diff --git a/src/input_common/tas/tas_input.cpp b/src/input_common/tas/tas_input.cpp
new file mode 100644
index 0000000000..343641945d
--- /dev/null
+++ b/src/input_common/tas/tas_input.cpp
@@ -0,0 +1,340 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include <chrono>
+#include <cstring>
+#include <functional>
+#include <random>
+#include <regex>
+#include <thread>
+#include <boost/asio.hpp>
+
+#include "common/fs/file.h"
+#include "common/fs/fs_types.h"
+#include "common/fs/path_util.h"
+#include "common/logging/log.h"
+#include "common/settings.h"
+#include "input_common/tas/tas_input.h"
+
+namespace TasInput {
+
+Tas::Tas() {
+    LoadTasFiles();
+}
+
+Tas::~Tas() {
+    update_thread_running = false;
+}
+
+void Tas::RefreshTasFile() {
+    refresh_tas_fle = true;
+}
+void Tas::LoadTasFiles() {
+    scriptLength = 0;
+    for (int i = 0; i < PLAYER_NUMBER; i++) {
+        LoadTasFile(i);
+        if (newCommands[i].size() > scriptLength)
+            scriptLength = newCommands[i].size();
+    }
+}
+void Tas::LoadTasFile(int playerIndex) {
+    LOG_DEBUG(Input, "LoadTasFile()");
+    if (!newCommands[playerIndex].empty()) {
+        newCommands[playerIndex].clear();
+    }
+    std::string file = Common::FS::ReadStringFromFile(
+        Common::FS::GetYuzuPathString(Common::FS::YuzuPath::TASFile) + "script0-" +
+            std::to_string(playerIndex + 1) + ".txt",
+        Common::FS::FileType::BinaryFile);
+    std::stringstream command_line(file);
+    std::string line;
+    int frameNo = 0;
+    TASCommand empty = {.buttons = 0, .l_axis = {0.f, 0.f}, .r_axis = {0.f, 0.f}};
+    while (std::getline(command_line, line, '\n')) {
+        if (line.empty())
+            continue;
+        LOG_DEBUG(Input, "Loading line: {}", line);
+        std::smatch m;
+
+        std::stringstream linestream(line);
+        std::string segment;
+        std::vector<std::string> seglist;
+
+        while (std::getline(linestream, segment, ' ')) {
+            seglist.push_back(segment);
+        }
+
+        if (seglist.size() < 4)
+            continue;
+
+        while (frameNo < std::stoi(seglist.at(0))) {
+            newCommands[playerIndex].push_back(empty);
+            frameNo++;
+        }
+
+        TASCommand command = {
+            .buttons = ReadCommandButtons(seglist.at(1)),
+            .l_axis = ReadCommandAxis(seglist.at(2)),
+            .r_axis = ReadCommandAxis(seglist.at(3)),
+        };
+        newCommands[playerIndex].push_back(command);
+        frameNo++;
+    }
+    LOG_INFO(Input, "TAS file loaded! {} frames", frameNo);
+}
+
+void Tas::WriteTasFile() {
+    LOG_DEBUG(Input, "WriteTasFile()");
+    std::string output_text = "";
+    for (int frame = 0; frame < (signed)recordCommands.size(); frame++) {
+        if (!output_text.empty())
+            output_text += "\n";
+        TASCommand line = recordCommands.at(frame);
+        output_text += std::to_string(frame) + " " + WriteCommandButtons(line.buttons) + " " +
+                       WriteCommandAxis(line.l_axis) + " " + WriteCommandAxis(line.r_axis);
+    }
+    size_t bytesWritten = Common::FS::WriteStringToFile(
+        Common::FS::GetYuzuPathString(Common::FS::YuzuPath::TASFile) + "record.txt",
+        Common::FS::FileType::TextFile, output_text);
+    if (bytesWritten == output_text.size())
+        LOG_INFO(Input, "TAS file written to file!");
+    else
+        LOG_ERROR(Input, "Writing the TAS-file has failed! {} / {} bytes written", bytesWritten,
+                  output_text.size());
+}
+
+void Tas::RecordInput(u32 buttons, std::array<std::pair<float, float>, 2> axes) {
+    lastInput = {buttons, flipY(axes[0]), flipY(axes[1])};
+}
+
+std::pair<float, float> Tas::flipY(std::pair<float, float> old) const {
+    auto [x, y] = old;
+    return {x, -y};
+}
+
+std::string Tas::GetStatusDescription() {
+    if (Settings::values.tas_record) {
+        return "Recording TAS: " + std::to_string(recordCommands.size());
+    }
+    if (Settings::values.tas_enable) {
+        return "Playing TAS: " + std::to_string(current_command) + "/" +
+               std::to_string(scriptLength);
+    }
+    return "TAS not running: " + std::to_string(current_command) + "/" +
+           std::to_string(scriptLength);
+}
+
+std::string debugButtons(u32 buttons) {
+    return "{ " + TasInput::Tas::buttonsToString(buttons) + " }";
+}
+
+std::string debugJoystick(float x, float y) {
+    return "[ " + std::to_string(x) + "," + std::to_string(y) + " ]";
+}
+
+std::string debugInput(TasData data) {
+    return "{ " + debugButtons(data.buttons) + " , " + debugJoystick(data.axis[0], data.axis[1]) +
+           " , " + debugJoystick(data.axis[2], data.axis[3]) + " }";
+}
+
+std::string debugInputs(std::array<TasData, PLAYER_NUMBER> arr) {
+    std::string returns = "[ ";
+    for (size_t i = 0; i < arr.size(); i++) {
+        returns += debugInput(arr[i]);
+        if (i != arr.size() - 1)
+            returns += " , ";
+    }
+    return returns + "]";
+}
+
+void Tas::UpdateThread() {
+    if (update_thread_running) {
+        if (Settings::values.pauseTasOnLoad && Settings::values.cpuBoosted) {
+            for (int i = 0; i < PLAYER_NUMBER; i++) {
+                tas_data[i].buttons = 0;
+                tas_data[i].axis = {};
+            }
+        }
+
+        if (Settings::values.tas_record) {
+            recordCommands.push_back(lastInput);
+        }
+        if (!Settings::values.tas_record && !recordCommands.empty()) {
+            WriteTasFile();
+            Settings::values.tas_reset = true;
+            refresh_tas_fle = true;
+            recordCommands.clear();
+        }
+        if (Settings::values.tas_reset) {
+            current_command = 0;
+            if (refresh_tas_fle) {
+                LoadTasFiles();
+                refresh_tas_fle = false;
+            }
+            Settings::values.tas_reset = false;
+            LoadTasFiles();
+            LOG_DEBUG(Input, "tas_reset done");
+        }
+        if (Settings::values.tas_enable) {
+            if ((signed)current_command < scriptLength) {
+                LOG_INFO(Input, "Playing TAS {}/{}", current_command, scriptLength);
+                size_t frame = current_command++;
+                for (int i = 0; i < PLAYER_NUMBER; i++) {
+                    if (frame < newCommands[i].size()) {
+                        TASCommand command = newCommands[i][frame];
+                        tas_data[i].buttons = command.buttons;
+                        auto [l_axis_x, l_axis_y] = command.l_axis;
+                        tas_data[i].axis[0] = l_axis_x;
+                        tas_data[i].axis[1] = l_axis_y;
+                        auto [r_axis_x, r_axis_y] = command.r_axis;
+                        tas_data[i].axis[2] = r_axis_x;
+                        tas_data[i].axis[3] = r_axis_y;
+                    } else {
+                        tas_data[i].buttons = 0;
+                        tas_data[i].axis = {};
+                    }
+                }
+            } else {
+                Settings::values.tas_enable = false;
+                current_command = 0;
+                for (int i = 0; i < PLAYER_NUMBER; i++) {
+                    tas_data[i].buttons = 0;
+                    tas_data[i].axis = {};
+                }
+            }
+        } else {
+            for (int i = 0; i < PLAYER_NUMBER; i++) {
+                tas_data[i].buttons = 0;
+                tas_data[i].axis = {};
+            }
+        }
+    }
+    LOG_DEBUG(Input, "TAS inputs: {}", debugInputs(tas_data));
+}
+
+TasAnalog Tas::ReadCommandAxis(const std::string line) const {
+    std::stringstream linestream(line);
+    std::string segment;
+    std::vector<std::string> seglist;
+
+    while (std::getline(linestream, segment, ';')) {
+        seglist.push_back(segment);
+    }
+
+    const float x = std::stof(seglist.at(0)) / 32767.f;
+    const float y = std::stof(seglist.at(1)) / 32767.f;
+
+    return {x, y};
+}
+
+u32 Tas::ReadCommandButtons(const std::string data) const {
+    std::stringstream button_text(data);
+    std::string line;
+    u32 buttons = 0;
+    while (std::getline(button_text, line, ';')) {
+        for (auto [text, tas_button] : text_to_tas_button) {
+            if (text == line) {
+                buttons |= static_cast<u32>(tas_button);
+                break;
+            }
+        }
+    }
+    return buttons;
+}
+
+std::string Tas::WriteCommandAxis(TasAnalog data) const {
+    auto [x, y] = data;
+    std::string line;
+    line += std::to_string(static_cast<int>(x * 32767));
+    line += ";";
+    line += std::to_string(static_cast<int>(y * 32767));
+    return line;
+}
+
+std::string Tas::WriteCommandButtons(u32 data) const {
+    if (data == 0)
+        return "NONE";
+
+    std::string line;
+    u32 index = 0;
+    while (data > 0) {
+        if ((data & 1) == 1) {
+            for (auto [text, tas_button] : text_to_tas_button) {
+                if (tas_button == static_cast<TasButton>(1 << index)) {
+                    if (line.size() > 0)
+                        line += ";";
+                    line += text;
+                    break;
+                }
+            }
+        }
+        index++;
+        data >>= 1;
+    }
+    return line;
+}
+
+InputCommon::ButtonMapping Tas::GetButtonMappingForDevice(
+    const Common::ParamPackage& params) const {
+    // This list is missing ZL/ZR since those are not considered buttons.
+    // We will add those afterwards
+    // This list also excludes any button that can't be really mapped
+    static constexpr std::array<std::pair<Settings::NativeButton::Values, TasButton>, 20>
+        switch_to_tas_button = {
+            std::pair{Settings::NativeButton::A, TasButton::BUTTON_A},
+            {Settings::NativeButton::B, TasButton::BUTTON_B},
+            {Settings::NativeButton::X, TasButton::BUTTON_X},
+            {Settings::NativeButton::Y, TasButton::BUTTON_Y},
+            {Settings::NativeButton::LStick, TasButton::STICK_L},
+            {Settings::NativeButton::RStick, TasButton::STICK_R},
+            {Settings::NativeButton::L, TasButton::TRIGGER_L},
+            {Settings::NativeButton::R, TasButton::TRIGGER_R},
+            {Settings::NativeButton::Plus, TasButton::BUTTON_PLUS},
+            {Settings::NativeButton::Minus, TasButton::BUTTON_MINUS},
+            {Settings::NativeButton::DLeft, TasButton::BUTTON_LEFT},
+            {Settings::NativeButton::DUp, TasButton::BUTTON_UP},
+            {Settings::NativeButton::DRight, TasButton::BUTTON_RIGHT},
+            {Settings::NativeButton::DDown, TasButton::BUTTON_DOWN},
+            {Settings::NativeButton::SL, TasButton::BUTTON_SL},
+            {Settings::NativeButton::SR, TasButton::BUTTON_SR},
+            {Settings::NativeButton::Screenshot, TasButton::BUTTON_CAPTURE},
+            {Settings::NativeButton::Home, TasButton::BUTTON_HOME},
+            {Settings::NativeButton::ZL, TasButton::TRIGGER_ZL},
+            {Settings::NativeButton::ZR, TasButton::TRIGGER_ZR},
+        };
+
+    InputCommon::ButtonMapping mapping{};
+    for (const auto& [switch_button, tas_button] : switch_to_tas_button) {
+        Common::ParamPackage button_params({{"engine", "tas"}});
+        button_params.Set("pad", params.Get("pad", 0));
+        button_params.Set("button", static_cast<int>(tas_button));
+        mapping.insert_or_assign(switch_button, std::move(button_params));
+    }
+
+    return mapping;
+}
+
+InputCommon::AnalogMapping Tas::GetAnalogMappingForDevice(
+    const Common::ParamPackage& params) const {
+
+    InputCommon::AnalogMapping mapping = {};
+    Common::ParamPackage left_analog_params;
+    left_analog_params.Set("engine", "tas");
+    left_analog_params.Set("pad", params.Get("pad", 0));
+    left_analog_params.Set("axis_x", static_cast<int>(TasAxes::StickX));
+    left_analog_params.Set("axis_y", static_cast<int>(TasAxes::StickY));
+    mapping.insert_or_assign(Settings::NativeAnalog::LStick, std::move(left_analog_params));
+    Common::ParamPackage right_analog_params;
+    right_analog_params.Set("engine", "tas");
+    right_analog_params.Set("pad", params.Get("pad", 0));
+    right_analog_params.Set("axis_x", static_cast<int>(TasAxes::SubstickX));
+    right_analog_params.Set("axis_y", static_cast<int>(TasAxes::SubstickY));
+    mapping.insert_or_assign(Settings::NativeAnalog::RStick, std::move(right_analog_params));
+    return mapping;
+}
+
+const TasData& Tas::GetTasState(std::size_t pad) const {
+    return tas_data[pad];
+}
+} // namespace TasInput
diff --git a/src/input_common/tas/tas_input.h b/src/input_common/tas/tas_input.h
new file mode 100644
index 0000000000..0a152a04fa
--- /dev/null
+++ b/src/input_common/tas/tas_input.h
@@ -0,0 +1,163 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <mutex>
+#include <thread>
+
+#include "common/common_types.h"
+#include "core/frontend/input.h"
+#include "input_common/main.h"
+
+#define PLAYER_NUMBER 8
+
+namespace TasInput {
+
+using TasAnalog = std::tuple<float, float>;
+
+enum class TasButton : u32 {
+    BUTTON_A = 0x000001,
+    BUTTON_B = 0x000002,
+    BUTTON_X = 0x000004,
+    BUTTON_Y = 0x000008,
+    STICK_L = 0x000010,
+    STICK_R = 0x000020,
+    TRIGGER_L = 0x000040,
+    TRIGGER_R = 0x000080,
+    TRIGGER_ZL = 0x000100,
+    TRIGGER_ZR = 0x000200,
+    BUTTON_PLUS = 0x000400,
+    BUTTON_MINUS = 0x000800,
+    BUTTON_LEFT = 0x001000,
+    BUTTON_UP = 0x002000,
+    BUTTON_RIGHT = 0x004000,
+    BUTTON_DOWN = 0x008000,
+    BUTTON_SL = 0x010000,
+    BUTTON_SR = 0x020000,
+    BUTTON_HOME = 0x040000,
+    BUTTON_CAPTURE = 0x080000,
+};
+
+static const std::array<std::pair<std::string, TasButton>, 20> text_to_tas_button = {
+    std::pair{"KEY_A", TasButton::BUTTON_A},
+    {"KEY_B", TasButton::BUTTON_B},
+    {"KEY_X", TasButton::BUTTON_X},
+    {"KEY_Y", TasButton::BUTTON_Y},
+    {"KEY_LSTICK", TasButton::STICK_L},
+    {"KEY_RSTICK", TasButton::STICK_R},
+    {"KEY_L", TasButton::TRIGGER_L},
+    {"KEY_R", TasButton::TRIGGER_R},
+    {"KEY_PLUS", TasButton::BUTTON_PLUS},
+    {"KEY_MINUS", TasButton::BUTTON_MINUS},
+    {"KEY_DLEFT", TasButton::BUTTON_LEFT},
+    {"KEY_DUP", TasButton::BUTTON_UP},
+    {"KEY_DRIGHT", TasButton::BUTTON_RIGHT},
+    {"KEY_DDOWN", TasButton::BUTTON_DOWN},
+    {"KEY_SL", TasButton::BUTTON_SL},
+    {"KEY_SR", TasButton::BUTTON_SR},
+    {"KEY_CAPTURE", TasButton::BUTTON_CAPTURE},
+    {"KEY_HOME", TasButton::BUTTON_HOME},
+    {"KEY_ZL", TasButton::TRIGGER_ZL},
+    {"KEY_ZR", TasButton::TRIGGER_ZR},
+};
+
+enum class TasAxes : u8 {
+    StickX,
+    StickY,
+    SubstickX,
+    SubstickY,
+    Undefined,
+};
+
+struct TasData {
+    u32 buttons{};
+    std::array<float, 4> axis{};
+};
+
+class Tas {
+public:
+    Tas();
+    ~Tas();
+
+    static std::string buttonsToString(u32 button) {
+        std::string returns;
+        if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_A)) != 0)
+            returns += ", A";
+        if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_B)) != 0)
+            returns += ", B";
+        if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_X)) != 0)
+            returns += ", X";
+        if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_Y)) != 0)
+            returns += ", Y";
+        if ((button & static_cast<u32>(TasInput::TasButton::STICK_L)) != 0)
+            returns += ", STICK_L";
+        if ((button & static_cast<u32>(TasInput::TasButton::STICK_R)) != 0)
+            returns += ", STICK_R";
+        if ((button & static_cast<u32>(TasInput::TasButton::TRIGGER_L)) != 0)
+            returns += ", TRIGGER_L";
+        if ((button & static_cast<u32>(TasInput::TasButton::TRIGGER_R)) != 0)
+            returns += ", TRIGGER_R";
+        if ((button & static_cast<u32>(TasInput::TasButton::TRIGGER_ZL)) != 0)
+            returns += ", TRIGGER_ZL";
+        if ((button & static_cast<u32>(TasInput::TasButton::TRIGGER_ZR)) != 0)
+            returns += ", TRIGGER_ZR";
+        if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_PLUS)) != 0)
+            returns += ", PLUS";
+        if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_MINUS)) != 0)
+            returns += ", MINUS";
+        if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_LEFT)) != 0)
+            returns += ", LEFT";
+        if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_UP)) != 0)
+            returns += ", UP";
+        if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_RIGHT)) != 0)
+            returns += ", RIGHT";
+        if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_DOWN)) != 0)
+            returns += ", DOWN";
+        if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_SL)) != 0)
+            returns += ", SL";
+        if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_SR)) != 0)
+            returns += ", SR";
+        if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_HOME)) != 0)
+            returns += ", HOME";
+        if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_CAPTURE)) != 0)
+            returns += ", CAPTURE";
+        return returns.length() != 0 ? returns.substr(2) : "";
+    }
+
+    void RefreshTasFile();
+    void LoadTasFiles();
+    void RecordInput(u32 buttons, std::array<std::pair<float, float>, 2> axes);
+    void UpdateThread();
+    std::string GetStatusDescription();
+
+    InputCommon::ButtonMapping GetButtonMappingForDevice(const Common::ParamPackage& params) const;
+    InputCommon::AnalogMapping GetAnalogMappingForDevice(const Common::ParamPackage& params) const;
+    [[nodiscard]] const TasData& GetTasState(std::size_t pad) const;
+
+private:
+    struct TASCommand {
+        u32 buttons{};
+        TasAnalog l_axis{};
+        TasAnalog r_axis{};
+    };
+    void LoadTasFile(int playerIndex);
+    void WriteTasFile();
+    TasAnalog ReadCommandAxis(const std::string line) const;
+    u32 ReadCommandButtons(const std::string line) const;
+    std::string WriteCommandButtons(u32 data) const;
+    std::string WriteCommandAxis(TasAnalog data) const;
+    std::pair<float, float> flipY(std::pair<float, float> old) const;
+
+    size_t scriptLength{0};
+    std::array<TasData, PLAYER_NUMBER> tas_data;
+    bool update_thread_running{true};
+    bool refresh_tas_fle{false};
+    std::array<std::vector<TASCommand>, PLAYER_NUMBER> newCommands{};
+    std::vector<TASCommand> recordCommands{};
+    std::size_t current_command{0};
+    TASCommand lastInput{}; // only used for recording
+};
+} // namespace TasInput
diff --git a/src/input_common/tas/tas_poller.cpp b/src/input_common/tas/tas_poller.cpp
new file mode 100644
index 0000000000..15810d6b0d
--- /dev/null
+++ b/src/input_common/tas/tas_poller.cpp
@@ -0,0 +1,101 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <mutex>
+#include <utility>
+
+#include "common/settings.h"
+#include "common/threadsafe_queue.h"
+#include "input_common/tas/tas_input.h"
+#include "input_common/tas/tas_poller.h"
+
+namespace InputCommon {
+
+class TasButton final : public Input::ButtonDevice {
+public:
+    explicit TasButton(u32 button_, u32 pad_, const TasInput::Tas* tas_input_)
+        : button(button_), pad(pad_), tas_input(tas_input_) {}
+
+    bool GetStatus() const override {
+        return (tas_input->GetTasState(pad).buttons & button) != 0;
+    }
+
+private:
+    const u32 button;
+    const u32 pad;
+    const TasInput::Tas* tas_input;
+};
+
+TasButtonFactory::TasButtonFactory(std::shared_ptr<TasInput::Tas> tas_input_)
+    : tas_input(std::move(tas_input_)) {}
+
+std::unique_ptr<Input::ButtonDevice> TasButtonFactory::Create(const Common::ParamPackage& params) {
+    const auto button_id = params.Get("button", 0);
+    const auto pad = params.Get("pad", 0);
+
+    return std::make_unique<TasButton>(button_id, pad, tas_input.get());
+}
+
+class TasAnalog final : public Input::AnalogDevice {
+public:
+    explicit TasAnalog(u32 pad_, u32 axis_x_, u32 axis_y_, const TasInput::Tas* tas_input_)
+        : pad(pad_), axis_x(axis_x_), axis_y(axis_y_), tas_input(tas_input_) {}
+
+    float GetAxis(u32 axis) const {
+        std::lock_guard lock{mutex};
+        return tas_input->GetTasState(pad).axis.at(axis);
+    }
+
+    std::pair<float, float> GetAnalog(u32 analog_axis_x, u32 analog_axis_y) const {
+        float x = GetAxis(analog_axis_x);
+        float y = GetAxis(analog_axis_y);
+
+        // Make sure the coordinates are in the unit circle,
+        // otherwise normalize it.
+        float r = x * x + y * y;
+        if (r > 1.0f) {
+            r = std::sqrt(r);
+            x /= r;
+            y /= r;
+        }
+
+        return {x, y};
+    }
+
+    std::tuple<float, float> GetStatus() const override {
+        return GetAnalog(axis_x, axis_y);
+    }
+
+    Input::AnalogProperties GetAnalogProperties() const override {
+        return {0.0f, 1.0f, 0.5f};
+    }
+
+private:
+    const u32 pad;
+    const u32 axis_x;
+    const u32 axis_y;
+    const TasInput::Tas* tas_input;
+    mutable std::mutex mutex;
+};
+
+/// An analog device factory that creates analog devices from GC Adapter
+TasAnalogFactory::TasAnalogFactory(std::shared_ptr<TasInput::Tas> tas_input_)
+    : tas_input(std::move(tas_input_)) {}
+
+/**
+ * Creates analog device from joystick axes
+ * @param params contains parameters for creating the device:
+ *     - "port": the nth gcpad on the adapter
+ *     - "axis_x": the index of the axis to be bind as x-axis
+ *     - "axis_y": the index of the axis to be bind as y-axis
+ */
+std::unique_ptr<Input::AnalogDevice> TasAnalogFactory::Create(const Common::ParamPackage& params) {
+    const auto pad = static_cast<u32>(params.Get("pad", 0));
+    const auto axis_x = static_cast<u32>(params.Get("axis_x", 0));
+    const auto axis_y = static_cast<u32>(params.Get("axis_y", 1));
+
+    return std::make_unique<TasAnalog>(pad, axis_x, axis_y, tas_input.get());
+}
+
+} // namespace InputCommon
diff --git a/src/input_common/tas/tas_poller.h b/src/input_common/tas/tas_poller.h
new file mode 100644
index 0000000000..1bc0d173ba
--- /dev/null
+++ b/src/input_common/tas/tas_poller.h
@@ -0,0 +1,43 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include "core/frontend/input.h"
+#include "input_common/tas/tas_input.h"
+
+namespace InputCommon {
+
+/**
+ * A button device factory representing a mouse. It receives mouse events and forward them
+ * to all button devices it created.
+ */
+class TasButtonFactory final : public Input::Factory<Input::ButtonDevice> {
+public:
+    explicit TasButtonFactory(std::shared_ptr<TasInput::Tas> tas_input_);
+
+    /**
+     * Creates a button device from a button press
+     * @param params contains parameters for creating the device:
+     *     - "code": the code of the key to bind with the button
+     */
+    std::unique_ptr<Input::ButtonDevice> Create(const Common::ParamPackage& params) override;
+
+private:
+    std::shared_ptr<TasInput::Tas> tas_input;
+};
+
+/// An analog device factory that creates analog devices from mouse
+class TasAnalogFactory final : public Input::Factory<Input::AnalogDevice> {
+public:
+    explicit TasAnalogFactory(std::shared_ptr<TasInput::Tas> tas_input_);
+
+    std::unique_ptr<Input::AnalogDevice> Create(const Common::ParamPackage& params) override;
+
+private:
+    std::shared_ptr<TasInput::Tas> tas_input;
+};
+
+} // namespace InputCommon
diff --git a/src/yuzu/configuration/configure_input_player.cpp b/src/yuzu/configuration/configure_input_player.cpp
index 7527c068b9..88f4bf388a 100644
--- a/src/yuzu/configuration/configure_input_player.cpp
+++ b/src/yuzu/configuration/configure_input_player.cpp
@@ -124,6 +124,19 @@ QString ButtonToText(const Common::ParamPackage& param) {
         return GetKeyName(param.Get("code", 0));
     }
 
+    if (param.Get("engine", "") == "tas") {
+        if (param.Has("axis")) {
+            const QString axis_str = QString::fromStdString(param.Get("axis", ""));
+
+            return QObject::tr("TAS Axis %1").arg(axis_str);
+        }
+        if (param.Has("button")) {
+            const QString button_str = QString::number(int(std::log2(param.Get("button", 0))));
+            return QObject::tr("TAS Btn %1").arg(button_str);
+        }
+        return GetKeyName(param.Get("code", 0));
+    }
+
     if (param.Get("engine", "") == "cemuhookudp") {
         if (param.Has("pad_index")) {
             const QString motion_str = QString::fromStdString(param.Get("pad_index", ""));
@@ -187,7 +200,8 @@ QString AnalogToText(const Common::ParamPackage& param, const std::string& dir)
     const QString axis_y_str = QString::fromStdString(param.Get("axis_y", ""));
     const bool invert_x = param.Get("invert_x", "+") == "-";
     const bool invert_y = param.Get("invert_y", "+") == "-";
-    if (engine_str == "sdl" || engine_str == "gcpad" || engine_str == "mouse") {
+    if (engine_str == "sdl" || engine_str == "gcpad" || engine_str == "mouse" ||
+        engine_str == "tas") {
         if (dir == "modifier") {
             return QObject::tr("[unused]");
         }
@@ -926,9 +940,9 @@ void ConfigureInputPlayer::UpdateUI() {
 
         int slider_value;
         auto& param = analogs_param[analog_id];
-        const bool is_controller = param.Get("engine", "") == "sdl" ||
-                                   param.Get("engine", "") == "gcpad" ||
-                                   param.Get("engine", "") == "mouse";
+        const bool is_controller =
+            param.Get("engine", "") == "sdl" || param.Get("engine", "") == "gcpad" ||
+            param.Get("engine", "") == "mouse" || param.Get("engine", "") == "tas";
 
         if (is_controller) {
             if (!param.Has("deadzone")) {
@@ -1045,8 +1059,12 @@ int ConfigureInputPlayer::GetIndexFromControllerType(Settings::ControllerType ty
 void ConfigureInputPlayer::UpdateInputDevices() {
     input_devices = input_subsystem->GetInputDevices();
     ui->comboDevices->clear();
-    for (auto device : input_devices) {
-        ui->comboDevices->addItem(QString::fromStdString(device.Get("display", "Unknown")), {});
+    for (auto& device : input_devices) {
+        const std::string display = device.Get("display", "Unknown");
+        ui->comboDevices->addItem(QString::fromStdString(display), {});
+        if (display == "TAS") {
+            device.Set("pad", static_cast<u8>(player_index));
+        }
     }
 }
 
diff --git a/src/yuzu/configuration/configure_input_player_widget.cpp b/src/yuzu/configuration/configure_input_player_widget.cpp
index 9c890ed5da..e649e2169b 100644
--- a/src/yuzu/configuration/configure_input_player_widget.cpp
+++ b/src/yuzu/configuration/configure_input_player_widget.cpp
@@ -220,8 +220,20 @@ void PlayerControlPreview::UpdateInput() {
         }
     }
 
+    ControllerInput input{};
     if (input_changed) {
         update();
+        input.changed = true;
+    }
+    input.axis_values[Settings::NativeAnalog::LStick] = {
+        axis_values[Settings::NativeAnalog::LStick].value.x(),
+        axis_values[Settings::NativeAnalog::LStick].value.y()};
+    input.axis_values[Settings::NativeAnalog::RStick] = {
+        axis_values[Settings::NativeAnalog::RStick].value.x(),
+        axis_values[Settings::NativeAnalog::RStick].value.y()};
+    input.button_values = button_values;
+    if (controller_callback.input != NULL) {
+        controller_callback.input(std::move(input));
     }
 
     if (mapping_active) {
@@ -229,6 +241,10 @@ void PlayerControlPreview::UpdateInput() {
     }
 }
 
+void PlayerControlPreview::SetCallBack(ControllerCallback callback_) {
+    controller_callback = callback_;
+}
+
 void PlayerControlPreview::paintEvent(QPaintEvent* event) {
     QFrame::paintEvent(event);
     QPainter p(this);
diff --git a/src/yuzu/configuration/configure_input_player_widget.h b/src/yuzu/configuration/configure_input_player_widget.h
index f4a6a5e1b2..f4bbfa5281 100644
--- a/src/yuzu/configuration/configure_input_player_widget.h
+++ b/src/yuzu/configuration/configure_input_player_widget.h
@@ -9,6 +9,7 @@
 #include <QPointer>
 #include "common/settings.h"
 #include "core/frontend/input.h"
+#include "yuzu/debugger/controller.h"
 
 class QLabel;
 
@@ -33,6 +34,7 @@ public:
     void BeginMappingAnalog(std::size_t button_id);
     void EndMapping();
     void UpdateInput();
+    void SetCallBack(ControllerCallback callback_);
 
 protected:
     void paintEvent(QPaintEvent* event) override;
@@ -181,6 +183,7 @@ private:
     using StickArray =
         std::array<std::unique_ptr<Input::AnalogDevice>, Settings::NativeAnalog::NUM_STICKS_HID>;
 
+    ControllerCallback controller_callback;
     bool is_enabled{};
     bool mapping_active{};
     int blink_counter{};
diff --git a/src/yuzu/debugger/controller.cpp b/src/yuzu/debugger/controller.cpp
index c1fc695782..822d033d1e 100644
--- a/src/yuzu/debugger/controller.cpp
+++ b/src/yuzu/debugger/controller.cpp
@@ -6,10 +6,13 @@
 #include <QLayout>
 #include <QString>
 #include "common/settings.h"
+#include "input_common/main.h"
+#include "input_common/tas/tas_input.h"
 #include "yuzu/configuration/configure_input_player_widget.h"
 #include "yuzu/debugger/controller.h"
 
-ControllerDialog::ControllerDialog(QWidget* parent) : QWidget(parent, Qt::Dialog) {
+ControllerDialog::ControllerDialog(QWidget* parent, InputCommon::InputSubsystem* input_subsystem_)
+    : QWidget(parent, Qt::Dialog), input_subsystem{input_subsystem_} {
     setObjectName(QStringLiteral("Controller"));
     setWindowTitle(tr("Controller P1"));
     resize(500, 350);
@@ -38,6 +41,9 @@ void ControllerDialog::refreshConfiguration() {
     constexpr std::size_t player = 0;
     widget->SetPlayerInputRaw(player, players[player].buttons, players[player].analogs);
     widget->SetControllerType(players[player].controller_type);
+    ControllerCallback callback{[this](ControllerInput input) { InputController(input); }};
+    widget->SetCallBack(callback);
+    widget->repaint();
     widget->SetConnectedStatus(players[player].connected);
 }
 
@@ -67,3 +73,17 @@ void ControllerDialog::hideEvent(QHideEvent* ev) {
     widget->SetConnectedStatus(false);
     QWidget::hideEvent(ev);
 }
+
+void ControllerDialog::RefreshTasFile() {
+    input_subsystem->GetTas()->RefreshTasFile();
+}
+
+void ControllerDialog::InputController(ControllerInput input) {
+    u32 buttons = 0;
+    int index = 0;
+    for (bool btn : input.button_values) {
+        buttons += (btn ? 1 : 0) << index;
+        index++;
+    }
+    input_subsystem->GetTas()->RecordInput(buttons, input.axis_values);
+}
\ No newline at end of file
diff --git a/src/yuzu/debugger/controller.h b/src/yuzu/debugger/controller.h
index c547500707..659923e1ba 100644
--- a/src/yuzu/debugger/controller.h
+++ b/src/yuzu/debugger/controller.h
@@ -4,18 +4,36 @@
 
 #pragma once
 
+#include <QFileSystemWatcher>
 #include <QWidget>
+#include "common/settings.h"
 
 class QAction;
 class QHideEvent;
 class QShowEvent;
 class PlayerControlPreview;
 
+namespace InputCommon {
+class InputSubsystem;
+}
+
+struct ControllerInput {
+    std::array<std::pair<float, float>, Settings::NativeAnalog::NUM_STICKS_HID> axis_values{};
+    std::array<bool, Settings::NativeButton::NumButtons> button_values{};
+    bool changed{};
+};
+
+struct ControllerCallback {
+    std::function<void(ControllerInput)> input;
+    std::function<void()> update;
+};
+
 class ControllerDialog : public QWidget {
     Q_OBJECT
 
 public:
-    explicit ControllerDialog(QWidget* parent = nullptr);
+    explicit ControllerDialog(QWidget* parent = nullptr,
+                              InputCommon::InputSubsystem* input_subsystem_ = nullptr);
 
     /// Returns a QAction that can be used to toggle visibility of this dialog.
     QAction* toggleViewAction();
@@ -26,6 +44,10 @@ protected:
     void hideEvent(QHideEvent* ev) override;
 
 private:
+    void RefreshTasFile();
+    void InputController(ControllerInput input);
     QAction* toggle_view_action = nullptr;
+    QFileSystemWatcher* watcher = nullptr;
     PlayerControlPreview* widget;
+    InputCommon::InputSubsystem* input_subsystem;
 };
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index f4e49001d7..22489231b7 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -193,6 +193,7 @@ GMainWindow::GMainWindow()
       config{std::make_unique<Config>()}, vfs{std::make_shared<FileSys::RealVfsFilesystem>()},
       provider{std::make_unique<FileSys::ManualContentProvider>()} {
     Common::Log::Initialize();
+    Settings::values.inputSubsystem = input_subsystem;
     LoadTranslation();
 
     setAcceptDrops(true);
@@ -841,7 +842,7 @@ void GMainWindow::InitializeDebugWidgets() {
     waitTreeWidget->hide();
     debug_menu->addAction(waitTreeWidget->toggleViewAction());
 
-    controller_dialog = new ControllerDialog(this);
+    controller_dialog = new ControllerDialog(this, input_subsystem.get());
     controller_dialog->hide();
     debug_menu->addAction(controller_dialog->toggleViewAction());