diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0fdccae..c310f42 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,7 +13,7 @@ pkg_check_modules(NIX_UTIL REQUIRED IMPORTED_TARGET nix-util)
 pkg_check_modules(NIX_FETCHERS REQUIRED IMPORTED_TARGET nix-fetchers)
 pkg_check_modules(NIX_MAIN REQUIRED IMPORTED_TARGET nix-main)
 
-# nix-irc (External IR Compiler)
+# nix-irc
 add_executable(nix-irc
     src/irc/main.cpp
     src/irc/parser.cpp
@@ -41,6 +41,7 @@ add_library(nix-ir-plugin MODULE
     src/irc/resolver.cpp
     src/irc/ir_gen.cpp
     src/irc/serializer.cpp
+    src/irc/evaluator.cpp
 )
 
 # Include directories from pkg-config
diff --git a/src/irc/evaluator.cpp b/src/irc/evaluator.cpp
new file mode 100644
index 0000000..8aa64c7
--- /dev/null
+++ b/src/irc/evaluator.cpp
@@ -0,0 +1,482 @@
+#ifdef unix
+#undef unix
+#endif
+
+#include "evaluator.h"
+#include "nix/expr/eval.hh"
+#include "nix/expr/value.hh"
+#include "nix/util/error.hh"
+
+#include <unordered_map>
+#include <stdexcept>
+
+namespace nix_irc {
+
+using namespace nix;
+
+struct IREnvironment {
+    IREnvironment* parent;
+    std::vector<Value*> bindings;
+    Value* with_attrs;
+
+    explicit IREnvironment(IREnvironment* p = nullptr) : parent(p), with_attrs(nullptr) {}
+
+    IREnvironment* push() {
+        return new IREnvironment(this);
+    }
+
+    void bind(Value* val) {
+        bindings.push_back(val);
+    }
+
+    Value* lookup(uint32_t index) {
+        IREnvironment* env = this;
+        while (env) {
+            if (index < env->bindings.size()) {
+                return env->bindings[index];
+            }
+            index -= env->bindings.size();
+            env = env->parent;
+        }
+        return nullptr;
+    }
+
+    Value* lookup_with(EvalState& state, const std::string& name) {
+        IREnvironment* env = this;
+        while (env) {
+            if (env->with_attrs && env->with_attrs->type() == nAttrs) {
+                auto sym = state.symbols.create(name);
+                auto attr = env->with_attrs->attrs()->get(sym);
+                if (attr) {
+                    return attr->value;
+                }
+            }
+            env = env->parent;
+        }
+        return nullptr;
+    }
+};
+
+struct Thunk {
+    std::shared_ptr<Node> expr;
+    IREnvironment* env;
+    bool blackholed;
+
+    Thunk(std::shared_ptr<Node> e, IREnvironment* en)
+        : expr(e), env(en), blackholed(false) {}
+};
+
+struct Evaluator::Impl {
+    EvalState& state;
+    std::unordered_map<Value*, std::unique_ptr<Thunk>> thunks;
+    std::vector<std::unique_ptr<IREnvironment>> environments;
+
+    explicit Impl(EvalState& s) : state(s) {}
+
+    ~Impl() {
+        for (auto& env : environments) {
+            delete env.release();
+        }
+    }
+
+    IREnvironment* make_env(IREnvironment* parent = nullptr) {
+        auto env = new IREnvironment(parent);
+        environments.push_back(std::unique_ptr<IREnvironment>(env));
+        return env;
+    }
+
+    Value* make_thunk(const std::shared_ptr<Node>& expr, IREnvironment* env) {
+        Value* v = state.allocValue();
+        thunks[v] = std::make_unique<Thunk>(expr, env);
+        return v;
+    }
+
+    void force(Value* v) {
+        auto it = thunks.find(v);
+        if (it == thunks.end()) {
+            return;
+        }
+
+        Thunk* thunk = it->second.get();
+        if (thunk->blackholed) {
+            state.error<EvalError>("infinite recursion encountered").debugThrow();
+        }
+
+        thunk->blackholed = true;
+        eval_node(thunk->expr, *v, thunk->env);
+        thunks.erase(it);
+    }
+
+    void eval_node(const std::shared_ptr<Node>& node, Value& v, IREnvironment* env) {
+        if (!node) {
+            v.mkNull();
+            return;
+        }
+
+        if (auto* n = node->get_if<ConstIntNode>()) {
+            v.mkInt(n->value);
+        }
+        else if (auto* n = node->get_if<ConstStringNode>()) {
+            v.mkString(n->value);
+        }
+        else if (auto* n = node->get_if<ConstPathNode>()) {
+            v.mkPath(state.rootPath(CanonPath(n->value)));
+        }
+        else if (auto* n = node->get_if<ConstBoolNode>()) {
+            v.mkBool(n->value);
+        }
+        else if (auto* n = node->get_if<ConstNullNode>()) {
+            v.mkNull();
+        }
+        else if (auto* n = node->get_if<VarNode>()) {
+            Value* bound = env ? env->lookup(n->index) : nullptr;
+            if (!bound && env && n->name.has_value()) {
+                bound = env->lookup_with(state, n->name.value());
+            }
+            if (!bound) {
+                state.error<EvalError>("variable not found").debugThrow();
+            }
+            force(bound);
+            v = *bound;
+        }
+        else if (auto* n = node->get_if<LambdaNode>()) {
+            auto lambda_env = env;
+            auto body = n->body;
+
+            auto primOp = [this, lambda_env, body](EvalState& state, PosIdx pos,
+                                                   Value** args, Value& result) {
+                auto call_env = make_env(lambda_env);
+                call_env->bind(args[0]);
+                eval_node(body, result, call_env);
+            };
+
+            v.mkPrimOp(new PrimOp {
+                .name = n->param_name.value_or("lambda"),
+                .arity = static_cast<size_t>(n->arity),
+                .fun = primOp
+            });
+        }
+        else if (auto* n = node->get_if<AppNode>()) {
+            Value* func_val = state.allocValue();
+            eval_node(n->func, *func_val, env);
+            force(func_val);
+
+            Value* arg_val = make_thunk(n->arg, env);
+
+            state.callFunction(*func_val, *arg_val, v, noPos);
+        }
+        else if (auto* n = node->get_if<BinaryOpNode>()) {
+            Value* left = state.allocValue();
+            Value* right = state.allocValue();
+
+            switch (n->op) {
+                case BinaryOp::AND:
+                    eval_node(n->left, *left, env);
+                    force(left);
+                    if (left->type() != nBool) {
+                        state.error<EvalError>("type error in logical AND").debugThrow();
+                    }
+                    if (!left->boolean()) {
+                        v.mkBool(false);
+                    } else {
+                        eval_node(n->right, *right, env);
+                        force(right);
+                        if (right->type() != nBool) {
+                            state.error<EvalError>("type error in logical AND").debugThrow();
+                        }
+                        v.mkBool(right->boolean());
+                    }
+                    break;
+                case BinaryOp::OR:
+                    eval_node(n->left, *left, env);
+                    force(left);
+                    if (left->type() != nBool) {
+                        state.error<EvalError>("type error in logical OR").debugThrow();
+                    }
+                    if (left->boolean()) {
+                        v.mkBool(true);
+                    } else {
+                        eval_node(n->right, *right, env);
+                        force(right);
+                        if (right->type() != nBool) {
+                            state.error<EvalError>("type error in logical OR").debugThrow();
+                        }
+                        v.mkBool(right->boolean());
+                    }
+                    break;
+                case BinaryOp::IMPL:
+                    eval_node(n->left, *left, env);
+                    force(left);
+                    if (left->type() != nBool) {
+                        state.error<EvalError>("type error in implication").debugThrow();
+                    }
+                    if (!left->boolean()) {
+                        v.mkBool(true);
+                    } else {
+                        eval_node(n->right, *right, env);
+                        force(right);
+                        if (right->type() != nBool) {
+                            state.error<EvalError>("type error in implication").debugThrow();
+                        }
+                        v.mkBool(right->boolean());
+                    }
+                    break;
+                default:
+                    eval_node(n->left, *left, env);
+                    eval_node(n->right, *right, env);
+                    force(left);
+                    force(right);
+
+                    switch (n->op) {
+                        case BinaryOp::ADD:
+                            if (left->type() == nInt && right->type() == nInt) {
+                                v.mkInt((left->integer() + right->integer()).valueWrapping());
+                            } else {
+                                state.error<EvalError>("type error in addition").debugThrow();
+                            }
+                            break;
+                        case BinaryOp::SUB:
+                            if (left->type() == nInt && right->type() == nInt) {
+                                v.mkInt((left->integer() - right->integer()).valueWrapping());
+                            } else {
+                                state.error<EvalError>("type error in subtraction").debugThrow();
+                            }
+                            break;
+                        case BinaryOp::MUL:
+                            if (left->type() == nInt && right->type() == nInt) {
+                                v.mkInt((left->integer() * right->integer()).valueWrapping());
+                            } else {
+                                state.error<EvalError>("type error in multiplication").debugThrow();
+                            }
+                            break;
+                        case BinaryOp::DIV:
+                            if (left->type() == nInt && right->type() == nInt) {
+                                if (right->integer() == NixInt(0)) {
+                                    state.error<EvalError>("division by zero").debugThrow();
+                                }
+                                v.mkInt((left->integer() / right->integer()).valueWrapping());
+                            } else {
+                                state.error<EvalError>("type error in division").debugThrow();
+                            }
+                            break;
+                        case BinaryOp::EQ:
+                            v.mkBool(state.eqValues(*left, *right, noPos, ""));
+                            break;
+                        case BinaryOp::NE:
+                            v.mkBool(!state.eqValues(*left, *right, noPos, ""));
+                            break;
+                        case BinaryOp::LT:
+                            if (left->type() == nInt && right->type() == nInt) {
+                                v.mkBool(left->integer() < right->integer());
+                            } else {
+                                state.error<EvalError>("type error in comparison").debugThrow();
+                            }
+                            break;
+                        case BinaryOp::GT:
+                            if (left->type() == nInt && right->type() == nInt) {
+                                v.mkBool(left->integer() > right->integer());
+                            } else {
+                                state.error<EvalError>("type error in comparison").debugThrow();
+                            }
+                            break;
+                        case BinaryOp::LE:
+                            if (left->type() == nInt && right->type() == nInt) {
+                                v.mkBool(left->integer() <= right->integer());
+                            } else {
+                                state.error<EvalError>("type error in comparison").debugThrow();
+                            }
+                            break;
+                        case BinaryOp::GE:
+                            if (left->type() == nInt && right->type() == nInt) {
+                                v.mkBool(left->integer() >= right->integer());
+                            } else {
+                                state.error<EvalError>("type error in comparison").debugThrow();
+                            }
+                            break;
+                        case BinaryOp::CONCAT:
+                            if (left->type() == nString && right->type() == nString) {
+                                v.mkString(std::string(left->c_str()) + std::string(right->c_str()));
+                            } else {
+                                state.error<EvalError>("type error in concatenation").debugThrow();
+                            }
+                            break;
+                        default:
+                            state.error<EvalError>("unknown binary operator").debugThrow();
+                    }
+                    break;
+            }
+        }
+        else if (auto* n = node->get_if<UnaryOpNode>()) {
+            Value* operand = state.allocValue();
+            eval_node(n->operand, *operand, env);
+            force(operand);
+
+            switch (n->op) {
+                case UnaryOp::NEG:
+                    if (operand->type() == nInt) {
+                        v.mkInt((NixInt(0) - operand->integer()).valueWrapping());
+                    } else {
+                        state.error<EvalError>("type error in negation").debugThrow();
+                    }
+                    break;
+                case UnaryOp::NOT:
+                    if (operand->type() == nBool) {
+                        v.mkBool(!operand->boolean());
+                    } else {
+                        state.error<EvalError>("type error in logical NOT").debugThrow();
+                    }
+                    break;
+                default:
+                    state.error<EvalError>("unknown unary operator").debugThrow();
+            }
+        }
+        else if (auto* n = node->get_if<IfNode>()) {
+            Value* cond = state.allocValue();
+            eval_node(n->cond, *cond, env);
+            force(cond);
+
+            if (cond->type() != nBool) {
+                state.error<EvalError>("condition must be a boolean").debugThrow();
+            }
+
+            if (cond->boolean()) {
+                eval_node(n->then_branch, v, env);
+            } else {
+                eval_node(n->else_branch, v, env);
+            }
+        }
+        else if (auto* n = node->get_if<LetNode>()) {
+            auto let_env = make_env(env);
+            for (const auto& [name, expr] : n->bindings) {
+                Value* val = make_thunk(expr, env);
+                let_env->bind(val);
+            }
+            eval_node(n->body, v, let_env);
+        }
+        else if (auto* n = node->get_if<LetRecNode>()) {
+            auto letrec_env = make_env(env);
+            std::vector<Value*> thunk_vals;
+
+            for (const auto& [name, expr] : n->bindings) {
+                Value* val = make_thunk(expr, letrec_env);
+                thunk_vals.push_back(val);
+                letrec_env->bind(val);
+            }
+
+            eval_node(n->body, v, letrec_env);
+        }
+        else if (auto* n = node->get_if<AttrsetNode>()) {
+            auto bindings = state.buildBindings(n->attrs.size());
+
+            IREnvironment* attr_env = env;
+            if (n->recursive) {
+                attr_env = make_env(env);
+                for (const auto& [key, val] : n->attrs) {
+                    Value* thunk = make_thunk(val, attr_env);
+                    attr_env->bind(thunk);
+                }
+            }
+
+            for (const auto& [key, val] : n->attrs) {
+                Value* attr_val = state.allocValue();
+                if (n->recursive) {
+                    eval_node(val, *attr_val, attr_env);
+                } else {
+                    eval_node(val, *attr_val, env);
+                }
+                bindings.insert(state.symbols.create(key), attr_val);
+            }
+
+            v.mkAttrs(bindings.finish());
+        }
+        else if (auto* n = node->get_if<SelectNode>()) {
+            Value* obj = state.allocValue();
+            eval_node(n->expr, *obj, env);
+            force(obj);
+
+            Value* attr_val = state.allocValue();
+            eval_node(n->attr, *attr_val, env);
+            force(attr_val);
+
+            if (obj->type() != nAttrs) {
+                state.error<EvalError>("selection on non-attrset").debugThrow();
+            }
+
+            if (attr_val->type() != nString) {
+                state.error<EvalError>("attribute name must be string").debugThrow();
+            }
+
+            auto sym = state.symbols.create(attr_val->c_str());
+            auto attr = obj->attrs()->get(sym);
+
+            if (attr) {
+                v = *attr->value;
+            } else if (n->default_expr) {
+                eval_node(*n->default_expr, v, env);
+            } else {
+                state.error<EvalError>("attribute not found").debugThrow();
+            }
+        }
+        else if (auto* n = node->get_if<HasAttrNode>()) {
+            Value* obj = state.allocValue();
+            eval_node(n->expr, *obj, env);
+            force(obj);
+
+            Value* attr_val = state.allocValue();
+            eval_node(n->attr, *attr_val, env);
+            force(attr_val);
+
+            if (obj->type() != nAttrs) {
+                v.mkBool(false);
+            } else if (attr_val->type() != nString) {
+                state.error<EvalError>("attribute name must be string").debugThrow();
+            } else {
+                auto sym = state.symbols.create(attr_val->c_str());
+                auto attr = obj->attrs()->get(sym);
+                v.mkBool(attr != nullptr);
+            }
+        }
+        else if (auto* n = node->get_if<WithNode>()) {
+            Value* attrs = state.allocValue();
+            eval_node(n->attrs, *attrs, env);
+            force(attrs);
+
+            if (attrs->type() != nAttrs) {
+                state.error<EvalError>("with expression requires attrset").debugThrow();
+            }
+
+            auto with_env = make_env(env);
+            with_env->with_attrs = attrs;
+            eval_node(n->body, v, with_env);
+        }
+        else if (auto* n = node->get_if<AssertNode>()) {
+            Value* cond = state.allocValue();
+            eval_node(n->cond, *cond, env);
+            force(cond);
+
+            if (cond->type() != nBool) {
+                state.error<EvalError>("assertion must be boolean").debugThrow();
+            }
+
+            if (!cond->boolean()) {
+                state.error<EvalError>("assertion failed").debugThrow();
+            }
+
+            eval_node(n->body, v, env);
+        }
+        else {
+            v.mkNull();
+        }
+    }
+};
+
+Evaluator::Evaluator(EvalState& state) : pImpl(std::make_unique<Impl>(state)) {}
+Evaluator::~Evaluator() = default;
+
+void Evaluator::eval_to_nix(const std::shared_ptr<Node>& ir_node,
+                            Value& result,
+                            IREnvironment* env) {
+    pImpl->eval_node(ir_node, result, env);
+}
+
+}
diff --git a/src/irc/evaluator.h b/src/irc/evaluator.h
new file mode 100644
index 0000000..107bd78
--- /dev/null
+++ b/src/irc/evaluator.h
@@ -0,0 +1,35 @@
+#ifndef NIX_IRC_EVALUATOR_H
+#define NIX_IRC_EVALUATOR_H
+
+#include "types.h"
+#include <memory>
+#include <vector>
+
+namespace nix {
+class EvalState;
+class Value;
+class PosIdx;
+}
+
+namespace nix_irc {
+
+class IRValue;
+class IREnvironment;
+
+class Evaluator {
+public:
+    explicit Evaluator(nix::EvalState& state);
+    ~Evaluator();
+
+    void eval_to_nix(const std::shared_ptr<Node>& ir_node,
+                     nix::Value& result,
+                     IREnvironment* env = nullptr);
+
+private:
+    struct Impl;
+    std::unique_ptr<Impl> pImpl;
+};
+
+}
+
+#endif