diff --git a/src/main.cpp b/src/main.cpp
index f23beb7..a451860 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -32,11 +32,16 @@ namespace HighGround {
         };
 
         class HGData {
-            std::variant<int64_t, std::string, double, bool, char> data;
+            typedef std::variant<int64_t, std::string, double, bool, char> varData; 
+            varData data;
             public:
             HGDataType type = HGDataType::Int;
             HGData() = default;
-            HGData(int64_t in) : data(in) {}
+            HGData(int64_t in) : data(in), type(HGDataType::Int) {}
+            HGData(double in) : data(in), type(HGDataType::Double) {}
+            HGData(std::string in) : data(in), type(HGDataType::String) {}
+            HGData(char in) : data(in), type(HGDataType::Char) {}
+            HGData(bool in) : data(in), type(HGDataType::Bool) {}
             std::optional<int64_t> getInt() {
                 if (type == HGDataType::Int) {
                     return std::get<int64_t>(data);
@@ -44,6 +49,34 @@ namespace HighGround {
                     return {};
                 }
             }
+            std::optional<double> getDouble() {
+                if (type == HGDataType::Double) {
+                    return std::get<double>(data);
+                } else {
+                    return {};
+                }
+            }
+            std::optional<std::string> getString() {
+                if (type == HGDataType::String) {
+                    return std::get<std::string>(data);
+                } else {
+                    return {};
+                }
+            }
+            std::optional<char> getChar() {
+                if (type == HGDataType::Char) {
+                    return std::get<char>(data);
+                } else {
+                    return {};
+                }
+            }
+            std::optional<bool> getBool() {
+                if (type == HGDataType::Bool) {
+                    return std::get<bool>(data);
+                } else {
+                    return {};
+                }
+            }
         };
 
         class HGNode {
@@ -79,6 +112,35 @@ namespace HighGround {
                                 if (dataopt) {
                                     groundAddValueToInstruction(&gi, groundCreateValue(INT, dataopt.value()));
                                 }
+                                break;
+                            }
+                            case HGDataType::Double: {
+                                auto dataopt = data.getDouble();
+                                if (dataopt) {
+                                    groundAddValueToInstruction(&gi, groundCreateValue(DOUBLE, dataopt.value()));
+                                }
+                                break;
+                            }
+                            case HGDataType::String: {
+                                auto dataopt = data.getString();
+                                if (dataopt) {
+                                    groundAddValueToInstruction(&gi, groundCreateValue(STRING, dataopt.value().c_str()));
+                                }
+                                break;
+                            }
+                            case HGDataType::Char: {
+                                auto dataopt = data.getChar();
+                                if (dataopt) {
+                                    groundAddValueToInstruction(&gi, groundCreateValue(CHAR, dataopt.value()));
+                                }
+                                break;
+                            }
+                            case HGDataType::Bool: {
+                                auto dataopt = data.getBool();
+                                if (dataopt) {
+                                    groundAddValueToInstruction(&gi, groundCreateValue(BOOL, dataopt.value()));
+                                }
+                                break;
                             }
                         }
                         codeBlock.code.push_back(gi);
@@ -136,6 +198,24 @@ namespace HighGround {
                 }
                 return true;
             }
+            bool isString(std::string in) {
+                if (in.size() > 1 && in[0] == '"' && in.back() == '"') {
+                    return true;
+                }
+                return false;
+            }
+            bool isChar(std::string in) {
+                if (in.size() == 3 && in[0] == '\'' && in.back() == '\'') {
+                    return true;
+                }
+                return false;
+            }
+            bool isBool(std::string in) {
+                if (in == "true" || in == "false") {
+                    return true;
+                }
+                return false;
+            }
 
             HGDataType getDataType(std::string in) {
                 if (isInt(in)) {
@@ -144,6 +224,15 @@ namespace HighGround {
                 if (isDouble(in)) {
                     return HGDataType::Double;
                 }
+                if (isString(in)) {
+                    return HGDataType::String;
+                }
+                if (isChar(in)) {
+                    return HGDataType::Char;
+                }
+                if (isBool(in)) {
+                    return HGDataType::Bool;
+                }
                 return HGDataType::None;
             }
 
@@ -167,12 +256,35 @@ namespace HighGround {
                         case HGNodeType::Value: {
                             switch (getDataType(token)) {
                                 case HGDataType::Int: {
-                                    std::cout << "We have an int\n";
                                     HGNode intNode(HGNodeType::Value);
-                                    intNode.setValue(std::stoll(token));
+                                    intNode.setValue((int64_t) std::stoll(token));
                                     rootNode.addNode(intNode);
                                     break;
                                 }
+                                case HGDataType::Double: {
+                                    HGNode doubleNode(HGNodeType::Value);
+                                    doubleNode.setValue(std::stod(token));
+                                    rootNode.addNode(doubleNode);
+                                    break;
+                                }
+                                case HGDataType::String: {
+                                    HGNode stringNode(HGNodeType::Value);
+                                    stringNode.setValue(token.substr(1, token.size() - 2));
+                                    rootNode.addNode(stringNode);
+                                    break;
+                                }
+                                case HGDataType::Char: {
+                                    HGNode charNode(HGNodeType::Value);
+                                    charNode.setValue(token[1]);
+                                    rootNode.addNode(charNode);
+                                    break;
+                                }
+                                case HGDataType::Bool: {
+                                    HGNode boolNode(HGNodeType::Value);
+                                    boolNode.setValue(token == "true");
+                                    rootNode.addNode(boolNode);
+                                    break;
+                                }
                             }
                             break;
                         }
diff --git a/tests/data.hg b/tests/data.hg
new file mode 100644
index 0000000..5509d65
--- /dev/null
+++ b/tests/data.hg
@@ -0,0 +1,5 @@
+"dingus"
+432
+3.141
+'c'
+true