diff --git a/range.go b/range.go
index 11390f5..fca406d 100644
--- a/range.go
+++ b/range.go
@@ -2,10 +2,33 @@ package semver
 
 import (
 	"fmt"
+	"strconv"
 	"strings"
 	"unicode"
 )
 
+type wildcardType int
+
+const (
+	noneWildcard  wildcardType = iota
+	majorWildcard wildcardType = 1
+	minorWildcard wildcardType = 2
+	patchWildcard wildcardType = 3
+)
+
+func wildcardTypefromInt(i int) wildcardType {
+	switch i {
+	case 1:
+		return majorWildcard
+	case 2:
+		return minorWildcard
+	case 3:
+		return patchWildcard
+	default:
+		return noneWildcard
+	}
+}
+
 type comparator func(Version, Version) bool
 
 var (
@@ -92,8 +115,12 @@ func ParseRange(s string) (Range, error) {
 	if err != nil {
 		return nil, err
 	}
+	expandedParts, err := expandWildcardVersion(orParts)
+	if err != nil {
+		return nil, err
+	}
 	var orFn Range
-	for _, p := range orParts {
+	for _, p := range expandedParts {
 		var andFn Range
 		for _, ap := range p {
 			opStr, vStr, err := splitComparatorVersion(ap)
@@ -207,7 +234,6 @@ func splitAndTrim(s string) (result []string) {
 }
 
 // splitComparatorVersion splits the comparator from the version.
-// Spaces between the comparator and the version are not allowed.
 // Input must be free of leading or trailing spaces.
 func splitComparatorVersion(s string) (string, string, error) {
 	i := strings.IndexFunc(s, unicode.IsDigit)
@@ -217,6 +243,144 @@ func splitComparatorVersion(s string) (string, string, error) {
 	return strings.TrimSpace(s[0:i]), s[i:], nil
 }
 
+// getWildcardType will return the type of wildcard that the
+// passed version contains
+func getWildcardType(vStr string) wildcardType {
+	parts := strings.Split(vStr, ".")
+	nparts := len(parts)
+	wildcard := parts[nparts-1]
+
+	possibleWildcardType := wildcardTypefromInt(nparts)
+	if wildcard == "x" {
+		return possibleWildcardType
+	}
+
+	return noneWildcard
+}
+
+// createVersionFromWildcard will convert a wildcard version
+// into a regular version, replacing 'x's with '0's, handling
+// special cases like '1.x.x' and '1.x'
+func createVersionFromWildcard(vStr string) string {
+	// handle 1.x.x
+	vStr2 := strings.Replace(vStr, ".x.x", ".x", 1)
+	vStr2 = strings.Replace(vStr2, ".x", ".0", 1)
+	parts := strings.Split(vStr2, ".")
+
+	// handle 1.x
+	if len(parts) == 2 {
+		return vStr2 + ".0"
+	}
+
+	return vStr2
+}
+
+// incrementMajorVersion will increment the major version
+// of the passed version
+func incrementMajorVersion(vStr string) (string, error) {
+	parts := strings.Split(vStr, ".")
+	i, err := strconv.Atoi(parts[0])
+	if err != nil {
+		return "", err
+	}
+	parts[0] = strconv.Itoa(i + 1)
+
+	return strings.Join(parts, "."), nil
+}
+
+// incrementMajorVersion will increment the minor version
+// of the passed version
+func incrementMinorVersion(vStr string) (string, error) {
+	parts := strings.Split(vStr, ".")
+	i, err := strconv.Atoi(parts[1])
+	if err != nil {
+		return "", err
+	}
+	parts[1] = strconv.Itoa(i + 1)
+
+	return strings.Join(parts, "."), nil
+}
+
+// expandWildcardVersion will expand wildcards inside versions
+// following these rules:
+//
+// * when dealing with patch wildcards:
+// >= 1.2.x    will become    >= 1.2.0
+// <= 1.2.x    will become    <  1.3.0
+// >  1.2.x    will become    >= 1.3.0
+// <  1.2.x    will become    <  1.2.0
+// != 1.2.x    will become    <  1.2.0 >= 1.3.0
+//
+// * when dealing with minor wildcards:
+// >= 1.x      will become    >= 1.0.0
+// <= 1.x      will become    <  2.0.0
+// >  1.x      will become    >= 2.0.0
+// <  1.0      will become    <  1.0.0
+// != 1.x      will become    <  1.0.0 >= 2.0.0
+//
+// * when dealing with wildcards without
+// version operator:
+// 1.2.x       will become    >= 1.2.0 < 1.3.0
+// 1.x         will become    >= 1.0.0 < 2.0.0
+func expandWildcardVersion(parts [][]string) ([][]string, error) {
+	var expandedParts [][]string
+	for _, p := range parts {
+		var newParts []string
+		for _, ap := range p {
+			if strings.Index(ap, "x") != -1 {
+				opStr, vStr, err := splitComparatorVersion(ap)
+				if err != nil {
+					return nil, err
+				}
+
+				versionWildcardType := getWildcardType(vStr)
+				flatVersion := createVersionFromWildcard(vStr)
+
+				var resultOperator string
+				var shouldIncrementVersion bool
+				switch opStr {
+				case ">":
+					resultOperator = ">="
+					shouldIncrementVersion = true
+				case ">=":
+					resultOperator = ">="
+				case "<":
+					resultOperator = "<"
+				case "<=":
+					resultOperator = "<"
+					shouldIncrementVersion = true
+				case "", "=", "==":
+					newParts = append(newParts, ">="+flatVersion)
+					resultOperator = "<"
+					shouldIncrementVersion = true
+				case "!=", "!":
+					newParts = append(newParts, "<"+flatVersion)
+					resultOperator = ">="
+					shouldIncrementVersion = true
+				}
+
+				var resultVersion string
+				if shouldIncrementVersion {
+					switch versionWildcardType {
+					case patchWildcard:
+						resultVersion, _ = incrementMinorVersion(flatVersion)
+					case minorWildcard:
+						resultVersion, _ = incrementMajorVersion(flatVersion)
+					}
+				} else {
+					resultVersion = flatVersion
+				}
+
+				ap = resultOperator + resultVersion
+			}
+			newParts = append(newParts, ap)
+		}
+		expandedParts = append(expandedParts, newParts)
+	}
+
+	return expandedParts, nil
+}
+
 func parseComparator(s string) comparator {
 	switch s {
 	case "==":
diff --git a/range_test.go b/range_test.go
index 1d71837..83ee9c7 100644
--- a/range_test.go
+++ b/range_test.go
@@ -6,6 +6,11 @@ import (
 	"testing"
 )
 
+type wildcardTypeTest struct {
+	input        string
+	wildcardType wildcardType
+}
+
 type comparatorTest struct {
 	input      string
 	comparator func(comparator) bool
@@ -192,6 +197,103 @@ func TestSplitORParts(t *testing.T) {
 	}
 }
 
+func TestGetWildcardType(t *testing.T) {
+	wildcardTypeTests := []wildcardTypeTest{
+		{"x", majorWildcard},
+		{"1.x", minorWildcard},
+		{"1.2.x", patchWildcard},
+		{"fo.o.b.ar", noneWildcard},
+	}
+
+	for _, tc := range wildcardTypeTests {
+		o := getWildcardType(tc.input)
+		if o != tc.wildcardType {
+			t.Errorf("Invalid for case: %q: Expected %q, got: %q", tc.input, tc.wildcardType, o)
+		}
+	}
+}
+
+func TestCreateVersionFromWildcard(t *testing.T) {
+	tests := []struct {
+		i string
+		s string
+	}{
+		{"1.2.x", "1.2.0"},
+		{"1.x", "1.0.0"},
+	}
+
+	for _, tc := range tests {
+		p := createVersionFromWildcard(tc.i)
+		if p != tc.s {
+			t.Errorf("Invalid for case %q: Expected %q, got: %q", tc.i, tc.s, p)
+		}
+	}
+}
+
+func TestIncrementMajorVersion(t *testing.T) {
+	tests := []struct {
+		i string
+		s string
+	}{
+		{"1.2.3", "2.2.3"},
+		{"1.2", "2.2"},
+		{"foo.bar", ""},
+	}
+
+	for _, tc := range tests {
+		p, _ := incrementMajorVersion(tc.i)
+		if p != tc.s {
+			t.Errorf("Invalid for case %q: Expected %q, got: %q", tc.i, tc.s, p)
+		}
+	}
+}
+
+func TestIncrementMinorVersion(t *testing.T) {
+	tests := []struct {
+		i string
+		s string
+	}{
+		{"1.2.3", "1.3.3"},
+		{"1.2", "1.3"},
+		{"foo.bar", ""},
+	}
+
+	for _, tc := range tests {
+		p, _ := incrementMinorVersion(tc.i)
+		if p != tc.s {
+			t.Errorf("Invalid for case %q: Expected %q, got: %q", tc.i, tc.s, p)
+		}
+	}
+}
+
+func TestExpandWildcardVersion(t *testing.T) {
+	tests := []struct {
+		i [][]string
+		o [][]string
+	}{
+		{[][]string{[]string{"foox"}}, nil},
+		{[][]string{[]string{">=1.2.x"}}, [][]string{[]string{">=1.2.0"}}},
+		{[][]string{[]string{"<=1.2.x"}}, [][]string{[]string{"<1.3.0"}}},
+		{[][]string{[]string{">1.2.x"}}, [][]string{[]string{">=1.3.0"}}},
+		{[][]string{[]string{"<1.2.x"}}, [][]string{[]string{"<1.2.0"}}},
+		{[][]string{[]string{"!=1.2.x"}}, [][]string{[]string{"<1.2.0", ">=1.3.0"}}},
+		{[][]string{[]string{">=1.x"}}, [][]string{[]string{">=1.0.0"}}},
+		{[][]string{[]string{"<=1.x"}}, [][]string{[]string{"<2.0.0"}}},
+		{[][]string{[]string{">1.x"}}, [][]string{[]string{">=2.0.0"}}},
+		{[][]string{[]string{"<1.x"}}, [][]string{[]string{"<1.0.0"}}},
+		{[][]string{[]string{"!=1.x"}}, [][]string{[]string{"<1.0.0", ">=2.0.0"}}},
+		{[][]string{[]string{"1.2.x"}}, [][]string{[]string{">=1.2.0", "<1.3.0"}}},
+		{[][]string{[]string{"1.x"}}, [][]string{[]string{">=1.0.0", "<2.0.0"}}},
+	}
+
+	for _, tc := range tests {
+		o, _ := expandWildcardVersion(tc.i)
+		if !reflect.DeepEqual(tc.o, o) {
+			t.Errorf("Invalid for case %q: Expected %q, got: %q", tc.i, tc.o, o)
+		}
+	}
+}
+
 func TestVersionRangeToRange(t *testing.T) {
 	vr := versionRange{
 		v: MustParse("1.2.3"),
@@ -311,7 +413,7 @@ func TestParseRange(t *testing.T) {
 		{"1.0", nil},
 		{"string", nil},
 		{"", nil},
-
+		{"fo.ob.ar.x", nil},
 		// AND Expressions
 		{">1.2.2 <1.2.4", []tv{
 			{"1.2.2", false},
@@ -347,6 +449,18 @@ func TestParseRange(t *testing.T) {
 			{"1.2.3", false},
 			{"1.2.4", false},
 		}},
+		// Wildcard expressions
+		{">1.x", []tv{
+			{"0.1.9", false},
+			{"1.2.6", false},
+			{"1.9.0", false},
+			{"2.0.0", true},
+		}},
+		{">1.2.x", []tv{
+			{"1.1.9", false},
+			{"1.2.6", false},
+			{"1.3.0", true},
+		}},
 		// Combined Expressions
 		{">1.2.2 <1.2.4 || >=2.0.0", []tv{
 			{"1.2.2", false},
@@ -355,6 +469,13 @@ func TestParseRange(t *testing.T) {
 			{"2.0.0", true},
 			{"2.0.1", true},
 		}},
+		{"1.x || >=2.0.x <2.2.x", []tv{
+			{"0.9.2", false},
+			{"1.2.2", true},
+			{"2.0.0", true},
+			{"2.1.8", true},
+			{"2.2.0", false},
+		}},
 		{">1.2.2 <1.2.4 || >=2.0.0 <3.0.0", []tv{
 			{"1.2.2", false},
 			{"1.2.3", true},