diff --git a/files.go b/files.go
index c955661..da7a83a 100644
--- a/files.go
+++ b/files.go
@@ -33,7 +33,7 @@ func getRandomFile(dir string) (path string, filename string, error error) {
 	return dir + "/" + randomImg.Name(), randomImg.Name(), nil
 }
 
-func fileExists(filename string) (bool, error) {
+func fileExistsInCache(filename string) (bool, error) {
 	files, err := os.ReadDir("images")
 	if err != nil {
 		return false, err
diff --git a/go-img b/go-img
new file mode 100755
index 0000000..8af9321
Binary files /dev/null and b/go-img differ
diff --git a/go.mod b/go.mod
index 9b40d3f..8f5adae 100644
--- a/go.mod
+++ b/go.mod
@@ -2,4 +2,7 @@ module go-img
 
 go 1.23.2
 
-require github.com/disintegration/gift v1.2.1
+require (
+	github.com/disintegration/gift v1.2.1
+	golang.org/x/image v0.21.0
+)
diff --git a/go.sum b/go.sum
index 89e5a54..11ba15c 100644
--- a/go.sum
+++ b/go.sum
@@ -1,2 +1,4 @@
 github.com/disintegration/gift v1.2.1 h1:Y005a1X4Z7Uc+0gLpSAsKhWi4qLtsdEcMIbbdvdZ6pc=
 github.com/disintegration/gift v1.2.1/go.mod h1:Jh2i7f7Q2BM7Ezno3PhfezbR1xpUg9dUg3/RlKGr4HI=
+golang.org/x/image v0.21.0 h1:c5qV36ajHpdj4Qi0GnE0jUc/yuo33OLFaa0d+crTD5s=
+golang.org/x/image v0.21.0/go.mod h1:vUbsLavqK/W303ZroQQVKQ+Af3Yl6Uz1Ppu5J/cLz78=
diff --git a/hyprpaper.go b/hyprpaper.go
index 82cfe08..ef0fef0 100644
--- a/hyprpaper.go
+++ b/hyprpaper.go
@@ -6,8 +6,23 @@ import (
 	"os/exec"
 )
 
+func hyprpaperSet(path string) {
+
+	err := hyprpaperPreload(path)
+	if err != nil {
+		log.Fatal("preload failed!", err)
+	}
+	err = hyprpaperWallpaper(path)
+	if err != nil {
+		log.Fatal("set wallpaper failed!", err)
+	}
+	err = hyprpaperUnloadAll()
+	if err != nil {
+		log.Fatal("unload all failed!", err)
+	}
+}
+
 func hyprpaperPreload(path string) error {
-	log.Println("path: ", path)
 	out, err := exec.Command("hyprctl", "hyprpaper", "preload", path).Output()
 	if err != nil {
 		return err
@@ -16,7 +31,7 @@ func hyprpaperPreload(path string) error {
 }
 
 func hyprpaperWallpaper(path string) error {
-	out, err := exec.Command("hyprctl", "hyprpaper", "wallpaper", ","+path).Output()
+	out, err := exec.Command("hyprctl", "hyprpaper", "wallpaper", ",contain:"+path).Output()
 	if err != nil {
 		return err
 	}
diff --git a/image.go b/image.go
index 245de1e..cda0d95 100644
--- a/image.go
+++ b/image.go
@@ -4,11 +4,15 @@ import (
 	"image"
 	"log"
 	"os"
+	"path/filepath"
+	"strings"
 
 	"github.com/disintegration/gift"
 
 	_ "image/jpeg"
 	"image/png"
+
+	_ "golang.org/x/image/webp"
 )
 
 type ImageFilters struct {
@@ -17,31 +21,58 @@ type ImageFilters struct {
 	Gamma    float64
 }
 
-func loadImage(filename string) image.Image {
-	f, err := os.Open(filename)
-	log.Println("filename: ", filename)
+func pickRandomImage(dir string) (string, error) {
+	dir = config.Root + "/" + dir
+	wd, err := os.Getwd()
 	if err != nil {
-		log.Fatalf("os.Open failed: %v", err)
+		return "", err
+	}
+	randomImg, filename, _ := getRandomFile(dir)
+	filenameNoExt := strings.TrimSuffix(filename, filepath.Ext(filename))
+
+	//check to see if rendered copy already exists
+	fileExists, err := fileExistsInCache(filenameNoExt)
+	if err != nil {
+		return "", err
+	}
+	curr := wd + "/images/" + filenameNoExt
+	if !fileExists {
+		img, err := loadImage(randomImg)
+		if err != nil {
+			return "", err
+		}
+		dst := processImage(img, config)
+		saveImage(curr, dst)
+	} else {
+		log.Println("file already exists in cache. skipping image processing")
+	}
+	return curr, nil
+}
+
+func loadImage(filename string) (image.Image, error) {
+	f, err := os.Open(filename)
+	if err != nil {
+		return nil, err
 	}
 	defer f.Close()
 	img, _, err := image.Decode(f)
 	if err != nil {
-		log.Fatalf("image.Decode failed: %v", err)
+		return nil, err
 	}
-	return img
+	return img, nil
 }
 
-func saveImage(filename string, img image.Image) {
-	log.Println("new filename: ", filename)
+func saveImage(filename string, img image.Image) error {
 	f, err := os.Create(filename)
 	if err != nil {
-		log.Fatalf("os.Create failed: %v", err)
+		return err
 	}
 	defer f.Close()
 	err = png.Encode(f, img)
 	if err != nil {
-		log.Fatalf("png.Encode failed: %v", err)
+		return err
 	}
+	return nil
 }
 
 func processImage(img image.Image, config Config) image.Image {
diff --git a/main.go b/main.go
index c93fc36..982646f 100644
--- a/main.go
+++ b/main.go
@@ -4,51 +4,31 @@ import (
 	"fmt"
 	"log"
 	"os"
-	"path/filepath"
-	"strings"
+	"sync"
 )
 
+var config Config
+
 func main() {
 	var err error
 
-	var config Config
 	config.load()
 	fmt.Printf("%+v\n", config)
 
-	//get working directory
-	wd, err := os.Getwd()
-	if err != nil {
-		log.Fatal("couldn't find working directory", err)
+	args := []string{""}
+	if len(os.Args) > 0 {
+		args = os.Args[1:]
 	}
 
-	dir := config.Root + "/chsck"
-	randomImg, filename, _ := getRandomFile(dir)
-	filenameNoExt := strings.TrimSuffix(filename, filepath.Ext(filename))
-	//check to see if rendered copy already exists
-	fileExists, err := fileExists(filenameNoExt)
+	curr, err := pickRandomImage(args[0])
 	if err != nil {
-		log.Fatal("failure checking if file exists!", err)
-	}
-	curr := wd + "/images/" + filenameNoExt
-	log.Println("curr: ", curr)
-	if !fileExists {
-		img := loadImage(randomImg)
-		dst := processImage(img, config)
-		saveImage(curr, dst)
-	} else {
-		log.Println("file exists! skipping image processing")
+		log.Fatal("failed to pick image!", err)
 	}
 
-	err = hyprpaperPreload(curr)
-	if err != nil {
-		log.Fatal("preload failed!", err)
-	}
-	err = hyprpaperWallpaper(curr)
-	if err != nil {
-		log.Fatal("set wallpaper failed!", err)
-	}
-	err = hyprpaperUnloadAll()
-	if err != nil {
-		log.Fatal("unload all failed!", err)
-	}
+	hyprpaperSet(curr)
+
+	var waitGroup sync.WaitGroup
+	waitGroup.Add(1)
+	go server(&waitGroup)
+	waitGroup.Wait()
 }
diff --git a/server.go b/server.go
new file mode 100644
index 0000000..290b60c
--- /dev/null
+++ b/server.go
@@ -0,0 +1,68 @@
+package main
+
+import (
+	"log"
+	"net"
+	"os"
+	"os/signal"
+	"strings"
+	"sync"
+	"syscall"
+)
+
+func server(waitGroup *sync.WaitGroup) {
+
+	sockfile := "/tmp/bg-go.sock"
+	//Create a Unix domain socket and listen for incoming connections.
+	socket, err := net.Listen("unix", sockfile)
+	if err != nil {
+		panic(err)
+	}
+
+	//cleanup sockfile
+	//TODO: this only works when the program is killed from outside. Make it work via defer() too?
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+	go func() {
+		<-c
+		os.Remove(sockfile)
+		os.Exit(1)
+	}()
+
+	for {
+		//Accept incoming
+		conn, err := socket.Accept()
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		//create store for incoming bytes
+
+		//handle connection in separate goroutine
+		go func(conn net.Conn) {
+			defer conn.Close()
+			//create buffer for incoming data
+			buf := make([]byte, 4096)
+
+			//read data from connection
+			n, err := conn.Read(buf)
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			str := strings.TrimSpace(string(buf[:n]))
+			newbg, err := pickRandomImage(str)
+			if err != nil {
+				panic(err)
+			}
+			hyprpaperSet(newbg)
+
+			// // Echo the data back to the connection
+			// _, err = conn.Write(buf[:n])
+			// if err != nil {
+			// 	log.Fatal(err)
+			// }
+		}(conn)
+	}
+
+}
diff --git a/slideshow.go b/slideshow.go
new file mode 100644
index 0000000..bce00f4
--- /dev/null
+++ b/slideshow.go
@@ -0,0 +1,5 @@
+package main
+
+func slideshow(dir string) {
+
+}