diff --git a/.github/workflows/kotlin-checks.yml b/.github/workflows/kotlin-checks.yml
index 93ff4a3..5e04024 100644
--- a/.github/workflows/kotlin-checks.yml
+++ b/.github/workflows/kotlin-checks.yml
@@ -19,14 +19,19 @@ jobs:
           distribution: 'temurin'
           cache: gradle
           
+      - name: Cache Gradle dependencies
+        uses: actions/cache@v3
+        with:
+          path: ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+      
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
         
       - name: Build with Gradle
         run: ./gradlew build
         
-      - name: Run ktlint
-        run: ./gradlew ktlintCheck
-        
       - name: Kotlin Kover
         run: ./gradlew koverXmlReport
diff --git a/.idea/.name b/.idea/.name
new file mode 100644
index 0000000..b71e6e5
--- /dev/null
+++ b/.idea/.name
@@ -0,0 +1 @@
+CompilerLogic
\ No newline at end of file
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 14746e7..2a65317 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index 5b03e1e..40927b2 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -31,6 +31,7 @@
     <inspection_tool class="ReplaceCollectionCountWithSize" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
     <inspection_tool class="ReplaceNotNullAssertionWithElvisReturn" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
     <inspection_tool class="RestrictReturnStatementTargetMigration" enabled="true" level="ERROR" enabled_by_default="true" />
+    <inspection_tool class="SingleClassImport" enabled="true" level="INFORMATION" enabled_by_default="true" editorAttributes="INFORMATION_ATTRIBUTES" />
     <inspection_tool class="UnusedMainParameter" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
     <inspection_tool class="WarningOnMainUnusedParameterMigration" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
     <inspection_tool class="WhenWithOnlyElse" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
diff --git a/.idea/ktlint-plugin.xml b/.idea/ktlint-plugin.xml
new file mode 100644
index 0000000..e8bd90c
--- /dev/null
+++ b/.idea/ktlint-plugin.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="com.nbadal.ktlint.KtlintProjectSettings">
+    <ktlintMode>DISTRACT_FREE</ktlintMode>
+    <ktlintRulesetVersion>DEFAULT</ktlintRulesetVersion>
+  </component>
+</project>
\ No newline at end of file
diff --git a/src/main/kotlin/Exceptions/SyntaxError.kt b/src/main/kotlin/Exceptions/SyntaxError.kt
new file mode 100644
index 0000000..795a668
--- /dev/null
+++ b/src/main/kotlin/Exceptions/SyntaxError.kt
@@ -0,0 +1,20 @@
+package org.example.Exceptions
+
+class SyntaxError(
+    message: String,
+    val line: Int? = null,
+    val column: Int? = null
+) : Exception(buildMessage(message, line, column)) {
+    companion object {
+        private fun buildMessage(
+            message: String,
+            line: Int?,
+            column: Int?
+        ): String =
+            when {
+                line != null && column != null -> "Syntax error at line $line, column $column: $message"
+                line != null -> "Syntax error at line $line: $message"
+                else -> "Syntax error: $message"
+            }
+    }
+}
diff --git a/src/main/kotlin/Main.kt b/src/main/kotlin/Main.kt
index f05bc13..50305ce 100644
--- a/src/main/kotlin/Main.kt
+++ b/src/main/kotlin/Main.kt
@@ -1,15 +1,15 @@
 package org.example
 
-import Lexer
+import lexer.Lexer
+import org.example.parser.Parser
 
 fun main() {
-    val code = """
-    int main(void){
-    int x = 5
-    int y = 3
-    int z = 5+3
-    }
-    """.trimIndent()
+    val code =
+        """
+        int main(void){
+        return 5;
+        }
+        """.trimIndent()
     val lexer = Lexer(code)
     val tokens = lexer.tokenize()
     tokens.forEach { token ->
@@ -19,4 +19,8 @@ fun main() {
                 "Position: [L:${token.line}, C:${token.column}]"
         )
     }
+
+    val parser = Parser()
+    val ast = parser.parseTokens(tokens)
+    println(ast.prettyPrint())
 }
diff --git a/src/main/kotlin/Lexer.kt b/src/main/kotlin/lexer/Lexer.kt
similarity index 97%
rename from src/main/kotlin/Lexer.kt
rename to src/main/kotlin/lexer/Lexer.kt
index a737099..5ef87bd 100644
--- a/src/main/kotlin/Lexer.kt
+++ b/src/main/kotlin/lexer/Lexer.kt
@@ -1,3 +1,5 @@
+package lexer
+
 // a sealed class that can't be inherited and includes distinct objects for each category
 // instead of instantiating objects, we use them directly
 
