diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..dda858bed168788356c1b4bc4ea79ba9d59d0c6c
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,8 @@
+build:
+	go get
+run:
+	go run . $(directory) $(filter)
+json: 
+	go run . -j $(directory)
+test:
+	go test
diff --git a/README.md b/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b52dafda53907268529a9e58a187cfa93b1f27b0
--- /dev/null
+++ b/README.md
@@ -0,0 +1,17 @@
+# Linux Tree CLI
+## Usage
+```
+$ make build
+$ make run directory=tests filter=2021-04-22 #Runs the command using filter and prints in terminal.
+$ make json directory=tests #Runs the CLI using -j to output to JSON.
+```
+
+## Testing
+```
+$ make test
+```
+## Discussion
+The application runs in 2 different modes: Terminal and JSON. Terminal outputs the tree structure. JSON outputs the structure to a JSON file.
+
+## Dependencies
+- You'd need to have GOPATH exported.  GOBIN for MACOS for go get command
\ No newline at end of file
diff --git a/handler.go b/handler.go
index d45df5201d609c8e256300e665b7e999b658bd9c..bd0476f8a79d8ff830df50f57fb616801c31cf5b 100644
--- a/handler.go
+++ b/handler.go
@@ -5,6 +5,7 @@ import (
 	"os"
 	"path"
 	"sort"
+	"time"
 )
 
 //Counter strucutre need for presenting final results
