diff --git a/Makefile b/Makefile
index 78cd83f..90bd7e9 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,6 @@
 BINAY_NAME=glox
 TESTS_DIR=./tests
-TEST_SET=. ./utils ./reporting ./token ./scanner ./expression ./astprinter ./cmd/ast
+TEST_SET=. ./utils ./reporting ./token ./scanner ./expression ./astprinter ./parser ./cmd/ast
 
 build:
 	go build -o glox .
diff --git a/README.md b/README.md
index 473612f..641f20e 100644
--- a/README.md
+++ b/README.md
@@ -7,10 +7,11 @@ This implementation is written in Go.
 # Grammar
 
 ```
-expression -> literal | unary | binary | grouping ;
-literal    -> NUMBER | STRING | "true" | "false" | "nil" ;
-grouping   -> "(" expression ")" ;
-unary      -> ( "-" | "!" ) expression ;
-binary     -> expression operator expression ;
-operator   -> "==" | "!=" | "<" | "<=" | ">" | ">=" | "+" | "-" | "*" | "/" ;
+expression -> equality
+equality   -> comparison ( ( "!=" | "==" ) comparison )* ;
+comparison -> term ( ( ">" | ">=" | "<" | "<=" ) term )* ;
+term       -> factor ( ( "-" | "+" ) factor )* ;
+factor     -> unary ( ( "/" | "*" ) unary )* ;
+unary      -> ( "!" | "-" ) unary | primary ;
+primary    -> NUMBER | STRING | "true" | "false" | "nil" | "(" expression ")" ;
 ```
diff --git a/main.go b/main.go
index 39c9746..488ffd5 100644
--- a/main.go
+++ b/main.go
@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"os"
 
+	"github.com/ByteHunter/glox/astprinter"
+	"github.com/ByteHunter/glox/parser"
 	scan "github.com/ByteHunter/glox/scanner"
 )
 
@@ -73,7 +75,10 @@ func run(source string) error {
 	}
 
 	scanner := scan.NewScanner(source)
-	scanner.ScanTokens()
+	t, _ := scanner.ScanTokens()
+	parser := parser.NewParser(t)
+	expr := parser.Parse()
+	fmt.Println(astprinter.NewAstPrinter().Print(expr))
 
 	return nil
 }
