diff --git a/dev.thihup.jvisualg.frontend/src/main/java/dev/thihup/jvisualg/frontend/VisuAlgParserVisitor.java b/dev.thihup.jvisualg.frontend/src/main/java/dev/thihup/jvisualg/frontend/VisuAlgParserVisitor.java
index b7a23ac..37fcdce 100644
--- a/dev.thihup.jvisualg.frontend/src/main/java/dev/thihup/jvisualg/frontend/VisuAlgParserVisitor.java
+++ b/dev.thihup.jvisualg.frontend/src/main/java/dev/thihup/jvisualg/frontend/VisuAlgParserVisitor.java
@@ -40,6 +40,9 @@ public Node visitAlgorithm(VisuAlgParser.AlgorithmContext ctx) {
 
     @Override
     public Node visitDeclarations(VisuAlgParser.DeclarationsContext ctx) {
+        if (ctx.children == null) {
+            return CompundNode.EMPTY;
+        }
         List<Node> list = ctx.children.stream()
             .map(this::visit)
             .filter(Objects::nonNull)
@@ -364,7 +367,7 @@ public Node visitExpr(VisuAlgParser.ExprContext ctx) {
         if (ctx.parenExpression() instanceof VisuAlgParser.ParenExpressionContext parenExpressionContext) {
             return visit(parenExpressionContext.expr());
         }
-        if (ctx.SUB() != null) {
+        if (ctx.SUB() != null && ctx.expr().size() == 1) {
             return new NegNode(visit(ctx.expr(0)), fromRuleContext(ctx));
         }
         if (ctx.NOT() != null) {
@@ -469,7 +472,7 @@ public Node visitTimerCommand(VisuAlgParser.TimerCommandContext ctx) {
 
     @Override
     public Node visitPausaCommand(VisuAlgParser.PausaCommandContext ctx) {
-        return new PausaCommandNode(fromRuleContext(ctx));
+        return new PausaCommandNode(EmptyNode.INSTANCE, fromRuleContext(ctx));
     }
 
 
diff --git a/dev.thihup.jvisualg.frontend/src/main/java/dev/thihup/jvisualg/frontend/node/Node.java b/dev.thihup.jvisualg.frontend/src/main/java/dev/thihup/jvisualg/frontend/node/Node.java
index 1a2ce0a..aa7e88f 100644
--- a/dev.thihup.jvisualg.frontend/src/main/java/dev/thihup/jvisualg/frontend/node/Node.java
+++ b/dev.thihup.jvisualg.frontend/src/main/java/dev/thihup/jvisualg/frontend/node/Node.java
@@ -443,7 +443,9 @@ record PowNode(Node left, Node right, Optional<Location> location) implements Bi
 
     sealed interface BooleanNode extends CommandNode, ExpressionNode {}
 
-    record AndNode(Node left, Node right, Optional<Location> location) implements BooleanNode, BinaryNode {
+    sealed interface RelationalNode extends BinaryNode, BooleanNode {}
+
+    record AndNode(Node left, Node right, Optional<Location> location) implements RelationalNode {
         public AndNode {
             Objects.requireNonNull(left);
             Objects.requireNonNull(right);
@@ -451,7 +453,7 @@ record AndNode(Node left, Node right, Optional<Location> location) implements Bo
         }
     }
 
-    record OrNode(Node left, Node right, Optional<Location> location) implements BooleanNode, BinaryNode {
+    record OrNode(Node left, Node right, Optional<Location> location) implements RelationalNode {
         public OrNode {
             Objects.requireNonNull(left);
             Objects.requireNonNull(right);
@@ -466,7 +468,6 @@ record NotNode(Node expr, Optional<Location> location) implements BooleanNode {
         }
     }
 
-    sealed interface RelationalNode extends BinaryNode {}
 
     record EqNode(Node left, Node right, Optional<Location> location) implements RelationalNode {
         public EqNode {
@@ -551,7 +552,7 @@ record TimerCommandNode(boolean on, int value, Optional<Location> location) impl
         }
     }
 
-    record PausaCommandNode(Optional<Location> location) implements CommandNode {
+    record PausaCommandNode(Node node, Optional<Location> location) implements CommandNode {
         public PausaCommandNode {
             Objects.requireNonNull(location);
         }
diff --git a/dev.thihup.jvisualg.ide/pom.xml b/dev.thihup.jvisualg.ide/pom.xml
index b4535c8..ca7536a 100644
--- a/dev.thihup.jvisualg.ide/pom.xml
+++ b/dev.thihup.jvisualg.ide/pom.xml
@@ -26,6 +26,11 @@
             <artifactId>dev.thihup.jvisualg.lsp</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>dev.thihup.jvisualg</groupId>
+            <artifactId>dev.thihup.jvisualg.interpreter</artifactId>
+            <version>${project.version}</version>
+        </dependency>
         <dependency>
             <groupId>org.openjfx</groupId>
             <artifactId>javafx-controls</artifactId>
diff --git a/dev.thihup.jvisualg.ide/src/main/java/dev/thihup/jvisualg/ide/Main.java b/dev.thihup.jvisualg.ide/src/main/java/dev/thihup/jvisualg/ide/Main.java
index 9197da5..f21fe8d 100644
--- a/dev.thihup.jvisualg.ide/src/main/java/dev/thihup/jvisualg/ide/Main.java
+++ b/dev.thihup.jvisualg.ide/src/main/java/dev/thihup/jvisualg/ide/Main.java
@@ -1,5 +1,7 @@
 package dev.thihup.jvisualg.ide;
 
+import dev.thihup.jvisualg.interpreter.DAPServer;
+import dev.thihup.jvisualg.interpreter.DebugProtocolClientExtension;
 import dev.thihup.jvisualg.lsp.VisualgLauncher;
 import javafx.application.Application;
 import javafx.application.Platform;
@@ -9,11 +11,20 @@
 import javafx.geometry.Point2D;
 import javafx.scene.Parent;
 import javafx.scene.Scene;
+import javafx.scene.control.Button;
 import javafx.scene.control.Label;
+import javafx.scene.control.TextArea;
 import javafx.stage.Popup;
 import javafx.stage.Stage;
 import org.eclipse.lsp4j.*;
+import org.eclipse.lsp4j.debug.InitializeRequestArguments;
+import org.eclipse.lsp4j.debug.OutputEventArguments;
+import org.eclipse.lsp4j.debug.SetBreakpointsArguments;
+import org.eclipse.lsp4j.debug.SourceBreakpoint;
+import org.eclipse.lsp4j.debug.launch.DSPLauncher;
+import org.eclipse.lsp4j.debug.services.IDebugProtocolServer;
 import org.eclipse.lsp4j.jsonrpc.Launcher;
+import org.eclipse.lsp4j.jsonrpc.debug.DebugLauncher;
 import org.eclipse.lsp4j.launch.LSPLauncher;
 import org.eclipse.lsp4j.services.LanguageClient;
 import org.eclipse.lsp4j.services.LanguageServer;
@@ -24,15 +35,13 @@
 import org.fxmisc.richtext.model.StyleSpansBuilder;
 import org.reactfx.Subscription;
 
+import java.io.IOException;
 import java.io.PipedInputStream;
 import java.io.PipedOutputStream;
 import java.time.Duration;
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-import java.util.Optional;
+import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -43,28 +52,99 @@
 
 public class Main extends Application {
 
-    private final ExecutorService executor = Executors.newFixedThreadPool(3);
+    private final ExecutorService fxClientExecutor = Executors.newSingleThreadExecutor();
+
+    private final ExecutorService lspClientExecutor = Executors.newSingleThreadExecutor();
+    private final ExecutorService lspServerExecutor = Executors.newSingleThreadExecutor();
+
+    private final ExecutorService dapClientExecutor = Executors.newSingleThreadExecutor();
+    private final ExecutorService dapServerExecutor = Executors.newSingleThreadExecutor();
+
 
     @FXML
     private CodeArea codeArea;
 
+    @FXML
+    private Button runButton;
+
+    @FXML
+    private TextArea outputArea;
+
     private Subscription subscribe;
     private Launcher<LanguageServer> clientLauncher;
     private Future<Void> lspServer;
     private Future<Void> lspClient;
+    private Launcher<DebugProtocolClientExtension> dapServerLauncher;
+    private Launcher<IDebugProtocolServer> dapClientLauncher;
+    private Future<Void> dapServerListener;
+    private Future<Void> dapClientListener;
+    private List<Diagnostic> diagnostics;
 
     @Override
     public void start(Stage stage) throws Exception {
         FXMLLoader fxmlLoader = new FXMLLoader(getClass().getResource("gui.fxml"));
         fxmlLoader.setController(this);
-
         Parent root = fxmlLoader.load();
 
         codeArea.setParagraphGraphicFactory(LineNumberFactory.get(codeArea));
 
+        setupSyntaxHighlighting();
+
+        setupDefaultText();
+
+        showScene(stage, root);
+
+        setupLSP();
+
+        setupDAP();
+
+        runButton.addEventHandler(javafx.event.ActionEvent.ACTION, e -> {
+            Platform.runLater(() -> {
+                outputArea.clear();
+                dapClientLauncher.getRemoteProxy().launch(Map.of("source", codeArea.getText()));
+            });
+        });
+
+
+        setupErrorPopup();
+
+        if (Boolean.getBoolean("autoClose"))
+            Platform.runLater(stage::close);
+    }
+
+    private void showScene(Stage stage, Parent root) {
+        Scene scene = new Scene(root);
+        scene.setOnKeyPressed(x -> {
+            switch (x.getCode()) {
+                case F9 -> runButton.fire();
+                default -> {}
+            }
+        });
+        scene.getStylesheets().add(getClass().getResource("styles.css").toExternalForm());
+        stage.setTitle("JVisualG");
+        stage.setScene(scene);
+        stage.show();
+    }
+
+    private void setupDefaultText() {
+        codeArea.replaceText(0, 0, """
+                algoritmo "semnome"
+                // Função :
+                // Autor :
+                // Data : %s
+                // Seção de Declarações
+                var
+
+                inicio
+                // Seção de Comandos
+                fimalgoritmo
+                """.formatted(LocalDate.now().format(DateTimeFormatter.ofPattern("dd/MM/yyyy"))));
+    }
+
+    private void setupSyntaxHighlighting() {
         subscribe = codeArea.multiPlainChanges()
                 .successionEnds(Duration.ofMillis(50))
-                .retainLatestUntilLater(executor)
+                .retainLatestUntilLater(fxClientExecutor)
                 .supplyTask(this::computeHighlightingAsync)
                 .awaitLatest(codeArea.multiPlainChanges())
                 .filterMap(t -> {
@@ -76,42 +156,44 @@ public void start(Stage stage) throws Exception {
                     }
                 })
                 .subscribe(this::applyHighlighting);
+    }
 
+    private void setupLSP() throws IOException {
+        PipedInputStream lspInputClient = new PipedInputStream();
+        PipedOutputStream lspOutputClient = new PipedOutputStream();
+        PipedInputStream lspInputServer = new PipedInputStream();
+        PipedOutputStream lspOutputServer = new PipedOutputStream();
 
-        codeArea.replaceText(0, 0, """
-                algoritmo "semnome"
-                // Função :
-                // Autor :
-                // Data : %s
-                // Seção de Declarações
-                var
-
-                inicio
-                // Seção de Comandos
-                fimalgoritmo
-                """.formatted(LocalDate.now().format(DateTimeFormatter.ofPattern("dd/MM/yyyy"))));
+        lspInputClient.connect(lspOutputServer);
+        lspOutputClient.connect(lspInputServer);
 
+        lspServer = VisualgLauncher.startServer(lspInputServer, lspOutputServer, lspServerExecutor);
+        clientLauncher = LSPLauncher.createClientLauncher(new VisualgLanguageClient(), lspInputClient, lspOutputClient, lspClientExecutor, null);
 
-        Scene scene = new Scene(root);
-        scene.getStylesheets().add(getClass().getResource("styles.css").toExternalForm());
-        stage.setTitle("JVisualG");
-        stage.setScene(scene);
-        stage.show();
+        lspClient = clientLauncher.startListening();
+    }
 
+    private void setupDAP() throws IOException {
+        PipedInputStream dapInputClient = new PipedInputStream();
+        PipedOutputStream dapOutputClient = new PipedOutputStream();
+        PipedInputStream dapInputServer  = new PipedInputStream();
+        PipedOutputStream dapOutputServer = new PipedOutputStream();
 
-        PipedInputStream inClient = new PipedInputStream();
-        PipedOutputStream outClient = new PipedOutputStream();
-        PipedInputStream inServer = new PipedInputStream();
-        PipedOutputStream outServer = new PipedOutputStream();
+        dapInputClient.connect(dapOutputServer);
+        dapOutputClient.connect(dapInputServer);
 
-        inClient.connect(outServer);
-        outClient.connect(inServer);
+        DAPServer server = new DAPServer();
+        dapServerLauncher = DebugLauncher.createLauncher(server, DebugProtocolClientExtension.class, dapInputServer, dapOutputServer, dapServerExecutor, null);
+        server.connect(dapServerLauncher.getRemoteProxy());
+        dapServerListener = dapServerLauncher.startListening();
 
-        lspServer = VisualgLauncher.startServer(inServer, outServer, executor);
-        clientLauncher = LSPLauncher.createClientLauncher(new VisualgLanguageClient(), inClient, outClient, executor, null);
 
-        lspClient = clientLauncher.startListening();
+        dapClientLauncher = DSPLauncher.createClientLauncher(new DAPClient(), dapInputClient, dapOutputClient, dapClientExecutor, null);
+        dapClientListener = dapClientLauncher.startListening();
+        dapClientLauncher.getRemoteProxy().initialize(new InitializeRequestArguments());
+    }
 
+    private void setupErrorPopup() {
         Popup popup = new Popup();
         Label popupMsg = new Label();
         popupMsg.setStyle(
@@ -122,33 +204,30 @@ public void start(Stage stage) throws Exception {
 
         codeArea.setMouseOverTextDelay(Duration.ofMillis(200));
         codeArea.addEventHandler(MouseOverTextEvent.MOUSE_OVER_TEXT_BEGIN, e -> {
-            int chIdx = e.getCharacterIndex();
-            Point2D pos = e.getScreenPosition();
-            if (codeArea.getText().isEmpty() || diagnostics == null)
-                return;
-            diagnostics.stream()
-                    .filter(diagnostic -> {
-                        int start = toOffset(codeArea.getText(), diagnostic.getRange().getStart());
-                        int end = toOffset(codeArea.getText(), diagnostic.getRange().getEnd());
-                        return chIdx >= start && chIdx <= end;
-                    })
-                    .findFirst().ifPresent(diagnostic -> {
-                        popupMsg.setText(diagnostic.getMessage());
-                        popup.show(codeArea, pos.getX(), pos.getY() + 10);
-                    });
-
+            handlePopupError(e, popupMsg, popup);
         });
         codeArea.addEventHandler(MouseOverTextEvent.MOUSE_OVER_TEXT_END, e -> {
             popup.hide();
         });
-
-
-        if (Boolean.getBoolean("autoClose"))
-            Platform.runLater(stage::close);
     }
 
+    private void handlePopupError(MouseOverTextEvent e, Label popupMsg, Popup popup) {
+        int chIdx = e.getCharacterIndex();
+        Point2D pos = e.getScreenPosition();
+        if (codeArea.getText().isEmpty() || diagnostics == null)
+            return;
+        diagnostics.stream()
+                .filter(diagnostic -> {
+                    int start = toOffset(codeArea.getText(), diagnostic.getRange().getStart());
+                    int end = toOffset(codeArea.getText(), diagnostic.getRange().getEnd());
+                    return chIdx >= start && chIdx <= end;
+                })
+                .findFirst().ifPresent(diagnostic -> {
+                    popupMsg.setText(diagnostic.getMessage());
+                    popup.show(codeArea, pos.getX(), pos.getY() + 10);
+                });
+    }
 
-    private List<Diagnostic> diagnostics;
 
     class VisualgLanguageClient implements LanguageClient {
 
@@ -195,13 +274,24 @@ public void stop() throws Exception {
         if (subscribe != null) {
             subscribe.unsubscribe();
         }
+        if (lspClient != null) {
+            lspClient.cancel(true);
+        }
         if (lspServer != null) {
             lspServer.cancel(true);
         }
-        if (lspClient != null) {
-            lspClient.cancel(true);
+        if (dapClientListener != null) {
+            dapClientListener.cancel(true);
         }
-        executor.shutdown();
+        if (dapServerListener != null) {
+            dapServerListener.cancel(true);
+        }
+
+        fxClientExecutor.shutdown();
+        lspClientExecutor.shutdown();
+        dapClientExecutor.shutdown();
+        lspServerExecutor.shutdown();
+        dapServerExecutor.shutdown();
     }
 
     private int toOffset(String text, Position position) {
@@ -265,7 +355,7 @@ protected StyleSpans<Collection<String>> call() throws Exception {
                 return computeHighlighting(text);
             }
         };
-        executor.execute(task);
+        fxClientExecutor.execute(task);
         return task;
     }
 
@@ -298,4 +388,15 @@ private StyleSpans<Collection<String>> computeHighlighting(String text) {
         return spansBuilder.create();
     }
 
+    private class DAPClient implements DebugProtocolClientExtension {
+        @Override
+        public void output(OutputEventArguments args) {
+            Platform.runLater(() -> outputArea.appendText(args.getOutput()));
+        }
+
+        @Override
+        public CompletableFuture<String> input() {
+            return CompletableFuture.completedFuture("SIMPLE TEXT");
+        }
+    }
 }
diff --git a/dev.thihup.jvisualg.ide/src/main/java/module-info.java b/dev.thihup.jvisualg.ide/src/main/java/module-info.java
index 94989cb..b22161b 100644
--- a/dev.thihup.jvisualg.ide/src/main/java/module-info.java
+++ b/dev.thihup.jvisualg.ide/src/main/java/module-info.java
@@ -4,6 +4,11 @@
     requires org.fxmisc.richtext;
     requires reactfx;
     requires dev.thihup.jvisualg.lsp;
+    requires org.eclipse.lsp4j;
+    requires org.eclipse.lsp4j.jsonrpc;
+    requires dev.thihup.jvisualg.interpreter;
+    requires org.eclipse.lsp4j.debug;
+    requires org.eclipse.lsp4j.jsonrpc.debug;
 
     exports dev.thihup.jvisualg.ide to javafx.graphics;
 
diff --git a/dev.thihup.jvisualg.ide/src/main/resources/dev/thihup/jvisualg/ide/gui.fxml b/dev.thihup.jvisualg.ide/src/main/resources/dev/thihup/jvisualg/ide/gui.fxml
index 38215ae..d97e095 100644
--- a/dev.thihup.jvisualg.ide/src/main/resources/dev/thihup/jvisualg/ide/gui.fxml
+++ b/dev.thihup.jvisualg.ide/src/main/resources/dev/thihup/jvisualg/ide/gui.fxml
@@ -1,9 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
+<?import javafx.collections.FXCollections?>
 <?import javafx.scene.control.Button?>
 <?import javafx.scene.control.Menu?>
 <?import javafx.scene.control.MenuBar?>
-<?import javafx.scene.control.MenuItem?>
 <?import javafx.scene.control.SplitPane?>
 <?import javafx.scene.control.TableColumn?>
 <?import javafx.scene.control.TableView?>
@@ -13,8 +13,6 @@
 <?import org.fxmisc.flowless.VirtualizedScrollPane?>
 <?import org.fxmisc.richtext.CodeArea?>
 
-<?import java.lang.String?>
-<?import javafx.collections.FXCollections?>
 <AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="400.0" prefWidth="600.0" xmlns="http://javafx.com/javafx/21" xmlns:fx="http://javafx.com/fxml/1">
    <children>
       <AnchorPane AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
@@ -46,7 +44,7 @@
                   <Button layoutX="70.0" layoutY="13.0" mnemonicParsing="false" text="✂" />
                   <Button layoutX="90.0" layoutY="13.0" mnemonicParsing="false" text="🗐" />
                   <Button layoutX="110.0" layoutY="13.0" mnemonicParsing="false" text="📋" />
-                  <Button layoutX="130.0" layoutY="13.0" mnemonicParsing="false" />
+                  <Button id="runButton" fx:id="runButton" layoutX="130.0" layoutY="13.0" mnemonicParsing="false" text="▶" />
                   <Button layoutX="150.0" layoutY="13.0" mnemonicParsing="false" />
                   <Button layoutX="170.0" layoutY="13.0" mnemonicParsing="false" />
                   <Button layoutX="190.0" layoutY="13.0" mnemonicParsing="false" />
@@ -60,7 +58,7 @@
                      <children>
                         <VirtualizedScrollPane AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
                             <content>
-                                <CodeArea fx:id="codeArea" id="codeArea" wrapText="true" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0" />
+                                <CodeArea id="codeArea" fx:id="codeArea" wrapText="true" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0" />
                             </content>
                         </VirtualizedScrollPane>
                      </children>
@@ -87,7 +85,7 @@
                               </AnchorPane>
                             <AnchorPane minHeight="0.0" minWidth="0.0" prefHeight="158.0" prefWidth="346.0">
                                  <children>
-                                    <TextArea layoutX="240.0" layoutY="-33.0" prefHeight="200.0" prefWidth="175.0" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0" />
+                                    <TextArea id="outputArea" fx:id="outputArea" layoutX="240.0" layoutY="-33.0" prefHeight="200.0" prefWidth="175.0" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0" />
                                  </children>
                               </AnchorPane>
                           </items>
diff --git a/dev.thihup.jvisualg.interpreter/pom.xml b/dev.thihup.jvisualg.interpreter/pom.xml
index 8a95ae7..017ab18 100644
--- a/dev.thihup.jvisualg.interpreter/pom.xml
+++ b/dev.thihup.jvisualg.interpreter/pom.xml
@@ -17,6 +17,11 @@
             <artifactId>dev.thihup.jvisualg.frontend</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.eclipse.lsp4j</groupId>
+            <artifactId>org.eclipse.lsp4j.debug</artifactId>
+            <version>0.22.0</version>
+        </dependency>
     </dependencies>
 
 </project>
diff --git a/dev.thihup.jvisualg.interpreter/src/main/java/dev/thihup/jvisualg/interpreter/DAPServer.java b/dev.thihup.jvisualg.interpreter/src/main/java/dev/thihup/jvisualg/interpreter/DAPServer.java
new file mode 100644
index 0000000..ee7fb1f
--- /dev/null
+++ b/dev.thihup.jvisualg.interpreter/src/main/java/dev/thihup/jvisualg/interpreter/DAPServer.java
@@ -0,0 +1,112 @@
+package dev.thihup.jvisualg.interpreter;
+
+import dev.thihup.jvisualg.frontend.ASTResult;
+import dev.thihup.jvisualg.frontend.Main;
+import dev.thihup.jvisualg.frontend.node.Location;
+import org.eclipse.lsp4j.debug.*;
+import org.eclipse.lsp4j.debug.services.IDebugProtocolClient;
+import org.eclipse.lsp4j.debug.services.IDebugProtocolServer;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class DAPServer implements IDebugProtocolServer {
+
+    private Reader reader;
+    private Writer writer;
+
+    Interpreter interpreter;
+
+    private ReentrantLock lock = new ReentrantLock();
+    private DebugProtocolClientExtension client;
+
+    @Override
+    public CompletableFuture<Capabilities> initialize(InitializeRequestArguments args) {
+        reader = new Reader() {
+            @Override
+            public int read(char[] cbuf, int off, int len) throws IOException {
+                return client.input().thenApply(x -> {
+                    x.getChars(0, x.length(), cbuf, off);
+                    return x.length();
+                }).join();
+            }
+
+            @Override
+            public void close() throws IOException {
+
+            }
+        };
+
+
+        writer = new StringWriter();
+        interpreter = new Interpreter(reader, new FilterWriter(writer) {
+            @Override
+            public void write(String str, int off, int len) throws IOException {
+                super.write(str, off, len);
+
+                OutputEventArguments args1 = new OutputEventArguments();
+                args1.setOutput(str.substring(off, off + len));
+                args1.setCategory(OutputEventArgumentsCategory.STDOUT);
+                client.output(args1);
+            }
+        }, lock);
+        return CompletableFuture.completedFuture(new Capabilities());
+    }
+
+    @Override
+    public CompletableFuture<Void> launch(Map<String, Object> args) {
+        return CompletableFuture.runAsync(() -> {
+            ByteArrayInputStream source = new ByteArrayInputStream(args.get("source").toString().getBytes(StandardCharsets.ISO_8859_1));
+            ASTResult astResult = Main.buildAST(source);
+
+            OutputEventArguments outputStart = new OutputEventArguments();
+            outputStart.setOutput("Início da execução\n");
+            client.output(outputStart);
+
+            try {
+                astResult.node().ifPresent(interpreter::run);
+                OutputEventArguments outputEnd = new OutputEventArguments();
+                outputEnd.setOutput("\nFim da execução.");
+                client.output(outputEnd);
+            } catch (Exception e) {
+                OutputEventArguments outputEnd = new OutputEventArguments();
+                outputEnd.setOutput("\nErro: " + e.getMessage());
+                client.output(outputEnd);
+            }
+            client.terminated(new TerminatedEventArguments());
+            reset();
+        });
+    }
+
+    private void reset() {
+    }
+
+    @Override
+    public CompletableFuture<Void> stepIn(StepInArguments args) {
+        lock.unlock();
+        return CompletableFuture.completedFuture(null);
+    }
+
+    // F9
+    @Override
+    public CompletableFuture<ContinueResponse> continue_(ContinueArguments args) {
+        lock.unlock();
+        return CompletableFuture.completedFuture(new ContinueResponse());
+    }
+
+    @Override
+    public CompletableFuture<SetBreakpointsResponse> setBreakpoints(SetBreakpointsArguments args) {
+        Arrays.stream(args.getBreakpoints())
+            .map(x -> new Location(x.getLine(), x.getColumn(), x.getLine(), x.getColumn()))
+            .forEach(interpreter::addBreakpoint);
+        return CompletableFuture.completedFuture(new SetBreakpointsResponse());
+    }
+
+    public void connect(DebugProtocolClientExtension remoteProxy) {
+        this.client = remoteProxy;
+    }
+}
diff --git a/dev.thihup.jvisualg.interpreter/src/main/java/dev/thihup/jvisualg/interpreter/DebugProtocolClientExtension.java b/dev.thihup.jvisualg.interpreter/src/main/java/dev/thihup/jvisualg/interpreter/DebugProtocolClientExtension.java
new file mode 100644
index 0000000..c777819
--- /dev/null
+++ b/dev.thihup.jvisualg.interpreter/src/main/java/dev/thihup/jvisualg/interpreter/DebugProtocolClientExtension.java
@@ -0,0 +1,12 @@
+package dev.thihup.jvisualg.interpreter;
+
+import org.eclipse.lsp4j.jsonrpc.services.JsonNotification;
+
+import java.util.concurrent.CompletableFuture;
+
+public interface DebugProtocolClientExtension extends org.eclipse.lsp4j.debug.services.IDebugProtocolClient {
+
+    @JsonNotification("input")
+    CompletableFuture<String> input();
+
+}
diff --git a/dev.thihup.jvisualg.interpreter/src/main/java/dev/thihup/jvisualg/interpreter/Interpreter.java b/dev.thihup.jvisualg.interpreter/src/main/java/dev/thihup/jvisualg/interpreter/Interpreter.java
index cdf9c5e..4aa6ffa 100644
--- a/dev.thihup.jvisualg.interpreter/src/main/java/dev/thihup/jvisualg/interpreter/Interpreter.java
+++ b/dev.thihup.jvisualg.interpreter/src/main/java/dev/thihup/jvisualg/interpreter/Interpreter.java
@@ -2,28 +2,32 @@
 
 import dev.thihup.jvisualg.frontend.ASTResult;
 import dev.thihup.jvisualg.frontend.Main;
+import dev.thihup.jvisualg.frontend.node.Location;
 import dev.thihup.jvisualg.frontend.node.Node;
+import org.antlr.v4.runtime.misc.Pair;
 
 import java.io.*;
 import java.math.RoundingMode;
 import java.text.NumberFormat;
-import java.util.LinkedHashMap;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Scanner;
+import java.util.*;
+import java.util.concurrent.locks.Lock;
 
 public class Interpreter {
 
     private final Map<String, Object> global = new LinkedHashMap<>();
     private final Reader originalInput;
     private final Writer output;
+    private final Lock lock;
     private boolean running = true;
     private Scanner input;
 
-    Interpreter(Reader input, Writer output) {
+    private List<Location> breakpointLocations = new ArrayList<>();
+
+    Interpreter(Reader input, Writer output, Lock debuggerLock) {
         this.originalInput = input;
         this.input = new Scanner(input);
         this.output = output;
+        this.lock = debuggerLock;
     }
 
     public void run(Node node) {
@@ -31,6 +35,11 @@ public void run(Node node) {
             return;
         }
         try {
+            if (breakpointLocations.stream()
+                    .anyMatch(location -> location.isInside(node.location().orElse(Location.EMPTY)))) {
+                lock.lock();
+            }
+
             switch (node) {
                 case Node.AlgoritimoNode algoritimoNode -> runAlgoritmo(algoritimoNode);
                 case Node.ArrayTypeNode arrayTypeNode -> throw new UnsupportedOperationException("ArrayTypeNode not implemented");
@@ -52,7 +61,7 @@ public void run(Node node) {
         }
     }
 
-    private void runCommand(Node.CommandNode commandNode) throws IOException {
+    private void runCommand(Node.CommandNode commandNode) throws IOException, InterruptedException {
         switch (commandNode) {
             case Node.AleatorioCommandNode aleatorioCommandNode -> throw new UnsupportedOperationException("AleatorioCommandNode not implemented");
             case Node.ArquivoCommandNode arquivoCommandNode -> throw new UnsupportedOperationException("ArquivoCommandNode not implemented");
@@ -182,7 +191,7 @@ private void printValue(Object value, Node spaces, Node precision) throws IOExce
     private Object evaluate(Node.ExpressionNode node){
         return switch (node) {
             case Node.StringLiteralNode(var value, _) -> value;
-            case Node.BinaryNode binaryNode -> throw new UnsupportedOperationException("BinaryNode not implemented");
+            case Node.BinaryNode binaryNode -> evaluateBinaryNode(binaryNode);
             case Node.BooleanLiteralNode(var value, _) -> value;
             case Node.BooleanNode booleanNode -> throw new UnsupportedOperationException("BooleanNode not implemented");
             case Node.FunctionCallNode functionCallNode -> throw new UnsupportedOperationException("FunctionCallNode not implemented");
@@ -191,6 +200,200 @@ private Object evaluate(Node.ExpressionNode node){
             case Node.IdNode idNode -> global.get(idNode.id());
         };
     }
+    record PairValue(Object left, Object right) {}
+    private Object evaluateBinaryNode(Node.BinaryNode binaryNode) {
+
+        return switch (binaryNode) {
+            case Node.AddNode(Node.ExpressionNode left, Node.ExpressionNode right, _) -> {
+                Object leftResult = evaluate(left);
+                Object rightResult = evaluate(right);
+
+                yield switch (new PairValue(leftResult, rightResult)) {
+                    case PairValue(Number x, Double y) -> x.doubleValue() + y;
+                    case PairValue(Double x, Number y) -> x + y.doubleValue();
+
+                    case PairValue(Number x, Number y) -> x.intValue() + y.intValue();
+                    case Object o -> throw new UnsupportedOperationException("unsupported add node types: " + o);
+                };
+            }
+            case Node.DivNode(Node.ExpressionNode left, Node.ExpressionNode right, _) -> {
+                Object leftResult = evaluate(left);
+                Object rightResult = evaluate(right);
+
+                yield switch (new PairValue(leftResult, rightResult)) {
+                    case PairValue(Number x, Double y) -> x.doubleValue() / y;
+                    case PairValue(Double x, Number y) -> x / y.doubleValue();
+
+                    case PairValue(Number x, Number y) -> x.intValue() / y.intValue();
+                    case Object o -> throw new UnsupportedOperationException("unsupported add node types: " + o);
+                };
+            }
+            case Node.ModNode(Node.ExpressionNode left, Node.ExpressionNode right, _) -> {
+                Object leftResult = evaluate(left);
+                Object rightResult = evaluate(right);
+
+                yield switch (new PairValue(leftResult, rightResult)) {
+                    case PairValue(Number x, Double y) -> x.doubleValue() % y;
+                    case PairValue(Double x, Number y) -> x % y.doubleValue();
+
+                    case PairValue(Number x, Number y) -> x.intValue() % y.intValue();
+                    case Object o -> throw new UnsupportedOperationException("unsupported add node types: " + o);
+                };
+            }
+            case Node.MulNode(Node.ExpressionNode left, Node.ExpressionNode right, _) -> {
+                Object leftResult = evaluate(left);
+                Object rightResult = evaluate(right);
+
+                yield switch (new PairValue(leftResult, rightResult)) {
+                    case PairValue(Number x, Double y) -> x.doubleValue() * y;
+                    case PairValue(Double x, Number y) -> x * y.doubleValue();
+
+                    case PairValue(Number x, Number y) -> x.intValue() * y.intValue();
+                    case Object o -> throw new UnsupportedOperationException("unsupported add node types: " + o);
+                };
+            }
+
+            case Node.PowNode(Node.ExpressionNode left, Node.ExpressionNode right, _) -> {
+                Object leftResult = evaluate(left);
+                Object rightResult = evaluate(right);
+
+                yield switch (new PairValue(leftResult, rightResult)) {
+                    case PairValue(Number x, Double y) -> Math.pow(x.doubleValue(),y);
+                    case PairValue(Double x, Number y) -> Math.pow(x, y.doubleValue());
+
+                    case PairValue(Number x, Number y) -> (int) Math.pow(x.intValue(), y.intValue());
+                    case Object o -> throw new UnsupportedOperationException("unsupported add node types: " + o);
+                };
+            }
+            case Node.SubNode(Node.ExpressionNode left, Node.ExpressionNode right, _) -> {
+                Object leftResult = evaluate(left);
+                Object rightResult = evaluate(right);
+
+                yield switch (new PairValue(leftResult, rightResult)) {
+                    case PairValue(Number x, Double y) -> x.doubleValue() - y;
+                    case PairValue(Double x, Number y) -> x - y.doubleValue();
+
+                    case PairValue(Number x, Number y) -> x.intValue() - y.intValue();
+                    case Object o -> throw new UnsupportedOperationException("unsupported add node types: " + o);
+                };
+            }
+            case Node.RelationalNode relationalNode -> evaluateRelationalNode(relationalNode);
+            case Object o -> throw new UnsupportedOperationException("Operands should be expressions: " + o);
+        };
+    }
+
+    private Object evaluateRelationalNode(Node.RelationalNode relationalNode) {
+        return switch (relationalNode) {
+            case Node.AndNode(Node.ExpressionNode left, Node.ExpressionNode right, _) -> {
+                Object leftResult = evaluate(left);
+                Object rightResult = evaluate(right);
+
+                yield switch (new PairValue(leftResult, rightResult)) {
+                    case PairValue(Boolean x, Boolean y) -> x && y;
+                    case Object o -> throw new UnsupportedOperationException("unsupported add node types: " + o);
+                };
+            }
+            case Node.OrNode(Node.ExpressionNode left, Node.ExpressionNode right, _) -> {
+                Object leftResult = evaluate(left);
+                Object rightResult = evaluate(right);
+
+                yield switch (new PairValue(leftResult, rightResult)) {
+                    case PairValue(Boolean x, Boolean y) -> x || y;
+                    case Object o -> throw new UnsupportedOperationException("unsupported add node types: " + o);
+                };
+            }
+
+            case Node.GeNode(Node.ExpressionNode left, Node.ExpressionNode right, _) -> {
+                Object leftResult = evaluate(left);
+                Object rightResult = evaluate(right);
+
+                yield switch (new PairValue(leftResult, rightResult)) {
+                    case PairValue(Number x, Double y) -> x.doubleValue() >= y;
+                    case PairValue(Double x, Number y) -> x >= y.doubleValue();
+                    case PairValue(Boolean x, Boolean y) -> x || !y;
+                    case PairValue(Boolean _, Number y) -> y;
+                    case PairValue(Number _, Boolean y) -> y;
+
+                    case PairValue(Number x, Number y) -> x.intValue() >= y.intValue();
+                    case Object o -> throw new UnsupportedOperationException("unsupported add node types: " + o);
+                };
+            }
+            case Node.GtNode(Node.ExpressionNode left, Node.ExpressionNode right, _) -> {
+                Object leftResult = evaluate(left);
+                Object rightResult = evaluate(right);
+
+                yield switch (new PairValue(leftResult, rightResult)) {
+                    case PairValue(Number x, Double y) -> x.doubleValue() > y;
+                    case PairValue(Double x, Number y) -> x > y.doubleValue();
+                    case PairValue(Boolean x, Boolean y) -> x && !y;
+                    case PairValue(Number x, Number y) -> x.intValue() > y.intValue();
+                    case PairValue(Boolean _, Number y) -> y;
+                    case PairValue(Number _, Boolean y) -> y;
+
+
+                    case Object o -> throw new UnsupportedOperationException("unsupported add node types: " + o);
+                };
+            }
+            case Node.LeNode(Node.ExpressionNode left, Node.ExpressionNode right, _) -> {
+                Object leftResult = evaluate(left);
+                Object rightResult = evaluate(right);
+
+                yield switch (new PairValue(leftResult, rightResult)) {
+                    case PairValue(Number x, Double y) -> x.doubleValue() <= y;
+                    case PairValue(Double x, Number y) -> x <= y.doubleValue();
+                    case PairValue(Boolean x, Boolean y) -> !x || y;
+                    case PairValue(Boolean _, Number y) -> y;
+                    case PairValue(Number _, Boolean y) -> y;
+
+
+                    case PairValue(Number x, Number y) -> x.intValue() <= y.intValue();
+                    case Object o -> throw new UnsupportedOperationException("unsupported add node types: " + o);
+                };
+            }
+            case Node.LtNode(Node.ExpressionNode left, Node.ExpressionNode right, _) -> {
+                Object leftResult = evaluate(left);
+                Object rightResult = evaluate(right);
+
+                yield switch (new PairValue(leftResult, rightResult)) {
+                    case PairValue(Number x, Double y) -> x.doubleValue() < y;
+                    case PairValue(Double x, Number y) -> x < y.doubleValue();
+                    case PairValue(Boolean x, Boolean y) -> !x && y;
+                    case PairValue(Boolean _, Number y) -> y;
+                    case PairValue(Number _, Boolean y) -> y;
+
+
+                    case PairValue(Number x, Number y) -> x.intValue() < y.intValue();
+                    case Object o -> throw new UnsupportedOperationException("unsupported add node types: " + o);
+                };
+            }
+
+            case Node.EqNode(Node.ExpressionNode left, Node.ExpressionNode right, _) -> {
+                Object leftResult = evaluate(left);
+                Object rightResult = evaluate(right);
+
+                yield switch (new PairValue(leftResult, rightResult)) {
+                    case PairValue(Boolean _, Number y) -> y;
+                    case PairValue(Number _, Boolean y) -> y;
+                    case PairValue(Object x, Object y) -> x.equals(y);
+                    case Object o -> throw new UnsupportedOperationException("unsupported add node types: " + o);
+                };
+            }
+
+            case Node.NeNode(Node.ExpressionNode left, Node.ExpressionNode right, _) -> {
+                Object leftResult = evaluate(left);
+                Object rightResult = evaluate(right);
+
+                yield switch (new PairValue(leftResult, rightResult)) {
+                    case PairValue(Boolean _, Number y) -> y;
+                    case PairValue(Number _, Boolean y) -> y;
+                    case PairValue(Object x, Object y) -> !x.equals(y);
+                    case Object o -> throw new UnsupportedOperationException("unsupported add node types: " + o);
+                };
+            }
+
+            case Object o -> throw new UnsupportedOperationException("Operands should be expressions: " + o);
+        };
+    }
 
     public void stop() {
         running = false;
@@ -231,4 +434,8 @@ private Object newInstance(Node typeNode) {
             default -> throw new IllegalStateException("Unexpected value: " + typeNode);
         };
     }
+
+    public void addBreakpoint(Location location) {
+        breakpointLocations.add(location);
+    }
 }
diff --git a/dev.thihup.jvisualg.interpreter/src/main/java/module-info.java b/dev.thihup.jvisualg.interpreter/src/main/java/module-info.java
index bb845a1..006cedd 100644
--- a/dev.thihup.jvisualg.interpreter/src/main/java/module-info.java
+++ b/dev.thihup.jvisualg.interpreter/src/main/java/module-info.java
@@ -1,3 +1,7 @@
 module dev.thihup.jvisualg.interpreter {
     requires dev.thihup.jvisualg.frontend;
+    requires org.eclipse.lsp4j.debug;
+    requires org.eclipse.lsp4j.jsonrpc;
+
+    exports dev.thihup.jvisualg.interpreter to dev.thihup.jvisualg.ide, org.eclipse.lsp4j.jsonrpc;
 }