diff --git a/router/handshake.go b/router/handshake.go
index ee3ef90d..d9d0ecda 100644
--- a/router/handshake.go
+++ b/router/handshake.go
@@ -59,7 +59,7 @@ func (conn *LocalConnection) handshake(enc *gob.Encoder, dec *gob.Decoder, accep
 		"ProtocolVersion": versionStr,
 		"PeerNameFlavour": PeerNameFlavour,
 		"Name":            conn.local.Name.String(),
-		"HostName":        conn.local.HostName,
+		"NickName":        conn.local.NickName,
 		"UID":             fmt.Sprint(conn.local.UID),
 		"ConnID":          fmt.Sprint(localConnID)}
 	handshakeRecv := map[string]string{}
@@ -85,7 +85,7 @@ func (conn *LocalConnection) handshake(enc *gob.Encoder, dec *gob.Decoder, accep
 	fv.CheckEqual("ProtocolVersion", versionStr)
 	fv.CheckEqual("PeerNameFlavour", PeerNameFlavour)
 	nameStr, _ := fv.Value("Name")
-	hostNameStr, _ := fv.Value("HostName")
+	nickNameStr, _ := fv.Value("NickName")
 	uidStr, _ := fv.Value("UID")
 	remoteConnIdStr, _ := fv.Value("ConnID")
 	if err := fv.Err(); err != nil {
@@ -138,7 +138,7 @@ func (conn *LocalConnection) handshake(enc *gob.Encoder, dec *gob.Decoder, accep
 		conn.Decryptor = NewNonDecryptor(conn)
 	}
 
-	toPeer := NewPeer(name, hostNameStr, uid, 0)
+	toPeer := NewPeer(name, nickNameStr, uid, 0)
 	toPeer = conn.Router.Peers.FetchWithDefault(toPeer)
 	switch toPeer {
 	case nil:
diff --git a/router/local_peer.go b/router/local_peer.go
index 3599de86..9164e887 100644
--- a/router/local_peer.go
+++ b/router/local_peer.go
@@ -18,8 +18,8 @@ type PeerInteraction struct {
 	payload interface{}
 }
 
-func NewLocalPeer(name PeerName, hostName string, router *Router) *LocalPeer {
-	return &LocalPeer{Peer: NewPeer(name, hostName, 0, 0), Router: router}
+func NewLocalPeer(name PeerName, nickName string, router *Router) *LocalPeer {
+	return &LocalPeer{Peer: NewPeer(name, nickName, 0, 0), Router: router}
 }
 
 func (peer *LocalPeer) Start() {
diff --git a/router/peer.go b/router/peer.go
index adcc42eb..86047e3a 100644
--- a/router/peer.go
+++ b/router/peer.go
@@ -10,21 +10,21 @@ type Peer struct {
 	sync.RWMutex
 	Name          PeerName
 	NameByte      []byte
-	HostName      string
+	NickName      string
 	UID           uint64
 	version       uint64
 	localRefCount uint64
 	connections   map[PeerName]Connection
 }
 
-func NewPeer(name PeerName, hostName string, uid uint64, version uint64) *Peer {
+func NewPeer(name PeerName, nickName string, uid uint64, version uint64) *Peer {
 	if uid == 0 {
 		uid = randUint64()
 	}
 	return &Peer{
 		Name:        name,
 		NameByte:    name.Bin(),
-		HostName:    hostName,
+		NickName:    nickName,
 		UID:         uid,
 		version:     version,
 		connections: make(map[PeerName]Connection)}
@@ -33,7 +33,7 @@ func NewPeer(name PeerName, hostName string, uid uint64, version uint64) *Peer {
 func (peer *Peer) String() string {
 	peer.RLock()
 	defer peer.RUnlock()
-	return fmt.Sprint("Peer ", peer.Name, " (", peer.HostName, ") (v", peer.version, ") (UID ", peer.UID, ")")
+	return fmt.Sprint("Peer ", peer.Name, " (", peer.NickName, ") (v", peer.version, ") (UID ", peer.UID, ")")
 }
 
 func (peer *Peer) Version() uint64 {
diff --git a/router/peers.go b/router/peers.go
index 7d3f84bd..e8540a8a 100644
--- a/router/peers.go
+++ b/router/peers.go
@@ -128,7 +128,7 @@ func (peers *Peers) String() string {
 			if !conn.Established() {
 				established = " (unestablished)"
 			}
-			buf.WriteString(fmt.Sprintf("   -> %v (%v) [%v%s]\n", remoteName, conn.Remote().HostName, conn.RemoteTCPAddr(), established))
+			buf.WriteString(fmt.Sprintf("   -> %v (%v) [%v%s]\n", remoteName, conn.Remote().NickName, conn.RemoteTCPAddr(), established))
 		})
 	})
 	return buf.String()
@@ -178,7 +178,7 @@ func (peers *Peers) decodeUpdate(update []byte) (newPeers map[PeerName]*Peer, de
 	decoder := gob.NewDecoder(updateBuf)
 
 	for {
-		nameByte, hostName, uid, version, connsBuf, decErr := decodePeerNoConns(decoder)
+		nameByte, nickName, uid, version, connsBuf, decErr := decodePeerNoConns(decoder)
 		if decErr == io.EOF {
 			break
 		} else if decErr != nil {
@@ -186,7 +186,7 @@ func (peers *Peers) decodeUpdate(update []byte) (newPeers map[PeerName]*Peer, de
 			return
 		}
 		name := PeerNameFromBin(nameByte)
-		newPeer := NewPeer(name, hostName, uid, version)
+		newPeer := NewPeer(name, nickName, uid, version)
 		decodedUpdate = append(decodedUpdate, newPeer)
 		decodedConns = append(decodedConns, connsBuf)
 		existingPeer, found := peers.table[name]
@@ -257,7 +257,7 @@ func (peer *Peer) encode(enc *gob.Encoder) {
 	defer peer.RUnlock()
 
 	checkFatal(enc.Encode(peer.NameByte))
-	checkFatal(enc.Encode(peer.HostName))
+	checkFatal(enc.Encode(peer.NickName))
 	checkFatal(enc.Encode(peer.UID))
 	checkFatal(enc.Encode(peer.version))
 
@@ -272,11 +272,11 @@ func (peer *Peer) encode(enc *gob.Encoder) {
 	checkFatal(enc.Encode(connsBuf.Bytes()))
 }
 
-func decodePeerNoConns(dec *gob.Decoder) (nameByte []byte, hostName string, uid uint64, version uint64, conns []byte, err error) {
+func decodePeerNoConns(dec *gob.Decoder) (nameByte []byte, nickName string, uid uint64, version uint64, conns []byte, err error) {
 	if err = dec.Decode(&nameByte); err != nil {
 		return
 	}
-	if err = dec.Decode(&hostName); err != nil {
+	if err = dec.Decode(&nickName); err != nil {
 		return
 	}
 	if err = dec.Decode(&uid); err != nil {
diff --git a/router/router.go b/router/router.go
index f0a02ab0..fd867ee2 100644
--- a/router/router.go
+++ b/router/router.go
@@ -46,7 +46,7 @@ type PacketSourceSink interface {
 	PacketSink
 }
 
-func NewRouter(iface *net.Interface, name PeerName, hostName string, password []byte, connLimit int, bufSz int, logFrame func(string, []byte, *layers.Ethernet)) *Router {
+func NewRouter(iface *net.Interface, name PeerName, nickName string, password []byte, connLimit int, bufSz int, logFrame func(string, []byte, *layers.Ethernet)) *Router {
 	router := &Router{
 		Iface:          iface,
 		GossipChannels: make(map[uint32]*GossipChannel),
@@ -63,7 +63,7 @@ func NewRouter(iface *net.Interface, name PeerName, hostName string, password []
 		router.Macs.Delete(peer)
 		log.Println("Removed unreachable", peer)
 	}
-	router.Ourself = NewLocalPeer(name, hostName, router)
+	router.Ourself = NewLocalPeer(name, nickName, router)
 	router.Macs = NewMacCache(macMaxAge, onMacExpiry)
 	router.Peers = NewPeers(router.Ourself.Peer, onPeerGC)
 	router.Peers.FetchWithDefault(router.Ourself.Peer)
@@ -94,7 +94,7 @@ func (router *Router) UsingPassword() bool {
 
 func (router *Router) Status() string {
 	var buf bytes.Buffer
-	buf.WriteString(fmt.Sprintln("Our name is", router.Ourself.Name, "(" + router.Ourself.HostName + ")"))
+	buf.WriteString(fmt.Sprintln("Our name is", router.Ourself.Name, "(" + router.Ourself.NickName + ")"))
 	buf.WriteString(fmt.Sprintln("Sniffing traffic on", router.Iface))
 	buf.WriteString(fmt.Sprintf("MACs:\n%s", router.Macs))
 	buf.WriteString(fmt.Sprintf("Peers:\n%s", router.Peers))
diff --git a/weave b/weave
index 9d10399d..95365628 100755
--- a/weave
+++ b/weave
@@ -6,7 +6,7 @@ SCRIPT_VERSION="(unreleased version)"
 usage() {
     echo "Usage:"
     echo "weave setup"
-    echo "weave launch     [-password <password>] <peer> ..."
+    echo "weave launch     [-password <password>] [-nickname <nickname>] <peer> ..."
     echo "weave launch-dns <cidr>"
     echo "weave connect    <peer>"
     echo "weave run        [--with-dns] <cidr> <docker run args> ..."
@@ -475,19 +475,31 @@ case "$COMMAND" in
             echo "WARNING: $1 parameter ignored; 'weave launch' no longer takes a CIDR as the first parameter" >&2
             shift 1
         fi
-        if [ "$1" = "-password" ] ; then
-            [ $# -gt 1 ] || usage
-            WEAVE_PASSWORD="$2"
-            export WEAVE_PASSWORD
-            shift 2
-        fi
-        HOSTNAME=$(hostname)
+        NICKNAME=$(hostname)
+        while true; do
+            case "$1" in
+                -password)
+                    [ $# -gt 1 ] || usage
+                    WEAVE_PASSWORD="$2"
+                    export WEAVE_PASSWORD
+                    shift 2
+                    ;;
+                -nickname)
+                    [ $# -gt 1 ] || usage
+                    NICKNAME="$2"
+                    shift 2
+                    ;;
+                *)
+                    break
+                    ;;
+            esac
+        done
         # Set WEAVE_DOCKER_ARGS in the environment in order to supply
         # additional parameters, such as resource limits, to docker
         # when launching the weave container.
         CONTAINER=$(docker run --privileged -d --name=$CONTAINER_NAME \
             -p $PORT:$PORT/tcp -p $PORT:$PORT/udp -e WEAVE_PASSWORD \
-            $WEAVE_DOCKER_ARGS $IMAGE -name $MACADDR -iface $CONTAINER_IFNAME -hostname $HOSTNAME "$@")
+            $WEAVE_DOCKER_ARGS $IMAGE -name $MACADDR -iface $CONTAINER_IFNAME -nickname "$NICKNAME" "$@")
         with_container_netns $CONTAINER launch >/dev/null
         echo $CONTAINER
         ;;
diff --git a/weaver/main.go b/weaver/main.go
index 0e2cc8b3..f950dd23 100644
--- a/weaver/main.go
+++ b/weaver/main.go
@@ -37,7 +37,7 @@ func main() {
 		justVersion bool
 		ifaceName   string
 		routerName  string
-		hostName    string
+		nickName    string
 		password    string
 		wait        int
 		debug       bool
@@ -50,7 +50,7 @@ func main() {
 	flag.BoolVar(&justVersion, "version", false, "print version and exit")
 	flag.StringVar(&ifaceName, "iface", "", "name of interface to read from")
 	flag.StringVar(&routerName, "name", "", "name of router (defaults to MAC)")
-	flag.StringVar(&hostName, "hostname", "", "name of host (defaults to kernel hostname)")
+	flag.StringVar(&nickName, "nickname", "", "nickname of host (defaults to container hostname)")
 	flag.StringVar(&password, "password", "", "network password")
 	flag.IntVar(&wait, "wait", 0, "number of seconds to wait for interface to be created and come up (defaults to 0, i.e. don't wait)")
 	flag.BoolVar(&debug, "debug", false, "enable debug logging")
@@ -89,16 +89,12 @@ func main() {
 		routerName = iface.HardwareAddr.String()
 	}
 
-	if hostName == "" {
-		osHostName, err := os.Hostname()
+	if nickName == "" {
+		osHostname, err := os.Hostname()
 		if err != nil {
 			log.Fatal(err)
 		}
-		if osHostName == "" {
-			hostName = "<unknown>"
-		} else {
-			hostName = osHostName
-		}
+    	nickName = osHostname
 	}
 
 	ourName, err := weave.PeerNameFromUserInput(routerName)
@@ -135,8 +131,8 @@ func main() {
 		defer profile.Start(&p).Stop()
 	}
 
-	router := weave.NewRouter(iface, ourName, hostName, []byte(password), connLimit, bufSz*1024*1024, logFrame)
-	log.Println("Our name is", router.Ourself.Name, "(" + hostName + ")")
+	router := weave.NewRouter(iface, ourName, nickName, []byte(password), connLimit, bufSz*1024*1024, logFrame)
+	log.Println("Our name is", router.Ourself.Name, "(" + router.Ourself.NickName + ")")
 	router.Start()
 	for _, peer := range peers {
 		if addr, err := net.ResolveTCPAddr("tcp4", weave.NormalisePeerAddr(peer)); err == nil {