Add used and total GPU vram variables

length

README.md

@@ -19,7 +19,10 @@ Stormfetch is still in beta, so distro compatibility is limited. If you would li
 ```
 make SYSCONFDIR=/etc
 ```
-- Run the following command to install stormfetch into your system. You may also append a DESTDIR variable at the end of this line if you wish to install in a different location
+- Run the following command to install stormfetch into your system. You may also append a DESTDIR variable at the end of this line if you wish to install in a different root directory
 ```
-make install PREFIX=/usr SYSCONFDIR=/etc
+make install
+make install-config SYSCONFDIR=/etc
 ```
+### Post installation
+- (Optional) Download `curl` from your package manager to fetch the amdgpu.ids database for AMD GPUs. It may be safely uninstalled after running stormfetch once with curl installed

config/config.yml

@@ -1,11 +1,12 @@
 distro_ascii: auto
+disable_amdgpu_ids_warning: false
 modules:
   - name: distribution
   - name: hostname
   - name: kernel
   - name: packages
   - name: shell
-  - name: init
+  - name: init_system
   - name: motherboard
   - name: cpus
   - name: gpus

src/color.go

@@ -5,9 +5,13 @@ import (
 	"strings"
 )
 
-func setupColorMap(asciiArtHeader string) map[int]string {
-	colorMap := make(map[int]string)
-	colorMap[0] = "\033[0m"
+func setupColorMap(asciiArtHeader string) []string {
+	colorMap := make([]string, 10)
+
+	// Set default color map values
+	for i := range 10 {
+		colorMap[i] = "\033[0m"
+	}
 
 	// Return if header is empty
 	if asciiArtHeader == "" {
@@ -16,8 +20,8 @@ func setupColorMap(asciiArtHeader string) map[int]string {
 
 	// Read colors from ascii art header
 	ansiColors := strings.Split(strings.TrimPrefix(asciiArtHeader, "#/"), ";")
-	for i, ansiColor := range ansiColors {
-		colorMap[i+1] = fmt.Sprintf("\033[38;5;%sm", ansiColor)
+	for i := 0; i < 9 && i < len(ansiColors); i++ {
+		colorMap[i+1] = fmt.Sprintf("\033[38;5;%sm", ansiColors[i])
 	}
 
 	return colorMap

src/config.go

@@ -10,7 +10,7 @@ import (
 
 type StormfetchConfig struct {
 	Ascii                   string                   `yaml:"distro_ascii"`
-	DistroName       string                   `yaml:"distro_name"`
+	DisableAmdgpuIdsWarning bool                     `yaml:"disable_amdgpu_ids_warning"`
 	Modules                 []stormfetchModuleConfig `yaml:"modules"`
 	AnsiiColors             []int                    `yaml:"ansii_colors"`
 	ForceConfigAnsii        bool                     `yaml:"force_config_ansii"`
@@ -22,20 +22,22 @@ var config = StormfetchConfig{
 }
 
 func readConfig() {
+	if ConfigPath == "" {
 		// Get home directory
 		userConfigDir, _ := os.UserConfigDir()
 
 		// Find valid config directory
 		if _, err := os.Stat(path.Join(userConfigDir, "stormfetch/config.yml")); err == nil {
-		configPath = path.Join(userConfigDir, "stormfetch/config.yml")
+			ConfigPath = path.Join(userConfigDir, "stormfetch/config.yml")
 		} else if _, err := os.Stat(path.Join(SystemConfigDir, "stormfetch/config.yml")); err == nil {
-		configPath = path.Join(SystemConfigDir, "stormfetch/config.yml")
+			ConfigPath = path.Join(SystemConfigDir, "stormfetch/config.yml")
 		} else {
 			log.Fatalf("Config file not found: %s", err.Error())
 		}
+	}
 
 	// Parse config
-	bytes, err := os.ReadFile(configPath)
+	bytes, err := os.ReadFile(ConfigPath)
 	if err != nil {
 		log.Fatal(err)
 	}

src/go.mod

@@ -1,19 +1,19 @@
 module stormfetch
 
-go 1.22
+go 1.24.0
 
 require (
-	github.com/go-gl/glfw/v3.3/glfw v0.0.0-20240506104042-037f3cc74f2a
-	github.com/jackmordaunt/ghw v1.0.4
+	github.com/go-gl/glfw/v3.3/glfw v0.0.0-20250301202403-da16c1255728
+	github.com/jackmordaunt/ghw v1.0.5
 	github.com/mitchellh/go-ps v1.0.0
 	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
-	github.com/go-ole/go-ole v1.2.6 // indirect
+	github.com/go-ole/go-ole v1.3.0 // indirect
 	github.com/jackmordaunt/pcidb v1.0.1 // indirect
 	github.com/jackmordaunt/wmi v1.2.4 // indirect
 	github.com/kr/pretty v0.1.0 // indirect
-	golang.org/x/sys v0.3.0 // indirect
+	golang.org/x/sys v0.39.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 )

src/go.sum

@@ -1,9 +1,15 @@
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20240506104042-037f3cc74f2a h1:vxnBhFDDT+xzxf1jTJKMKZw3H0swfWk9RpWbBbDK5+0=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20240506104042-037f3cc74f2a/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20250301202403-da16c1255728 h1:RkGhqHxEVAvPM0/R+8g7XRwQnHatO0KAuVcwHo8q9W8=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20250301202403-da16c1255728/go.mod h1:SyRD8YfuKk+ZXlDqYiqe1qMSqjNgtHzBTG810KUagMc=
 github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
+github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
+github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
 github.com/jackmordaunt/ghw v1.0.4 h1:as+COFuPuXaNQC3WqzoHS/E2JYWZU7gN8ompNTUxNxs=
 github.com/jackmordaunt/ghw v1.0.4/go.mod h1:4dReYvJ36CoAzIxlEx8du25Qi/YqKYvEGE9QJoRXiK8=
+github.com/jackmordaunt/ghw v1.0.5 h1:3rTXwu0D9RkungV7/WlhC8HVuDlPaq0aKY8u0I51jLY=
+github.com/jackmordaunt/ghw v1.0.5/go.mod h1:VpFlLXnJErgoRttR3WOxun4v5EE8/xfB4cK26G5q2U0=
 github.com/jackmordaunt/pcidb v1.0.1 h1:uLLZa6kD5P39r2cwMyJJkxmuHfH9Wq19gYQEbYcB0Z4=
 github.com/jackmordaunt/pcidb v1.0.1/go.mod h1:OMmhrZOZVu2hYXhBDZXddypxwKR/dp4DbIgzCkQDxdQ=
 github.com/jackmordaunt/wmi v1.2.4 h1:/XyuMiKby0qXNQp1j0uU0JqTWLM0QGOVok1Hf5Yagtg=
@@ -16,8 +22,11 @@ github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/mitchellh/go-ps v1.0.0 h1:i6ampVEEF4wQFF+bkYfwYgY+F/uYJDktmvLPf7qIgjc=
 github.com/mitchellh/go-ps v1.0.0/go.mod h1:J4lOc8z8yJs6vUwklHw2XEIiT4z4C40KtWVN3nvg8Pg=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ=
 golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk=
+golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

src/hardware.go

@@ -1,9 +1,10 @@
 package main
 
 import (
+	"fmt"
 	"os"
-	"os/exec"
 	"slices"
+	"strconv"
 	"strings"
 
 	"github.com/go-gl/glfw/v3.3/glfw"
@@ -11,12 +12,22 @@ import (
 )
 
 type CPU struct {
-	Vendor  string
 	Model   string
 	Cores   int
 	Threads int
 }
 
+type GPU struct {
+	PCIAddress string
+	Vendor     string
+	Name       string
+	Product    string
+	Subsystem  string
+	Driver     string
+	VramTotal  string
+	VramUsed   string
+}
+
 type Monitor struct {
 	Width       int
 	Height      int
@@ -36,9 +47,23 @@ func GetCPUs(hiddenCPUs []int) []CPU {
 			continue
 		}
 
+		// Remove unnecessary information from the CPU model
+		model := cpu.Model
+		stringsToRemove := []string{
+			" CPU", " FPU", " APU", " Processor",
+			" Dual-Core", " Quad-Core", " Six-Core", " Eight-Core", " Ten-Core",
+			" 2-Core", " 4-Core", " 6-Core", " 8-Core", " 10-Core", " 12-Core", " 14-Core", " 16-Core",
+		}
+		for _, str := range stringsToRemove {
+			model = strings.ReplaceAll(model, str, "")
+		}
+		model = strings.Split(model, "w/ Radeon ")[0]
+		model = strings.Split(model, "with Radeon ")[0]
+		model = strings.Split(model, "@")[0]
+		model = strings.TrimSpace(model)
+
 		ret = append(ret, CPU{
-			Vendor:  cpu.Vendor,
-			Model:   cpu.Model,
+			Model:   model,
 			Cores:   int(cpu.NumCores),
 			Threads: int(cpu.NumThreads),
 		})
@@ -47,22 +72,94 @@ func GetCPUs(hiddenCPUs []int) []CPU {
 	return ret
 }
 
-func GetGPUModels(hiddenGPUS []int) (ret []string) {
-	cmd := exec.Command("sh", "-c", "lspci -v -m | grep 'VGA' -A6 | grep '^Device:'")
-	bytes, err := cmd.Output()
+func GetGPUModels(hiddenGPUs []int) []GPU {
+	ret := make([]GPU, 0)
+
+	// Set stderr to nil to avoid warnings
+	stderr := os.Stderr
+	os.Stderr = nil
+
+	gpus, err := ghw.GPU()
 	if err != nil {
-		return nil
+		return ret
 	}
 
-	for i, gpu := range strings.Split(string(bytes), "\n") {
-		if slices.Contains(hiddenGPUS, i+1) {
+	// Restore stderr
+	os.Stderr = stderr
+
+	for i, gpu := range gpus.GraphicsCards {
+		if slices.Contains(hiddenGPUs, i+1) {
 			continue
 		}
-		if gpu == "" {
-			continue
+
+		// Set alternative names for vendors
+		var vendor string
+		switch gpu.DeviceInfo.Vendor.ID {
+		case "1002":
+			vendor = "AMD"
+		case "10de":
+			vendor = "Nvidia"
+		case "8086":
+			vendor = "Intel"
+		default:
+			vendor = gpu.DeviceInfo.Vendor.Name
 		}
-		gpu = strings.TrimPrefix(strings.TrimSpace(gpu), "Device:\t")
-		ret = append(ret, gpu)
+
+		// Set GPU name
+		name := ""
+
+		// Use GPU name from amdgpu.ids database
+		if vendor == "AMD" {
+			fetchedName, err := fetchAmdGpuName(gpu.DeviceInfo.Product.ID, gpu.DeviceInfo.Revision)
+			if err == nil && !config.DisableAmdgpuIdsWarning {
+				name = fetchedName
+			} else {
+				fmt.Println("Warning: could not fetch GPU name from amdgpu.ids database! Error: " + err.Error())
+				fmt.Println("         You can disable this warning in the configuration file")
+			}
+		}
+
+		if name == "" {
+			if gpu.DeviceInfo.Subsystem.Name == "" || gpu.DeviceInfo.Subsystem.Name == "unknown" {
+				// Set GPU name to product name
+				name = gpu.DeviceInfo.Product.Name
+			} else {
+				// Set GPU name to subsystem name
+				name = gpu.DeviceInfo.Subsystem.Name
+			}
+
+			// Use GPU name in brackets
+			leftBracket := strings.IndexByte(name, '[')
+			rightBracket := strings.IndexByte(name, ']')
+			if leftBracket != -1 && rightBracket != -1 {
+				name = name[leftBracket+1 : rightBracket]
+			}
+		}
+
+		// Get VRAM
+		vramTotal := "Unknown"
+		bytes, err := os.ReadFile("/sys/class/drm/card" + strconv.Itoa(gpu.Index) + "/device/mem_info_vram_total")
+		if err == nil {
+			vramUint, _ := strconv.ParseUint(strings.TrimSpace(string(bytes)), 10, 64)
+			vramTotal = FormatBytes(vramUint)
+		}
+		vramUsed := "Unknown"
+		bytes, err = os.ReadFile("/sys/class/drm/card" + strconv.Itoa(gpu.Index) + "/device/mem_info_vram_used")
+		if err == nil {
+			vramUint, _ := strconv.ParseUint(strings.TrimSpace(string(bytes)), 10, 64)
+			vramUsed = FormatBytes(vramUint)
+		}
+
+		ret = append(ret, GPU{
+			PCIAddress: gpu.Address,
+			Vendor:     vendor,
+			Name:       name,
+			Product:    gpu.DeviceInfo.Product.Name,
+			Subsystem:  gpu.DeviceInfo.Subsystem.Name,
+			Driver:     gpu.DeviceInfo.Driver,
+			VramTotal:  vramTotal,
+			VramUsed:   vramUsed,
+		})
 	}
 
 	return ret
@@ -73,7 +170,11 @@ func GetMotherboardModel() string {
 	if err != nil {
 		return ""
 	}
-	return strings.TrimSpace(string(bytes))
+
+	// Remove duplicate whitespaces
+	ret := strings.Join(strings.Fields(string(bytes)), " ")
+
+	return ret
 }
 
 func GetMonitors() []Monitor {

src/main.go

@@ -15,22 +15,22 @@ var SystemConfigDir = "/etc/"
 
 // Flag variables
 var ShowVersion = false
+var ConfigPath = ""
+var Ascii = ""
 var ShowModuleTimeTaken = false
 
-var configPath = ""
-
 func main() {
-	readConfig()
 	parseFlags()
+	readConfig()
 	initializeModuleMap()
 	run()
 }
 
 func parseFlags() {
 	flag.BoolVar(&ShowVersion, "version", false, "Show Stormfetch version")
+	flag.StringVar(&ConfigPath, "config", "", "Use the specified config file")
 	flag.BoolVar(&ShowModuleTimeTaken, "time-taken", false, "Show time taken to execute each module")
-	flag.StringVar(&config.Ascii, "ascii", config.Ascii, "Set distro ascii")
-	flag.StringVar(&config.DistroName, "distro-name", config.DistroName, "Set distro name")
+	flag.StringVar(&Ascii, "ascii", "", "Set distro ascii")
 	flag.Parse()
 }
 
@@ -91,6 +91,9 @@ func run() {
 		text := module.Execute(module)
 		end := time.Now().UnixMilli()
 
+		// Insert default color at the start of the module's text
+		text = colorMap[0] + text
+
 		// Show time taken
 		if ShowModuleTimeTaken {
 			fmt.Printf("Module '%s' took %d milliseconds\n", module.Name, end-start)
@@ -104,7 +107,7 @@ func run() {
 		}
 
 		// Continue if text length is 0
-		if len(textNoColor) == 0 {
+		if len(textNoColor)-len(colorMap[0]) == 0 {
 			continue
 		}
 

src/modules.go

@@ -100,10 +100,12 @@ func initializeModuleMap() {
 
 	// Packages module
 	packagesModule := StormfetchModule{stormfetchModuleConfig: stormfetchModuleConfig{Name: "packages", Format: "%3Packages: %4$PACKAGES"}, Execute: func(sm StormfetchModule) string {
+		packages := GetInstalledPackages()
+
 		return os.Expand(sm.Format, func(s string) string {
 			switch s {
 			case "PACKAGES":
-				return GetInstalledPackages()
+				return packages
 			default:
 				return ""
 			}
@@ -113,10 +115,12 @@ func initializeModuleMap() {
 
 	// Shell module
 	shellModule := StormfetchModule{stormfetchModuleConfig: stormfetchModuleConfig{Name: "shell", Format: "%3Shell: %4$SHELL"}, Execute: func(sm StormfetchModule) string {
+		shell := GetShell()
+
 		return os.Expand(sm.Format, func(s string) string {
 			switch s {
 			case "SHELL":
-				return GetShell()
+				return shell
 			default:
 				return ""
 			}
@@ -126,10 +130,16 @@ func initializeModuleMap() {
 
 	// Init system module
 	initSystemModule := StormfetchModule{stormfetchModuleConfig: stormfetchModuleConfig{Name: "init_system", Format: "%3Init: %4$INIT"}, Execute: func(sm StormfetchModule) string {
+		initSystem := GetInitSystem()
+
+		if initSystem == "" {
+			return ""
+		}
+
 		return os.Expand(sm.Format, func(s string) string {
 			switch s {
 			case "INIT":
-				return GetInitSystem()
+				return initSystem
 			default:
 				return ""
 			}
@@ -139,10 +149,12 @@ func initializeModuleMap() {
 
 	// Libc module
 	libcModule := StormfetchModule{stormfetchModuleConfig: stormfetchModuleConfig{Name: "libc", Format: "%3Libc: %4$LIBC"}, Execute: func(sm StormfetchModule) string {
+		libc := GetLibc()
+
 		return os.Expand(sm.Format, func(s string) string {
 			switch s {
 			case "LIBC":
-				return GetLibc()
+				return libc
 			default:
 				return ""
 			}
@@ -188,8 +200,6 @@ func initializeModuleMap() {
 				switch s {
 				case "CPU_NUM":
 					return strconv.Itoa(i + 1)
-				case "CPU_VENDOR":
-					return cpu.Vendor
 				case "CPU_MODEL":
 					return cpu.Model
 				case "CPU_CORES":
@@ -209,7 +219,7 @@ func initializeModuleMap() {
 	RegisterModule(cpusModule)
 
 	// GPUs module
-	gpusModule := StormfetchModule{stormfetchModuleConfig: stormfetchModuleConfig{Name: "gpus", Format: "%3GPU: %4$GPU_MODEL"}, Execute: func(sm StormfetchModule) string {
+	gpusModule := StormfetchModule{stormfetchModuleConfig: stormfetchModuleConfig{Name: "gpus", Format: "%3GPU: %4$GPU_VENDOR $GPU_NAME"}, Execute: func(sm StormfetchModule) string {
 		hiddenGPUsInterface, _ := sm.GetData("hidden_gpus", make([]any, 0))
 
 		// Convert interface slices to string slices
@@ -226,8 +236,20 @@ func initializeModuleMap() {
 				switch s {
 				case "GPU_NUM":
 					return strconv.Itoa(i + 1)
-				case "GPU_MODEL":
-					return gpu
+				case "GPU_VENDOR":
+					return gpu.Vendor
+				case "GPU_NAME":
+					return gpu.Name
+				case "GPU_PRODUCT":
+					return gpu.Product
+				case "GPU_SUBSYSTEM":
+					return gpu.Subsystem
+				case "GPU_DRIVER":
+					return gpu.Driver
+				case "GPU_VRAM_TOTAL":
+					return gpu.VramTotal
+				case "GPU_VRAM_USED":
+					return gpu.VramUsed
 				default:
 					return ""
 				}
@@ -244,6 +266,10 @@ func initializeModuleMap() {
 	memoryModule := StormfetchModule{stormfetchModuleConfig: stormfetchModuleConfig{Name: "memory", Format: "%3Memory: %4$MEM_USED MiB / $MEM_TOTAL MiB"}, Execute: func(sm StormfetchModule) string {
 		memoryInfo := GetMemoryInfo()
 
+		if memoryInfo == nil {
+			return ""
+		}
+
 		return os.Expand(sm.Format, func(s string) string {
 			switch s {
 			case "MEM_TOTAL":
@@ -330,10 +356,12 @@ func initializeModuleMap() {
 
 	// Local IP module
 	localIpModule := StormfetchModule{stormfetchModuleConfig: stormfetchModuleConfig{Name: "local_ip", Format: "%3Local IP: %4$LOCAL_IP"}, Execute: func(sm StormfetchModule) string {
+		localIP := GetLocalIP()
+
 		return os.Expand(sm.Format, func(s string) string {
 			switch s {
 			case "LOCAL_IP":
-				return GetLocalIP()
+				return localIP
 			default:
 				return ""
 			}
@@ -349,6 +377,7 @@ func initializeModuleMap() {
 		}
 
 		dewm := GetDEWM()
+		displayProtocol := GetDisplayProtocol()
 
 		// Return empty string if can't detect DE/WM
 		if dewm.Name == "Unknown" {
@@ -364,7 +393,7 @@ func initializeModuleMap() {
 			case "DEWM_VERSION":
 				return dewm.Version
 			case "DISPLAY_PROTOCOL":
-				return GetDisplayProtocol()
+				return displayProtocol
 			default:
 				return ""
 			}
@@ -399,4 +428,37 @@ func initializeModuleMap() {
 		return builder.String()
 	}}
 	RegisterModule(monitorsModule)
+
+	// Custom module
+	customModule := StormfetchModule{stormfetchModuleConfig: stormfetchModuleConfig{Name: "custom"}, Execute: func(sm StormfetchModule) string {
+		shell, _ := sm.GetData("shell", "/bin/sh")
+		commandList, _ := sm.GetData("commands", make([]any, 0))
+
+		// Exeucte all commands
+		commandOutput := make(map[int]string)
+		for i, value := range commandList.([]any) {
+			command, ok := value.(string)
+			if !ok {
+				continue
+			}
+
+			commandOutput[i+1] = runCommand(command, shell.(string))
+		}
+
+		return os.Expand(sm.Format, func(s string) string {
+			if len(s) <= 4 || !strings.HasPrefix(s, "CMD_") {
+				return ""
+			}
+
+			commandIndexStr := strings.Split(s, "CMD_")[1]
+
+			commandIndex, err := strconv.Atoi(commandIndexStr)
+			if err != nil {
+				return ""
+			}
+
+			return commandOutput[commandIndex]
+		})
+	}}
+	RegisterModule(customModule)
 }

src/pms.go

@@ -2,25 +2,29 @@ package main
 
 import (
 	"fmt"
+	"os"
 	"os/exec"
+	"path"
+	"strconv"
 	"strings"
 )
 
 type PackageManager struct {
 	Name           string
 	ExecutableName string
-	PackageListCommand string
+	GetPackages    func(...any) int
+	FunctionInput  []any
 }
 
 var PackageManagers = []PackageManager{
-	{Name: "dpkg", ExecutableName: "dpkg", PackageListCommand: "dpkg-query -f '${Package}\\n' -W"},
-	{Name: "pacman", ExecutableName: "pacman", PackageListCommand: "pacman -Q"},
-	{Name: "rpm", ExecutableName: "rpm", PackageListCommand: "rpm -qa"},
-	{Name: "xbps", ExecutableName: "xbps-query", PackageListCommand: "xbps-query -l"},
-	{Name: "bpm", ExecutableName: "bpm", PackageListCommand: "ls /var/lib/bpm/installed/"},
-	{Name: "portage", ExecutableName: "emerge", PackageListCommand: "find /var/db/pkg/*/ -mindepth 1 -maxdepth 1"},
-	{Name: "flatpak", ExecutableName: "flatpak", PackageListCommand: "flatpak list"},
-	{Name: "snap", ExecutableName: "snap", PackageListCommand: "snap list | tail +2"},
+	{Name: "dpkg", ExecutableName: "dpkg", GetPackages: pmFileLines, FunctionInput: []any{"/var/lib/dpkg/status", "Status: install ok installed"}},
+	{Name: "pacman", ExecutableName: "pacman", GetPackages: pmDirectoryElements, FunctionInput: []any{"/var/lib/pacman/local/", true}},
+	{Name: "rpm", ExecutableName: "rpm", GetPackages: pmShellCommandLines, FunctionInput: []any{"rpm -qa"}},
+	{Name: "xbps", ExecutableName: "xbps-query", GetPackages: pmFileLines, FunctionInput: []any{"/var/db/xbps/pkgdb-0.38.plist", "<string>installed</string>"}},
+	{Name: "bpm", ExecutableName: "bpm", GetPackages: pmDirectoryElements, FunctionInput: []any{"/var/lib/bpm/installed/"}},
+	{Name: "portage", ExecutableName: "emerge", GetPackages: pmPortage},
+	{Name: "flatpak", ExecutableName: "flatpak", GetPackages: pmFlatpak},
+	{Name: "snap", ExecutableName: "snap", GetPackages: pmSnap},
 }
 
 func (pm *PackageManager) CountPackages() int {
@@ -29,12 +33,7 @@ func (pm *PackageManager) CountPackages() int {
 		return 0
 	}
 
-	output, err := exec.Command("/bin/sh", "-c", pm.PackageListCommand).Output()
-	if err != nil {
-		return 0
-	}
-
-	return strings.Count(string(output), "\n")
+	return pm.GetPackages(pm.FunctionInput...)
 }
 
 func GetInstalledPackages() (ret string) {
@@ -51,3 +50,128 @@ func GetInstalledPackages() (ret string) {
 
 	return ret
 }
+
+func pmDirectoryElements(args ...any) int {
+	directory := args[0].(string)
+	dirsOnly := false
+	if len(args) >= 2 {
+		dirsOnly = args[1].(bool)
+	}
+	total := 0
+
+	dirEntries, _ := os.ReadDir(directory)
+	for _, entry := range dirEntries {
+		if !entry.IsDir() && dirsOnly {
+			continue
+		}
+		total++
+	}
+
+	return total
+}
+
+func pmFileLines(args ...any) int {
+	filepath := args[0].(string)
+	mustContain := ""
+	if len(args) >= 2 {
+		mustContain = args[1].(string)
+	}
+	total := 0
+
+	content, err := os.ReadFile(filepath)
+	if err == nil {
+		for _, line := range strings.Split(strings.TrimSpace(string(content)), "\n") {
+			if mustContain != "" && !strings.Contains(line, mustContain) {
+				continue
+			}
+
+			total++
+		}
+	}
+
+	return total
+}
+
+func pmShellCommandLines(args ...any) int {
+	command := args[0].(string)
+
+	output := runCommand(command, "/bin/sh")
+
+	return len(strings.Split(output, "\n"))
+}
+
+func pmShellCommandOutput(args ...any) int {
+	command := args[0].(string)
+
+	output := runCommand(command, "/bin/sh")
+
+	packageCount, _ := strconv.Atoi(output)
+	return packageCount
+}
+
+func pmPortage(args ...any) int {
+	portageDir := "/var/db/pkg"
+	total := 0
+
+	dirEntries, _ := os.ReadDir(portageDir)
+	for _, repo := range dirEntries {
+		if !repo.IsDir() {
+			continue
+		}
+
+		packages, _ := os.ReadDir(path.Join(portageDir, repo.Name()))
+		total += len(packages)
+	}
+
+	return total
+}
+
+func pmFlatpak(args ...any) int {
+	arch := GetArch()
+	flatpakDir := "/var/lib/flatpak"
+	total := 0
+
+	// Count applications
+	apps, err := os.ReadDir(path.Join(flatpakDir, "app"))
+	if err == nil {
+		for _, app := range apps {
+			if strings.HasSuffix(app.Name(), ".Locale") || strings.HasSuffix(app.Name(), ".Debug") {
+				continue
+			}
+
+			dirEntries, _ := os.ReadDir(path.Join(flatpakDir, "app", app.Name(), arch))
+
+			total += len(dirEntries)
+		}
+	}
+
+	// Count runtimes
+	runtimes, err := os.ReadDir(path.Join(flatpakDir, "runtime"))
+	if err == nil {
+		for _, runtime := range runtimes {
+			if strings.HasSuffix(runtime.Name(), ".Locale") || strings.HasSuffix(runtime.Name(), ".Debug") {
+				continue
+			}
+
+			dirEntries, _ := os.ReadDir(path.Join(flatpakDir, "runtime", runtime.Name(), arch))
+
+			total += len(dirEntries)
+		}
+	}
+
+	return total
+}
+
+func pmSnap(args ...any) int {
+	total := pmDirectoryElements("/snap", true)
+	if total > 0 {
+		return total - 1
+	}
+
+	total = pmDirectoryElements("/var/lib/snapd/snap", true)
+	if total > 0 {
+		return total - 1
+	}
+
+	return 0
+}

src/system.go

@@ -22,10 +22,6 @@ func GetDistroInfo() DistroInfo {
 		LongName:  "Unknown",
 		ShortName: "Unknown",
 	}
-	if strings.TrimSpace(config.DistroName) != "" {
-		info.LongName = strings.TrimSpace(config.DistroName)
-		info.ShortName = strings.TrimSpace(config.DistroName)
-	}
 
 	// Detect release file location
 	var releaseFile string
@@ -39,20 +35,23 @@ func GetDistroInfo() DistroInfo {
 		return info
 	}
 
+	// Read release file
 	releaseMap, err := ReadKeyValueFile(releaseFile)
 	if err != nil {
 		return info
 	}
 
+	// Set struct fields
 	if id, ok := releaseMap["ID"]; ok {
 		info.ID = id
 	}
-	if longName, ok := releaseMap["PRETTY_NAME"]; ok && info.LongName == "Unknown" {
+	if longName, ok := releaseMap["PRETTY_NAME"]; ok {
 		info.LongName = longName
 	}
-	if shortName, ok := releaseMap["NAME"]; ok && info.ShortName == "Unknown" {
+	if shortName, ok := releaseMap["NAME"]; ok {
 		info.ShortName = shortName
 	}
+
 	return info
 }
 
@@ -65,40 +64,36 @@ func GetDistroAsciiArt() string {
  (|     | )
 /'\_   _/'\
 \___)=(___/`
-	var id string
-	if config.Ascii == "auto" {
-		id = GetDistroInfo().ID
+
+	// Get ascii name to use
+	var asciiName string
+	if Ascii != "" {
+		asciiName = Ascii
+	} else if config.Ascii == "auto" {
+		asciiName = GetDistroInfo().ID
 	} else {
-		id = config.Ascii
+		asciiName = config.Ascii
 	}
+
+	// Check for ascii art in home directory
 	userConfDir, err := os.UserConfigDir()
-	if err != nil {
-		if _, err := os.Stat(path.Join(SystemConfigDir, "stormfetch/ascii/", id)); err == nil {
-			bytes, err := os.ReadFile(path.Join(SystemConfigDir, "stormfetch/ascii/", id))
-			if err != nil {
+	if err == nil {
+		if _, err := os.Stat(path.Join(userConfDir, "stormfetch/ascii/", asciiName)); err == nil {
+			if bytes, err := os.ReadFile(path.Join(userConfDir, "stormfetch/ascii/", asciiName)); err == nil {
+				return strings.TrimRight(string(bytes), "\n")
+			}
+		}
+	}
+
+	// Check for ascii art in system config directory
+	if _, err := os.Stat(path.Join(SystemConfigDir, "stormfetch/ascii/", asciiName)); err == nil {
+		if bytes, err := os.ReadFile(path.Join(SystemConfigDir, "stormfetch/ascii/", asciiName)); err == nil {
+			return strings.TrimRight(string(bytes), "\n")
+		}
+	}
+
 	return defaultAscii
 }
-			return string(bytes)
-		} else {
-			return defaultAscii
-		}
-	}
-	if _, err := os.Stat(path.Join(userConfDir, "stormfetch/ascii/", id)); err == nil {
-		bytes, err := os.ReadFile(path.Join(userConfDir, "stormfetch/ascii/", id))
-		if err != nil {
-			return defaultAscii
-		}
-		return string(bytes)
-	} else if _, err := os.Stat(path.Join(SystemConfigDir, "stormfetch/ascii/", id)); err == nil {
-		bytes, err := os.ReadFile(path.Join(SystemConfigDir, "stormfetch/ascii/", id))
-		if err != nil {
-			return defaultAscii
-		}
-		return strings.TrimRight(string(bytes), "\n\t ")
-	} else {
-		return defaultAscii
-	}
-}
 
 func GetArch() string {
 	uname := syscall.Utsname{}
@@ -138,42 +133,32 @@ func GetKernel() (string, string) {
 }
 
 func GetInitSystem() string {
-	runCommand := func(command string) string {
-		cmd := exec.Command("/bin/sh", "-c", command)
-		workdir, err := os.Getwd()
-		if err != nil {
-			return ""
-		}
-		cmd.Dir = workdir
-		cmd.Env = os.Environ()
-		out, err := cmd.Output()
-		if err != nil {
-			return ""
-		}
-		return strings.TrimSpace(string(out))
-	}
-
 	process, err := ps.FindProcess(1)
 	if err != nil {
 		return ""
 	}
 
+	// Return if init system can't be found
+	if process == nil {
+		return ""
+	}
+
 	// Special cases
 	// OpenRC check
 	if _, err := os.Stat("/usr/sbin/openrc"); err == nil {
-		return "OpenRC " + runCommand("openrc --version | awk '{print $3}'")
+		return "OpenRC " + runCommand("openrc --version | awk '{print $3}'", "/bin/sh")
 	}
 
 	// Default PID 1 process name checking
 	switch process.Executable() {
 	case "systemd":
-		return "Systemd " + runCommand("systemctl --version | head -n1 | awk '{print $2}'")
+		return "Systemd " + runCommand("systemctl --version | head -n1 | awk '{print $2}'", "/bin/sh")
 	case "runit":
 		return "Runit"
 	case "dinit":
-		return "Dinit " + runCommand("dinit --version | head -n1 | awk '{print substr($3, 1, length($3)-1)}'")
+		return "Dinit " + runCommand("dinit --version | head -n1 | awk '{print substr($3, 1, length($3)-1)}'", "/bin/sh")
 	case "enit":
-		return "Enit " + runCommand("enit --version | awk '{print $3}'")
+		return "Enit " + runCommand("enit --version | awk '{print $3}'", "/bin/sh")
 	default:
 		return process.Executable()
 	}

src/user.go

@@ -3,7 +3,6 @@ package main
 import (
 	"log"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"slices"
 	"strconv"
@@ -19,20 +18,6 @@ type DEWM struct {
 }
 
 func GetShell() string {
-	runCommand := func(command string) string {
-		cmd := exec.Command("/bin/sh", "-c", command)
-		workdir, err := os.Getwd()
-		if err != nil {
-			return ""
-		}
-		cmd.Dir = workdir
-		cmd.Env = os.Environ()
-		out, err := cmd.Output()
-		if err != nil {
-			return ""
-		}
-		return strings.TrimSpace(string(out))
-	}
 	file, err := os.ReadFile("/etc/passwd")
 	if err != nil {
 		return ""
@@ -54,13 +39,13 @@ func GetShell() string {
 	case "dash":
 		return "Dash"
 	case "bash":
-		return "Bash " + runCommand("echo $BASH_VERSION")
+		return "Bash " + runCommand("echo $BASH_VERSION", "/bin/sh")
 	case "zsh":
-		return "Zsh " + runCommand("$SHELL --version | awk '{print $2}'")
+		return "Zsh " + runCommand("$SHELL --version | awk '{print $2}'", "/bin/sh")
 	case "fish":
-		return "Fish " + runCommand("$SHELL --version | awk '{print $3}'")
+		return "Fish " + runCommand("$SHELL --version | awk '{print $3}'", "/bin/sh")
 	case "nu":
-		return "Nushell " + runCommand("$SHELL --version")
+		return "Nushell " + runCommand("$SHELL --version", "/bin/sh")
 	default:
 		return "Unknown"
 	}
@@ -79,53 +64,39 @@ func GetDEWM() DEWM {
 	processExists := func(process string) bool {
 		return slices.Contains(executables, process)
 	}
-	runCommand := func(command string) string {
-		cmd := exec.Command("/bin/sh", "-c", command)
-		workdir, err := os.Getwd()
-		if err != nil {
-			return ""
-		}
-		cmd.Dir = workdir
-		cmd.Env = os.Environ()
-		out, err := cmd.Output()
-		if err != nil {
-			return ""
-		}
-		return strings.TrimSpace(string(out))
-	}
 	if processExists("plasmashell") {
 		dewm := DEWM{
 			Name:    "KDE Plasma",
 			Type:    "DE",
-			Version: runCommand("plasmashell --version | awk '{print $2}'"),
+			Version: runCommand("plasmashell --version | awk '{print $2}'", "/bin/sh"),
 		}
 		return dewm
 	} else if processExists("gnome-session") {
 		dewm := DEWM{
 			Name:    "Gnome",
 			Type:    "DE",
-			Version: runCommand("gnome-shell --version | awk '{print $3}'"),
+			Version: runCommand("gnome-shell --version | awk '{print $3}'", "/bin/sh"),
 		}
 		return dewm
 	} else if processExists("xfce4-session") {
 		dewm := DEWM{
 			Name:    "XFCE",
 			Type:    "DE",
-			Version: runCommand("xfce4-session --version | head -n1 | awk '{print $2}'"),
+			Version: runCommand("xfce4-session --version | head -n1 | awk '{print $2}'", "/bin/sh"),
 		}
 		return dewm
 	} else if processExists("cinnamon") {
 		dewm := DEWM{
 			Name:    "Cinnamon",
 			Type:    "DE",
-			Version: runCommand("cinnamon --version | awk '{print $3}'"),
+			Version: runCommand("cinnamon --version | awk '{print $3}'", "/bin/sh"),
 		}
 		return dewm
 	} else if processExists("mate-panel") {
 		dewm := DEWM{
 			Name:    "MATE",
 			Type:    "DE",
-			Version: runCommand("mate-about --version | awk '{print $4}'"),
+			Version: runCommand("mate-about --version | awk '{print $4}'", "/bin/sh"),
 		}
 		return dewm
 	} else if processExists("lxsession") {
@@ -139,23 +110,23 @@ func GetDEWM() DEWM {
 		dewm := DEWM{
 			Name:    "LXQt",
 			Type:    "DE",
-			Version: runCommand("lxqt-session --version | head -n1 | awk '{print $2}'"),
+			Version: runCommand("lxqt-session --version | head -n1 | awk '{print $2}'", "/bin/sh"),
 		}
 		return dewm
 	} else if processExists("i3") || processExists("i3-with-shmlog") {
 		dewm := DEWM{
 			Name:    "i3",
 			Type:    "WM",
-			Version: runCommand("i3 --version | awk '{print $3}'"),
+			Version: runCommand("i3 --version | awk '{print $3}'", "/bin/sh"),
 		}
 		return dewm
 	} else if processExists("sway") {
 		dewm := DEWM{
 			Name:    "Sway",
 			Type:    "WM",
-			Version: runCommand("sway --version | awk '{print $3}'"),
+			Version: runCommand("sway --version | awk '{print $3}'", "/bin/sh"),
 		}
-		if runCommand("sway --version | awk '{print $1}'") == "swayfx" {
+		if runCommand("sway --version | awk '{print $1}'", "/bin/sh") == "swayfx" {
 			dewm.Name = "SwayFX"
 		} else {
 			dewm.Name = "Sway"
@@ -165,21 +136,21 @@ func GetDEWM() DEWM {
 		dewm := DEWM{
 			Name:    "Bspwm",
 			Type:    "WM",
-			Version: runCommand("bspwm -v"),
+			Version: runCommand("bspwm -v", "/bin/sh"),
 		}
 		return dewm
 	} else if processExists("Hyprland") {
 		dewm := DEWM{
 			Name:    "Hyprland",
 			Type:    "WM",
-			Version: runCommand("hyprctl version | sed -n 3p | awk '{print $2}' | tr -d 'v,'"),
+			Version: runCommand("hyprctl version | sed -n 3p | awk '{print $2}' | tr -d 'v,'", "/bin/sh"),
 		}
 		return dewm
 	} else if processExists("icewm-session") {
 		dewm := DEWM{
 			Name:    "IceWM",
 			Type:    "WM",
-			Version: runCommand("icewm --version | awk '{print $2}'"),
+			Version: runCommand("icewm --version | awk '{print $2}'", "/bin/sh"),
 		}
 		return dewm
 	}

src/utils.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"math"
 	"os"
+	"os/exec"
+	"path"
 	"regexp"
 	"strings"
 )
@@ -56,3 +58,58 @@ func ReadKeyValueFile(filepath string) (map[string]string, error) {
 	}
 	return ret, nil
 }
+
+func fetchAmdGpuName(productId, revision string) (string, error) {
+	productId = strings.ToUpper(productId)
+	revision = strings.ToUpper(revision[2:])
+
+	// Get cache directory
+	cachedir, err := os.UserCacheDir()
+	if err != nil {
+		return "", err
+	}
+
+	// Ensure amdgpu.ids file exists and download it if it doesn't
+	if _, err := os.Stat(path.Join(cachedir, "amdgpu.ids")); err != nil {
+		cmd := exec.Command("curl", "-o", path.Join(cachedir, "amdgpu.ids"), "https://gitlab.freedesktop.org/mesa/libdrm/-/raw/main/data/amdgpu.ids")
+		err = cmd.Run()
+		if err != nil {
+			return "", fmt.Errorf("Could not fetch amdgpu.ids using curl")
+		}
+	}
+
+	// Read amdgpu.ids file
+	amdgpuIds, err := os.ReadFile(path.Join(cachedir, "amdgpu.ids"))
+	if err != nil {
+		return "", err
+	}
+
+	// Parse read data and find GPU
+	for _, line := range strings.Split(string(amdgpuIds), "\n") {
+		if len(line) < 2 || line[0] == '#' {
+			continue
+		}
+
+		fields := strings.Split(line, ",\t")
+		if fields[0] == productId && fields[1] == revision {
+			return strings.TrimPrefix(fields[2], "AMD "), nil
+		}
+	}
+
+	return "", nil
+}
+
+func runCommand(command string, shell string) string {
+	cmd := exec.Command(shell, "-c", command)
+	workdir, err := os.Getwd()
+	if err != nil {
+		return ""
+	}
+	cmd.Dir = workdir
+	cmd.Env = os.Environ()
+	out, err := cmd.Output()
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(out))
+}