diff --git a/action/config_wizard.go b/action/config_wizard.go
index 1257980..1cc6da7 100644
--- a/action/config_wizard.go
+++ b/action/config_wizard.go
@@ -13,10 +13,14 @@
 	gpath "github.com/Masterminds/glide/path"
 	"github.com/Masterminds/semver"
 	"github.com/Masterminds/vcs"
+	"github.com/sdboyer/gps"
 )
 
 // ConfigWizard reads configuration from a glide.yaml file and attempts to suggest
 // improvements. The wizard is interactive.
+//
+// TODO(sdboyer) the Dependency.Reference -> Dependency.Constraint conversion is
+// really awkward here and needs to be revisited
 func ConfigWizard(base string) {
 	_, err := gpath.Glide()
 	glidefile := gpath.GlideFile
@@ -76,7 +80,7 @@
 
 		// First check, ask if the tag should be used instead of the commit id for it.
 		cur := cache.MemCurrent(remote)
-		if cur != "" && cur != dep.Reference {
+		if cur != "" && cur != dep.Constraint.String() {
 			wizardSugOnce()
 			var dres bool
 			asked, use, val := wizardOnce("current")
@@ -93,15 +97,16 @@
 			}
 
 			if dres {
-				msg.Info("Updating %s to use the tag %s instead of commit id %s", dep.Name, cur, dep.Reference)
-				dep.Reference = cur
+				msg.Info("Updating %s to use the tag %s instead of commit id %s", dep.Name, cur, dep.Constraint)
+				// FIXME just wrong; have to disambiguate branches and versions
+				dep.Constraint = gps.NewVersion(cur)
 				changes++
 			}
 		}
 
 		// Second check, if no version is being used and there's a semver release ask about latest.
 		memlatest := cache.MemLatest(remote)
-		if dep.Reference == "" && memlatest != "" {
+		if dep.Constraint == nil && memlatest != "" {
 			wizardSugOnce()
 			var dres bool
 			asked, use, val := wizardOnce("latest")
@@ -119,14 +124,14 @@
 
 			if dres {
 				msg.Info("Updating %s to use the release %s instead of no release", dep.Name, memlatest)
-				dep.Reference = memlatest
+				dep.Constraint = gps.NewVersion(memlatest)
 				changes++
 			}
 		}
 
 		// Third check, if the version is semver offer to use a range instead.
-		sv, err := semver.NewVersion(dep.Reference)
-		if err == nil {
+		if v, ok := dep.Constraint.(gps.Version); ok && v.Type() == "semver" {
+			sv, _ := semver.NewVersion(v.String())
 			wizardSugOnce()
 			var res string
 			asked, use, val := wizardOnce("range")
@@ -144,13 +149,13 @@
 
 			if res == "m" {
 				r := "^" + sv.String()
-				msg.Info("Updating %s to use the range %s instead of commit id %s", dep.Name, r, dep.Reference)
-				dep.Reference = r
+				msg.Info("Updating %s to use the range %s instead of commit id %s", dep.Name, r, dep.Constraint)
+				dep.Constraint, _ = gps.NewSemverConstraint(r)
 				changes++
 			} else if res == "p" {
 				r := "~" + sv.String()
-				msg.Info("Updating %s to use the range %s instead of commit id %s", dep.Name, r, dep.Reference)
-				dep.Reference = r
+				msg.Info("Updating %s to use the range %s instead of commit id %s", dep.Name, r, dep.Constraint)
+				dep.Constraint, _ = gps.NewSemverConstraint(r)
 				changes++
 			}
 		}
@@ -229,7 +234,7 @@
 }
 
 func wizardAskCurrent(cur string, d *cfg.Dependency) bool {
-	msg.Info("The package %s is currently set to use the version %s.", d.Name, d.Reference)
+	msg.Info("The package %s is currently set to use the version %s.", d.Name, d.Constraint)
 	msg.Info("There is an equivalent semantic version (http://semver.org) release of %s. Would", cur)
 	msg.Info("you like to use that instead? Yes (Y) or No (N)")
 	return msg.PromptUntilYorN()
@@ -243,7 +248,7 @@
 }
 
 func wizardLookInto(d *cfg.Dependency) bool {
-	_, err := semver.NewConstraint(d.Reference)
+	_, err := semver.NewConstraint(d.Constraint.String())
 
 	// The existing version is already a valid semver constraint so we skip suggestions.
 	if err == nil {
@@ -302,7 +307,7 @@
 				if found := createGitParseVersion.FindString(ti); found != "" {
 					tg := strings.TrimPrefix(strings.TrimSuffix(found, "^{}"), "tags/")
 					cache.MemPut(remote, tg)
-					if d.Reference != "" && strings.HasPrefix(ti, d.Reference) {
+					if d.Constraint != nil && strings.HasPrefix(ti, d.Constraint.String()) {
 						cache.MemSetCurrent(remote, tg)
 					}
 				}
@@ -332,15 +337,17 @@
 				cache.MemPut(remote, v)
 			}
 		}
-		if d.Reference != "" && repo.IsReference(d.Reference) {
-			tgs, err = repo.TagsFromCommit(d.Reference)
-			if err != nil {
-				msg.Debug("Problem getting tags for commit: %s", err)
-			} else {
-				if len(tgs) > 0 {
-					for _, v := range tgs {
-						if !(repo.Vcs() == vcs.Hg && v == "tip") {
-							cache.MemSetCurrent(remote, v)
+		if d.Constraint != nil {
+			if rev, ok := d.Constraint.(gps.Revision); ok {
+				tgs, err = repo.TagsFromCommit(string(rev))
+				if err != nil {
+					msg.Debug("Problem getting tags for commit: %s", err)
+				} else {
+					if len(tgs) > 0 {
+						for _, v := range tgs {
+							if !(repo.Vcs() == vcs.Hg && v == "tip") {
+								cache.MemSetCurrent(remote, v)
+							}
 						}
 					}
 				}
diff --git a/action/create.go b/action/create.go
index 5d42199..e6cf2e4 100644
--- a/action/create.go
+++ b/action/create.go
@@ -129,32 +129,20 @@
 
 	for _, pa := range sortable {
 		n := strings.TrimPrefix(pa, vpath)
-		root, subpkg := util.NormalizeName(n)
+		root, _ := util.NormalizeName(n)
 
 		if !config.Imports.Has(root) && root != config.Name {
 			msg.Info("--> Found reference to %s\n", n)
 			d := &cfg.Dependency{
 				Name: root,
 			}
-			if len(subpkg) > 0 {
-				d.Subpackages = []string{subpkg}
-			}
 			config.Imports = append(config.Imports, d)
-		} else if config.Imports.Has(root) {
-			if len(subpkg) > 0 {
-				subpkg = strings.TrimPrefix(subpkg, "/")
-				d := config.Imports.Get(root)
-				if !d.HasSubpackage(subpkg) {
-					msg.Info("--> Adding sub-package %s to %s\n", subpkg, root)
-					d.Subpackages = append(d.Subpackages, subpkg)
-				}
-			}
 		}
 	}
 
 	for _, pa := range testSortable {
 		n := strings.TrimPrefix(pa, vpath)
-		root, subpkg := util.NormalizeName(n)
+		root, _ := util.NormalizeName(n)
 
 		if config.Imports.Has(root) && root != config.Name {
 			msg.Debug("--> Found test reference to %s already listed as an import", n)
@@ -163,19 +151,7 @@
 			d := &cfg.Dependency{
 				Name: root,
 			}
-			if len(subpkg) > 0 {
-				d.Subpackages = []string{subpkg}
-			}
 			config.DevImports = append(config.DevImports, d)
-		} else if config.DevImports.Has(root) {
-			if len(subpkg) > 0 {
-				subpkg = strings.TrimPrefix(subpkg, "/")
-				d := config.DevImports.Get(root)
-				if !d.HasSubpackage(subpkg) {
-					msg.Info("--> Adding test sub-package %s to %s\n", subpkg, root)
-					d.Subpackages = append(d.Subpackages, subpkg)
-				}
-			}
 		}
 	}
 
@@ -207,10 +183,10 @@
 	}
 
 	for _, i := range deps {
-		if i.Reference == "" {
+		if i.Constraint == nil {
 			msg.Info("--> Found imported reference to %s", i.Name)
 		} else {
-			msg.Info("--> Found imported reference to %s at revision %s", i.Name, i.Reference)
+			msg.Info("--> Found imported reference to %s with constraint %s", i.Name, i.Constraint)
 		}
 
 		config.Imports = append(config.Imports, i)
diff --git a/action/ensure.go b/action/ensure.go
index 2f5f5af..154b8ee 100644
--- a/action/ensure.go
+++ b/action/ensure.go
@@ -29,7 +29,10 @@
 		msg.ExitCode(2)
 		msg.Die("Failed to load %s: %s", yamlpath, err)
 	}
-	conf, err := cfg.ConfigFromYaml(yml)
+	conf, legacy, err := cfg.ConfigFromYaml(yml)
+	if legacy {
+		msg.Warn("glide.yaml was in a legacy format. An attempt will be made to automatically update it.")
+	}
 	if err != nil {
 		msg.ExitCode(3)
 		msg.Die("Failed to parse %s: %s", yamlpath, err)
diff --git a/action/get.go b/action/get.go
index bcb62f3..60607f2 100644
--- a/action/get.go
+++ b/action/get.go
@@ -151,7 +151,7 @@
 
 		msg.Info("Attempting to get package %s", name)
 
-		root, subpkg := util.NormalizeName(name)
+		root, _ := util.NormalizeName(name)
 		if len(root) == 0 {
 			return 0, fmt.Errorf("Package name is required for %q.", name)
 		}
@@ -172,24 +172,7 @@
 				msg.Warn("--> Test dependency %s already listed as import", root)
 			}
 
-			// Check if the subpackage is present.
-			if subpkg != "" {
-				if dep == nil {
-					dep = conf.Imports.Get(root)
-					if dep == nil && testDeps {
-						dep = conf.DevImports.Get(root)
-					}
-				}
-				if dep.HasSubpackage(subpkg) {
-					if !moved {
-						msg.Warn("--> Package %q is already in glide.yaml. Skipping", name)
-					}
-				} else {
-					dep.Subpackages = append(dep.Subpackages, subpkg)
-					msg.Info("--> Adding sub-package %s to existing import %s", subpkg, root)
-					numAdded++
-				}
-			} else if !moved {
+			if !moved {
 				msg.Warn("--> Package %q is already in glide.yaml. Skipping", root)
 			}
 			continue
@@ -212,17 +195,14 @@
 		}
 
 		if version != "" {
-			dep.Reference = version
+			// TODO(sdboyer) set the right type...what is that here?
+			dep.Constraint = gps.NewVersion(version)
 		} else if !nonInteract {
 			getWizard(dep)
 		}
 
-		if len(subpkg) > 0 {
-			dep.Subpackages = []string{subpkg}
-		}
-
-		if dep.Reference != "" {
-			msg.Info("--> Adding %s to your configuration with the version %s", dep.Name, dep.Reference)
+		if dep.Constraint != nil {
+			msg.Info("--> Adding %s to your configuration with the version %s", dep.Name, dep.Constraint)
 		} else {
 			msg.Info("--> Adding %s to your configuration", dep.Name)
 		}
@@ -253,15 +233,20 @@
 	if memlatest != "" {
 		dres := wizardAskLatest(memlatest, dep)
 		if dres {
-			dep.Reference = memlatest
+			// TODO(sdboyer) set the right type...what is that here?
+			v := gps.NewVersion(memlatest)
+			dep.Constraint = v
 
-			sv, err := semver.NewVersion(dep.Reference)
-			if err == nil {
+			if v.Type() == "semver" {
+				sv, _ := semver.NewVersion(memlatest)
 				res := wizardAskRange(sv, dep)
+
 				if res == "m" {
-					dep.Reference = "^" + sv.String()
+					// no errors possible here, if init was valid semver version
+					dep.Constraint, _ = gps.NewSemverConstraint("^" + v.String())
 				} else if res == "p" {
-					dep.Reference = "~" + sv.String()
+					// no errors possible here, if init was valid semver version
+					dep.Constraint, _ = gps.NewSemverConstraint("~" + v.String())
 				}
 			}
 		}
diff --git a/action/get_test.go b/action/get_test.go
index 07dba0f..9e5d8f0 100644
--- a/action/get_test.go
+++ b/action/get_test.go
@@ -16,7 +16,6 @@
 	conf := new(cfg.Config)
 	dep := new(cfg.Dependency)
 	dep.Name = "github.com/Masterminds/cookoo"
-	dep.Subpackages = append(dep.Subpackages, "convert")
 	conf.Imports = append(conf.Imports, dep)
 
 	names := []string{
@@ -30,17 +29,6 @@
 		t.Error("addPkgsToConfig failed to add github.com/Masterminds/semver")
 	}
 
-	d := conf.Imports.Get("github.com/Masterminds/cookoo")
-	found := false
-	for _, s := range d.Subpackages {
-		if s == "fmt" {
-			found = true
-		}
-	}
-	if !found {
-		t.Error("addPkgsToConfig failed to add subpackage to existing import")
-	}
-
 	// Restore messaging to original location
 	msg.Default.Stderr = o
 }
diff --git a/action/rebuild.go b/action/rebuild.go
index dffde39..6e76625 100644
--- a/action/rebuild.go
+++ b/action/rebuild.go
@@ -41,22 +41,23 @@
 }
 
 func buildDep(dep *cfg.Dependency, vpath string) error {
-	if len(dep.Subpackages) == 0 {
-		buildPath(dep.Name)
-	}
+	buildPath(dep.Name)
 
-	for _, pkg := range dep.Subpackages {
-		if pkg == "**" || pkg == "..." {
-			//Info("Building all packages in %s\n", dep.Name)
-			buildPath(path.Join(dep.Name, "..."))
-		} else {
-			paths, err := resolvePackages(vpath, dep.Name, pkg)
-			if err != nil {
-				msg.Warn("Error resolving packages: %s", err)
-			}
-			buildPaths(paths)
-		}
-	}
+	// TODO(sdboyer) to replace this, would need static analysis. But...rebuild
+	// is going away anyway, right?
+
+	//for _, pkg := range dep.Subpackages {
+	//if pkg == "**" || pkg == "..." {
+	////Info("Building all packages in %s\n", dep.Name)
+	//buildPath(path.Join(dep.Name, "..."))
+	//} else {
+	//paths, err := resolvePackages(vpath, dep.Name, pkg)
+	//if err != nil {
+	//msg.Warn("Error resolving packages: %s", err)
+	//}
+	//buildPaths(paths)
+	//}
+	//}
 
 	return nil
 }
diff --git a/dependency/analyzer.go b/dependency/analyzer.go
index 0f88d7d..d209f4e 100644
--- a/dependency/analyzer.go
+++ b/dependency/analyzer.go
@@ -102,7 +102,8 @@
 		return nil, nil, fmt.Errorf("Error while reading glide manifest data: %s", root)
 	}
 
-	m, err := cfg.ConfigFromYaml(yml)
+	// We don't care here if it's legacy
+	m, _, err := cfg.ConfigFromYaml(yml)
 	if err != nil {
 		return nil, nil, fmt.Errorf("Error while parsing glide manifest data: %s", root)
 	}
diff --git a/dependency/resolver.go b/dependency/resolver.go
index 06dd2dc..a0cabf1 100644
--- a/dependency/resolver.go
+++ b/dependency/resolver.go
@@ -257,10 +257,10 @@
 		}
 		pt := strings.TrimPrefix(path, r.basedir+string(os.PathSeparator))
 		pt = strings.TrimSuffix(pt, string(os.PathSeparator))
-		if r.Config.HasExclude(pt) {
-			msg.Debug("Excluding %s", pt)
-			return filepath.SkipDir
-		}
+		//if r.Config.HasExclude(pt) {
+		//msg.Debug("Excluding %s", pt)
+		//return filepath.SkipDir
+		//}
 		if !fi.IsDir() {
 			return nil
 		}
@@ -588,7 +588,7 @@
 	// In addition to generating a list
 	for e := queue.Front(); e != nil; e = e.Next() {
 		t := r.Stripv(e.Value.(string))
-		root, sp := util.NormalizeName(t)
+		root, _ := util.NormalizeName(t)
 
 		// Skip ignored packages
 		if r.Config.HasIgnore(e.Value.(string)) {
@@ -598,25 +598,19 @@
 
 		// TODO(mattfarina): Need to eventually support devImport
 		existing := r.Config.Imports.Get(root)
-		if existing == nil && addTest {
-			existing = r.Config.DevImports.Get(root)
-		}
-		if existing != nil {
-			if sp != "" && !existing.HasSubpackage(sp) {
-				existing.Subpackages = append(existing.Subpackages, sp)
-			}
-		} else {
-			newDep := &cfg.Dependency{
-				Name: root,
-			}
-			if sp != "" {
-				newDep.Subpackages = []string{sp}
-			}
-
+		if existing == nil {
 			if addTest {
-				r.Config.DevImports = append(r.Config.DevImports, newDep)
+				existing = r.Config.DevImports.Get(root)
 			} else {
-				r.Config.Imports = append(r.Config.Imports, newDep)
+				newDep := &cfg.Dependency{
+					Name: root,
+				}
+
+				if addTest {
+					r.Config.DevImports = append(r.Config.DevImports, newDep)
+				} else {
+					r.Config.Imports = append(r.Config.Imports, newDep)
+				}
 			}
 		}
 		res = append(res, t)
@@ -685,29 +679,22 @@
 	// In addition to generating a list
 	for e := queue.Front(); e != nil; e = e.Next() {
 		t := strings.TrimPrefix(e.Value.(string), r.VendorDir+string(os.PathSeparator))
-		root, sp := util.NormalizeName(t)
+		root, _ := util.NormalizeName(t)
 
 		existing := r.Config.Imports.Get(root)
-		if existing == nil && addTest {
-			existing = r.Config.DevImports.Get(root)
-		}
-
-		if existing != nil {
-			if sp != "" && !existing.HasSubpackage(sp) {
-				existing.Subpackages = append(existing.Subpackages, sp)
-			}
-		} else {
-			newDep := &cfg.Dependency{
-				Name: root,
-			}
-			if sp != "" {
-				newDep.Subpackages = []string{sp}
-			}
-
+		if existing == nil {
 			if addTest {
-				r.Config.DevImports = append(r.Config.DevImports, newDep)
+				existing = r.Config.DevImports.Get(root)
 			} else {
-				r.Config.Imports = append(r.Config.Imports, newDep)
+				newDep := &cfg.Dependency{
+					Name: root,
+				}
+
+				if addTest {
+					r.Config.DevImports = append(r.Config.DevImports, newDep)
+				} else {
+					r.Config.Imports = append(r.Config.Imports, newDep)
+				}
 			}
 		}
 		res = append(res, e.Value.(string))
@@ -861,20 +848,8 @@
 func sliceToQueue(deps []*cfg.Dependency, basepath string) *list.List {
 	l := list.New()
 	for _, e := range deps {
-		if len(e.Subpackages) > 0 {
-			for _, v := range e.Subpackages {
-				ip := e.Name
-				if v != "." && v != "" {
-					ip = ip + "/" + v
-				}
-				msg.Debug("Adding local Import %s to queue", ip)
-				l.PushBack(filepath.Join(basepath, filepath.FromSlash(ip)))
-			}
-		} else {
-			msg.Debug("Adding local Import %s to queue", e.Name)
-			l.PushBack(filepath.Join(basepath, filepath.FromSlash(e.Name)))
-		}
-
+		msg.Debug("Adding local Import %s to queue", e.Name)
+		l.PushBack(filepath.Join(basepath, filepath.FromSlash(e.Name)))
 	}
 	return l
 }
diff --git a/importer/importer.go b/importer/importer.go
index 9d5d2ac..9da292b 100644
--- a/importer/importer.go
+++ b/importer/importer.go
@@ -44,7 +44,7 @@
 		if err != nil {
 			return false, []*cfg.Dependency{}, err
 		}
-		conf, err := cfg.ConfigFromYaml(yml)
+		conf, _, err := cfg.ConfigFromYaml(yml)
 		if err != nil {
 			return false, []*cfg.Dependency{}, err
 		}
diff --git a/repo/installer.go b/repo/installer.go
index eec08df..de751bf 100644
--- a/repo/installer.go
+++ b/repo/installer.go
@@ -195,19 +195,13 @@
 		if conf.HasIgnore(n) {
 			continue
 		}
-		rt, sub := util.NormalizeName(n)
-		if sub == "" {
-			sub = "."
-		}
+		rt, _ := util.NormalizeName(n)
 		d := deps.Get(rt)
 		if d == nil {
 			nd := &cfg.Dependency{
-				Name:        rt,
-				Subpackages: []string{sub},
+				Name: rt,
 			}
 			deps = append(deps, nd)
-		} else if !d.HasSubpackage(sub) {
-			d.Subpackages = append(d.Subpackages, sub)
 		}
 	}
 	if i.ResolveTest {
@@ -216,22 +210,16 @@
 			if conf.HasIgnore(n) {
 				continue
 			}
-			rt, sub := util.NormalizeName(n)
-			if sub == "" {
-				sub = "."
-			}
+			rt, _ := util.NormalizeName(n)
 			d := deps.Get(rt)
 			if d == nil {
 				d = tdeps.Get(rt)
 			}
 			if d == nil {
 				nd := &cfg.Dependency{
-					Name:        rt,
-					Subpackages: []string{sub},
+					Name: rt,
 				}
 				tdeps = append(tdeps, nd)
-			} else if !d.HasSubpackage(sub) {
-				d.Subpackages = append(d.Subpackages, sub)
 			}
 		}
 	}
@@ -330,12 +318,12 @@
 			continue
 		}
 
-		if ver == dep.Reference {
-			msg.Info("--> Found desired version %s %s!", dep.Name, dep.Reference)
+		if ver == dep.Constraint.String() {
+			msg.Info("--> Found desired version %s %s!", dep.Name, dep.Constraint)
 			continue
 		}
 
-		msg.Debug("--> Queue %s for update (%s != %s).", dep.Name, ver, dep.Reference)
+		msg.Debug("--> Queue %s for update (%s != %s).", dep.Name, ver, dep.Constraint)
 		newDeps = append(newDeps, dep)
 	}
 	if len(newDeps) > 0 {
@@ -621,7 +609,7 @@
 
 				// The fist one wins. Would something smater than this be better?
 				exists, _ := d.Use.Get(dep.Name)
-				if exists == nil && (dep.Reference != "" || dep.Repository != "") {
+				if exists == nil && (dep.Constraint != nil || dep.Repository != "") {
 					d.Use.Add(dep.Name, dep, root)
 				}
 			}
@@ -656,8 +644,8 @@
 			// There are import chains (because the import tree is resolved
 			// before the test tree) that can cause this.
 			tempD := d.Config.DevImports.Get(root)
-			if tempD.Reference != v.Reference {
-				msg.Warn("Using import %s (version %s) for test instead of testImport (version %s).", v.Name, v.Reference, tempD.Reference)
+			if tempD.Constraint.String() != v.Constraint.String() {
+				msg.Warn("Using import %s (version %s) for test instead of testImport (version %s).", v.Name, v.Constraint, tempD.Constraint)
 			}
 			// TODO(mattfarina): Note repo difference in a warning.
 		}
@@ -665,12 +653,12 @@
 
 	dep, req := d.Use.Get(root)
 	if dep != nil && v != nil {
-		if v.Reference == "" && dep.Reference != "" {
-			v.Reference = dep.Reference
+		if v.Constraint == nil && dep.Constraint != nil {
+			v.Constraint = dep.Constraint
 			// Clear the pin, if set, so the new version can be used.
-			v.Pin = ""
+			//v.Pin = ""
 			dep = v
-		} else if v.Reference != "" && dep.Reference != "" && v.Reference != dep.Reference {
+		} else if v.Constraint != nil && dep.Constraint != nil && v.Constraint.String() != dep.Constraint.String() {
 			dest := filepath.Join(d.Destination, filepath.FromSlash(v.Name))
 			dep = determineDependency(v, dep, dest, req)
 		} else {
@@ -689,13 +677,10 @@
 		}
 	} else {
 		// If we've gotten here we don't have any depenency objects.
-		r, sp := util.NormalizeName(pkg)
+		r, _ := util.NormalizeName(pkg)
 		dep = &cfg.Dependency{
 			Name: r,
 		}
-		if sp != "" {
-			dep.Subpackages = []string{sp}
-		}
 		if addTest {
 			d.Config.DevImports = append(d.Config.DevImports, dep)
 		} else {
@@ -705,7 +690,7 @@
 
 	err := VcsVersion(dep, d.Destination)
 	if err != nil {
-		msg.Warn("Unable to set version on %s to %s. Err: %s", root, dep.Reference, err)
+		msg.Warn("Unable to set version on %s to %s. Err: %s", root, dep.Constraint, err)
 		e = err
 	}
 
@@ -716,110 +701,110 @@
 	repo, err := v.GetRepo(dest)
 	if err != nil {
 		singleWarn("Unable to access repo for %s\n", v.Name)
-		singleInfo("Keeping %s %s", v.Name, v.Reference)
+		singleInfo("Keeping %s %s", v.Name, v.Constraint)
 		return v
 	}
 
-	vIsRef := repo.IsReference(v.Reference)
-	depIsRef := repo.IsReference(dep.Reference)
+	vIsRef := repo.IsReference(v.Constraint.String())
+	depIsRef := repo.IsReference(dep.Constraint.String())
 
 	// Both are references and they are different ones.
 	if vIsRef && depIsRef {
-		singleWarn("Conflict: %s rev is currently %s, but %s wants %s\n", v.Name, v.Reference, req, dep.Reference)
+		singleWarn("Conflict: %s rev is currently %s, but %s wants %s\n", v.Name, v.Constraint, req, dep.Constraint)
 
 		displayCommitInfo(repo, v)
 		displayCommitInfo(repo, dep)
 
-		singleInfo("Keeping %s %s", v.Name, v.Reference)
+		singleInfo("Keeping %s %s", v.Name, v.Constraint)
 		return v
 	} else if vIsRef {
 		// The current one is a reference and the suggestion is a SemVer constraint.
-		con, err := semver.NewConstraint(dep.Reference)
+		con, err := semver.NewConstraint(dep.Constraint.String())
 		if err != nil {
-			singleWarn("Version issue for %s: '%s' is neither a reference or semantic version constraint\n", dep.Name, dep.Reference)
-			singleInfo("Keeping %s %s", v.Name, v.Reference)
+			singleWarn("Version issue for %s: '%s' is neither a reference or semantic version constraint\n", dep.Name, dep.Constraint)
+			singleInfo("Keeping %s %s", v.Name, v.Constraint)
 			return v
 		}
 
-		ver, err := semver.NewVersion(v.Reference)
+		ver, err := semver.NewVersion(v.Constraint.String())
 		if err != nil {
 			// The existing version is not a semantic version.
-			singleWarn("Conflict: %s version is %s, but also asked for %s\n", v.Name, v.Reference, dep.Reference)
+			singleWarn("Conflict: %s version is %s, but also asked for %s\n", v.Name, v.Constraint, dep.Constraint)
 			displayCommitInfo(repo, v)
-			singleInfo("Keeping %s %s", v.Name, v.Reference)
+			singleInfo("Keeping %s %s", v.Name, v.Constraint)
 			return v
 		}
 
 		if con.Matches(ver) == nil {
-			singleInfo("Keeping %s %s because it fits constraint '%s'", v.Name, v.Reference, dep.Reference)
+			singleInfo("Keeping %s %s because it fits constraint '%s'", v.Name, v.Constraint, dep.Constraint)
 			return v
 		}
-		singleWarn("Conflict: %s version is %s but does not meet constraint '%s'\n", v.Name, v.Reference, dep.Reference)
-		singleInfo("Keeping %s %s", v.Name, v.Reference)
+		singleWarn("Conflict: %s version is %s but does not meet constraint '%s'\n", v.Name, v.Constraint, dep.Constraint)
+		singleInfo("Keeping %s %s", v.Name, v.Constraint)
 		return v
 	} else if depIsRef {
 
-		con, err := semver.NewConstraint(v.Reference)
+		con, err := semver.NewConstraint(v.Constraint.String())
 		if err != nil {
-			singleWarn("Version issue for %s: '%s' is neither a reference or semantic version constraint\n", v.Name, v.Reference)
-			singleInfo("Keeping %s %s", v.Name, v.Reference)
+			singleWarn("Version issue for %s: '%s' is neither a reference or semantic version constraint\n", v.Name, v.Constraint)
+			singleInfo("Keeping %s %s", v.Name, v.Constraint)
 			return v
 		}
 
-		ver, err := semver.NewVersion(dep.Reference)
+		ver, err := semver.NewVersion(dep.Constraint.String())
 		if err != nil {
-			singleWarn("Conflict: %s version is %s, but also asked for %s\n", v.Name, v.Reference, dep.Reference)
+			singleWarn("Conflict: %s version is %s, but also asked for %s\n", v.Name, v.Constraint, dep.Constraint)
 			displayCommitInfo(repo, dep)
-			singleInfo("Keeping %s %s", v.Name, v.Reference)
+			singleInfo("Keeping %s %s", v.Name, v.Constraint)
 			return v
 		}
 
 		if con.Matches(ver) == nil {
-			v.Reference = dep.Reference
-			singleInfo("Using %s %s because it fits constraint '%s'", v.Name, v.Reference, v.Reference)
+			v.Constraint = dep.Constraint
+			singleInfo("Using %s %s because it fits constraint '%s'", v.Name, v.Constraint, v.Constraint)
 			return v
 		}
-		singleWarn("Conflict: %s semantic version constraint is %s but '%s' does not meet the constraint\n", v.Name, v.Reference, v.Reference)
-		singleInfo("Keeping %s %s", v.Name, v.Reference)
+		singleWarn("Conflict: %s semantic version constraint is %s but '%s' does not meet the constraint\n", v.Name, v.Constraint, v.Constraint)
+		singleInfo("Keeping %s %s", v.Name, v.Constraint)
 		return v
 	}
 	// Neither is a vcs reference and both could be semantic version
 	// constraints that are different.
 
-	_, err = semver.NewConstraint(dep.Reference)
+	_, err = semver.NewConstraint(dep.Constraint.String())
 	if err != nil {
-		// dd.Reference is not a reference or a valid constraint.
-		singleWarn("Version %s %s is not a reference or valid semantic version constraint\n", dep.Name, dep.Reference)
-		singleInfo("Keeping %s %s", v.Name, v.Reference)
+		// dd.Constraint is not a reference or a valid constraint.
+		singleWarn("Version %s %s is not a reference or valid semantic version constraint\n", dep.Name, dep.Constraint)
+		singleInfo("Keeping %s %s", v.Name, v.Constraint)
 		return v
 	}
 
-	_, err = semver.NewConstraint(v.Reference)
+	_, err = semver.NewConstraint(v.Constraint.String())
 	if err != nil {
-		// existing.Reference is not a reference or a valid constraint.
+		// existing.Constraint is not a reference or a valid constraint.
 		// We really should never end up here.
-		singleWarn("Version %s %s is not a reference or valid semantic version constraint\n", v.Name, v.Reference)
+		singleWarn("Version %s %s is not a reference or valid semantic version constraint\n", v.Name, v.Constraint)
 
-		v.Reference = dep.Reference
-		v.Pin = ""
-		singleInfo("Using %s %s because it is a valid version", v.Name, v.Reference)
+		v.Constraint = dep.Constraint
+		//v.Pin = ""
+		singleInfo("Using %s %s because it is a valid version", v.Name, v.Constraint)
 		return v
 	}
 
 	// Both versions are constraints. Try to merge them.
 	// If either comparison has an || skip merging. That's complicated.
-	ddor := strings.Index(dep.Reference, "||")
-	eor := strings.Index(v.Reference, "||")
+	ddor := strings.Index(dep.Constraint.String(), "||")
+	eor := strings.Index(v.Constraint.String(), "||")
 	if ddor == -1 && eor == -1 {
 		// Add the comparisons together.
-		newRef := v.Reference + ", " + dep.Reference
-		v.Reference = newRef
-		v.Pin = ""
-		singleInfo("Combining %s semantic version constraints %s and %s", v.Name, v.Reference, dep.Reference)
+		// TODO(sdboyer) this all just reeeeeally needs to go
+		v.Constraint = v.Constraint.Intersect(dep.Constraint)
+		//v.Pin = ""
+		singleInfo("Combining %s semantic version constraints %s and %s", v.Name, v.Constraint, dep.Constraint)
 		return v
 	}
-	singleWarn("Conflict: %s version is %s, but also asked for %s\n", v.Name, v.Reference, dep.Reference)
-	singleInfo("Keeping %s %s", v.Name, v.Reference)
+	singleWarn("Conflict: %s version is %s, but also asked for %s\n", v.Name, v.Constraint, dep.Constraint)
+	singleInfo("Keeping %s %s", v.Name, v.Constraint)
 	return v
 }
 
@@ -877,13 +862,13 @@
 	displayCommitInfoPrefix + "- subject (first line): %s\n"
 
 func displayCommitInfo(repo vcs.Repo, dep *cfg.Dependency) {
-	c, err := repo.CommitInfo(dep.Reference)
-	ref := dep.Reference
+	ref := dep.Constraint.String()
+	c, err := repo.CommitInfo(ref)
 
 	if err == nil {
 		tgs, err2 := repo.TagsFromCommit(c.Commit)
 		if err2 == nil && len(tgs) > 0 {
-			if tgs[0] != dep.Reference {
+			if tgs[0] != ref {
 				ref = ref + " (" + tgs[0] + ")"
 			}
 		}
diff --git a/repo/set_reference.go b/repo/set_reference.go
index f5891ac..e4367e3 100644
--- a/repo/set_reference.go
+++ b/repo/set_reference.go
@@ -47,7 +47,7 @@
 					}
 					cache.Lock(key)
 					if err := VcsVersion(dep, cwd); err != nil {
-						msg.Err("Failed to set version on %s to %s: %s\n", dep.Name, dep.Reference, err)
+						msg.Err("Failed to set version on %s to %s: %s\n", dep.Name, dep.Constraint, err)
 
 						// Capture the error while making sure the concurrent
 						// operations don't step on each other.
diff --git a/repo/vcs.go b/repo/vcs.go
index ba84ca2..2f3b0cf 100644
--- a/repo/vcs.go
+++ b/repo/vcs.go
@@ -18,6 +18,7 @@
 	gpath "github.com/Masterminds/glide/path"
 	"github.com/Masterminds/semver"
 	v "github.com/Masterminds/vcs"
+	"github.com/sdboyer/gps"
 )
 
 // VcsUpdate updates to a particular checkout based on the VCS setting.
@@ -25,10 +26,10 @@
 
 	// If the dependency has already been pinned we can skip it. This is a
 	// faster path so we don't need to resolve it again.
-	if dep.Pin != "" {
-		msg.Debug("Dependency %s has already been pinned. Fetching updates skipped.", dep.Name)
-		return nil
-	}
+	//if dep.Pin != "" {
+	//msg.Debug("Dependency %s has already been pinned. Fetching updates skipped.", dep.Name)
+	//return nil
+	//}
 
 	if updated.Check(dep.Name) {
 		msg.Debug("%s was already updated, skipping.", dep.Name)
@@ -83,7 +84,7 @@
 					msg.Err("Unable to update vendored dependency %s.\n", dep.Name)
 					return err
 				}
-				dep.UpdateAsVendored = true
+				//dep.UpdateAsVendored = true
 
 				if err = VcsGet(dep, dest, home, cache, cacheGopath, useGopath); err != nil {
 					msg.Warn("Unable to checkout %s\n", dep.Name)
@@ -132,21 +133,22 @@
 			// and that version is already checked out we can skip updating
 			// which is faster than going out to the Internet to perform
 			// an update.
-			if dep.Reference != "" {
+			if dep.Constraint != nil {
 				version, err := repo.Version()
 				if err != nil {
 					return err
 				}
-				ib, err := isBranch(dep.Reference, repo)
-				if err != nil {
-					return err
+
+				var ib bool
+				if cv, ok := dep.Constraint.(gps.Version); ok {
+					ib = cv.Type() == "branch"
 				}
 
 				// If the current version equals the ref and it's not a
 				// branch it's a tag or commit id so we can skip
 				// performing an update.
-				if version == dep.Reference && !ib {
-					msg.Debug("%s is already set to version %s. Skipping update.", dep.Name, dep.Reference)
+				if version == dep.Constraint.String() && !ib {
+					msg.Debug("%s is already set to version %s. Skipping update.", dep.Name, dep.Constraint)
 					return nil
 				}
 			}
@@ -166,24 +168,24 @@
 
 	// If the dependency has already been pinned we can skip it. This is a
 	// faster path so we don't need to resolve it again.
-	if dep.Pin != "" {
-		msg.Debug("Dependency %s has already been pinned. Setting version skipped.", dep.Name)
-		return nil
-	}
+	//if dep.Pin != "" {
+	//msg.Debug("Dependency %s has already been pinned. Setting version skipped.", dep.Name)
+	//return nil
+	//}
 
 	cwd := filepath.Join(vend, dep.Name)
 
 	// If there is no reference configured there is nothing to set.
-	if dep.Reference == "" {
+	if dep.Constraint == nil {
 		// Before exiting update the pinned version
-		repo, err := dep.GetRepo(cwd)
-		if err != nil {
-			return err
-		}
-		dep.Pin, err = repo.Version()
-		if err != nil {
-			return err
-		}
+		//_, err := dep.GetRepo(cwd)
+		//if err != nil {
+		//return err
+		//}
+		//dep.Pin, err = repo.Version()
+		//if err != nil {
+		//return err
+		//}
 		return nil
 	}
 
@@ -202,7 +204,7 @@
 			return err
 		}
 
-		ver := dep.Reference
+		ver := dep.Constraint.String()
 		// References in Git can begin with a ^ which is similar to semver.
 		// If there is a ^ prefix we assume it's a semver constraint rather than
 		// part of the git/VCS commit id.
@@ -250,10 +252,10 @@
 		if err := repo.UpdateVersion(ver); err != nil {
 			return err
 		}
-		dep.Pin, err = repo.Version()
-		if err != nil {
-			return err
-		}
+		//dep.Pin, err = repo.Version()
+		//if err != nil {
+		//return err
+		//}
 	}
 
 	return nil
@@ -306,7 +308,7 @@
 
 				// If there is no reference set on the dep we try to checkout
 				// the default branch.
-				if dep.Reference == "" {
+				if dep.Constraint == nil {
 					db := defaultBranch(repo, home)
 					if db != "" {
 						err = repo.UpdateVersion(db)
@@ -477,32 +479,6 @@
 //
 // FIXME: Should this be moved to the dependency package?
 func filterArchOs(dep *cfg.Dependency) bool {
-	found := false
-	if len(dep.Arch) > 0 {
-		for _, a := range dep.Arch {
-			if a == runtime.GOARCH {
-				found = true
-			}
-		}
-		// If it's not found, it should be filtered out.
-		if !found {
-			return true
-		}
-	}
-
-	found = false
-	if len(dep.Os) > 0 {
-		for _, o := range dep.Os {
-			if o == runtime.GOOS {
-				found = true
-			}
-		}
-		if !found {
-			return true
-		}
-
-	}
-
 	return false
 }
 
diff --git a/repo/vendored_cleanup.go b/repo/vendored_cleanup.go
index acbab91..1db6de9 100644
--- a/repo/vendored_cleanup.go
+++ b/repo/vendored_cleanup.go
@@ -20,23 +20,22 @@
 	}
 
 	for _, dep := range conf.Imports {
-		if dep.UpdateAsVendored == true {
-			msg.Info("Cleaning up vendored package %s\n", dep.Name)
+		//if dep.UpdateAsVendored == true {
+		msg.Info("Cleaning up vendored package %s\n", dep.Name)
 
-			// Remove the VCS directory
-			cwd := filepath.Join(vend, dep.Name)
-			repo, err := dep.GetRepo(cwd)
-			if err != nil {
-				msg.Err("Error cleaning up %s:%s", dep.Name, err)
-				continue
-			}
-			t := repo.Vcs()
-			err = os.RemoveAll(cwd + string(os.PathSeparator) + "." + string(t))
-			if err != nil {
-				msg.Err("Error cleaning up VCS dir for %s:%s", dep.Name, err)
-			}
+		// Remove the VCS directory
+		cwd := filepath.Join(vend, dep.Name)
+		repo, err := dep.GetRepo(cwd)
+		if err != nil {
+			msg.Err("Error cleaning up %s:%s", dep.Name, err)
+			continue
 		}
-
+		t := repo.Vcs()
+		err = os.RemoveAll(cwd + string(os.PathSeparator) + "." + string(t))
+		if err != nil {
+			msg.Err("Error cleaning up VCS dir for %s:%s", dep.Name, err)
+		}
+		//}
 	}
 
 	return nil