diff --git a/src/applications/auth/controller/PhabricatorAuthRegisterController.php b/src/applications/auth/controller/PhabricatorAuthRegisterController.php
index 6f75a51555..563f256cc5 100644
--- a/src/applications/auth/controller/PhabricatorAuthRegisterController.php
+++ b/src/applications/auth/controller/PhabricatorAuthRegisterController.php
@@ -1,581 +1,583 @@
 <?php
 
 final class PhabricatorAuthRegisterController
   extends PhabricatorAuthController {
 
   private $accountKey;
 
   public function shouldRequireLogin() {
     return false;
   }
 
   public function willProcessRequest(array $data) {
     $this->accountKey = idx($data, 'akey');
   }
 
   public function processRequest() {
     $request = $this->getRequest();
 
     if ($request->getUser()->isLoggedIn()) {
       return $this->renderError(pht('You are already logged in.'));
     }
 
     $is_setup = false;
     if (strlen($this->accountKey)) {
       $result = $this->loadAccountForRegistrationOrLinking($this->accountKey);
       list($account, $provider, $response) = $result;
       $is_default = false;
     } else if ($this->isFirstTimeSetup()) {
       list($account, $provider, $response) = $this->loadSetupAccount();
       $is_default = true;
       $is_setup = true;
     } else {
       list($account, $provider, $response) = $this->loadDefaultAccount();
       $is_default = true;
     }
 
     if ($response) {
       return $response;
     }
 
     if (!$provider->shouldAllowRegistration()) {
 
       // TODO: This is a routine error if you click "Login" on an external
       // auth source which doesn't allow registration. The error should be
       // more tailored.
 
       return $this->renderError(
         pht(
           'The account you are attempting to register with uses an '.
           'authentication provider ("%s") which does not allow registration. '.
           'An administrator may have recently disabled registration with this '.
           'provider.',
           $provider->getProviderName()));
     }
 
     $user = new PhabricatorUser();
 
     $default_username = $account->getUsername();
     $default_realname = $account->getRealName();
 
     $default_email = $account->getEmail();
     if (!PhabricatorUserEmail::isValidAddress($default_email)) {
       $default_email = null;
     }
 
     if ($default_email !== null) {
       // If the account source provided an email, but it's not allowed by
       // the configuration, roadblock the user. Previously, we let the user
       // pick a valid email address instead, but this does not align well with
       // user expectation and it's not clear the cases it enables are valuable.
       // See discussion in T3472.
       if (!PhabricatorUserEmail::isAllowedAddress($default_email)) {
         return $this->renderError(
           array(
             pht(
               'The account you are attempting to register with has an invalid '.
               'email address (%s). This Phabricator install only allows '.
               'registration with specific email addresses:',
               $default_email),
             phutil_tag('br'),
             phutil_tag('br'),
             PhabricatorUserEmail::describeAllowedAddresses(),
           ));
       }
 
       // If the account source provided an email, but another account already
       // has that email, just pretend we didn't get an email.
 
       // TODO: See T3340.
       // TODO: See T3472.
 
       if ($default_email !== null) {
         $same_email = id(new PhabricatorUserEmail())->loadOneWhere(
           'address = %s',
           $default_email);
         if ($same_email) {
           $default_email = null;
         }
       }
     }
 
     $profile = id(new PhabricatorRegistrationProfile())
       ->setDefaultUsername($default_username)
       ->setDefaultEmail($default_email)
       ->setDefaultRealName($default_realname)
       ->setCanEditUsername(true)
       ->setCanEditEmail(($default_email === null))
       ->setCanEditRealName(true)
       ->setShouldVerifyEmail(false);
 
     $event_type = PhabricatorEventType::TYPE_AUTH_WILLREGISTERUSER;
     $event_data = array(
       'account' => $account,
       'profile' => $profile,
     );
 
     $event = id(new PhabricatorEvent($event_type, $event_data))
       ->setUser($user);
     PhutilEventEngine::dispatchEvent($event);
 
     $default_username = $profile->getDefaultUsername();
     $default_email = $profile->getDefaultEmail();
     $default_realname = $profile->getDefaultRealName();
 
     $can_edit_username = $profile->getCanEditUsername();
     $can_edit_email = $profile->getCanEditEmail();
     $can_edit_realname = $profile->getCanEditRealName();
 
     $must_set_password = $provider->shouldRequireRegistrationPassword();
 
     $can_edit_anything = $profile->getCanEditAnything() || $must_set_password;
     $force_verify = $profile->getShouldVerifyEmail();
 
     // Automatically verify the administrator's email address during first-time
     // setup.
     if ($is_setup) {
       $force_verify = true;
     }
 
     $value_username = $default_username;
     $value_realname = $default_realname;
     $value_email = $default_email;
     $value_password = null;
 
     $errors = array();
 
+    $require_real_name = PhabricatorEnv::getEnvConfig('user.require-real-name');
+
     $e_username = strlen($value_username) ? null : true;
-    $e_realname = strlen($value_realname) ? null : true;
+    $e_realname = $require_real_name ? true : null;
     $e_email = strlen($value_email) ? null : true;
     $e_password = true;
     $e_captcha = true;
 
     $min_len = PhabricatorEnv::getEnvConfig('account.minimum-password-length');
     $min_len = (int)$min_len;
 
     if ($request->isFormPost() || !$can_edit_anything) {
       $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
 
       if ($must_set_password) {
         $e_captcha = pht('Again');
 
         $captcha_ok = AphrontFormRecaptchaControl::processCaptcha($request);
         if (!$captcha_ok) {
           $errors[] = pht("Captcha response is incorrect, try again.");
           $e_captcha = pht('Invalid');
         }
       }
 
       if ($can_edit_username) {
         $value_username = $request->getStr('username');
         if (!strlen($value_username)) {
           $e_username = pht('Required');
           $errors[] = pht('Username is required.');
         } else if (!PhabricatorUser::validateUsername($value_username)) {
           $e_username = pht('Invalid');
           $errors[] = PhabricatorUser::describeValidUsername();
         } else {
           $e_username = null;
         }
       }
 
       if ($must_set_password) {
         $value_password = $request->getStr('password');
         $value_confirm = $request->getStr('confirm');
         if (!strlen($value_password)) {
           $e_password = pht('Required');
           $errors[] = pht('You must choose a password.');
         } else if ($value_password !== $value_confirm) {
           $e_password = pht('No Match');
           $errors[] = pht('Password and confirmation must match.');
         } else if (strlen($value_password) < $min_len) {
           $e_password = pht('Too Short');
           $errors[] = pht(
             'Password is too short (must be at least %d characters long).',
             $min_len);
         } else if (
           PhabricatorCommonPasswords::isCommonPassword($value_password)) {
 
           $e_password = pht('Very Weak');
           $errors[] = pht(
             'Password is pathologically weak. This password is one of the '.
             'most common passwords in use, and is extremely easy for '.
             'attackers to guess. You must choose a stronger password.');
         } else {
           $e_password = null;
         }
       }
 
       if ($can_edit_email) {
         $value_email = $request->getStr('email');
         if (!strlen($value_email)) {
           $e_email = pht('Required');
           $errors[] = pht('Email is required.');
         } else if (!PhabricatorUserEmail::isValidAddress($value_email)) {
           $e_email = pht('Invalid');
           $errors[] = PhabricatorUserEmail::describeValidAddresses();
         } else if (!PhabricatorUserEmail::isAllowedAddress($value_email)) {
           $e_email = pht('Disallowed');
           $errors[] = PhabricatorUserEmail::describeAllowedAddresses();
         } else {
           $e_email = null;
         }
       }
 
       if ($can_edit_realname) {
         $value_realname = $request->getStr('realName');
-        if (!strlen($value_realname)) {
+        if (!strlen($value_realname) && $require_real_name) {
           $e_realname = pht('Required');
           $errors[] = pht('Real name is required.');
         } else {
           $e_realname = null;
         }
       }
 
       if (!$errors) {
         $image = $this->loadProfilePicture($account);
         if ($image) {
           $user->setProfileImagePHID($image->getPHID());
         }
 
         try {
           if ($force_verify) {
             $verify_email = true;
           } else {
             $verify_email =
               ($account->getEmailVerified()) &&
               ($value_email === $default_email);
           }
 
           $email_obj = id(new PhabricatorUserEmail())
             ->setAddress($value_email)
             ->setIsVerified((int)$verify_email);
 
           $user->setUsername($value_username);
           $user->setRealname($value_realname);
 
           if ($is_setup) {
             $must_approve = false;
           } else {
             $must_approve = PhabricatorEnv::getEnvConfig(
               'auth.require-approval');
           }
 
           if ($must_approve) {
             $user->setIsApproved(0);
           } else {
             $user->setIsApproved(1);
           }
 
           $user->openTransaction();
 
             $editor = id(new PhabricatorUserEditor())
               ->setActor($user);
 
             $editor->createNewUser($user, $email_obj);
             if ($must_set_password) {
               $envelope = new PhutilOpaqueEnvelope($value_password);
               $editor->changePassword($user, $envelope);
             }
 
             if ($is_setup) {
               $editor->makeAdminUser($user, true);
             }
 
             $account->setUserPHID($user->getPHID());
             $provider->willRegisterAccount($account);
             $account->save();
 
           $user->saveTransaction();
 
           if (!$email_obj->getIsVerified()) {
             $email_obj->sendVerificationEmail($user);
           }
 
           if ($must_approve) {
             $this->sendWaitingForApprovalEmail($user);
           }
 
           return $this->loginUser($user);
         } catch (AphrontQueryDuplicateKeyException $exception) {
           $same_username = id(new PhabricatorUser())->loadOneWhere(
             'userName = %s',
             $user->getUserName());
 
           $same_email = id(new PhabricatorUserEmail())->loadOneWhere(
             'address = %s',
             $value_email);
 
           if ($same_username) {
             $e_username = pht('Duplicate');
             $errors[] = pht('Another user already has that username.');
           }
 
           if ($same_email) {
             // TODO: See T3340.
             $e_email = pht('Duplicate');
             $errors[] = pht('Another user already has that email.');
           }
 
           if (!$same_username && !$same_email) {
             throw $exception;
           }
         }
       }
 
       unset($unguarded);
     }
 
     $form = id(new AphrontFormView())
       ->setUser($request->getUser());
 
     if (!$is_default) {
       $form->appendChild(
         id(new AphrontFormMarkupControl())
           ->setLabel(pht('External Account'))
           ->setValue(
             id(new PhabricatorAuthAccountView())
               ->setUser($request->getUser())
               ->setExternalAccount($account)
               ->setAuthProvider($provider)));
     }
 
 
     if ($can_edit_username) {
       $form->appendChild(
         id(new AphrontFormTextControl())
           ->setLabel(pht('Phabricator Username'))
           ->setName('username')
           ->setValue($value_username)
           ->setError($e_username));
     } else {
       $form->appendChild(
         id(new AphrontFormMarkupControl())
           ->setLabel(pht('Phabricator Username'))
           ->setValue($value_username)
           ->setError($e_username));
     }
 
     if ($must_set_password) {
       $form->appendChild(
         id(new AphrontFormPasswordControl())
           ->setLabel(pht('Password'))
           ->setName('password')
           ->setError($e_password)
           ->setCaption(
             $min_len
               ? pht('Minimum length of %d characters.', $min_len)
               : null));
       $form->appendChild(
         id(new AphrontFormPasswordControl())
           ->setLabel(pht('Confirm Password'))
           ->setName('confirm')
           ->setError($e_password));
     }
 
     if ($can_edit_email) {
       $form->appendChild(
         id(new AphrontFormTextControl())
           ->setLabel(pht('Email'))
           ->setName('email')
           ->setValue($value_email)
           ->setCaption(PhabricatorUserEmail::describeAllowedAddresses())
           ->setError($e_email));
     }
 
     if ($can_edit_realname) {
       $form->appendChild(
         id(new AphrontFormTextControl())
           ->setLabel(pht('Real Name'))
           ->setName('realName')
           ->setValue($value_realname)
           ->setError($e_realname));
     }
 
     if ($must_set_password) {
       $form->appendChild(
         id(new AphrontFormRecaptchaControl())
           ->setLabel(pht('Captcha'))
           ->setError($e_captcha));
     }
 
     $submit = id(new AphrontFormSubmitControl());
 
     if ($is_setup) {
       $submit
         ->setValue(pht('Create Admin Account'));
     } else {
       $submit
         ->addCancelButton($this->getApplicationURI('start/'))
         ->setValue(pht('Register Phabricator Account'));
     }
 
 
     $form->appendChild($submit);
 
     $crumbs = $this->buildApplicationCrumbs();
 
     if ($is_setup) {
       $crumbs->addTextCrumb(pht('Setup Admin Account'));
         $title = pht('Welcome to Phabricator');
     } else {
       $crumbs->addTextCrumb(pht('Register'));
       $crumbs->addTextCrumb($provider->getProviderName());
         $title = pht('Phabricator Registration');
     }
 
     $welcome_view = null;
     if ($is_setup) {
       $welcome_view = id(new AphrontErrorView())
         ->setSeverity(AphrontErrorView::SEVERITY_NOTICE)
         ->setTitle(pht('Welcome to Phabricator'))
         ->appendChild(
           pht(
             'Installation is complete. Register your administrator account '.
             'below to log in. You will be able to configure options and add '.
             'other authentication mechanisms (like LDAP or OAuth) later on.'));
     }
 
     $object_box = id(new PHUIObjectBoxView())
       ->setHeaderText($title)
       ->setForm($form)
       ->setFormErrors($errors);
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $welcome_view,
         $object_box,
       ),
       array(
         'title' => $title,
         'device' => true,
       ));
   }
 
   private function loadDefaultAccount() {
     $providers = PhabricatorAuthProvider::getAllEnabledProviders();
     $account = null;
     $provider = null;
     $response = null;
 
     foreach ($providers as $key => $candidate_provider) {
       if (!$candidate_provider->shouldAllowRegistration()) {
         unset($providers[$key]);
         continue;
       }
       if (!$candidate_provider->isDefaultRegistrationProvider()) {
         unset($providers[$key]);
       }
     }
 
     if (!$providers) {
       $response = $this->renderError(
         pht(
           "There are no configured default registration providers."));
       return array($account, $provider, $response);
     } else if (count($providers) > 1) {
       $response = $this->renderError(
         pht(
           "There are too many configured default registration providers."));
       return array($account, $provider, $response);
     }
 
     $provider = head($providers);
     $account = $provider->getDefaultExternalAccount();
 
     return array($account, $provider, $response);
   }
 
   private function loadSetupAccount() {
     $provider = new PhabricatorAuthProviderPassword();
     $provider->attachProviderConfig(
       id(new PhabricatorAuthProviderConfig())
         ->setShouldAllowRegistration(1)
         ->setShouldAllowLogin(1)
         ->setIsEnabled(true));
 
     $account = $provider->getDefaultExternalAccount();
     $response = null;
     return array($account, $provider, $response);
   }
 
   private function loadProfilePicture(PhabricatorExternalAccount $account) {
     $phid = $account->getProfileImagePHID();
     if (!$phid) {
       return null;
     }
 
     // NOTE: Use of omnipotent user is okay here because the registering user
     // can not control the field value, and we can't use their user object to
     // do meaningful policy checks anyway since they have not registered yet.
     // Reaching this means the user holds the account secret key and the
     // registration secret key, and thus has permission to view the image.
 
     $file = id(new PhabricatorFileQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withPHIDs(array($phid))
       ->executeOne();
     if (!$file) {
       return null;
     }
 
     try {
       $xformer = new PhabricatorImageTransformer();
       return $xformer->executeProfileTransform(
         $file,
         $width = 50,
         $min_height = 50,
         $max_height = 50);
     } catch (Exception $ex) {
       phlog($ex);
       return null;
     }
   }
 
   protected function renderError($message) {
     return $this->renderErrorPage(
       pht('Registration Failed'),
       array($message));
   }
 
   private function sendWaitingForApprovalEmail(PhabricatorUser $user) {
     $title = '[Phabricator] '.pht(
       'New User "%s" Awaiting Approval',
       $user->getUsername());
 
     $body = new PhabricatorMetaMTAMailBody();
 
     $body->addRawSection(
       pht(
         'Newly registered user "%s" is awaiting account approval by an '.
         'administrator.',
         $user->getUsername()));
 
     $body->addTextSection(
       pht('APPROVAL QUEUE'),
       PhabricatorEnv::getProductionURI(
         '/people/query/approval/'));
 
     $body->addTextSection(
       pht('DISABLE APPROVAL QUEUE'),
       PhabricatorEnv::getProductionURI(
         '/config/edit/auth.require-approval/'));
 
     $admins = id(new PhabricatorPeopleQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withIsAdmin(true)
       ->execute();
 
     if (!$admins) {
       return;
     }
 
     $mail = id(new PhabricatorMetaMTAMail())
       ->addTos(mpull($admins, 'getPHID'))
       ->setSubject($title)
       ->setBody($body->render())
       ->saveAndSend();
   }
 
 }
diff --git a/src/applications/metamta/query/PhabricatorMetaMTAActorQuery.php b/src/applications/metamta/query/PhabricatorMetaMTAActorQuery.php
index ad94b9ff31..ff5689d44e 100644
--- a/src/applications/metamta/query/PhabricatorMetaMTAActorQuery.php
+++ b/src/applications/metamta/query/PhabricatorMetaMTAActorQuery.php
@@ -1,191 +1,192 @@
 <?php
 
 final class PhabricatorMetaMTAActorQuery extends PhabricatorQuery {
 
   private $phids = array();
   private $viewer;
 
   public function setViewer(PhabricatorUser $viewer) {
     $this->viewer = $viewer;
     return $this;
   }
 
   public function getViewer() {
     return $this->viewer;
   }
 
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
   public function execute() {
     $phids = array_fuse($this->phids);
     $actors = array();
     $type_map = array();
     foreach ($phids as $phid) {
       $type_map[phid_get_type($phid)][] = $phid;
       $actors[$phid] = id(new PhabricatorMetaMTAActor())->setPHID($phid);
     }
 
     // TODO: Move this to PhabricatorPHIDType, or the objects, or some
     // interface.
 
     foreach ($type_map as $type => $phids) {
       switch ($type) {
         case PhabricatorPeoplePHIDTypeUser::TYPECONST:
           $this->loadUserActors($actors, $phids);
           break;
         case PhabricatorPeoplePHIDTypeExternal::TYPECONST:
           $this->loadExternalUserActors($actors, $phids);
           break;
         case PhabricatorMailingListPHIDTypeList::TYPECONST:
           $this->loadMailingListActors($actors, $phids);
           break;
         default:
           $this->loadUnknownActors($actors, $phids);
           break;
       }
     }
 
     return $actors;
   }
 
   private function loadUserActors(array $actors, array $phids) {
     assert_instances_of($actors, 'PhabricatorMetaMTAActor');
 
     $emails = id(new PhabricatorUserEmail())->loadAllWhere(
       'userPHID IN (%Ls) AND isPrimary = 1',
       $phids);
     $emails = mpull($emails, null, 'getUserPHID');
 
     $users = id(new PhabricatorPeopleQuery())
       ->setViewer($this->getViewer())
       ->withPHIDs($phids)
       ->execute();
     $users = mpull($users, null, 'getPHID');
 
     foreach ($phids as $phid) {
       $actor = $actors[$phid];
 
       $user = idx($users, $phid);
       if (!$user) {
         $actor->setUndeliverable(
           pht('Unable to load user record for this PHID.'));
       } else {
         $actor->setName($this->getUserName($user));
         if ($user->getIsDisabled()) {
           $actor->setUndeliverable(
             pht('This user is disabled; disabled users do not receive mail.'));
         }
         if ($user->getIsSystemAgent()) {
           $actor->setUndeliverable(
             pht('This user is a bot; bot accounts do not receive mail.'));
         }
 
         // NOTE: We do send email to unapproved users, and to unverified users,
         // because it would otherwise be impossible to get them to verify their
         // email addresses. Possibly we should white-list this kind of mail and
         // deny all other types of mail.
       }
 
       $email = idx($emails, $phid);
       if (!$email) {
         $actor->setUndeliverable(
           pht('Unable to load email record for this PHID.'));
       } else {
         $actor->setEmailAddress($email->getAddress());
       }
     }
   }
 
   private function loadExternalUserActors(array $actors, array $phids) {
     assert_instances_of($actors, 'PhabricatorMetaMTAActor');
 
     $xusers = id(new PhabricatorExternalAccountQuery())
       ->setViewer($this->getViewer())
       ->withPHIDs($phids)
       ->execute();
     $xusers = mpull($xusers, null, 'getPHID');
 
     foreach ($phids as $phid) {
       $actor = $actors[$phid];
 
       $xuser = idx($xusers, $phid);
       if (!$xuser) {
         $actor->setUndeliverable(
           pht('Unable to load external user record for this PHID.'));
         continue;
       }
 
       $actor->setName($xuser->getDisplayName());
 
       if ($xuser->getAccountType() != 'email') {
         $actor->setUndeliverable(
           pht(
             'Only external accounts of type "email" are deliverable; this '.
             'account has a different type.'));
         continue;
       }
 
       $actor->setEmailAddress($xuser->getAccountID());
     }
   }
 
   private function loadMailingListActors(array $actors, array $phids) {
     assert_instances_of($actors, 'PhabricatorMetaMTAActor');
 
     $lists = id(new PhabricatorMailingListQuery())
       ->setViewer($this->getViewer())
       ->withPHIDs($phids)
       ->execute();
     $lists = mpull($lists, null, 'getPHID');
 
     foreach ($phids as $phid) {
       $actor = $actors[$phid];
 
       $list = idx($lists, $phid);
       if (!$list) {
         $actor->setUndeliverable(
           pht(
             'Unable to load mailing list record for this PHID.'));
         continue;
       }
 
       $actor->setName($list->getName());
       $actor->setEmailAddress($list->getEmail());
     }
   }
 
   private function loadUnknownActors(array $actors, array $phids) {
     foreach ($phids as $phid) {
       $actor = $actors[$phid];
       $actor->setUndeliverable(pht('This PHID type is not mailable.'));
     }
   }
 
 
   /**
    * Small helper function to make sure we format the username properly as
    * specified by the `metamta.user-address-format` configuration value.
    */
   private function getUserName(PhabricatorUser $user) {
     $format = PhabricatorEnv::getEnvConfig('metamta.user-address-format');
 
     switch ($format) {
       case 'short':
         $name = $user->getUserName();
         break;
       case 'real':
-        $name = $user->getRealName();
+        $name = strlen($user->getRealName()) ?
+          $user->getRealName() : $user->getUserName();
         break;
       case 'full':
       default:
         $name = $user->getFullName();
         break;
     }
 
     return $name;
   }
 
 }
diff --git a/src/applications/people/config/PhabricatorUserConfigOptions.php b/src/applications/people/config/PhabricatorUserConfigOptions.php
index 0795ba67e5..5c83312fcc 100644
--- a/src/applications/people/config/PhabricatorUserConfigOptions.php
+++ b/src/applications/people/config/PhabricatorUserConfigOptions.php
@@ -1,42 +1,49 @@
 <?php
 
 final class PhabricatorUserConfigOptions
   extends PhabricatorApplicationConfigOptions {
 
   public function getName() {
     return pht("User Profiles");
   }
 
   public function getDescription() {
     return pht("User profiles configuration.");
   }
 
   public function getOptions() {
 
     $default = array(
       id(new PhabricatorUserRealNameField())->getFieldKey() => true,
       id(new PhabricatorUserTitleField())->getFieldKey() => true,
       id(new PhabricatorUserSinceField())->getFieldKey() => true,
       id(new PhabricatorUserRolesField())->getFieldKey() => true,
       id(new PhabricatorUserStatusField())->getFieldKey() => true,
       id(new PhabricatorUserBlurbField())->getFieldKey() => true,
     );
 
     foreach ($default as $key => $enabled) {
       $default[$key] = array(
         'disabled' => !$enabled,
       );
     }
 
     $custom_field_type = 'custom:PhabricatorCustomFieldConfigOptionType';
 
     return array(
       $this->newOption('user.fields', $custom_field_type, $default)
         ->setCustomData(id(new PhabricatorUser())->getCustomFieldBaseClass())
         ->setDescription(pht("Select and reorder user profile fields.")),
       $this->newOption('user.custom-field-definitions', 'map', array())
         ->setDescription(pht("Add new simple fields to user profiles.")),
+      $this->newOption('user.require-real-name', 'bool', true)
+        ->setDescription(pht("Always require real name for user profiles."))
+        ->setBoolOptions(
+          array(
+            pht('Make real names required'),
+            pht('Make real names optional'),
+          )),
     );
   }
 
 }
diff --git a/src/applications/people/controller/PhabricatorPeopleNewController.php b/src/applications/people/controller/PhabricatorPeopleNewController.php
index c789747fff..5769c3aca7 100644
--- a/src/applications/people/controller/PhabricatorPeopleNewController.php
+++ b/src/applications/people/controller/PhabricatorPeopleNewController.php
@@ -1,223 +1,224 @@
 <?php
 
 final class PhabricatorPeopleNewController
   extends PhabricatorPeopleController {
 
   private $type;
 
   public function willProcessRequest(array $data) {
     $this->type = $data['type'];
   }
 
   public function processRequest() {
     $request = $this->getRequest();
     $admin = $request->getUser();
 
     switch ($this->type) {
       case 'standard':
         $is_bot = false;
         break;
       case 'bot':
         $is_bot = true;
         break;
       default:
         return new Aphront404Response();
     }
 
     $user = new PhabricatorUser();
+    $require_real_name = PhabricatorEnv::getEnvConfig('user.require-real-name');
 
     $e_username = true;
-    $e_realname = true;
+    $e_realname = $require_real_name ? true : null;
     $e_email    = true;
     $errors = array();
 
     $welcome_checked = true;
 
     $new_email = null;
 
     $request = $this->getRequest();
     if ($request->isFormPost()) {
       $welcome_checked = $request->getInt('welcome');
 
       $user->setUsername($request->getStr('username'));
 
       $new_email = $request->getStr('email');
       if (!strlen($new_email)) {
         $errors[] = pht('Email is required.');
         $e_email = pht('Required');
       } else if (!PhabricatorUserEmail::isAllowedAddress($new_email)) {
         $e_email = pht('Invalid');
         $errors[] = PhabricatorUserEmail::describeAllowedAddresses();
       } else {
         $e_email = null;
       }
 
       $user->setRealName($request->getStr('realname'));
 
       if (!strlen($user->getUsername())) {
         $errors[] = pht("Username is required.");
         $e_username = pht('Required');
       } else if (!PhabricatorUser::validateUsername($user->getUsername())) {
         $errors[] = PhabricatorUser::describeValidUsername();
         $e_username = pht('Invalid');
       } else {
         $e_username = null;
       }
 
-      if (!strlen($user->getRealName())) {
+      if (!strlen($user->getRealName()) && $require_real_name) {
         $errors[] = pht('Real name is required.');
         $e_realname = pht('Required');
       } else {
         $e_realname = null;
       }
 
       if (!$errors) {
         try {
 
           $email = id(new PhabricatorUserEmail())
             ->setAddress($new_email)
             ->setIsVerified(0);
 
           // Automatically approve the user, since an admin is creating them.
           $user->setIsApproved(1);
 
           // If the user is a bot, approve their email too.
           if ($is_bot) {
             $email->setIsVerified(1);
           }
 
           id(new PhabricatorUserEditor())
             ->setActor($admin)
             ->createNewUser($user, $email);
 
           if ($is_bot) {
             id(new PhabricatorUserEditor())
               ->setActor($admin)
               ->makeSystemAgentUser($user, true);
           }
 
           if ($welcome_checked && !$is_bot) {
             $user->sendWelcomeEmail($admin);
           }
 
           $response = id(new AphrontRedirectResponse())
             ->setURI('/p/'.$user->getUsername().'/');
           return $response;
         } catch (AphrontQueryDuplicateKeyException $ex) {
           $errors[] = pht('Username and email must be unique.');
 
           $same_username = id(new PhabricatorUser())
             ->loadOneWhere('username = %s', $user->getUsername());
           $same_email = id(new PhabricatorUserEmail())
             ->loadOneWhere('address = %s', $new_email);
 
           if ($same_username) {
             $e_username = pht('Duplicate');
           }
 
           if ($same_email) {
             $e_email = pht('Duplicate');
           }
         }
       }
     }
 
     $form = id(new AphrontFormView())
       ->setUser($admin);
 
     if ($is_bot) {
       $form->appendRemarkupInstructions(
         pht(
           'You are creating a new **bot/script** user account.'));
     } else {
       $form->appendRemarkupInstructions(
         pht(
           'You are creating a new **standard** user account.'));
     }
 
     $form
       ->appendChild(
         id(new AphrontFormTextControl())
           ->setLabel(pht('Username'))
           ->setName('username')
           ->setValue($user->getUsername())
           ->setError($e_username))
       ->appendChild(
         id(new AphrontFormTextControl())
           ->setLabel(pht('Real Name'))
           ->setName('realname')
           ->setValue($user->getRealName())
           ->setError($e_realname))
       ->appendChild(
         id(new AphrontFormTextControl())
           ->setLabel(pht('Email'))
           ->setName('email')
           ->setValue($new_email)
           ->setCaption(PhabricatorUserEmail::describeAllowedAddresses())
           ->setError($e_email));
 
     if (!$is_bot) {
       $form->appendChild(
         id(new AphrontFormCheckboxControl())
           ->addCheckbox(
             'welcome',
             1,
             pht('Send "Welcome to Phabricator" email with login instructions.'),
             $welcome_checked));
     }
 
     $form
       ->appendChild(
         id(new AphrontFormSubmitControl())
           ->addCancelButton($this->getApplicationURI())
           ->setValue(pht('Create User')));
 
     if ($is_bot) {
       $form
         ->appendChild(id(new AphrontFormDividerControl()))
         ->appendRemarkupInstructions(
           pht(
             '**Why do bot/script accounts need an email address?**'.
             "\n\n".
             'Although bots do not normally receive email from Phabricator, '.
             'they can interact with other systems which require an email '.
             'address. Examples include:'.
             "\n\n".
             "  - If the account takes actions which //send// email, we need ".
             "    an address to use in the //From// header.\n".
             "  - If the account creates commits, Git and Mercurial require ".
             "    an email address for authorship.\n".
             "  - If you send email //to// Phabricator on behalf of the ".
             "    account, the address can identify the sender.\n".
             "  - Some internal authentication functions depend on accounts ".
             "    having an email address.\n".
             "\n\n".
             "The address will automatically be verified, so you do not need ".
             "to be able to receive mail at this address, and can enter some ".
             "invalid or nonexistent (but correctly formatted) address like ".
             "`bot@yourcompany.com` if you prefer."));
     }
 
 
     $title = pht('Create New User');
 
     $form_box = id(new PHUIObjectBoxView())
       ->setHeaderText($title)
       ->setFormErrors($errors)
       ->setForm($form);
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addTextCrumb($title);
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $form_box,
       ),
       array(
         'title' => $title,
         'device' => true,
       ));
   }
 
 }
