diff --git a/flag.go b/flag.go
index fd03681..33db47c 100644
--- a/flag.go
+++ b/flag.go
@@ -120,6 +120,10 @@
 	PanicOnError
 )
 
+// normalizedName is a flag name that has been normalized according to rules
+// for the FlagSet (e.g. making '-' and '_' equivalent).
+type normalizedName string
+
 // A FlagSet represents a set of defined flags.
 type FlagSet struct {
 	// Usage is the function called when an error occurs while parsing flags.
@@ -127,16 +131,17 @@
 	// a custom error handler.
 	Usage func()
 
-	name          string
-	parsed        bool
-	actual        map[string]*Flag
-	formal        map[string]*Flag
-	shorthands    map[byte]*Flag
-	args          []string // arguments after flags
-	exitOnError   bool     // does the program exit if there's an error?
-	errorHandling ErrorHandling
-	output        io.Writer // nil means stderr; use out() accessor
-	interspersed  bool      // allow interspersed option/non-option args
+	name           string
+	parsed         bool
+	actual         map[normalizedName]*Flag
+	formal         map[normalizedName]*Flag
+	shorthands     map[byte]*Flag
+	args           []string // arguments after flags
+	exitOnError    bool     // does the program exit if there's an error?
+	errorHandling  ErrorHandling
+	output         io.Writer // nil means stderr; use out() accessor
+	interspersed   bool      // allow interspersed option/non-option args
+	wordSeparators []string
 }
 
 // A Flag represents the state of a flag.
@@ -159,21 +164,30 @@
 }
 
 // sortFlags returns the flags as a slice in lexicographical sorted order.
