diff --git a/Compiler/CodeGen/generator.cpp b/Compiler/CodeGen/generator.cpp
new file mode 100644
index 0000000..88d624a
--- /dev/null
+++ b/Compiler/CodeGen/generator.cpp
@@ -0,0 +1,154 @@
+#include "generator.hpp"
+#include <iostream>
+
+namespace sakoraE::CodeGen {
+
+    llvm::Value* CodeGenerator::generate(NodePtr node) {
+        if (!node) return nullptr;
+        switch (node->getTag()) {
+            case ASTTag::LiteralNode: return genLiteralNode(node);
+            case ASTTag::IndexOpNode: return genIndexOpNode(node);
+            case ASTTag::CallingOpNode: return genCallingOpNode(node);
+            case ASTTag::AtomIdentifierNode: return genAtomIdentifierNode(node);
+            case ASTTag::IdentifierExprNode: return genIdentifierExprNode(node);
+            case ASTTag::PrimExprNode: return genPrimExprNode(node);
+            case ASTTag::MulExprNode: return genMulExprNode(node);
+            case ASTTag::AddExprNode: return genAddExprNode(node);
+            case ASTTag::LogicExprNode: return genLogicExprNode(node);
+            case ASTTag::BinaryExprNode: return genBinaryExprNode(node);
+            case ASTTag::ArrayExprNode: return genArrayExprNode(node);
+            case ASTTag::WholeExprNode: return genWholeExprNode(node);
+            case ASTTag::AssignExprNode: return genAssignExprNode(node);
+            case ASTTag::RangeExprNode: return genRangeExprNode(node);
+
+            case ASTTag::DeclareStmtNode: return genDeclareStmtNode(node);
+            case ASTTag::ExprStmtNode: return genExprStmtNode(node);
+            case ASTTag::IfStmtNode: return genIfStmtNode(node);
+            case ASTTag::ElseStmtNode: return genElseStmtNode(node);
+            case ASTTag::WhileStmtNode: return genWhileStmtNode(node);
+            case ASTTag::ForStmtNode: return genForStmtNode(node);
+            case ASTTag::BlockStmtNode: return genBlockStmtNode(node);
+            case ASTTag::FuncDefineStmtNode: return genFuncDefineStmtNode(node);
+            case ASTTag::ReturnStmtNode: return genReturnStmtNode(node);
+            
+            default: return nullptr;
+        }
+    }
+
+    llvm::Value* CodeGenerator::genLiteralNode(NodePtr node) {
+        // TODO: Implement Literal generation (Int, Float, String, etc.)
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genIndexOpNode(NodePtr node) {
+        // TODO: Implement Array Indexing
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genCallingOpNode(NodePtr node) {
+        // TODO: Implement Function Call
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genAtomIdentifierNode(NodePtr node) {
+        // TODO: Implement Atom Identifier resolution
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genIdentifierExprNode(NodePtr node) {
+        // TODO: Implement Identifier Expression
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genPrimExprNode(NodePtr node) {
+        // TODO: Implement Primary Expression
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genMulExprNode(NodePtr node) {
+        // TODO: Implement Multiplication/Division
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genAddExprNode(NodePtr node) {
+        // TODO: Implement Addition/Subtraction
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genLogicExprNode(NodePtr node) {
+        // TODO: Implement Logic Operations (AND, OR)
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genBinaryExprNode(NodePtr node) {
+        // TODO: Implement Binary Expressions
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genArrayExprNode(NodePtr node) {
+        // TODO: Implement Array Literals or Expressions
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genWholeExprNode(NodePtr node) {
+        // TODO: Implement Whole Expression wrapper
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genAssignExprNode(NodePtr node) {
+        // TODO: Implement Assignment
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genRangeExprNode(NodePtr node) {
+        // TODO: Implement Range logic
+        return nullptr;
+    }
+
+    // Statements
+    llvm::Value* CodeGenerator::genDeclareStmtNode(NodePtr node) {
+        // TODO: Implement Variable Declaration (Alloca)
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genExprStmtNode(NodePtr node) {
+        // TODO: Implement Expression Statement
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genIfStmtNode(NodePtr node) {
+        // TODO: Implement If Statement (Control Flow)
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genElseStmtNode(NodePtr node) {
+        // TODO: Implement Else block
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genWhileStmtNode(NodePtr node) {
+        // TODO: Implement While Loop
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genForStmtNode(NodePtr node) {
+        // TODO: Implement For Loop
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genBlockStmtNode(NodePtr node) {
+        // TODO: Implement Block Scope
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genFuncDefineStmtNode(NodePtr node) {
+        // TODO: Implement Function Definition
+        return nullptr;
+    }
+
+    llvm::Value* CodeGenerator::genReturnStmtNode(NodePtr node) {
+        // TODO: Implement Return Statement
+        return nullptr;
+    }
+
+}
diff --git a/Compiler/CodeGen/generator.hpp b/Compiler/CodeGen/generator.hpp
new file mode 100644
index 0000000..6e23ceb
--- /dev/null
+++ b/Compiler/CodeGen/generator.hpp
@@ -0,0 +1,76 @@
+#ifndef SAKORAE_GENERATOR_HPP
+#define SAKORAE_GENERATOR_HPP
+
+#include <llvm/IR/Value.h>
+#include <llvm/IR/Type.h>
+#include <llvm/IR/LLVMContext.h>
+#include <llvm/IR/Module.h>
+#include <llvm/IR/IRBuilder.h>
+#include <llvm/IR/Verifier.h>
+#include <memory>
+#include <vector>
+#include <iostream>
+
+#include "../Frontend/AST.hpp"
+#include "../IR/symbol.hpp"
+
+namespace sakoraE::CodeGen {
+    using namespace sakoraE::IR;
+
+    class CodeGenerator {
+    private:
+        std::unique_ptr<llvm::LLVMContext> context;
+        std::unique_ptr<llvm::Module> module;
+        std::unique_ptr<llvm::IRBuilder<>> builder;
+        SymbolManager symManager;
+
+    public:
+        CodeGenerator() {
+            context = std::make_unique<llvm::LLVMContext>();
+            module = std::make_unique<llvm::Module>("SakuraE_Module", *context);
+            builder = std::make_unique<llvm::IRBuilder<>>(*context);
+            symManager.NewMap();
+        }
+
+        llvm::Module* getModule() { return module.get(); }
+        llvm::LLVMContext* getContext() { return context.get(); }
+        llvm::IRBuilder<>* getBuilder() { return builder.get(); }
+
+        llvm::Value* generate(NodePtr node);
+
+    private:
+        // Expressions
+        llvm::Value* genLiteralNode(NodePtr node);
+        llvm::Value* genIndexOpNode(NodePtr node);
+        llvm::Value* genCallingOpNode(NodePtr node);
+        llvm::Value* genAtomIdentifierNode(NodePtr node);
+        llvm::Value* genIdentifierExprNode(NodePtr node);
+        llvm::Value* genPrimExprNode(NodePtr node);
+        llvm::Value* genMulExprNode(NodePtr node);
+        llvm::Value* genAddExprNode(NodePtr node);
+        llvm::Value* genLogicExprNode(NodePtr node);
+        llvm::Value* genBinaryExprNode(NodePtr node);
+        llvm::Value* genArrayExprNode(NodePtr node);
+        llvm::Value* genWholeExprNode(NodePtr node);
+        llvm::Value* genAssignExprNode(NodePtr node);
+        llvm::Value* genRangeExprNode(NodePtr node);
+
+        // Statements
+        llvm::Value* genDeclareStmtNode(NodePtr node);
+        llvm::Value* genExprStmtNode(NodePtr node);
+        llvm::Value* genIfStmtNode(NodePtr node);
+        llvm::Value* genElseStmtNode(NodePtr node);
+        llvm::Value* genWhileStmtNode(NodePtr node);
+        llvm::Value* genForStmtNode(NodePtr node);
+        llvm::Value* genBlockStmtNode(NodePtr node);
+        llvm::Value* genFuncDefineStmtNode(NodePtr node);
+        llvm::Value* genReturnStmtNode(NodePtr node);
+
+        llvm::Value* logError(const char* str) {
+            std::cerr << "CodeGen Error: " << str << std::endl;
+            return nullptr;
+        }
+    };
+}
+
+#endif // ! SAKORAE_GENERATOR_HPP