diff --git a/.gitignore b/.gitignore
index 4de2feb..fb0249b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,8 @@
-./RepRaptor
\ No newline at end of file
+RepRaptor
+Makefile
+*.user
+*.o
+ui_*.h
+moc_*
+qrc_*
+*~
diff --git a/mainwindow.cpp b/mainwindow.cpp
index d875991..4c8f4d8 100644
--- a/mainwindow.cpp
+++ b/mainwindow.cpp
@@ -110,27 +110,27 @@ MainWindow::MainWindow(QWidget *parent) :
     //Parser thread signal-slots and init
     parserWorker->moveToThread(parserThread);
     connect(parserThread, &QThread::finished, parserWorker, &QObject::deleteLater);
-    connect(this, &MainWindow::recievedData, parserWorker, &Parser::parse);
+    connect(this, &MainWindow::receivedData, parserWorker, &Parser::parse);
     connect(this, &MainWindow::startedReadingEEPROM, parserWorker, &Parser::setEEPROMReadingMode);
-    connect(parserWorker, &Parser::recievedTemperature, this, &MainWindow::updateTemperature);
-    connect(parserWorker, &Parser::recievedSDFilesList, this, &MainWindow::initSDprinting);
-    connect(parserWorker, &Parser::recievedEEPROMLine, this, &MainWindow::EEPROMSettingRecieved);
+    connect(parserWorker, &Parser::receivedTemperature, this, &MainWindow::updateTemperature);
+    connect(parserWorker, &Parser::receivedSDFilesList, this, &MainWindow::initSDprinting);
+    connect(parserWorker, &Parser::receivedEEPROMLine, this, &MainWindow::EEPROMSettingReceived);
     connect(parserWorker, &Parser::recievingEEPROMDone, this, &MainWindow::openEEPROMeditor);
-    connect(parserWorker, &Parser::recievedError, this, &MainWindow::recievedError);
-    connect(parserWorker, &Parser::recievedSDDone, this, &MainWindow::recievedSDDone);
-    connect(parserWorker, &Parser::recievedSDUpdate, this, &MainWindow::updateSDStatus);
+    connect(parserWorker, &Parser::receivedError, this, &MainWindow::receivedError);
+    connect(parserWorker, &Parser::receivedSDDone, this, &MainWindow::receivedSDDone);
+    connect(parserWorker, &Parser::receivedSDUpdate, this, &MainWindow::updateSDStatus);
     parserThread->start();
 
     //Sender thread signal-slots and init
     senderWorker->moveToThread(senderThread);
     connect(senderThread, &QThread::finished, senderWorker, &QObject::deleteLater);
-    connect(parserWorker, &Parser::recievedOkNum, senderWorker, &Sender::recievedOkNum);
-    connect(parserWorker, &Parser::recievedOkWait, senderWorker, &Sender::recievedOkWait);
-    connect(parserWorker, &Parser::recievedResend, senderWorker, &Sender::recievedResend);
-    connect(parserWorker, &Parser::recievedStart, senderWorker, &Sender::recievedStart);
-    connect(senderWorker, &Sender::errorRecieved, this, &MainWindow::serialError);
-    connect(senderWorker, &Sender::dataRecieved, parserWorker, &Parser::parse, Qt::QueuedConnection);
-    connect(senderWorker, &Sender::dataRecieved, this, &MainWindow::readSerial, Qt::QueuedConnection);
+    connect(parserWorker, &Parser::receivedOkNum, senderWorker, &Sender::receivedOkNum);
+    connect(parserWorker, &Parser::receivedOkWait, senderWorker, &Sender::receivedOkWait);
+    connect(parserWorker, &Parser::receivedResend, senderWorker, &Sender::receivedResend);
+    connect(parserWorker, &Parser::receivedStart, senderWorker, &Sender::receivedStart);
+    connect(senderWorker, &Sender::errorReceived, this, &MainWindow::serialError);
+    connect(senderWorker, &Sender::dataReceived, parserWorker, &Parser::parse, Qt::QueuedConnection);
+    connect(senderWorker, &Sender::dataReceived, this, &MainWindow::readSerial, Qt::QueuedConnection);
     connect(senderWorker, &Sender::reportProgress, this, &MainWindow::updateFileProgress);
     connect(senderWorker, &Sender::baudrateSetFailed, this, &MainWindow::baudrateSetFailed);
     connect(this, &MainWindow::setFile, senderWorker, &Sender::setFile);
