diff --git a/clean.go b/clean.go
index ae3a6ed3..16c12480 100644
--- a/clean.go
+++ b/clean.go
@@ -18,17 +18,19 @@ import (
 )
 
 // CleanDependencies removes all dangling dependencies in system.
-func cleanDependencies(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Executor, removeOptional bool) error {
+func cleanDependencies(ctx context.Context, cfg *settings.Configuration,
+	cmdArgs *parser.Arguments, dbExecutor db.Executor, removeOptional bool,
+) error {
 	hanging := hangingPackages(removeOptional, dbExecutor)
 	if len(hanging) != 0 {
-		return cleanRemove(ctx, cmdArgs, hanging)
+		return cleanRemove(ctx, cfg, cmdArgs, hanging)
 	}
 
 	return nil
 }
 
 // CleanRemove sends a full removal command to pacman with the pkgName slice.
-func cleanRemove(ctx context.Context, cmdArgs *parser.Arguments, pkgNames []string) error {
+func cleanRemove(ctx context.Context, config *settings.Configuration, cmdArgs *parser.Arguments, pkgNames []string) error {
 	if len(pkgNames) == 0 {
 		return nil
 	}
@@ -42,13 +44,13 @@ func cleanRemove(ctx context.Context, cmdArgs *parser.Arguments, pkgNames []stri
 			arguments, config.Runtime.Mode, settings.NoConfirm))
 }
 
-func syncClean(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
+func syncClean(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
 	keepInstalled := false
 	keepCurrent := false
 
 	_, removeAll, _ := cmdArgs.GetArg("c", "clean")
 
-	for _, v := range config.Runtime.PacmanConf.CleanMethod {
+	for _, v := range cfg.Runtime.PacmanConf.CleanMethod {
 		if v == "KeepInstalled" {
 			keepInstalled = true
 		} else if v == "KeepCurrent" {
@@ -56,14 +58,14 @@ func syncClean(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Exe
 		}
 	}
 
-	if config.Runtime.Mode.AtLeastRepo() {
-		if err := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, config.Runtime.Mode, settings.NoConfirm)); err != nil {
+	if cfg.Runtime.Mode.AtLeastRepo() {
+		if err := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
+			cmdArgs, cfg.Runtime.Mode, settings.NoConfirm)); err != nil {
 			return err
 		}
 	}
 
-	if !config.Runtime.Mode.AtLeastAUR() {
+	if !cfg.Runtime.Mode.AtLeastAUR() {
 		return nil
 	}
 
@@ -74,10 +76,10 @@ func syncClean(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Exe
 		question = gotext.Get("Do you want to remove all other AUR packages from cache?")
 	}
 
-	fmt.Println(gotext.Get("\nBuild directory:"), config.BuildDir)
+	fmt.Println(gotext.Get("\nBuild directory:"), cfg.BuildDir)
 
 	if text.ContinueTask(os.Stdin, question, true, settings.NoConfirm) {
-		if err := cleanAUR(ctx, keepInstalled, keepCurrent, removeAll, dbExecutor); err != nil {
+		if err := cleanAUR(ctx, cfg, keepInstalled, keepCurrent, removeAll, dbExecutor); err != nil {
 			return err
 		}
 	}
@@ -87,13 +89,15 @@ func syncClean(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Exe
 	}
 
 	if text.ContinueTask(os.Stdin, gotext.Get("Do you want to remove ALL untracked AUR files?"), true, settings.NoConfirm) {
-		return cleanUntracked(ctx)
+		return cleanUntracked(ctx, cfg)
 	}
 
 	return nil
 }
 
-func cleanAUR(ctx context.Context, keepInstalled, keepCurrent, removeAll bool, dbExecutor db.Executor) error {
+func cleanAUR(ctx context.Context, config *settings.Configuration,
+	keepInstalled, keepCurrent, removeAll bool, dbExecutor db.Executor,
+) error {
 	fmt.Println(gotext.Get("removing AUR packages from cache..."))
 
 	installedBases := make(stringset.StringSet)
@@ -164,10 +168,10 @@ func cleanAUR(ctx context.Context, keepInstalled, keepCurrent, removeAll bool, d
 	return nil
 }
 
-func cleanUntracked(ctx context.Context) error {
+func cleanUntracked(ctx context.Context, cfg *settings.Configuration) error {
 	fmt.Println(gotext.Get("removing untracked AUR files from cache..."))
 
-	files, err := os.ReadDir(config.BuildDir)
+	files, err := os.ReadDir(cfg.BuildDir)
 	if err != nil {
 		return err
 	}
@@ -177,9 +181,9 @@ func cleanUntracked(ctx context.Context) error {
 			continue
 		}
 
-		dir := filepath.Join(config.BuildDir, file.Name())
+		dir := filepath.Join(cfg.BuildDir, file.Name())
 		if isGitRepository(dir) {
-			if err := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildGitCmd(ctx, dir, "clean", "-fx")); err != nil {
+			if err := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildGitCmd(ctx, dir, "clean", "-fx")); err != nil {
 				text.Warnln(gotext.Get("Unable to clean:"), dir)
 
 				return err
@@ -195,7 +199,9 @@ func isGitRepository(dir string) bool {
 	return !os.IsNotExist(err)
 }
 
-func cleanAfter(ctx context.Context, cmdBuilder exe.ICmdBuilder, pkgbuildDirs map[string]string) {
+func cleanAfter(ctx context.Context, config *settings.Configuration,
+	cmdBuilder exe.ICmdBuilder, pkgbuildDirs map[string]string,
+) {
 	fmt.Println(gotext.Get("removing untracked AUR files from cache..."))
 
 	i := 0
diff --git a/cmd.go b/cmd.go
index 9ddbf10e..51cc04e3 100644
--- a/cmd.go
+++ b/cmd.go
@@ -151,7 +151,7 @@ getpkgbuild specific options:
 
 func handleCmd(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
 	if cmdArgs.ExistsArg("h", "help") {
-		return handleHelp(ctx, cmdArgs)
+		return handleHelp(ctx, cfg, cmdArgs)
 	}
 
 	if cfg.SudoLoop && cmdArgs.NeedRoot(cfg.Runtime.Mode) {
@@ -170,9 +170,9 @@ func handleCmd(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser
 		return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
 			cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
 	case "Q", "query":
-		return handleQuery(ctx, cmdArgs, dbExecutor)
+		return handleQuery(ctx, cfg, cmdArgs, dbExecutor)
 	case "R", "remove":
-		return handleRemove(ctx, cmdArgs, cfg.Runtime.VCSStore)
+		return handleRemove(ctx, cfg, cmdArgs, cfg.Runtime.VCSStore)
 	case "S", "sync":
 		return handleSync(ctx, cfg, cmdArgs, dbExecutor)
 	case "T", "deptest":
@@ -183,13 +183,13 @@ func handleCmd(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser
 	case "B", "build":
 		return handleBuild(ctx, cfg, dbExecutor, cmdArgs)
 	case "G", "getpkgbuild":
-		return handleGetpkgbuild(ctx, cmdArgs, dbExecutor)
+		return handleGetpkgbuild(ctx, cfg, cmdArgs, dbExecutor)
 	case "P", "show":
-		return handlePrint(ctx, cmdArgs, dbExecutor)
+		return handlePrint(ctx, cfg, cmdArgs, dbExecutor)
 	case "Y", "yay":
-		return handleYay(ctx, cmdArgs, dbExecutor, cfg.Runtime.QueryBuilder)
+		return handleYay(ctx, cfg, cmdArgs, dbExecutor, cfg.Runtime.QueryBuilder)
 	case "W", "web":
-		return handleWeb(ctx, cmdArgs)
+		return handleWeb(ctx, cfg, cmdArgs)
 	}
 
 	return errors.New(gotext.Get("unhandled operation"))
@@ -219,18 +219,19 @@ func getFilter(cmdArgs *parser.Arguments) (upgrade.Filter, error) {
 	}, nil
 }
 
-func handleQuery(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
+func handleQuery(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
 	if cmdArgs.ExistsArg("u", "upgrades") {
 		filter, err := getFilter(cmdArgs)
 		if err != nil {
 			return err
 		}
 
-		return printUpdateList(ctx, cmdArgs, dbExecutor, cmdArgs.ExistsDouble("u", "sysupgrade"), filter)
+		return printUpdateList(ctx, cfg, cmdArgs, dbExecutor,
+			cmdArgs.ExistsDouble("u", "sysupgrade"), filter)
 	}
 
-	if err := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-		cmdArgs, config.Runtime.Mode, settings.NoConfirm)); err != nil {
+	if err := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
+		cmdArgs, cfg.Runtime.Mode, settings.NoConfirm)); err != nil {
 		if str := err.Error(); strings.Contains(str, "exit status") {
 			// yay -Qdt should not output anything in case of error
 			return fmt.Errorf("")
@@ -242,22 +243,22 @@ func handleQuery(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.E
 	return nil
 }
 
-func handleHelp(ctx context.Context, cmdArgs *parser.Arguments) error {
+func handleHelp(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments) error {
 	switch cmdArgs.Op {
 	case "Y", "yay", "G", "getpkgbuild", "P", "show", "W", "web", "B", "build":
 		usage()
 		return nil
 	}
 
-	return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-		cmdArgs, config.Runtime.Mode, settings.NoConfirm))
+	return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
+		cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
 }
 
 func handleVersion() {
 	fmt.Printf("yay v%s - libalpm v%s\n", yayVersion, alpm.Version())
 }
 
-func handlePrint(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
+func handlePrint(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
 	switch {
 	case cmdArgs.ExistsArg("d", "defaultconfig"):
 		tmpConfig := settings.DefaultConfig(yayVersion)
@@ -265,7 +266,7 @@ func handlePrint(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.E
 
 		return nil
 	case cmdArgs.ExistsArg("g", "currentconfig"):
-		fmt.Printf("%v", config)
+		fmt.Printf("%v", cfg)
 
 		return nil
 	case cmdArgs.ExistsArg("n", "numberupgrades"):
@@ -274,60 +275,62 @@ func handlePrint(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.E
 			return err
 		}
 
-		return printNumberOfUpdates(ctx, dbExecutor, cmdArgs.ExistsDouble("u", "sysupgrade"), filter)
+		return printNumberOfUpdates(ctx, cfg, dbExecutor, cmdArgs.ExistsDouble("u", "sysupgrade"), filter)
 	case cmdArgs.ExistsArg("w", "news"):
 		double := cmdArgs.ExistsDouble("w", "news")
 		quiet := cmdArgs.ExistsArg("q", "quiet")
 
-		return news.PrintNewsFeed(ctx, config.Runtime.HTTPClient, dbExecutor.LastBuildTime(), config.BottomUp, double, quiet)
+		return news.PrintNewsFeed(ctx, cfg.Runtime.HTTPClient, dbExecutor.LastBuildTime(), cfg.BottomUp, double, quiet)
 	case cmdArgs.ExistsDouble("c", "complete"):
-		return completion.Show(ctx, config.Runtime.HTTPClient, dbExecutor,
-			config.AURURL, config.Runtime.CompletionPath, config.CompletionInterval, true)
+		return completion.Show(ctx, cfg.Runtime.HTTPClient, dbExecutor,
+			cfg.AURURL, cfg.Runtime.CompletionPath, cfg.CompletionInterval, true)
 	case cmdArgs.ExistsArg("c", "complete"):
-		return completion.Show(ctx, config.Runtime.HTTPClient, dbExecutor,
-			config.AURURL, config.Runtime.CompletionPath, config.CompletionInterval, false)
+		return completion.Show(ctx, cfg.Runtime.HTTPClient, dbExecutor,
+			cfg.AURURL, cfg.Runtime.CompletionPath, cfg.CompletionInterval, false)
 	case cmdArgs.ExistsArg("s", "stats"):
-		return localStatistics(ctx, dbExecutor)
+		return localStatistics(ctx, cfg, dbExecutor)
 	}
 
 	return nil
 }
 
-func handleYay(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Executor, queryBuilder query.Builder) error {
+func handleYay(ctx context.Context, cfg *settings.Configuration,
+	cmdArgs *parser.Arguments, dbExecutor db.Executor, queryBuilder query.Builder,
+) error {
 	switch {
 	case cmdArgs.ExistsArg("gendb"):
-		return createDevelDB(ctx, config, dbExecutor)
+		return createDevelDB(ctx, cfg, dbExecutor)
 	case cmdArgs.ExistsDouble("c"):
-		return cleanDependencies(ctx, cmdArgs, dbExecutor, true)
+		return cleanDependencies(ctx, cfg, cmdArgs, dbExecutor, true)
 	case cmdArgs.ExistsArg("c", "clean"):
-		return cleanDependencies(ctx, cmdArgs, dbExecutor, false)
+		return cleanDependencies(ctx, cfg, cmdArgs, dbExecutor, false)
 	case len(cmdArgs.Targets) > 0:
-		return displayNumberMenu(ctx, cmdArgs.Targets, dbExecutor, queryBuilder, cmdArgs)
+		return displayNumberMenu(ctx, cfg, cmdArgs.Targets, dbExecutor, queryBuilder, cmdArgs)
 	}
 
 	return nil
 }
 
-func handleWeb(ctx context.Context, cmdArgs *parser.Arguments) error {
+func handleWeb(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments) error {
 	switch {
 	case cmdArgs.ExistsArg("v", "vote"):
-		return handlePackageVote(ctx, cmdArgs.Targets, config.Runtime.AURClient,
-			config.Runtime.VoteClient, config.RequestSplitN, true)
+		return handlePackageVote(ctx, cmdArgs.Targets, cfg.Runtime.AURClient,
+			cfg.Runtime.VoteClient, cfg.RequestSplitN, true)
 	case cmdArgs.ExistsArg("u", "unvote"):
-		return handlePackageVote(ctx, cmdArgs.Targets, config.Runtime.AURClient,
-			config.Runtime.VoteClient, config.RequestSplitN, false)
+		return handlePackageVote(ctx, cmdArgs.Targets, cfg.Runtime.AURClient,
+			cfg.Runtime.VoteClient, cfg.RequestSplitN, false)
 	}
 
 	return nil
 }
 
-func handleGetpkgbuild(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor download.DBSearcher) error {
+func handleGetpkgbuild(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments, dbExecutor download.DBSearcher) error {
 	if cmdArgs.ExistsArg("p", "print") {
-		return printPkgbuilds(dbExecutor, config.Runtime.AURCache,
-			config.Runtime.HTTPClient, cmdArgs.Targets, config.Runtime.Mode, config.AURURL)
+		return printPkgbuilds(dbExecutor, cfg.Runtime.AURCache,
+			cfg.Runtime.HTTPClient, cmdArgs.Targets, cfg.Runtime.Mode, cfg.AURURL)
 	}
 
-	return getPkgbuilds(ctx, dbExecutor, config.Runtime.AURCache, config,
+	return getPkgbuilds(ctx, dbExecutor, cfg.Runtime.AURCache, cfg,
 		cmdArgs.Targets, cmdArgs.ExistsArg("f", "force"))
 }
 
@@ -359,20 +362,20 @@ func handleSync(ctx context.Context, cfg *settings.Configuration, cmdArgs *parse
 		return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
 			cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
 	case cmdArgs.ExistsArg("c", "clean"):
-		return syncClean(ctx, cmdArgs, dbExecutor)
+		return syncClean(ctx, cfg, cmdArgs, dbExecutor)
 	case cmdArgs.ExistsArg("l", "list"):
-		return syncList(ctx, cfg.Runtime.HTTPClient, cmdArgs, dbExecutor)
+		return syncList(ctx, cfg, cfg.Runtime.HTTPClient, cmdArgs, dbExecutor)
 	case cmdArgs.ExistsArg("g", "groups"):
 		return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
 			cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
 	case cmdArgs.ExistsArg("i", "info"):
-		return syncInfo(ctx, cmdArgs, targets, dbExecutor)
+		return syncInfo(ctx, cfg, cmdArgs, targets, dbExecutor)
 	case cmdArgs.ExistsArg("u", "sysupgrade") || len(cmdArgs.Targets) > 0:
 		if cfg.NewInstallEngine {
 			return syncInstall(ctx, cfg, cmdArgs, dbExecutor)
 		}
 
-		return install(ctx, cmdArgs, dbExecutor, false)
+		return install(ctx, cfg, cmdArgs, dbExecutor, false)
 	case cmdArgs.ExistsArg("y", "refresh"):
 		return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
 			cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
@@ -381,9 +384,9 @@ func handleSync(ctx context.Context, cfg *settings.Configuration, cmdArgs *parse
 	return nil
 }
 
-func handleRemove(ctx context.Context, cmdArgs *parser.Arguments, localCache vcs.Store) error {
-	err := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-		cmdArgs, config.Runtime.Mode, settings.NoConfirm))
+func handleRemove(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments, localCache vcs.Store) error {
+	err := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
+		cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
 	if err == nil {
 		localCache.RemovePackages(cmdArgs.Targets)
 	}
@@ -392,7 +395,7 @@ func handleRemove(ctx context.Context, cmdArgs *parser.Arguments, localCache vcs
 }
 
 // NumberMenu presents a CLI for selecting packages to install.
-func displayNumberMenu(ctx context.Context, pkgS []string, dbExecutor db.Executor,
+func displayNumberMenu(ctx context.Context, cfg *settings.Configuration, pkgS []string, dbExecutor db.Executor,
 	queryBuilder query.Builder, cmdArgs *parser.Arguments,
 ) error {
 	queryBuilder.Execute(ctx, dbExecutor, pkgS)
@@ -429,25 +432,27 @@ func displayNumberMenu(ctx context.Context, pkgS []string, dbExecutor db.Executo
 		return nil
 	}
 
-	if config.NewInstallEngine {
-		return syncInstall(ctx, config, cmdArgs, dbExecutor)
+	if cfg.NewInstallEngine {
+		return syncInstall(ctx, cfg, cmdArgs, dbExecutor)
 	}
 
-	return install(ctx, cmdArgs, dbExecutor, true)
+	return install(ctx, cfg, cmdArgs, dbExecutor, true)
 }
 
-func syncList(ctx context.Context, httpClient *http.Client, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
+func syncList(ctx context.Context, cfg *settings.Configuration,
+	httpClient *http.Client, cmdArgs *parser.Arguments, dbExecutor db.Executor,
+) error {
 	aur := false
 
 	for i := len(cmdArgs.Targets) - 1; i >= 0; i-- {
-		if cmdArgs.Targets[i] == "aur" && config.Runtime.Mode.AtLeastAUR() {
+		if cmdArgs.Targets[i] == "aur" && cfg.Runtime.Mode.AtLeastAUR() {
 			cmdArgs.Targets = append(cmdArgs.Targets[:i], cmdArgs.Targets[i+1:]...)
 			aur = true
 		}
 	}
 
-	if config.Runtime.Mode.AtLeastAUR() && (len(cmdArgs.Targets) == 0 || aur) {
-		req, err := http.NewRequestWithContext(ctx, http.MethodGet, config.AURURL+"/packages.gz", http.NoBody)
+	if cfg.Runtime.Mode.AtLeastAUR() && (len(cmdArgs.Targets) == 0 || aur) {
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, cfg.AURURL+"/packages.gz", http.NoBody)
 		if err != nil {
 			return err
 		}
@@ -478,9 +483,9 @@ func syncList(ctx context.Context, httpClient *http.Client, cmdArgs *parser.Argu
 		}
 	}
 
-	if config.Runtime.Mode.AtLeastRepo() && (len(cmdArgs.Targets) != 0 || !aur) {
-		return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, config.Runtime.Mode, settings.NoConfirm))
+	if cfg.Runtime.Mode.AtLeastRepo() && (len(cmdArgs.Targets) != 0 || !aur) {
+		return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
+			cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
 	}
 
 	return nil
diff --git a/globals.go b/globals.go
deleted file mode 100644
index fc31f740..00000000
--- a/globals.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package main
-
-import "github.com/Jguer/yay/v11/pkg/settings"
-
-var (
-	yayVersion = "11.3.0"            // To be set by compiler.
-	localePath = "/usr/share/locale" // To be set by compiler.
-)
-
-var config *settings.Configuration // YayConf holds the current config values for yay.
diff --git a/install.go b/install.go
index d872df5a..65194d6e 100644
--- a/install.go
+++ b/install.go
@@ -85,12 +85,14 @@ func asexp(ctx context.Context,
 }
 
 // Install handles package installs.
-func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Executor, ignoreProviders bool) error {
+func install(ctx context.Context, cfg *settings.Configuration,
+	cmdArgs *parser.Arguments, dbExecutor db.Executor, ignoreProviders bool,
+) error {
 	var (
 		do              *dep.Order
 		srcinfos        map[string]*gosrc.Srcinfo
 		noDeps          = cmdArgs.ExistsDouble("d", "nodeps")
-		noCheck         = strings.Contains(config.MFlags, "--nocheck")
+		noCheck         = strings.Contains(cfg.MFlags, "--nocheck")
 		assumeInstalled = cmdArgs.GetArgs("assume-installed")
 		sysupgradeArg   = cmdArgs.ExistsArg("u", "sysupgrade")
 		refreshArg      = cmdArgs.ExistsArg("y", "refresh")
@@ -98,19 +100,19 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
 	)
 
 	if noDeps {
-		config.Runtime.CmdBuilder.AddMakepkgFlag("-d")
+		cfg.Runtime.CmdBuilder.AddMakepkgFlag("-d")
 	}
 
-	if config.Runtime.Mode.AtLeastRepo() {
-		if config.CombinedUpgrade {
+	if cfg.Runtime.Mode.AtLeastRepo() {
+		if cfg.CombinedUpgrade {
 			if refreshArg {
-				if errR := earlyRefresh(ctx, config, config.Runtime.CmdBuilder, cmdArgs); errR != nil {
+				if errR := earlyRefresh(ctx, cfg, cfg.Runtime.CmdBuilder, cmdArgs); errR != nil {
 					return fmt.Errorf("%s - %w", gotext.Get("error refreshing databases"), errR)
 				}
 				cmdArgs.DelArg("y", "refresh")
 			}
 		} else if refreshArg || sysupgradeArg || len(cmdArgs.Targets) > 0 {
-			if errP := earlyPacmanCall(ctx, cmdArgs, dbExecutor); errP != nil {
+			if errP := earlyPacmanCall(ctx, cfg, cmdArgs, dbExecutor); errP != nil {
 				return errP
 			}
 		}
@@ -137,7 +139,7 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
 	arguments.Op = "S"
 	arguments.ClearTargets()
 
-	if config.Runtime.Mode == parser.ModeAUR {
+	if cfg.Runtime.Mode == parser.ModeAUR {
 		arguments.DelArg("u", "sysupgrade")
 	}
 
@@ -145,7 +147,7 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
 	if sysupgradeArg {
 		var errSysUp error
 
-		requestTargets, errSysUp = addUpgradeTargetsToArgs(ctx, dbExecutor, cmdArgs, requestTargets, arguments)
+		requestTargets, errSysUp = addUpgradeTargetsToArgs(ctx, cfg, dbExecutor, cmdArgs, requestTargets, arguments)
 		if errSysUp != nil {
 			return errSysUp
 		}
@@ -154,8 +156,8 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
 	targets := stringset.FromSlice(cmdArgs.Targets)
 
 	dp, err := dep.GetPool(ctx, requestTargets,
-		warnings, dbExecutor, config.Runtime.AURClient, config.Runtime.Mode,
-		ignoreProviders, settings.NoConfirm, config.Provides, config.ReBuild, config.RequestSplitN, noDeps, noCheck, assumeInstalled)
+		warnings, dbExecutor, cfg.Runtime.AURClient, cfg.Runtime.Mode,
+		ignoreProviders, settings.NoConfirm, cfg.Provides, cfg.ReBuild, cfg.RequestSplitN, noDeps, noCheck, assumeInstalled)
 	if err != nil {
 		return err
 	}
@@ -165,7 +167,7 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
 	}
 
 	if len(dp.Aur) == 0 {
-		if !config.CombinedUpgrade {
+		if !cfg.CombinedUpgrade {
 			if sysupgradeArg {
 				fmt.Println(gotext.Get(" there is nothing to do"))
 			}
@@ -180,11 +182,11 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
 			cmdArgs.CreateOrAppendOption("ignore", arguments.GetArgs("ignore")...)
 		}
 
-		return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, config.Runtime.Mode, settings.NoConfirm))
+		return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
+			cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
 	}
 
-	conflicts, errCC := dp.CheckConflicts(config.UseAsk, settings.NoConfirm, noDeps)
+	conflicts, errCC := dp.CheckConflicts(cfg.UseAsk, settings.NoConfirm, noDeps)
 	if errCC != nil {
 		return errCC
 	}
@@ -200,7 +202,7 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
 	}
 
 	if len(do.Aur) == 0 && len(arguments.Targets) == 0 &&
-		(!cmdArgs.ExistsArg("u", "sysupgrade") || config.Runtime.Mode == parser.ModeAUR) {
+		(!cmdArgs.ExistsArg("u", "sysupgrade") || cfg.Runtime.Mode == parser.ModeAUR) {
 		fmt.Println(gotext.Get(" there is nothing to do"))
 		return nil
 	}
@@ -211,21 +213,21 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
 	pkgbuildDirs := make(map[string]string, len(do.Aur))
 
 	for _, base := range do.Aur {
-		dir := filepath.Join(config.BuildDir, base.Pkgbase())
+		dir := filepath.Join(cfg.BuildDir, base.Pkgbase())
 		pkgbuildDirs[base.Pkgbase()] = dir
 	}
 
-	if config.CleanAfter {
+	if cfg.CleanAfter {
 		defer func() {
-			cleanAfter(ctx, config.Runtime.CmdBuilder, pkgbuildDirs)
+			cleanAfter(ctx, cfg, cfg.Runtime.CmdBuilder, pkgbuildDirs)
 		}()
 	}
 
 	if do.HasMake() {
-		switch config.RemoveMake {
+		switch cfg.RemoveMake {
 		case "yes":
 			defer func() {
-				err = removeMake(ctx, config.Runtime.CmdBuilder, do.GetMake(), cmdArgs)
+				err = removeMake(ctx, cfg, cfg.Runtime.CmdBuilder, do.GetMake(), cmdArgs)
 			}()
 
 		case "no":
@@ -233,15 +235,15 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
 		default:
 			if text.ContinueTask(os.Stdin, gotext.Get("Remove make dependencies after install?"), false, settings.NoConfirm) {
 				defer func() {
-					err = removeMake(ctx, config.Runtime.CmdBuilder, do.GetMake(), cmdArgs)
+					err = removeMake(ctx, cfg, cfg.Runtime.CmdBuilder, do.GetMake(), cmdArgs)
 				}()
 			}
 		}
 	}
 
-	if errCleanMenu := menus.Clean(os.Stdout, config.CleanMenu,
+	if errCleanMenu := menus.Clean(os.Stdout, cfg.CleanMenu,
 		pkgbuildDirs,
-		remoteNamesCache, settings.NoConfirm, config.AnswerClean); errCleanMenu != nil {
+		remoteNamesCache, settings.NoConfirm, cfg.AnswerClean); errCleanMenu != nil {
 		if errors.As(errCleanMenu, &settings.ErrUserAbort{}) {
 			return errCleanMenu
 		}
@@ -249,7 +251,7 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
 		text.Errorln(errCleanMenu)
 	}
 
-	toSkip := pkgbuildsToSkip(do.Aur, targets)
+	toSkip := pkgbuildsToSkip(cfg, do.Aur, targets)
 	toClone := make([]string, 0, len(do.Aur))
 
 	for _, base := range do.Aur {
@@ -265,14 +267,14 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
 	}
 
 	cloned, errA := download.AURPKGBUILDRepos(ctx,
-		config.Runtime.CmdBuilder, toClone, config.AURURL, config.BuildDir, false)
+		cfg.Runtime.CmdBuilder, toClone, cfg.AURURL, cfg.BuildDir, false)
 	if errA != nil {
 		return errA
 	}
 
-	if errDiffMenu := menus.Diff(ctx, config.Runtime.CmdBuilder, os.Stdout, pkgbuildDirs,
-		config.DiffMenu, remoteNamesCache,
-		cloned, settings.NoConfirm, config.AnswerDiff); errDiffMenu != nil {
+	if errDiffMenu := menus.Diff(ctx, cfg.Runtime.CmdBuilder, os.Stdout, pkgbuildDirs,
+		cfg.DiffMenu, remoteNamesCache,
+		cloned, settings.NoConfirm, cfg.AnswerDiff); errDiffMenu != nil {
 		if errors.As(errDiffMenu, &settings.ErrUserAbort{}) {
 			return errDiffMenu
 		}
@@ -280,7 +282,7 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
 		text.Errorln(errDiffMenu)
 	}
 
-	if errM := mergePkgbuilds(ctx, config.Runtime.CmdBuilder, pkgbuildDirs); errM != nil {
+	if errM := mergePkgbuilds(ctx, cfg.Runtime.CmdBuilder, pkgbuildDirs); errM != nil {
 		return errM
 	}
 
@@ -289,9 +291,9 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
 		return err
 	}
 
-	if errEditMenu := menus.Edit(os.Stdout, config.EditMenu, pkgbuildDirs,
-		config.Editor, config.EditorFlags, remoteNamesCache, srcinfos,
-		settings.NoConfirm, config.AnswerEdit); errEditMenu != nil {
+	if errEditMenu := menus.Edit(os.Stdout, cfg.EditMenu, pkgbuildDirs,
+		cfg.Editor, cfg.EditorFlags, remoteNamesCache, srcinfos,
+		settings.NoConfirm, cfg.AnswerEdit); errEditMenu != nil {
 		if errors.As(errEditMenu, &settings.ErrUserAbort{}) {
 			return errEditMenu
 		}
@@ -303,19 +305,19 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
 		return errI
 	}
 
-	if config.PGPFetch {
-		if _, errCPK := pgp.CheckPgpKeys(ctx, pkgbuildDirs, srcinfos, config.Runtime.CmdBuilder, settings.NoConfirm); errCPK != nil {
+	if cfg.PGPFetch {
+		if _, errCPK := pgp.CheckPgpKeys(ctx, pkgbuildDirs, srcinfos, cfg.Runtime.CmdBuilder, settings.NoConfirm); errCPK != nil {
 			return errCPK
 		}
 	}
 
-	if !config.CombinedUpgrade {
+	if !cfg.CombinedUpgrade {
 		arguments.DelArg("u", "sysupgrade")
 	}
 
 	if len(arguments.Targets) > 0 || arguments.ExistsArg("u") {
-		if errShow := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			arguments, config.Runtime.Mode, settings.NoConfirm)); errShow != nil {
+		if errShow := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
+			arguments, cfg.Runtime.Mode, settings.NoConfirm)); errShow != nil {
 			return errors.New(gotext.Get("error installing repo packages"))
 		}
 
@@ -336,38 +338,39 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
 			}
 		}
 
-		if errDeps := asdeps(ctx, config.Runtime.CmdBuilder, config.Runtime.Mode, cmdArgs, deps); errDeps != nil {
+		if errDeps := asdeps(ctx, cfg.Runtime.CmdBuilder, cfg.Runtime.Mode, cmdArgs, deps); errDeps != nil {
 			return errDeps
 		}
 
-		if errExp := asexp(ctx, config.Runtime.CmdBuilder, config.Runtime.Mode, cmdArgs, exp); errExp != nil {
+		if errExp := asexp(ctx, cfg.Runtime.CmdBuilder, cfg.Runtime.Mode, cmdArgs, exp); errExp != nil {
 			return errExp
 		}
 	}
 
 	go func() {
-		_ = completion.Update(ctx, config.Runtime.HTTPClient, dbExecutor,
-			config.AURURL, config.Runtime.CompletionPath, config.CompletionInterval, false)
+		_ = completion.Update(ctx, cfg.Runtime.HTTPClient, dbExecutor,
+			cfg.AURURL, cfg.Runtime.CompletionPath, cfg.CompletionInterval, false)
 	}()
 
 	if errP := downloadPKGBUILDSourceFanout(ctx,
-		config.Runtime.CmdBuilder,
+		cfg.Runtime.CmdBuilder,
 		pkgbuildDirs,
-		true, config.MaxConcurrentDownloads); errP != nil {
+		true, cfg.MaxConcurrentDownloads); errP != nil {
 		text.Errorln(errP)
 	}
 
-	if errB := buildInstallPkgbuilds(ctx, cmdArgs, dbExecutor, dp, do, srcinfos, true, conflicts, noDeps, noCheck); errB != nil {
+	if errB := buildInstallPkgbuilds(ctx, cfg, cmdArgs, dbExecutor, dp, do,
+		srcinfos, true, conflicts, noDeps, noCheck); errB != nil {
 		return errB
 	}
 
 	return nil
 }
 
-func addUpgradeTargetsToArgs(ctx context.Context, dbExecutor db.Executor,
+func addUpgradeTargetsToArgs(ctx context.Context, cfg *settings.Configuration, dbExecutor db.Executor,
 	cmdArgs *parser.Arguments, requestTargets []string, arguments *parser.Arguments,
 ) ([]string, error) {
-	ignore, targets, errUp := sysupgradeTargets(ctx, dbExecutor, cmdArgs.ExistsDouble("u", "sysupgrade"))
+	ignore, targets, errUp := sysupgradeTargets(ctx, cfg, dbExecutor, cmdArgs.ExistsDouble("u", "sysupgrade"))
 	if errUp != nil {
 		return nil, errUp
 	}
@@ -384,7 +387,9 @@ func addUpgradeTargetsToArgs(ctx context.Context, dbExecutor db.Executor,
 	return requestTargets, nil
 }
 
-func removeMake(ctx context.Context, cmdBuilder exe.ICmdBuilder, makeDeps []string, cmdArgs *parser.Arguments) error {
+func removeMake(ctx context.Context, config *settings.Configuration,
+	cmdBuilder exe.ICmdBuilder, makeDeps []string, cmdArgs *parser.Arguments,
+) error {
 	removeArguments := cmdArgs.CopyGlobal()
 
 	err := removeArguments.AddArg("R", "u")
@@ -422,14 +427,16 @@ func inRepos(dbExecutor db.Executor, pkg string) bool {
 	return exists || len(dbExecutor.PackagesFromGroup(target.Name)) > 0
 }
 
-func earlyPacmanCall(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
+func earlyPacmanCall(ctx context.Context, cfg *settings.Configuration,
+	cmdArgs *parser.Arguments, dbExecutor db.Executor,
+) error {
 	arguments := cmdArgs.Copy()
 	arguments.Op = "S"
 	targets := cmdArgs.Targets
 	cmdArgs.ClearTargets()
 	arguments.ClearTargets()
 
-	if config.Runtime.Mode == parser.ModeRepo {
+	if cfg.Runtime.Mode == parser.ModeRepo {
 		arguments.Targets = targets
 	} else {
 		// separate aur and repo targets
@@ -443,8 +450,8 @@ func earlyPacmanCall(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor
 	}
 
 	if cmdArgs.ExistsArg("y", "refresh") || cmdArgs.ExistsArg("u", "sysupgrade") || len(arguments.Targets) > 0 {
-		if err := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			arguments, config.Runtime.Mode, settings.NoConfirm)); err != nil {
+		if err := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
+			arguments, cfg.Runtime.Mode, settings.NoConfirm)); err != nil {
 			return errors.New(gotext.Get("error installing repo packages"))
 		}
 	}
@@ -538,7 +545,7 @@ func parsePackageList(ctx context.Context, cmdBuilder exe.ICmdBuilder,
 	return pkgdests, pkgVersion, nil
 }
 
-func pkgbuildsToSkip(bases []dep.Base, targets stringset.StringSet) stringset.StringSet {
+func pkgbuildsToSkip(cfg *settings.Configuration, bases []dep.Base, targets stringset.StringSet) stringset.StringSet {
 	toSkip := make(stringset.StringSet)
 
 	for _, base := range bases {
@@ -547,11 +554,11 @@ func pkgbuildsToSkip(bases []dep.Base, targets stringset.StringSet) stringset.St
 			isTarget = isTarget || targets.Get(pkg.Name)
 		}
 
-		if (config.ReDownload == "yes" && isTarget) || config.ReDownload == "all" {
+		if (cfg.ReDownload == "yes" && isTarget) || cfg.ReDownload == "all" {
 			continue
 		}
 
-		dir := filepath.Join(config.BuildDir, base.Pkgbase(), ".SRCINFO")
+		dir := filepath.Join(cfg.BuildDir, base.Pkgbase(), ".SRCINFO")
 		pkgbuild, err := gosrc.ParseFile(dir)
 
 		if err == nil {
@@ -595,6 +602,7 @@ func mergePkgbuilds(ctx context.Context, cmdBuilder exe.ICmdBuilder, pkgbuildDir
 
 func buildInstallPkgbuilds(
 	ctx context.Context,
+	cfg *settings.Configuration,
 	cmdArgs *parser.Arguments,
 	dbExecutor db.Executor,
 	dp *dep.Pool,
@@ -620,7 +628,7 @@ func buildInstallPkgbuilds(
 
 	for i, base := range do.Aur {
 		pkg := base.Pkgbase()
-		dir := filepath.Join(config.BuildDir, pkg)
+		dir := filepath.Join(cfg.BuildDir, pkg)
 		built := true
 
 		satisfied := true
@@ -636,11 +644,11 @@ func buildInstallPkgbuilds(
 			}
 		}
 
-		if !satisfied || !config.BatchInstall {
+		if !satisfied || !cfg.BatchInstall {
 			text.Debugln("non batch installing archives:", pkgArchives)
-			errArchive := installPkgArchive(ctx, config.Runtime.CmdBuilder,
-				config.Runtime.Mode, config.Runtime.VCSStore, cmdArgs, pkgArchives)
-			errReason := setInstallReason(ctx, config.Runtime.CmdBuilder, config.Runtime.Mode, cmdArgs, deps, exp)
+			errArchive := installPkgArchive(ctx, cfg.Runtime.CmdBuilder,
+				cfg.Runtime.Mode, cfg.Runtime.VCSStore, cmdArgs, pkgArchives)
+			errReason := setInstallReason(ctx, cfg.Runtime.CmdBuilder, cfg.Runtime.Mode, cmdArgs, deps, exp)
 
 			deps = make([]string, 0)
 			exp = make([]string, 0)
@@ -648,7 +656,7 @@ func buildInstallPkgbuilds(
 
 			if errArchive != nil || errReason != nil {
 				if i != 0 {
-					go config.Runtime.VCSStore.RemovePackages([]string{do.Aur[i-1].String()})
+					go cfg.Runtime.VCSStore.RemovePackages([]string{do.Aur[i-1].String()})
 				}
 
 				if errArchive != nil {
@@ -668,12 +676,12 @@ func buildInstallPkgbuilds(
 		}
 
 		// pkgver bump
-		if err := config.Runtime.CmdBuilder.Show(
-			config.Runtime.CmdBuilder.BuildMakepkgCmd(ctx, dir, args...)); err != nil {
+		if err := cfg.Runtime.CmdBuilder.Show(
+			cfg.Runtime.CmdBuilder.BuildMakepkgCmd(ctx, dir, args...)); err != nil {
 			return errors.New(gotext.Get("error making: %s", base.String()))
 		}
 
-		pkgdests, pkgVersion, errList := parsePackageList(ctx, config.Runtime.CmdBuilder, dir)
+		pkgdests, pkgVersion, errList := parsePackageList(ctx, cfg.Runtime.CmdBuilder, dir)
 		if errList != nil {
 			return errList
 		}
@@ -683,7 +691,7 @@ func buildInstallPkgbuilds(
 			isExplicit = isExplicit || dp.Explicit.Get(b.Name)
 		}
 
-		if config.ReBuild == "no" || (config.ReBuild == "yes" && !isExplicit) {
+		if cfg.ReBuild == "no" || (cfg.ReBuild == "yes" && !isExplicit) {
 			for _, split := range base {
 				pkgdest, ok := pkgdests[split.Name]
 				if !ok {
@@ -707,8 +715,8 @@ func buildInstallPkgbuilds(
 			}
 
 			if installed {
-				err := config.Runtime.CmdBuilder.Show(
-					config.Runtime.CmdBuilder.BuildMakepkgCmd(ctx,
+				err := cfg.Runtime.CmdBuilder.Show(
+					cfg.Runtime.CmdBuilder.BuildMakepkgCmd(ctx,
 						dir, "-c", "--nobuild", "--noextract", "--ignorearch"))
 				if err != nil {
 					return errors.New(gotext.Get("error making: %s", err))
@@ -721,8 +729,8 @@ func buildInstallPkgbuilds(
 		}
 
 		if built {
-			err := config.Runtime.CmdBuilder.Show(
-				config.Runtime.CmdBuilder.BuildMakepkgCmd(ctx,
+			err := cfg.Runtime.CmdBuilder.Show(
+				cfg.Runtime.CmdBuilder.BuildMakepkgCmd(ctx,
 					dir, "-c", "--nobuild", "--noextract", "--ignorearch"))
 			if err != nil {
 				return errors.New(gotext.Get("error making: %s", err))
@@ -736,15 +744,15 @@ func buildInstallPkgbuilds(
 				args = append(args, "--ignorearch")
 			}
 
-			if errMake := config.Runtime.CmdBuilder.Show(
-				config.Runtime.CmdBuilder.BuildMakepkgCmd(ctx,
+			if errMake := cfg.Runtime.CmdBuilder.Show(
+				cfg.Runtime.CmdBuilder.BuildMakepkgCmd(ctx,
 					dir, args...)); errMake != nil {
 				return errors.New(gotext.Get("error making: %s", base.String()))
 			}
 		}
 
 		// conflicts have been checked so answer y for them
-		if config.UseAsk && cmdArgs.ExistsArg("ask") {
+		if cfg.UseAsk && cmdArgs.ExistsArg("ask") {
 			ask, _ := strconv.Atoi(cmdArgs.Options["ask"].First())
 			uask := alpm.QuestionType(ask) | alpm.QuestionTypeConflictPkg
 			cmdArgs.Options["ask"].Set(fmt.Sprint(uask))
@@ -783,7 +791,7 @@ func buildInstallPkgbuilds(
 
 			text.Debugln("checking vcs store for:", pkg.Name)
 			go func(name string) {
-				config.Runtime.VCSStore.Update(ctx, name, srcInfo.Source)
+				cfg.Runtime.VCSStore.Update(ctx, name, srcInfo.Source)
 				wg.Done()
 			}(pkg.Name)
 		}
@@ -792,14 +800,14 @@ func buildInstallPkgbuilds(
 	}
 
 	text.Debugln("installing archives:", pkgArchives)
-	errArchive := installPkgArchive(ctx, config.Runtime.CmdBuilder, config.Runtime.Mode, config.Runtime.VCSStore, cmdArgs, pkgArchives)
+	errArchive := installPkgArchive(ctx, cfg.Runtime.CmdBuilder, cfg.Runtime.Mode, cfg.Runtime.VCSStore, cmdArgs, pkgArchives)
 	if errArchive != nil {
-		go config.Runtime.VCSStore.RemovePackages([]string{do.Aur[len(do.Aur)-1].String()})
+		go cfg.Runtime.VCSStore.RemovePackages([]string{do.Aur[len(do.Aur)-1].String()})
 	}
 
-	errReason := setInstallReason(ctx, config.Runtime.CmdBuilder, config.Runtime.Mode, cmdArgs, deps, exp)
+	errReason := setInstallReason(ctx, cfg.Runtime.CmdBuilder, cfg.Runtime.Mode, cmdArgs, deps, exp)
 	if errReason != nil {
-		go config.Runtime.VCSStore.RemovePackages([]string{do.Aur[len(do.Aur)-1].String()})
+		go cfg.Runtime.VCSStore.RemovePackages([]string{do.Aur[len(do.Aur)-1].String()})
 	}
 
 	settings.NoConfirm = oldConfirm
diff --git a/main.go b/main.go
index acd48d7f..c0aec613 100644
--- a/main.go
+++ b/main.go
@@ -17,6 +17,11 @@ import (
 	"github.com/Jguer/yay/v11/pkg/text"
 )
 
+var (
+	yayVersion = "11.3.0"            // To be set by compiler.
+	localePath = "/usr/share/locale" // To be set by compiler.
+)
+
 func initGotext() {
 	if envLocalePath := os.Getenv("LOCALE_PATH"); envLocalePath != "" {
 		localePath = envLocalePath
@@ -55,7 +60,7 @@ func main() {
 		text.Warnln(gotext.Get("Avoid running yay as root/sudo."))
 	}
 
-	config, err = settings.NewConfig(yayVersion)
+	cfg, err := settings.NewConfig(yayVersion)
 	if err != nil {
 		if str := err.Error(); str != "" {
 			text.Errorln(str)
@@ -66,18 +71,18 @@ func main() {
 		return
 	}
 
-	if config.Debug {
+	if cfg.Debug {
 		text.GlobalLogger.Debug = true
 	}
 
-	if errS := config.RunMigrations(
-		settings.DefaultMigrations(), config.Runtime.ConfigPath); errS != nil {
+	if errS := cfg.RunMigrations(
+		settings.DefaultMigrations(), cfg.Runtime.ConfigPath); errS != nil {
 		text.Errorln(errS)
 	}
 
 	cmdArgs := parser.MakeArguments()
 
-	if err = config.ParseCommandLine(cmdArgs); err != nil {
+	if err = cfg.ParseCommandLine(cmdArgs); err != nil {
 		if str := err.Error(); str != "" {
 			text.Errorln(str)
 		}
@@ -87,29 +92,29 @@ func main() {
 		return
 	}
 
-	if config.Runtime.SaveConfig {
-		if errS := config.Save(config.Runtime.ConfigPath); errS != nil {
+	if cfg.Runtime.SaveConfig {
+		if errS := cfg.Save(cfg.Runtime.ConfigPath); errS != nil {
 			text.Errorln(errS)
 		}
 	}
 
-	if config.SeparateSources {
-		config.Runtime.QueryBuilder = query.NewSourceQueryBuilder(
-			config.Runtime.AURClient, config.Runtime.AURCache,
-			config.Runtime.Logger.Child("querybuilder"), config.SortBy,
-			config.Runtime.Mode, config.SearchBy, config.BottomUp,
-			config.SingleLineResults, config.NewInstallEngine)
+	if cfg.SeparateSources {
+		cfg.Runtime.QueryBuilder = query.NewSourceQueryBuilder(
+			cfg.Runtime.AURClient, cfg.Runtime.AURCache,
+			cfg.Runtime.Logger.Child("querybuilder"), cfg.SortBy,
+			cfg.Runtime.Mode, cfg.SearchBy, cfg.BottomUp,
+			cfg.SingleLineResults, cfg.NewInstallEngine)
 	} else {
-		config.Runtime.QueryBuilder = query.NewMixedSourceQueryBuilder(
-			config.Runtime.AURClient, config.Runtime.AURCache,
-			config.Runtime.Logger.Child("mixed.querybuilder"), config.SortBy,
-			config.Runtime.Mode, config.SearchBy,
-			config.BottomUp, config.SingleLineResults, config.NewInstallEngine)
+		cfg.Runtime.QueryBuilder = query.NewMixedSourceQueryBuilder(
+			cfg.Runtime.AURClient, cfg.Runtime.AURCache,
+			cfg.Runtime.Logger.Child("mixed.querybuilder"), cfg.SortBy,
+			cfg.Runtime.Mode, cfg.SearchBy,
+			cfg.BottomUp, cfg.SingleLineResults, cfg.NewInstallEngine)
 	}
 
 	var useColor bool
 
-	config.Runtime.PacmanConf, useColor, err = settings.RetrievePacmanConfig(cmdArgs, config.PacmanConf)
+	cfg.Runtime.PacmanConf, useColor, err = settings.RetrievePacmanConfig(cmdArgs, cfg.PacmanConf)
 	if err != nil {
 		if str := err.Error(); str != "" {
 			text.Errorln(str)
@@ -120,11 +125,11 @@ func main() {
 		return
 	}
 
-	config.Runtime.CmdBuilder.SetPacmanDBPath(config.Runtime.PacmanConf.DBPath)
+	cfg.Runtime.CmdBuilder.SetPacmanDBPath(cfg.Runtime.PacmanConf.DBPath)
 
 	text.UseColor = useColor
 
-	dbExecutor, err := ialpm.NewExecutor(config.Runtime.PacmanConf)
+	dbExecutor, err := ialpm.NewExecutor(cfg.Runtime.PacmanConf)
 	if err != nil {
 		if str := err.Error(); str != "" {
 			text.Errorln(str)
@@ -144,7 +149,7 @@ func main() {
 		dbExecutor.Cleanup()
 	}()
 
-	if err = handleCmd(ctx, config, cmdArgs, db.Executor(dbExecutor)); err != nil {
+	if err = handleCmd(ctx, cfg, cmdArgs, db.Executor(dbExecutor)); err != nil {
 		if str := err.Error(); str != "" {
 			text.Errorln(str)
 		}
diff --git a/preparer.go b/preparer.go
index ed03a071..7728606f 100644
--- a/preparer.go
+++ b/preparer.go
@@ -66,7 +66,7 @@ func (preper *Preparer) ShouldCleanAURDirs(pkgBuildDirs map[string]string) PostI
 	text.Debugln("added post install hook to clean up AUR dirs", pkgBuildDirs)
 
 	return func(ctx context.Context) error {
-		cleanAfter(ctx, preper.cfg.Runtime.CmdBuilder, pkgBuildDirs)
+		cleanAfter(ctx, preper.cfg, preper.cfg.Runtime.CmdBuilder, pkgBuildDirs)
 		return nil
 	}
 }
@@ -90,7 +90,7 @@ func (preper *Preparer) ShouldCleanMakeDeps(cmdArgs *parser.Arguments) PostInsta
 	text.Debugln("added post install hook to clean up AUR makedeps", preper.makeDeps)
 
 	return func(ctx context.Context) error {
-		return removeMake(ctx, preper.cfg.Runtime.CmdBuilder, preper.makeDeps, cmdArgs)
+		return removeMake(ctx, preper.cfg, preper.cfg.Runtime.CmdBuilder, preper.makeDeps, cmdArgs)
 	}
 }
 
diff --git a/print.go b/print.go
index f67d38d6..268df7a0 100644
--- a/print.go
+++ b/print.go
@@ -11,6 +11,7 @@ import (
 
 	"github.com/Jguer/yay/v11/pkg/db"
 	"github.com/Jguer/yay/v11/pkg/query"
+	"github.com/Jguer/yay/v11/pkg/settings"
 	"github.com/Jguer/yay/v11/pkg/settings/parser"
 	"github.com/Jguer/yay/v11/pkg/stringset"
 	"github.com/Jguer/yay/v11/pkg/text"
@@ -18,7 +19,7 @@ import (
 )
 
 // PrintInfo prints package info like pacman -Si.
-func PrintInfo(a *aur.Pkg, extendedInfo bool) {
+func PrintInfo(config *settings.Configuration, a *aur.Pkg, extendedInfo bool) {
 	text.PrintInfoValue(gotext.Get("Repository"), "aur")
 	text.PrintInfoValue(gotext.Get("Name"), a.Name)
 	text.PrintInfoValue(gotext.Get("Keywords"), a.Keywords...)
@@ -70,8 +71,8 @@ func biggestPackages(dbExecutor db.Executor) {
 }
 
 // localStatistics prints installed packages statistics.
-func localStatistics(ctx context.Context, dbExecutor db.Executor) error {
-	info := statistics(dbExecutor)
+func localStatistics(ctx context.Context, cfg *settings.Configuration, dbExecutor db.Executor) error {
+	info := statistics(cfg, dbExecutor)
 
 	remoteNames := dbExecutor.InstalledRemotePackageNames()
 	text.Infoln(gotext.Get("Yay version v%s", yayVersion))
@@ -85,22 +86,24 @@ func localStatistics(ctx context.Context, dbExecutor db.Executor) error {
 		text.Infoln(gotext.Get("Size of pacman cache %s: %s", path, text.Cyan(text.Human(size))))
 	}
 
-	text.Infoln(gotext.Get("Size of yay cache %s: %s", config.BuildDir, text.Cyan(text.Human(info.yayCache))))
+	text.Infoln(gotext.Get("Size of yay cache %s: %s", cfg.BuildDir, text.Cyan(text.Human(info.yayCache))))
 	fmt.Println(text.Bold(text.Cyan("===========================================")))
 	text.Infoln(gotext.Get("Ten biggest packages:"))
 	biggestPackages(dbExecutor)
 	fmt.Println(text.Bold(text.Cyan("===========================================")))
 
-	query.AURInfoPrint(ctx, config.Runtime.AURClient, remoteNames, config.RequestSplitN)
+	query.AURInfoPrint(ctx, cfg.Runtime.AURClient, remoteNames, cfg.RequestSplitN)
 
 	return nil
 }
 
-func printNumberOfUpdates(ctx context.Context, dbExecutor db.Executor, enableDowngrade bool, filter upgrade.Filter) error {
+func printNumberOfUpdates(ctx context.Context, cfg *settings.Configuration,
+	dbExecutor db.Executor, enableDowngrade bool, filter upgrade.Filter,
+) error {
 	warnings := query.NewWarnings()
 	old := os.Stdout // keep backup of the real stdout
 	os.Stdout = nil
-	aurUp, repoUp, err := upList(ctx, warnings, dbExecutor, enableDowngrade, filter)
+	aurUp, repoUp, err := upList(ctx, cfg, warnings, dbExecutor, enableDowngrade, filter)
 	os.Stdout = old // restoring the real stdout
 
 	if err != nil {
@@ -112,7 +115,7 @@ func printNumberOfUpdates(ctx context.Context, dbExecutor db.Executor, enableDow
 	return nil
 }
 
-func printUpdateList(ctx context.Context, cmdArgs *parser.Arguments,
+func printUpdateList(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments,
 	dbExecutor db.Executor, enableDowngrade bool, filter upgrade.Filter,
 ) error {
 	targets := stringset.FromSlice(cmdArgs.Targets)
@@ -123,7 +126,7 @@ func printUpdateList(ctx context.Context, cmdArgs *parser.Arguments,
 	remoteNames := dbExecutor.InstalledRemotePackageNames()
 	localNames := dbExecutor.InstalledSyncPackageNames()
 
-	aurUp, repoUp, err := upList(ctx, warnings, dbExecutor, enableDowngrade, filter)
+	aurUp, repoUp, err := upList(ctx, cfg, warnings, dbExecutor, enableDowngrade, filter)
 	os.Stdout = old // restoring the real stdout
 
 	if err != nil {
diff --git a/query.go b/query.go
index 61f53813..01f8fc27 100644
--- a/query.go
+++ b/query.go
@@ -33,15 +33,17 @@ func syncSearch(ctx context.Context, pkgS []string,
 }
 
 // SyncInfo serves as a pacman -Si for repo packages and AUR packages.
-func syncInfo(ctx context.Context, cmdArgs *parser.Arguments, pkgS []string, dbExecutor db.Executor) error {
+func syncInfo(ctx context.Context, cfg *settings.Configuration,
+	cmdArgs *parser.Arguments, pkgS []string, dbExecutor db.Executor,
+) error {
 	var (
 		info    []aur.Pkg
 		err     error
 		missing = false
 	)
 
-	pkgS = query.RemoveInvalidTargets(pkgS, config.Runtime.Mode)
-	aurS, repoS := packageSlices(pkgS, dbExecutor)
+	pkgS = query.RemoveInvalidTargets(pkgS, cfg.Runtime.Mode)
+	aurS, repoS := packageSlices(pkgS, cfg, dbExecutor)
 
 	if len(aurS) != 0 {
 		noDB := make([]string, 0, len(aurS))
@@ -51,7 +53,7 @@ func syncInfo(ctx context.Context, cmdArgs *parser.Arguments, pkgS []string, dbE
 			noDB = append(noDB, name)
 		}
 
-		info, err = query.AURInfoPrint(ctx, config.Runtime.AURClient, noDB, config.RequestSplitN)
+		info, err = query.AURInfoPrint(ctx, cfg.Runtime.AURClient, noDB, cfg.RequestSplitN)
 		if err != nil {
 			missing = true
 
@@ -65,8 +67,8 @@ func syncInfo(ctx context.Context, cmdArgs *parser.Arguments, pkgS []string, dbE
 		arguments.ClearTargets()
 		arguments.AddTarget(repoS...)
 
-		err = config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			arguments, config.Runtime.Mode, settings.NoConfirm))
+		err = cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
+			arguments, cfg.Runtime.Mode, settings.NoConfirm))
 		if err != nil {
 			return err
 		}
@@ -78,7 +80,7 @@ func syncInfo(ctx context.Context, cmdArgs *parser.Arguments, pkgS []string, dbE
 
 	if len(info) != 0 {
 		for i := range info {
-			PrintInfo(&info[i], cmdArgs.ExistsDouble("i"))
+			PrintInfo(cfg, &info[i], cmdArgs.ExistsDouble("i"))
 		}
 	}
 
@@ -90,7 +92,7 @@ func syncInfo(ctx context.Context, cmdArgs *parser.Arguments, pkgS []string, dbE
 }
 
 // PackageSlices separates an input slice into aur and repo slices.
-func packageSlices(toCheck []string, dbExecutor db.Executor) (aurNames, repoNames []string) {
+func packageSlices(toCheck []string, config *settings.Configuration, dbExecutor db.Executor) (aurNames, repoNames []string) {
 	for _, _pkg := range toCheck {
 		dbName, name := text.SplitDBFromName(_pkg)
 
@@ -203,7 +205,7 @@ func getFolderSize(path string) (size int64) {
 }
 
 // Statistics returns statistics about packages installed in system.
-func statistics(dbExecutor db.Executor) (res struct {
+func statistics(cfg *settings.Configuration, dbExecutor db.Executor) (res struct {
 	Totaln       int
 	Expln        int
 	TotalSize    int64
@@ -221,11 +223,11 @@ func statistics(dbExecutor db.Executor) (res struct {
 	}
 
 	res.pacmanCaches = make(map[string]int64)
-	for _, path := range config.Runtime.PacmanConf.CacheDir {
+	for _, path := range cfg.Runtime.PacmanConf.CacheDir {
 		res.pacmanCaches[path] = getFolderSize(path)
 	}
 
-	res.yayCache = getFolderSize(config.BuildDir)
+	res.yayCache = getFolderSize(cfg.BuildDir)
 
 	return
 }
diff --git a/upgrade.go b/upgrade.go
index 5d3a9b45..94b238fc 100644
--- a/upgrade.go
+++ b/upgrade.go
@@ -36,7 +36,7 @@ func filterUpdateList(list []db.Upgrade, filter upgrade.Filter) []db.Upgrade {
 }
 
 // upList returns lists of packages to upgrade from each source.
-func upList(ctx context.Context,
+func upList(ctx context.Context, cfg *settings.Configuration,
 	warnings *query.AURWarnings, dbExecutor db.Executor, enableDowngrade bool,
 	filter upgrade.Filter,
 ) (aurUp, repoUp upgrade.UpSlice, err error) {
@@ -58,7 +58,7 @@ func upList(ctx context.Context,
 		}
 	}
 
-	if config.Runtime.Mode.AtLeastRepo() {
+	if cfg.Runtime.Mode.AtLeastRepo() {
 		text.OperationInfoln(gotext.Get("Searching databases for updates..."))
 		wg.Add(1)
 
@@ -69,11 +69,11 @@ func upList(ctx context.Context,
 		}()
 	}
 
-	if config.Runtime.Mode.AtLeastAUR() {
+	if cfg.Runtime.Mode.AtLeastAUR() {
 		text.OperationInfoln(gotext.Get("Searching AUR for updates..."))
 
 		var _aurdata []aur.Pkg
-		_aurdata, err = query.AURInfo(ctx, config.Runtime.AURClient, remoteNames, warnings, config.RequestSplitN)
+		_aurdata, err = query.AURInfo(ctx, cfg.Runtime.AURClient, remoteNames, warnings, cfg.RequestSplitN)
 
 		errs.Add(err)
 
@@ -86,19 +86,19 @@ func upList(ctx context.Context,
 			wg.Add(1)
 
 			go func() {
-				aurUp = upgrade.UpAUR(remote, aurdata, config.TimeUpdate, enableDowngrade)
+				aurUp = upgrade.UpAUR(remote, aurdata, cfg.TimeUpdate, enableDowngrade)
 
 				wg.Done()
 			}()
 
-			if config.Devel {
+			if cfg.Devel {
 				text.OperationInfoln(gotext.Get("Checking development packages..."))
 				wg.Add(1)
 
 				go func() {
-					develUp = upgrade.UpDevel(ctx, remote, aurdata, config.Runtime.VCSStore)
+					develUp = upgrade.UpDevel(ctx, remote, aurdata, cfg.Runtime.VCSStore)
 
-					config.Runtime.VCSStore.CleanOrphans(remote)
+					cfg.Runtime.VCSStore.CleanOrphans(remote)
 					wg.Done()
 				}()
 			}
@@ -185,7 +185,7 @@ func isDevelPackage(pkg alpm.IPackage) bool {
 }
 
 // upgradePkgsMenu handles updating the cache and installing updates.
-func upgradePkgsMenu(aurUp, repoUp upgrade.UpSlice) (stringset.StringSet, []string, error) {
+func upgradePkgsMenu(cfg *settings.Configuration, aurUp, repoUp upgrade.UpSlice) (stringset.StringSet, []string, error) {
 	ignore := make(stringset.StringSet)
 	targets := []string{}
 
@@ -194,7 +194,7 @@ func upgradePkgsMenu(aurUp, repoUp upgrade.UpSlice) (stringset.StringSet, []stri
 		return ignore, nil, nil
 	}
 
-	if !config.UpgradeMenu {
+	if !cfg.UpgradeMenu {
 		for _, pkg := range aurUp.Up {
 			targets = append(targets, pkg.Repository+"/"+pkg.Name)
 		}
@@ -208,11 +208,11 @@ func upgradePkgsMenu(aurUp, repoUp upgrade.UpSlice) (stringset.StringSet, []stri
 	allUp := upgrade.UpSlice{Up: append(repoUp.Up, aurUp.Up...), Repos: append(repoUp.Repos, aurUp.Repos...)}
 
 	fmt.Printf("%s"+text.Bold(" %d ")+"%s\n", text.Bold(text.Cyan("::")), allUpLen, text.Bold(gotext.Get("Packages to upgrade.")))
-	allUp.Print(config.Runtime.Logger)
+	allUp.Print(cfg.Runtime.Logger)
 
 	text.Infoln(gotext.Get("Packages to exclude") + " (eg: \"1 2 3\", \"1-3\", \"^4\" or repo name):")
 
-	numbers, err := text.GetInput(os.Stdin, config.AnswerUpgrade, settings.NoConfirm)
+	numbers, err := text.GetInput(os.Stdin, cfg.AnswerUpgrade, settings.NoConfirm)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -259,12 +259,12 @@ func upgradePkgsMenu(aurUp, repoUp upgrade.UpSlice) (stringset.StringSet, []stri
 }
 
 // Targets for sys upgrade.
-func sysupgradeTargets(ctx context.Context, dbExecutor db.Executor,
+func sysupgradeTargets(ctx context.Context, cfg *settings.Configuration, dbExecutor db.Executor,
 	enableDowngrade bool,
 ) (stringset.StringSet, []string, error) {
 	warnings := query.NewWarnings()
 
-	aurUp, repoUp, err := upList(ctx, warnings, dbExecutor, enableDowngrade,
+	aurUp, repoUp, err := upList(ctx, cfg, warnings, dbExecutor, enableDowngrade,
 		func(*upgrade.Upgrade) bool { return true })
 	if err != nil {
 		return nil, nil, err
@@ -272,5 +272,5 @@ func sysupgradeTargets(ctx context.Context, dbExecutor db.Executor,
 
 	warnings.Print()
 
-	return upgradePkgsMenu(aurUp, repoUp)
+	return upgradePkgsMenu(cfg, aurUp, repoUp)
 }
diff --git a/vcs.go b/vcs.go
index 1d25fc9f..cc059470 100644
--- a/vcs.go
+++ b/vcs.go
@@ -19,15 +19,15 @@ import (
 )
 
 // createDevelDB forces yay to create a DB of the existing development packages.
-func createDevelDB(ctx context.Context, config *settings.Configuration, dbExecutor db.Executor) error {
+func createDevelDB(ctx context.Context, cfg *settings.Configuration, dbExecutor db.Executor) error {
 	remoteNames := dbExecutor.InstalledRemotePackageNames()
-	info, err := query.AURInfoPrint(ctx, config.Runtime.AURClient, remoteNames, config.RequestSplitN)
+	info, err := query.AURInfoPrint(ctx, cfg.Runtime.AURClient, remoteNames, cfg.RequestSplitN)
 	if err != nil {
 		return err
 	}
 
 	bases := dep.GetBases(info)
-	toSkip := pkgbuildsToSkip(bases, stringset.FromSlice(remoteNames))
+	toSkip := pkgbuildsToSkip(cfg, bases, stringset.FromSlice(remoteNames))
 
 	targets := make([]string, 0, len(bases))
 	pkgBuildDirsByBase := make(map[string]string, len(bases))
@@ -37,7 +37,7 @@ func createDevelDB(ctx context.Context, config *settings.Configuration, dbExecut
 			targets = append(targets, base.Pkgbase())
 		}
 
-		pkgBuildDirsByBase[base.Pkgbase()] = filepath.Join(config.BuildDir, base.Pkgbase())
+		pkgBuildDirsByBase[base.Pkgbase()] = filepath.Join(cfg.BuildDir, base.Pkgbase())
 	}
 
 	toSkipSlice := toSkip.ToSlice()
@@ -48,7 +48,7 @@ func createDevelDB(ctx context.Context, config *settings.Configuration, dbExecut
 	}
 
 	if _, errA := download.AURPKGBUILDRepos(ctx,
-		config.Runtime.CmdBuilder, targets, config.AURURL, config.BuildDir, false); errA != nil {
+		cfg.Runtime.CmdBuilder, targets, cfg.AURURL, cfg.BuildDir, false); errA != nil {
 		return err
 	}
 
@@ -63,7 +63,7 @@ func createDevelDB(ctx context.Context, config *settings.Configuration, dbExecut
 			wg.Add(1)
 
 			go func(i string, iP int) {
-				config.Runtime.VCSStore.Update(ctx, srcinfos[i].Packages[iP].Pkgname, srcinfos[i].Source)
+				cfg.Runtime.VCSStore.Update(ctx, srcinfos[i].Packages[iP].Pkgname, srcinfos[i].Source)
 				wg.Done()
 			}(i, iP)
 		}