diff --git a/src/applications/people/controller/PhabricatorPeopleProfileController.php b/src/applications/people/controller/PhabricatorPeopleProfileController.php
index 0413127dce..c75ae8088e 100644
--- a/src/applications/people/controller/PhabricatorPeopleProfileController.php
+++ b/src/applications/people/controller/PhabricatorPeopleProfileController.php
@@ -1,279 +1,279 @@
 <?php
 
 final class PhabricatorPeopleProfileController
   extends PhabricatorPeopleController {
 
   private $username;
 
   public function shouldRequireAdmin() {
     return false;
   }
 
   public function willProcessRequest(array $data) {
     $this->username = idx($data, 'username');
   }
 
   public function processRequest() {
     $viewer = $this->getRequest()->getUser();
 
     $user = id(new PhabricatorPeopleQuery())
       ->setViewer($viewer)
       ->withUsernames(array($this->username))
       ->needProfileImage(true)
       ->executeOne();
     if (!$user) {
       return new Aphront404Response();
     }
 
     require_celerity_resource('phabricator-profile-css');
 
     $profile = $user->loadUserProfile();
     $username = phutil_escape_uri($user->getUserName());
 
     $picture = $user->loadProfileImageURI();
 
     $header = id(new PHUIHeaderView())
-      ->setHeader($user->getUserName().' ('.$user->getRealName().')')
+      ->setHeader($user->getFullName())
       ->setSubheader($profile->getTitle())
       ->setImage($picture);
 
     $actions = id(new PhabricatorActionListView())
       ->setObject($user)
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $user,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $actions->addAction(
       id(new PhabricatorActionView())
         ->setIcon('edit')
         ->setName(pht('Edit Profile'))
         ->setHref($this->getApplicationURI('editprofile/'.$user->getID().'/'))
         ->setDisabled(!$can_edit)
         ->setWorkflow(!$can_edit));
 
     $actions->addAction(
       id(new PhabricatorActionView())
         ->setIcon('image')
         ->setName(pht('Edit Profile Picture'))
         ->setHref($this->getApplicationURI('picture/'.$user->getID().'/'))
         ->setDisabled(!$can_edit)
         ->setWorkflow(!$can_edit));
 
     if ($viewer->getIsAdmin()) {
       $actions->addAction(
         id(new PhabricatorActionView())
           ->setIcon('wrench')
           ->setName(pht('Edit Settings'))
           ->setDisabled(!$can_edit)
           ->setWorkflow(!$can_edit)
           ->setHref('/settings/'.$user->getID().'/'));
 
       if ($user->getIsAdmin()) {
         $empower_icon = 'lower-priority';
         $empower_name = pht('Remove Administrator');
       } else {
         $empower_icon = 'raise-priority';
         $empower_name = pht('Make Administrator');
       }
 
       $actions->addAction(
         id(new PhabricatorActionView())
           ->setIcon($empower_icon)
           ->setName($empower_name)
           ->setDisabled(($user->getPHID() == $viewer->getPHID()))
           ->setWorkflow(true)
           ->setHref($this->getApplicationURI('empower/'.$user->getID().'/')));
 
       $actions->addAction(
         id(new PhabricatorActionView())
           ->setIcon('tag')
           ->setName(pht('Change Username'))
           ->setWorkflow(true)
           ->setHref($this->getApplicationURI('rename/'.$user->getID().'/')));
 
       if ($user->getIsDisabled()) {
         $disable_icon = 'enable';
         $disable_name = pht('Enable User');
       } else {
         $disable_icon = 'disable';
         $disable_name = pht('Disable User');
       }
 
       $actions->addAction(
         id(new PhabricatorActionView())
           ->setIcon($disable_icon)
           ->setName($disable_name)
           ->setDisabled(($user->getPHID() == $viewer->getPHID()))
           ->setWorkflow(true)
           ->setHref($this->getApplicationURI('disable/'.$user->getID().'/')));
 
       $actions->addAction(
         id(new PhabricatorActionView())
           ->setIcon('delete')
           ->setName(pht('Delete User'))
           ->setDisabled(($user->getPHID() == $viewer->getPHID()))
           ->setWorkflow(true)
           ->setHref($this->getApplicationURI('delete/'.$user->getID().'/')));
 
       $actions->addAction(
         id(new PhabricatorActionView())
           ->setIcon('message')
           ->setName(pht('Send Welcome Email'))
           ->setWorkflow(true)
           ->setHref($this->getApplicationURI('welcome/'.$user->getID().'/')));
     }
 
     $properties = $this->buildPropertyView($user, $actions);
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addTextCrumb($user->getUsername());
     $feed = $this->renderUserFeed($user);
     $calendar = $this->renderUserCalendar($user);
     $activity = phutil_tag(
       'div',
       array(
         'class' => 'profile-activity-view grouped'
       ),
       array(
         $calendar,
         $feed
       ));
 
     $object_box = id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->addPropertyList($properties);
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $object_box,
         $activity,
       ),
       array(
         'title' => $user->getUsername(),
         'device' => true,
       ));
   }
 
   private function buildPropertyView(
     PhabricatorUser $user,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setObject($user)
       ->setActionList($actions);
 
     $field_list = PhabricatorCustomField::getObjectFields(
       $user,
       PhabricatorCustomField::ROLE_VIEW);
     $field_list->appendFieldsToPropertyList($user, $viewer, $view);
 
     return $view;
   }
 
   private function renderUserFeed(PhabricatorUser $user) {
     $viewer = $this->getRequest()->getUser();
 
     $query = new PhabricatorFeedQuery();
     $query->setFilterPHIDs(
       array(
         $user->getPHID(),
       ));
     $query->setLimit(100);
     $query->setViewer($viewer);
     $stories = $query->execute();
 
     $builder = new PhabricatorFeedBuilder($stories);
     $builder->setUser($viewer);
     $builder->setShowHovercards(true);
     $view = $builder->buildView();
 
     return phutil_tag_div(
       'profile-feed',
       $view->render());
   }
 
   private function renderUserCalendar(PhabricatorUser $user) {
     $viewer = $this->getRequest()->getUser();
     $epochs = CalendarTimeUtil::getCalendarEventEpochs(
       $viewer,
       'today',
        7);
     $start_epoch = $epochs['start_epoch'];
     $end_epoch = $epochs['end_epoch'];
     $statuses = id(new PhabricatorCalendarEventQuery())
       ->setViewer($viewer)
       ->withInvitedPHIDs(array($user->getPHID()))
       ->withDateRange($start_epoch, $end_epoch)
       ->execute();
 
     $timestamps = CalendarTimeUtil::getCalendarWeekTimestamps(
       $viewer);
     $today = $timestamps['today'];
     $epoch_stamps = $timestamps['epoch_stamps'];
     $events = array();
 
     foreach ($epoch_stamps as $day) {
       $epoch_start = $day->format('U');
       $next_day = clone $day;
       $next_day->modify('+1 day');
       $epoch_end = $next_day->format('U');
 
       foreach ($statuses as $status) {
         if ($status->getDateTo() < $epoch_start) {
           continue;
         }
         if ($status->getDateFrom() >= $epoch_end) {
           continue;
         }
 
         $event = new AphrontCalendarEventView();
         $event->setEpochRange($status->getDateFrom(), $status->getDateTo());
 
         $status_text = $status->getHumanStatus();
         $event->setUserPHID($status->getUserPHID());
         $event->setName($status_text);
         $event->setDescription($status->getDescription());
         $event->setEventID($status->getID());
         $events[$epoch_start][] = $event;
       }
     }
 
     $week = array();
     foreach ($epoch_stamps as $day) {
       $epoch = $day->format('U');
       $headertext = phabricator_format_local_time($epoch, $user, 'l, M d');
 
       $list = new PHUICalendarListView();
       $list->setUser($viewer);
       $list->showBlankState(true);
       if (isset($events[$epoch])) {
         foreach ($events[$epoch] as $event) {
           $list->addEvent($event);
         }
       }
 
       $header = phutil_tag(
         'a',
         array(
           'href' => $this->getRequest()->getRequestURI().'calendar/'
         ),
         $headertext);
 
       $calendar = new PHUICalendarWidgetView();
       $calendar->setHeader($header);
       $calendar->setCalendarList($list);
       $week[] = $calendar;
     }
 
     return phutil_tag_div(
       'profile-calendar',
       $week);
   }
 }