diff --git a/parser/parser.go b/parser/parser.go
new file mode 100644
index 0000000..0d53e12
--- /dev/null
+++ b/parser/parser.go
@@ -0,0 +1,236 @@
+package parser
+
+import (
+	"fmt"
+
+	"github.com/ByteHunter/glox/expression"
+	"github.com/ByteHunter/glox/reporting"
+	"github.com/ByteHunter/glox/token"
+)
+
+type ParseError struct {
+	token   token.Token
+	message string
+}
+
+func NewParseError(token token.Token, message string) *ParseError {
+	return &ParseError{
+		token:   token,
+		message: message,
+	}
+}
+
+func (p ParseError) Error() string {
+	return fmt.Sprintf("ParseError %s", p.message)
+}
+
+type Parser struct {
+	tokens  []token.Token
+	current int
+}
+
+func NewParser(tokens []token.Token) *Parser {
+	return &Parser{
+		tokens: tokens,
+	}
+}
+
+func (p *Parser) Parse() expression.Expression {
+	if len(p.tokens) == 0 {
+		return nil
+	}
+
+	expr, err := p.Expression()
+	if err != nil {
+		return nil
+	}
+
+	return expr
+}
+
+func (p *Parser) Expression() (expression.Expression, error) {
+	return p.Equality()
+}
+
+func (p *Parser) Equality() (expression.Expression, error) {
+	expr, err := p.Comparison()
+	if err != nil {
+		return expr, err
+	}
+
+	for p.match(token.BANQ_EQUAL, token.EQUAL_EQUAL) {
+		var operator token.Token = p.previous()
+		right, err := p.Comparison()
+		expr = expression.NewBinary(expr, operator, right)
+		if err != nil {
+			return expr, err
+		}
+	}
+
+	return expr, nil
+}
+
+func (p *Parser) Comparison() (expression.Expression, error) {
+	expr, err := p.Term()
+	if err != nil {
+		return expr, err
+	}
+
+	for p.match(token.GREATER, token.GREATER_EQUAL, token.LESS, token.LESS_EQUAL) {
+		var operator token.Token = p.previous()
+		right, err := p.Term()
+		expr = expression.NewBinary(expr, operator, right)
+		if err != nil {
+			return expr, err
+		}
+	}
+
+	return expr, nil
+}
+
+func (p *Parser) Term() (expression.Expression, error) {
+	expr, err := p.Factor()
+	if err != nil {
+		return expr, err
+	}
+
+	for p.match(token.MINUS, token.PLUS) {
+		var operator token.Token = p.previous()
+		right, err := p.Factor()
+		expr = expression.NewBinary(expr, operator, right)
+		if err != nil {
+			return expr, err
+		}
+	}
+
+	return expr, nil
+}
+
+func (p *Parser) Factor() (expression.Expression, error) {
+	expr, err := p.Unary()
+	if err != nil {
+		return expr, err
+	}
+
+	for p.match(token.SLASH, token.STAR) {
+		var operator token.Token = p.previous()
+		right, err := p.Unary()
+		expr = expression.NewBinary(expr, operator, right)
+		if err != nil {
+			return expr, err
+		}
+	}
+
+	return expr, nil
+}
+
+func (p *Parser) Unary() (expression.Expression, error) {
+	if p.match(token.BANG, token.MINUS) {
+		var operator token.Token = p.previous()
+		right, err := p.Unary()
+		return expression.NewUnary(operator, right), err
+	}
+
+	return p.Primary()
+}
+
+func (p *Parser) Primary() (expression.Expression, error) {
+	if p.match(token.FALSE) {
+		return expression.NewLiteral(false), nil
+	}
+	if p.match(token.TRUE) {
+		return expression.NewLiteral(true), nil
+	}
+	if p.match(token.NIL) {
+		return expression.NewLiteral(nil), nil
+	}
+
+	if p.match(token.NUMBER, token.STRING) {
+		return expression.NewLiteral(p.previous().Literal), nil
+	}
+
+	if p.match(token.LEFT_PAREN) {
+		expr, _ := p.Expression()
+		_, err := p.consume(token.RIGHT_PAREN, "Expect ')' after expression.")
+		if err != nil {
+			return expression.NewGrouping(expr), err
+		}
+		return expression.NewGrouping(expr), nil
+	}
+
+	reporting.LoxTokenError(p.peek(), "Expected expression")
+	return nil, NewParseError(p.peek(), "Expected expression.")
+}
+
+func (p *Parser) match(tokenTypes ...token.TokenType) bool {
+	for _, tokenType := range tokenTypes {
+		if p.check(tokenType) {
+			p.advance()
+			return true
+		}
+	}
+
+	return false
+}
+
+func (p *Parser) check(expected token.TokenType) bool {
+	if p.isAtEnd() {
+		return false
+	}
+
+	return p.peek().Type == expected
+}
+
+func (p *Parser) isAtEnd() bool {
+	return p.peek().Type == token.EOF
+}
+
+func (p *Parser) advance() token.Token {
+	if !p.isAtEnd() {
+		p.current++
+	}
+
+	return p.previous()
+}
+
+func (p *Parser) peek() token.Token {
+	return p.tokens[p.current]
+}
+
+func (p *Parser) previous() token.Token {
+	return p.tokens[p.current-1]
+}
+
+func (p *Parser) consume(expected token.TokenType, message string) (token.Token, error) {
+	if p.check(expected) {
+		return p.advance(), nil
+	}
+
+	reporting.LoxTokenError(p.previous(), message)
+	return p.previous(), NewParseError(p.previous(), message)
+}
+
+func (p *Parser) synchronize() {
+	p.advance()
+
+	for !p.isAtEnd() {
+		if p.previous().Type == token.SEMICOLON {
+			return
+		}
+
+		switch p.peek().Type {
+		case
+			token.CLASS,
+			token.FUN,
+			token.VAR,
+			token.FOR,
+			token.IF,
+			token.WHILE,
+			token.PRINT,
+			token.RETURN:
+			return
+		}
+
+		p.advance()
+	}
+}
diff --git a/parser/parser_test.go b/parser/parser_test.go
new file mode 100644
index 0000000..8f35e0b
--- /dev/null
+++ b/parser/parser_test.go
@@ -0,0 +1,295 @@
+package parser
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/ByteHunter/glox/astprinter"
+	"github.com/ByteHunter/glox/expression"
+	"github.com/ByteHunter/glox/token"
+)
+
+func printExpression(expr expression.Expression, _ error) {
+	fmt.Printf("%s", astprinter.NewAstPrinter().Print(expr))
+}
+
+func ExampleNewParser_empty() {
+	parser := NewParser([]token.Token{})
+
+	fmt.Println(parser)
+	// Output:
+	// &{[] 0}
+}
+
+func ExampleNewParser_with_tokens() {
+	parser := NewParser([]token.Token{
+		*token.NewToken(token.LEFT_PAREN, "(", nil, 1),
+		*token.NewToken(token.NUMBER, "42", 42, 1),
+		*token.NewToken(token.RIGHT_PAREN, ")", nil, 1),
+	})
+
+	fmt.Println(parser)
+	// Output:
+	// &{[{0 ( <nil> 1} {21 42 42 1} {1 ) <nil> 1}] 0}
+}
+
+func ExampleParser_Parse_empty_tokens_slice() {
+	parser := NewParser([]token.Token{})
+
+	fmt.Println(parser.Parse())
+	// Output:
+	// <nil>
+}
+
+func ExampleParser_Parse_only_eof() {
+	parser := NewParser([]token.Token{
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+
+	fmt.Println(parser.Parse())
+	// Output:
+	// [line 1] Error at end: Expected expression
+	// <nil>
+}
+
+func ExampleParser_Primary_false() {
+	p := NewParser([]token.Token{
+		*token.NewToken(token.FALSE, "false", false, 1),
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+
+	printExpression(p.Primary())
+	// Output:
+	// false
+}
+
+func ExampleParser_Primary_true() {
+	p := NewParser([]token.Token{
+		*token.NewToken(token.TRUE, "true", true, 1),
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+
+	printExpression(p.Primary())
+	// Output:
+	// true
+}
+
+func ExampleParser_Primary_nil() {
+	p := NewParser([]token.Token{
+		*token.NewToken(token.NIL, "nil", nil, 1),
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+
+	printExpression(p.Primary())
+	// Output:
+	// nil
+}
+
+func ExampleParser_Primary_number() {
+	p := NewParser([]token.Token{
+		*token.NewToken(token.NUMBER, "42", 42, 1),
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+
+	printExpression(p.Primary())
+	// Output:
+	// 42
+}
+
+func ExampleParser_Primary_string() {
+	p := NewParser([]token.Token{
+		*token.NewToken(token.STRING, "test", "test", 1),
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+
+	printExpression(p.Primary())
+	// Output:
+	// test
+}
+
+func ExampleParser_Primary_parenthesis() {
+	p := NewParser([]token.Token{
+		*token.NewToken(token.LEFT_PAREN, "(", nil, 1),
+		*token.NewToken(token.NIL, "nil", nil, 1),
+		*token.NewToken(token.RIGHT_PAREN, ")", nil, 1),
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+
+	printExpression(p.Primary())
+	// Output:
+	// (group nil)
+}
+
+func ExampleParser_Primary_parenthesis_true() {
+	p := NewParser([]token.Token{
+		*token.NewToken(token.LEFT_PAREN, "(", nil, 1),
+		*token.NewToken(token.TRUE, "true", true, 1),
+		*token.NewToken(token.RIGHT_PAREN, ")", nil, 1),
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+
+	printExpression(p.Primary())
+	// Output:
+	// (group true)
+}
+
+func ExampleParser_Primary_parenthesize_with_grouping() {
+	p := NewParser([]token.Token{
+		*token.NewToken(token.LEFT_PAREN, "(", nil, 1),
+		*token.NewToken(token.NUMBER, "42", 42, 1),
+		*token.NewToken(token.EQUAL_EQUAL, "==", nil, 1),
+		*token.NewToken(token.NUMBER, "42", 42, 1),
+		*token.NewToken(token.RIGHT_PAREN, ")", nil, 1),
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+
+	printExpression(p.Primary())
+	// Output:
+	// (group (== 42 42))
+}
+
+func ExampleParser_Primary_parenthesize_with_error() {
+	p := NewParser([]token.Token{
+		*token.NewToken(token.LEFT_PAREN, "(", nil, 1),
+		*token.NewToken(token.NUMBER, "42", 42, 1),
+		*token.NewToken(token.EQUAL_EQUAL, "==", nil, 1),
+		*token.NewToken(token.NUMBER, "41", 41, 1),
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+
+	printExpression(p.Primary())
+	// Output:
+	// [line 1] Error at '41': Expect ')' after expression.
+	// (group (== 42 41))
+}
+
+func ExampleParser_Comparison() {
+	var examples = []struct {
+		tokens []token.Token
+	}{
+		{tokens: []token.Token{
+			*token.NewToken(token.NUMBER, "42", 42, 1),
+			*token.NewToken(token.GREATER, ">", nil, 1),
+			*token.NewToken(token.NUMBER, "42", 42, 1),
+			*token.NewToken(token.EOF, "", nil, 1),
+		}},
+		{tokens: []token.Token{
+			*token.NewToken(token.NUMBER, "42", 42, 1),
+			*token.NewToken(token.GREATER_EQUAL, ">=", nil, 1),
+			*token.NewToken(token.NUMBER, "42", 42, 1),
+			*token.NewToken(token.EOF, "", nil, 1),
+		}},
+		{tokens: []token.Token{
+			*token.NewToken(token.NUMBER, "42", 42, 1),
+			*token.NewToken(token.LESS, "<", nil, 1),
+			*token.NewToken(token.NUMBER, "42", 42, 1),
+			*token.NewToken(token.EOF, "", nil, 1),
+		}},
+		{tokens: []token.Token{
+			*token.NewToken(token.NUMBER, "42", 42, 1),
+			*token.NewToken(token.LESS_EQUAL, "<=", nil, 1),
+			*token.NewToken(token.NUMBER, "42", 42, 1),
+			*token.NewToken(token.EOF, "", nil, 1),
+		}},
+	}
+
+	for _,e := range examples {
+		p := NewParser(e.tokens)
+		printExpression(p.Comparison())
+		fmt.Println()
+	}
+	// Output:
+	// (> 42 42)
+	// (>= 42 42)
+	// (< 42 42)
+	// (<= 42 42)
+}
+
+func ExampleParser_Term_minus() {
+	p := NewParser([]token.Token{
+		*token.NewToken(token.NUMBER, "42", 42, 1),
+		*token.NewToken(token.MINUS, "-", nil, 1),
+		*token.NewToken(token.NUMBER, "42", 42, 1),
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+
+	printExpression(p.Term())
+	// Output:
+	// (- 42 42)
+}
+
+func ExampleParser_Term_plus() {
+	p := NewParser([]token.Token{
+		*token.NewToken(token.NUMBER, "42", 42, 1),
+		*token.NewToken(token.PLUS, "+", nil, 1),
+		*token.NewToken(token.NUMBER, "42", 42, 1),
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+
+	printExpression(p.Term())
+	// Output:
+	// (+ 42 42)
+}
+
+func ExampleParser_Factor_slash() {
+	p := NewParser([]token.Token{
+		*token.NewToken(token.NUMBER, "42", 42, 1),
+		*token.NewToken(token.SLASH, "/", nil, 1),
+		*token.NewToken(token.NUMBER, "42", 42, 1),
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+
+	printExpression(p.Factor())
+	// Output:
+	// (/ 42 42)
+}
+
+func ExampleParser_Factor_star() {
+	p := NewParser([]token.Token{
+		*token.NewToken(token.NUMBER, "21", 21, 1),
+		*token.NewToken(token.STAR, "*", nil, 1),
+		*token.NewToken(token.NUMBER, "2", 2, 1),
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+
+	printExpression(p.Factor())
+	// Output:
+	// (* 21 2)
+}
+
+func ExampleParser_Unary_bang() {
+	p := NewParser([]token.Token{
+		*token.NewToken(token.BANG, "!", nil, 1),
+		*token.NewToken(token.TRUE, "true", true, 1),
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+
+	printExpression(p.Unary())
+	// Output:
+	// (! true)
+}
+
+func ExampleParser_Unary_minus() {
+	p := NewParser([]token.Token{
+		*token.NewToken(token.MINUS, "-", nil, 1),
+		*token.NewToken(token.NUMBER, "42", 42, 1),
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+
+	printExpression(p.Unary())
+	// Output:
+	// (- 42)
+}
+
+func TestPeek(t *testing.T) {
+	p := NewParser([]token.Token{
+		*token.NewToken(token.MINUS, "-", nil, 1),
+		*token.NewToken(token.EOF, "", nil, 1),
+	})
+	tok := p.peek()
+	actual := tok.Type
+	expected := token.MINUS
+	if actual != expected {
+		t.Errorf("Expected to be '%v' but got '%v'", expected, actual)
+	}
+}
diff --git a/reporting/report.go b/reporting/report.go
index 7ff086a..4c8b437 100644
--- a/reporting/report.go
+++ b/reporting/report.go
@@ -3,8 +3,19 @@ package reporting
 import (
 	"fmt"
 	"os"
+
+	"github.com/ByteHunter/glox/token"
 )
 
+func LoxTokenError(t token.Token, message string) {
+	if t.Type == token.EOF {
+		LoxReport(t.Line, "at end", message)
+		return
+	}
+
+	LoxReport(t.Line, "at '" + t.Lexeme + "'", message)
+}
+
 func LoxError(line int, message string) {
 	LoxReport(line, "", message)
 }
diff --git a/scanner/scanner.go b/scanner/scanner.go
index cc11131..b61c47e 100644
--- a/scanner/scanner.go
+++ b/scanner/scanner.go
@@ -42,6 +42,10 @@ func NewScanner(source string) *Scanner {
 	}
 }
 
+func (s *Scanner) GetTokens() []token.Token {
+	return s.tokens
+}
+
 func (s *Scanner) ScanTokens() ([]token.Token, error) {
 	for !s.isAtEnd() {
 		s.start = s.current