diff --git a/.github/workflows/pull-request.yml b/.github/workflows/pull-request.yml
index ad8904d..4e40634 100644
--- a/.github/workflows/pull-request.yml
+++ b/.github/workflows/pull-request.yml
@@ -10,5 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v4
+        with:
+          go-version: '1.21' 
       - run: go test ./...
\ No newline at end of file
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 0000000..e63a647
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,15 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Launch Package",
+      "type": "go",
+      "request": "launch",
+      "mode": "auto",
+      "program": "${fileDirname}/../main.go"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index 47352c3..deb862f 100644
--- a/README.md
+++ b/README.md
@@ -33,7 +33,8 @@ Head to the [releases](https://github.com/shikaan/shmux/releases) page and downl
 
 ### Usage
 
-A common use case for `shmux` is running simple scripts in a standardized and language-agnostic way. These scripts are to be found in the _configuration_ file, also known as _shmuxfile_.
+A common use case for `shmux` is running simple scripts in a standardized and *language-agnostic* way (see [Other Languages](#other-languages)). 
+These scripts are to be found in the _configuration_ file, also known as _shmuxfile_.
 
 For example, a `shmuxfile.sh` for a Go project might look like: 
 
@@ -47,6 +48,26 @@ build:
 
 greet:
   echo "Hello $1, my old friend"
+
+echo:
+  echo "$@"  
+```
+
+Last two recipes in JavaScript that could looke like:
+
+```js
+// shmuxfile.js
+
+greet:
+  #!/usr/bin/env node
+
+  const friend = "$1"
+  console.log(`Hello ${friend}, my old friend`)
+
+echo:
+  #!/usr/bin/env node
+
+  console.log(`$@`)
 ```
 
 Which can then be utilized as
@@ -63,29 +84,20 @@ $ shmux greet -- "darkness"
 # => Hello darkness, my old friend
 ```
 
-### More Usage
-
-What if we wanted to write the scripts in JavaScript? Well, you then just need a `shmuxfile.js` with a [shebang](https://en.wikipedia.org/wiki/Shebang_(Unix)) defining the interpreter to be used and you're set.
+Recipes can have dependencies:
 
-```js
-greet:
-  #!/usr/bin/env node
+```sh
+test:
+  go test ./...
 
-  const friend = "$1"
-  const author = "$@"
-  const message = friend === "darkness" 
-    ? "Hello darkness, my old friend"
-    : `Hello ${friend}, from ${author}`
-  
-  console.log(message)
+build: test
+  go build
 ```
 
-and run it like
-
 ```bash
-$ shmux greet -- "Manuel"
-# => Hello Manuel, from greet
+$ shmux build
 ```
+Running `shmux build` will execute `test` before `build`.
 
 ## 📄 Documentation
 
@@ -93,9 +105,27 @@ More detailed documentation can be found [here](./docs/docs.md).
 
 ## ❓ FAQs
 
+* _Isn't this similar to a Makefile?_
+
+  `shmux` draws inspiration from `make` but stands out as a script runner, not a build system. This distinction eliminates common build system constraintsl ike the presumption that outputs are files. Moreover, it offers:
+
+  * Command line arguments support.
+  * Compatibility with various scripting languages.
+  * Pre-runtime issue detection.
+  * Execution capability from any subdirectory.
+  * Native support on MacOS and Windows, no extra dependencies required.
+
 * _Which languages are supported?_
   
-  `shmux` makes no assumptions about the underlying scripting language to utilize, because it always requires you to specify the shell. Any language whose syntax is compatible with shmuxfiles' requirements is supported.
+  `shmux` makes no assumptions about the underlying scripting language to utilize, because it always requires you to specify the shell (either via flag or shebang).
+
+  To this day, `shmux` is known to be working with:
+
+  * sh and derviatives (bash, dash, fish, zsh...)
+  * JavaScript / TypeScript (with ts-node)
+  * Perl
+  * Python
+  * Ruby
 
 * _Does it have editor support?_
 
diff --git a/docs/docs.md b/docs/docs.md
index 5d9ec7e..18adf7d 100644
--- a/docs/docs.md
+++ b/docs/docs.md
@@ -11,6 +11,7 @@
 The scripts run by `shmux` live in files called _shmuxfiles_. These configuration files follow the following pattern:
 
 * lines starting with a non-white space and ending with a `:` will be interpreted as a _script definition_
+    * if the colon is followed by space-separated words, they are treated as _script dependencies_ (i.e., scripts running before the invoked one)
 * non-empty lines prepended with whitespaces are considered _script lines_ 
 * the other lines are ignored
 
@@ -20,6 +21,13 @@ In a nutshell, `shmux` is not opinionated about which languages the script are w
 
 For example, a shmuxfile with bash scripts can be called `shmuxfile.bash`. If it was with JavaScript scripts, it can be called `shmuxfile.js`. This will yield pretty decent syntax highlighting.
 
+At this point, `shmux` is known to be working with:
+* sh and derviatives (bash, dash, fish, zsh...)
+* JavaScript / TypeScript (with ts-node)
+* Perl
+* Python
+* Ruby
+
 If you need more sophisticated tooling, please [open an Issue](https://github.com/shikaan/shmux/issues).
 
 [^1]: Namely, permits intendations and presence of the `script:` labels.
diff --git a/main.go b/main.go
index 6f17511..b6b9bf3 100644
--- a/main.go
+++ b/main.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"io"
 	"os"
 
 	"github.com/shikaan/shmux/pkg/arguments"
@@ -9,12 +10,14 @@ import (
 	"github.com/shikaan/shmux/pkg/scripts"
 )
 
+const MAX_FILE_SIZE = 1<<20; // 1MB
+
 func main() {
 	shell, config, scriptName, args, err := arguments.Parse()
-	exceptions.HandleException(err)
+	exceptions.HandleException(err, 1)
 
 	file, err := os.Open(config)
-	exceptions.HandleException(err)
+	exceptions.HandleException(err, 1)
 	defer file.Close()
 
 	if scriptName == arguments.HELP_SCRIPT {
@@ -22,9 +25,13 @@ func main() {
 		return
 	}
 
-	script, err := scripts.ReadScript(scriptName, shell, file)
-	exceptions.HandleException(err)
+	limitedReader := io.LimitReader(file, MAX_FILE_SIZE)
+	content, err := io.ReadAll(limitedReader)
+	exceptions.HandleException(err, 1)
+
+	script, err := scripts.ReadScript(scriptName, shell, content, 0)
+	exceptions.HandleException(err, 1)
 
-	err = scripts.RunScript(script, args)
-	exceptions.HandleScriptError(scriptName, err)
+	status, err := scripts.RunScript(script, args)
+	exceptions.HandleException(err, status)
 }
diff --git a/pkg/exceptions/exceptions.go b/pkg/exceptions/exceptions.go
index 2191382..d9befbb 100644
--- a/pkg/exceptions/exceptions.go
+++ b/pkg/exceptions/exceptions.go
@@ -3,24 +3,11 @@ package exceptions
 import (
 	"fmt"
 	"os"
-	"os/exec"
 )
 
-func HandleException(e error) {
+func HandleException(e error, status int) {
 	if e != nil {
 		os.Stderr.WriteString(fmt.Sprintf("shmux: %s\n", e.Error()))
-		os.Exit(1)
-	}
-}
-
-func HandleScriptError(scriptName string, e error) {
-	if e != nil {
-		status := 1
-		if exitError, ok := e.(*exec.ExitError); ok {
-			status = exitError.ExitCode()
-		}
-
-		os.Stderr.WriteString(fmt.Sprintf("shmux: script \"%s\" exited with code %d\n", scriptName, status))
 		os.Exit(status)
 	}
 }
diff --git a/pkg/scripts/help.go b/pkg/scripts/help.go
new file mode 100644
index 0000000..25afae3
--- /dev/null
+++ b/pkg/scripts/help.go
@@ -0,0 +1,28 @@
+package scripts
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"strings"
+)
+
+func MakeHelp(file io.Reader) string {
+	availableScripts := []string{}
+	scanner := bufio.NewScanner(file)
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		isScriptLine, match, _ := readScript(line)
+
+		if isScriptLine {
+			availableScripts = append(availableScripts, match)
+		}
+	}
+
+	return fmt.Sprintf(`usage: shmux [-config <path>] [-shell <path>] <script> -- [arguments ...]
+
+Available scripts: %s
+Run 'shmux -h' for details.
+`, strings.Join(availableScripts, ", "))
+}
\ No newline at end of file
diff --git a/pkg/scripts/help_test.go b/pkg/scripts/help_test.go
new file mode 100644
index 0000000..40df269
--- /dev/null
+++ b/pkg/scripts/help_test.go
@@ -0,0 +1,27 @@
+package scripts
+
+import (
+	"io"
+	"strings"
+	"testing"
+)
+
+func TestMakeHelp(t *testing.T) {
+	type args struct {
+		file io.Reader
+	}
+	tests := []struct {
+		name     string
+		args     args
+		includes string
+	}{
+		{"returns the correct text", args{strings.NewReader("script:\n\tscript1\n\nanother:\n\tscript2")}, "script1, script2"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := MakeHelp(tt.args.file); strings.Contains(got, tt.includes) {
+				t.Errorf("MakeHelp() = %v, does not include %v", got, tt.includes)
+			}
+		})
+	}
+}
\ No newline at end of file
diff --git a/pkg/scripts/scripts.go b/pkg/scripts/parse.go
similarity index 54%
rename from pkg/scripts/scripts.go
rename to pkg/scripts/parse.go
index ff3e2f8..2b3ab2b 100644
--- a/pkg/scripts/scripts.go
+++ b/pkg/scripts/parse.go
@@ -1,21 +1,14 @@
 package scripts
 
 import (
-	"bufio"
 	"fmt"
-	"io"
-	"os"
-	"os/exec"
-	"path/filepath"
 	"regexp"
+	"slices"
 	"strings"
-	"time"
 )
 
-var TEMP_SCRIPT_FILE = ""
-func init() {
-	TEMP_SCRIPT_FILE = fmt.Sprintf("shmux_%d", time.Now().UnixNano())
-}
+// To prevent infinite recursion, we limit the nesting level of script dependencies
+const MAXIMUM_NESTING_LEVEL = 2
 
 // A script is a slice of lines representing each a LOC
 type Script struct {
@@ -23,41 +16,21 @@ type Script struct {
 	Lines       []string
 	Interpreter string
 	Options     []string
-}
-
-// Creates an exec.Cmd that executes a script in a given shell
-// Arguments are positional arguments ($1, $2...) which can be used in the script as replacement
-func RunScript(script *Script, arguments []string) (err error) {
-	path := GetTempScriptPath()
-
-	file, err := os.Create(path)
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-	defer os.RemoveAll(path)
-
-	fileContent := strings.Join(script.Lines, "\n")
-	file.WriteString(replaceArguments(fileContent, arguments, script.Name))
-
-	cmd := exec.Command(script.Interpreter, append(script.Options, path)...)
-	cmd.Stderr = os.Stderr
-	cmd.Stdout = os.Stdout
-	return cmd.Run()
+	Dependencies []Script
 }
 
 // Parses the provided file, retuning the Script whose name is the provided one
-func ReadScript(scriptName string, shell string, file io.Reader) (*Script, error) {
-	script := &Script{Name: scriptName, Interpreter: shell}
-	availableScripts := []string{}
-	scanner := bufio.NewScanner(file)
+func ReadScript(scriptName string, shell string, fileContent []byte, currentNestingLevel uint) (script *Script, err error) {
+	script = &Script{Name: scriptName, Interpreter: shell, Dependencies: []Script{}}
+	lines := strings.Split(string(fileContent), "\n")
 
+	availableScripts := []string{}
 	shouldCollect := false
 	firstLine := true
 	tabLength := 0
-	for scanner.Scan() {
-		line := scanner.Text()
-		isScriptLine, match := readScript(line)
+
+	for _, line := range lines {
+		isScriptLine, match, dependencies := readScript(line)
 
 		if isScriptLine {
 			availableScripts = append(availableScripts, match)
@@ -66,6 +39,12 @@ func ReadScript(scriptName string, shell string, file io.Reader) (*Script, error
 			// This allows collecting lines from next line on.
 			if !shouldCollect && match == scriptName {
 				shouldCollect = true
+
+				script.Dependencies, err = getDependencyScripts(dependencies, match, currentNestingLevel, shell, fileContent)
+				if err != nil { 
+					return nil, err
+				}
+
 				continue
 			}
 
@@ -109,56 +88,47 @@ func ReadScript(scriptName string, shell string, file io.Reader) (*Script, error
 		return nil, fmt.Errorf("could not find \"%s\". Available scripts: %s", scriptName, strings.Join(availableScripts, ", "))
 	}
 
-	return script, nil
+	return
 }
 
-func MakeHelp(file io.Reader) string {
-	availableScripts := []string{}
-	scanner := bufio.NewScanner(file)
-
-	for scanner.Scan() {
-		line := scanner.Text()
-		isScriptLine, match := readScript(line)
+func getDependencyScripts(dependencies []string, match string, currentNestingLevel uint, shell string, fileContent []byte) (deps []Script, err error) {
+	for _, dependency := range dependencies {
 
-		if isScriptLine {
-			availableScripts = append(availableScripts, match)
+		if dependency == match {
+			return nil, fmt.Errorf("script \"%s\" has a circular dependency on itself", match)
 		}
-	}
 
-	return fmt.Sprintf(`usage: shmux [-config <path>] [-shell <path>] <script> -- [arguments ...]
-
-Available scripts: %s
-Run 'shmux -h' for details.
-`, strings.Join(availableScripts, ", "))
-}
+		if currentNestingLevel >= MAXIMUM_NESTING_LEVEL {
+			return nil, fmt.Errorf("script \"%s\" has a dependency on \"%s\" which exceeds the maximum nesting level of %d", match, dependency, MAXIMUM_NESTING_LEVEL)
+		}
 
-// Replaces positional arguments in the arguments slice ($1..$9) and
-// $@ with script name in 'content
-func replaceArguments(content string, arguments []string, scriptName string) string {
-	result := content
+		var dependencyScript *Script; 
+		dependencyScript, err = ReadScript(dependency, shell, fileContent, currentNestingLevel+1)
+		if err != nil { return }
 
-	for i, arg := range cap(arguments, 9) {
-		placeholder := fmt.Sprintf("$%d", i+1)
-		result = strings.ReplaceAll(result, placeholder, arg)
+		deps = append(deps, *dependencyScript)
 	}
 
-	return strings.ReplaceAll(result, "$@", scriptName)
+	return
 }
 
-// Returns the path of the temporary script we use for execution
-func GetTempScriptPath() string {
-	return filepath.Join(os.TempDir(), TEMP_SCRIPT_FILE)
-}
-
-const SCRIPT_IDENTIFIER_REGEXP = "^(\\S+):(.*)"
+const SCRIPT_IDENTIFIER_REGEXP = `^(\S+):\s*(.*)$`
 
 // Tries identifying lines including scripts, returning if it's a match and what that is
-func readScript(line string) (isScriptLine bool, match string) {
+func readScript(line string) (isScriptLine bool, script string, dependencies []string) {
 	r, _ := regexp.Compile(SCRIPT_IDENTIFIER_REGEXP)
 	submatch := r.FindStringSubmatch(line)
-	scriptName := get(submatch, 1)
+	
+	if submatch == nil { return }
+
+	script = submatch[1]
+	isScriptLine = script != "" 
+	
+	if isScriptLine {
+		dependencies = slices.Compact(strings.Fields(submatch[2]))
+	}
 
-	return scriptName != "", scriptName
+	return
 }
 
 const SHEBANG_REGEXP = "#!\\s?(\\S+)\\s?(.*)"
diff --git a/pkg/scripts/parse_test.go b/pkg/scripts/parse_test.go
new file mode 100644
index 0000000..53ebee9
--- /dev/null
+++ b/pkg/scripts/parse_test.go
@@ -0,0 +1,204 @@
+package scripts
+
+import (
+	"reflect"
+	"slices"
+	"testing"
+)
+
+func Test_readScript(t *testing.T) {
+	type args struct {
+		line string
+	}
+	tests := []struct {
+		name             string
+		args             args
+		wantIsScriptLine bool
+		wantMatch        string
+		wantDeps				 []string
+	}{
+		{"returns true with correct script", args{"start:"}, true, "start", nil},
+		{"interprets further strings as dependencies", args{"start: dunno"}, true, "start", []string{"dunno"}},
+		{"returns all the dependencies", args{"start: dep1 dep2 dep3"}, true, "start", []string{"dep1", "dep2", "dep3"}},
+		{"dedupes dependencies", args{"start: dep1 dep1 dep1"}, true, "start", []string{"dep1"}},
+		{"handles whitespaces", args{"start:dep1     dep2    dep3       "}, true, "start", []string{"dep1", "dep2", "dep3"}},
+		{"returns false with blank script", args{"    start:"}, false, "", nil},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotIsScriptLine, gotMatch, gotDeps := readScript(tt.args.line)
+			if gotIsScriptLine != tt.wantIsScriptLine {
+				t.Errorf("readScript() gotIsScriptLine = %v, want %v", gotIsScriptLine, tt.wantIsScriptLine)
+			}
+			if gotMatch != tt.wantMatch {
+				t.Errorf("readScript() gotMatch = %v, want %v", gotMatch, tt.wantMatch)
+			}
+			if !slices.Equal(gotDeps, tt.wantDeps) {
+				t.Errorf("readScript() gotDeps = %v, want %v", gotDeps, tt.wantDeps)
+			}
+		})
+	}
+}
+
+func TestReadScript(t *testing.T) {
+	type args struct {
+		scriptName string
+		shell      string
+		file       []byte
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *Script
+		wantErr bool
+	}{
+		{
+			"one script, with non-default interpreter",
+			args{"script", "/bin/interpreter", []byte("script:\n\techo $HOME")},
+			&Script{Name: "script", Lines: []string{"echo $HOME"}, Interpreter: "/bin/interpreter"},
+			false,
+		},
+		{
+			"one script, one line",
+			args{"script", "/bin/bash", []byte("script:\n\techo $HOME")},
+			&Script{Name: "script", Lines: []string{"echo $HOME"}, Interpreter: "/bin/bash"},
+			false,
+		},
+		{
+			"one script, many lines",
+			args{"script", "/bin/bash", []byte("script:\n\tif true:\n\t\tprint('test2')")},
+			&Script{Name: "script", Lines: []string{"if true:", "\tprint('test2')"}, Interpreter: "/bin/bash"},
+			false,
+		},
+		{
+			"one script, many lines with spaces",
+			args{"script", "/bin/bash", []byte("script:\n   if true:\n     print('test2')")},
+			&Script{Name: "script", Lines: []string{"if true:", "  print('test2')"}, Interpreter: "/bin/bash"},
+			false,
+		},
+		{
+			"two scripts, retuns latter",
+			args{"another", "/bin/bash", []byte("script:\n\tscript1\n\nanother:\n\tscript2")},
+			&Script{Name: "another", Lines: []string{"script2"}, Interpreter: "/bin/bash"},
+			false,
+		},
+		{
+			"two scripts, finds nothing",
+			args{"unknown", "/bin/bash", []byte("script:\n\tscript1\n\nanother:\n\tscript2")},
+			nil,
+			true,
+		},
+		{
+			"one script, with simple shebang",
+			args{"script", "/bin/bash", []byte("script:\n\t#!/bin/lol\n\tline")},
+			&Script{Name: "script", Lines: []string{"line"}, Interpreter: "/bin/lol"},
+			false,
+		},
+		{
+			"one script, with shebang with options",
+			args{"script", "/bin/bash", []byte("script:\n\t#!/bin/lol --lol=1 --two\n\tline")},
+			&Script{Name: "script", Lines: []string{"line"}, Interpreter: "/bin/lol", Options: []string{"--lol=1", "--two"}},
+			false,
+		},
+		{
+			"with one dependency",
+			args{"top_level", "/bin/bash", []byte("top_level: dep1\n\tline\ndep1:\n\tline2")},
+			&Script{Name: "top_level", Lines: []string{"line"}, Interpreter: "/bin/bash", Dependencies: []Script{{Name: "dep1", Lines: []string{"line2"}, Interpreter: "/bin/bash"}}},
+			false,
+		},
+		{
+			"with more dependencies",
+			args{"top_level", "/bin/bash", []byte("top_level: dep1 dep2\n\tline0\ndep1:\n\tline1\ndep2:\n\tline2")},
+			&Script{Name: "top_level", Lines: []string{"line0"}, Interpreter: "/bin/bash", Dependencies: []Script{
+				{Name: "dep1", Lines: []string{"line1"}, Interpreter: "/bin/bash"},
+				{Name: "dep2", Lines: []string{"line2"}, Interpreter: "/bin/bash"},
+			}},
+			false,
+		},
+		{
+			"with nesting",
+			args{"top_level", "/bin/bash", []byte("top_level: dep1\n\tline0\ndep1: dep2\n\tline1\ndep2:\n\tline2")},
+			&Script{
+				Name: "top_level",
+				Lines: []string{"line0"},
+				Interpreter: "/bin/bash",
+				Dependencies: []Script{
+					{
+						Name: "dep1",
+						Lines: []string{"line1"},
+						Interpreter: "/bin/bash",
+						Dependencies: []Script{
+							{
+								Name: "dep2",
+								Lines: []string{"line2"},
+								Interpreter: "/bin/bash",
+							},
+						},
+					},
+				},
+			},
+			false,
+		},
+		{
+			"with circular dependency",
+			args{"top_level", "/bin/bash", []byte("top_level: top_level\n\tline")},
+			nil,
+			true,
+		},
+		{
+			"with too nested dependencies",
+			args{"top_level", "/bin/bash", []byte("top_level: dep1\n\tline\n\ndep1: dep2\n\tline2\n\ndep2: dep3\n\tline3\n\ndep3: top_level\n\tline4")},
+			nil,
+			true,
+		},
+	};
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := ReadScript(tt.args.scriptName, tt.args.shell, tt.args.file, 0)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ReadScript() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+
+			if got == tt.want {
+				return
+			}
+
+			sameName := got.Name == tt.want.Name
+			sameLines := slices.Equal(got.Lines, tt.want.Lines)
+			sameInterpreter := got.Interpreter == tt.want.Interpreter
+			sameOptions := slices.Equal(got.Options, tt.want.Options)
+			sameDeps := slices.EqualFunc(got.Dependencies, tt.want.Dependencies, func(a Script, b Script) bool {
+				return reflect.DeepEqual(a,b)
+			})
+			
+			if !sameName || !sameLines || !sameInterpreter || !sameOptions || !sameDeps {
+				t.Errorf("ReadScript() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_cap(t *testing.T) {
+	type args struct {
+		slice []string
+		n     int
+	}
+	tests := []struct {
+		name string
+		args args
+		want []string
+	}{
+		{"shorter", args{[]string{"1"}, 2}, []string{"1"}},
+		{"equal", args{[]string{"1", "2"}, 2}, []string{"1", "2"}},
+		{"longer", args{[]string{"1", "2"}, 1}, []string{"1"}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := cap(tt.args.slice, tt.args.n); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("cap() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
\ No newline at end of file
diff --git a/pkg/scripts/run.go b/pkg/scripts/run.go
new file mode 100644
index 0000000..6b16a0d
--- /dev/null
+++ b/pkg/scripts/run.go
@@ -0,0 +1,69 @@
+package scripts
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// The file we use to store the script we want to execute
+var TEMP_SCRIPT_FILE = ""
+func init() {
+	TEMP_SCRIPT_FILE = fmt.Sprintf("shmux_%d", time.Now().UnixNano())
+}
+
+// Creates an exec.Cmd that executes a script in a given shell
+// Arguments are positional arguments ($1, $2...) which can be used in the script as replacement
+func RunScript(script *Script, arguments []string) (status int, err error) {
+	for _, dependency := range script.Dependencies {
+		status, err = RunScript(&dependency, arguments)
+		if err != nil { return }
+	}
+	path := getTempScriptPath(script.Name)
+
+	file, err := os.Create(path)
+	if err != nil {
+		return 1, err
+	}
+	defer file.Close()
+	defer os.RemoveAll(path)
+
+	fileContent := strings.Join(script.Lines, "\n")
+	file.WriteString(replaceArguments(fileContent, arguments, script.Name))
+
+	cmd := exec.Command(script.Interpreter, append(script.Options, path)...)
+	cmd.Stderr = os.Stderr
+	cmd.Stdout = os.Stdout
+
+	err = cmd.Run()
+	if err != nil {
+		status = 1
+		if exitError, ok := err.(*exec.ExitError); ok {
+			status = exitError.ExitCode()
+			err = fmt.Errorf("script \"%s\" exited with code %d", script.Name, status)
+		}
+	}
+
+	return
+}
+
+// Returns the path of the temporary script we use for execution
+func getTempScriptPath(scriptName string) string {
+	return filepath.Join(os.TempDir(), fmt.Sprintf("%s_%s", TEMP_SCRIPT_FILE, scriptName))
+}
+
+// Replaces positional arguments in the arguments slice ($1..$9) and
+// $@ with script name in 'content
+func replaceArguments(content string, arguments []string, scriptName string) string {
+	result := content
+
+	for i, arg := range cap(arguments, 9) {
+		placeholder := fmt.Sprintf("$%d", i+1)
+		result = strings.ReplaceAll(result, placeholder, arg)
+	}
+
+	return strings.ReplaceAll(result, "$@", scriptName)
+}
\ No newline at end of file
diff --git a/pkg/scripts/run_test.go b/pkg/scripts/run_test.go
new file mode 100644
index 0000000..eb1db3b
--- /dev/null
+++ b/pkg/scripts/run_test.go
@@ -0,0 +1,28 @@
+package scripts
+
+import "testing"
+
+func Test_replaceArguments(t *testing.T) {
+	type args struct {
+		content    string
+		arguments  []string
+		scriptName string
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		{"replace one occurrence", args{"this $1 replacement, $1 it not?", []string{"is"}, "script"}, "this is replacement, is it not?"},
+		{"replace script name", args{"this $1 $@", []string{"is"}, "script"}, "this is script"},
+		{"replace many occurrences", args{"this $2 $1 $@", []string{"not", "is"}, "script"}, "this is not script"},
+		{"replace only 9 occurrences", args{"$9$8$7$6$5$4$3$2$1", []string{"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"}, "script"}, "987654321"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := replaceArguments(tt.args.content, tt.args.arguments, tt.args.scriptName); got != tt.want {
+				t.Errorf("replaceArguments() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/pkg/scripts/scripts_test.go b/pkg/scripts/scripts_test.go
deleted file mode 100644
index 7fcf71c..0000000
--- a/pkg/scripts/scripts_test.go
+++ /dev/null
@@ -1,178 +0,0 @@
-package scripts
-
-import (
-	"io"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-func Test_readScript(t *testing.T) {
-	type args struct {
-		line string
-	}
-	tests := []struct {
-		name             string
-		args             args
-		wantIsScriptLine bool
-		wantMatch        string
-	}{
-		{"returns true with correct script", args{"start:"}, true, "start"},
-		{"handles and ignores foreign characters", args{"start: dunno"}, true, "start"},
-		{"returns false with blank start", args{"    start:"}, false, ""},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gotIsScriptLine, gotMatch := readScript(tt.args.line)
-			if gotIsScriptLine != tt.wantIsScriptLine {
-				t.Errorf("readScript() gotIsScriptLine = %v, want %v", gotIsScriptLine, tt.wantIsScriptLine)
-			}
-			if gotMatch != tt.wantMatch {
-				t.Errorf("readScript() gotMatch = %v, want %v", gotMatch, tt.wantMatch)
-			}
-		})
-	}
-}
-
-func TestReadScript(t *testing.T) {
-	type args struct {
-		scriptName string
-		shell      string
-		file       io.Reader
-	}
-	tests := []struct {
-		name    string
-		args    args
-		want    *Script
-		wantErr bool
-	}{
-		{
-			"one script, with non-default interpreter",
-			args{"script", "/bin/interpreter", strings.NewReader("script:\n\techo $HOME")},
-			&Script{Name: "script", Lines: []string{"echo $HOME"}, Interpreter: "/bin/interpreter"},
-			false,
-		},
-		{
-			"one script, one line",
-			args{"script", "/bin/bash", strings.NewReader("script:\n\techo $HOME")},
-			&Script{Name: "script", Lines: []string{"echo $HOME"}, Interpreter: "/bin/bash"},
-			false,
-		},
-		{
-			"one script, many lines",
-			args{"script", "/bin/bash", strings.NewReader("script:\n\tif true:\n\t\tprint('test2')")},
-			&Script{Name: "script", Lines: []string{"if true:", "\tprint('test2')"}, Interpreter: "/bin/bash"},
-			false,
-		},
-		{
-			"one script, many lines with spaces",
-			args{"script", "/bin/bash", strings.NewReader("script:\n   if true:\n     print('test2')")},
-			&Script{Name: "script", Lines: []string{"if true:", "  print('test2')"}, Interpreter: "/bin/bash"},
-			false,
-		},
-		{
-			"two scripts, retuns latter",
-			args{"another", "/bin/bash", strings.NewReader("script:\n\tscript1\n\nanother:\n\tscript2")},
-			&Script{Name: "another", Lines: []string{"script2"}, Interpreter: "/bin/bash"},
-			false,
-		},
-		{
-			"two scripts, finds nothing",
-			args{"unknown", "/bin/bash", strings.NewReader("script:\n\tscript1\n\nanother:\n\tscript2")},
-			nil,
-			true,
-		},
-		{
-			"one script, with simple shebang",
-			args{"script", "/bin/bash", strings.NewReader("script:\n\t#!/bin/lol\n\tline")},
-			&Script{Name: "script", Lines: []string{"line"}, Interpreter: "/bin/lol"},
-			false,
-		},
-		{
-			"one script, with shebang with options",
-			args{"script", "/bin/bash", strings.NewReader("script:\n\t#!/bin/lol --lol=1 --two\n\tline")},
-			&Script{Name: "script", Lines: []string{"line"}, Interpreter: "/bin/lol", Options: []string{"--lol=1", "--two"}},
-			false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := ReadScript(tt.args.scriptName, tt.args.shell, tt.args.file)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ReadScript() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("ReadScript() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func Test_replaceArguments(t *testing.T) {
-	type args struct {
-		content    string
-		arguments  []string
-		scriptName string
-	}
-	tests := []struct {
-		name string
-		args args
-		want string
-	}{
-		{"replace one occurrence", args{"this $1 replacement, $1 it not?", []string{"is"}, "script"}, "this is replacement, is it not?"},
-		{"replace script name", args{"this $1 $@", []string{"is"}, "script"}, "this is script"},
-		{"replace many occurrences", args{"this $2 $1 $@", []string{"not", "is"}, "script"}, "this is not script"},
-		{"replace only 9 occurrences", args{"$9$8$7$6$5$4$3$2$1", []string{"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"}, "script"}, "987654321"},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := replaceArguments(tt.args.content, tt.args.arguments, tt.args.scriptName); got != tt.want {
-				t.Errorf("replaceArguments() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func Test_cap(t *testing.T) {
-	type args struct {
-		slice []string
-		n     int
-	}
-	tests := []struct {
-		name string
-		args args
-		want []string
-	}{
-		{"shorter", args{[]string{"1"}, 2}, []string{"1"}},
-		{"equal", args{[]string{"1", "2"}, 2}, []string{"1", "2"}},
-		{"longer", args{[]string{"1", "2"}, 1}, []string{"1"}},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := cap(tt.args.slice, tt.args.n); !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("cap() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestMakeHelp(t *testing.T) {
-	type args struct {
-		file io.Reader
-	}
-	tests := []struct {
-		name     string
-		args     args
-		includes string
-	}{
-		{"returns the correct text", args{strings.NewReader("script:\n\tscript1\n\nanother:\n\tscript2")}, "script1, script2"},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := MakeHelp(tt.args.file); strings.Contains(got, tt.includes) {
-				t.Errorf("MakeHelp() = %v, does not include %v", got, tt.includes)
-			}
-		})
-	}
-}
diff --git a/shmuxfile.sh b/shmuxfile.sh
index 9dca2f9..fc6d188 100644
--- a/shmuxfile.sh
+++ b/shmuxfile.sh
@@ -1,9 +1,6 @@
 test:
   go test github.com/shikaan/shmux/pkg/...
 
-build:
+build: test
   go build -o shmux-dev .
-  mv shmux-dev /usr/local/bin/shmux-dev
-
-greet:
-  echo "Hello $1, my old friend"
\ No newline at end of file
+  mv shmux-dev ~/.local/bin/shmux-dev
\ No newline at end of file
diff --git a/test_shmuxfile.sh b/test_shmuxfile.sh
new file mode 100644
index 0000000..8f01fd3
--- /dev/null
+++ b/test_shmuxfile.sh
@@ -0,0 +1,27 @@
+greet:
+  echo "Hello $1, my old friend"
+
+deps: greet
+  echo "Deps"
+  
+deps_error: greet error
+  echo "Deps error"
+
+error:
+  exit 1
+
+javascript:
+  #!/usr/bin/env node
+  console.log("hello")
+
+python:
+  #!/usr/bin/env python3
+  print("hello")
+
+perl:
+  #!/usr/bin/env perl
+  print "hello\n";
+
+ruby:
+  #!/usr/bin/env ruby
+  puts "hello"
\ No newline at end of file