diff --git a/cmd.go b/cmd.go
index 88345269..15e9dfac 100644
--- a/cmd.go
+++ b/cmd.go
@@ -579,8 +579,8 @@ func numberMenu(pkgS []string, flags []string) (err error) {
 		aurQ.printSearch(numpq + 1)
 	}
 
-	fmt.Println(boldGreenFg(arrow) + boldGreenFg(" Packages to not upgrade (eg: 1 2 3, 1-3 or ^4)"))
-	fmt.Print(boldGreenFg(arrow + " "))
+	fmt.Println(bold(green(arrow + " Packages to install (eg: 1 2 3, 1-3 or ^4)")))
+	fmt.Print(bold(green(arrow + " ")))
 	reader := bufio.NewReader(os.Stdin)
 	numberBuf, overflow, err := reader.ReadLine()
 	if err != nil || overflow {
diff --git a/config.go b/config.go
index da5c6f63..b5101890 100644
--- a/config.go
+++ b/config.go
@@ -142,12 +142,12 @@ func editor() string {
 		}
 		fallthrough
 	default:
-		fmt.Println(boldRedFgBlackBg("Warning:"),
-			boldYellowFgBlackBg("$EDITOR"), whiteFgBlackBg("is not set"))
+		fmt.Println(bold(red("Warning:")),
+			bold(magenta("$EDITOR")), "is not set")
 		fmt.Println("Please add $EDITOR or to your environment variables.")
 
 	editorLoop:
-		fmt.Print(greenFg("Edit PKGBUILD with:"))
+		fmt.Print(green("Edit PKGBUILD with:"))
 		var editorInput string
 		_, err := fmt.Scanln(&editorInput)
 		if err != nil {
@@ -179,7 +179,7 @@ func continueTask(s string, def string) (cont bool) {
 	}
 
 	var response string
-	fmt.Print(boldGreenFg(arrow+" "+s+" "), boldWhiteFg(postFix))
+	fmt.Print(bold(green(arrow+" "+s+" ")), bold(postFix))
 
 	n, err := fmt.Scanln(&response)
 	if err != nil || n == 0 {
diff --git a/download.go b/download.go
index 090f7330..bccbdf85 100644
--- a/download.go
+++ b/download.go
@@ -101,10 +101,10 @@ nextPkg:
 
 				errD := downloadAndUnpack(url, path, true)
 				if errD != nil {
-					fmt.Println(boldYellowFg(pkg.Name()), boldGreenFg(errD.Error()))
+					fmt.Println(bold(magenta(pkg.Name())), bold(green(errD.Error())))
 				}
 
-				fmt.Println(boldGreenFg(arrow), boldGreenFg("Downloaded"), boldYellowFg(pkg.Name()), boldGreenFg("from ABS"))
+				fmt.Println(bold(green(arrow)), bold(green("Downloaded")), bold(magenta(pkg.Name())), bold(green("from ABS")))
 				continue nextPkg
 			}
 		}
@@ -124,7 +124,7 @@ func getPkgbuildsfromAUR(pkgs []string, dir string) (err error) {
 
 	for _, pkg := range aq {
 		downloadAndUnpack(baseURL+aq[0].URLPath, dir, false)
-		fmt.Println(boldGreenFg(arrow), boldGreenFg("Downloaded"), boldYellowFg(pkg.Name), boldGreenFg("from AUR"))
+		fmt.Println(bold(green(arrow)), bold(green("Downloaded")), bold(magenta(pkg.Name)), bold(green("from AUR")))
 	}
 
 	return
diff --git a/install.go b/install.go
index 799c4bb0..930e4cd3 100644
--- a/install.go
+++ b/install.go
@@ -24,7 +24,7 @@ func install(parser *arguments) error {
 	srcinfos := make(map[string]*gopkg.PKGBUILD)
 	var dc *depCatagories
 
-	//fmt.Println(greenFg(arrow), greenFg("Resolving Dependencies"))
+	//fmt.Println(green(arrow), green("Resolving Dependencies"))
 	requestTargets := append(aurTargets, repoTargets...)
 
 	//remotenames: names of all non repo packages on the system
@@ -46,7 +46,7 @@ func install(parser *arguments) error {
 	}
 
 	if len(aurTargets) > 0 || parser.existsArg("u", "sysupgrade") && len(remoteNames) > 0 {
-		fmt.Println(boldCyanFg("::"), boldFg("Querying AUR..."))
+		fmt.Println(bold(cyan("::") + " Querying AUR..."))
 	}
 	dt, err := getDepTree(requestTargets)
 	if err != nil {
@@ -56,8 +56,8 @@ func install(parser *arguments) error {
 	//only error if direct targets or deps are missing
 	for missingName := range dt.Missing {
 		if !remoteNamesCache.get(missingName) {
-			return fmt.Errorf(boldRedFgBlackBg(arrow+" Error: ") +
-				blackBg("Could not find all required package"))
+			return fmt.Errorf(bold(red(arrow+" Error: ")) +
+				"Could not find all required package")
 		}
 	}
 
@@ -192,7 +192,7 @@ func install(parser *arguments) error {
 				return err
 			}
 
-			fmt.Println(boldGreenFg(arrow + " GenDB finished. No packages were installed"))
+			fmt.Println(bold(green(arrow + " GenDB finished. No packages were installed")))
 			return nil
 		}
 
@@ -298,11 +298,11 @@ func checkForConflicts(dc *depCatagories) error {
 
 	if len(toRemove) != 0 {
 		fmt.Println(
-			redFg("Package conflicts found:"))
+			red("Package conflicts found:"))
 		for name, pkgs := range toRemove {
-			str := "\tInstalling " + yellowFg(name) + " will remove"
+			str := "\tInstalling " + magenta(name) + " will remove"
 			for pkg := range pkgs {
-				str += " " + yellowFg(pkg)
+				str += " " + magenta(pkg)
 			}
 
 			fmt.Println(str)
@@ -356,7 +356,7 @@ func parsesrcinfosFile(pkgs []*rpc.Pkg, srcinfos map[string]*gopkg.PKGBUILD, bas
 	for k, pkg := range pkgs {
 		dir := config.BuildDir + pkg.PackageBase + "/"
 
-		str := boldCyanFg("::") + boldFg(" Parsing SRCINFO (%d/%d): %s\n")
+		str := bold(cyan("::") + " Parsing SRCINFO (%d/%d): %s\n")
 		fmt.Printf(str, k+1, len(pkgs), formatPkgbase(pkg, bases))
 
 		pkgbuild, err := gopkg.ParseSRCINFO(dir + ".SRCINFO")
@@ -375,7 +375,7 @@ func parsesrcinfosGenerate(pkgs []*rpc.Pkg, srcinfos map[string]*gopkg.PKGBUILD,
 	for k, pkg := range pkgs {
 		dir := config.BuildDir + pkg.PackageBase + "/"
 
-		str := boldCyanFg("::") + boldFg(" Parsing SRCINFO (%d/%d): %s\n")
+		str := bold(cyan("::") + " Parsing SRCINFO (%d/%d): %s\n")
 		fmt.Printf(str, k+1, len(pkgs), formatPkgbase(pkg, bases))
 
 		cmd := exec.Command(config.MakepkgBin, "--printsrcinfo")
@@ -401,7 +401,7 @@ func parsesrcinfosGenerate(pkgs []*rpc.Pkg, srcinfos map[string]*gopkg.PKGBUILD,
 func dowloadPkgBuilds(pkgs []*rpc.Pkg, bases map[string][]*rpc.Pkg) (err error) {
 	for k, pkg := range pkgs {
 		//todo make pretty
-		str := boldCyanFg("::") + boldFg(" Downloading (%d/%d): %s\n")
+		str := bold(cyan("::") + " Downloading (%d/%d): %s\n")
 
 		fmt.Printf(str, k+1, len(pkgs), formatPkgbase(pkg, bases))
 
@@ -446,8 +446,8 @@ func buildInstallPkgBuilds(pkgs []*rpc.Pkg, srcinfos map[string]*gopkg.PKGBUILD,
 		}
 
 		if built {
-			fmt.Println(boldRedFgBlackBg(arrow+" Warning:"),
-				blackBg(pkg.Name+"-"+pkg.Version+" Already made -- skipping build"))
+			fmt.Println(bold(red(arrow+" Warning:")),
+				pkg.Name+"-"+pkg.Version+" Already made -- skipping build")
 		} else {
 			err := passToMakepkg(dir, "-Ccf", "--noconfirm")
 			if err != nil {
@@ -509,8 +509,8 @@ func clean(pkgs []*rpc.Pkg) {
 	for _, pkg := range pkgs {
 		dir := config.BuildDir + pkg.PackageBase + "/"
 
-		fmt.Println(boldGreenFg(arrow +
-			" CleanAfter enabled. Deleting " + pkg.Name + " source folder."))
+		fmt.Println(bold(green(arrow +
+			" CleanAfter enabled. Deleting " + pkg.Name + " source folder.")))
 		os.RemoveAll(dir)
 	}
 }
diff --git a/print.go b/print.go
index 483f3960..eb5d5159 100644
--- a/print.go
+++ b/print.go
@@ -5,6 +5,7 @@ import (
 	"os"
 	"strconv"
 	"strings"
+	"time"
 
 	alpm "github.com/jguer/go-alpm"
 	rpc "github.com/mikkeloscar/aur"
@@ -33,28 +34,30 @@ func (q aurQuery) printSearch(start int) {
 		var toprint string
 		if config.SearchMode == NumberMenu {
 			if config.SortMode == BottomUp {
-				toprint += yellowFg(strconv.Itoa(len(q)+start-i-1) + " ")
+				toprint += magenta(strconv.Itoa(len(q)+start-i-1) + " ")
 			} else {
-				toprint += yellowFg(strconv.Itoa(start+i) + " ")
+				toprint += magenta(strconv.Itoa(start+i) + " ")
 			}
 		} else if config.SearchMode == Minimal {
 			fmt.Println(res.Name)
 			continue
 		}
-		toprint += boldWhiteFg("aur/") + boldYellowFg(res.Name) +
-			" " + boldCyanFg(res.Version) +
-			" (" + strconv.Itoa(res.NumVotes) + ") "
+
+		toprint += bold(colourHash("aur")) + "/" + bold(res.Name) +
+			" " + cyan(res.Version) +
+			bold(" (+"+strconv.Itoa(res.NumVotes)) +
+			" " + bold(strconv.FormatFloat(res.Popularity, 'f', 2, 64)+"%) ")
 
 		if res.Maintainer == "" {
-			toprint += redFgBlackBg("(Orphaned)") + " "
+			toprint += bold(red("(Orphaned)")) + " "
 		}
 
 		if res.OutOfDate != 0 {
-			toprint += redFgBlackBg("(Out-of-date)") + " "
+			toprint += bold(red("(Out-of-date "+formatTime(res.OutOfDate)+")")) + " "
 		}
 
 		if _, err := localDb.PkgByName(res.Name); err == nil {
-			toprint += greenFgBlackBg("Installed")
+			toprint += bold(green("(Installed)"))
 		}
 		toprint += "\n    " + res.Description
 		fmt.Println(toprint)
@@ -67,16 +70,19 @@ func (s repoQuery) printSearch() {
 		var toprint string
 		if config.SearchMode == NumberMenu {
 			if config.SortMode == BottomUp {
-				toprint += yellowFg(strconv.Itoa(len(s)-i) + " ")
+				toprint += magenta(strconv.Itoa(len(s)-i) + " ")
 			} else {
-				toprint += yellowFg(strconv.Itoa(i+1) + " ")
+				toprint += magenta(strconv.Itoa(i+1) + " ")
 			}
 		} else if config.SearchMode == Minimal {
 			fmt.Println(res.Name())
 			continue
 		}
-		toprint += boldWhiteFg(res.DB().Name()+"/") + boldYellowFg(res.Name()) +
-			" " + boldCyanFg(res.Version()) + " "
+
+		toprint += bold(colourHash(res.DB().Name())) + "/" + bold(res.Name()) +
+			" " + cyan(res.Version()) +
+			bold(" ("+human(res.Size())+
+				" "+human(res.ISize())+") ")
 
 		if len(res.Groups().Slice()) != 0 {
 			toprint += fmt.Sprint(res.Groups().Slice(), " ")
@@ -85,7 +91,7 @@ func (s repoQuery) printSearch() {
 		localDb, err := alpmHandle.LocalDb()
 		if err == nil {
 			if _, err = localDb.PkgByName(res.Name()); err == nil {
-				toprint += greenFgBlackBg("Installed")
+				toprint += bold(green("(Installed)"))
 			}
 		}
 
@@ -183,29 +189,29 @@ func printDownloads(repoName string, length int, packages string) {
 		return
 	}
 
-	repoInfo := boldBlueFg(
-		"[" + repoName + ": " + strconv.Itoa(length) + "]")
-	fmt.Println(repoInfo + yellowFg(packages))
+	repoInfo := bold(blue(
+		"[" + repoName + ": " + strconv.Itoa(length) + "]"))
+	fmt.Println(repoInfo + magenta(packages))
 }
 
 // PrintInfo prints package info like pacman -Si.
 func PrintInfo(a *rpc.Pkg) {
-	fmt.Println(boldWhiteFg("Repository      :"), "aur")
-	fmt.Println(boldWhiteFg("Name            :"), a.Name)
-	fmt.Println(boldWhiteFg("Version         :"), a.Version)
-	fmt.Println(boldWhiteFg("Description     :"), a.Description)
-	fmt.Println(boldWhiteFg("URL             :"), a.URL)
-	fmt.Println(boldWhiteFg("Licenses        :"), strings.Join(a.License, "  "))
-	fmt.Println(boldWhiteFg("Depends On      :"), strings.Join(a.Depends, "  "))
-	fmt.Println(boldWhiteFg("Make Deps       :"), strings.Join(a.MakeDepends, "  "))
-	fmt.Println(boldWhiteFg("Check Deps      :"), strings.Join(a.CheckDepends, "  "))
-	fmt.Println(boldWhiteFg("Optional Deps   :"), strings.Join(a.OptDepends, "  "))
-	fmt.Println(boldWhiteFg("Conflicts With  :"), strings.Join(a.Conflicts, "  "))
-	fmt.Println(boldWhiteFg("Maintainer      :"), a.Maintainer)
-	fmt.Println(boldWhiteFg("Votes           :"), a.NumVotes)
-	fmt.Println(boldWhiteFg("Popularity      :"), a.Popularity)
+	fmt.Println(bold("Repository      :"), "aur")
+	fmt.Println(bold("Name            :"), a.Name)
+	fmt.Println(bold("Version         :"), a.Version)
+	fmt.Println(bold("Description     :"), a.Description)
+	fmt.Println(bold("URL             :"), a.URL)
+	fmt.Println(bold("Licenses        :"), strings.Join(a.License, "  "))
+	fmt.Println(bold("Depends On      :"), strings.Join(a.Depends, "  "))
+	fmt.Println(bold("Make Deps       :"), strings.Join(a.MakeDepends, "  "))
+	fmt.Println(bold("Check Deps      :"), strings.Join(a.CheckDepends, "  "))
+	fmt.Println(bold("Optional Deps   :"), strings.Join(a.OptDepends, "  "))
+	fmt.Println(bold("Conflicts With  :"), strings.Join(a.Conflicts, "  "))
+	fmt.Println(bold("Maintainer      :"), a.Maintainer)
+	fmt.Println(bold("Votes           :"), a.NumVotes)
+	fmt.Println(bold("Popularity      :"), a.Popularity)
 	if a.OutOfDate != 0 {
-		fmt.Println(boldWhiteFg("Out-of-date     :"), "Yes")
+		fmt.Println(bold("Out-of-date     :"), "Yes", "["+formatTime(a.OutOfDate)+"]")
 	}
 
 	fmt.Println()
@@ -226,7 +232,7 @@ func biggestPackages() {
 	}
 
 	for i := 0; i < 10; i++ {
-		fmt.Println(pkgS[i].Name() + ": " + yellowFg(human(pkgS[i].ISize())))
+		fmt.Println(bold(pkgS[i].Name()) + ": " + cyan(human(pkgS[i].ISize())))
 	}
 	// Could implement size here as well, but we just want the general idea
 }
@@ -243,16 +249,16 @@ func localStatistics() error {
 		return err
 	}
 
-	fmt.Printf("\n Yay version r%s\n", version)
-	fmt.Println(boldCyanFg("==========================================="))
-	fmt.Println(boldGreenFg("Total installed packages: ") + yellowFg(strconv.Itoa(info.Totaln)))
-	fmt.Println(boldGreenFg("Total foreign installed packages: ") + yellowFg(strconv.Itoa(len(remoteNames))))
-	fmt.Println(boldGreenFg("Explicitly installed packages: ") + yellowFg(strconv.Itoa(info.Expln)))
-	fmt.Println(boldGreenFg("Total Size occupied by packages: ") + yellowFg(human(info.TotalSize)))
-	fmt.Println(boldCyanFg("==========================================="))
-	fmt.Println(boldGreenFg("Ten biggest packages"))
+	fmt.Printf(bold("Yay version v%s\n"), version)
+	fmt.Println(bold(cyan("===========================================")))
+	fmt.Println(bold(green("Total installed packages: ")) + magenta(strconv.Itoa(info.Totaln)))
+	fmt.Println(bold(green("Total foreign installed packages: ")) + magenta(strconv.Itoa(len(remoteNames))))
+	fmt.Println(bold(green("Explicitly installed packages: ")) + magenta(strconv.Itoa(info.Expln)))
+	fmt.Println(bold(green("Total Size occupied by packages: ")) + magenta(human(info.TotalSize)))
+	fmt.Println(bold(cyan("===========================================")))
+	fmt.Println(bold(green("Ten biggest packages:")))
 	biggestPackages()
-	fmt.Println(boldCyanFg("==========================================="))
+	fmt.Println(bold(cyan("===========================================")))
 
 	aurInfo(remoteNames)
 
@@ -299,121 +305,74 @@ func printUpdateList() error {
 	return nil
 }
 
-func blackBg(in string) string {
+func formatTime(i int) string {
+	t := time.Unix(int64(i), 0)
+	return fmt.Sprintf("%d/%d/%d", t.Year(), int(t.Month()), t.Day())
+}
+
+func red(in string) string {
 	if alpmConf.Options&alpm.ConfColor > 0 {
-		return "\x1b[0;;40m" + in + "\x1b[0m"
+		return "\x1b[31m" + in + "\x1b[0m"
 	}
 
 	return in
 }
 
-func redFg(in string) string {
+func green(in string) string {
 	if alpmConf.Options&alpm.ConfColor > 0 {
-		return "\x1b[0;31m" + in + "\x1b[0m"
+		return "\x1b[32m" + in + "\x1b[0m"
 	}
 
 	return in
 }
 
-func greenFg(in string) string {
+func yellow(in string) string {
 	if alpmConf.Options&alpm.ConfColor > 0 {
-		return "\x1b[0;32m" + in + "\x1b[0m"
+		return "\x1b[33m" + in + "\x1b[0m"
 	}
 
 	return in
 }
 
-func yellowFg(in string) string {
+func blue(in string) string {
 	if alpmConf.Options&alpm.ConfColor > 0 {
-		return "\x1b[0;33m" + in + "\x1b[0m"
+		return "\x1b[34m" + in + "\x1b[0m"
 	}
 
 	return in
 }
 
-func boldFg(in string) string {
+func cyan(in string) string {
+	if alpmConf.Options&alpm.ConfColor > 0 {
+		return "\x1b[36m" + in + "\x1b[0m"
+	}
+
+	return in
+}
+
+func magenta(in string) string {
+	if alpmConf.Options&alpm.ConfColor > 0 {
+		return "\x1b[35m" + in + "\x1b[0m"
+	}
+
+	return in
+}
+
+func bold(in string) string {
 	if alpmConf.Options&alpm.ConfColor > 0 {
 		return "\x1b[1m" + in + "\x1b[0m"
 	}
 
 	return in
 }
-func boldGreenFg(in string) string {
-	if alpmConf.Options&alpm.ConfColor > 0 {
-		return "\x1b[1;32m" + in + "\x1b[0m"
+
+func colourHash(name string) (output string) {
+	if alpmConf.Options&alpm.ConfColor == 0 {
+		return name
 	}
-
-	return in
-}
-
-func boldYellowFg(in string) string {
-	if alpmConf.Options&alpm.ConfColor > 0 {
-		return "\x1b[1;33m" + in + "\x1b[0m"
+	var hash = 5381
+	for i := 0; i < len(name); i++ {
+		hash = int(name[i]) + ((hash << 5) + (hash))
 	}
-
-	return in
-}
-
-func boldBlueFg(in string) string {
-	if alpmConf.Options&alpm.ConfColor > 0 {
-		return "\x1b[1;34m" + in + "\x1b[0m"
-	}
-
-	return in
-}
-
-func boldCyanFg(in string) string {
-	if alpmConf.Options&alpm.ConfColor > 0 {
-		return "\x1b[1;36m" + in + "\x1b[0m"
-	}
-
-	return in
-}
-
-func boldWhiteFg(in string) string {
-	if alpmConf.Options&alpm.ConfColor > 0 {
-		return "\x1b[1;37m" + in + "\x1b[0m"
-	}
-
-	return in
-}
-
-func redFgBlackBg(in string) string {
-	if alpmConf.Options&alpm.ConfColor > 0 {
-		return "\x1b[0;31;40m" + in + "\x1b[0m"
-	}
-
-	return in
-}
-
-func greenFgBlackBg(in string) string {
-	if alpmConf.Options&alpm.ConfColor > 0 {
-		return "\x1b[0;32;40m" + in + "\x1b[0m"
-	}
-
-	return in
-}
-
-func whiteFgBlackBg(in string) string {
-	if alpmConf.Options&alpm.ConfColor > 0 {
-		return "\x1b[0;37;40m" + in + "\x1b[0m"
-	}
-
-	return in
-}
-
-func boldRedFgBlackBg(in string) string {
-	if alpmConf.Options&alpm.ConfColor > 0 {
-		return "\x1b[1;31;40m" + in + "\x1b[0m"
-	}
-
-	return in
-}
-
-func boldYellowFgBlackBg(in string) string {
-	if alpmConf.Options&alpm.ConfColor > 0 {
-		return "\x1b[1;33;40m" + in + "\x1b[0m"
-	}
-
-	return in
+	return fmt.Sprintf("\x1b[%dm%s\x1b[0m", hash%6+31, name)
 }
diff --git a/query.go b/query.go
index 5c4dbfa9..550b84b6 100644
--- a/query.go
+++ b/query.go
@@ -266,7 +266,7 @@ func hangingPackages() (hanging []string, err error) {
 		requiredby := pkg.ComputeRequiredBy()
 		if len(requiredby) == 0 {
 			hanging = append(hanging, pkg.Name())
-			fmt.Println(pkg.Name() + ": " + yellowFg(human(pkg.ISize())))
+			fmt.Println(pkg.Name() + ": " + magenta(human(pkg.ISize())))
 
 		}
 		return nil
@@ -378,25 +378,25 @@ func aurInfo(names []string) ([]rpc.Pkg, error) {
 	}
 
 	if len(missing) > 0 {
-		fmt.Print(boldRedFgBlackBg(arrow + " Missing AUR Packages:"))
+		fmt.Print(bold(red(arrow + " Missing AUR Packages:")))
 		for _, name := range missing {
-			fmt.Print(" " + boldYellowFgBlackBg(name))
+			fmt.Print(" " + bold(magenta(name)))
 		}
 		fmt.Println()
 	}
 
 	if len(orphans) > 0 {
-		fmt.Print(boldRedFgBlackBg(arrow + " Orphaned AUR Packages:"))
+		fmt.Print(bold(red(arrow + " Orphaned AUR Packages:")))
 		for _, name := range orphans {
-			fmt.Print(" " + boldYellowFgBlackBg(name))
+			fmt.Print(" " + bold(magenta(name)))
 		}
 		fmt.Println()
 	}
 
 	if len(outOfDate) > 0 {
-		fmt.Print(boldRedFgBlackBg(arrow + " Out Of Date AUR Packages:"))
+		fmt.Print(bold(red(arrow + " Out Of Date AUR Packages:")))
 		for _, name := range outOfDate {
-			fmt.Print(" " + boldYellowFgBlackBg(name))
+			fmt.Print(" " + bold(magenta(name)))
 		}
 		fmt.Println()
 	}
diff --git a/upgrade.go b/upgrade.go
index eeafd8d7..9ef516d4 100644
--- a/upgrade.go
+++ b/upgrade.go
@@ -61,19 +61,19 @@ func getVersionDiff(oldVersion, newversion string) (left, right string) {
 	new, errNew := pkgb.NewCompleteVersion(newversion)
 
 	if errOld != nil {
-		left = redFg("Invalid Version")
+		left = red("Invalid Version")
 	}
 	if errNew != nil {
-		right = redFg("Invalid Version")
+		right = red("Invalid Version")
 	}
 
 	if errOld == nil && errNew == nil {
 		if old.Version == new.Version {
-			left = string(old.Version) + "-" + redFg(string(old.Pkgrel))
-			right = string(new.Version) + "-" + greenFg(string(new.Pkgrel))
+			left = string(old.Version) + "-" + red(string(old.Pkgrel))
+			right = string(new.Version) + "-" + green(string(new.Pkgrel))
 		} else {
-			left = redFg(string(old.Version)) + "-" + string(old.Pkgrel)
-			right = boldGreenFg(string(new.Version)) + "-" + string(new.Pkgrel)
+			left = red(string(old.Version)) + "-" + string(old.Pkgrel)
+			right = bold(green(string(new.Version))) + "-" + string(new.Pkgrel)
 		}
 	}
 
@@ -85,18 +85,8 @@ func (u upSlice) Print(start int) {
 	for k, i := range u {
 		left, right := getVersionDiff(i.LocalVersion, i.RemoteVersion)
 
-		f := func(name string) (output string) {
-			if alpmConf.Options&alpm.ConfColor == 0 {
-				return name
-			}
-			var hash = 5381
-			for i := 0; i < len(name); i++ {
-				hash = int(name[i]) + ((hash << 5) + (hash))
-			}
-			return fmt.Sprintf("\x1b[1;%dm%s\x1b[0m", hash%6+31, name)
-		}
-		fmt.Print(yellowFg(fmt.Sprintf("%2d ", len(u)+start-k-1)))
-		fmt.Print(f(i.Repository), "/", boldWhiteFg(i.Name))
+		fmt.Print(magenta(fmt.Sprintf("%2d ", len(u)+start-k-1)))
+		fmt.Print(bold(colourHash(i.Repository)), "/", cyan(i.Name))
 
 		w := 70 - len(i.Repository) - len(i.Name) + len(left)
 		fmt.Printf(fmt.Sprintf("%%%ds", w),
@@ -115,14 +105,14 @@ func upList(dt *depTree) (aurUp upSlice, repoUp upSlice, err error) {
 	aurC := make(chan upSlice)
 	errC := make(chan error)
 
-	fmt.Println(boldCyanFg("::"), boldFg("Searching databases for updates..."))
+	fmt.Println(bold(cyan("::") + " Searching databases for updates..."))
 	go func() {
 		repoUpList, err := upRepo(local)
 		errC <- err
 		repoC <- repoUpList
 	}()
 
-	fmt.Println(boldCyanFg("::"), boldFg("Searching AUR for updates..."))
+	fmt.Println(bold(cyan("::") + " Searching AUR for updates..."))
 	go func() {
 		aurUpList, err := upAUR(remote, remoteNames, dt)
 		errC <- err
@@ -166,8 +156,8 @@ func upDevel(remote []alpm.Package, packageC chan upgrade, done chan bool) {
 			}
 			if found {
 				if pkg.ShouldIgnore() {
-					fmt.Print(yellowFg("Warning: "))
-					fmt.Printf("%s ignoring package upgrade (%s => %s)\n", pkg.Name(), pkg.Version(), "git")
+					fmt.Print(magenta("Warning: "))
+					fmt.Printf("%s ignoring package upgrade (%s => %s)\n", cyan(pkg.Name()), pkg.Version(), "git")
 				} else {
 					packageC <- upgrade{e.Package, "devel", pkg.Version(), "commit-" + e.SHA[0:6]}
 				}
@@ -191,7 +181,7 @@ func upAUR(remote []alpm.Package, remoteNames []string, dt *depTree) (toUpgrade
 	if config.Devel {
 		routines++
 		go upDevel(remote, packageC, done)
-		fmt.Println(boldCyanFg("::"), boldFg("Checking development packages..."))
+		fmt.Println(bold(cyan("::") + "Checking development packages..."))
 	}
 
 	routines++
@@ -206,8 +196,8 @@ func upAUR(remote []alpm.Package, remoteNames []string, dt *depTree) (toUpgrade
 				(alpm.VerCmp(pkg.Version(), aurPkg.Version) < 0) {
 				if pkg.ShouldIgnore() {
 					left, right := getVersionDiff(pkg.Version(), aurPkg.Version)
-					fmt.Print(yellowFg("Warning: "))
-					fmt.Printf("%s ignoring package upgrade (%s => %s)\n", pkg.Name(), left, right)
+					fmt.Print(magenta("Warning: "))
+					fmt.Printf("%s ignoring package upgrade (%s => %s)\n", cyan(pkg.Name()), left, right)
 				} else {
 					packageC <- upgrade{aurPkg.Name, "aur", pkg.Version(), aurPkg.Version}
 				}
@@ -255,7 +245,7 @@ func upRepo(local []alpm.Package) (upSlice, error) {
 		newPkg := pkg.NewVersion(dbList)
 		if newPkg != nil {
 			if pkg.ShouldIgnore() {
-				fmt.Print(yellowFg("Warning: "))
+				fmt.Print(magenta("Warning: "))
 				fmt.Printf("%s ignoring package upgrade (%s => %s)\n", pkg.Name(), pkg.Version(), newPkg.Version())
 			} else {
 				slice = append(slice, upgrade{pkg.Name(), newPkg.DB().Name(), pkg.Version(), newPkg.Version()})
@@ -303,13 +293,13 @@ func upgradePkgs(dt *depTree) (stringSet, stringSet, error) {
 	}
 
 	sort.Sort(repoUp)
-	fmt.Println(boldBlueFg("::"), len(aurUp)+len(repoUp), boldWhiteFg("Packages to upgrade."))
+	fmt.Println(bold(blue("::")), len(aurUp)+len(repoUp), bold("Packages to upgrade."))
 	repoUp.Print(len(aurUp) + 1)
 	aurUp.Print(1)
 
 	if !config.NoConfirm {
-		fmt.Println(boldGreenFg(arrow) + greenFg(" Packages to not upgrade (eg: 1 2 3, 1-3 or ^4)"))
-		fmt.Print(boldGreenFg(arrow + " "))
+		fmt.Println(bold(green(arrow + " Packages to not upgrade (eg: 1 2 3, 1-3 or ^4)")))
+		fmt.Print(bold(green(arrow + " ")))
 		reader := bufio.NewReader(os.Stdin)
 
 		numberBuf, overflow, err := reader.ReadLine()