-func sortFlags(flags map[string]*Flag) []*Flag {
+func sortFlags(flags map[normalizedName]*Flag) []*Flag {
 	list := make(sort.StringSlice, len(flags))
 	i := 0
-	for _, f := range flags {
-		list[i] = f.Name
+	for k := range flags {
+		list[i] = string(k)
 		i++
 	}
 	list.Sort()
 	result := make([]*Flag, len(list))
 	for i, name := range list {
-		result[i] = flags[name]
+		result[i] = flags[normalizedName(name)]
 	}
 	return result
 }
 
+func (f *FlagSet) normalizeFlagName(name string) normalizedName {
+	result := name
+	for _, sep := range f.wordSeparators {
+		result = strings.Replace(result, sep, "-", -1)
+	}
+	// Type convert to indicate normalization has been done.
+	return normalizedName(result)
+}
+
 func (f *FlagSet) out() io.Writer {
 	if f.output == nil {
 		return os.Stderr
@@ -221,18 +235,24 @@
 
 // Lookup returns the Flag structure of the named flag, returning nil if none exists.
 func (f *FlagSet) Lookup(name string) *Flag {
+	return f.lookup(f.normalizeFlagName(name))
+}
+
+// lookup returns the Flag structure of the named flag, returning nil if none exists.
+func (f *FlagSet) lookup(name normalizedName) *Flag {
 	return f.formal[name]
 }
 
 // Lookup returns the Flag structure of the named command-line flag,
 // returning nil if none exists.
 func Lookup(name string) *Flag {
-	return CommandLine.formal[name]
+	return CommandLine.Lookup(name)
 }
 
 // Set sets the value of the named flag.
 func (f *FlagSet) Set(name, value string) error {
-	flag, ok := f.formal[name]
+	normalName := f.normalizeFlagName(name)
+	flag, ok := f.formal[normalName]
 	if !ok {
 		return fmt.Errorf("no such flag -%v", name)
 	}
@@ -241,10 +261,10 @@
 		return err
 	}
 	if f.actual == nil {
-		f.actual = make(map[string]*Flag)
+		f.actual = make(map[normalizedName]*Flag)
 	}
-	f.actual[name] = flag
-	f.Lookup(name).Changed = true
+	f.actual[normalName] = flag
+	f.lookup(normalName).Changed = true
 	return nil
 }
 
@@ -370,16 +390,16 @@
 }
 
 func (f *FlagSet) AddFlag(flag *Flag) {
-	_, alreadythere := f.formal[flag.Name]
+	_, alreadythere := f.formal[f.normalizeFlagName(flag.Name)]
 	if alreadythere {
 		msg := fmt.Sprintf("%s flag redefined: %s", f.name, flag.Name)
 		fmt.Fprintln(f.out(), msg)
 		panic(msg) // Happens only if flags are declared with identical names
 	}
 	if f.formal == nil {
-		f.formal = make(map[string]*Flag)
+		f.formal = make(map[normalizedName]*Flag)
 	}
-	f.formal[flag.Name] = flag
+	f.formal[f.normalizeFlagName(flag.Name)] = flag
 
 	if len(flag.Shorthand) == 0 {
 		return
@@ -442,9 +462,9 @@
 	}
 	// mark as visited for Visit()
 	if f.actual == nil {
-		f.actual = make(map[string]*Flag)
+		f.actual = make(map[normalizedName]*Flag)
 	}
-	f.actual[flag.Name] = flag
+	f.actual[f.normalizeFlagName(flag.Name)] = flag
 	flag.Changed = true
 	return nil
 }
@@ -463,7 +483,7 @@
 	split := strings.SplitN(name, "=", 2)
 	name = split[0]
 	m := f.formal
-	flag, alreadythere := m[name] // BUG
+	flag, alreadythere := m[f.normalizeFlagName(name)] // BUG
 	if !alreadythere {
 		if name == "help" { // special case for nice help message.
 			f.usage()
@@ -513,7 +533,8 @@
 				continue
 			}
 			if i < len(shorthands)-1 {
-				if e := f.setFlag(flag, shorthands[i+1:], s); e != nil {
+				v := strings.TrimPrefix(shorthands[i+1:], "=")
+				if e := f.setFlag(flag, v, s); e != nil {
 					err = e
 					return
 				}
@@ -604,6 +625,19 @@
 	CommandLine.SetInterspersed(interspersed)
 }
 
+// SetWordSeparators sets a list of strings to be considerered as word
+// separators and normalized for the pruposes of lookups.  For example, if this
+// is set to {"-", "_", "."} then --foo_bar, --foo-bar, and --foo.bar are
+// considered equivalent flags.  This must be called before flags are parsed,
+// and may only be called once.
+func (f *FlagSet) SetWordSeparators(separators []string) {
+	f.wordSeparators = separators
+	for k, v := range f.formal {
+		delete(f.formal, k)
+		f.formal[f.normalizeFlagName(string(k))] = v
+	}
+}
+
 // Parsed returns true if the command-line flags have been parsed.
 func Parsed() bool {
 	return CommandLine.Parsed()
diff --git a/flag_test.go b/flag_test.go
index a33c601..c4055ed 100644
--- a/flag_test.go
+++ b/flag_test.go
@@ -185,7 +185,8 @@
 	boolaFlag := f.BoolP("boola", "a", false, "bool value")
 	boolbFlag := f.BoolP("boolb", "b", false, "bool2 value")
 	boolcFlag := f.BoolP("boolc", "c", false, "bool3 value")
-	stringFlag := f.StringP("string", "s", "0", "string value")
+	stringaFlag := f.StringP("stringa", "s", "0", "string value")
+	stringzFlag := f.StringP("stringz", "z", "0", "string value")
 	extra := "interspersed-argument"
 	notaflag := "--i-look-like-a-flag"
 	args := []string{
@@ -193,6 +194,7 @@
 		extra,
 		"-cs",
 		"hello",
+		"-z=something",
 		"--",
 		notaflag,
 	}
@@ -212,8 +214,11 @@
 	if *boolcFlag != true {
 		t.Error("boolc flag should be true, is ", *boolcFlag)
 	}
-	if *stringFlag != "hello" {
-		t.Error("string flag should be `hello`, is ", *stringFlag)
+	if *stringaFlag != "hello" {
+		t.Error("stringa flag should be `hello`, is ", *stringaFlag)
+	}
+	if *stringzFlag != "something" {
+		t.Error("stringz flag should be `something`, is ", *stringzFlag)
 	}
 	if len(f.Args()) != 2 {
 		t.Error("expected one argument, got", len(f.Args()))
@@ -233,6 +238,56 @@
 	testParse(NewFlagSet("test", ContinueOnError), t)
 }
 
+func testNormalizedNames(args []string, t *testing.T) {
+	f := NewFlagSet("normalized", ContinueOnError)
+	if f.Parsed() {
+		t.Error("f.Parse() = true before Parse")
+	}
+	withDashFlag := f.Bool("with-dash-flag", false, "bool value")
+	// Set this after some flags have been added and before others.
+	f.SetWordSeparators([]string{"-", "_"})
+	withUnderFlag := f.Bool("with_under_flag", false, "bool value")
+	withBothFlag := f.Bool("with-both_flag", false, "bool value")
+	if err := f.Parse(args); err != nil {
+		t.Fatal(err)
+	}
+	if !f.Parsed() {
+		t.Error("f.Parse() = false after Parse")
+	}
+	if *withDashFlag != true {
+		t.Error("withDashFlag flag should be true, is ", *withDashFlag)
+	}
+	if *withUnderFlag != true {
+		t.Error("withUnderFlag flag should be true, is ", *withUnderFlag)
+	}
+	if *withBothFlag != true {
+		t.Error("withBothFlag flag should be true, is ", *withBothFlag)
+	}
+}
+
+func TestNormalizedNames(t *testing.T) {
+	args := []string{
+		"--with-dash-flag",
+		"--with-under-flag",
+		"--with-both-flag",
+	}
+	testNormalizedNames(args, t)
+
+	args = []string{
+		"--with_dash_flag",
+		"--with_under_flag",
+		"--with_both_flag",
+	}
+	testNormalizedNames(args, t)
+
+	args = []string{
+		"--with-dash_flag",
+		"--with-under_flag",
+		"--with-both_flag",
+	}
+	testNormalizedNames(args, t)
+}
+
 // Declare a user-defined flag type.
 type flagVar []string