diff --git a/realize.go b/realize.go
index e3c0444..798752d 100644
--- a/realize.go
+++ b/realize.go
@@ -3,109 +3,97 @@ package main
 import (
 	"errors"
 	"fmt"
-	"github.com/fatih/color"
-	i "github.com/tockins/interact"
-	s "github.com/tockins/realize/server"
-	c "github.com/tockins/realize/settings"
-	w "github.com/tockins/realize/watcher"
-	"gopkg.in/urfave/cli.v2"
 	"os"
 	"time"
+
+	"github.com/fatih/color"
+	"github.com/tockins/interact"
+	"github.com/tockins/realize/server"
+	"github.com/tockins/realize/settings"
+	"github.com/tockins/realize/style"
+	"github.com/tockins/realize/watcher"
+	cli "gopkg.in/urfave/cli.v2"
 )
 
 const (
-	name        = "Realize"
-	version     = "1.3"
-	description = "A Go build system with file watchers, output streams and live reload. Run, build and watch file changes with custom paths"
-	config      = "realize.yaml"
-	outputs     = "outputs.log"
-	errs        = "errors.log"
-	logs        = "logs.log"
-	host        = "localhost"
-	port        = 5001
-	interval    = 200
+	appVersion = "1.3"
+
+	config   = "realize.yaml"
+	outputs  = "outputs.log"
+	errs     = "errors.log"
+	logs     = "logs.log"
+	host     = "localhost"
+	port     = 5001
+	interval = 200
 )
 