@@ -60,10 +62,10 @@ class Lexer(val source: String) {
 
     // check if we are at end of the source code
     private fun isAtEnd(): Boolean {
-        if (current >= source.length) {
-            return true
+        return if (current >= source.length) {
+            true
         } else {
-            return false
+            false
         }
     }
 
diff --git a/src/main/kotlin/parser/ASTNode.kt b/src/main/kotlin/parser/ASTNode.kt
new file mode 100644
index 0000000..11f82f4
--- /dev/null
+++ b/src/main/kotlin/parser/ASTNode.kt
@@ -0,0 +1,6 @@
+package org.example.parser
+
+sealed class ASTNode {
+    abstract fun prettyPrint(indent: Int = 0): String
+    fun indent(level: Int): String = "    ".repeat(level) // 4 spaces per level
+}
diff --git a/src/main/kotlin/parser/Expression.kt b/src/main/kotlin/parser/Expression.kt
new file mode 100644
index 0000000..6709de6
--- /dev/null
+++ b/src/main/kotlin/parser/Expression.kt
@@ -0,0 +1,13 @@
+package org.example.parser
+
+import lexer.Token
+
+sealed class Expression : ASTNode()
+
+data class IntExpression(
+    val value: Token
+) : Expression() {
+    override fun prettyPrint(indent: Int): String {
+        return "${indent(indent)}Int(${value.lexeme})"
+    }
+}
diff --git a/src/main/kotlin/parser/Functions.kt b/src/main/kotlin/parser/Functions.kt
new file mode 100644
index 0000000..18ea668
--- /dev/null
+++ b/src/main/kotlin/parser/Functions.kt
@@ -0,0 +1,18 @@
+package org.example.parser
+
+sealed class FunctionDefinition : ASTNode()
+
+data class SimpleFunction(
+    val name: Identifier,
+    val body: Statement
+) : FunctionDefinition() {
+    override fun prettyPrint(indent: Int): String {
+        return buildString {
+            appendLine("${indent(indent)}SimpleFunction(")
+            append("${indent(indent + 1)}name=${name.prettyPrint(0)}")
+            appendLine("${indent(indent + 1)}body=")
+            append("${indent(indent)}${body.prettyPrint(indent + 1)}")
+            appendLine("${indent(indent)})")
+        }
+    }
+}
diff --git a/src/main/kotlin/parser/Identifier.kt b/src/main/kotlin/parser/Identifier.kt
new file mode 100644
index 0000000..788d1ba
--- /dev/null
+++ b/src/main/kotlin/parser/Identifier.kt
@@ -0,0 +1,11 @@
+package org.example.parser
+
+import lexer.Token
+
+data class Identifier(
+    val token: Token
+) : ASTNode() {
+    override fun prettyPrint(indent: Int): String {
+        return buildString { appendLine("${indent(indent)}\"${token.lexeme}\"") }
+    }
+}
diff --git a/src/main/kotlin/parser/Parser.kt b/src/main/kotlin/parser/Parser.kt
new file mode 100644
index 0000000..c478469
--- /dev/null
+++ b/src/main/kotlin/parser/Parser.kt
@@ -0,0 +1,91 @@
+package org.example.parser
+
+import lexer.Token
+import lexer.TokenType
+import org.example.Exceptions.SyntaxError
+
+class Parser {
+    fun parseTokens(tokens: List<Token>): ASTNode {
+        val tokens = tokens.toMutableList()
+        val ast = parseProgram(tokens)
+
+        val lastToken = tokens.removeFirst()
+        if (lastToken.type != TokenType.EOF) {
+            throw SyntaxError(
+                line = lastToken.line,
+                column = lastToken.column,
+                message = "Expected end of file"
+            )
+        }
+        return ast
+    }
+
+    private fun parseProgram(tokens: MutableList<Token>): SimpleProgram {
+        val function = parseFunction(tokens)
+
+        return SimpleProgram(functionDefinition = function)
+    }
+
+    private fun parseFunction(tokens: MutableList<Token>): FunctionDefinition {
+        expect(TokenType.KEYWORD_INT, tokens)
+        val name = parseIdentifier(tokens)
+        expect(TokenType.LEFT_PAREN, tokens)
+        expect(TokenType.KEYWORD_VOID, tokens)
+        expect(TokenType.RIGHT_PAREN, tokens)
+        expect(TokenType.LEFT_BRACK, tokens)
+        val body = parseStatement(tokens)
+        expect(TokenType.RIGHT_BRACK, tokens)
+
+        return SimpleFunction(name = name, body = body)
+    }
+
+    private fun expect(
+        expected: TokenType,
+        tokens: MutableList<Token>
+    ): Token {
+        val token = tokens.removeFirst()
+
+        if (token.type != expected) {
+            throw SyntaxError(
+                line = token.line,
+                column = token.column,
+                message = "Expected token: $expected, got ${token.type}"
+            )
+        }
+
+        return token
+    }
+
+    private fun parseIdentifier(tokens: MutableList<Token>): Identifier {
+        val token = tokens.removeFirst()
+        if (token.type != TokenType.IDENTIFIER) {
+            throw SyntaxError(
+                line = token.line,
+                column = token.column,
+                message = "Expected token: ${TokenType.IDENTIFIER}, got ${token.type}"
+            )
+        }
+
+        return Identifier(token = token)
+    }
+
+    private fun parseStatement(tokens: MutableList<Token>): Statement {
+        expect(TokenType.KEYWORD_RETURN, tokens)
+        val expression = parseExpression(tokens)
+        expect(TokenType.SEMICOLON, tokens)
+
+        return ReturnStatement(expression = expression)
+    }
+
+    private fun parseExpression(tokens: MutableList<Token>): Expression {
+        val token = tokens.removeFirst()
+        if (token.type != TokenType.INT_LITERAL) {
+            throw SyntaxError(
+                line = token.line,
+                column = token.column,
+                message = "Expected token: ${TokenType.INT_LITERAL}, got ${token.type}"
+            )
+        }
+        return IntExpression(value = token)
+    }
+}
diff --git a/src/main/kotlin/parser/Programs.kt b/src/main/kotlin/parser/Programs.kt
new file mode 100644
index 0000000..008cdef
--- /dev/null
+++ b/src/main/kotlin/parser/Programs.kt
@@ -0,0 +1,15 @@
+package org.example.parser
+
+sealed class Program : ASTNode()
+
+data class SimpleProgram(
+    val functionDefinition: FunctionDefinition
+) : Program() {
+    override fun prettyPrint(indent: Int): String {
+        return buildString {
+            appendLine("${indent(indent)}SimpleProgram(")
+            append(functionDefinition.prettyPrint(indent + 1))
+            appendLine("${indent(indent)})")
+        }
+    }
+}
diff --git a/src/main/kotlin/parser/Statement.kt b/src/main/kotlin/parser/Statement.kt
new file mode 100644
index 0000000..64e1866
--- /dev/null
+++ b/src/main/kotlin/parser/Statement.kt
@@ -0,0 +1,15 @@
+package org.example.parser
+
+sealed class Statement : ASTNode()
+
+data class ReturnStatement(
+    val expression: Expression
+) : Statement() {
+    override fun prettyPrint(indent: Int): String {
+        return buildString {
+            appendLine("${indent(indent)}ReturnStatement(")
+            appendLine(expression.prettyPrint(indent + 1))
+            appendLine("${indent(indent)})")
+        }
+    }
+}
diff --git a/src/test/kotlin/LexerTest.kt b/src/test/kotlin/LexerTest.kt
index 34158b2..944d557 100644
--- a/src/test/kotlin/LexerTest.kt
+++ b/src/test/kotlin/LexerTest.kt
@@ -1,4 +1,6 @@
 
+import lexer.Lexer
+import lexer.TokenType
 import org.junit.jupiter.api.Test
 import kotlin.test.assertEquals
 
diff --git a/src/test/kotlin/integration/LexerParserIntegrationTest.kt b/src/test/kotlin/integration/LexerParserIntegrationTest.kt
new file mode 100644
index 0000000..30a7918
--- /dev/null
+++ b/src/test/kotlin/integration/LexerParserIntegrationTest.kt
@@ -0,0 +1,48 @@
+package integration
+
+import lexer.Lexer
+import org.example.parser.IntExpression
+import org.example.parser.Parser
+import org.example.parser.ReturnStatement
+import org.example.parser.SimpleFunction
+import org.example.parser.SimpleProgram
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+
+class LexerParserIntegrationTest {
+
+    @Test
+    fun `test lexer and parser integration`() {
+        // Source code for a simple program
+        val source = "int main(void) { return 42; }"
+
+        // Use the lexer to tokenize the source
+        val lexer = Lexer(source)
+        val tokens = lexer.tokenize()
+
+        // Parse the tokens
+        val parser = Parser()
+        val ast = parser.parseTokens(tokens)
+
+        // Verify the AST structure
+        assertIs<SimpleProgram>(ast)
+        val program = ast
+
+        // Check function name
+        val function = program.functionDefinition
+        assertIs<SimpleFunction>(function)
+        val simpleFunction = function
+        assertEquals("main", simpleFunction.name.token.lexeme)
+
+        // Check return value
+        val returnStatement = simpleFunction.body
+        assertIs<ReturnStatement>(returnStatement)
+        val returnStmt = returnStatement
+
+        val expression = returnStmt.expression
+        assertIs<IntExpression>(expression)
+        val intExpr = expression
+        assertEquals("42", intExpr.value.lexeme)
+    }
+}
diff --git a/src/test/kotlin/parser/ParserTest.kt b/src/test/kotlin/parser/ParserTest.kt
new file mode 100644
index 0000000..9287407
--- /dev/null
+++ b/src/test/kotlin/parser/ParserTest.kt
@@ -0,0 +1,167 @@
+package parser
+
+import lexer.Token
+import lexer.TokenType
+import org.example.Exceptions.SyntaxError
+import org.example.parser.Parser
+import org.example.parser.SimpleProgram
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+
+class ParserTest {
+
+    @Test
+    fun `test basic program parsing`() {
+        // Create a list of tokens for a simple program: int main(void) { return 42; }
+        val tokens = listOf(
+            Token(TokenType.KEYWORD_INT, "int", 1, 1),
+            Token(TokenType.IDENTIFIER, "main", 1, 5),
+            Token(TokenType.LEFT_PAREN, "(", 1, 9),
+            Token(TokenType.KEYWORD_VOID, "void", 1, 10),
+            Token(TokenType.RIGHT_PAREN, ")", 1, 14),
+            Token(TokenType.LEFT_BRACK, "{", 1, 16),
+            Token(TokenType.KEYWORD_RETURN, "return", 1, 18),
+            Token(TokenType.INT_LITERAL, "42", 1, 25),
+            Token(TokenType.SEMICOLON, ";", 1, 27),
+            Token(TokenType.RIGHT_BRACK, "}", 1, 29),
+            Token(TokenType.EOF, "", 1, 30)
+        )
+
+        val parser = Parser()
+        val ast = parser.parseTokens(tokens)
+
+        // Verify the AST structure
+        assertIs<SimpleProgram>(ast)
+    }
+
+    @Test
+    fun `test detailed AST structure`() {
+        // Create a list of tokens for a simple program: int main(void) { return 42; }
+        val tokens = listOf(
+            Token(TokenType.KEYWORD_INT, "int", 1, 1),
+            Token(TokenType.IDENTIFIER, "main", 1, 5),
+            Token(TokenType.LEFT_PAREN, "(", 1, 9),
+            Token(TokenType.KEYWORD_VOID, "void", 1, 10),
+            Token(TokenType.RIGHT_PAREN, ")", 1, 14),
+            Token(TokenType.LEFT_BRACK, "{", 1, 16),
+            Token(TokenType.KEYWORD_RETURN, "return", 1, 18),
+            Token(TokenType.INT_LITERAL, "42", 1, 25),
+            Token(TokenType.SEMICOLON, ";", 1, 27),
+            Token(TokenType.RIGHT_BRACK, "}", 1, 29),
+            Token(TokenType.EOF, "", 1, 30)
+        )
+
+        val parser = Parser()
+        val ast = parser.parseTokens(tokens)
+
+        // Verify the AST structure in detail
+        assertIs<SimpleProgram>(ast)
+        val program = ast
+
+        // Check function definition
+        val function = program.functionDefinition
+        assertIs<org.example.parser.SimpleFunction>(function)
+        val simpleFunction = function
+
+        // Check function name
+        assertEquals("main", simpleFunction.name.token.lexeme)
+
+        // Check return statement
+        val returnStatement = simpleFunction.body
+        assertIs<org.example.parser.ReturnStatement>(returnStatement)
+        val returnStmt = returnStatement
+
+        // Check return expression
+        val expression = returnStmt.expression
+        assertIs<org.example.parser.IntExpression>(expression)
+        val intExpr = expression
+        assertEquals("42", intExpr.value.lexeme)
+    }
+
+    @Test
+    fun `test syntax error - missing int keyword`() {
+        // Missing the int keyword at the beginning
+        val tokens = listOf(
+            Token(TokenType.IDENTIFIER, "main", 1, 1),
+            Token(TokenType.LEFT_PAREN, "(", 1, 5),
+            Token(TokenType.KEYWORD_VOID, "void", 1, 6),
+            Token(TokenType.RIGHT_PAREN, ")", 1, 10),
+            Token(TokenType.LEFT_BRACK, "{", 1, 12),
+            Token(TokenType.KEYWORD_RETURN, "return", 1, 14),
+            Token(TokenType.INT_LITERAL, "42", 1, 21),
+            Token(TokenType.SEMICOLON, ";", 1, 23),
+            Token(TokenType.RIGHT_BRACK, "}", 1, 25),
+            Token(TokenType.EOF, "", 1, 26)
+        )
+
+        val parser = Parser()
+        val exception = assertThrows<SyntaxError> {
+            parser.parseTokens(tokens)
+        }
+
+        // Check that the error message contains the expected text
+        assert(exception.message!!.contains("Expected token: KEYWORD_INT, got IDENTIFIER"))
+        assertEquals(1, exception.line)
+        assertEquals(1, exception.column)
+    }
+
+    @Test
+    fun `test syntax error - missing return keyword`() {
+        // Missing the return keyword
+        val tokens = listOf(
+            Token(TokenType.KEYWORD_INT, "int", 1, 1),
+            Token(TokenType.IDENTIFIER, "main", 1, 5),
+            Token(TokenType.LEFT_PAREN, "(", 1, 9),
+            Token(TokenType.KEYWORD_VOID, "void", 1, 10),
+            Token(TokenType.RIGHT_PAREN, ")", 1, 14),
+            Token(TokenType.LEFT_BRACK, "{", 1, 16),
+            // Missing KEYWORD_RETURN here
+            Token(TokenType.INT_LITERAL, "42", 1, 18),
+            Token(TokenType.SEMICOLON, ";", 1, 20),
+            Token(TokenType.RIGHT_BRACK, "}", 1, 22),
+            Token(TokenType.EOF, "", 1, 23)
+        )
+
+        val parser = Parser()
+        val exception = assertThrows<SyntaxError> {
+            parser.parseTokens(tokens)
+        }
+
+        // Check that the error message contains the expected text
+        assert(exception.message!!.contains("Expected token: KEYWORD_RETURN, got INT_LITERAL"))
+        assertEquals(1, exception.line)
+        assertEquals(18, exception.column)
+    }
+
+    @Test
+    fun `test syntax error - extra tokens after program`() {
+        // Extra tokens after the program
+        val tokens = listOf(
+            Token(TokenType.KEYWORD_INT, "int", 1, 1),
+            Token(TokenType.IDENTIFIER, "main", 1, 5),
+            Token(TokenType.LEFT_PAREN, "(", 1, 9),
+            Token(TokenType.KEYWORD_VOID, "void", 1, 10),
+            Token(TokenType.RIGHT_PAREN, ")", 1, 14),
+            Token(TokenType.LEFT_BRACK, "{", 1, 16),
+            Token(TokenType.KEYWORD_RETURN, "return", 1, 18),
+            Token(TokenType.INT_LITERAL, "42", 1, 25),
+            Token(TokenType.SEMICOLON, ";", 1, 27),
+            Token(TokenType.RIGHT_BRACK, "}", 1, 29),
+            // Extra tokens here
+            Token(TokenType.IDENTIFIER, "extra", 1, 31),
+            Token(TokenType.EOF, "", 1, 36)
+        )
+
+        val parser = Parser()
+        val exception = assertThrows<SyntaxError> {
+            parser.parseTokens(tokens)
+        }
+
+        // Check that the error message contains the expected text
+        assert(exception.message!!.contains("Expected end of file"))
+        assertEquals(1, exception.line)
+        assertEquals(31, exception.column)
+    }
+}