@@ -587,7 +587,7 @@ void MainWindow::checkStatus()
     //We want to check for few things here:
     //if we are checking temperature at all and
     //if the time passed from the time we last
-    //recieved update is more than the check
+    //received update is more than the check
     //interval
     if(checkingTemperature
             &&(sinceLastTemp->elapsed() > statusTimer->interval())) emit injectCommand("M105");
@@ -818,19 +818,19 @@ void MainWindow::sendEEPROMsettings(QStringList changes)
     }
 }
 
-void MainWindow::EEPROMSettingRecieved(QString esetting)
+void MainWindow::EEPROMSettingReceived(QString esetting)
 {
     EEPROMSettings.append(esetting);
 }
 
-void MainWindow::recievedError()
+void MainWindow::receivedError()
 {
-    //This should be raised if "!!" recieved
+    //This should be raised if "!!" received
     ErrorWindow errorwindow(this,"Hardware failure");
     errorwindow.exec();
 }
 
-void MainWindow::recievedSDDone()
+void MainWindow::receivedSDDone()
 {
     sdprinting=false;
     ui->progressBar->setValue(0);
diff --git a/mainwindow.h b/mainwindow.h
index 2271519..09a7392 100644
--- a/mainwindow.h
+++ b/mainwindow.h
@@ -94,9 +94,9 @@ private slots:
     void openEEPROMeditor();
     void sendEEPROMsettings(QStringList changes);
     void updateTemperature(TemperatureReadings r);
-    void EEPROMSettingRecieved(QString esetting);
-    void recievedError();
-    void recievedSDDone();
+    void EEPROMSettingReceived(QString esetting);
+    void receivedError();
+    void receivedSDDone();
     void parseFile(QString filename);
     void recentClicked();
     void updateFileProgress(FileProgress);
@@ -149,7 +149,7 @@ private slots:
 signals:
     void sdReady();
     void eepromReady();
-    void recievedData(QByteArray);
+    void receivedData(QByteArray);
     void startedReadingEEPROM();
 
     void openPort(QSerialPortInfo i);
diff --git a/parser.cpp b/parser.cpp
index d4dcef7..52f6b1b 100644
--- a/parser.cpp
+++ b/parser.cpp
@@ -33,7 +33,7 @@ void Parser::parse(QByteArray data)
             else
             {
                 readingFiles = false;
-                emit recievedSDFilesList(SDFilesList);
+                emit receivedSDFilesList(SDFilesList);
             }
             return;
         }
@@ -44,7 +44,7 @@ void Parser::parse(QByteArray data)
             {
                 if(data.startsWith("EPR"))
                 {
-                    emit recievedEEPROMLine(QString(data));
+                    emit receivedEEPROMLine(QString(data));
                     EEPROMReadingStarted = true;
                 }
                 else if(EEPROMReadingStarted)
@@ -62,8 +62,8 @@ void Parser::parse(QByteArray data)
         {
             QStringList tmp = QString(data).split(' ');
             if(tmp.size() > 1)
-                emit recievedOkNum(tmp.at(1).toInt());
-            else emit recievedOkNum(0);
+                emit receivedOkNum(tmp.at(1).toInt());
+            else emit receivedOkNum(0);
         }
         */
         else if(data.contains("T:"))
@@ -79,14 +79,14 @@ void Parser::parse(QByteArray data)
 
             r.raw = QString(data);
 
-            emit recievedTemperature(r);
+            emit receivedTemperature(r);
         }
