diff --git a/web/modals/threads/thread-settings-general-tab.css b/web/modals/threads/thread-settings-general-tab.css
index d7c9e9d30..14cd3fbc6 100644
--- a/web/modals/threads/thread-settings-general-tab.css
+++ b/web/modals/threads/thread-settings-general-tab.css
@@ -1,30 +1,32 @@
 div.form_title {
-  padding: 6px 6px 0 0;
+  padding-top: 6px;
   font-size: 14px;
   font-weight: 600;
   vertical-align: top;
   color: var(--fg);
 }
 div.form_content {
   display: flex;
   font-family: var(--font-stack);
   color: var(--fg);
-  margin-top: 4px;
-  margin-bottom: 8px;
-}
-div.form_content input {
-  margin-bottom: 4px;
+  margin-top: 8px;
+  margin-bottom: 12px;
 }
 div.form_content textarea {
   padding: 12px;
   background: var(--modal-bg);
   color: var(--fg);
   border: 1px solid var(--border-color);
   font-size: var(--m-font-16);
   border-radius: 4px;
   width: 100%;
 }
 
+div.colorSelectorContainer {
+  margin-top: 8px;
+  margin-bottom: 12px;
+}
+
 .save_button {
   width: 100%;
 }
diff --git a/web/modals/threads/thread-settings-general-tab.react.js b/web/modals/threads/thread-settings-general-tab.react.js
index 37aedb274..85ac782dc 100644
--- a/web/modals/threads/thread-settings-general-tab.react.js
+++ b/web/modals/threads/thread-settings-general-tab.react.js
@@ -1,177 +1,179 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   changeThreadSettingsActionTypes,
   changeThreadSettings,
 } from 'lib/actions/thread-actions';
 import { type SetState } from 'lib/types/hook-types.js';
 import { type ThreadInfo, type ThreadChanges } from 'lib/types/thread-types';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils';
 import { firstLine } from 'lib/utils/string-utils';
 
 import Button from '../../components/button.react';
 import Input from '../input.react.js';
 import { useModalContext } from '../modal-provider.react.js';
 import ColorSelector from './color-selector.react.js';
 import css from './thread-settings-general-tab.css';
 
 type ThreadSettingsGeneralTabProps = {
   +inputDisabled: boolean,
   +threadInfo: ThreadInfo,
   +threadNamePlaceholder: string,
   +queuedChanges: ThreadChanges,
   +setQueuedChanges: SetState<ThreadChanges>,
   +setErrorMessage: SetState<string>,
 };
 function ThreadSettingsGeneralTab(
   props: ThreadSettingsGeneralTabProps,
 ): React.Node {
   const {
     inputDisabled,
     threadInfo,
     threadNamePlaceholder,
     queuedChanges,
     setQueuedChanges,
     setErrorMessage,
   } = props;
 
   const modalContext = useModalContext();
   const dispatchActionPromise = useDispatchActionPromise();
   const callChangeThreadSettings = useServerCall(changeThreadSettings);
 
   const nameInputRef = React.useRef();
 
   React.useEffect(() => {
     nameInputRef.current?.focus();
   }, [inputDisabled]);
 
   const changeQueued: boolean = React.useMemo(
     () => Object.values(queuedChanges).some(v => v !== null && v !== undefined),
     [queuedChanges],
   );
 
   const onChangeName = React.useCallback(
     (event: SyntheticEvent<HTMLInputElement>) => {
       const target = event.currentTarget;
       setQueuedChanges(prevQueuedChanges =>
         Object.freeze({
           ...prevQueuedChanges,
           name: firstLine(
             target.value !== threadInfo.name ? target.value : undefined,
           ),
         }),
       );
     },
     [setQueuedChanges, threadInfo.name],
   );
 
   const onChangeDescription = React.useCallback(
     (event: SyntheticEvent<HTMLTextAreaElement>) => {
       const target = event.currentTarget;
       setQueuedChanges(prevQueuedChanges =>
         Object.freeze({
           ...prevQueuedChanges,
           description:
             target.value !== threadInfo.description ? target.value : undefined,
         }),
       );
     },
     [setQueuedChanges, threadInfo.description],
   );
 
   const onChangeColor = React.useCallback(
     (color: string) => {
       setQueuedChanges(prevQueuedChanges =>
         Object.freeze({
           ...prevQueuedChanges,
           color: color !== threadInfo.color ? color : undefined,
         }),
       );
     },
     [setQueuedChanges, threadInfo.color],
   );
 
   const changeThreadSettingsAction = React.useCallback(async () => {
     try {
       const response = await callChangeThreadSettings({
         threadID: threadInfo.id,
         changes: queuedChanges,
       });
       modalContext.popModal();
       return response;
     } catch (e) {
       setErrorMessage('unknown_error');
       setQueuedChanges(Object.freeze({}));
       throw e;
     }
   }, [
     callChangeThreadSettings,
     modalContext,
     queuedChanges,
     setErrorMessage,
     setQueuedChanges,
     threadInfo.id,
   ]);
 
   const onSubmit = React.useCallback(
     (event: SyntheticEvent<HTMLElement>) => {
       event.preventDefault();
       dispatchActionPromise(
         changeThreadSettingsActionTypes,
         changeThreadSettingsAction(),
       );
     },
     [changeThreadSettingsAction, dispatchActionPromise],
   );
 
   return (
     <form method="POST">
       <div>
         <div className={css.form_title}>Thread name</div>
         <div className={css.form_content}>
           <Input
             type="text"
             value={firstLine(queuedChanges.name ?? threadInfo.name)}
             placeholder={threadNamePlaceholder}
             onChange={onChangeName}
             disabled={inputDisabled}
             ref={nameInputRef}
           />
         </div>
       </div>
       <div>
         <div className={css.form_title}>Description</div>
         <div className={css.form_content}>
           <textarea
             value={queuedChanges.description ?? threadInfo.description ?? ''}
             placeholder="Thread description"
             onChange={onChangeDescription}
             disabled={inputDisabled}
           />
         </div>
       </div>
       <div>
         <div className={css.form_title}>Color</div>
-        <ColorSelector
-          currentColor={queuedChanges.color ?? threadInfo.color}
-          onColorSelection={onChangeColor}
-        />
+        <div className={css.colorSelectorContainer}>
+          <ColorSelector
+            currentColor={queuedChanges.color ?? threadInfo.color}
+            onColorSelection={onChangeColor}
+          />
+        </div>
       </div>
       <Button
         type="submit"
         onClick={onSubmit}
         disabled={inputDisabled || !changeQueued}
         className={css.save_button}
       >
         Save
       </Button>
     </form>
   );
 }
 
 export default ThreadSettingsGeneralTab;
diff --git a/web/modals/threads/thread-settings-modal.css b/web/modals/threads/thread-settings-modal.css
index 3f28954d4..ea4c8fa59 100644
--- a/web/modals/threads/thread-settings-modal.css
+++ b/web/modals/threads/thread-settings-modal.css
@@ -1,15 +1,15 @@
 div.modal_body {
   display: flex;
   flex-direction: column;
 }
 div.tab_body {
   padding: 20px;
 }
 div.modal_form_error {
   display: flex;
   justify-content: center;
-  padding-top: 16px;
+  padding-top: 8px;
   font-size: 16px;
   color: red;
   font-style: italic;
 }