-var r realize
-
-// Realize struct contains the general app informations
-type realize struct {
-	c.Settings                                      `yaml:"settings,omitempty"`
-	Name, Description, Author, Email, Host, Version string       `yaml:"-"`
-	Sync                                            chan string  `yaml:"-"`
-	Blueprint                                       w.Blueprint  `yaml:"-"`
-	Server                                          s.Server     `yaml:"-"`
-	Projects                                        *[]w.Project `yaml:"projects" json:"projects"`
-}
-
-// Realize struct initialization
-func init() {
-	r = realize{
-		Name:        name,
-		Version:     version,
-		Description: description,
-		Sync:        make(chan string),
-		Settings: c.Settings{
-			Config: c.Config{
-				Create: true,
-			},
-			Resources: c.Resources{
-				Config:  config,
-				Outputs: outputs,
-				Logs:    logs,
-				Errors:  errs,
-			},
-			Server: c.Server{
-				Status: false,
-				Open:   false,
-				Host:   host,
-				Port:   port,
-			},
-		},
-	}
-	r.Blueprint = w.Blueprint{
-		Settings: &r.Settings,
-		Sync:     r.Sync,
-	}
-	r.Server = s.Server{
-		Blueprint: &r.Blueprint,
-		Settings:  &r.Settings,
-		Sync:      r.Sync,
-	}
-	r.Projects = &r.Blueprint.Projects
-
-	// read if exist
-	r.Read(&r)
-
-	// increase the file limit
-	if r.Config.Flimit != 0 {
-		r.Flimit()
-	}
-}
-
-// Before of every exec of a cli method
-func before() error {
-	gopath := os.Getenv("GOPATH")
-	if gopath == "" {
-		return handle(errors.New("$GOPATH isn't set up properly"))
-	}
-	return nil
-}
-
-// Handle errors
-func handle(err error) error {
-	if err != nil {
-		fmt.Println(r.Red.Bold(err.Error()))
-		os.Exit(1)
-	}
-	return nil
-}
-
 // Cli commands
 func main() {
+	// Realize struct contains the general app informations
+	type realize struct {
+		settings.Settings `yaml:"settings,omitempty"`
+		Sync              chan string        `yaml:"-"`
+		Blueprint         watcher.Blueprint  `yaml:"-"`
+		Server            server.Server      `yaml:"-"`
+		Projects          *[]watcher.Project `yaml:"projects" json:"projects"`
+	}
+
+	var r realize
+	// Before of every exec of a cli method
+	before := func(*cli.Context) error {
+		gopath := os.Getenv("GOPATH")
+		if gopath == "" {
+			return errors.New("$GOPATH isn't set up properly")
+		}
+
+		r = realize{
+			Sync: make(chan string),
+			Settings: settings.Settings{
+				Config: settings.Config{
+					Create: true,
+				},
+				Resources: settings.Resources{
+					Config:  config,
+					Outputs: outputs,
+					Logs:    logs,
+					Errors:  errs,
+				},
+				Server: settings.Server{
+					Status: false,
+					Open:   false,
+					Host:   host,
+					Port:   port,
+				},
+			},
+		}
+		r.Blueprint = watcher.Blueprint{
+			Settings: &r.Settings,
+			Sync:     r.Sync,
+		}
+		r.Server = server.Server{
+			Blueprint: &r.Blueprint,
+			Settings:  &r.Settings,
+			Sync:      r.Sync,
+		}
+		r.Projects = &r.Blueprint.Projects
+
+		// read if exist
+		if err := r.Read(&r); err != nil {
+			return err
+		}
+
+		// increase the file limit
+		if r.Config.Flimit != 0 {
+			if err := r.Flimit(); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+
 	app := &cli.App{
-		Name:    r.Name,
-		Version: r.Version,
+		Name:    "Realize",
+		Version: appVersion,
 		Authors: []*cli.Author{
 			{
 				Name:  "Alessio Pracchia",
@@ -116,12 +104,12 @@ func main() {
 				Email: "conventi@hastega.it",
 			},
 		},
-		Usage: r.Description,
+		Description: "A Go build system with file watchers, output streams and live reload. Run, build and watch file changes with custom paths",
 		Commands: []*cli.Command{
 			{
-				Name:    "run",
-				Aliases: []string{"r"},
-				Usage:   "Run a toolchain on a project or a list of projects. If not exist a config file it creates a new one.",
+				Name:        "run",
+				Aliases:     []string{"r"},
+				Description: "Run a toolchain on a project or a list of projects. If not exist a config file it creates a new one",
 				Flags: []cli.Flag{
 					&cli.StringFlag{Name: "path", Aliases: []string{"p"}, Value: "", Usage: "Project base path."},
 					&cli.BoolFlag{Name: "test", Aliases: []string{"t"}, Value: false, Usage: "Enable go test."},
@@ -135,7 +123,7 @@ func main() {
 				},
 				Action: func(p *cli.Context) error {
 					if p.Bool("legacy") {
-						r.Config.Legacy = c.Legacy{
+						r.Config.Legacy = settings.Legacy{
 							Status:   p.Bool("legacy"),
 							Interval: interval,
 						}
@@ -144,23 +132,29 @@ func main() {
 						if p.Bool("no-config") {
 							r.Config.Create = false
 						}
-						r.Blueprint.Projects = []w.Project{}
-						handle(r.Blueprint.Add(p))
+						r.Blueprint.Projects = []watcher.Project{}
+						if err := r.Blueprint.Add(p); err != nil {
+							return err
+						}
+					}
+					if err := r.Server.Start(p); err != nil {
+						return err
+					}
+					if err := r.Blueprint.Run(); err != nil {
+						return err
+					}
+					if err := r.Record(r); err != nil {
+						return err
 					}
-					handle(r.Server.Start(p))
-					handle(r.Blueprint.Run())
-					handle(r.Record(r))
 					return nil
 				},
-				Before: func(c *cli.Context) error {
-					return before()
-				},
+				Before: before,
 			},
 			{
-				Name:     "add",
-				Category: "Configuration",
-				Aliases:  []string{"a"},
-				Usage:    "Add a project to an existing config file or create a new one.",
+				Name:        "add",
+				Category:    "Configuration",
+				Aliases:     []string{"a"},
+				Description: "Add a project to an existing config file or create a new one.",
 				Flags: []cli.Flag{
 					&cli.StringFlag{Name: "path", Aliases: []string{"p"}, Value: "", Usage: "Project base path."},
 					&cli.BoolFlag{Name: "test", Aliases: []string{"t"}, Value: false, Usage: "Enable go test."},
@@ -173,58 +167,60 @@ func main() {
 					&cli.BoolFlag{Name: "no-install", Aliases: []string{"ni"}, Value: false, Usage: "Disable go install"},
 					&cli.BoolFlag{Name: "no-config", Aliases: []string{"nc"}, Value: false, Usage: "Ignore existing configurations."},
 				},
-				Action: func(p *cli.Context) (err error) {
+				Action: func(p *cli.Context) error {
 					fmt.Println(p.String("path"))
-					handle(r.Blueprint.Add(p))
-					handle(r.Record(r))
-					fmt.Println(r.Yellow.Bold("[")+"REALIZE"+r.Yellow.Bold("]"), r.Green.Bold("Your project was successfully added."))
+					if err := r.Blueprint.Add(p); err != nil {
+						return err
+					}
+					if err := r.Record(r); err != nil {
+						return err
+					}
+					fmt.Println(style.Yellow.Bold("[")+"REALIZE"+style.Yellow.Bold("]"), style.Green.Bold("Your project was successfully added."))
 					return nil
 				},
-				Before: func(c *cli.Context) error {
-					return before()
-				},
+				Before: before,
 			},
 			{
-				Name:     "init",
-				Category: "Configuration",
-				Aliases:  []string{"a"},
-				Usage:    "Define a new config file with all options step by step",
-				Action: func(p *cli.Context) (err error) {
-					i.Run(&i.Interact{
-						Before: func(context i.Context) error {
-							context.SetErr(r.Red.Bold("INVALID INPUT"))
-							context.SetPrfx(color.Output, r.Yellow.Bold("[")+"REALIZE"+r.Yellow.Bold("]"))
+				Name:        "init",
+				Category:    "Configuration",
+				Aliases:     []string{"a"},
+				Description: "Define a new config file with all options step by step",
+				Action: func(p *cli.Context) (actErr error) {
+					interact.Run(&interact.Interact{
+						Before: func(context interact.Context) error {
+							context.SetErr(style.Red.Bold("INVALID INPUT"))
+							context.SetPrfx(color.Output, style.Yellow.Bold("[")+"REALIZE"+style.Yellow.Bold("]"))
 							return nil
 						},
-						Questions: []*i.Question{
+						Questions: []*interact.Question{
 							{
-								Before: func(d i.Context) error {
+								Before: func(d interact.Context) error {
 									if _, err := os.Stat(".realize/" + config); err != nil {
 										d.Skip()
 									}
-									d.SetDef(false, r.Green.Regular("(n)"))
+									d.SetDef(false, style.Green.Regular("(n)"))
 									return nil
 								},
-								Quest: i.Quest{
-									Options: r.Yellow.Regular("[y/n]"),
-									Msg:     "Would you want to overwrite the existing " + r.Colors.Magenta.Bold("Realize") + " config?",
+								Quest: interact.Quest{
+									Options: style.Yellow.Regular("[y/n]"),
+									Msg:     "Would you want to overwrite the existing " + style.Magenta.Bold("Realize") + " config?",
 								},
-								Action: func(d i.Context) interface{} {
+								Action: func(d interact.Context) interface{} {
 									val, err := d.Ans().Bool()
 									if err != nil {
 										return d.Err()
 									} else if val {
-										r.Settings = c.Settings{
-											Config: c.Config{
+										r.Settings = settings.Settings{
+											Config: settings.Config{
 												Create: true,
 											},
-											Resources: c.Resources{
+											Resources: settings.Resources{
 												Config:  config,
 												Outputs: outputs,
 												Logs:    logs,
 												Errors:  errs,
 											},
-											Server: c.Server{
+											Server: settings.Server{
 												Status: false,
 												Open:   false,
 												Host:   host,
@@ -237,29 +233,29 @@ func main() {
 								},
 							},
 							{
-								Before: func(d i.Context) error {
-									d.SetDef(false, r.Green.Regular("(n)"))
+								Before: func(d interact.Context) error {
+									d.SetDef(false, style.Green.Regular("(n)"))
 									return nil
 								},
-								Quest: i.Quest{
-									Options: r.Yellow.Regular("[y/n]"),
-									Msg:     "Would you want to customize the " + r.Colors.Magenta.Bold("settings") + "?",
-									Resolve: func(d i.Context) bool {
+								Quest: interact.Quest{
+									Options: style.Yellow.Regular("[y/n]"),
+									Msg:     "Would you want to customize the " + ("settings") + "?",
+									Resolve: func(d interact.Context) bool {
 										val, _ := d.Ans().Bool()
 										return val
 									},
 								},
-								Subs: []*i.Question{
+								Subs: []*interact.Question{
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(0, r.Green.Regular("(os default)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(0, style.Green.Regular("(os default)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[int]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[int]"),
 											Msg:     "Max number of open files (root required)",
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											val, err := d.Ans().Int()
 											if err != nil {
 												return d.Err()
@@ -269,29 +265,29 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(false, r.Green.Regular("(n)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(false, style.Green.Regular("(n)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Enable legacy watch by polling",
-											Resolve: func(d i.Context) bool {
+											Resolve: func(d interact.Context) bool {
 												val, _ := d.Ans().Bool()
 												return val
 											},
 										},
-										Subs: []*i.Question{
+										Subs: []*interact.Question{
 											{
-												Before: func(d i.Context) error {
-													d.SetDef(1, r.Green.Regular("(1s)"))
+												Before: func(d interact.Context) error {
+													d.SetDef(1, style.Green.Regular("(1s)"))
 													return nil
 												},
-												Quest: i.Quest{
-													Options: r.Yellow.Regular("[seconds]"),
+												Quest: interact.Quest{
+													Options: style.Yellow.Regular("[seconds]"),
 													Msg:     "Set polling interval in seconds",
 												},
-												Action: func(d i.Context) interface{} {
+												Action: func(d interact.Context) interface{} {
 													val, err := d.Ans().Int()
 													if err != nil {
 														return d.Err()
@@ -301,7 +297,7 @@ func main() {
 												},
 											},
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											val, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -311,29 +307,29 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(false, r.Green.Regular("(n)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(false, style.Green.Regular("(n)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Enable web server",
-											Resolve: func(d i.Context) bool {
+											Resolve: func(d interact.Context) bool {
 												val, _ := d.Ans().Bool()
 												return val
 											},
 										},
-										Subs: []*i.Question{
+										Subs: []*interact.Question{
 											{
-												Before: func(d i.Context) error {
-													d.SetDef(5001, r.Green.Regular("(5001)"))
+												Before: func(d interact.Context) error {
+													d.SetDef(5001, style.Green.Regular("(5001)"))
 													return nil
 												},
-												Quest: i.Quest{
-													Options: r.Yellow.Regular("[int]"),
+												Quest: interact.Quest{
+													Options: style.Yellow.Regular("[int]"),
 													Msg:     "Server port",
 												},
-												Action: func(d i.Context) interface{} {
+												Action: func(d interact.Context) interface{} {
 													val, err := d.Ans().Int()
 													if err != nil {
 														return d.Err()
@@ -343,15 +339,15 @@ func main() {
 												},
 											},
 											{
-												Before: func(d i.Context) error {
-													d.SetDef("localhost", r.Green.Regular("(localhost)"))
+												Before: func(d interact.Context) error {
+													d.SetDef("localhost", style.Green.Regular("(localhost)"))
 													return nil
 												},
-												Quest: i.Quest{
-													Options: r.Yellow.Regular("[string]"),
+												Quest: interact.Quest{
+													Options: style.Yellow.Regular("[string]"),
 													Msg:     "Server host",
 												},
-												Action: func(d i.Context) interface{} {
+												Action: func(d interact.Context) interface{} {
 													val, err := d.Ans().String()
 													if err != nil {
 														return d.Err()
@@ -361,15 +357,15 @@ func main() {
 												},
 											},
 											{
-												Before: func(d i.Context) error {
-													d.SetDef(false, r.Green.Regular("(n)"))
+												Before: func(d interact.Context) error {
+													d.SetDef(false, style.Green.Regular("(n)"))
 													return nil
 												},
-												Quest: i.Quest{
-													Options: r.Yellow.Regular("[y/n]"),
+												Quest: interact.Quest{
+													Options: style.Yellow.Regular("[y/n]"),
 													Msg:     "Open in the current browser",
 												},
-												Action: func(d i.Context) interface{} {
+												Action: func(d interact.Context) interface{} {
 													val, err := d.Ans().Bool()
 													if err != nil {
 														return d.Err()
@@ -379,7 +375,7 @@ func main() {
 												},
 											},
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											val, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -389,7 +385,7 @@ func main() {
 										},
 									},
 								},
-								Action: func(d i.Context) interface{} {
+								Action: func(d interact.Context) interface{} {
 									_, err := d.Ans().Bool()
 									if err != nil {
 										return d.Err()
@@ -398,15 +394,15 @@ func main() {
 								},
 							},
 							{
-								Before: func(d i.Context) error {
-									d.SetDef(true, r.Green.Regular("(y)"))
+								Before: func(d interact.Context) error {
+									d.SetDef(true, style.Green.Regular("(y)"))
 									d.SetEnd("!")
 									return nil
 								},
-								Quest: i.Quest{
-									Options: r.Yellow.Regular("[y/n]"),
-									Msg:     "Would you want to " + r.Colors.Magenta.Regular("add a new project") + "? (insert '!' to stop)",
-									Resolve: func(d i.Context) bool {
+								Quest: interact.Quest{
+									Options: style.Yellow.Regular("[y/n]"),
+									Msg:     "Would you want to " + style.Magenta.Regular("add a new project") + "? (insert '!' to stop)",
+									Resolve: func(d interact.Context) bool {
 										val, _ := d.Ans().Bool()
 										if val {
 											r.Blueprint.Add(p)
@@ -414,17 +410,17 @@ func main() {
 										return val
 									},
 								},
-								Subs: []*i.Question{
+								Subs: []*interact.Question{
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(r.Settings.Wdir(), r.Green.Regular("("+r.Settings.Wdir()+")"))
+										Before: func(d interact.Context) error {
+											d.SetDef(r.Settings.Wdir(), style.Green.Regular("("+r.Settings.Wdir()+")"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[string]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[string]"),
 											Msg:     "Project name",
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											val, err := d.Ans().String()
 											if err != nil {
 												return d.Err()
@@ -434,16 +430,16 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
+										Before: func(d interact.Context) error {
 											dir, _ := os.Getwd()
-											d.SetDef(dir, r.Green.Regular("("+dir+")"))
+											d.SetDef(dir, style.Green.Regular("("+dir+")"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[string]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[string]"),
 											Msg:     "Project path",
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											val, err := d.Ans().String()
 											if err != nil {
 												return d.Err()
@@ -453,15 +449,15 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(true, r.Green.Regular("(y)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(true, style.Green.Regular("(y)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Enable go fmt",
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											val, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -471,15 +467,15 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(false, r.Green.Regular("(n)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(false, style.Green.Regular("(n)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Enable go test",
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											val, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -489,15 +485,15 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(false, r.Green.Regular("(n)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(false, style.Green.Regular("(n)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Enable go generate",
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											val, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -507,15 +503,15 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(true, r.Green.Regular("(y)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(true, style.Green.Regular("(y)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Enable go install",
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											val, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -525,15 +521,15 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(false, r.Green.Regular("(n)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(false, style.Green.Regular("(n)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Enable go build",
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											val, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -543,15 +539,15 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(true, r.Green.Regular("(y)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(true, style.Green.Regular("(y)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Enable go run",
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											val, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -561,14 +557,14 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(false, r.Green.Regular("(n)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(false, style.Green.Regular("(n)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Customize the watched paths",
-											Resolve: func(d i.Context) bool {
+											Resolve: func(d interact.Context) bool {
 												val, _ := d.Ans().Bool()
 												if val {
 													r.Blueprint.Projects[len(r.Blueprint.Projects)-1].Watcher.Paths = r.Blueprint.Projects[len(r.Blueprint.Projects)-1].Watcher.Paths[:len(r.Blueprint.Projects[len(r.Blueprint.Projects)-1].Watcher.Paths)-1]
@@ -576,17 +572,17 @@ func main() {
 												return val
 											},
 										},
-										Subs: []*i.Question{
+										Subs: []*interact.Question{
 											{
-												Before: func(d i.Context) error {
+												Before: func(d interact.Context) error {
 													d.SetEnd("!")
 													return nil
 												},
-												Quest: i.Quest{
-													Options: r.Yellow.Regular("[string]"),
+												Quest: interact.Quest{
+													Options: style.Yellow.Regular("[string]"),
 													Msg:     "Insert a path to watch (insert '!' to stop)",
 												},
-												Action: func(d i.Context) interface{} {
+												Action: func(d interact.Context) interface{} {
 													val, err := d.Ans().String()
 													if err != nil {
 														return d.Err()
@@ -597,7 +593,7 @@ func main() {
 												},
 											},
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											_, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -606,14 +602,14 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(false, r.Green.Regular("(n)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(false, style.Green.Regular("(n)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Customize the ignored paths",
-											Resolve: func(d i.Context) bool {
+											Resolve: func(d interact.Context) bool {
 												val, _ := d.Ans().Bool()
 												if val {
 													r.Blueprint.Projects[len(r.Blueprint.Projects)-1].Watcher.Ignore = r.Blueprint.Projects[len(r.Blueprint.Projects)-1].Watcher.Ignore[:len(r.Blueprint.Projects[len(r.Blueprint.Projects)-1].Watcher.Ignore)-1]
@@ -621,17 +617,17 @@ func main() {
 												return val
 											},
 										},
-										Subs: []*i.Question{
+										Subs: []*interact.Question{
 											{
-												Before: func(d i.Context) error {
+												Before: func(d interact.Context) error {
 													d.SetEnd("!")
 													return nil
 												},
-												Quest: i.Quest{
-													Options: r.Yellow.Regular("[string]"),
+												Quest: interact.Quest{
+													Options: style.Yellow.Regular("[string]"),
 													Msg:     "Insert a path to ignore (insert '!' to stop)",
 												},
-												Action: func(d i.Context) interface{} {
+												Action: func(d interact.Context) interface{} {
 													val, err := d.Ans().String()
 													if err != nil {
 														return d.Err()
@@ -642,7 +638,7 @@ func main() {
 												},
 											},
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											_, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -651,29 +647,29 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(false, r.Green.Regular("(n)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(false, style.Green.Regular("(n)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Add additionals arguments",
-											Resolve: func(d i.Context) bool {
+											Resolve: func(d interact.Context) bool {
 												val, _ := d.Ans().Bool()
 												return val
 											},
 										},
-										Subs: []*i.Question{
+										Subs: []*interact.Question{
 											{
-												Before: func(d i.Context) error {
+												Before: func(d interact.Context) error {
 													d.SetEnd("!")
 													return nil
 												},
-												Quest: i.Quest{
-													Options: r.Yellow.Regular("[string]"),
+												Quest: interact.Quest{
+													Options: style.Yellow.Regular("[string]"),
 													Msg:     "Insert an argument (insert '!' to stop)",
 												},
-												Action: func(d i.Context) interface{} {
+												Action: func(d interact.Context) interface{} {
 													val, err := d.Ans().String()
 													if err != nil {
 														return d.Err()
@@ -684,7 +680,7 @@ func main() {
 												},
 											},
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											_, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -693,40 +689,40 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(false, r.Green.Regular("(n)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(false, style.Green.Regular("(n)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Add 'before' custom commands",
-											Resolve: func(d i.Context) bool {
+											Resolve: func(d interact.Context) bool {
 												val, _ := d.Ans().Bool()
 												return val
 											},
 										},
-										Subs: []*i.Question{
+										Subs: []*interact.Question{
 											{
-												Before: func(d i.Context) error {
+												Before: func(d interact.Context) error {
 													d.SetEnd("!")
 													return nil
 												},
-												Quest: i.Quest{
-													Options: r.Yellow.Regular("[string]"),
+												Quest: interact.Quest{
+													Options: style.Yellow.Regular("[string]"),
 													Msg:     "Insert a command (insert '!' to stop)",
 												},
-												Action: func(d i.Context) interface{} {
+												Action: func(d interact.Context) interface{} {
 													val, err := d.Ans().String()
 													if err != nil {
 														return d.Err()
 													}
-													r.Blueprint.Projects[len(r.Blueprint.Projects)-1].Watcher.Scripts = append(r.Blueprint.Projects[len(r.Blueprint.Projects)-1].Watcher.Scripts, w.Command{Type: "before", Command: val})
+													r.Blueprint.Projects[len(r.Blueprint.Projects)-1].Watcher.Scripts = append(r.Blueprint.Projects[len(r.Blueprint.Projects)-1].Watcher.Scripts, watcher.Command{Type: "before", Command: val})
 													d.Reload()
 													return nil
 												},
 											},
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											_, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -735,40 +731,40 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(false, r.Green.Regular("(n)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(false, style.Green.Regular("(n)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Add 'after' custom commands",
-											Resolve: func(d i.Context) bool {
+											Resolve: func(d interact.Context) bool {
 												val, _ := d.Ans().Bool()
 												return val
 											},
 										},
-										Subs: []*i.Question{
+										Subs: []*interact.Question{
 											{
-												Before: func(d i.Context) error {
+												Before: func(d interact.Context) error {
 													d.SetEnd("!")
 													return nil
 												},
-												Quest: i.Quest{
-													Options: r.Yellow.Regular("[string]"),
+												Quest: interact.Quest{
+													Options: style.Yellow.Regular("[string]"),
 													Msg:     "Insert a command (insert '!' to stop)",
 												},
-												Action: func(d i.Context) interface{} {
+												Action: func(d interact.Context) interface{} {
 													val, err := d.Ans().String()
 													if err != nil {
 														return d.Err()
 													}
-													r.Blueprint.Projects[len(r.Blueprint.Projects)-1].Watcher.Scripts = append(r.Blueprint.Projects[len(r.Blueprint.Projects)-1].Watcher.Scripts, w.Command{Type: "after", Command: val})
+													r.Blueprint.Projects[len(r.Blueprint.Projects)-1].Watcher.Scripts = append(r.Blueprint.Projects[len(r.Blueprint.Projects)-1].Watcher.Scripts, watcher.Command{Type: "after", Command: val})
 													d.Reload()
 													return nil
 												},
 											},
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											_, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -777,15 +773,15 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(false, r.Green.Regular("(n)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(false, style.Green.Regular("(n)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Enable watcher files preview",
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											val, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -795,15 +791,15 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(false, r.Green.Regular("(n)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(false, style.Green.Regular("(n)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Enable file output history",
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											val, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -813,15 +809,15 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(false, r.Green.Regular("(n)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(false, style.Green.Regular("(n)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Enable file logs history",
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											val, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -831,15 +827,15 @@ func main() {
 										},
 									},
 									{
-										Before: func(d i.Context) error {
-											d.SetDef(false, r.Green.Regular("(n)"))
+										Before: func(d interact.Context) error {
+											d.SetDef(false, style.Green.Regular("(n)"))
 											return nil
 										},
-										Quest: i.Quest{
-											Options: r.Yellow.Regular("[y/n]"),
+										Quest: interact.Quest{
+											Options: style.Yellow.Regular("[y/n]"),
 											Msg:     "Enable file errors history",
 										},
-										Action: func(d i.Context) interface{} {
+										Action: func(d interact.Context) interface{} {
 											val, err := d.Ans().Bool()
 											if err != nil {
 												return d.Err()
@@ -849,7 +845,7 @@ func main() {
 										},
 									},
 								},
-								Action: func(d i.Context) interface{} {
+								Action: func(d interact.Context) interface{} {
 									if val, err := d.Ans().Bool(); err != nil {
 										return d.Err()
 									} else if val {
@@ -859,69 +855,73 @@ func main() {
 								},
 							},
 						},
-						After: func(d i.Context) error {
+						After: func(d interact.Context) error {
 							if val, _ := d.Qns().Get(0).Ans().Bool(); val {
-								err = r.Settings.Remove()
-								if err != nil {
-									return err
+								actErr = r.Settings.Remove()
+								if actErr != nil {
+									return actErr
 								}
 							}
 							return nil
 						},
 					})
-					handle(r.Record(r))
-					fmt.Println(r.Yellow.Bold("[")+"REALIZE"+r.Yellow.Bold("]"), r.Green.Bold("Your configuration was successful."))
+					if err := r.Record(r); err != nil {
+						return err
+					}
+					fmt.Println(style.Yellow.Bold("[")+"REALIZE"+style.Yellow.Bold("]"), style.Green.Bold("Your configuration was successful."))
 					return nil
 				},
-				Before: func(c *cli.Context) error {
-					return before()
-				},
+				Before: before,
 			},
 			{
-				Name:     "remove",
-				Category: "Configuration",
-				Aliases:  []string{"r"},
-				Usage:    "Remove a project from a realize configuration.",
+				Name:        "remove",
+				Category:    "Configuration",
+				Aliases:     []string{"r"},
+				Description: "Remove a project from a realize configuration.",
 				Flags: []cli.Flag{
 					&cli.StringFlag{Name: "name", Aliases: []string{"n"}, Value: ""},
 				},
 				Action: func(p *cli.Context) error {
-					handle(r.Blueprint.Remove(p))
-					handle(r.Record(r))
-					fmt.Println(r.Yellow.Bold("[")+"REALIZE"+r.Yellow.Bold("]"), r.Green.Bold("Your project was successfully removed."))
+					if err := r.Blueprint.Remove(p); err != nil {
+						return err
+					}
+					if err := r.Record(r); err != nil {
+						return err
+					}
+					fmt.Println(style.Yellow.Bold("[")+"REALIZE"+style.Yellow.Bold("]"), style.Green.Bold("Your project was successfully removed."))
 					return nil
 				},
-				Before: func(c *cli.Context) error {
-					return before()
-				},
+				Before: before,
 			},
 			{
-				Name:     "list",
-				Category: "Configuration",
-				Aliases:  []string{"l"},
-				Usage:    "Print projects list.",
+				Name:        "list",
+				Category:    "Configuration",
+				Aliases:     []string{"l"},
+				Description: "Print projects list.",
 				Action: func(p *cli.Context) error {
-					return handle(r.Blueprint.List())
-				},
-				Before: func(c *cli.Context) error {
-					return before()
+					return r.Blueprint.List()
 				},
+				Before: before,
 			},
 			{
-				Name:     "clean",
-				Category: "Configuration",
-				Aliases:  []string{"c"},
-				Usage:    "Remove realize folder.",
+				Name:        "clean",
+				Category:    "Configuration",
+				Aliases:     []string{"c"},
+				Description: "Remove realize folder.",
 				Action: func(p *cli.Context) error {
-					handle(r.Settings.Remove())
-					fmt.Println(r.Yellow.Bold("[")+"REALIZE"+r.Yellow.Bold("]"), r.Green.Bold("Realize folder successfully removed."))
+					if err := r.Settings.Remove(); err != nil {
+						return err
+					}
+					fmt.Println(style.Yellow.Bold("[")+"REALIZE"+style.Yellow.Bold("]"), style.Green.Bold("Realize folder successfully removed."))
 					return nil
 				},
-				Before: func(c *cli.Context) error {
-					return before()
-				},
+				Before: before,
 			},
 		},
 	}
-	app.Run(os.Args)
+
+	if err := app.Run(os.Args); err != nil {
+		fmt.Println(style.Red.Bold(err))
+		os.Exit(1)
+	}
 }
diff --git a/server/main.go b/server/main.go
index d40605b..382fb4a 100644
--- a/server/main.go
+++ b/server/main.go
@@ -2,21 +2,22 @@ package server
 
 import (
 	"encoding/json"
-	"github.com/labstack/echo"
-	"github.com/labstack/echo/middleware"
-	c "github.com/tockins/realize/settings"
-	w "github.com/tockins/realize/watcher"
-	"golang.org/x/net/websocket"
-	"gopkg.in/urfave/cli.v2"
 	"net/http"
 	"strconv"
+
+	"github.com/labstack/echo"
+	"github.com/labstack/echo/middleware"
+	"github.com/tockins/realize/settings"
+	"github.com/tockins/realize/watcher"
+	"golang.org/x/net/websocket"
+	"gopkg.in/urfave/cli.v2"
 )
 
 // Server settings
 type Server struct {
-	*c.Settings  `yaml:"-"`
-	*w.Blueprint `yaml:"-"`
-	Sync         chan string `yaml:"-"`
+	*settings.Settings `yaml:"-"`
+	*watcher.Blueprint `yaml:"-"`
+	Sync               chan string `yaml:"-"`
 }
 
 // Render return a web pages defined in bindata
diff --git a/server/open.go b/server/open.go
index 22ba233..25a436c 100644
--- a/server/open.go
+++ b/server/open.go
@@ -2,7 +2,7 @@ package server
 
 import (
 	"bytes"
-	"errors"
+	"fmt"
 	"io"
 	"os/exec"
 	"runtime"
@@ -22,9 +22,10 @@ func init() {
 
 // Open a url in the default browser
 func Open(url string) (io.Writer, error) {
-	open, err := cmd[runtime.GOOS]
+	goos := runtime.GOOS
+	open, err := cmd[goos]
 	if !err {
-		return nil, errors.New("This operating system is not supported.")
+		return nil, fmt.Errorf("operating system %q is not supported", goos)
 	}
 	cmd := exec.Command(open, url)
 	cmd.Stderr = &stderr
diff --git a/settings/colors.go b/settings/colors.go
deleted file mode 100644
index 7073127..0000000
--- a/settings/colors.go
+++ /dev/null
@@ -1,89 +0,0 @@
-package settings
-
-import (
-	"github.com/fatih/color"
-)
-
-// Colors allowed
-type Colors struct {
-	Red
-	Blue
-	Yellow
-	Magenta
-	Green
-}
-
-// Red color
-type Red struct{}
-
-// Blue color
-type Blue struct{}
-
-// Yellow color
-type Yellow struct{}
-
-// Magenta color
-type Magenta struct{}
-
-// Green color
-type Green struct{}
-
-// Regular font in red
-func (c Red) Regular(t ...interface{}) string {
-	r := color.New(color.FgRed).SprintFunc()
-	return r(t...)
-}
-
-// Bold font in red
-func (c Red) Bold(t ...interface{}) string {
-	r := color.New(color.FgRed, color.Bold).SprintFunc()
-	return r(t...)
-}
-
-// Regular font in blue
-func (c Blue) Regular(t ...interface{}) string {
-	r := color.New(color.FgBlue).SprintFunc()
-	return r(t...)
-}
-
-// Bold font in blue
-func (c Blue) Bold(t ...interface{}) string {
-	r := color.New(color.FgBlue, color.Bold).SprintFunc()
-	return r(t...)
-}
-
-// Regular font in yellow
-func (c Yellow) Regular(t ...interface{}) string {
-	r := color.New(color.FgYellow).SprintFunc()
-	return r(t...)
-}
-
-// Bold font in red
-func (c Yellow) Bold(t ...interface{}) string {
-	r := color.New(color.FgYellow, color.Bold).SprintFunc()
-	return r(t...)
-}
-
-// Regular font in magenta
-func (c Magenta) Regular(t ...interface{}) string {
-	r := color.New(color.FgMagenta).SprintFunc()
-	return r(t...)
-}
-
-// Bold font in magenta
-func (c Magenta) Bold(t ...interface{}) string {
-	r := color.New(color.FgMagenta, color.Bold).SprintFunc()
-	return r(t...)
-}
-
-// Regular font in green
-func (c Green) Regular(t ...interface{}) string {
-	r := color.New(color.FgGreen).SprintFunc()
-	return r(t...)
-}
-
-// Bold font in red
-func (c Green) Bold(t ...interface{}) string {
-	r := color.New(color.FgGreen, color.Bold).SprintFunc()
-	return r(t...)
-}
diff --git a/settings/flimit.go b/settings/flimit.go
index 258c92d..6ba2df9 100644
--- a/settings/flimit.go
+++ b/settings/flimit.go
@@ -5,12 +5,13 @@ package settings
 import "syscall"
 
 // Flimit defines the max number of watched files
-func (s *Settings) Flimit() {
+func (s *Settings) Flimit() error {
 	var rLimit syscall.Rlimit
 	rLimit.Max = uint64(s.Config.Flimit)
 	rLimit.Cur = uint64(s.Config.Flimit)
-	err := syscall.Setrlimit(syscall.RLIMIT_NOFILE, &rLimit)
-	if err != nil {
-		s.Fatal(err, "Error setting rlimit")
+
+	if err := syscall.Setrlimit(syscall.RLIMIT_NOFILE, &rLimit); err != nil {
+		return err
 	}
+	return nil
 }
diff --git a/settings/flimit_windows.go b/settings/flimit_windows.go
index 60a53eb..f74d23a 100644
--- a/settings/flimit_windows.go
+++ b/settings/flimit_windows.go
@@ -1,6 +1,7 @@
+// build windows
 package settings
 
 // Flimit defines the max number of watched files
-func (s *Settings) Flimit() {
-	return
+func (s *Settings) Flimit() error {
+	return nil
 }
diff --git a/settings/io.go b/settings/io.go
index c479928..e3fc2c3 100644
--- a/settings/io.go
+++ b/settings/io.go
@@ -9,12 +9,12 @@ import (
 // Stream return a byte stream of a given file
 func (s Settings) Stream(file string) ([]byte, error) {
 	_, err := os.Stat(file)
-	if err == nil {
-		content, err := ioutil.ReadFile(file)
-		s.Validate(err)
-		return content, err
+	if err != nil {
+		return nil, err
 	}
-	return nil, err
+	content, err := ioutil.ReadFile(file)
+	s.Validate(err)
+	return content, err
 }
 
 // Write a file given a name and a byte stream
diff --git a/settings/settings.go b/settings/settings.go
index 733b974..a7700aa 100644
--- a/settings/settings.go
+++ b/settings/settings.go
@@ -1,14 +1,14 @@
 package settings
 
 import (
-	"gopkg.in/yaml.v2"
 	"os"
 	"time"
+
+	yaml "gopkg.in/yaml.v2"
 )
 
 // Settings defines a group of general settings
 type Settings struct {
-	Colors    `yaml:"-"`
 	Config    `yaml:",inline" json:"config"`
 	Resources `yaml:"resources" json:"resources"`
 	Server    `yaml:"server,omitempty" json:"server,omitempty"`
diff --git a/settings/utils.go b/settings/utils.go
index f1af11d..88ee87a 100644
--- a/settings/utils.go
+++ b/settings/utils.go
@@ -5,6 +5,8 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+
+	"github.com/tockins/realize/style"
 )
 
 // Wdir return the current working directory
@@ -25,7 +27,7 @@ func (s Settings) Validate(err error) error {
 // Fatal prints a fatal error with its additional messages
 func (s Settings) Fatal(err error, msg ...interface{}) {
 	if len(msg) > 0 && err != nil {
-		log.Fatalln(s.Red.Regular(msg...), err.Error())
+		log.Fatalln(style.Red.Regular(msg...), err.Error())
 	} else if err != nil {
 		log.Fatalln(err.Error())
 	}
diff --git a/style/style.go b/style/style.go
new file mode 100644
index 0000000..32f8181
--- /dev/null
+++ b/style/style.go
@@ -0,0 +1,24 @@
+package style
+
+import (
+	"github.com/fatih/color"
+)
+
+type colorBase color.Attribute
+
+func (s colorBase) Regular(a ...interface{}) string {
+	return color.New(color.Attribute(s)).Sprint(a...)
+}
+
+func (s colorBase) Bold(a ...interface{}) string {
+	return color.New(color.Attribute(s), color.Bold).Sprint(a...)
+}
+
+// allowed colors
+var (
+	Red     = colorBase(color.FgRed)
+	Blue    = colorBase(color.FgBlue)
+	Yellow  = colorBase(color.FgYellow)
+	Magenta = colorBase(color.FgMagenta)
+	Green   = colorBase(color.FgGreen)
+)
diff --git a/watcher/cmd.go b/watcher/cmd.go
index 450b3d6..5f88012 100644
--- a/watcher/cmd.go
+++ b/watcher/cmd.go
@@ -1,10 +1,12 @@
-package cli
+package watcher
 
 import (
 	"errors"
 	"fmt"
-	"gopkg.in/urfave/cli.v2"
 	"strings"
+
+	"github.com/tockins/realize/style"
+	cli "gopkg.in/urfave/cli.v2"
 )
 
 // Run launches the toolchain for each project
@@ -80,7 +82,7 @@ func (h *Blueprint) Remove(p *cli.Context) error {
 			return nil
 		}
 	}
-	return errors.New("No project found.")
+	return errors.New("no project found")
 }
 
 // List of all the projects
@@ -88,49 +90,49 @@ func (h *Blueprint) List() error {
 	err := h.check()
 	if err == nil {
 		for _, val := range h.Projects {
-			fmt.Println(h.Blue.Bold("[") + strings.ToUpper(val.Name) + h.Blue.Bold("]"))
-			name := h.Magenta.Bold("[") + strings.ToUpper(val.Name) + h.Magenta.Bold("]")
+			fmt.Println(style.Blue.Bold("[") + strings.ToUpper(val.Name) + style.Blue.Bold("]"))
+			name := style.Magenta.Bold("[") + strings.ToUpper(val.Name) + style.Magenta.Bold("]")
 
-			fmt.Println(name, h.Yellow.Regular("Base Path"), ":", h.Magenta.Regular(val.Path))
-			fmt.Println(name, h.Yellow.Regular("Fmt"), ":", h.Magenta.Regular(val.Fmt))
-			fmt.Println(name, h.Yellow.Regular("Generate"), ":", h.Magenta.Regular(val.Generate))
-			fmt.Println(name, h.Yellow.Regular("Test"), ":", h.Magenta.Regular(val.Test))
-			fmt.Println(name, h.Yellow.Regular("Install"), ":", h.Magenta.Regular(val.Bin))
-			fmt.Println(name, h.Yellow.Regular("Build"), ":", h.Magenta.Regular(val.Build))
-			fmt.Println(name, h.Yellow.Regular("Run"), ":", h.Magenta.Regular(val.Run))
+			fmt.Println(name, style.Yellow.Regular("Base Path"), ":", style.Magenta.Regular(val.Path))
+			fmt.Println(name, style.Yellow.Regular("Fmt"), ":", style.Magenta.Regular(val.Fmt))
+			fmt.Println(name, style.Yellow.Regular("Generate"), ":", style.Magenta.Regular(val.Generate))
+			fmt.Println(name, style.Yellow.Regular("Test"), ":", style.Magenta.Regular(val.Test))
+			fmt.Println(name, style.Yellow.Regular("Install"), ":", style.Magenta.Regular(val.Bin))
+			fmt.Println(name, style.Yellow.Regular("Build"), ":", style.Magenta.Regular(val.Build))
+			fmt.Println(name, style.Yellow.Regular("Run"), ":", style.Magenta.Regular(val.Run))
 			if len(val.Params) > 0 {
-				fmt.Println(name, h.Yellow.Regular("Params"), ":", h.Magenta.Regular(val.Params))
+				fmt.Println(name, style.Yellow.Regular("Params"), ":", style.Magenta.Regular(val.Params))
 			}
-			fmt.Println(name, h.Yellow.Regular("Watcher"), ":")
-			fmt.Println(name, "\t", h.Yellow.Regular("Preview"), ":", h.Magenta.Regular(val.Watcher.Preview))
+			fmt.Println(name, style.Yellow.Regular("Watcher"), ":")
+			fmt.Println(name, "\t", style.Yellow.Regular("Preview"), ":", style.Magenta.Regular(val.Watcher.Preview))
 			if len(val.Watcher.Exts) > 0 {
-				fmt.Println(name, "\t", h.Yellow.Regular("Extensions"), ":", h.Magenta.Regular(val.Watcher.Exts))
+				fmt.Println(name, "\t", style.Yellow.Regular("Extensions"), ":", style.Magenta.Regular(val.Watcher.Exts))
 			}
 			if len(val.Watcher.Paths) > 0 {
-				fmt.Println(name, "\t", h.Yellow.Regular("Paths"), ":", h.Magenta.Regular(val.Watcher.Paths))
+				fmt.Println(name, "\t", style.Yellow.Regular("Paths"), ":", style.Magenta.Regular(val.Watcher.Paths))
 			}
 			if len(val.Watcher.Ignore) > 0 {
-				fmt.Println(name, "\t", h.Yellow.Regular("Ignored paths"), ":", h.Magenta.Regular(val.Watcher.Ignore))
+				fmt.Println(name, "\t", style.Yellow.Regular("Ignored paths"), ":", style.Magenta.Regular(val.Watcher.Ignore))
 			}
 			if len(val.Watcher.Scripts) > 0 {
-				fmt.Println(name, "\t", h.Yellow.Regular("Scripts"), ":")
+				fmt.Println(name, "\t", style.Yellow.Regular("Scripts"), ":")
 				for _, v := range val.Watcher.Scripts {
 					if v.Command != "" {
-						fmt.Println(name, "\t\t", h.Magenta.Regular("-"), h.Yellow.Regular("Command"), ":", h.Magenta.Regular(v.Command))
+						fmt.Println(name, "\t\t", style.Magenta.Regular("-"), style.Yellow.Regular("Command"), ":", style.Magenta.Regular(v.Command))
 						if v.Path != "" {
-							fmt.Println(name, "\t\t", h.Yellow.Regular("Path"), ":", h.Magenta.Regular(v.Path))
+							fmt.Println(name, "\t\t", style.Yellow.Regular("Path"), ":", style.Magenta.Regular(v.Path))
 						}
 						if v.Type != "" {
-							fmt.Println(name, "\t\t", h.Yellow.Regular("Type"), ":", h.Magenta.Regular(v.Type))
+							fmt.Println(name, "\t\t", style.Yellow.Regular("Type"), ":", style.Magenta.Regular(v.Type))
 						}
 					}
 				}
 			}
-			fmt.Println(name, h.Yellow.Regular("Streams"), ":")
-			fmt.Println(name, "\t", h.Yellow.Regular("Cli Out"), ":", h.Magenta.Regular(val.Streams.CliOut))
-			fmt.Println(name, "\t", h.Yellow.Regular("File Out"), ":", h.Magenta.Regular(val.Streams.FileOut))
-			fmt.Println(name, "\t", h.Yellow.Regular("File Log"), ":", h.Magenta.Regular(val.Streams.FileLog))
-			fmt.Println(name, "\t", h.Yellow.Regular("File Err"), ":", h.Magenta.Regular(val.Streams.FileErr))
+			fmt.Println(name, style.Yellow.Regular("Streams"), ":")
+			fmt.Println(name, "\t", style.Yellow.Regular("Cli Out"), ":", style.Magenta.Regular(val.Streams.CliOut))
+			fmt.Println(name, "\t", style.Yellow.Regular("File Out"), ":", style.Magenta.Regular(val.Streams.FileOut))
+			fmt.Println(name, "\t", style.Yellow.Regular("File Log"), ":", style.Magenta.Regular(val.Streams.FileLog))
+			fmt.Println(name, "\t", style.Yellow.Regular("File Err"), ":", style.Magenta.Regular(val.Streams.FileErr))
 		}
 		return nil
 	}
@@ -143,5 +145,5 @@ func (h *Blueprint) check() error {
 		h.Clean()
 		return nil
 	}
-	return errors.New("There are no projects. The config file is empty.")
+	return errors.New("there are no projects")
 }
diff --git a/watcher/exec.go b/watcher/exec.go
index d197576..2797c88 100644
--- a/watcher/exec.go
+++ b/watcher/exec.go
@@ -1,4 +1,4 @@
-package cli
+package watcher
 
 import (
 	"bufio"
@@ -11,6 +11,8 @@ import (
 	"strings"
 	"sync"
 	"time"
+
+	"github.com/tockins/realize/style"
 )
 
 // GoRun  is an implementation of the bin execution
@@ -46,7 +48,7 @@ func (p *Project) goRun(channel chan bool, runner chan bool, wr *sync.WaitGroup)
 			p.Buffer.StdLog = append(p.Buffer.StdLog, BufferOut{Time: time.Now(), Text: "Failed to stop: " + err.Error()})
 			p.Fatal(err, "Failed to stop", ":")
 		}
-		msg := fmt.Sprintln(p.pname(p.Name, 2), ":", p.Red.Regular("Ended"))
+		msg := fmt.Sprintln(p.pname(p.Name, 2), ":", style.Red.Regular("Ended"))
 		out := BufferOut{Time: time.Now(), Text: "Ended", Type: "Go Run"}
 		p.print("log", out, msg, "")
 		wr.Done()
@@ -55,11 +57,11 @@ func (p *Project) goRun(channel chan bool, runner chan bool, wr *sync.WaitGroup)
 	stdout, err := build.StdoutPipe()
 	stderr, err := build.StderrPipe()
 	if err != nil {
-		log.Println(p.Red.Bold(err.Error()))
+		log.Println(style.Red.Bold(err.Error()))
 		return err
 	}
 	if err := build.Start(); err != nil {
-		log.Println(p.Red.Bold(err.Error()))
+		log.Println(style.Red.Bold(err.Error()))
 		return err
 	}
 	close(runner)
@@ -70,7 +72,7 @@ func (p *Project) goRun(channel chan bool, runner chan bool, wr *sync.WaitGroup)
 		for output.Scan() {
 			select {
 			default:
-				msg := fmt.Sprintln(p.pname(p.Name, 3), ":", p.Blue.Regular(output.Text()))
+				msg := fmt.Sprintln(p.pname(p.Name, 3), ":", style.Blue.Regular(output.Text()))
 				if isError {
 					out := BufferOut{Time: time.Now(), Text: output.Text(), Type: "Go Run"}
 					p.print("error", out, msg, "")
diff --git a/watcher/main.go b/watcher/main.go
index ba5c367..2364b4e 100644
--- a/watcher/main.go
+++ b/watcher/main.go
@@ -1,10 +1,11 @@
-package cli
+package watcher
 
 import (
-	c "github.com/tockins/realize/settings"
 	"log"
 	"sync"
 	"time"
+
+	"github.com/tockins/realize/settings"
 )
 
 var wg sync.WaitGroup
@@ -21,35 +22,34 @@ type pollWatcher struct {
 
 // Log struct
 type logWriter struct {
-	c.Colors
 }
 
 // Blueprint struct contains a projects list
 type Blueprint struct {
-	*c.Settings `yaml:"-"`
-	Projects    []Project   `yaml:"projects,omitempty" json:"projects,omitempty"`
-	Sync        chan string `yaml:"-"`
+	*settings.Settings `yaml:"-"`
+	Projects           []Project   `yaml:"projects,omitempty" json:"projects,omitempty"`
+	Sync               chan string `yaml:"-"`
 }
 
 // Project defines the informations of a single project
 type Project struct {
-	c.Settings    `yaml:"-"`
-	LastChangedOn time.Time `yaml:"-" json:"-"`
-	base          string
-	Name          string   `yaml:"name" json:"name"`
-	Path          string   `yaml:"path" json:"path"`
-	Fmt           bool     `yaml:"fmt" json:"fmt"`
-	Generate      bool     `yaml:"generate" json:"generate"`
-	Test          bool     `yaml:"test" json:"test"`
-	Bin           bool     `yaml:"bin" json:"bin"`
-	Build         bool     `yaml:"build" json:"build"`
-	Run           bool     `yaml:"run" json:"run"`
-	Params        []string `yaml:"params,omitempty" json:"params,omitempty"`
-	Watcher       Watcher  `yaml:"watcher" json:"watcher"`
-	Streams       Streams  `yaml:"streams" json:"streams"`
-	Buffer        Buffer   `yaml:"-" json:"buffer"`
-	parent        *Blueprint
-	path          string
+	settings.Settings `yaml:"-"`
+	LastChangedOn     time.Time `yaml:"-" json:"-"`
+	base              string
+	Name              string   `yaml:"name" json:"name"`
+	Path              string   `yaml:"path" json:"path"`
+	Fmt               bool     `yaml:"fmt" json:"fmt"`
+	Generate          bool     `yaml:"generate" json:"generate"`
+	Test              bool     `yaml:"test" json:"test"`
+	Bin               bool     `yaml:"bin" json:"bin"`
+	Build             bool     `yaml:"build" json:"build"`
+	Run               bool     `yaml:"run" json:"run"`
+	Params            []string `yaml:"params,omitempty" json:"params,omitempty"`
+	Watcher           Watcher  `yaml:"watcher" json:"watcher"`
+	Streams           Streams  `yaml:"streams" json:"streams"`
+	Buffer            Buffer   `yaml:"-" json:"buffer"`
+	parent            *Blueprint
+	path              string
 }
 
 // Watcher struct defines the livereload's logic
diff --git a/watcher/utils.go b/watcher/utils.go
index 659feb4..9535a2d 100644
--- a/watcher/utils.go
+++ b/watcher/utils.go
@@ -1,10 +1,12 @@
-package cli
+package watcher
 
 import (
 	"errors"
 	"fmt"
-	"gopkg.in/urfave/cli.v2"
 	"time"
+
+	"github.com/tockins/realize/style"
+	cli "gopkg.in/urfave/cli.v2"
 )
 
 // Argsparam parse one by one the given argumentes
@@ -23,7 +25,7 @@ func argsParam(params *cli.Context) []string {
 // Duplicates check projects with same name or same combinations of main/path
 func duplicates(value Project, arr []Project) (Project, error) {
 	for _, val := range arr {
-		if value.Path == val.Path {
+		if value.Path == val.Path && val.Name == value.Name {
 			return val, errors.New("There is already a project for '" + val.Path + "'. Check your config file!")
 		}
 	}
@@ -42,5 +44,5 @@ func inArray(str string, list []string) bool {
 
 // Rewrite the layout of the log timestamp
 func (w logWriter) Write(bytes []byte) (int, error) {
-	return fmt.Print(w.Yellow.Regular("[") + time.Now().Format("15:04:05") + w.Yellow.Regular("]") + string(bytes))
+	return fmt.Print(style.Yellow.Regular("[") + time.Now().Format("15:04:05") + style.Yellow.Regular("]") + string(bytes))
 }
diff --git a/watcher/watcher.go b/watcher/watcher.go
index f725c3f..b7e16ba 100644
--- a/watcher/watcher.go
+++ b/watcher/watcher.go
@@ -1,9 +1,8 @@
-package cli
+package watcher
 
 import (
 	"errors"
 	"fmt"
-	"github.com/fsnotify/fsnotify"
 	"log"
 	"math/big"
 	"os"
@@ -14,6 +13,9 @@ import (
 	"sync"
 	"syscall"
 	"time"
+
+	"github.com/fsnotify/fsnotify"
+	"github.com/tockins/realize/style"
 )
 
 var msg string
@@ -71,7 +73,7 @@ func (p *Project) watchByPolling() {
 			}
 			p.LastChangedOn = time.Now().Truncate(time.Second)
 			// repeat the initial cycle
-			msg = fmt.Sprintln(p.pname(p.Name, 4), ":", p.Magenta.Bold(strings.ToUpper(ext[1:])+" changed"), p.Magenta.Bold(file))
+			msg = fmt.Sprintln(p.pname(p.Name, 4), ":", style.Magenta.Bold(strings.ToUpper(ext[1:])+" changed"), style.Magenta.Bold(file))
 			out = BufferOut{Time: time.Now(), Text: strings.ToUpper(ext[1:]) + " changed " + file}
 			p.print("log", out, msg, "")
 
@@ -88,7 +90,7 @@ func (p *Project) watchByPolling() {
 			base := filepath.Join(p.base, dir)
 			if _, err := os.Stat(base); err == nil {
 				if err := filepath.Walk(base, walk); err != nil {
-					msg = fmt.Sprintln(p.pname(p.Name, 2), ":", p.Red.Regular(err.Error()))
+					msg = fmt.Sprintln(p.pname(p.Name, 2), ":", style.Red.Regular(err.Error()))
 					out = BufferOut{Time: time.Now(), Text: err.Error()}
 					p.print("error", out, msg, "")
 				}
@@ -147,7 +149,7 @@ func (p *Project) watchByNotify() {
 						}
 						p.LastChangedOn = time.Now().Truncate(time.Second)
 						// repeat the initial cycle
-						msg = fmt.Sprintln(p.pname(p.Name, 4), ":", p.Magenta.Bold(strings.ToUpper(ext[1:])+" changed"), p.Magenta.Bold(file))
+						msg = fmt.Sprintln(p.pname(p.Name, 4), ":", style.Magenta.Bold(strings.ToUpper(ext[1:])+" changed"), style.Magenta.Bold(file))
 						out = BufferOut{Time: time.Now(), Text: strings.ToUpper(ext[1:]) + " changed " + file}
 						p.print("log", out, msg, "")
 
@@ -160,7 +162,7 @@ func (p *Project) watchByNotify() {
 				}
 			}
 		case err := <-watcher.Errors:
-			msg = fmt.Sprintln(p.pname(p.Name, 2), ":", p.Red.Regular(err.Error()))
+			msg = fmt.Sprintln(p.pname(p.Name, 2), ":", style.Red.Regular(err.Error()))
 			out = BufferOut{Time: time.Now(), Text: err.Error()}
 			p.print("error", out, msg, "")
 		case <-exit:
@@ -206,13 +208,13 @@ func (p *Project) watch(watcher watcher) error {
 		base := filepath.Join(p.base, dir)
 		if _, err := os.Stat(base); err == nil {
 			if err := filepath.Walk(base, walk); err != nil {
-				log.Println(p.Red.Bold(err.Error()))
+				log.Println(style.Red.Bold(err.Error()))
 			}
 		} else {
 			return errors.New(base + " path doesn't exist")
 		}
 	}
-	msg = fmt.Sprintln(p.pname(p.Name, 1), ":", p.Blue.Bold("Watching"), p.Magenta.Bold(files), "file/s", p.Magenta.Bold(folders), "folder/s")
+	msg = fmt.Sprintln(p.pname(p.Name, 1), ":", style.Blue.Bold("Watching"), style.Magenta.Bold(files), "file/s", style.Magenta.Bold(folders), "folder/s")
 	out = BufferOut{Time: time.Now(), Text: "Watching " + strconv.FormatInt(files, 10) + " files/s " + strconv.FormatInt(folders, 10) + " folder/s"}
 	p.print("log", out, msg, "")
 	return nil
@@ -225,11 +227,11 @@ func (p *Project) install() error {
 		log.Println(p.pname(p.Name, 1), ":", "Installing..")
 		stream, err := p.goInstall()
 		if err != nil {
-			msg = fmt.Sprintln(p.pname(p.Name, 2), ":", p.Red.Bold("Go Install"), p.Red.Regular(err.Error()))
+			msg = fmt.Sprintln(p.pname(p.Name, 2), ":", style.Red.Bold("Go Install"), style.Red.Regular(err.Error()))
 			out = BufferOut{Time: time.Now(), Text: err.Error(), Type: "Go Install", Stream: stream}
 			p.print("error", out, msg, stream)
 		} else {
-			msg = fmt.Sprintln(p.pname(p.Name, 5), ":", p.Green.Regular("Installed")+" after", p.Magenta.Regular(big.NewFloat(float64(time.Since(start).Seconds())).Text('f', 3), " s"))
+			msg = fmt.Sprintln(p.pname(p.Name, 5), ":", style.Green.Regular("Installed")+" after", style.Magenta.Regular(big.NewFloat(float64(time.Since(start).Seconds())).Text('f', 3), " s"))
 			out = BufferOut{Time: time.Now(), Text: "Installed after " + big.NewFloat(float64(time.Since(start).Seconds())).Text('f', 3) + " s"}
 			p.print("log", out, msg, stream)
 		}
@@ -248,7 +250,7 @@ func (p *Project) run(channel chan bool, wr *sync.WaitGroup) {
 		for {
 			select {
 			case <-runner:
-				msg = fmt.Sprintln(p.pname(p.Name, 5), ":", p.Green.Regular("Has been run")+" after", p.Magenta.Regular(big.NewFloat(float64(time.Since(start).Seconds())).Text('f', 3), " s"))
+				msg = fmt.Sprintln(p.pname(p.Name, 5), ":", style.Green.Regular("Has been run")+" after", style.Magenta.Regular(big.NewFloat(float64(time.Since(start).Seconds())).Text('f', 3), " s"))
 				out = BufferOut{Time: time.Now(), Text: "Has been run after " + big.NewFloat(float64(time.Since(start).Seconds())).Text('f', 3) + " s"}
 				p.print("log", out, msg, "")
 				return
@@ -264,11 +266,11 @@ func (p *Project) build() error {
 		log.Println(p.pname(p.Name, 1), ":", "Building..")
 		stream, err := p.goBuild()
 		if err != nil {
-			msg = fmt.Sprintln(p.pname(p.Name, 2), ":", p.Red.Bold("Go Build"), p.Red.Regular(err.Error()))
+			msg = fmt.Sprintln(p.pname(p.Name, 2), ":", style.Red.Bold("Go Build"), style.Red.Regular(err.Error()))
 			out = BufferOut{Time: time.Now(), Text: err.Error(), Type: "Go Build", Stream: stream}
 			p.print("error", out, msg, stream)
 		} else {
-			msg = fmt.Sprintln(p.pname(p.Name, 5), ":", p.Green.Regular("Builded")+" after", p.Magenta.Regular(big.NewFloat(float64(time.Since(start).Seconds())).Text('f', 3), " s"))
+			msg = fmt.Sprintln(p.pname(p.Name, 5), ":", style.Green.Regular("Builded")+" after", style.Magenta.Regular(big.NewFloat(float64(time.Since(start).Seconds())).Text('f', 3), " s"))
 			out = BufferOut{Time: time.Now(), Text: "Builded after " + big.NewFloat(float64(time.Since(start).Seconds())).Text('f', 3) + " s"}
 			p.print("log", out, msg, stream)
 		}
@@ -281,7 +283,7 @@ func (p *Project) build() error {
 func (p *Project) fmt(path string) error {
 	if p.Fmt && strings.HasSuffix(path, ".go") {
 		if stream, err := p.goTools(p.base, "gofmt", "-s", "-w", "-e", path); err != nil {
-			msg = fmt.Sprintln(p.pname(p.Name, 2), ":", p.Red.Bold("Go Fmt"), p.Red.Regular("there are some errors in"), ":", p.Magenta.Bold(path))
+			msg = fmt.Sprintln(p.pname(p.Name, 2), ":", style.Red.Bold("Go Fmt"), style.Red.Regular("there are some errors in"), ":", style.Magenta.Bold(path))
 			out = BufferOut{Time: time.Now(), Text: "there are some errors in", Path: path, Type: "Go Fmt", Stream: stream}
 			p.print("error", out, msg, stream)
 			return err
@@ -294,7 +296,7 @@ func (p *Project) fmt(path string) error {
 func (p *Project) generate(path string) error {
 	if p.Generate {
 		if stream, err := p.goTools(path, "go", "generate"); err != nil {
-			msg = fmt.Sprintln(p.pname(p.Name, 2), ":", p.Red.Bold("Go Generate"), p.Red.Regular("there are some errors in"), ":", p.Magenta.Bold(path))
+			msg = fmt.Sprintln(p.pname(p.Name, 2), ":", style.Red.Bold("Go Generate"), style.Red.Regular("there are some errors in"), ":", style.Magenta.Bold(path))
 			out = BufferOut{Time: time.Now(), Text: "there are some errors in", Path: path, Type: "Go Generate", Stream: stream}
 			p.print("error", out, msg, stream)
 			return err
@@ -307,7 +309,7 @@ func (p *Project) generate(path string) error {
 func (p *Project) test(path string) error {
 	if p.Test {
 		if stream, err := p.goTools(path, "go", "test"); err != nil {
-			msg = fmt.Sprintln(p.pname(p.Name, 2), ":", p.Red.Bold("Go Test"), p.Red.Regular("there are some errors in "), ":", p.Magenta.Bold(path))
+			msg = fmt.Sprintln(p.pname(p.Name, 2), ":", style.Red.Bold("Go Test"), style.Red.Regular("there are some errors in "), ":", style.Magenta.Bold(path))
 			out = BufferOut{Time: time.Now(), Text: "there are some errors in", Path: path, Type: "Go Test", Stream: stream}
 			p.print("error", out, msg, stream)
 			return err
@@ -321,7 +323,7 @@ func (p *Project) cmd(flag string) {
 	for _, cmd := range p.Watcher.Scripts {
 		if strings.ToLower(cmd.Type) == flag {
 			errors, logs := p.command(cmd)
-			msg = fmt.Sprintln(p.pname(p.Name, 5), ":", p.Green.Bold("Command"), p.Green.Bold("\"")+cmd.Command+p.Green.Bold("\""))
+			msg = fmt.Sprintln(p.pname(p.Name, 5), ":", style.Green.Bold("Command"), style.Green.Bold("\"")+cmd.Command+style.Green.Bold("\""))
 			out = BufferOut{Time: time.Now(), Text: cmd.Command, Type: flag}
 			if logs != "" {
 				p.print("log", out, msg, "")
@@ -335,7 +337,7 @@ func (p *Project) cmd(flag string) {
 				p.print("log", out, "", msg)
 			}
 			if errors != "" {
-				msg = fmt.Sprintln(p.Red.Regular(errors))
+				msg = fmt.Sprintln(style.Red.Regular(errors))
 				out = BufferOut{Time: time.Now(), Text: errors, Type: flag}
 				p.print("error", out, "", msg)
 			}
@@ -368,19 +370,19 @@ func (p *Project) routines(channel chan bool, wr *sync.WaitGroup) {
 func (p *Project) pname(name string, color int) string {
 	switch color {
 	case 1:
-		name = p.Yellow.Regular("[") + strings.ToUpper(name) + p.Yellow.Regular("]")
+		name = style.Yellow.Regular("[") + strings.ToUpper(name) + style.Yellow.Regular("]")
 		break
 	case 2:
-		name = p.Yellow.Regular("[") + p.Red.Bold(strings.ToUpper(name)) + p.Yellow.Regular("]")
+		name = style.Yellow.Regular("[") + style.Red.Bold(strings.ToUpper(name)) + style.Yellow.Regular("]")
 		break
 	case 3:
-		name = p.Yellow.Regular("[") + p.Blue.Bold(strings.ToUpper(name)) + p.Yellow.Regular("]")
+		name = style.Yellow.Regular("[") + style.Blue.Bold(strings.ToUpper(name)) + style.Yellow.Regular("]")
 		break
 	case 4:
-		name = p.Yellow.Regular("[") + p.Magenta.Bold(strings.ToUpper(name)) + p.Yellow.Regular("]")
+		name = style.Yellow.Regular("[") + style.Magenta.Bold(strings.ToUpper(name)) + style.Yellow.Regular("]")
 		break
 	case 5:
-		name = p.Yellow.Regular("[") + p.Green.Bold(strings.ToUpper(name)) + p.Yellow.Regular("]")
+		name = style.Yellow.Regular("[") + style.Green.Bold(strings.ToUpper(name)) + style.Yellow.Regular("]")
 		break
 	}
 	return name