-        //else if(data.startsWith("wait")) emit recievedOkWait();
+        //else if(data.startsWith("wait")) emit receivedOkWait();
         else if(data.startsWith("rs") || data.toLower().startsWith("resend"))
-            emit recievedResend(data.split(':').at(1).toInt());
-        else if(data.startsWith("!!")) emit recievedError();
-        else if(data.startsWith("Done")) emit recievedSDDone();
-        else if(data.startsWith("start")) emit recievedStart();
+            emit receivedResend(data.split(':').at(1).toInt());
+        else if(data.startsWith("!!")) emit receivedError();
+        else if(data.startsWith("Done")) emit receivedSDDone();
+        else if(data.startsWith("start")) emit receivedStart();
         else if(data.startsWith("SD pr"))
         {
             SDProgress p;
@@ -102,7 +102,7 @@ void Parser::parse(QByteArray data)
             }
             else return;
 
-            emit recievedSDUpdate(p);
+            emit receivedSDUpdate(p);
 
         }
         else if(data.startsWith("Not SD "));
@@ -111,8 +111,8 @@ void Parser::parse(QByteArray data)
             SDFilesList.clear();
             readingFiles = true; //start reading files from SD
         }
-        //else if(data.contains("REPETIER")) emit recievedFirmware(Repetier);
-        //else if(data.contains("MARLIN")) emit recievedFirmware(Marlin);
+        //else if(data.contains("REPETIER")) emit receivedFirmware(Repetier);
+        //else if(data.contains("MARLIN")) emit receivedFirmware(Marlin);
     }
 }
 
diff --git a/parser.h b/parser.h
index f6af475..0b121c3 100644
--- a/parser.h
+++ b/parser.h
@@ -26,18 +26,18 @@ protected:
     bool EEPROMReadingStarted;
 
 signals:
-    void recievedTemperature(TemperatureReadings);
-    void recievedSDUpdate(SDProgress);
-    void recievedEEPROMLine(QString);
+    void receivedTemperature(TemperatureReadings);
+    void receivedSDUpdate(SDProgress);
+    void receivedEEPROMLine(QString);
     void recievingEEPROMDone();
-    void recievedSDFilesList(QStringList);
-    void recievedOkWait();
-    void recievedOkNum(int);
-    void recievedStart();
-    void recievedResend(int);
-    void recievedError();
-    void recievedFirmware(int);
-    void recievedSDDone();
+    void receivedSDFilesList(QStringList);
+    void receivedOkWait();
+    void receivedOkNum(int);
+    void receivedStart();
+    void receivedResend(int);
+    void receivedError();
+    void receivedFirmware(int);
+    void receivedSDDone();
 
 public slots:
     void parse(QByteArray data);
diff --git a/sender.cpp b/sender.cpp
index da00742..3a6678c 100644
--- a/sender.cpp
+++ b/sender.cpp
@@ -11,7 +11,7 @@ Sender::Sender(QObject *parent) : QObject(parent)
     sendingChecksum=false;
     paused=false;
     sending=false;
-    readyRecieve = false;
+    readyReceive = false;
     printer = new QSerialPort(this);
     sendTimer = new QTimer(this);
 
@@ -23,8 +23,8 @@ Sender::Sender(QObject *parent) : QObject(parent)
 
     sendTimer->start();
 
-    connect(printer, SIGNAL(error(QSerialPort::SerialPortError)), this, SLOT(recievedError(QSerialPort::SerialPortError)));
-    connect(printer, &QSerialPort::readyRead, this, &Sender::recievedData);
+    connect(printer, SIGNAL(error(QSerialPort::SerialPortError)), this, SLOT(receivedError(QSerialPort::SerialPortError)));
+    connect(printer, &QSerialPort::readyRead, this, &Sender::receivedData);
     connect(sendTimer, &QTimer::timeout, this, &Sender::sendNext);
 }
 