diff --git a/src/applications/people/phid/PhabricatorPeoplePHIDTypeUser.php b/src/applications/people/phid/PhabricatorPeoplePHIDTypeUser.php
index 49ddf01ed4..db6295006f 100644
--- a/src/applications/people/phid/PhabricatorPeoplePHIDTypeUser.php
+++ b/src/applications/people/phid/PhabricatorPeoplePHIDTypeUser.php
@@ -1,89 +1,90 @@
 <?php
 
 final class PhabricatorPeoplePHIDTypeUser extends PhabricatorPHIDType {
 
   const TYPECONST = 'USER';
 
   public function getTypeConstant() {
     return self::TYPECONST;
   }
 
   public function getTypeName() {
     return pht('User');
   }
 
   public function getPHIDTypeApplicationClass() {
     return 'PhabricatorApplicationPeople';
   }
 
   public function getTypeIcon() {
     return 'policy-all';
   }
 
   public function newObject() {
     return new PhabricatorUser();
   }
 
   protected function buildQueryForObjects(
     PhabricatorObjectQuery $query,
     array $phids) {
 
     return id(new PhabricatorPeopleQuery())
       ->withPHIDs($phids)
       ->needProfileImage(true)
       ->needStatus(true);
   }
 
   public function loadHandles(
     PhabricatorHandleQuery $query,
     array $handles,
     array $objects) {
 
     foreach ($handles as $phid => $handle) {
       $user = $objects[$phid];
+      $realname = $user->getRealName();
+
       $handle->setName($user->getUsername());
       $handle->setURI('/p/'.$user->getUsername().'/');
-      $handle->setFullName(
-        $user->getUsername().' ('.$user->getRealName().')');
+      $handle->setFullName($user->getFullName());
       $handle->setImageURI($user->loadProfileImageURI());
       $handle->setDisabled(!$user->isUserActivated());
       if ($user->hasStatus()) {
         $status = $user->getStatus();
         $handle->setStatus($status->getTextStatus());
         $handle->setTitle($status->getTerseSummary($query->getViewer()));
       }
     }
 
   }
 
   public function canLoadNamedObject($name) {
     return preg_match('/^@.+/', $name);
   }
 
   public function loadNamedObjects(
     PhabricatorObjectQuery $query,
     array $names) {
 
     $id_map = array();
     foreach ($names as $name) {
       $id = substr($name, 1);
       $id_map[$id][] = $name;
     }
 
     $objects = id(new PhabricatorPeopleQuery())
       ->setViewer($query->getViewer())
       ->withUsernames(array_keys($id_map))
       ->execute();
 
     $results = array();
     foreach ($objects as $id => $object) {
       $username = $object->getUsername();
       foreach (idx($id_map, $username, array()) as $name) {
         $results[$name] = $object;
       }
     }
 
     return $results;
   }
 
 }
