diff --git a/Base/limine.cfg b/Base/limine.cfg
index fe48c1b3..4922434c 100644
--- a/Base/limine.cfg
+++ b/Base/limine.cfg
@@ -30,6 +30,12 @@ KERNEL_CMDLINE=runtests debug
 KERNEL_PATH=boot:///lemon/kernel.sys
 MODULE_PATH=boot:///lemon/initrd.tar
 
+:Lemon OS (framebuffer console)
+PROTOCOL=stivale2
+KERNEL_CMDLINE=kcon
+KERNEL_PATH=boot:///lemon/kernel.sys
+MODULE_PATH=boot:///lemon/initrd.tar
+
 :Lemon OS (debug, nosmp)
 PROTOCOL=stivale2
 KERNEL_CMDLINE=debug nosmp
diff --git a/Kernel/include/Arch/x86_64/Thread.h b/Kernel/include/Arch/x86_64/Thread.h
index 4b62f29d..dd5ba384 100644
--- a/Kernel/include/Arch/x86_64/Thread.h
+++ b/Kernel/include/Arch/x86_64/Thread.h
@@ -81,6 +81,8 @@ struct Thread {
 
     Thread(class Process* _parent, pid_t _tid);
 
+    ALWAYS_INLINE static Thread* Current() { return GetCPULocal()->currentThread; }
+
     /////////////////////////////
     /// \brief Dispatch a signal to the thread
     /////////////////////////////
@@ -90,6 +92,13 @@ struct Thread {
     /// \brief Call the signal handler for the first pending signal
     /////////////////////////////
     void HandlePendingSignal(RegisterContext* regs);
+    
+    /////////////////////////////
+    /// \brief Get the signal mask accounting for unmaskable signals
+    /////////////////////////////
+    ALWAYS_INLINE uint64_t EffectiveSignalMask() const {
+        return signalMask & (~UNMASKABLE_SIGNALS);
+    }
 
     /////////////////////////////
     /// \brief Block a thread
diff --git a/Kernel/include/Signal.h b/Kernel/include/Signal.h
index f5c91f9b..1c0c9cf9 100644
--- a/Kernel/include/Signal.h
+++ b/Kernel/include/Signal.h
@@ -6,6 +6,7 @@ typedef void (*__sighandler) (int);
 #include <abi-bits/signal.h>
 
 #define SIGNAL_MAX 34 // Maximum amount of signal handlers
+#define UNMASKABLE_SIGNALS (1 << (SIGKILL - 1)) | (1 << (SIGSTOP - 1))
 
 enum class SignalAction : int {
     Die = 0, // Kill the thread
diff --git a/Kernel/include/UserPointer.h b/Kernel/include/UserPointer.h
index d1fc922e..e08f427f 100644
--- a/Kernel/include/UserPointer.h
+++ b/Kernel/include/UserPointer.h
@@ -31,8 +31,12 @@ template <typename T> class UserPointer {
 public:
     UserPointer(uintptr_t ptr) : m_ptr(reinterpret_cast<T*>(ptr)) {}
 
-    ALWAYS_INLINE int GetValue(T& kernelValue) const { return UserMemcpy(&kernelValue, m_ptr, sizeof(T)); }
-    ALWAYS_INLINE int StoreValue(const T& kernelValue) { return UserMemcpy(m_ptr, &kernelValue, sizeof(T)); }
+    [[nodiscard]] ALWAYS_INLINE int GetValue(T& kernelValue) const {
+        return UserMemcpy(&kernelValue, m_ptr, sizeof(T));
+    }
+    [[nodiscard]] ALWAYS_INLINE int StoreValue(const T& kernelValue) {
+        return UserMemcpy(m_ptr, &kernelValue, sizeof(T));
+    }
 
     ALWAYS_INLINE T* Pointer() { return m_ptr; }
 
@@ -46,20 +50,24 @@ template <typename T> class UserBuffer {
 public:
     UserBuffer(uintptr_t ptr) : m_ptr(reinterpret_cast<T*>(ptr)) {}
 
-    ALWAYS_INLINE int GetValue(unsigned index, T& kernelValue) const { return UserMemcpy(&kernelValue, &m_ptr[index], sizeof(T)); }
-    ALWAYS_INLINE int StoreValue(unsigned index, const T& kernelValue) { return UserMemcpy(&m_ptr[index], &kernelValue, sizeof(T)); }
+    [[nodiscard]] ALWAYS_INLINE int GetValue(unsigned index, T& kernelValue) const {
+        return UserMemcpy(&kernelValue, &m_ptr[index], sizeof(T));
+    }
+    [[nodiscard]] ALWAYS_INLINE int StoreValue(unsigned index, const T& kernelValue) {
+        return UserMemcpy(&m_ptr[index], &kernelValue, sizeof(T));
+    }
 
-    ALWAYS_INLINE int Read(T* data, size_t offset, size_t count) const {
+    [[nodiscard]] ALWAYS_INLINE int Read(T* data, size_t offset, size_t count) const {
         if (!IsUsermodePointer(m_ptr, offset, count)) { // Don't allow kernel memory access
-            return 0;
+            return 1;
         }
 
         return UserMemcpy(data, &m_ptr[offset], sizeof(T) * count);
     }
 
-    ALWAYS_INLINE int Write(T* data, size_t offset, size_t count) {
+    [[nodiscard]] ALWAYS_INLINE int Write(T* data, size_t offset, size_t count) {
         if (!IsUsermodePointer(m_ptr, offset, count)) { // Don't allow kernel memory access
-            return 0;
+            return 1;
         }
 
         return UserMemcpy(&m_ptr[offset], data, sizeof(T) * count);
diff --git a/Kernel/src/Arch/x86_64/Scheduler.cpp b/Kernel/src/Arch/x86_64/Scheduler.cpp
index 8763eecb..d55eec95 100755
--- a/Kernel/src/Arch/x86_64/Scheduler.cpp
+++ b/Kernel/src/Arch/x86_64/Scheduler.cpp
@@ -212,7 +212,7 @@ void Schedule(__attribute__((unused)) void* data, RegisterContext* r) {
     // - Pending unmasked signals
     // If true, invoke the signal handler
     if ((cpu->currentThread->registers.cs & 0x3) &&
-        (cpu->currentThread->pendingSignals & ~cpu->currentThread->signalMask)) {
+        (cpu->currentThread->pendingSignals & ~cpu->currentThread->EffectiveSignalMask())) {
         if (cpu->currentThread->parent->State() == ThreadStateRunning) {
             int ret = acquireTestLock(&cpu->currentThread->lock);
             assert(!ret);
diff --git a/Kernel/src/Arch/x86_64/Syscalls.cpp b/Kernel/src/Arch/x86_64/Syscalls.cpp
index 186278a3..49794ae0 100755
--- a/Kernel/src/Arch/x86_64/Syscalls.cpp
+++ b/Kernel/src/Arch/x86_64/Syscalls.cpp
@@ -5,6 +5,7 @@
 #include <Device.h>
 #include <Errno.h>
 #include <Framebuffer.h>
+#include <Fs/EPoll.h>
 #include <Fs/Pipe.h>
 #include <HAL.h>
 #include <IDT.h>
@@ -15,7 +16,7 @@
 #include <Modules.h>
 #include <Net/Socket.h>
 #include <Objects/Service.h>
-#include <TTY/PTY.h>
+#include <OnCleanup.h>
 #include <Pair.h>
 #include <PhysicalAllocator.h>
 #include <SMP.h>
@@ -23,9 +24,10 @@
 #include <SharedMemory.h>
 #include <Signal.h>
 #include <StackTrace.h>
+#include <TTY/PTY.h>
 #include <Timer.h>
-#include <Video/Video.h>
 #include <UserPointer.h>
+#include <Video/Video.h>
 
 #include <ABI/Process.h>
 #include <ABI/Syscall.h>
@@ -40,7 +42,7 @@
 #define SC_ARG4(r) ((r)->r9)
 #define SC_ARG5(r) ((r)->r8)
 
-#define NUM_SYSCALLS 108
+#define NUM_SYSCALLS 111
 
 #define EXEC_CHILD 1
 
@@ -51,7 +53,15 @@
 #define WNOWAIT 16
 #define WSTOPPED 32
 
-#define TRY_STORE_UMODE_VALUE(ptrObject, value) if(ptrObject.StoreValue(value)) { return -EFAULT; }
+#define TRY_STORE_UMODE_VALUE(ptrObject, value)                                                                        \
+    if (ptrObject.StoreValue(value)) {                                                                                 \
+        return -EFAULT;                                                                                                \
+    }
+
+#define TRY_GET_UMODE_VALUE(ptrObject, value)                                                                          \
+    if (ptrObject.GetValue(value)) {                                                                                   \
+        return -EFAULT;                                                                                                \
+    }
 
 typedef long (*syscall_t)(RegisterContext*);
 
@@ -259,7 +269,7 @@ long SysOpen(RegisterContext* r) {
                      { Log::Warning("SysOpen (flags %x): Failed to open file %s", flags, filepath); });
             return -ENOENT;
         }
-    } else if(node->IsSymlink()){
+    } else if (node->IsSymlink()) {
         Log::Warning("SysOpen: Is a symlink (O_NOFOLLOW specified)");
         return -ELOOP;
     }
@@ -450,8 +460,9 @@ long SysExecve(RegisterContext* r) {
     // Reset register state
     memset(r, 0, sizeof(RegisterContext));
 
-    MappedRegion* stackRegion = currentProcess->addressSpace->AllocateAnonymousVMObject(0x200000, 0, false); // 2MB max stacksize
-    currentThread->stack = reinterpret_cast<void*>(stackRegion->base);                             // 256KB stack size
+    MappedRegion* stackRegion =
+        currentProcess->addressSpace->AllocateAnonymousVMObject(0x200000, 0, false); // 2MB max stacksize
+    currentThread->stack = reinterpret_cast<void*>(stackRegion->base);               // 256KB stack size
     r->rsp = (uintptr_t)currentThread->stack + 0x200000;
 
     // Force the first 8KB to be allocated
@@ -471,7 +482,7 @@ long SysExecve(RegisterContext* r) {
     }
 
     strncpy(currentProcess->name, kernelArgv[0].c_str(), sizeof(currentProcess->name));
-    
+
     assert(!(r->rsp & 0xF));
 
     r->cs = USER_CS;
@@ -960,7 +971,7 @@ long SysMmap(RegisterContext* r) {
         return -EINVAL;
     }
 
-    if(size > 0x40000000){ // size > 1GB
+    if (size > 0x40000000) { // size > 1GB
         Log::Warning("MMap size: %u (>1GB)", size);
         Log::Info("rip: %x", r->rip);
         UserPrintStackTrace(r->rbp, proc->addressSpace);
@@ -1020,7 +1031,7 @@ long SysWaitPID(RegisterContext* r) {
         }
 
         assert(child.get());
-        if(status){
+        if (status) {
             *status = child->exitCode;
         }
 
@@ -1053,7 +1064,7 @@ long SysWaitPID(RegisterContext* r) {
         }
 
         assert(child->IsDead());
-        if(status){
+        if (status) {
             *status = child->exitCode;
         }
 
@@ -1846,7 +1857,7 @@ long SysSendMsg(RegisterContext* r) {
             Log::Warning("SysSendMsg: msg: Invalid iovec entry base");
             return -EFAULT;
         }
-        
+
         long ret = sock->SendTo(msg->msg_iov[i].iov_base, msg->msg_iov[i].iov_len, flags, (sockaddr*)msg->msg_name,
                                 msg->msg_namelen, msg->msg_control, msg->msg_controllen);
 
@@ -2519,7 +2530,7 @@ long SysCreateInterface(RegisterContext* r) {
         return ret;
     }
 
-    Handle handle = currentProcess->AllocateHandle(static_pointer_cast<KernelObject, MessageInterface>(interface)); 
+    Handle handle = currentProcess->AllocateHandle(static_pointer_cast<KernelObject, MessageInterface>(interface));
     return handle.id;
 }
 
@@ -2552,8 +2563,7 @@ long SysInterfaceAccept(RegisterContext* r) {
         return ret;
     }
 
-    Handle handle =
-        currentProcess->AllocateHandle(static_pointer_cast<KernelObject, MessageEndpoint>(endp));
+    Handle handle = currentProcess->AllocateHandle(static_pointer_cast<KernelObject, MessageEndpoint>(endp));
 
     return handle.id;
 }
@@ -3546,7 +3556,7 @@ long SysAlarm(RegisterContext* r) {
     return 0;
 }
 
-long SysGetResourceLimit(RegisterContext* r){
+long SysGetResourceLimit(RegisterContext* r) {
     Process* proc = Scheduler::GetCurrentProcess();
     int resource = SC_ARG0(r);
     // struct rlimit* = SC_ARG1(r);
@@ -3557,6 +3567,306 @@ long SysGetResourceLimit(RegisterContext* r){
     return -ENOSYS;
 }
 
+long SysEpollCreate(RegisterContext* r) {
+    Process* proc = Process::Current();
+    int flags = SC_ARG0(r);
+
+    if (flags & (~EPOLL_CLOEXEC)) {
+        return -EINVAL;
+    }
+
+    fs::EPoll* ep = new fs::EPoll();
+    FancyRefPtr<UNIXFileDescriptor> handle = new UNIXFileDescriptor;
+    handle->node = ep;
+    handle->mode = 0;
+    if (flags & EPOLL_CLOEXEC) {
+        handle->mode |= O_CLOEXEC;
+    }
+
+    int fd = proc->AllocateFileDescriptor(handle);
+    return fd;
+}
+
+long SysEPollCtl(RegisterContext* r) {
+    Process* proc = Process::Current();
+
+    int epfd = SC_ARG0(r);
+    int op = SC_ARG1(r);
+    int fd = SC_ARG2(r);
+    UserPointer<struct epoll_event> event = SC_ARG3(r);
+
+    auto epHandle = proc->GetFileDescriptor(epfd);
+    auto handle = proc->GetFileDescriptor(fd);
+
+    if (!(handle && epHandle)) {
+        return -EBADF; // epfd or fd is invalid
+    }
+
+    if (handle->node->IsEPoll()) {
+        Log::Warning("SysEPollCtl: Currently watching other epoll devices is not supported.");
+    }
+
+    if (epfd == fd) {
+        Log::Debug(debugLevelSyscalls, DebugLevelVerbose, "epfd == fd");
+        return -EINVAL;
+    } else if (!epHandle->node->IsEPoll()) {
+        Log::Debug(debugLevelSyscalls, DebugLevelVerbose, "Not an epoll device!");
+        return -EINVAL; // Not an epoll device
+    }
+
+    fs::EPoll* epoll = (fs::EPoll*)epHandle->node;
+
+    ScopedSpinLock<true> lockEp(epoll->epLock);
+
+    if (op == EPOLL_CTL_ADD) {
+        struct epoll_event e;
+        TRY_GET_UMODE_VALUE(event, e);
+
+        if (e.events & EPOLLEXCLUSIVE) {
+            // Unsupported
+            Log::Warning("SysEPollCtl: EPOLLEXCLUSIVE unsupported!");
+        }
+
+        if (e.events & EPOLLET) {
+            Log::Warning("SysEPollCtl: EPOLLET unsupported!");
+        }
+
+        for (const auto& pair : epoll->fds) {
+            if (pair.item1 == fd) {
+                return -EEXIST; // Already watching the fd
+            }
+        }
+
+        epoll->fds.add_back({fd, {e.events, e.data}});
+    } else if (op == EPOLL_CTL_DEL) {
+        for (auto it = epoll->fds.begin(); it != epoll->fds.end(); it++) {
+            if (it->item1 == fd) {
+                epoll->fds.remove(it);
+                return 0;
+            }
+        }
+
+        return -ENOENT;
+    } else if (op == EPOLL_CTL_MOD) {
+        struct epoll_event* current = nullptr;
+        struct epoll_event e;
+        TRY_GET_UMODE_VALUE(event, e);
+
+        if (e.events & EPOLLEXCLUSIVE) {
+            // Not that we support this flag yet,
+            // however for future it can only be
+            // enabled on EPOLL_CTL_ADD.
+            return -EINVAL;
+        }
+
+        for (auto& pair : epoll->fds) {
+            if (pair.item1 == fd) {
+                current = &pair.item2;
+                break;
+            }
+        }
+
+        if (!current) {
+            return -ENOENT; // fd not found
+        }
+    }
+
+    return -EINVAL;
+}
+
+long SysEpollWait(RegisterContext* r) {
+    Process* proc = Process::Current();
+    Thread* thread = Thread::Current();
+
+    int epfd = SC_ARG0(r);
+    UserBuffer<struct epoll_event> events = SC_ARG1(r);
+    int maxevents = SC_ARG2(r);
+    long timeout = SC_ARG3(r) * 1000;
+
+    auto epHandle = proc->GetFileDescriptor(epfd);
+    if (!epHandle) {
+        return -EBADF;
+    } else if (!epHandle->node->IsEPoll()) {
+        Log::Debug(debugLevelSyscalls, DebugLevelVerbose, "Not an epoll device!");
+        return -EINVAL; // Not an epoll device
+    }
+
+    if (maxevents <= 0) {
+        Log::Debug(debugLevelSyscalls, DebugLevelVerbose, "maxevents cannot be <= 0");
+        return -EINVAL; // maxevents cannot be <= 0
+    }
+
+    fs::EPoll* epoll = (fs::EPoll*)epHandle->node;
+
+    int64_t sigmask = SC_ARG4(r);
+    int64_t oldsigmask = 0;
+    if (sigmask) {
+        oldsigmask = thread->signalMask;
+        thread->signalMask = sigmask;
+    }
+
+    OnCleanup([sigmask, oldsigmask, thread]() {
+        if (sigmask) {
+            thread->signalMask = oldsigmask;
+        }
+    });
+
+    ScopedSpinLock lockEp(epoll->epLock);
+
+    Vector<int> removeFds; // Fds to unwatch
+    auto getEvents = [removeFds](FancyRefPtr<UNIXFileDescriptor>& handle, uint32_t requested, int& evCount) -> uint32_t {
+        uint32_t ev = 0;
+        if (requested & EPOLLIN) {
+            if (handle->node->CanRead()) {
+                ev |= EPOLLIN;
+            }
+        }
+
+        if (requested & EPOLLOUT) {
+            if (handle->node->CanWrite()) {
+                ev |= EPOLLOUT;
+            }
+        }
+
+        if (handle->node->IsSocket()) {
+            if (!((Socket*)handle->node)->IsConnected() && !((Socket*)handle->node)->IsListening()) {
+                ev |= EPOLLHUP;
+            }
+
+            if (((Socket*)handle->node)->PendingConnections() && (requested & EPOLLIN)) {
+                ev |= EPOLLIN;
+            }
+        }
+
+        if (ev) {
+            evCount++;
+        }
+
+        return ev;
+    };
+
+    auto epollToPollEvents = [](uint32_t ep) -> int {
+        int evs = 0;
+        if (ep & EPOLLIN) {
+            evs |= POLLIN;
+        }
+
+        if (ep & EPOLLOUT) {
+            evs |= POLLOUT;
+        }
+
+        if (ep & EPOLLHUP) {
+            evs |= POLLHUP;
+        }
+
+        if (ep & EPOLLRDHUP) {
+            evs |= POLLRDHUP;
+        }
+
+        if (ep & EPOLLERR) {
+            evs |= POLLERR;
+        }
+
+        if (ep & EPOLLPRI) {
+            evs |= POLLPRI;
+        }
+
+        return evs;
+    };
+
+    struct EPollFD {
+        FancyRefPtr<UNIXFileDescriptor> handle;
+        int fd;
+        struct epoll_event ev;
+    };
+
+    Vector<EPollFD> files;
+    int evCount = 0; // Amount of fds with events
+    for (const auto& pair : epoll->fds) {
+        auto handle = proc->GetFileDescriptor(pair.item1);
+        if (!handle) {
+            continue; // Ignore closed fds
+        }
+
+        if (uint32_t ev = getEvents(handle, pair.item2.events, evCount); ev) {
+            if (events.StoreValue(evCount - 1, {
+                                                   .events = ev,
+                                                   .data = pair.item2.data,
+                                               })) {
+                return -EFAULT;
+            }
+        }
+
+        if(evCount > 0) {
+            if(pair.item2.events & EPOLLONESHOT) {
+                removeFds.add_back(pair.item1);
+            }
+        } else {
+            files.add_back({handle, pair.item1, pair.item2}); // We only need the handle for later if events were not found
+        }
+
+        if (evCount >= maxevents) {
+            goto done; // Reached max events/fds
+        }
+    }
+
+    if (evCount > 0) {
+        goto done;
+    }
+
+    if (!evCount && timeout) {
+        FilesystemWatcher fsWatcher;
+        for (auto& file : files) {
+            fsWatcher.WatchNode(file.handle->node, epollToPollEvents(file.ev.events));
+        }
+
+        while (!evCount) {
+            if (timeout > 0) {
+                if (fsWatcher.WaitTimeout(timeout)) {
+                    return -EINTR; // Interrupted
+                } else if (timeout <= 0) {
+                    return 0; // Timed out
+                }
+            } else if (fsWatcher.Wait()) {
+                return -EINTR; // Interrupted
+            }
+
+            for (auto& handle : files) {
+                if (uint32_t ev = getEvents(handle.handle, handle.ev.events, evCount); ev) {
+                    if (events.StoreValue(evCount - 1, {
+                                                           .events = ev,
+                                                           .data = handle.ev.data,
+                                                       })) {
+                        return -EFAULT;
+                    }
+                }
+
+                if(evCount > 0) {
+                    if(handle.ev.events & EPOLLONESHOT) {
+                        removeFds.add_back(handle.fd);
+                    }
+                }
+
+                if (evCount >= maxevents) {
+                    goto done; // Reached max events/fds
+                }
+            }
+        }
+    }
+
+done:
+    for(int fd : removeFds) {
+        for(auto it = epoll->fds.begin(); it != epoll->fds.end(); it++) {
+            if(it->item1 == fd) {
+                epoll->fds.remove(it);
+                break;
+            }
+        }
+    }
+
+    return evCount;
+}
+
 syscall_t syscalls[NUM_SYSCALLS]{
     SysDebug,
     SysExit, // 1
@@ -3666,6 +3976,9 @@ syscall_t syscalls[NUM_SYSCALLS]{
     SysSignalReturn, // 105
     SysAlarm,
     SysGetResourceLimit,
+    SysEpollCreate,
+    SysEPollCtl,
+    SysEpollWait,   // 110
 };
 
 void DumpLastSyscall(Thread* t) {
@@ -3706,7 +4019,7 @@ extern "C" void SyscallHandler(RegisterContext* regs) {
 
     regs->rax = syscalls[regs->rax](regs); // Call syscall
 
-    if (__builtin_expect(thread->pendingSignals & (~thread->signalMask), 0)) {
+    if (__builtin_expect(thread->pendingSignals & (~thread->EffectiveSignalMask()), 0)) {
         thread->HandlePendingSignal(regs);
     }
     releaseLock(&thread->lock);
diff --git a/Kernel/src/Arch/x86_64/Thread.cpp b/Kernel/src/Arch/x86_64/Thread.cpp
index 96844ad7..291f22cf 100644
--- a/Kernel/src/Arch/x86_64/Thread.cpp
+++ b/Kernel/src/Arch/x86_64/Thread.cpp
@@ -209,7 +209,7 @@ bool Thread::Block(ThreadBlocker* newBlocker) {
         return false;
     }
 
-    if (pendingSignals & (~signalMask)) {
+    if (pendingSignals & (~EffectiveSignalMask())) {
         releaseLock(&newBlocker->lock); // Pending signals, don't block
         asm("sti");
 
diff --git a/LibLemon/include/Lemon/System/ABI/Syscall.h b/LibLemon/include/Lemon/System/ABI/Syscall.h
index 8ab72f3f..116739a1 100644
--- a/LibLemon/include/Lemon/System/ABI/Syscall.h
+++ b/LibLemon/include/Lemon/System/ABI/Syscall.h
@@ -103,4 +103,9 @@
 #define SYS_SIGNAL_ACTION 102
 #define SYS_SIGPROCMASK 103
 #define SYS_KILL 104
-#define SYS_SIGNAL_RETURN 105
\ No newline at end of file
+#define SYS_SIGNAL_RETURN 105
+#define SYS_ALARM 106
+#define SYS_GET_RESOURCE_LIMIT 107 
+#define SYS_EPOLL_CREATE 108
+#define SYS_EPOLL_CTL 109
+#define SYS_EPOLL_WAIT 110
diff --git a/System/FTerm/colours.h b/System/FTerm/colours.h
old mode 100644
new mode 100755
index 140ace41..f243fc57
--- a/System/FTerm/colours.h
+++ b/System/FTerm/colours.h
@@ -1,21 +1,280 @@
 #pragma once
-static rgba_colour_t colours[] = {
-	{18 , 12 , 0  , 255}, // Black
-	{120, 80 , 0  , 255}, // Dark Red
-	{186, 124, 0  , 255}, // Dark Green
-	{120, 80 , 10 , 255}, // Dark Yellow
-	{153, 102, 0  , 255}, // Dark Blue
-	{186, 124, 0  , 255}, // Dark Magenta
-	{84 , 56 , 0  , 255}, // Dark Cyan
-	{186, 124, 0, 255}, // Gray
-	{18 , 12 , 0  , 255}, // Black
-	{120, 80 , 0  , 255}, // Red
-	{186, 124, 0  , 255}, // Green
-	{120, 80 , 10 , 255}, // Yellow
-	{37 , 26 , 3  , 255}, // Blue
-	{186, 124, 0  , 255}, // Magenta
-	{84 , 56 , 0  , 255}, // Cyan
-	{255, 170, 0, 255}, // White
+rgba_colour_t coloursProfile1[] = {
+	{0	, 0	 , 0  , 255}, // Black
+	{180, 20 , 10 , 255}, // Dark Red
+	{10	, 200, 10 , 255}, // Dark Green
+	{200, 180, 10 , 255}, // Dark Yellow
+	{0	, 0  , 180, 255}, // Dark Blue
+	{200, 0  , 180, 255}, // Dark Magenta
+	{0  , 180, 180, 255}, // Dark Cyan
+	{210, 210, 210, 255}, // Gray
+	{128, 128, 128, 255}, // Black
+	{255, 0  , 0  , 255}, // Red
+	{0 	, 255, 0  , 255}, // Green
+	{255, 255, 0  , 255}, // Yellow
+	{0	, 0  , 255, 255}, // Blue
+	{255, 0  , 255, 255}, // Magenta
+	{0  , 255, 255, 255}, // Cyan
+	{255, 255, 255, 255}, // White
+	{ 0, 0, 0, 255 },
+	{ 0, 0, 95, 255 },
+	{ 0, 0, 135, 255 },
+	{ 0, 0, 175, 255 },
+	{ 0, 0, 215, 255 },
+	{ 0, 0, 255, 255 },
+	{ 0, 95, 0, 255 },
+	{ 0, 95, 95, 255 },
+	{ 0, 95, 135, 255 },
+	{ 0, 95, 175, 255 },
+	{ 0, 95, 215, 255 },
+	{ 0, 95, 255, 255 },
+	{ 0, 135, 0, 255 },
+	{ 0, 135, 95, 255 },
+	{ 0, 135, 135, 255 },
+	{ 0, 135, 175, 255 },
+	{ 0, 135, 215, 255 },
+	{ 0, 135, 255, 255 },
+	{ 0, 175, 0, 255 },
+	{ 0, 175, 95, 255 },
+	{ 0, 175, 135, 255 },
+	{ 0, 175, 175, 255 },
+	{ 0, 175, 215, 255 },
+	{ 0, 175, 255, 255 },
+	{ 0, 215, 0, 255 },
+	{ 0, 215, 95, 255 },
+	{ 0, 215, 135, 255 },
+	{ 0, 215, 175, 255 },
+	{ 0, 215, 215, 255 },
+	{ 0, 215, 255, 255 },
+	{ 0, 255, 0, 255 },
+	{ 0, 255, 95, 255 },
+	{ 0, 255, 135, 255 },
+	{ 0, 255, 175, 255 },
+	{ 0, 255, 215, 255 },
+	{ 0, 255, 255, 255 },
+	{ 95, 0, 0, 255 },
+	{ 95, 0, 95, 255 },
+	{ 95, 0, 135, 255 },
+	{ 95, 0, 175, 255 },
+	{ 95, 0, 215, 255 },
+	{ 95, 0, 255, 255 },
+	{ 95, 95, 0, 255 },
+	{ 95, 95, 95, 255 },
+	{ 95, 95, 135, 255 },
+	{ 95, 95, 175, 255 },
+	{ 95, 95, 215, 255 },
+	{ 95, 95, 255, 255 },
+	{ 95, 135, 0, 255 },
+	{ 95, 135, 95, 255 },
+	{ 95, 135, 135, 255 },
+	{ 95, 135, 175, 255 },
+	{ 95, 135, 215, 255 },
+	{ 95, 135, 255, 255 },
+	{ 95, 175, 0, 255 },
+	{ 95, 175, 95, 255 },
+	{ 95, 175, 135, 255 },
+	{ 95, 175, 175, 255 },
+	{ 95, 175, 215, 255 },
+	{ 95, 175, 255, 255 },
+	{ 95, 215, 0, 255 },
+	{ 95, 215, 95, 255 },
+	{ 95, 215, 135, 255 },
+	{ 95, 215, 175, 255 },
+	{ 95, 215, 215, 255 },
+	{ 95, 215, 255, 255 },
+	{ 95, 255, 0, 255 },
+	{ 95, 255, 95, 255 },
+	{ 95, 255, 135, 255 },
+	{ 95, 255, 175, 255 },
+	{ 95, 255, 215, 255 },
+	{ 95, 255, 255, 255 },
+	{ 135, 0, 0, 255 },
+	{ 135, 0, 95, 255 },
+	{ 135, 0, 135, 255 },
+	{ 135, 0, 175, 255 },
+	{ 135, 0, 215, 255 },
+	{ 135, 0, 255, 255 },
+	{ 135, 95, 0, 255 },
+	{ 135, 95, 95, 255 },
+	{ 135, 95, 135, 255 },
+	{ 135, 95, 175, 255 },
+	{ 135, 95, 215, 255 },
+	{ 135, 95, 255, 255 },
+	{ 135, 135, 0, 255 },
+	{ 135, 135, 95, 255 },
+	{ 135, 135, 135, 255 },
+	{ 135, 135, 175, 255 },
+	{ 135, 135, 215, 255 },
+	{ 135, 135, 255, 255 },
+	{ 135, 175, 0, 255 },
+	{ 135, 175, 95, 255 },
+	{ 135, 175, 135, 255 },
+	{ 135, 175, 175, 255 },
+	{ 135, 175, 215, 255 },
+	{ 135, 175, 255, 255 },
+	{ 135, 215, 0, 255 },
+	{ 135, 215, 95, 255 },
+	{ 135, 215, 135, 255 },
+	{ 135, 215, 175, 255 },
+	{ 135, 215, 215, 255 },
+	{ 135, 215, 255, 255 },
+	{ 135, 255, 0, 255 },
+	{ 135, 255, 95, 255 },
+	{ 135, 255, 135, 255 },
+	{ 135, 255, 175, 255 },
+	{ 135, 255, 215, 255 },
+	{ 135, 255, 255, 255 },
+	{ 175, 0, 0, 255 },
+	{ 175, 0, 95, 255 },
+	{ 175, 0, 135, 255 },
+	{ 175, 0, 175, 255 },
+	{ 175, 0, 215, 255 },
+	{ 175, 0, 255, 255 },
+	{ 175, 95, 0, 255 },
+	{ 175, 95, 95, 255 },
+	{ 175, 95, 135, 255 },
+	{ 175, 95, 175, 255 },
+	{ 175, 95, 215, 255 },
+	{ 175, 95, 255, 255 },
+	{ 175, 135, 0, 255 },
+	{ 175, 135, 95, 255 },
+	{ 175, 135, 135, 255 },
+	{ 175, 135, 175, 255 },
+	{ 175, 135, 215, 255 },
+	{ 175, 135, 255, 255 },
+	{ 175, 175, 0, 255 },
+	{ 175, 175, 95, 255 },
+	{ 175, 175, 135, 255 },
+	{ 175, 175, 175, 255 },
+	{ 175, 175, 215, 255 },
+	{ 175, 175, 255, 255 },
+	{ 175, 215, 0, 255 },
+	{ 175, 215, 95, 255 },
+	{ 175, 215, 135, 255 },
+	{ 175, 215, 175, 255 },
+	{ 175, 215, 215, 255 },
+	{ 175, 215, 255, 255 },
+	{ 175, 255, 0, 255 },
+	{ 175, 255, 95, 255 },
+	{ 175, 255, 135, 255 },
+	{ 175, 255, 175, 255 },
+	{ 175, 255, 215, 255 },
+	{ 175, 255, 255, 255 },
+	{ 215, 0, 0, 255 },
+	{ 215, 0, 95, 255 },
+	{ 215, 0, 135, 255 },
+	{ 215, 0, 175, 255 },
+	{ 215, 0, 215, 255 },
+	{ 215, 0, 255, 255 },
+	{ 215, 95, 0, 255 },
+	{ 215, 95, 95, 255 },
+	{ 215, 95, 135, 255 },
+	{ 215, 95, 175, 255 },
+	{ 215, 95, 215, 255 },
+	{ 215, 95, 255, 255 },
+	{ 215, 135, 0, 255 },
+	{ 215, 135, 95, 255 },
+	{ 215, 135, 135, 255 },
+	{ 215, 135, 175, 255 },
+	{ 215, 135, 215, 255 },
+	{ 215, 135, 255, 255 },
+	{ 215, 175, 0, 255 },
+	{ 215, 175, 95, 255 },
+	{ 215, 175, 135, 255 },
+	{ 215, 175, 175, 255 },
+	{ 215, 175, 215, 255 },
+	{ 215, 175, 255, 255 },
+	{ 215, 215, 0, 255 },
+	{ 215, 215, 95, 255 },
+	{ 215, 215, 135, 255 },
+	{ 215, 215, 175, 255 },
+	{ 215, 215, 215, 255 },
+	{ 215, 215, 255, 255 },
+	{ 215, 255, 0, 255 },
+	{ 215, 255, 95, 255 },
+	{ 215, 255, 135, 255 },
+	{ 215, 255, 175, 255 },
+	{ 215, 255, 215, 255 },
+	{ 215, 255, 255, 255 },
+	{ 255, 0, 0, 255 },
+	{ 255, 0, 95, 255 },
+	{ 255, 0, 135, 255 },
+	{ 255, 0, 175, 255 },
+	{ 255, 0, 215, 255 },
+	{ 255, 0, 255, 255 },
+	{ 255, 95, 0, 255 },
+	{ 255, 95, 95, 255 },
+	{ 255, 95, 135, 255 },
+	{ 255, 95, 175, 255 },
+	{ 255, 95, 215, 255 },
+	{ 255, 95, 255, 255 },
+	{ 255, 135, 0, 255 },
+	{ 255, 135, 95, 255 },
+	{ 255, 135, 135, 255 },
+	{ 255, 135, 175, 255 },
+	{ 255, 135, 215, 255 },
+	{ 255, 135, 255, 255 },
+	{ 255, 175, 0, 255 },
+	{ 255, 175, 95, 255 },
+	{ 255, 175, 135, 255 },
+	{ 255, 175, 175, 255 },
+	{ 255, 175, 215, 255 },
+	{ 255, 175, 255, 255 },
+	{ 255, 215, 0, 255 },
+	{ 255, 215, 95, 255 },
+	{ 255, 215, 135, 255 },
+	{ 255, 215, 175, 255 },
+	{ 255, 215, 215, 255 },
+	{ 255, 215, 255, 255 },
+	{ 255, 255, 0, 255 },
+	{ 255, 255, 95, 255 },
+	{ 255, 255, 135, 255 },
+	{ 255, 255, 175, 255 },
+	{ 255, 255, 215, 255 },
+	{ 255, 255, 255, 255 },
+	{ 0, 0, 0, 255 },
+	{ 18, 18, 18, 255 },
+	{ 28, 28, 28, 255 },
+	{ 38, 38, 38, 255 },
+	{ 48, 48, 48, 255 },
+	{ 58, 58, 58, 255 },
+	{ 68, 68, 68, 255 },
+	{ 78, 78, 78, 255 },
+	{ 88, 88, 88, 255 },
+	{ 98, 98, 98, 255 },
+	{ 108, 108, 108, 255 },
+	{ 118, 118, 118, 255 },
+	{ 128, 128, 128, 255 },
+	{ 138, 138, 138, 255 },
+	{ 148, 148, 148, 255 },
+	{ 158, 158, 158, 255 },
+	{ 168, 168, 168, 255 },
+	{ 178, 178, 178, 255 },
+	{ 188, 188, 188, 255 },
+	{ 198, 198, 198, 255 },
+	{ 208, 208, 208, 255 },
+	{ 218, 218, 218, 255 },
+	{ 228, 228, 228, 255 },
+	{ 238, 238, 238, 255}
+};
+
+rgba_colour_t coloursProfile2[] = {
+	{ 0x14, 0x14, 0x14, 200},	   // Black
+	RGBAColour::FromRGB(0xea192f), // Dark Red
+	RGBAColour::FromRGB(0xb0db43), // Dark Green
+	RGBAColour::FromRGB(0xffc145), // Dark Yellow
+	RGBAColour::FromRGB(0x06b6ef), // Dark Blue
+	RGBAColour::FromRGB(0xC200FB), // Dark Magenta
+	RGBAColour::FromRGB(0x558c8c), // Dark Cyan
+	RGBAColour::FromRGB(0xa39e9b), // Gray
+	RGBAColour::FromRGB(0x141414), // Black
+	RGBAColour::FromRGB(0xea192f), // Red
+	RGBAColour::FromRGB(0xb0db43), // Green
+	RGBAColour::FromRGB(0xffc145), // Yellow
+	RGBAColour::FromRGB(0x06b6ef), // Blue
+	RGBAColour::FromRGB(0xC200FB), // Magenta
+	RGBAColour::FromRGB(0x558c8c), // Cyan
+	RGBAColour::FromRGB(0xeee7ee), // White
 	{ 0, 0, 0, 255 },
 	{ 0, 0, 95, 255 },
 	{ 0, 0, 135, 255 },
diff --git a/System/FTerm/escape.h b/System/FTerm/escape.h
old mode 100644
new mode 100755
index 45daa404..85276688
--- a/System/FTerm/escape.h
+++ b/System/FTerm/escape.h
@@ -1,6 +1,11 @@
 #pragma once
 
-#define ANSI_ESC 27
+enum {
+    Control_Escape = '\e',
+    Control_Backspace = '\b', // Backspaces one column, however not past the beginning of the line
+    Control_LineFeed = '\n', // Line feed, by default will also carriage return
+    Control_CarriageReturn = '\r', // Carriage return
+};
 
 #define ESC_SAVE_CURSOR '7'
 #define ESC_RESTORE_CURSOR '8'
diff --git a/System/FTerm/main.cpp b/System/FTerm/main.cpp
index ce0f0b7e..e0b10430 100644
--- a/System/FTerm/main.cpp
+++ b/System/FTerm/main.cpp
@@ -1,488 +1,554 @@
+#include <cassert>
+#include <cstdlib>
+#include <thread>
 #include <vector>
-#include <cctype>
 
-#include <termios.h>
 #include <fcntl.h>
-#include <unistd.h>
+#include <pty.h>
+#include <signal.h>
 #include <sys/ioctl.h>
+#include <sys/wait.h>
+#include <sys/poll.h>
+#include <unistd.h>
 
-#include <lemon/syscall.h>
-#include <Lemon/System/Spawn.h>
+#include <Lemon/Core/Keyboard.h>
 #include <Lemon/Core/Framebuffer.h>
-#include <Lemon/Graphics/Graphics.h>
 
-#include "fterm.h"
+#include <Lemon/Graphics/Graphics.h>
 
 #include "colours.h"
 #include "escape.h"
+#include "fterm.h"
 
-struct TermState{
-	bool bold : 1 = false;
-	bool italic : 1 = false;
-	bool faint : 1 = false;
-	bool underline : 1 = false;
-	bool blink : 1 = false;
-	bool reverse : 1 = false;
-	bool strikethrough: 1 = false;
-
-	uint8_t fgColour = 15;
-	uint8_t bgColour = 0;
-};
+#define SCROLLBACK_BUFFER_MAX 400
 
-TermState defaultState {
-	.bold = false,
-	.italic = false,
-	.faint = false,
-	.underline = false,
-	.blink = false,
-	.reverse = false,
-	.strikethrough = false,
-	.fgColour = 136,
-	.bgColour = 0,
-};
+using namespace Lemon;
 
-struct TerminalChar {
-	TermState s = defaultState;
-	char c = ' ';
-};
+Colour* colours = coloursProfile2;
+Lemon::Graphics::Font* terminalFont = nullptr;
 
-int masterPTYFd;
-TermState state = defaultState;
-bool escapeSequence = false;
-int escapeType = 0;
+Surface renderSurface;
+Surface framebufferSurface;
 
-Lemon::Graphics::Font* terminalFont;
+RGBAColour defaultBackgroundColour = colours[0];
+RGBAColour defaultForegroundColour = colours[15];
+RGBAColour currentBackgroundColour = colours[0];
+RGBAColour currentForegroundColour = colours[15];
 
-surface_t fbSurface;
-surface_t renderSurface;
+Vector2i characterSize;
+Vector2i terminalSize;            // The size of the terminal window in characters
+Vector2i cursorPosition = {1, 1}; // The position of the cursor in characters
 
-winsize wSize;
+pid_t shellPID = -1;
 
-std::vector<std::vector<TerminalChar>> screenBuffer;
+struct TerminalChar {
+    char ch;
+    RGBAColour background;
+    RGBAColour foreground;
 
-vector2i_t curPos = {0, 0};
-vector2i_t storedCurPos = {0, 0};
+    TerminalChar() = default;
+    TerminalChar(char ch) : ch(ch), background(currentBackgroundColour), foreground(currentForegroundColour) {}
 
-const int escBufMax = 256;
-char escBuf[escBufMax];
+    inline operator char() { return ch; }
+};
 
-void Scroll(){
-	while(curPos.y >= wSize.ws_row){
-		screenBuffer.erase(screenBuffer.begin());
-		screenBuffer.push_back(std::vector<TerminalChar>());
+using TerminalLine = std::vector<TerminalChar>;
 
-        curPos.y--;
-	}
+std::vector<TerminalLine> scrollbackBuffer;
 
-	Lemon::Graphics::DrawRect({0, 0, renderSurface.width, renderSurface.height}, colours[state.bgColour], &renderSurface);
-}
+TerminalLine& GetLine(int cursorY) {
+    assert(scrollbackBuffer.size() >= static_cast<unsigned>(terminalSize.y));
 
-void Paint(){
-    int lnPos = 0;
-    int fontHeight = terminalFont->height;
-    for(std::vector<TerminalChar>& line : screenBuffer){
-        for(int j = 0; j < static_cast<long>(line.size()) && j < wSize.ws_col; j++){
-			TerminalChar ch = screenBuffer[lnPos][j];
-			rgba_colour_t fg = colours[ch.s.fgColour];
-			rgba_colour_t bg = colours[ch.s.bgColour];
+    // Cursor starts at (1, 1)
+    TerminalLine& ln = scrollbackBuffer[scrollbackBuffer.size() - terminalSize.y + (cursorY - 1)];
 
-			Lemon::Graphics::DrawRect(j * 8, lnPos * fontHeight, 8, fontHeight, bg.r, bg.g, bg.b, &renderSurface);
+    // Ensure the line is the right size
+    if (ln.size() != static_cast<unsigned>(terminalSize.x))
+        ln.resize(terminalSize.x);
+    return ln;
+}
 
-			if(isprint(ch.c))
-				Lemon::Graphics::DrawChar(ch.c, j * 8, lnPos * fontHeight, fg.r, fg.g, fg.b, &renderSurface, {0, 0, renderSurface.width, renderSurface.height}, terminalFont);
-        }
+inline auto FirstLine() { return scrollbackBuffer.begin() + (scrollbackBuffer.size() - terminalSize.y); }
 
-        if(++lnPos >= wSize.ws_row){
-            break;
+void Paint() {
+    assert(scrollbackBuffer.size() >= static_cast<unsigned>(terminalSize.y));
+
+    Vector2i screenPos = {0, 0};
+    for (unsigned i = scrollbackBuffer.size() - terminalSize.y; i < scrollbackBuffer.size(); i++) {
+        screenPos.x = 0;
+        for (auto& c : scrollbackBuffer[i]) {
+            Lemon::Graphics::DrawRect(Rect{screenPos, characterSize}, c.background, &renderSurface);
+            Lemon::Graphics::DrawChar(c.ch, screenPos.x, screenPos.y, c.foreground, &renderSurface, terminalFont);
+            screenPos.x += characterSize.x;
         }
+        screenPos.y += characterSize.y;
     }
 
-	timespec t;
-	clock_gettime(CLOCK_BOOTTIME, &t);
+    Lemon::Graphics::DrawRect(
+        Rect{{(cursorPosition.x - 1) * characterSize.x, (cursorPosition.y - 1) * characterSize.y}, characterSize},
+        currentForegroundColour, &renderSurface);
 	
-	long msec = (t.tv_nsec / 1000000.0);
-	if(msec < 250 || (msec > 500 && msec < 750)) // Only draw the cursor for a quarter of a second so it blinks
-		Lemon::Graphics::DrawRect(curPos.x * 8, curPos.y * fontHeight + (fontHeight / 4 * 3), 8, fontHeight / 4, colours[state.fgColour], &renderSurface);
+	framebufferSurface.Blit(&renderSurface);
+}
 
-    Lemon::Graphics::surfacecpy(&fbSurface, &renderSurface);
+void ClearScrollbackBuffer() {
+    scrollbackBuffer = std::vector<TerminalLine>(terminalSize.y, TerminalLine(terminalSize.x, TerminalChar(0)));
 }
 
-void DoAnsiSGR(){
-	int r = -1;
-	if(strchr(escBuf, ';')){
-		char temp[strchr(escBuf, ';') - escBuf + 1];
-		temp[strchr(escBuf, ';') - escBuf] = 0;
-		strncpy(temp, escBuf, (int)(strchr(escBuf, ';') - escBuf));
-		r = atoi(escBuf);
-
-	} else r = atoi(escBuf);
-	if(r < 30){
-		switch (r)
-		{
-		case 0:
-			state = defaultState;
-			break;
-		case 1:
-			state.bold = true;
-			break;
-		case 2:
-			state.faint = true;
-			break;
-		case 3:
-			state.italic = true;
-			break;
-		case 4:
-			state.underline = true;
-			break;
-		case 5:
-		case 6:
-			state.blink = true;
-			break;
-		case 7:
-			state.reverse = true;
-			break;
-		case 9:
-			state.strikethrough = true;
-			break;
-		case 21:
-			state.underline = true;
-			break;
-		case 24:
-			state.underline = false;
-			break;
-		case 25:
-			state.blink = false;
-			break;
-		case 27:
-			state.reverse = false;
-			break;
-		default:
-			break;
-		}
-	} else if (r >= ANSI_CSI_SGR_FG_BLACK && r <= ANSI_CSI_SGR_FG_WHITE){ // Foreground Colour
-		state.fgColour = r - ANSI_CSI_SGR_FG_BLACK;
-	} else if (r >= ANSI_CSI_SGR_BG_BLACK && r <= ANSI_CSI_SGR_BG_WHITE){ // Background Colour
-		state.bgColour = r - ANSI_CSI_SGR_BG_BLACK;
-	} else if (r >= ANSI_CSI_SGR_FG_BLACK_BRIGHT && r <= ANSI_CSI_SGR_FG_WHITE_BRIGHT){ // Foreground Colour (Bright)
-		state.fgColour = r - ANSI_CSI_SGR_FG_BLACK_BRIGHT + 8;
-	} else if (r >= ANSI_CSI_SGR_BG_BLACK_BRIGHT && r <= ANSI_CSI_SGR_BG_WHITE_BRIGHT){ // Background Colour (Bright)
-		state.bgColour = r - ANSI_CSI_SGR_BG_BLACK_BRIGHT + 8;
-	} else if (r == ANSI_CSI_SGR_FG){
-		if(strchr(escBuf, ';') && *(strchr(escBuf, ';') + 1) == '5' && strchr(strchr(escBuf, ';') + 1, ';')/* Check if 2 arguments are given */){ // Next argument should be '5' for 256 colours
-			state.fgColour = atoi(strchr(strchr(escBuf, ';') + 1, ';') + 1); // Get argument
-		}
-	} else if (r == ANSI_CSI_SGR_BG){
-		if(strchr(escBuf, ';') && *(strchr(escBuf, ';') + 1) == '5' && strchr(strchr(escBuf, ';') + 1, ';')/* Check if 2 arguments are given */){ // Next argument should be '5' for 256 colours
-			state.bgColour = atoi(strchr(strchr(escBuf, ';') + 1, ';') + 1); // Get argument
-		}
-	}
+void AddLine() {
+    if (scrollbackBuffer.size() < SCROLLBACK_BUFFER_MAX) {
+        scrollbackBuffer.push_back(TerminalLine(terminalSize.x, TerminalChar(0)));
+    } else {
+        scrollbackBuffer.erase(scrollbackBuffer.begin());
+        scrollbackBuffer.push_back(TerminalLine(terminalSize.x, TerminalChar(0)));
+    }
 }
 
-void DoAnsiCSI(char ch){
-	switch(ch){
-	case ANSI_CSI_SGR:
-		DoAnsiSGR(); // Set Graphics Rendition
-		break;
-	case ANSI_CSI_CUU:
-		{
-			int amount = 1;
-			if(strlen(escBuf)){
-				amount = atoi(escBuf);
-			}
-			curPos.y -= amount;
-			if(curPos.y < 0) curPos.y = 0;
-			break;
-		}
-	case ANSI_CSI_CUD:
-		{
-			int amount = 1;
-			if(strlen(escBuf)){
-				amount = atoi(escBuf);
-			}
-			curPos.y += amount;
-			Scroll();
-			break;
-		}
-	case ANSI_CSI_CUF:
-		{
-			int amount = 1;
-			if(strlen(escBuf)){
-				amount = atoi(escBuf);
-			}
-			curPos.x += amount;
-			if(curPos.x > wSize.ws_col) {
-				curPos.x = 0;
-				curPos.y++;
-				Scroll();
-			}
-			break;
-		}
-	case ANSI_CSI_CUB:
-		{
-			int amount = 1;
-			if(strlen(escBuf)){
-				amount = atoi(escBuf);
-			}
-			curPos.x -= amount;
-			if(curPos.x < 0) {
-				curPos.x = wSize.ws_col - 1;
-				curPos.y--;
-			}
-			if(curPos.y < 0) curPos.y = 0;
-			break;
-		}
-	case ANSI_CSI_CUP: // Set cursor position
-		{
-			char* scolon = strchr(escBuf, ';');
-			if(scolon){
-				*scolon = 0;
-
-				curPos.y = atoi(escBuf);
-				Scroll();
-
-				if(*(scolon + 1) == 0){
-					curPos.x = 0;
-				} else {
-					curPos.x = atoi(scolon + 1);
-				}
-			}
-		}
-		break;
-	case ANSI_CSI_ED:
-		{
-			int num = atoi(escBuf);
-			switch(num){
-				case 0: // Clear entire screen from cursor
-					for(int i = curPos.y + 1; i < wSize.ws_row && i < static_cast<long>(screenBuffer.size()); i++){
-						screenBuffer[i].clear();
-					}
-					break;
-				case 1: // Clear screen and move cursor
-				case 2: // Same as 1 but delete everything in the scrollback buffer
-					screenBuffer.clear();
-					curPos = {0, 0};
-					for(int i = 0; i < wSize.ws_row; i++){
-						screenBuffer.push_back(std::vector<TerminalChar>());
-					}
-					break;
-			}
-		}
-		break;
-	case ANSI_CSI_EL:
-		screenBuffer[curPos.y].erase(screenBuffer[curPos.y].begin() + curPos.x, screenBuffer[curPos.y].end());
-		break;
-	case ANSI_CSI_IL: // Insert blank lines
-		{
-			int amount = atoi(escBuf);
-			screenBuffer.insert(screenBuffer.begin() + curPos.y, amount, std::vector<TerminalChar>());
-			break;
-		}
-	case ANSI_CSI_DL:
-		{
-			int amount = atoi(escBuf);
-			screenBuffer.erase(screenBuffer.begin() + curPos.y - amount, screenBuffer.begin() + curPos.y);
+void AdvanceCursorY() {
+    cursorPosition.y++;
+    while (cursorPosition.y > terminalSize.y) {
+        AddLine();
+        cursorPosition.y--;
+    }
+}
 
-			while(screenBuffer.size() < wSize.ws_row){
-				screenBuffer.push_back(std::vector<TerminalChar>());
-			}
-			break;
-		}
-	case ANSI_CSI_SU: // Scroll Down
-        {
-            int amount = 1;
-            if(strlen(escBuf)){
-                amount = atoi(escBuf);
+void AdvanceCursorX() {
+    if (cursorPosition.x++ > terminalSize.x) {
+        cursorPosition.x = 1;
+        AdvanceCursorY();
+    }
+}
+
+// Place char at the cursor position
+void PutChar(char ch) {
+    assert(isprint(ch));
+
+    if (cursorPosition.x > terminalSize.x) {
+        cursorPosition.x = 1;
+        AdvanceCursorY();
+    }
+
+    TerminalLine& line = GetLine(cursorPosition.y);
+    line.at(cursorPosition.x - 1) = TerminalChar(ch);
+}
+
+// Print a char on screen and advance the cursor
+void PrintChar(char ch) {
+    PutChar(ch);
+    AdvanceCursorX();
+}
+
+enum TerminalParseState {
+    State_Normal,
+    State_Escape,
+    State_CSI,
+    State_OSC,
+    State_SGR,
+};
+TerminalParseState parseState = State_Normal;
+std::string escapeBuffer = "";
+
+Vector2i savedCursorPosition; // Cursor for save/restore
+
+// Parse input character
+void ParseChar(char ch) {
+    if (parseState == State_Normal) {
+        if (isprint(ch) || ch == ' ') {
+            PrintChar(ch);
+        } else if (ch == Control_Escape) {
+            escapeBuffer.clear();
+            parseState = State_Escape;
+        } else if (ch == Control_Backspace) {
+            if (cursorPosition.x > 1) {
+                cursorPosition.x--;
+                PutChar(' ');
+            } else {
+                PutChar(' ');
+            }
+        } else if (ch == Control_LineFeed) {
+            AdvanceCursorY();
+            cursorPosition.x = 1;
+        } else if (ch == Control_CarriageReturn) {
+            cursorPosition.x = 1;
+        }
+    } else if (parseState == State_Escape) {
+        switch (ch) {
+        case ANSI_RIS: // Reset to initial state
+            parseState = State_Normal;
+            ClearScrollbackBuffer();
+            cursorPosition = {1, 1};
+            break;
+        case ANSI_CSI:
+            parseState = State_CSI;
+            break;
+        case ANSI_OSC:
+            parseState = State_OSC;
+            break;
+        case ESC_SAVE_CURSOR:
+            savedCursorPosition = cursorPosition;
+            parseState = State_Normal;
+            break;
+        case ESC_RESTORE_CURSOR:
+            cursorPosition = savedCursorPosition;
+            parseState = State_Normal;
+            break;
+        default: // Unsupported escape sequence
+            parseState = State_Normal;
+            break;
+        }
+
+        assert(parseState != State_Escape); // Make sure the statement changed the parser state
+    } else if (parseState == State_CSI) {
+        if (!isalpha(ch)) { // If it is not a letter, add to the escape buffer
+            escapeBuffer += ch;
+        } else {
+            switch (ch) {
+            case ANSI_CSI_SGR:
+                parseState = State_SGR;
+                break;
+            case ANSI_CSI_CUU: { // Cursor up
+                int amount = 1;
+                if (escapeBuffer.size()) {
+                    amount = std::stoi(escapeBuffer);
+                }
+
+                cursorPosition.y = std::max(cursorPosition.y - amount, 1);
+                break;
+            }
+            case ANSI_CSI_CUD: { // Cursor down
+                int amount = 1;
+                if (escapeBuffer.size()) {
+                    amount = std::stoi(escapeBuffer);
+                }
+
+                cursorPosition.y = std::min(cursorPosition.y + amount, terminalSize.y);
+                break;
+            }
+            case ANSI_CSI_CUF: { // Cursor forward
+                int amount = 1;
+                if (escapeBuffer.size()) {
+                    amount = std::stoi(escapeBuffer);
+                }
+
+                cursorPosition.x = std::min(cursorPosition.x + amount, terminalSize.x);
+                break;
+            }
+            case ANSI_CSI_CUB: { // Cursor back
+                int amount = 1;
+                if (escapeBuffer.size()) {
+                    amount = std::stoi(escapeBuffer);
+                }
+
+                cursorPosition.x = std::max(cursorPosition.x - amount, 1);
+                break;
+            }
+            case ANSI_CSI_CUP: // Set cursor position
+            {
+                cursorPosition.x = 1;
+                cursorPosition.y = 1;
+
+                size_t semicolon = escapeBuffer.find(';');
+                if (semicolon != std::string::npos) {
+                    // Use atoi to prevent exceptions
+                    // 0 on error works well as the cursor position cannot be 0
+                    cursorPosition.y =
+                        std::min(std::max(atoi(escapeBuffer.substr(0, semicolon).c_str()), 1), terminalSize.y);
+
+                    std::string afterSemicolon = escapeBuffer.substr(semicolon + 1);
+                    if (afterSemicolon.length()) {
+                        cursorPosition.x = std::min(std::max(atoi(afterSemicolon.c_str()), 1), terminalSize.x);
+                    }
+                }
+            } break;
+            case ANSI_CSI_ED: {
+                int num = atoi(escapeBuffer.c_str());
+                auto& ln = GetLine(cursorPosition.y);
+                switch (num) {
+                default:
+                case 0: // Clear entire screen from cursor
+                    ln.erase(ln.begin() + (cursorPosition.x - 1), ln.end());
+                    ln.insert(ln.end(), terminalSize.x - (cursorPosition.x - 1), TerminalChar(0));
+
+                    assert(ln.size() == static_cast<unsigned>(terminalSize.x));
+                    scrollbackBuffer.erase(FirstLine() + (cursorPosition.y - 1) + 1, scrollbackBuffer.end());
+                    scrollbackBuffer.insert(scrollbackBuffer.end(), terminalSize.y - (cursorPosition.y - 1),
+                                            TerminalLine(terminalSize.x, TerminalChar(0)));
+                    break;
+                case 1: // Clear screen and move cursor
+                case 2: // Same as 1 but delete everything in the scrollback buffer
+                    ClearScrollbackBuffer();
+                    cursorPosition = {1, 1};
+                    break;
+                }
+                break;
+            }
+            case ANSI_CSI_EL: {
+                int n = 0;
+                if (escapeBuffer.length()) {
+                    n = atoi(escapeBuffer.c_str());
+                }
+
+                auto& ln = GetLine(cursorPosition.y);
+                switch (n) {
+                case 2: // Clear entire screen
+                    ClearScrollbackBuffer();
+                    cursorPosition = {1, 1};
+                    break;
+                case 1: // Clear from cursor to beginning of line
+                    ln.erase(ln.begin(), ln.begin() + cursorPosition.x);
+                    ln.insert(ln.begin(), cursorPosition.x, TerminalChar(0));
+                    break;
+                case 0: // Clear from cursor to end of line
+                default:
+                    ln.erase(ln.begin() + (cursorPosition.x - 1), ln.end());
+                    ln.insert(ln.end(), terminalSize.x - (cursorPosition.x - 1), TerminalChar(0));
+                    break;
+                }
+                break;
+            }
+            case ANSI_CSI_IL: // Insert blank lines
+            {
+                // Unsupported
+                break;
+            }
+            case ANSI_CSI_DL: {
+                // Unsupported
+                break;
+            }
+            case ANSI_CSI_SU: // Scroll Up
+            {
+                int amount = 1;
+                if (strlen(escapeBuffer.c_str())) {
+                    amount = atoi(escapeBuffer.c_str());
+                }
+
+                scrollbackBuffer.insert(scrollbackBuffer.end(), amount, TerminalLine(terminalSize.x, TerminalChar(0)));
+                break;
+            }
+            case ANSI_CSI_SD: { // Scroll Down
+                int amount = 1;
+                if (strlen(escapeBuffer.c_str())) {
+                    amount = atoi(escapeBuffer.c_str());
+                }
+
+                scrollbackBuffer.insert(FirstLine(), amount, TerminalLine(terminalSize.x, TerminalChar(0)));
+                break;
+            }
+            default:
+                break;
             }
 
-            while(amount--){
-                screenBuffer.erase(screenBuffer.begin());
-                screenBuffer.push_back(std::vector<TerminalChar>());
+            if (parseState == State_CSI) {
+                parseState = State_Normal;
             }
+        }
+    } else if (parseState == State_OSC) {
+        parseState = State_Normal;
+    }
 
-            break;
+    if (parseState == State_SGR) {
+        size_t semicolon = escapeBuffer.find(';');
+        int r = 0;
+
+        if (semicolon != std::string::npos) {
+            r = atoi(escapeBuffer.substr(0, semicolon).c_str());
+        } else {
+            r = atoi(escapeBuffer.c_str());
         }
-	case ANSI_CSI_SD: // Scroll up
-		break;
-	default:
-		//fprintf(stderr, "Unknown Control Sequence Introducer (CSI) '%c'\n", ch);
-		break;
-	}
-}
 
-void DoAnsiOSC(char ch){
+        if (r == 0) {
+            currentBackgroundColour = defaultBackgroundColour;
+            currentForegroundColour = defaultForegroundColour;
+        } else if (r >= ANSI_CSI_SGR_FG_BLACK && r <= ANSI_CSI_SGR_FG_WHITE) { // Foreground Colour
+            currentForegroundColour = colours[r - ANSI_CSI_SGR_FG_BLACK];
+        } else if (r >= ANSI_CSI_SGR_BG_BLACK && r <= ANSI_CSI_SGR_BG_WHITE) { // Background Colour
+            currentBackgroundColour = colours[r - ANSI_CSI_SGR_BG_BLACK];
+        } else if (r >= ANSI_CSI_SGR_FG_BLACK_BRIGHT &&
+                   r <= ANSI_CSI_SGR_FG_WHITE_BRIGHT) { // Foreground Colour (Bright)
+            currentForegroundColour = colours[r - ANSI_CSI_SGR_FG_BLACK_BRIGHT + 8];
+        } else if (r >= ANSI_CSI_SGR_BG_BLACK_BRIGHT &&
+                   r <= ANSI_CSI_SGR_BG_WHITE_BRIGHT) { // Background Colour (Bright)
+            currentBackgroundColour = colours[r - ANSI_CSI_SGR_BG_BLACK_BRIGHT + 8];
+        } else if (r == ANSI_CSI_SGR_FG) {
+            size_t firstSemicolon = escapeBuffer.find_first_of(';');
+            size_t secondSemicolon = escapeBuffer.find(';', firstSemicolon + 1);
+            // Next argument should be '5' for 256 colours
+            // e.g. [38;5;<colour number>
+            if (firstSemicolon != std::string::npos && escapeBuffer[firstSemicolon + 1] == '5' &&
+                secondSemicolon != std::string::npos) {
+                int col = atoi(escapeBuffer.substr(secondSemicolon + 1).c_str());
+                if (col < 256) {
+                    currentForegroundColour = colours[col];
+                }
+            }
+        } else if (r == ANSI_CSI_SGR_BG) {
+            size_t secondSemicolon = escapeBuffer.find(';', semicolon + 1);
+            // Next argument should be '5' for 256 colours
+            // e.g. [48;5;<colour number>
+            if (semicolon != std::string::npos && escapeBuffer[semicolon + 1] == '5' &&
+                secondSemicolon != std::string::npos) {
+                int col = atoi(escapeBuffer.substr(secondSemicolon + 1).c_str());
+                if (col < 256) {
+                    currentBackgroundColour = colours[col];
+                }
+            }
+        }
 
+        parseState = State_Normal;
+    }
 }
 
-void PrintChar(char ch){
-	if(escapeSequence){
-		if(isspace(ch)){
-			return;
-		}
+bool shouldPaint = true;
+std::mutex paintMutex;
+std::mutex bufferMutex;
 
-		if(!escapeType){
-			escapeType = ch;
-			ch = 0;
-		}
-		
-		if(escapeType == ANSI_CSI || escapeType == ANSI_OSC){
-			if(!isalpha(ch)){ // Found output sequence
-				if(strlen(escBuf) >= escBufMax){
-					escapeSequence = false;
-					return;
-				}
-				char s[] = {ch, 0};
-				strncat(escBuf, s, 2); // Add to buff
-				return;
-			}
+bool isOpen = true;
+int ptyMasterFd = -1;
 
-			if(escapeType == ANSI_CSI){
-				DoAnsiCSI(ch);
-			} else if (escapeType == ANSI_OSC) {
-				DoAnsiOSC(ch);
-			}
-		} else if (escapeType == ANSI_RIS){
-			state = defaultState;
-			screenBuffer.clear();
-			curPos = {0, 0};
-			for(int i = 0; i < wSize.ws_row; i++){
-				screenBuffer.push_back(std::vector<TerminalChar>());
-			}
-		} else if(escapeType == ESC_SAVE_CURSOR) {
-			storedCurPos = curPos;	
-		} else if(escapeType == ESC_RESTORE_CURSOR) {
-			curPos = storedCurPos;	
-		} else {
-			//fprintf(stderr, "Unknown ANSI escape code '%c'\n", ch);
-		}
-		escapeSequence = 0;
-		escapeType = 0;
-	} else {
-
-		switch (ch)
-		{
-		case ANSI_ESC:
-			escapeSequence = true;
-			escapeType = 0;
-			escBuf[0] = 0;
-			break;
-		case '\n':
-			curPos.y++;
-			curPos.x = 0;
-			Scroll();
-			break;
-		case '\b':
-			if(curPos.x > 0) {
-				curPos.x--;
-			} else if(curPos.y > 0) {
-				curPos.y--;
-				curPos.x = screenBuffer[curPos.y].size();
-			}
-			
-			if(curPos.x < static_cast<long>(screenBuffer[curPos.y].size()))
-				screenBuffer[curPos.y].erase(screenBuffer[curPos.y].begin() + curPos.x);
-
-			break;
-		case ' ':
-		default:
-			if(!(isgraph(ch) || isspace(ch))) break;
-
-			if(curPos.x > wSize.ws_col){
-				curPos.y++;
-				curPos.x = 0;
-				Scroll();
-			}
+void SIGCHLDHandler(int){
+    isOpen = false; // Shell has closed
+}
 
-			if(curPos.x >= static_cast<long>(screenBuffer[curPos.y].size()))
-				screenBuffer[curPos.y].push_back({.s = state, .c = ch});
-			else
-				screenBuffer[curPos.y][curPos.x] = {.s = state, .c = ch};
+void* PTYThread() {
+    pollfd pollFd = {.fd = ptyMasterFd, .events = POLLIN};
+    while (isOpen) {
+        if (poll(&pollFd, 1, 500000) > 0) {
+            char buf[512];
+            ssize_t r;
+            bufferMutex.lock();
+            while ((r = read(ptyMasterFd, buf, 512)) > 0) {
+                int i = 0;
+                while (r--) {
+                    ParseChar(buf[i++]);
+                }
+            }
+            bufferMutex.unlock();
 
-			curPos.x++;
+            std::unique_lock lock(paintMutex);
+			Paint();
+            shouldPaint = false;
+        }
+    }
 
-			if(curPos.x > wSize.ws_col){
-				curPos.x = 0;
-				curPos.y++;
-				Scroll();
-			}
-			
-			break;
-		}
-	}
+    return nullptr;
 }
 
-void OnKey(int key){
-    if(key == KEY_ARROW_UP){
+void OnKey(int key) {
+    if (key == KEY_ARROW_UP) {
         const char* esc = "\e[A";
-        write(masterPTYFd, esc, strlen(esc));
-    } else if(key == KEY_ARROW_DOWN){
+        write(ptyMasterFd, esc, strlen(esc));
+    } else if (key == KEY_ARROW_DOWN) {
         const char* esc = "\e[B";
-        write(masterPTYFd, esc, strlen(esc));
-    } else if(key == KEY_ARROW_RIGHT){
+        write(ptyMasterFd, esc, strlen(esc));
+    } else if (key == KEY_ARROW_RIGHT) {
         const char* esc = "\e[C";
-        write(masterPTYFd, esc, strlen(esc));
-    } else if(key == KEY_ARROW_LEFT){
+        write(ptyMasterFd, esc, strlen(esc));
+    } else if (key == KEY_ARROW_LEFT) {
         const char* esc = "\e[D";
-        write(masterPTYFd, esc, strlen(esc));
-    } else if(key == KEY_END){
+        write(ptyMasterFd, esc, strlen(esc));
+    } else if (key == KEY_END) {
         const char* esc = "\e[F";
-        write(masterPTYFd, esc, strlen(esc));
-    } else if(key == KEY_HOME){
+        write(ptyMasterFd, esc, strlen(esc));
+    } else if (key == KEY_HOME) {
         const char* esc = "\e[H";
-        write(masterPTYFd, esc, strlen(esc));
-    } else if(key == KEY_ESCAPE){
+        write(ptyMasterFd, esc, strlen(esc));
+    } else if (key == KEY_ESCAPE) {
         const char* esc = "\e\e";
-        write(masterPTYFd, esc, strlen(esc));
-    } else if(key < 128){
+        write(ptyMasterFd, esc, strlen(esc));
+    } else if (key < 128) {
         const char tkey = (char)key;
-        write(masterPTYFd, &tkey, 1);
+        write(ptyMasterFd, &tkey, 1);
     }
 }
 
-int main(int argc, char** argv){
-    Lemon::CreateFramebufferSurface(fbSurface);
-    renderSurface = fbSurface;
-    renderSurface.buffer = new uint8_t[fbSurface.width * fbSurface.height * 4];
-
-    wSize.ws_xpixel = renderSurface.width;
-    wSize.ws_ypixel = renderSurface.height;
-    
-	terminalFont = Lemon::Graphics::LoadFont("/initrd/sourcecodepro.ttf", "termmonospace");
-	if(!terminalFont){
-		terminalFont = Lemon::Graphics::GetFont("default");
-	}
+int main(int argc, char** argv) {
+    Lemon::CreateFramebufferSurface(framebufferSurface);
+    renderSurface = framebufferSurface;
+    renderSurface.buffer = new uint8_t[framebufferSurface.width * framebufferSurface.height * 4];
 
-    wSize.ws_col = renderSurface.width / 8;
-    wSize.ws_row = renderSurface.height / terminalFont->height;
+    terminalFont = Lemon::Graphics::LoadFont("/initrd/sourcecodepro.ttf", "termmonospace");
+    if (!terminalFont) {
+        terminalFont = Lemon::Graphics::GetFont("default");
+    }
+	
+	characterSize = Vector2i{terminalFont->width, terminalFont->lineHeight};
+    terminalSize =
+        Vector2i{renderSurface.width / characterSize.x, renderSurface.height / characterSize.y};
 
-    InputManager input;
+    ClearScrollbackBuffer();
+    assert(FirstLine() == scrollbackBuffer.begin());
+    assert(&GetLine(1) == &scrollbackBuffer.at(0));
+
+    int ptySlaveFd = -1;
+
+    setenv("TERM", "xterm-256color", 1);
+
+    struct sigaction action = {
+        .sa_handler = SIGCHLDHandler,
+        .sa_flags = 0,
+    };
+    sigemptyset(&action.sa_mask);
 
-    for(int i = 0; i < wSize.ws_row; i++){
-        screenBuffer.push_back(std::vector<TerminalChar>(wSize.ws_col));
+    // We want to exit on SIGCHLD
+    if(sigaction(SIGCHLD, &action, nullptr)){
+        perror("sigaction");
+        return 99;
     }
 
-	syscall(SYS_GRANT_PTY, (uintptr_t)&masterPTYFd, 0, 0, 0, 0);
+    if (openpty(&ptyMasterFd, &ptySlaveFd, nullptr, nullptr, nullptr)) {
+        perror("openpty");
+        return 2;
+    }
+
+    winsize wSz = {
+        .ws_row = static_cast<unsigned short>(terminalSize.y),
+        .ws_col = static_cast<unsigned short>(terminalSize.x),
+        .ws_xpixel = static_cast<unsigned short>(framebufferSurface.width),
+        .ws_ypixel = static_cast<unsigned short>(framebufferSurface.height),
+    };
+
+    InputManager input;
 
-	setenv("TERM", "xterm-256color", 1);
-	ioctl(masterPTYFd, TIOCSWINSZ, &wSize);
+    ioctl(ptyMasterFd, TIOCSWINSZ, &wSz);
 
-    char* const args[] = {"/initrd/lsh.lef"};
-    lemon_spawn(*args, 1, args, 1);
+	for(;;) {
+		// No need to use Lemon OS specifics here
+		shellPID = fork();
+		if (shellPID == 0) {
+			if (dup2(ptySlaveFd, STDIN_FILENO) < 0) {
+				perror("dup2");
+				exit(3);
+			}
 
-    char _buf[512];
-	bool paint = true;
+			if (dup2(ptySlaveFd, STDOUT_FILENO) < 0) {
+				perror("dup2");
+				exit(3);
+			}
 
-    for(;;){
-        input.Poll();
+			if (dup2(ptySlaveFd, STDERR_FILENO) < 0) {
+				perror("dup2");
+				exit(3);
+			}
 
-		while(int len = read(masterPTYFd, _buf, 512)){
-			for(int i = 0; i < len; i++){
-				PrintChar(_buf[i]);
+			close(ptySlaveFd);
+
+			char arg0[] = "/bin/lsh";
+			char* const shArgv[] {
+				arg0,
+				nullptr,
+			};
+			if (execve(arg0, shArgv, environ)) {
+				perror("execve");
+				exit(1);
 			}
-			paint = true;
+		} else if (shellPID < 0) {
+			perror("fork");
+			return 1;
 		}
 
-		if(paint){
-        	Paint();
+		std::thread ptyThread(PTYThread);
+		while (isOpen) {
+			input.Poll();
 		}
-    }
+	}
 }
\ No newline at end of file