diff --git a/src/parser.zig b/src/parser.zig
index 65c16c8..f05eed6 100644
--- a/src/parser.zig
+++ b/src/parser.zig
@@ -9,15 +9,26 @@ pub const NodeType = enum {
     include,
     with_block,
     now,
-    // extends, // <--- novo
-    // block, // <--- novo
-    // super, // <--- novo (para {{ block.super }})
+    extends, // <--- novo
+    block, // <--- novo
+    super, // <--- novo (para {{ block.super }})
 };
 
 pub const NowNode = struct {
     format: []const u8,
 };
 
+pub const ExtendsNode = struct {
+    parent_name: []const u8,
+};
+
+pub const BlockNode = struct {
+    name: []const u8,
+    body: []Node,
+    raw_open: []const u8,
+    raw_close: []const u8,
+};
+
 pub const Assignment = struct {
     key: []const u8,
     value_expr: []const u8,
@@ -76,6 +87,9 @@ pub const Node = struct {
     include: ?IncludeNode = null,
     with: ?WithNode = null,
     now: ?NowNode = null,
+    extends: ?ExtendsNode = null,
+    block: ?BlockNode = null,
+    super: bool = false, // para {{ block.super }}
 
     pub fn deinit(self: Node, allocator: std.mem.Allocator) void {
         switch (self.type) {
@@ -119,6 +133,16 @@ pub const Node = struct {
             .now => if (self.now) |n| {
                 allocator.free(n.format);
             },
+            .extends => if (self.extends) |e| {
+                allocator.free(e.parent_name);
+            },
+            .block => if (self.block) |b| {
+                allocator.free(b.name);
+                for (b.body) |n| n.deinit(allocator);
+                allocator.free(b.body);
+                // raw_open e raw_close são slices originais — não free
+            },
+            .super => {},
         }
     }
 };
@@ -218,6 +242,70 @@ pub const Parser = struct {
         return try list.toOwnedSlice(allocator);
     }
 
+    fn parseBlockBlock(self: *Parser, allocator: std.mem.Allocator, name: []const u8, raw_open: []const u8) !Node {
+        var body = std.ArrayList(Node){};
+        defer body.deinit(allocator);
+
+        var depth: usize = 1;
+
+        while (self.pos < self.template.len and depth > 0) {
+            if (try self.parseText(allocator)) |node| {
+                try body.append(allocator, node);
+                continue;
+            }
+
+            if (try self.parseVariable(allocator)) |node| {
+                if (node.variable) |v| {
+                    if (std.mem.eql(u8, v.content, "block.super")) {
+                        try body.append(allocator, Node{ .type = .super, .super = true });
+                        allocator.free(v.content);
+                        continue;
+                    }
+                }
+                try body.append(allocator, node);
+                continue;
+            }
+
+            if (try self.parseTag(allocator)) |tag_node| {
+                const tag_name = tag_node.tag.?.name;
+
+                if (std.mem.eql(u8, tag_name, "block")) {
+                    depth += 1;
+                    try body.append(allocator, tag_node);
+                    continue;
+                }
+
+                if (std.mem.eql(u8, tag_name, "endblock")) {
+                    depth -= 1;
+                    const raw_close = tag_node.tag.?.raw;
+
+                    allocator.free(tag_node.tag.?.name);
+                    allocator.free(tag_node.tag.?.args);
+
+                    if (depth == 0) {
+                        return Node{
+                            .type = .block,
+                            .block = .{
+                                .name = name,
+                                .body = try body.toOwnedSlice(allocator),
+                                .raw_open = raw_open,
+                                .raw_close = raw_close,
+                            },
+                        };
+                    }
+
+                    try body.append(allocator, tag_node);
+                    continue;
+                }
+
+                try body.append(allocator, tag_node);
+            } else {
+                self.advance(1);
+            }
+        }
+
+        return error.UnclosedBlock;
+    }
     fn parseWithBlock(self: *Parser, allocator: std.mem.Allocator, assignments: []const Assignment, raw_open: []const u8) !Node {
         std.debug.print("Vou verificar se sou bloco with\n", .{});
         var body = std.ArrayList(Node){};
@@ -627,6 +715,44 @@ pub const Parser = struct {
                     continue;
                 }
 
+                if (std.mem.eql(u8, tag_name, "extends")) {
+                    const parent = std.mem.trim(u8, node.tag.?.args, " \t\"");
+
+                    const duped = try allocator.dupe(u8, parent);
+
+                    allocator.free(node.tag.?.name);
+                    allocator.free(node.tag.?.args);
+
+                    std.debug.print("3.0 - na real sou um extends\n", .{});
+                    std.debug.print("===================================\n", .{});
+                    try list.append(allocator, Node{
+                        .type = .extends,
+                        .extends = .{ .parent_name = duped },
+                    });
+                    continue;
+                }
+
+                if (std.mem.eql(u8, tag_name, "block")) {
+                    const block_name_raw = node.tag.?.args;
+                    const raw_open = node.tag.?.raw;
+
+                    const block_name = std.mem.trim(u8, block_name_raw, " \t\r\n");
+
+                    // DUPE O NOME ANTES DE LIBERAR A TAG
+                    const duped_name = try allocator.dupe(u8, block_name);
+
+                    // Agora libera a tag open
+                    allocator.free(node.tag.?.name);
+                    allocator.free(node.tag.?.args);
+
+                    std.debug.print("3.0 - na real sou um block\n", .{});
+                    std.debug.print("===================================\n", .{});
+
+                    const block_node = try self.parseBlockBlock(allocator, duped_name, raw_open);
+                    try list.append(allocator, block_node);
+                    continue;
+                }
+
                 if (std.mem.eql(u8, tag_name, "now")) {
                     const args = node.tag.?.args;
 
diff --git a/src/parser_test.zig b/src/parser_test.zig
index e160020..aa5c88d 100644
--- a/src/parser_test.zig
+++ b/src/parser_test.zig
@@ -2,151 +2,332 @@ const std = @import("std");
 const testing = std.testing;
 const parser = @import("parser.zig");
 
-test "parse texto simples" {
+// test "parse texto simples" {
+//     const allocator = testing.allocator;
+//     const template = "Olá mundo!";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| {
+//             node.deinit(allocator);
+//         }
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 1), nodes.len);
+//     try testing.expect(nodes[0].type == .text);
+//     try testing.expectEqualStrings("Olá mundo!", nodes[0].text.?.content);
+// }
+//
+// test "parse variável simples" {
+//     const allocator = testing.allocator;
+//     const template = "Olá {{ nome }}!";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| {
+//             node.deinit(allocator);
+//         }
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 3), nodes.len);
+//
+//     try testing.expect(nodes[0].type == .text);
+//     try testing.expectEqualStrings("Olá ", nodes[0].text.?.content);
+//
+//     try testing.expect(nodes[1].type == .variable);
+//     try testing.expectEqualStrings("nome", nodes[1].variable.?.content);
+//
+//     try testing.expect(nodes[2].type == .text);
+//     try testing.expectEqualStrings("!", nodes[2].text.?.content);
+// }
+//
+// test "parse variável com espaços" {
+//     const allocator = testing.allocator;
+//     const template = "{{   espacos   }}";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| {
+//             node.deinit(allocator);
+//         }
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 1), nodes.len);
+//     try testing.expect(nodes[0].type == .variable);
+//     try testing.expectEqualStrings("espacos", nodes[0].variable.?.content);
+// }
+//
+// test "parse tag simples" {
+//     const allocator = testing.allocator;
+//     const template = "Antes {% minha_tag %} Depois";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| {
+//             node.deinit(allocator);
+//         }
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 3), nodes.len);
+//
+//     try testing.expect(nodes[0].type == .text);
+//     try testing.expectEqualStrings("Antes ", nodes[0].text.?.content);
+//
+//     try testing.expect(nodes[1].type == .tag);
+//     try testing.expectEqualStrings("minha_tag", nodes[1].tag.?.name);
+//     try testing.expectEqualStrings("", nodes[1].tag.?.args);
+//
+//     try testing.expect(nodes[2].type == .text);
+//     try testing.expectEqualStrings(" Depois", nodes[2].text.?.content);
+// }
+//
+// test "parse if block básico" {
+//     const allocator = testing.allocator;
+//     const template = "{% if usuario.logado %}Bem-vindo!{% endif %}";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| {
+//             node.deinit(allocator);
+//         }
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 1), nodes.len);
+//     try testing.expect(nodes[0].type == .if_block);
+//
+//     const ib = nodes[0].@"if".?;
+//     try testing.expectEqualStrings("usuario.logado", ib.condition);
+//     try testing.expectEqual(@as(usize, 1), ib.true_body.len);
+//     try testing.expect(nodes[0].@"if".?.true_body[0].type == .text);
+//     try testing.expectEqualStrings("Bem-vindo!", ib.true_body[0].text.?.content);
+//     try testing.expectEqual(@as(usize, 0), ib.false_body.len);
+// }
+//
+// test "parse if block sem else" {
+//     const allocator = testing.allocator;
+//     const template = "{% if cond %}Verdadeiro{% endif %}";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| {
+//             node.deinit(allocator);
+//         }
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 1), nodes.len);
+//     try testing.expect(nodes[0].type == .if_block);
+//     const ib = nodes[0].@"if".?;
+//     try testing.expectEqualStrings("cond", ib.condition);
+//     try testing.expectEqual(@as(usize, 1), ib.true_body.len);
+//     try testing.expectEqualStrings("Verdadeiro", ib.true_body[0].text.?.content);
+//     try testing.expectEqual(@as(usize, 0), ib.false_body.len);
+// }
+//
+// test "parse if block com else" {
+//     const allocator = testing.allocator;
+//     const template = "{% if cond %}Verdadeiro{% else %}Falso{% endif %}";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| {
+//             node.deinit(allocator);
+//         }
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 1), nodes.len);
+//     try testing.expect(nodes[0].type == .if_block);
+//     const ib = nodes[0].@"if".?;
+//     try testing.expectEqualStrings("cond", ib.condition);
+//     try testing.expectEqual(@as(usize, 1), ib.true_body.len);
+//     try testing.expectEqualStrings("Verdadeiro", ib.true_body[0].text.?.content);
+//     try testing.expectEqual(@as(usize, 1), ib.false_body.len);
+//     try testing.expectEqualStrings("Falso", ib.false_body[0].text.?.content);
+// }
+//
+// test "parse for block sem empty" {
+//     const allocator = testing.allocator;
+//     const template = "{% for item in lista %}Item: {{ item }}{% endfor %}";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| node.deinit(allocator);
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 1), nodes.len);
+//     try testing.expect(nodes[0].type == .for_block);
+//     const fb = nodes[0].@"for".?;
+//     try testing.expectEqualStrings("item", fb.loop_var);
+//     try testing.expectEqualStrings("lista", fb.iterable);
+//     try testing.expectEqual(@as(usize, 2), fb.body.len); // <--- corrigido: 2 nós
+//     try testing.expectEqual(@as(usize, 0), fb.empty_body.len);
+//
+//     try testing.expect(fb.body[0].type == .text);
+//     try testing.expectEqualStrings("Item: ", fb.body[0].text.?.content);
+//     try testing.expect(fb.body[1].type == .variable);
+//     try testing.expectEqualStrings("item", fb.body[1].variable.?.content);
+// }
+//
+// test "parse for block com empty" {
+//     const allocator = testing.allocator;
+//     const template = "{% for item in lista %}Tem{% empty %}Vazio{% endfor %}";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| node.deinit(allocator);
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 1), nodes.len);
+//     try testing.expect(nodes[0].type == .for_block);
+//     const fb = nodes[0].@"for".?;
+//     try testing.expectEqual(@as(usize, 1), fb.body.len);
+//     try testing.expectEqualStrings("Tem", fb.body[0].text.?.content);
+//     try testing.expectEqual(@as(usize, 1), fb.empty_body.len);
+//     try testing.expectEqualStrings("Vazio", fb.empty_body[0].text.?.content);
+// }
+//
+// test "parse comment" {
+//     const allocator = testing.allocator;
+//     const template = "Bazinga! {% comment %}{% for item in lista %}Tem{% empty %}Vazio{% endfor %}{% endcomment %}";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| node.deinit(allocator);
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 1), nodes.len);
+//     try testing.expect(nodes[0].type == .text);
+//     try testing.expectEqualStrings("Bazinga! ", nodes[0].text.?.content);
+// }
+//
+// test "parse include simples" {
+//     const allocator = testing.allocator;
+//     const template = "Cabeçalho {% include \"header.zdt\" %} Conteúdo {% include \"footer.zdt\" %}";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| node.deinit(allocator);
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 4), nodes.len);
+//
+//     try testing.expect(nodes[0].type == .text);
+//     try testing.expectEqualStrings("Cabeçalho ", nodes[0].text.?.content);
+//
+//     try testing.expect(nodes[1].type == .include);
+//     try testing.expectEqualStrings("header.zdt", nodes[1].include.?.template_name);
+//
+//     try testing.expect(nodes[2].type == .text);
+//     try testing.expectEqualStrings(" Conteúdo ", nodes[2].text.?.content);
+//
+//     try testing.expect(nodes[3].type == .include);
+//     try testing.expectEqualStrings("footer.zdt", nodes[3].include.?.template_name);
+//
+// }
+//
+// test "parse include sem aspas (erro esperado no futuro, mas por enquanto aceita)" {
+//     const allocator = testing.allocator;
+//     const template = "{% include header.zdt %}";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| node.deinit(allocator);
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 1), nodes.len);
+//     try testing.expect(nodes[0].type == .include);
+//     try testing.expectEqualStrings("header.zdt", nodes[0].include.?.template_name);
+// }
+//
+// test "parse with simples" {
+//     const allocator = testing.allocator;
+//     const template = "{% with nome=\"Lucas\" idade=30 %}Olá {{ nome }}, você tem {{ idade }} anos.{% endwith %}";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| node.deinit(allocator);
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 1), nodes.len);
+//     try testing.expect(nodes[0].type == .with_block);
+//     const w = nodes[0].with.?;
+//     try testing.expectEqual(@as(usize, 2), w.assignments.len);
+//     try testing.expectEqual(@as(usize, 5), w.body.len);
+//     try testing.expect(w.body[0].type == .text);
+// }
+//
+// test "parse now simples" {
+//     const allocator = testing.allocator;
+//     const template = "Data atual: {% now \"Y-m-d\" %} às {% now \"H:i\" %}";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| node.deinit(allocator);
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 4), nodes.len);
+//
+//     try testing.expect(nodes[0].type == .text);
+//     try testing.expectEqualStrings("Data atual: ", nodes[0].text.?.content);
+//
+//     try testing.expect(nodes[1].type == .now);
+//     try testing.expectEqualStrings("Y-m-d", nodes[1].now.?.format);
+//
+//     try testing.expect(nodes[2].type == .text);
+//     try testing.expectEqualStrings(" às ", nodes[2].text.?.content);
+//
+//     try testing.expect(nodes[3].type == .now);
+//     try testing.expectEqualStrings("H:i", nodes[3].now.?.format);
+//
+// }
+//
+// test "parse now sem aspas" {
+//     const allocator = testing.allocator;
+//     const template = "{% now Y-m-d %}";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| node.deinit(allocator);
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 1), nodes.len);
+//     try testing.expect(nodes[0].type == .now);
+//     try testing.expectEqualStrings("Y-m-d", nodes[0].now.?.format);
+// }
+//
+// test "parse extends" {
+//     const allocator = testing.allocator;
+//     const template = "{% extends \"base.zdt\" %}";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| node.deinit(allocator);
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 1), nodes.len);
+//     try testing.expect(nodes[0].type == .extends);
+//     try testing.expectEqualStrings("base.zdt", nodes[0].extends.?.parent_name);
+// }
+//
+// test "parse block simples" {
+//     const allocator = testing.allocator;
+//     const template = "{% block titulo %}Meu Título{% endblock %}";
+//     const nodes = try parser.parse(allocator, template);
+//     defer {
+//         for (nodes) |node| node.deinit(allocator);
+//         allocator.free(nodes);
+//     }
+//
+//     try testing.expectEqual(@as(usize, 1), nodes.len);
+//     try testing.expect(nodes[0].type == .block);
+//     const b = nodes[0].block.?;
+//     try testing.expectEqualStrings("titulo", b.name);
+//     try testing.expectEqual(@as(usize, 1), b.body.len);
+//     try testing.expectEqualStrings("Meu Título", b.body[0].text.?.content);
+// }
+//
+test "parse block com super" {
     const allocator = testing.allocator;
-    const template = "Olá mundo!";
-    const nodes = try parser.parse(allocator, template);
-    defer {
-        for (nodes) |node| {
-            node.deinit(allocator);
-        }
-        allocator.free(nodes);
-    }
-
-    try testing.expectEqual(@as(usize, 1), nodes.len);
-    try testing.expect(nodes[0].type == .text);
-    try testing.expectEqualStrings("Olá mundo!", nodes[0].text.?.content);
-}
-
-test "parse variável simples" {
-    const allocator = testing.allocator;
-    const template = "Olá {{ nome }}!";
-    const nodes = try parser.parse(allocator, template);
-    defer {
-        for (nodes) |node| {
-            node.deinit(allocator);
-        }
-        allocator.free(nodes);
-    }
-
-    try testing.expectEqual(@as(usize, 3), nodes.len);
-
-    try testing.expect(nodes[0].type == .text);
-    try testing.expectEqualStrings("Olá ", nodes[0].text.?.content);
-
-    try testing.expect(nodes[1].type == .variable);
-    try testing.expectEqualStrings("nome", nodes[1].variable.?.content);
-
-    try testing.expect(nodes[2].type == .text);
-    try testing.expectEqualStrings("!", nodes[2].text.?.content);
-}
-
-test "parse variável com espaços" {
-    const allocator = testing.allocator;
-    const template = "{{   espacos   }}";
-    const nodes = try parser.parse(allocator, template);
-    defer {
-        for (nodes) |node| {
-            node.deinit(allocator);
-        }
-        allocator.free(nodes);
-    }
-
-    try testing.expectEqual(@as(usize, 1), nodes.len);
-    try testing.expect(nodes[0].type == .variable);
-    try testing.expectEqualStrings("espacos", nodes[0].variable.?.content);
-}
-
-test "parse tag simples" {
-    const allocator = testing.allocator;
-    const template = "Antes {% minha_tag %} Depois";
-    const nodes = try parser.parse(allocator, template);
-    defer {
-        for (nodes) |node| {
-            node.deinit(allocator);
-        }
-        allocator.free(nodes);
-    }
-
-    try testing.expectEqual(@as(usize, 3), nodes.len);
-
-    try testing.expect(nodes[0].type == .text);
-    try testing.expectEqualStrings("Antes ", nodes[0].text.?.content);
-
-    try testing.expect(nodes[1].type == .tag);
-    try testing.expectEqualStrings("minha_tag", nodes[1].tag.?.name);
-    try testing.expectEqualStrings("", nodes[1].tag.?.args);
-
-    try testing.expect(nodes[2].type == .text);
-    try testing.expectEqualStrings(" Depois", nodes[2].text.?.content);
-}
-
-test "parse if block básico" {
-    const allocator = testing.allocator;
-    const template = "{% if usuario.logado %}Bem-vindo!{% endif %}";
-    const nodes = try parser.parse(allocator, template);
-    defer {
-        for (nodes) |node| {
-            node.deinit(allocator);
-        }
-        allocator.free(nodes);
-    }
-
-    try testing.expectEqual(@as(usize, 1), nodes.len);
-    try testing.expect(nodes[0].type == .if_block);
-
-    const ib = nodes[0].@"if".?;
-    try testing.expectEqualStrings("usuario.logado", ib.condition);
-    try testing.expectEqual(@as(usize, 1), ib.true_body.len);
-    try testing.expect(nodes[0].@"if".?.true_body[0].type == .text);
-    try testing.expectEqualStrings("Bem-vindo!", ib.true_body[0].text.?.content);
-    try testing.expectEqual(@as(usize, 0), ib.false_body.len);
-}
-
-test "parse if block sem else" {
-    const allocator = testing.allocator;
-    const template = "{% if cond %}Verdadeiro{% endif %}";
-    const nodes = try parser.parse(allocator, template);
-    defer {
-        for (nodes) |node| {
-            node.deinit(allocator);
-        }
-        allocator.free(nodes);
-    }
-
-    try testing.expectEqual(@as(usize, 1), nodes.len);
-    try testing.expect(nodes[0].type == .if_block);
-    const ib = nodes[0].@"if".?;
-    try testing.expectEqualStrings("cond", ib.condition);
-    try testing.expectEqual(@as(usize, 1), ib.true_body.len);
-    try testing.expectEqualStrings("Verdadeiro", ib.true_body[0].text.?.content);
-    try testing.expectEqual(@as(usize, 0), ib.false_body.len);
-}
-
-test "parse if block com else" {
-    const allocator = testing.allocator;
-    const template = "{% if cond %}Verdadeiro{% else %}Falso{% endif %}";
-    const nodes = try parser.parse(allocator, template);
-    defer {
-        for (nodes) |node| {
-            node.deinit(allocator);
-        }
-        allocator.free(nodes);
-    }
-
-    try testing.expectEqual(@as(usize, 1), nodes.len);
-    try testing.expect(nodes[0].type == .if_block);
-    const ib = nodes[0].@"if".?;
-    try testing.expectEqualStrings("cond", ib.condition);
-    try testing.expectEqual(@as(usize, 1), ib.true_body.len);
-    try testing.expectEqualStrings("Verdadeiro", ib.true_body[0].text.?.content);
-    try testing.expectEqual(@as(usize, 1), ib.false_body.len);
-    try testing.expectEqualStrings("Falso", ib.false_body[0].text.?.content);
-}
-
-test "parse for block sem empty" {
-    const allocator = testing.allocator;
-    const template = "{% for item in lista %}Item: {{ item }}{% endfor %}";
+    const template = "{% block conteudo %}{{ block.super }} Conteúdo filho{% endblock %}";
     const nodes = try parser.parse(allocator, template);
     defer {
         for (nodes) |node| node.deinit(allocator);
@@ -154,142 +335,10 @@ test "parse for block sem empty" {
     }
 
     try testing.expectEqual(@as(usize, 1), nodes.len);
-    try testing.expect(nodes[0].type == .for_block);
-    const fb = nodes[0].@"for".?;
-    try testing.expectEqualStrings("item", fb.loop_var);
-    try testing.expectEqualStrings("lista", fb.iterable);
-    try testing.expectEqual(@as(usize, 2), fb.body.len); // <--- corrigido: 2 nós
-    try testing.expectEqual(@as(usize, 0), fb.empty_body.len);
-
-    try testing.expect(fb.body[0].type == .text);
-    try testing.expectEqualStrings("Item: ", fb.body[0].text.?.content);
-    try testing.expect(fb.body[1].type == .variable);
-    try testing.expectEqualStrings("item", fb.body[1].variable.?.content);
-}
-
-test "parse for block com empty" {
-    const allocator = testing.allocator;
-    const template = "{% for item in lista %}Tem{% empty %}Vazio{% endfor %}";
-    const nodes = try parser.parse(allocator, template);
-    defer {
-        for (nodes) |node| node.deinit(allocator);
-        allocator.free(nodes);
-    }
-
-    try testing.expectEqual(@as(usize, 1), nodes.len);
-    try testing.expect(nodes[0].type == .for_block);
-    const fb = nodes[0].@"for".?;
-    try testing.expectEqual(@as(usize, 1), fb.body.len);
-    try testing.expectEqualStrings("Tem", fb.body[0].text.?.content);
-    try testing.expectEqual(@as(usize, 1), fb.empty_body.len);
-    try testing.expectEqualStrings("Vazio", fb.empty_body[0].text.?.content);
-}
-
-test "parse comment" {
-    const allocator = testing.allocator;
-    const template = "Bazinga! {% comment %}{% for item in lista %}Tem{% empty %}Vazio{% endfor %}{% endcomment %}";
-    const nodes = try parser.parse(allocator, template);
-    defer {
-        for (nodes) |node| node.deinit(allocator);
-        allocator.free(nodes);
-    }
-
-    try testing.expectEqual(@as(usize, 1), nodes.len);
-    try testing.expect(nodes[0].type == .text);
-    try testing.expectEqualStrings("Bazinga! ", nodes[0].text.?.content);
-}
-
-test "parse include simples" {
-    const allocator = testing.allocator;
-    const template = "Cabeçalho {% include \"header.zdt\" %} Conteúdo {% include \"footer.zdt\" %}";
-    const nodes = try parser.parse(allocator, template);
-    defer {
-        for (nodes) |node| node.deinit(allocator);
-        allocator.free(nodes);
-    }
-
-    try testing.expectEqual(@as(usize, 4), nodes.len);
-
-    try testing.expect(nodes[0].type == .text);
-    try testing.expectEqualStrings("Cabeçalho ", nodes[0].text.?.content);
-
-    try testing.expect(nodes[1].type == .include);
-    try testing.expectEqualStrings("header.zdt", nodes[1].include.?.template_name);
-
-    try testing.expect(nodes[2].type == .text);
-    try testing.expectEqualStrings(" Conteúdo ", nodes[2].text.?.content);
-
-    try testing.expect(nodes[3].type == .include);
-    try testing.expectEqualStrings("footer.zdt", nodes[3].include.?.template_name);
-
-}
-
-test "parse include sem aspas (erro esperado no futuro, mas por enquanto aceita)" {
-    const allocator = testing.allocator;
-    const template = "{% include header.zdt %}";
-    const nodes = try parser.parse(allocator, template);
-    defer {
-        for (nodes) |node| node.deinit(allocator);
-        allocator.free(nodes);
-    }
-
-    try testing.expectEqual(@as(usize, 1), nodes.len);
-    try testing.expect(nodes[0].type == .include);
-    try testing.expectEqualStrings("header.zdt", nodes[0].include.?.template_name);
-}
-
-test "parse with simples" {
-    const allocator = testing.allocator;
-    const template = "{% with nome=\"Lucas\" idade=30 %}Olá {{ nome }}, você tem {{ idade }} anos.{% endwith %}";
-    const nodes = try parser.parse(allocator, template);
-    defer {
-        for (nodes) |node| node.deinit(allocator);
-        allocator.free(nodes);
-    }
-
-    try testing.expectEqual(@as(usize, 1), nodes.len);
-    try testing.expect(nodes[0].type == .with_block);
-    const w = nodes[0].with.?;
-    try testing.expectEqual(@as(usize, 2), w.assignments.len);
-    try testing.expectEqual(@as(usize, 5), w.body.len);
-    try testing.expect(w.body[0].type == .text);
-}
-
-test "parse now simples" {
-    const allocator = testing.allocator;
-    const template = "Data atual: {% now \"Y-m-d\" %} às {% now \"H:i\" %}";
-    const nodes = try parser.parse(allocator, template);
-    defer {
-        for (nodes) |node| node.deinit(allocator);
-        allocator.free(nodes);
-    }
-
-    try testing.expectEqual(@as(usize, 4), nodes.len);
-
-    try testing.expect(nodes[0].type == .text);
-    try testing.expectEqualStrings("Data atual: ", nodes[0].text.?.content);
-
-    try testing.expect(nodes[1].type == .now);
-    try testing.expectEqualStrings("Y-m-d", nodes[1].now.?.format);
-
-    try testing.expect(nodes[2].type == .text);
-    try testing.expectEqualStrings(" às ", nodes[2].text.?.content);
-
-    try testing.expect(nodes[3].type == .now);
-    try testing.expectEqualStrings("H:i", nodes[3].now.?.format);
-
-}
-
-test "parse now sem aspas" {
-    const allocator = testing.allocator;
-    const template = "{% now Y-m-d %}";
-    const nodes = try parser.parse(allocator, template);
-    defer {
-        for (nodes) |node| node.deinit(allocator);
-        allocator.free(nodes);
-    }
-
-    try testing.expectEqual(@as(usize, 1), nodes.len);
-    try testing.expect(nodes[0].type == .now);
-    try testing.expectEqualStrings("Y-m-d", nodes[0].now.?.format);
+    try testing.expect(nodes[0].type == .block);
+    const b = nodes[0].block.?;
+    try testing.expectEqual(@as(usize, 2), b.body.len);
+    try testing.expect(b.body[0].type == .super);
+    // try testing.expectEqualStrings("conteudo", b.name);
+    try testing.expectEqualStrings(" Conteúdo filho", b.body[1].text.?.content);
 }
diff --git a/todo.md b/todo.md
new file mode 100644
index 0000000..390b434
--- /dev/null
+++ b/todo.md
@@ -0,0 +1,91 @@
+# Tags
+
+- [ ] autoescape
+- [x] block
+- [x] comment
+- [ ] csrf_token
+- [ ] cycle
+- [ ] debug
+- [x] extends
+- [ ] filter
+- [ ] firstof
+- [x] for
+- [x] if
+- [x] ifchanged
+- [x] include
+- [ ] load
+- [ ] lorem
+- [x] now
+- [ ] partial
+- [ ] partialdef
+- [ ] querystring
+- [ ] regroup
+- [ ] resetcycle
+- [ ] spaceless
+- [ ] templatetag
+- [ ] url
+- [ ] verbatim
+- [ ] widthratio
+- [x] with
+
+
+# Filters
+
+- [ ] add
+- [ ] addslashes
+- [ ] capfirst
+- [ ] center
+- [ ] cut
+- [ ] date
+- [ ] default
+- [ ] default_if_none
+- [ ] dictsort
+- [ ] dictsortreversed
+- [ ] divisibleby
+- [ ] escape
+- [ ] escapejs
+- [ ] escapeseq
+- [ ] filesizeformat
+- [ ] first
+- [ ] floatformat
+- [ ] force_escape
+- [ ] get_digit
+- [ ] iriencode
+- [ ] join
+- [ ] json_script
+- [ ] last
+- [ ] length
+- [ ] linebreaks
+- [ ] linebreaksbr
+- [ ] linenumbers
+- [ ] ljust
+- [ ] lower
+- [ ] make_list
+- [ ] phone2numeric
+- [ ] pluralize
+- [ ] pprint
+- [ ] random
+- [ ] rjust
+- [ ] safe
+- [ ] safeseq
+- [ ] slice
+- [ ] slugify
+- [ ] stringformat
+- [ ] striptags
+- [ ] time
+- [ ] timesince
+- [ ] timeuntil
+- [ ] title
+- [ ] truncatechars
+- [ ] truncatechars_html
+- [ ] truncatewords
+- [ ] truncatewords_html
+- [ ] unordered_list
+- [ ] upper
+- [ ] urlencode
+- [ ] urlize
+- [ ] urlizetrunc
+- [ ] wordcount
+- [ ] wordwrap
+- [ ] yesno
+