diff --git a/src/applications/people/search/PhabricatorUserSearchIndexer.php b/src/applications/people/search/PhabricatorUserSearchIndexer.php
index bb0a2a337c..da591d7f7d 100644
--- a/src/applications/people/search/PhabricatorUserSearchIndexer.php
+++ b/src/applications/people/search/PhabricatorUserSearchIndexer.php
@@ -1,30 +1,30 @@
 <?php
 
 final class PhabricatorUserSearchIndexer
   extends PhabricatorSearchDocumentIndexer {
 
   public function getIndexableObject() {
     return new PhabricatorUser();
   }
 
   protected function buildAbstractDocumentByPHID($phid) {
     $user = $this->loadDocumentByPHID($phid);
 
     $doc = new PhabricatorSearchAbstractDocument();
     $doc->setPHID($user->getPHID());
     $doc->setDocumentType(PhabricatorPeoplePHIDTypeUser::TYPECONST);
-    $doc->setDocumentTitle($user->getUserName().' ('.$user->getRealName().')');
+    $doc->setDocumentTitle($user->getFullName());
     $doc->setDocumentCreated($user->getDateCreated());
     $doc->setDocumentModified($user->getDateModified());
 
     $doc->addRelationship(
       $user->isUserActivated()
         ? PhabricatorSearchRelationship::RELATIONSHIP_OPEN
         : PhabricatorSearchRelationship::RELATIONSHIP_CLOSED,
       $user->getPHID(),
       PhabricatorPeoplePHIDTypeUser::TYPECONST,
       time());
 
     return $doc;
   }
 }
