diff --git a/checkReady.go b/checkReady.go
index 0b5a879..69f42f8 100644
--- a/checkReady.go
+++ b/checkReady.go
@@ -7,44 +7,27 @@ import (
 	"go.wit.com/log"
 )
 
-func ReCheckReady() bool {
-	return false
-}
-
-/*
--               // allrepos map[string]*repo
--
--               keys := make([]string, 0, len(me.allrepos))
--               for key := range me.allrepos {
--                       keys = append(keys, key)
--               }
--               sort.Strings(keys)
--
--               for _, path := range keys {
--                       repo := me.allrepos[path]
-*/
-
 func CheckReady() bool {
-	if release.current == nil {
+	if me.current == nil {
 		log.Info("find the next repo first")
 		return false
 	}
-	goSumS := release.current.GoState()
-	dirtyS := release.current.State()
-	lastS := release.current.Status.GetLastTagVersion()
-	currentS := release.current.Status.GetCurrentBranchVersion()
+	goSumS := me.current.GoState()
+	dirtyS := me.current.State()
+	lastS := me.current.Status.GetLastTagVersion()
+	currentS := me.current.Status.GetCurrentBranchVersion()
 
 	var targetS string
-	targetS = release.version.String()
+	targetS = me.release.version.String()
 
-	log.Info("repo:", release.current.State(), goSumS, dirtyS, lastS, currentS, targetS)
+	log.Info("repo:", me.current.State(), goSumS, dirtyS, lastS, currentS, targetS)
 
 	if goSumS == "RELEASED" {
 		return true
 	}
-	if release.current.Status.IsPrimitive() {
+	if me.current.Status.IsPrimitive() {
 		if targetS == lastS {
-			release.current.SetGoState("RELEASED")
+			me.current.SetGoState("RELEASED")
 		}
 		return true
 	}
@@ -53,45 +36,45 @@ func CheckReady() bool {
 	}
 	if goSumS == "READY" {
 		if targetS == lastS {
-			release.current.SetGoState("RELEASED")
+			me.current.SetGoState("RELEASED")
 			return true
 		}
 		if lastS == currentS {
-			release.current.SetGoState("UNRELEASED")
+			me.current.SetGoState("UNRELEASED")
 		}
 		return true
 	}
-	release.current.SetGoState("NOT READY")
-	if release.current.Status.ReadOnly() {
+	me.current.SetGoState("NOT READY")
+	if me.current.Status.ReadOnly() {
 		log.Info("\trepo is read only")
 		return false
 	}
 
 	if targetS == lastS {
 		log.Info("\trepo is already done", lastS, "=", targetS)
-		release.current.SetGoState("READY")
+		me.current.SetGoState("READY")
 		return true
 	}
 	if lastS == currentS {
 		log.Info("\trepo is already done", lastS, "=", targetS)
-		release.current.SetGoState("READY")
+		me.current.SetGoState("READY")
 		return true
 	}
 
 	if goSumS == "BAD" {
-		log.Info("\trepo is ready", release.current.State(), "BAD == BAD")
+		log.Info("\trepo is ready", me.current.State(), "BAD == BAD")
 	} else {
-		log.Info("\trepo is ready maybe", release.current.State(), "BAD !=", goSumS)
+		log.Info("\trepo is ready maybe", me.current.State(), "BAD !=", goSumS)
 	}
 
-	if release.current.Status.CheckDirty() {
+	if me.current.Status.CheckDirty() {
 		log.Info("\trepo is dirty")
 		return false
 	} else {
-		log.Info("\trepo is ready", release.current.State(), "not dirty")
+		log.Info("\trepo is ready", me.current.State(), "not dirty")
 	}
 
-	fullpath := filepath.Join(me.goSrcPwd.String(), release.current.State())
+	fullpath := filepath.Join(me.goSrcPwd.String(), me.current.State())
 
 	testf := filepath.Join(fullpath, "go.mod")
 	if Exists(testf) {
@@ -113,14 +96,14 @@ func CheckReady() bool {
 
 	// final checks here
 	if dirtyS == "unchanged" {
-		log.Info("\trepo is ready", release.current.Name(), "unchanged")
+		log.Info("\trepo is ready", me.current.Name(), "unchanged")
 	} else {
 		log.Info("\trepo is not ready", dirtyS, "!= 'unchanged'")
 		return false
 	}
 
-	curName := release.current.Status.GetCurrentBranchName()
-	mName := release.current.Status.GetMasterBranchName()
+	curName := me.current.Status.GetCurrentBranchName()
+	mName := me.current.Status.GetMasterBranchName()
 
 	if curName == mName {
 		log.Info("\trepo is ready working from main branch", curName, "=", mName)
@@ -129,7 +112,7 @@ func CheckReady() bool {
 		return false
 	}
 
-	release.current.SetGoState("READY")
+	me.current.SetGoState("READY")
 	return true
 }
 
diff --git a/doRelease.go b/doRelease.go
index 4032a67..2405a6e 100644
--- a/doRelease.go
+++ b/doRelease.go
@@ -12,46 +12,46 @@ import (
 )
 
 func doRelease() bool {
-	log.Info("doRelease() on", release.current.Name())
+	log.Info("doRelease() on", me.current.Name())
 	// double check release version logic
-	if release.releaseVersionB.String() != "release version "+release.version.String() {
-		log.Warn("something went wrong with the release.version:", release.version.String())
+	if me.release.releaseVersionB.String() != "release version "+me.release.version.String() {
+		log.Warn("something went wrong with the release.version:", me.release.version.String())
 		return false
 	}
-	if strings.HasPrefix(release.version.String(), "v") {
-		log.Warn("everything is ok. version starts with v.", release.version.String())
+	if strings.HasPrefix(me.release.version.String(), "v") {
+		log.Warn("everything is ok. version starts with v.", me.release.version.String())
 	} else {
-		log.Warn("version does not start with v.", release.version.String())
+		log.Warn("version does not start with v.", me.release.version.String())
 		return false
 	}
 
-	curName := release.current.Status.GetCurrentBranchName()
-	mName := release.current.Status.GetMasterBranchName()
+	curName := me.current.Status.GetCurrentBranchName()
+	mName := me.current.Status.GetMasterBranchName()
 	if curName != mName {
 		log.Info("\trepo is not working from main branch", curName, "!=", mName)
 		return false
 	}
 
-	if !checkValidGoSum(release.current) {
+	if !checkValidGoSum(me.current) {
 		return false
 	}
 
-	log.Info("\ttag and push", curName, release.version.String(), me.releaseReasonS)
+	log.Info("\ttag and push", curName, me.release.version.String(), me.releaseReasonS)
 
 	var all [][]string
 	all = append(all, []string{"git", "add", "-f", "go.mod"})
-	if release.current.Status.IsPrimitive() {
+	if me.current.Status.IsPrimitive() {
 		// don't add go.sum here. TODO: check for go.sum file and fail
 	} else {
 		all = append(all, []string{"git", "add", "-f", "go.sum"})
 	}
 	all = append(all, []string{"git", "commit", "-m", me.releaseReasonS})
 	all = append(all, []string{"git", "push"})
-	all = append(all, []string{"git", "tag", "-m", me.releaseReasonS, release.version.String()})
-	all = append(all, []string{"git", "push", "origin", release.version.String()})
+	all = append(all, []string{"git", "tag", "-m", me.releaseReasonS, me.release.version.String()})
+	all = append(all, []string{"git", "push", "origin", me.release.version.String()})
 
-	if !release.current.Status.DoAll(all) {
-		log.Info("failed to make new release", release.version.String())
+	if !me.current.Status.DoAll(all) {
+		log.Info("failed to make new release", me.release.version.String())
 		return false
 	}
 	log.Info("RELEASE OK")
@@ -63,37 +63,37 @@ func doRelease() bool {
 	}
 
 	log.Info("PUBLISH OK")
-	release.current.SetGoState("RELEASED")
+	me.current.SetGoState("RELEASED")
 
 	// unwind and re-tag. Now that the go.mod and go.sum are published, revert
 	// to the development branch
-	if !release.current.Status.RevertMasterToDevel() {
+	if !me.current.Status.RevertMasterToDevel() {
 		log.Info("Revert Failed")
 		return false
 	}
 
 	// update tag
 	var retag [][]string
-	retag = append(retag, []string{"git", "tag", "--delete", release.version.String()})
-	retag = append(retag, []string{"git", "push", "--delete", "origin", release.version.String()})
-	retag = append(retag, []string{"git", "tag", "-m", me.releaseReasonS, release.version.String()})
-	retag = append(retag, []string{"git", "push", "origin", release.version.String()})
+	retag = append(retag, []string{"git", "tag", "--delete", me.release.version.String()})
+	retag = append(retag, []string{"git", "push", "--delete", "origin", me.release.version.String()})
+	retag = append(retag, []string{"git", "tag", "-m", me.releaseReasonS, me.release.version.String()})
+	retag = append(retag, []string{"git", "push", "origin", me.release.version.String()})
 
-	if !release.current.Status.DoAll(retag) {
+	if !me.current.Status.DoAll(retag) {
 		log.Info("retag failed")
 		return false
 	}
-	log.Info("EVERYTHING OK. RERELEASED", release.current.Name())
+	log.Info("EVERYTHING OK. RERELEASED", me.current.Name())
 
 	// update the values in the GUI
-	release.current.NewScan()
+	me.current.NewScan()
 
 	// attempt to find another repo to release
 	if !doReleaseFindNext() {
 		log.Info("doReleaseFindNext() could not find a new")
 		return false
 	}
-	log.Info("GOOD TO RUN ANOTHER DAY ON:", release.current.Name())
+	log.Info("GOOD TO RUN ANOTHER DAY ON:", me.current.Name())
 	return true
 }
 
@@ -105,12 +105,12 @@ func checkValidGoSum(repo *repolist.Repo) bool {
 	}
 	if ok {
 		log.Info("repo has go.sum requirements that are clean")
-		// release.current.setGoSumStatus("CLEAN")
-		release.status.SetValue("GOOD")
-		release.notes.SetValue("CheckValidGoSum() does not seem to lie")
+		// me.current.setGoSumStatus("CLEAN")
+		me.release.status.SetValue("GOOD")
+		me.release.notes.SetValue("CheckValidGoSum() does not seem to lie")
 		return true
 	}
-	release.notes.SetValue("CheckValidGoSum() failed")
+	me.release.notes.SetValue("CheckValidGoSum() failed")
 	return false
 }
 
@@ -123,7 +123,7 @@ func doReleaseFindNext() bool {
 		log.Info("findNextDirty() could not find anything")
 		return false
 	}
-	if checkValidGoSum(release.current) {
+	if checkValidGoSum(me.current) {
 		return true
 	}
 	return false
@@ -132,12 +132,12 @@ func doReleaseFindNext() bool {
 // this pulls the new tag from the golang package repository
 // to insert the new version
 func doPublishVersion() bool {
-	gopath := release.current.GoPath()
-	cmd := []string{"go", "get", "-v", gopath + "@" + release.version.String()}
+	gopath := me.current.GoPath()
+	cmd := []string{"go", "get", "-v", gopath + "@" + me.release.version.String()}
 	log.Info("SHOULD RUN cmd HERE:", cmd)
 
 	// right now, you can't publish this because the go.* files in this project are screwed up
-	if release.guireleaser == nil {
+	if me.release.guireleaser == nil {
 		log.Info("CAN NOT SELF UPDATE HERE. cmd =", cmd)
 		return false
 	}
@@ -145,11 +145,11 @@ func doPublishVersion() bool {
 	gosum := filepath.Join(homeDir, "go/src/go.wit.com/apps/guireleaser/go.sum")
 	if !shell.Exists(gosum) {
 		log.Info("go.sum must exist here")
-		release.guireleaser.Status.MakeRedomod()
+		me.release.guireleaser.Status.MakeRedomod()
 	}
 	os.Unsetenv("GO111MODULE")
 	log.Info("TRYING TO SELF UPDATE HERE. cmd =", cmd)
-	err, out := release.guireleaser.Status.RunCmd(cmd)
+	err, out := me.release.guireleaser.Status.RunCmd(cmd)
 	if gopath == "go.wit.com/apps/guireleaser" {
 		// ignore errors on updating myself
 		log.Info("IGNORE SELF UPDATE ERROR. cmd =", cmd)
@@ -158,7 +158,7 @@ func doPublishVersion() bool {
 	if err == nil {
 		log.Info("SELF UPDATE OK. out =", out)
 		log.Info("SELF UPDATE WORKED")
-		release.current.SetGoState("RELEASED")
+		me.current.SetGoState("RELEASED")
 		return true
 	}
 	return false
diff --git a/lookForUnwind.go b/lookForUnwind.go
index cb54d87..239ab65 100644
--- a/lookForUnwind.go
+++ b/lookForUnwind.go
@@ -31,8 +31,8 @@ func lookToUnwind(r *repolist.Repo) bool {
 		return false
 	}
 
-	if release.version.String() != r.LastTag() {
-		log.Info("\trepo version mismatch last vs official", r.LastTag(), "!=", release.version.String())
+	if me.release.version.String() != r.LastTag() {
+		log.Info("\trepo version mismatch last vs official", r.LastTag(), "!=", me.release.version.String())
 		r.SetGoState("CAN NOT UNWIND")
 		return false
 	}
diff --git a/main.go b/main.go
index 5f0068a..675127f 100644
--- a/main.go
+++ b/main.go
@@ -74,9 +74,6 @@ func main() {
 	// which should be all the git repositories in ~/go/src & the .config file
 	me.repos = makeRepoView()
 
-	// register a Show/Hide function for the repo list table
-	me.repos.View.RegisterHideFunction(showHideRepos)
-
 	// the left side of the window options
 	globalDisplayOptions(me.mainBox)
 
@@ -89,17 +86,36 @@ func main() {
 	// tool to release the code for this app, the gui and the gui toolkits
 	// and sometimes they lie, don't display stuff, don't even disable things
 	// so I can't trust even what I see. It's complicated right now still.
-	release.openrepo.Disable()
+	me.release.openrepo.Disable()
 
+	me.Disable()
 	log.Sleep(5)
 
 	// parse config file and scan for .git repos
 	me.repos.initRepoList()
+	setTargetVersion()
 
-	// reads in the State of all the repos
+	// register a Show/Hide function for the repo list table
+	me.repos.View.RegisterHideFunction(showHideRepos)
+
+	// scan in the State of all the repos
 	// TODO: should not really be necessary directly after init()
-	// me.repos.View.ScanRepositories()
+	me.repos.View.ScanRepositories()
 
+	// find myself. the guireleaser directory is used as a working scratchpad
+	// for running go commands that can mess up the go.* files
+	for _, repo := range me.repos.View.AllRepos() {
+		if repo.GoPath() == "go.wit.com/apps/guireleaser" {
+			if me.release.guireleaser == nil {
+				me.release.guireleaser = repo
+			}
+		}
+	}
+
+	if me.release.guireleaser == nil {
+		log.Info("Can not release if guireleaser was not found")
+		os.Exit(0)
+	}
 	me.Enable()
 
 	// intermittently scans the status indefinitly
diff --git a/releaseBox.go b/releaseBox.go
index 9db31e1..b7fe76e 100644
--- a/releaseBox.go
+++ b/releaseBox.go
@@ -14,10 +14,8 @@ import (
 	"go.wit.com/lib/gui/repolist"
 )
 
-var release releaseStruct
-
 type releaseStruct struct {
-	current *repolist.Repo
+	// current *repolist.Repo
 
 	box      *gui.Node
 	group    *gui.Node
@@ -60,13 +58,13 @@ func (w *autoType) Enable() {
 func createReleaseBox(box *gui.Node) {
 	initWhitelist()
 
-	// release.box = box
-	release.box = box.NewVerticalBox("vbox")
-	release.group = release.box.NewGroup("Current Repo")
-	release.grid = release.group.NewGrid("buildOptions", 0, 0)
-	release.grid.NextRow()
+	// me.release.box = box
+	me.release.box = box.NewVerticalBox("vbox")
+	me.release.group = me.release.box.NewGroup("Current Repo")
+	me.release.grid = me.release.group.NewGrid("buildOptions", 0, 0)
+	me.release.grid.NextRow()
 
-	release.releaseVersionB = release.grid.NewButton("release version", func() {
+	me.release.releaseVersionB = me.release.grid.NewButton("release version", func() {
 		buttonDisable()
 		if doRelease() {
 			buttonEnable()
@@ -75,34 +73,34 @@ func createReleaseBox(box *gui.Node) {
 			log.Info("doRelease() failed")
 		}
 	})
-	release.grid.NextRow()
+	me.release.grid.NextRow()
 
-	release.repo = gadgets.NewOneLiner(release.grid, "repo")
-	release.openrepo = release.grid.NewButton("Configure", func() {
-		release.current.Status.Toggle()
+	me.release.repo = gadgets.NewOneLiner(me.release.grid, "repo")
+	me.release.openrepo = me.release.grid.NewButton("Configure", func() {
+		me.current.Status.Toggle()
 	})
-	release.openrepo.Disable()
-	release.grid.NextRow()
-	release.status = gadgets.NewOneLiner(release.grid, "status")
-	release.grid.NextRow()
-	release.readOnly = gadgets.NewOneLiner(release.grid, "read-only")
-	release.grid.NextRow()
-	release.notes = gadgets.NewOneLiner(release.grid, "notes")
-	release.grid.NextRow()
+	me.release.openrepo.Disable()
+	me.release.grid.NextRow()
+	me.release.status = gadgets.NewOneLiner(me.release.grid, "status")
+	me.release.grid.NextRow()
+	me.release.readOnly = gadgets.NewOneLiner(me.release.grid, "read-only")
+	me.release.grid.NextRow()
+	me.release.notes = gadgets.NewOneLiner(me.release.grid, "notes")
+	me.release.grid.NextRow()
 
-	release.version = gadgets.NewOneLiner(release.grid, "version")
-	release.grid.NextRow()
+	me.release.version = gadgets.NewOneLiner(me.release.grid, "version")
+	me.release.grid.NextRow()
 
-	release.reason = gadgets.NewBasicEntry(release.grid, "release reason")
-	release.reason.SetText(me.releaseReasonS)
-	release.grid.NextRow()
+	me.release.reason = gadgets.NewBasicEntry(me.release.grid, "release reason")
+	me.release.reason.SetText(me.releaseReasonS)
+	me.release.grid.NextRow()
 
-	me.autoWorkingPwd = gadgets.NewOneLiner(release.grid, "working directory (pwd)")
-	release.grid.NextRow()
-	me.userHomePwd = gadgets.NewOneLiner(release.grid, "user home")
-	release.grid.NextRow()
-	me.goSrcPwd = gadgets.NewOneLiner(release.grid, "go src home")
-	release.grid.NextRow()
+	me.autoWorkingPwd = gadgets.NewOneLiner(me.release.grid, "working directory (pwd)")
+	me.release.grid.NextRow()
+	me.userHomePwd = gadgets.NewOneLiner(me.release.grid, "user home")
+	me.release.grid.NextRow()
+	me.goSrcPwd = gadgets.NewOneLiner(me.release.grid, "go src home")
+	me.release.grid.NextRow()
 
 	homeDir, err := os.UserHomeDir()
 	if err != nil {
@@ -119,26 +117,37 @@ func createReleaseBox(box *gui.Node) {
 		panic("redo go.sum")
 	}
 
-	group := release.box.NewGroup("Run on Current Repo")
+	group := me.release.box.NewGroup("Run on Current Repo")
 	grid := group.NewGrid("buildOptions", 0, 0)
 
 	grid.NewButton("set to IGNORE", func() {
-		tmp := release.current.GoState()
+		tmp := me.current.GoState()
 		log.Info("trying to set repo IGNORE is now =", tmp)
-		release.current.SetGoState("IGNORE")
-		release.whitelist[release.current.GoPath()] = release.current
+		me.current.SetGoState("IGNORE")
+		me.release.whitelist[me.current.GoPath()] = me.current
 	})
 
-	release.checkGoSumB = grid.NewButton("checkValidGoSum()", func() {
+	me.release.checkGoSumB = grid.NewButton("checkValidGoSum()", func() {
 		buttonDisable()
-		checkValidGoSum(release.current)
+		checkValidGoSum(me.current)
 		buttonEnable()
 	})
+
+	grid.NewButton("Check Ready", func() {
+		buttonDisable()
+		defer buttonEnable()
+		if CheckReady() {
+			log.Info("repo is ready", me.current.Name())
+			return
+		} else {
+			log.Info("\trepo is not ready", me.current.Name())
+		}
+	})
 	grid.NextRow()
 
-	group = release.box.NewGroup("Process against all repos")
+	group = me.release.box.NewGroup("Process against all repos")
 	grid = group.NewGrid("buildOptions", 0, 0)
-	grid.NewButton("release all", func() {
+	grid.NewButton("doRelease() all", func() {
 		var worked bool = true
 		buttonDisable()
 		// rather than loop forever, at least limit this to the number of repos
@@ -148,7 +157,7 @@ func createReleaseBox(box *gui.Node) {
 				if doRelease() {
 					log.Info("doRelease() worked")
 				} else {
-					if release.status.String() == "ALL DONE?" {
+					if me.release.status.String() == "ALL DONE?" {
 						log.Info("maybe ALL DONE?")
 						buttonEnable()
 						worked = true
@@ -165,43 +174,22 @@ func createReleaseBox(box *gui.Node) {
 		buttonEnable()
 	})
 
-	grid.NewButton("find first repo", func() {
-		// set the target versions
-		setTargetVersion()
-
-		// have to run this twice for now. not sure why
-		// this is old
-		scanForReady()
-		scanForReady()
-
-		findNextDirty("")
-	})
-
-	grid.NewButton("Check Ready", func() {
-		buttonDisable()
-		defer buttonEnable()
-		goSumS := release.current.GoState()
-		dirtyS := release.current.State()
-		lastS := release.current.LastTag()
-		if CheckReady() {
-			log.Info("repo is ready", release.current.Name(), goSumS, dirtyS, lastS)
-			return
-		} else {
-			log.Info("\trepo is not ready", release.current.Name(), goSumS, dirtyS, lastS)
-		}
-	})
 	grid.NewButton("scan for Ready", func() {
 		me.Disable()
 		scanForReady()
 		me.Enable()
 	})
-	grid.NewButton("findNextDirty()", func() {
+	grid.NewButton("findNextDirty(PRIMATIVE)", func() {
 		me.Disable()
 		defer me.Enable()
 		if findNextDirty("PRIMATIVE") {
 			log.Info("findNextDirty() found a repo")
 			return
 		}
+	})
+	grid.NewButton("findNextDirty()", func() {
+		me.Disable()
+		defer me.Enable()
 		if findNextDirty("") {
 			log.Info("findNextDirty() found a repo")
 			return
@@ -209,7 +197,7 @@ func createReleaseBox(box *gui.Node) {
 	})
 	grid.NextRow()
 
-	group = release.box.NewGroup("experimental and dangerous stuff")
+	group = me.release.box.NewGroup("experimental and dangerous stuff")
 	grid = group.NewGrid("buildOptions", 0, 0)
 	grid.NewButton("rm -f go.mod go.sum", func() {
 		me.Disable()
@@ -297,14 +285,14 @@ func setCurrentRepo(newcur *repolist.Repo, s string, note string) bool {
 		return false
 	}
 
-	release.repo.SetText(newcur.GoPath())
-	release.status.SetText(s)
-	release.notes.SetText(note)
-	release.current = newcur
-	release.version.SetText(release.current.Status.GetTargetVersion())
-	release.releaseVersionB.SetText("release version " + release.current.Status.GetTargetVersion())
-	// release.unreleaseB.SetText("un-release version " + release.current.targetVersion.String())
-	release.openrepo.Enable()
+	me.release.repo.SetText(newcur.GoPath())
+	me.release.status.SetText(s)
+	me.release.notes.SetText(note)
+	me.current = newcur
+	me.release.version.SetText(me.current.Status.GetTargetVersion())
+	me.release.releaseVersionB.SetText("release version " + me.current.Status.GetTargetVersion())
+	// me.release.unreleaseB.SetText("un-release version " + me.current.targetVersion.String())
+	me.release.openrepo.Enable()
 
 	return true
 }
@@ -354,18 +342,25 @@ func findNextDirty(onlyKind string) bool {
 			continue
 		}
 		log.Info("findNextDirty()", repo.GoPath(), goSumS)
+		// do makeredomod here
+		// if ! repo.Status.Exists("go.sum") {
+		// }
 		if repo.Status.IsPrimitive() {
 			if setCurrentRepo(repo, "PRIMATIVE", "release new version") {
 				return true
 			}
 			continue
 		}
-		if checkValidGoSum(release.current) {
+		log.Info("findNextDirty()", repo.GoPath(), "is not a primative repo")
+		if onlyKind == "PRIMITIVE" {
+			continue
+		}
+		if checkValidGoSum(repo) {
 			setCurrentRepo(repo, "should be good to release", "pretty sure")
 			return true
 		}
 	}
 	log.Info("tried to findNextDirty() but not sure what to do next")
-	release.status.SetText("ALL DONE?")
+	me.release.status.SetText("ALL DONE?")
 	return false
 }
diff --git a/scanGoSum.go b/scanGoSum.go
index 40e637a..51a821f 100644
--- a/scanGoSum.go
+++ b/scanGoSum.go
@@ -1,15 +1,12 @@
 // This is a simple example
 package main
 
-import (
-	"go.wit.com/log"
-)
-
+/*
 func scanGoSum() {
 	for _, repo := range me.repos.View.AllRepos() {
 		if repo.GoPath() == "go.wit.com/apps/guireleaser" {
-			if release.guireleaser == nil {
-				release.guireleaser = repo
+			if me.release.guireleaser == nil {
+				me.release.guireleaser = repo
 			}
 		}
 		latestversion := repo.Status.GetLastTagVersion()
@@ -29,11 +26,11 @@ func scanGoSum() {
 			log.Info("dirty repo.getGoSumStatus =", repo.GoState())
 			repo.SetGoState("DIRTY")
 
-			// release.repo.SetValue(repo.status.String())
-			// release.status.SetValue("dirty")
-			// release.notes.SetValue("You must commit your changes\nbefore you can continue")
-			// release.current = repo
-			// release.openrepo.Enable()
+			// me.release.repo.SetValue(repo.status.String())
+			// me.release.status.SetValue("dirty")
+			// me.release.notes.SetValue("You must commit your changes\nbefore you can continue")
+			// me.current = repo
+			// me.release.openrepo.Enable()
 			continue
 		}
 		status := repo.State()
@@ -47,3 +44,4 @@ func scanGoSum() {
 	}
 	log.Info("scanGoSum() did everything, not sure what to do next")
 }
+*/
diff --git a/structs.go b/structs.go
index 4aa57cf..a6b9e82 100644
--- a/structs.go
+++ b/structs.go
@@ -4,20 +4,20 @@ package main
 import (
 	"go.wit.com/gui"
 	"go.wit.com/lib/gadgets"
+	"go.wit.com/lib/gui/repolist"
 )
 
-// the main window nodes
-// var reposwin *gadgets.BasicWindow
-var reposbox *gui.Node
-var reposgrid *gui.Node
-var reposgroup *gui.Node
-
 var me *autoType
 
 type autoType struct {
 	myGui *gui.Node
 
 	releaseReasonS string // = "gocui dropdown select"
+	release        releaseStruct
+	reposbox       *gui.Node
+	reposgrid      *gui.Node
+	reposgroup     *gui.Node
+	current        *repolist.Repo
 
 	// guireleaser window
 	mainWindow *gui.Node
diff --git a/whitelist.go b/whitelist.go
index 53df187..0b98f98 100644
--- a/whitelist.go
+++ b/whitelist.go
@@ -8,18 +8,18 @@ import (
 )
 
 func initWhitelist() {
-	release.whitelist = make(map[string]*repolist.Repo)
+	me.release.whitelist = make(map[string]*repolist.Repo)
 	for _, repo := range me.repos.View.AllRepos() {
 		if strings.HasPrefix(repo.GoPath(), "go.wit.com/dev/davecgh") {
-			release.whitelist[repo.GoPath()] = repo
+			me.release.whitelist[repo.GoPath()] = repo
 		}
 		//
 		//	if repo.String() == "go.wit.com/apps/guireleaser" {
-		//		release.whitelist[repo.String()] = repo
+		//		me.release.whitelist[repo.String()] = repo
 		//	}
 		//
 		//	if repo.String() == "go.wit.com/lib/gui/repostatus" {
-		//		release.whitelist[repo.String()] = repo
+		//		me.release.whitelist[repo.String()] = repo
 		//	}
 		//
 	}
@@ -31,7 +31,7 @@ func whitelist(path string) bool {
 		return false
 	}
 
-	_, ok := release.whitelist[path]
+	_, ok := me.release.whitelist[path]
 	if ok {
 		// log.Info("whitelist ok == true", path)
 		return true