@@ -41,24 +42,26 @@ func opendirectory(base string) []string {
 //Recursive function called on each directory. The function appends each path found
 //to a subpath called next, checks if each path is directory or file and appends to counter.
 //A print statment is based on the index of the path in the current directory.
-func tree(prefix string, counter *Counter, base string) {
+func tree(prefix string, counter *Counter, base string, t time.Time) {
 	dirnames := opendirectory(base)
 
 	for index, name := range dirnames {
-		//Exclude hiddenn folders
 		if name[0] == '.' {
 			continue
 		}
 
 		next := path.Join(base, name)
-
+		stat, _ := os.Stat(next)
+		if stat.ModTime().Before(t) {
+			continue
+		}
 		counter.isDir(next)
 		if index < len(dirnames)-1 {
 			fmt.Println(prefix+"├──", name)
-			tree(prefix+"│   ", counter, next)
+			tree(prefix+"│   ", counter, next, t)
 		} else {
 			fmt.Println(prefix+"└──", name)
-			tree(prefix+"    ", counter, next)
+			tree(prefix+"    ", counter, next, t)
 		}
 	}
 }
diff --git a/handler_test.go b/handler_test.go
index 490c96245878086a80178ff3ca1ca41bd252c6c7..9bf74c3729aa328a3485a778081340f9466c5f4d 100644
--- a/handler_test.go
+++ b/handler_test.go
@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"testing"
+	"time"
 )
 
 /*
@@ -63,7 +64,36 @@ Test if the tree function works by observing the counter.
 */
 func TestTree(t *testing.T) {
 	counter := new(Counter)
-	tree("", counter, ".")
+	filter := "2021-04-02"
+	format = "2006-01-02"
+
+	time, err := time.Parse(format, filter)
+	if err != nil {
+		ErrorLogger.Print("Format:", format)
+		ErrorLogger.Print(err)
+		return
+	}
+	tree("", counter, ".", time)
 	assertEqual(t, counter.directories, 3, "")
-	assertEqual(t, counter.files, 12, "")
+	assertEqual(t, counter.files, 14, "")
+}
+
+/*
+Test if the filter works on tree() by observing the counter.
+*/
+func TestFilter(t *testing.T) {
+	counter := new(Counter)
+	filter := "2021-04-23"
+	format = "2006-01-02"
+
+	time, err := time.Parse(format, filter)
+	if err != nil {
+		ErrorLogger.Print("Format:", format)
+		ErrorLogger.Print(err)
+		return
+	}
+
+	tree("", counter, ".", time)
+	assertEqual(t, counter.directories, 0, "")
+	assertEqual(t, counter.files, 9, "")
 }
diff --git a/jsonhandler_test.go b/jsonhandler_test.go
index ff3f20561094aa9fd3ee5ba8d81670da3eca5b4c..4fab7a6cf49a3ee5675187f9529ef899bafeade1 100644
--- a/jsonhandler_test.go
+++ b/jsonhandler_test.go
@@ -26,7 +26,7 @@ func TestJsonTree(t *testing.T) {
 	assertEqual(t, folder.Name, ".", "")
 
 	assertEqual(t, len(folder.Folders), 1, "")
-	assertEqual(t, len(folder.Files), 8, "")
+	assertEqual(t, len(folder.Files), 10, "")
 
 	assertEqual(t, len(folder.Folders["tests"].Folders), 2, "")
 	assertEqual(t, len(folder.Folders["tests"].Files), 3, "")
diff --git a/main.go b/main.go
index d95b8d1b224cdb7423a79a70da48749b6c07cebc..6f1ae25541e6e8e7163e30a3495025f6ac2f8b98 100644
--- a/main.go
+++ b/main.go
@@ -7,6 +7,7 @@ import (
 	"io/ioutil"
 	"log"
 	"os"
+	"time"
 )
 
 //File structure representation
@@ -30,6 +31,8 @@ func newFolder(name string) *Folder {
 var (
 	ErrorLogger *log.Logger
 	directory   string
+	filter      string
+	format      string
 )
 
 func main() {
@@ -41,7 +44,7 @@ func main() {
 		//Start JSON routine.
 		directory = "."
 		if len(os.Args) > 2 {
-			directory = os.Args[1]
+			directory = os.Args[2]
 		}
 		output := newFolder(directory)
 		counter := new(Counter)
@@ -53,18 +56,25 @@ func main() {
 		}
 		_ = ioutil.WriteFile("output.json", jsonString, 0644)
 		fmt.Printf("%d directories, %d files\n", counter.directories, counter.files)
-
 	} else {
-
 		directory = "."
-		if len(os.Args) > 1 {
+		format = "2006-01-02"
+
+		if len(os.Args) > 2 {
 			directory = os.Args[1]
+			filter = os.Args[2]
+		}
+
+		t, err := time.Parse(format, filter)
+		if err != nil {
+			ErrorLogger.Print("Format:", format)
+			ErrorLogger.Print(err)
+			return
 		}
 		counter := new(Counter)
 		//Start regular recursive tree.
-		tree("", counter, directory)
+		tree("", counter, directory, t)
 		fmt.Printf("%d directories, %d files\n", counter.directories, counter.files)
-
 	}
 
 }
diff --git a/output.json b/output.json
index 3a4f32ae5926ba7ac2051236f4d7b2eefad56edc..258268c1f90fcb6176d033864f17f9979c1f8b59 100644
--- a/output.json
+++ b/output.json
@@ -1,61 +1,30 @@
 {
-    "Name": ".",
+    "Name": "tests",
     "Files": [
         {
-            "Name": "go.mod"
+            "Name": "testfile"
         },
         {
-            "Name": "handler.go"
+            "Name": "testfile1"
         },
         {
-            "Name": "handler_test.go"
-        },
-        {
-            "Name": "jsonhandler.go"
-        },
-        {
-            "Name": "jsonhandler_test.go"
-        },
-        {
-            "Name": "main.go"
-        },
-        {
-            "Name": "output.json"
-        },
-        {
-            "Name": "tree-linux"
+            "Name": "testfile2"
         }
     ],
     "Folders": {
-        "tests": {
-            "Name": "tests",
+        "testFolder1": {
+            "Name": "testFolder1",
             "Files": [
                 {
-                    "Name": "testfile"
-                },
-                {
-                    "Name": "testfile1"
-                },
-                {
-                    "Name": "testfile2"
+                    "Name": "test123"
                 }
             ],
-            "Folders": {
-                "testFolder1": {
-                    "Name": "testFolder1",
-                    "Files": [
-                        {
-                            "Name": "test123"
-                        }
-                    ],
-                    "Folders": {}
-                },
-                "testFolder2": {
-                    "Name": "testFolder2",
-                    "Files": [],
-                    "Folders": {}
-                }
-            }
+            "Folders": {}
+        },
+        "testFolder2": {
+            "Name": "testFolder2",
+            "Files": [],
+            "Folders": {}
         }
     }
 }
\ No newline at end of file
diff --git a/tree-linux b/tree-linux
index 73457ffc8dc31d3f68bcf3c6d70cadcc76fe997a..38451039caf9da4c499a117e46612f5e9545ced6 100755
Binary files a/tree-linux and b/tree-linux differ