diff --git a/src/applications/people/storage/PhabricatorUser.php b/src/applications/people/storage/PhabricatorUser.php
index 051a77f2b8..f5da21efd4 100644
--- a/src/applications/people/storage/PhabricatorUser.php
+++ b/src/applications/people/storage/PhabricatorUser.php
@@ -1,885 +1,889 @@
 <?php
 
 final class PhabricatorUser
   extends PhabricatorUserDAO
   implements
     PhutilPerson,
     PhabricatorPolicyInterface,
     PhabricatorCustomFieldInterface,
     PhabricatorDestructableInterface {
 
   const SESSION_TABLE = 'phabricator_session';
   const NAMETOKEN_TABLE = 'user_nametoken';
   const MAXIMUM_USERNAME_LENGTH = 64;
 
   protected $userName;
   protected $realName;
   protected $sex;
   protected $translation;
   protected $passwordSalt;
   protected $passwordHash;
   protected $profileImagePHID;
   protected $timezoneIdentifier = '';
 
   protected $consoleEnabled = 0;
   protected $consoleVisible = 0;
   protected $consoleTab = '';
 
   protected $conduitCertificate;
 
   protected $isSystemAgent = 0;
   protected $isAdmin = 0;
   protected $isDisabled = 0;
   protected $isEmailVerified = 0;
   protected $isApproved = 0;
 
   protected $accountSecret;
 
   private $profileImage = self::ATTACHABLE;
   private $profile = null;
   private $status = self::ATTACHABLE;
   private $preferences = null;
   private $omnipotent = false;
   private $customFields = self::ATTACHABLE;
 
   private $alternateCSRFString = self::ATTACHABLE;
   private $session = self::ATTACHABLE;
 
   protected function readField($field) {
     switch ($field) {
       case 'timezoneIdentifier':
         // If the user hasn't set one, guess the server's time.
         return nonempty(
           $this->timezoneIdentifier,
           date_default_timezone_get());
       // Make sure these return booleans.
       case 'isAdmin':
         return (bool)$this->isAdmin;
       case 'isDisabled':
         return (bool)$this->isDisabled;
       case 'isSystemAgent':
         return (bool)$this->isSystemAgent;
       case 'isEmailVerified':
         return (bool)$this->isEmailVerified;
       case 'isApproved':
         return (bool)$this->isApproved;
       default:
         return parent::readField($field);
     }
   }
 
 
   /**
    * Is this a live account which has passed required approvals? Returns true
    * if this is an enabled, verified (if required), approved (if required)
    * account, and false otherwise.
    *
    * @return bool True if this is a standard, usable account.
    */
   public function isUserActivated() {
     if ($this->getIsDisabled()) {
       return false;
     }
 
     if (!$this->getIsApproved()) {
       return false;
     }
 
     if (PhabricatorUserEmail::isEmailVerificationRequired()) {
       if (!$this->getIsEmailVerified()) {
         return false;
       }
     }
 
     return true;
   }
 
   /**
    * Returns `true` if this is a standard user who is logged in. Returns `false`
    * for logged out, anonymous, or external users.
    *
    * @return bool `true` if the user is a standard user who is logged in with
    *              a normal session.
    */
   public function getIsStandardUser() {
     $type_user = PhabricatorPeoplePHIDTypeUser::TYPECONST;
     return $this->getPHID() && (phid_get_type($this->getPHID()) == $type_user);
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_PARTIAL_OBJECTS => true,
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorPeoplePHIDTypeUser::TYPECONST);
   }
 
   public function setPassword(PhutilOpaqueEnvelope $envelope) {
     if (!$this->getPHID()) {
       throw new Exception(
         "You can not set a password for an unsaved user because their PHID ".
         "is a salt component in the password hash.");
     }
 
     if (!strlen($envelope->openEnvelope())) {
       $this->setPasswordHash('');
     } else {
       $this->setPasswordSalt(md5(Filesystem::readRandomBytes(32)));
       $hash = $this->hashPassword($envelope);
       $this->setPasswordHash($hash->openEnvelope());
     }
     return $this;
   }
 
   // To satisfy PhutilPerson.
   public function getSex() {
     return $this->sex;
   }
 
   public function getMonogram() {
     return '@'.$this->getUsername();
   }
 
   public function getTranslation() {
     try {
       if ($this->translation &&
           class_exists($this->translation) &&
           is_subclass_of($this->translation, 'PhabricatorTranslation')) {
         return $this->translation;
       }
     } catch (PhutilMissingSymbolException $ex) {
       return null;
     }
     return null;
   }
 
   public function isLoggedIn() {
     return !($this->getPHID() === null);
   }
 
   public function save() {
     if (!$this->getConduitCertificate()) {
       $this->setConduitCertificate($this->generateConduitCertificate());
     }
 
     if (!strlen($this->getAccountSecret())) {
       $this->setAccountSecret(Filesystem::readRandomCharacters(64));
     }
 
     $result = parent::save();
 
     if ($this->profile) {
       $this->profile->save();
     }
 
     $this->updateNameTokens();
 
     id(new PhabricatorSearchIndexer())
       ->queueDocumentForIndexing($this->getPHID());
 
     return $result;
   }
 
   public function attachSession(PhabricatorAuthSession $session) {
     $this->session = $session;
     return $this;
   }
 
   public function getSession() {
     return $this->assertAttached($this->session);
   }
 
   public function hasSession() {
     return ($this->session !== self::ATTACHABLE);
   }
 
   private function generateConduitCertificate() {
     return Filesystem::readRandomCharacters(255);
   }
 
   public function comparePassword(PhutilOpaqueEnvelope $envelope) {
     if (!strlen($envelope->openEnvelope())) {
       return false;
     }
     if (!strlen($this->getPasswordHash())) {
       return false;
     }
 
     return PhabricatorPasswordHasher::comparePassword(
       $this->getPasswordHashInput($envelope),
       new PhutilOpaqueEnvelope($this->getPasswordHash()));
   }
 
   private function getPasswordHashInput(PhutilOpaqueEnvelope $password) {
     $input =
       $this->getUsername().
       $password->openEnvelope().
       $this->getPHID().
       $this->getPasswordSalt();
 
     return new PhutilOpaqueEnvelope($input);
   }
 
   private function hashPassword(PhutilOpaqueEnvelope $password) {
     $hasher = PhabricatorPasswordHasher::getBestHasher();
 
     $input_envelope = $this->getPasswordHashInput($password);
     return $hasher->getPasswordHashForStorage($input_envelope);
   }
 
   const CSRF_CYCLE_FREQUENCY  = 3600;
   const CSRF_SALT_LENGTH      = 8;
   const CSRF_TOKEN_LENGTH     = 16;
   const CSRF_BREACH_PREFIX    = 'B@';
 
   const EMAIL_CYCLE_FREQUENCY = 86400;
   const EMAIL_TOKEN_LENGTH    = 24;
 
   private function getRawCSRFToken($offset = 0) {
     return $this->generateToken(
       time() + (self::CSRF_CYCLE_FREQUENCY * $offset),
       self::CSRF_CYCLE_FREQUENCY,
       PhabricatorEnv::getEnvConfig('phabricator.csrf-key'),
       self::CSRF_TOKEN_LENGTH);
   }
 
   /**
    * @phutil-external-symbol class PhabricatorStartup
    */
   public function getCSRFToken() {
     $salt = PhabricatorStartup::getGlobal('csrf.salt');
     if (!$salt) {
       $salt = Filesystem::readRandomCharacters(self::CSRF_SALT_LENGTH);
       PhabricatorStartup::setGlobal('csrf.salt', $salt);
     }
 
     // Generate a token hash to mitigate BREACH attacks against SSL. See
     // discussion in T3684.
     $token = $this->getRawCSRFToken();
     $hash = PhabricatorHash::digest($token, $salt);
     return 'B@'.$salt.substr($hash, 0, self::CSRF_TOKEN_LENGTH);
   }
 
   public function validateCSRFToken($token) {
     $salt = null;
     $version = 'plain';
 
     // This is a BREACH-mitigating token. See T3684.
     $breach_prefix = self::CSRF_BREACH_PREFIX;
     $breach_prelen = strlen($breach_prefix);
 
     if (!strncmp($token, $breach_prefix, $breach_prelen)) {
       $version = 'breach';
       $salt = substr($token, $breach_prelen, self::CSRF_SALT_LENGTH);
       $token = substr($token, $breach_prelen + self::CSRF_SALT_LENGTH);
     }
 
     // When the user posts a form, we check that it contains a valid CSRF token.
     // Tokens cycle each hour (every CSRF_CYLCE_FREQUENCY seconds) and we accept
     // either the current token, the next token (users can submit a "future"
     // token if you have two web frontends that have some clock skew) or any of
     // the last 6 tokens. This means that pages are valid for up to 7 hours.
     // There is also some Javascript which periodically refreshes the CSRF
     // tokens on each page, so theoretically pages should be valid indefinitely.
     // However, this code may fail to run (if the user loses their internet
     // connection, or there's a JS problem, or they don't have JS enabled).
     // Choosing the size of the window in which we accept old CSRF tokens is
     // an issue of balancing concerns between security and usability. We could
     // choose a very narrow (e.g., 1-hour) window to reduce vulnerability to
     // attacks using captured CSRF tokens, but it's also more likely that real
     // users will be affected by this, e.g. if they close their laptop for an
     // hour, open it back up, and try to submit a form before the CSRF refresh
     // can kick in. Since the user experience of submitting a form with expired
     // CSRF is often quite bad (you basically lose data, or it's a big pain to
     // recover at least) and I believe we gain little additional protection
     // by keeping the window very short (the overwhelming value here is in
     // preventing blind attacks, and most attacks which can capture CSRF tokens
     // can also just capture authentication information [sniffing networks]
     // or act as the user [xss]) the 7 hour default seems like a reasonable
     // balance. Other major platforms have much longer CSRF token lifetimes,
     // like Rails (session duration) and Django (forever), which suggests this
     // is a reasonable analysis.
     $csrf_window = 6;
 
     for ($ii = -$csrf_window; $ii <= 1; $ii++) {
       $valid = $this->getRawCSRFToken($ii);
       switch ($version) {
         // TODO: We can remove this after the BREACH version has been in the
         // wild for a while.
         case 'plain':
           if ($token == $valid) {
             return true;
           }
           break;
         case 'breach':
           $digest = PhabricatorHash::digest($valid, $salt);
           if (substr($digest, 0, self::CSRF_TOKEN_LENGTH) == $token) {
             return true;
           }
           break;
         default:
           throw new Exception("Unknown CSRF token format!");
       }
     }
 
     return false;
   }
 
   private function generateToken($epoch, $frequency, $key, $len) {
     if ($this->getPHID()) {
       $vec = $this->getPHID().$this->getAccountSecret();
     } else {
       $vec = $this->getAlternateCSRFString();
     }
 
     $time_block = floor($epoch / $frequency);
     $vec = $vec.$key.$time_block;
 
     return substr(PhabricatorHash::digest($vec), 0, $len);
   }
 
   private function generateEmailToken(
     PhabricatorUserEmail $email,
     $offset = 0) {
 
     $key = implode(
       '-',
       array(
         PhabricatorEnv::getEnvConfig('phabricator.csrf-key'),
         $this->getPHID(),
         $email->getVerificationCode(),
       ));
 
     return $this->generateToken(
       time() + ($offset * self::EMAIL_CYCLE_FREQUENCY),
       self::EMAIL_CYCLE_FREQUENCY,
       $key,
       self::EMAIL_TOKEN_LENGTH);
   }
 
   public function validateEmailToken(
     PhabricatorUserEmail $email,
     $token) {
     for ($ii = -1; $ii <= 1; $ii++) {
       $valid = $this->generateEmailToken($email, $ii);
       if ($token == $valid) {
         return true;
       }
     }
     return false;
   }
 
   public function getEmailLoginURI(PhabricatorUserEmail $email = null) {
     if (!$email) {
       $email = $this->loadPrimaryEmail();
       if (!$email) {
         throw new Exception("User has no primary email!");
       }
     }
     $token = $this->generateEmailToken($email);
 
     $uri = '/login/etoken/'.$token.'/';
     try {
       $uri = PhabricatorEnv::getProductionURI($uri);
     } catch (Exception $ex) {
       // If a user runs `bin/auth recover` before configuring the base URI,
       // just show the path. We don't have any way to figure out the domain.
       // See T4132.
     }
 
     $uri = new PhutilURI($uri);
 
     return $uri->alter('email', $email->getAddress());
   }
 
   public function attachUserProfile(PhabricatorUserProfile $profile) {
     $this->profile = $profile;
     return $this;
   }
 
   public function loadUserProfile() {
     if ($this->profile) {
       return $this->profile;
     }
 
     $profile_dao = new PhabricatorUserProfile();
     $this->profile = $profile_dao->loadOneWhere('userPHID = %s',
       $this->getPHID());
 
     if (!$this->profile) {
       $profile_dao->setUserPHID($this->getPHID());
       $this->profile = $profile_dao;
     }
 
     return $this->profile;
   }
 
   public function loadPrimaryEmailAddress() {
     $email = $this->loadPrimaryEmail();
     if (!$email) {
       throw new Exception("User has no primary email address!");
     }
     return $email->getAddress();
   }
 
   public function loadPrimaryEmail() {
     return $this->loadOneRelative(
       new PhabricatorUserEmail(),
       'userPHID',
       'getPHID',
       '(isPrimary = 1)');
   }
 
   public function loadPreferences() {
     if ($this->preferences) {
       return $this->preferences;
     }
 
     $preferences = null;
     if ($this->getPHID()) {
       $preferences = id(new PhabricatorUserPreferences())->loadOneWhere(
         'userPHID = %s',
         $this->getPHID());
     }
 
     if (!$preferences) {
       $preferences = new PhabricatorUserPreferences();
       $preferences->setUserPHID($this->getPHID());
 
       $default_dict = array(
         PhabricatorUserPreferences::PREFERENCE_TITLES => 'glyph',
         PhabricatorUserPreferences::PREFERENCE_EDITOR => '',
         PhabricatorUserPreferences::PREFERENCE_MONOSPACED => '',
         PhabricatorUserPreferences::PREFERENCE_DARK_CONSOLE => 0);
 
       $preferences->setPreferences($default_dict);
     }
 
     $this->preferences = $preferences;
     return $preferences;
   }
 
   public function loadEditorLink($path, $line, $callsign) {
     $editor = $this->loadPreferences()->getPreference(
       PhabricatorUserPreferences::PREFERENCE_EDITOR);
 
     if (is_array($path)) {
       $multiedit = $this->loadPreferences()->getPreference(
         PhabricatorUserPreferences::PREFERENCE_MULTIEDIT);
       switch ($multiedit) {
         case '':
           $path = implode(' ', $path);
           break;
         case 'disable':
           return null;
       }
     }
 
     if (!strlen($editor)) {
       return null;
     }
 
     $uri = strtr($editor, array(
       '%%' => '%',
       '%f' => phutil_escape_uri($path),
       '%l' => phutil_escape_uri($line),
       '%r' => phutil_escape_uri($callsign),
     ));
 
     // The resulting URI must have an allowed protocol. Otherwise, we'll return
     // a link to an error page explaining the misconfiguration.
 
     $ok = PhabricatorHelpEditorProtocolController::hasAllowedProtocol($uri);
     if (!$ok) {
       return '/help/editorprotocol/';
     }
 
     return (string)$uri;
   }
 
   public function getAlternateCSRFString() {
     return $this->assertAttached($this->alternateCSRFString);
   }
 
   public function attachAlternateCSRFString($string) {
     $this->alternateCSRFString = $string;
     return $this;
   }
 
   private static function tokenizeName($name) {
     if (function_exists('mb_strtolower')) {
       $name = mb_strtolower($name, 'UTF-8');
     } else {
       $name = strtolower($name);
     }
     $name = trim($name);
     if (!strlen($name)) {
       return array();
     }
     return preg_split('/\s+/', $name);
   }
 
   /**
    * Populate the nametoken table, which used to fetch typeahead results. When
    * a user types "linc", we want to match "Abraham Lincoln" from on-demand
    * typeahead sources. To do this, we need a separate table of name fragments.
    */
   public function updateNameTokens() {
     $tokens = array_merge(
       self::tokenizeName($this->getRealName()),
       self::tokenizeName($this->getUserName()));
     $tokens = array_unique($tokens);
     $table  = self::NAMETOKEN_TABLE;
     $conn_w = $this->establishConnection('w');
 
     $sql = array();
     foreach ($tokens as $token) {
       $sql[] = qsprintf(
         $conn_w,
         '(%d, %s)',
         $this->getID(),
         $token);
     }
 
     queryfx(
       $conn_w,
       'DELETE FROM %T WHERE userID = %d',
       $table,
       $this->getID());
     if ($sql) {
       queryfx(
         $conn_w,
         'INSERT INTO %T (userID, token) VALUES %Q',
         $table,
         implode(', ', $sql));
     }
   }
 
   public function sendWelcomeEmail(PhabricatorUser $admin) {
     $admin_username = $admin->getUserName();
     $admin_realname = $admin->getRealName();
     $user_username = $this->getUserName();
     $is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');
 
     $base_uri = PhabricatorEnv::getProductionURI('/');
 
     $uri = $this->getEmailLoginURI();
     $body = <<<EOBODY
 Welcome to Phabricator!
 
 {$admin_username} ({$admin_realname}) has created an account for you.
 
   Username: {$user_username}
 
 To login to Phabricator, follow this link and set a password:
 
   {$uri}
 
 After you have set a password, you can login in the future by going here:
 
   {$base_uri}
 
 EOBODY;
 
     if (!$is_serious) {
       $body .= <<<EOBODY
 
 Love,
 Phabricator
 
 EOBODY;
     }
 
     $mail = id(new PhabricatorMetaMTAMail())
       ->addTos(array($this->getPHID()))
       ->setSubject('[Phabricator] Welcome to Phabricator')
       ->setBody($body)
       ->saveAndSend();
   }
 
   public function sendUsernameChangeEmail(
     PhabricatorUser $admin,
     $old_username) {
 
     $admin_username = $admin->getUserName();
     $admin_realname = $admin->getRealName();
     $new_username = $this->getUserName();
 
     $password_instructions = null;
     if (PhabricatorAuthProviderPassword::getPasswordProvider()) {
       $uri = $this->getEmailLoginURI();
       $password_instructions = <<<EOTXT
 If you use a password to login, you'll need to reset it before you can login
 again. You can reset your password by following this link:
 
   {$uri}
 
 And, of course, you'll need to use your new username to login from now on. If
 you use OAuth to login, nothing should change.
 
 EOTXT;
     }
 
     $body = <<<EOBODY
 {$admin_username} ({$admin_realname}) has changed your Phabricator username.
 
   Old Username: {$old_username}
   New Username: {$new_username}
 
 {$password_instructions}
 EOBODY;
 
     $mail = id(new PhabricatorMetaMTAMail())
       ->addTos(array($this->getPHID()))
       ->setSubject('[Phabricator] Username Changed')
       ->setBody($body)
       ->saveAndSend();
   }
 
   public static function describeValidUsername() {
     return pht(
       'Usernames must contain only numbers, letters, period, underscore and '.
       'hyphen, and can not end with a period. They must have no more than %d '.
       'characters.',
       new PhutilNumber(self::MAXIMUM_USERNAME_LENGTH));
   }
 
   public static function validateUsername($username) {
     // NOTE: If you update this, make sure to update:
     //
     //  - Remarkup rule for @mentions.
     //  - Routing rule for "/p/username/".
     //  - Unit tests, obviously.
     //  - describeValidUsername() method, above.
 
     if (strlen($username) > self::MAXIMUM_USERNAME_LENGTH) {
       return false;
     }
 
     return (bool)preg_match('/^[a-zA-Z0-9._-]*[a-zA-Z0-9_-]\z/', $username);
   }
 
   public static function getDefaultProfileImageURI() {
     return celerity_get_resource_uri('/rsrc/image/avatar.png');
   }
 
   public function attachStatus(PhabricatorCalendarEvent $status) {
     $this->status = $status;
     return $this;
   }
 
   public function getStatus() {
     return $this->assertAttached($this->status);
   }
 
   public function hasStatus() {
     return $this->status !== self::ATTACHABLE;
   }
 
   public function attachProfileImageURI($uri) {
     $this->profileImage = $uri;
     return $this;
   }
 
   public function getProfileImageURI() {
     return $this->assertAttached($this->profileImage);
   }
 
   public function loadProfileImageURI() {
     if ($this->profileImage && ($this->profileImage !== self::ATTACHABLE)) {
       return $this->profileImage;
     }
 
     $src_phid = $this->getProfileImagePHID();
 
     if ($src_phid) {
       // TODO: (T603) Can we get rid of this entirely and move it to
       // PeopleQuery with attach/attachable?
       $file = id(new PhabricatorFile())->loadOneWhere('phid = %s', $src_phid);
       if ($file) {
         $this->profileImage = $file->getBestURI();
         return $this->profileImage;
       }
     }
 
     $this->profileImage = self::getDefaultProfileImageURI();
     return $this->profileImage;
   }
 
   public function getFullName() {
-    return $this->getUsername().' ('.$this->getRealName().')';
+    if (strlen($this->getRealName())) {
+      return $this->getUsername().' ('.$this->getRealName().')';
+    } else {
+      return $this->getUsername();
+    }
   }
 
   public function __toString() {
     return $this->getUsername();
   }
 
   public static function loadOneWithEmailAddress($address) {
     $email = id(new PhabricatorUserEmail())->loadOneWhere(
       'address = %s',
       $address);
     if (!$email) {
       return null;
     }
     return id(new PhabricatorUser())->loadOneWhere(
       'phid = %s',
       $email->getUserPHID());
   }
 
 
 /* -(  Omnipotence  )-------------------------------------------------------- */
 
 
   /**
    * Returns true if this user is omnipotent. Omnipotent users bypass all policy
    * checks.
    *
    * @return bool True if the user bypasses policy checks.
    */
   public function isOmnipotent() {
     return $this->omnipotent;
   }
 
 
   /**
    * Get an omnipotent user object for use in contexts where there is no acting
    * user, notably daemons.
    *
    * @return PhabricatorUser An omnipotent user.
    */
   public static function getOmnipotentUser() {
     static $user = null;
     if (!$user) {
       $user = new PhabricatorUser();
       $user->omnipotent = true;
       $user->makeEphemeral();
     }
     return $user;
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return PhabricatorPolicies::POLICY_PUBLIC;
       case PhabricatorPolicyCapability::CAN_EDIT:
         if ($this->getIsSystemAgent()) {
           return PhabricatorPolicies::POLICY_ADMIN;
         } else {
           return PhabricatorPolicies::POLICY_NOONE;
         }
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return $this->getPHID() && ($viewer->getPHID() === $this->getPHID());
   }
 
   public function describeAutomaticCapability($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_EDIT:
         return pht('Only you can edit your information.');
       default:
         return null;
     }
   }
 
 
 /* -(  PhabricatorCustomFieldInterface  )------------------------------------ */
 
 
   public function getCustomFieldSpecificationForRole($role) {
     return PhabricatorEnv::getEnvConfig('user.fields');
   }
 
   public function getCustomFieldBaseClass() {
     return 'PhabricatorUserCustomField';
   }
 
   public function getCustomFields() {
     return $this->assertAttached($this->customFields);
   }
 
   public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
     $this->customFields = $fields;
     return $this;
   }
 
 
 /* -(  PhabricatorDestructableInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
       $this->delete();
 
       $externals = id(new PhabricatorExternalAccount())->loadAllWhere(
         'userPHID = %s',
         $this->getPHID());
       foreach ($externals as $external) {
         $external->delete();
       }
 
       $prefs = id(new PhabricatorUserPreferences())->loadAllWhere(
         'userPHID = %s',
         $this->getPHID());
       foreach ($prefs as $pref) {
         $pref->delete();
       }
 
       $profiles = id(new PhabricatorUserProfile())->loadAllWhere(
         'userPHID = %s',
         $this->getPHID());
       foreach ($profiles as $profile) {
         $profile->delete();
       }
 
       $keys = id(new PhabricatorUserSSHKey())->loadAllWhere(
         'userPHID = %s',
         $this->getPHID());
       foreach ($keys as $key) {
         $key->delete();
       }
 
       $emails = id(new PhabricatorUserEmail())->loadAllWhere(
         'userPHID = %s',
         $this->getPHID());
       foreach ($emails as $email) {
         $email->delete();
       }
 
       $sessions = id(new PhabricatorAuthSession())->loadAllWhere(
         'userPHID = %s',
         $this->getPHID());
       foreach ($sessions as $session) {
         $session->delete();
       }
 
       $factors = id(new PhabricatorAuthFactorConfig())->loadAllWhere(
         'userPHID = %s',
         $this->getPHID());
       foreach ($factors as $factor) {
         $factor->delete();
       }
 
     $this->saveTransaction();
   }
 
 
 }