@@ -37,7 +37,7 @@ Sender::~Sender()
 //Mainloop of sending
 void Sender::sendNext()
 {
-    if(printer->isWritable() && readyRecieve)
+    if(printer->isWritable() && readyReceive)
     {
         if(sendingChecksum && resending)
         {
@@ -63,7 +63,7 @@ void Sender::sendNext()
         if(!userCommands.isEmpty()) //Inject user command
         {
             sendLine(userCommands.dequeue());
-            readyRecieve = false;
+            readyReceive = false;
             return;
         }
         else if(sending && !paused) //Send line of gcode
@@ -83,7 +83,7 @@ void Sender::sendNext()
             }
             sendLine(gcode.at(currentLine));
             currentLine++;
-            readyRecieve=false;
+            readyReceive=false;
 
             p.P = currentLine;
             p.T = gcode.size();
@@ -170,19 +170,19 @@ void Sender::injectCommand(QString command)
     if(!userCommands.contains(command)) userCommands.enqueue(command);
 }
 
-void Sender::recievedOkWait()
+void Sender::receivedOkWait()
 {
-    readyRecieve = true;
+    readyReceive = true;
 }
 
-void Sender::recievedOkNum(int)
+void Sender::receivedOkNum(int)
 {
-    readyRecieve = true;
+    readyReceive = true;
 }
 
-void Sender::recievedStart()
+void Sender::receivedStart()
 {
-    readyRecieve = true;
+    readyReceive = true;
 }
 
 void Sender::flushInjectionBuffer()
@@ -190,7 +190,7 @@ void Sender::flushInjectionBuffer()
     userCommands.clear();
 }
 
-void Sender::recievedResend(int r)
+void Sender::receivedResend(int r)
 {
     if(sendingChecksum)
     {
@@ -200,23 +200,23 @@ void Sender::recievedResend(int r)
     else currentLine--;
 }
 
-void Sender::recievedData()
+void Sender::receivedData()
 {
     if(printer->canReadLine())
     {
         QByteArray data = printer->readLine();
         if(data == "") return;
-        emit dataRecieved(data);
+        emit dataReceived(data);
         //Yeah, yeah, I know. This class is called "Sender", but checking this here is faster.
-        if(data.startsWith("ok") || data.startsWith("wa")) readyRecieve=true;
+        if(data.startsWith("ok") || data.startsWith("wa")) readyReceive=true;
     }
 }
 
-void Sender::recievedError(QSerialPort::SerialPortError error)
+void Sender::receivedError(QSerialPort::SerialPortError error)
 {
     if(error > 0)
     {
         closePort();
-        emit errorRecieved(error);
+        emit errorReceived(error);
     }
 }
diff --git a/sender.h b/sender.h
index e456fb3..ce863e3 100644
--- a/sender.h
+++ b/sender.h
@@ -30,7 +30,7 @@ protected:
     bool paused;
     bool sending;
     bool dtr;
-    bool readyRecieve;
+    bool readyReceive;
     bool sendingChecksum;
     bool resending;
     QQueue <QString> userCommands;
@@ -40,8 +40,8 @@ protected:
     bool sendLine(QString s);
 
 signals:
-    void errorRecieved(QSerialPort::SerialPortError error);
-    void dataRecieved(QByteArray data);
+    void errorReceived(QSerialPort::SerialPortError error);
+    void dataReceived(QByteArray data);
     void reportProgress(FileProgress p);
     void baudrateSetFailed(int b);
 
@@ -56,15 +56,15 @@ public slots:
     void injectCommand(QString);
     void flushInjectionBuffer();
 
-    void recievedOkWait();
-    void recievedOkNum(int);
-    void recievedStart();
-    void recievedResend(int r);
+    void receivedOkWait();
+    void receivedOkNum(int);
+    void receivedStart();
+    void receivedResend(int r);
 
     void sendNext();
 
-    void recievedData();
-    void recievedError(QSerialPort::SerialPortError error);
+    void receivedData();
+    void receivedError(QSerialPort::SerialPortError error);
 };
 
 #endif // SENDER_H