diff --git a/web/calendar/thread-picker.css b/web/calendar/thread-picker.css
index f22c87518..470affafe 100644
--- a/web/calendar/thread-picker.css
+++ b/web/calendar/thread-picker.css
@@ -1,72 +1,45 @@
 div.container {
   position: absolute;
   left: 4px;
   bottom: 20px;
   box-shadow: 0 8px 16px 0 rgba(0, 0, 0, 0.3);
   z-index: 1;
   font-weight: 600;
   background-color: white;
   border-radius: 3px;
   white-space: nowrap;
   line-height: normal;
   font-size: 12px;
   cursor: pointer;
   outline: none;
 }
 span.thread {
   color: black;
   display: inline-block;
   overflow: hidden;
   text-overflow: ellipsis;
   width: 110px;
 }
 div.container > div.option {
   border-bottom: 1px solid #d3d3d3;
   padding: 1px 10px 1px 25px;
   position: relative;
 }
 div.container > div.option:hover {
   background-color: #f2f2f2;
 }
 div.container > div:last-child {
   border-bottom: none;
 }
 div.colorPreview {
   width: 12px;
   height: 12px;
   left: 6px;
   position: absolute;
   top: 4px;
   border: 1px solid lightgray;
   border-radius: 2px;
 }
 div.threadName {
   padding-top: 1px;
 }
-div.pagerContainer {
-  text-align: center;
-  height: 15px;
-  margin-top: -2px;
-  cursor: default;
-  background-color: #eaeaea;
-  position: relative;
-  border-radius: 0 0 3px 3px;
-}
-div.pager {
-  position: relative;
-  top: -2px;
-}
-span.pagerStatus {
-  text-transform: uppercase;
-  color: #777777;
-  font-size: 9px;
-}
-svg.pagerIcon {
-  fill: #777777;
-  vertical-align: middle;
-  width: 13px;
-  height: 13px;
-}
-a.pagerButton > svg.pagerIcon {
-  fill: #2a5db0;
-}
diff --git a/web/calendar/thread-picker.react.js b/web/calendar/thread-picker.react.js
index f5c960caf..016239784 100644
--- a/web/calendar/thread-picker.react.js
+++ b/web/calendar/thread-picker.react.js
@@ -1,195 +1,119 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { onScreenEntryEditableThreadInfos } from 'lib/selectors/thread-selectors';
 import type { ThreadInfo } from 'lib/types/thread-types';
 
 import { useSelector } from '../redux/redux-utils';
 import { htmlTargetFromEvent } from '../vector-utils';
-import { LeftPager, RightPager } from '../vectors.react';
 import css from './thread-picker.css';
 
 type OptionProps = {
   +threadInfo: ThreadInfo,
   +createNewEntry: (threadID: string) => void,
 };
 function ThreadPickerOption(props: OptionProps) {
   const { threadInfo, createNewEntry } = props;
   const onClick = React.useCallback(() => createNewEntry(threadInfo.id), [
     threadInfo.id,
     createNewEntry,
   ]);
   const colorStyle = { backgroundColor: `#${props.threadInfo.color}` };
 
   return (
     <div className={css.option} onClick={onClick}>
       <span className={css.thread}>
         <div className={css.colorPreview} style={colorStyle} />
         <span className={css.threadName}>{props.threadInfo.uiName}</span>
       </span>
     </div>
   );
 }
 
 type BaseProps = {
   +createNewEntry: (threadID: string) => void,
   +closePicker: () => void,
 };
 type Props = {
   ...BaseProps,
   +onScreenThreadInfos: $ReadOnlyArray<ThreadInfo>,
 };
-type State = {
-  +currentPage: number,
-};
-
-class ThreadPicker extends React.PureComponent<Props, State> {
-  static pageSize = 5;
 
+class ThreadPicker extends React.PureComponent<Props> {
   pickerDiv: ?HTMLDivElement;
 
   constructor(props: Props) {
     super(props);
-    this.state = {
-      currentPage: 0,
-    };
     invariant(
       props.onScreenThreadInfos.length > 0,
       "ThreadPicker can't be open when onScreenThreadInfos is empty",
     );
   }
 
   componentDidMount() {
     invariant(this.pickerDiv, 'pickerDiv ref unset');
     this.pickerDiv.focus();
   }
 
   render() {
     const length = this.props.onScreenThreadInfos.length;
     invariant(
       length > 0,
       "ThreadPicker can't be open when onScreenThreadInfos is empty",
     );
-    const firstIndex = ThreadPicker.pageSize * this.state.currentPage;
-    const secondIndex = Math.min(
-      ThreadPicker.pageSize * (this.state.currentPage + 1),
-      length,
-    );
-
-    let pager = null;
-    if (length > ThreadPicker.pageSize) {
-      let leftPager = <LeftPager className={css.pagerIcon} />;
-      if (this.state.currentPage > 0) {
-        leftPager = (
-          <a
-            href="#"
-            className={css.pagerButton}
-            onClick={this.onBackPagerClick}
-          >
-            {leftPager}
-          </a>
-        );
-      }
-      let rightPager = <RightPager className={css.pagerIcon} />;
-      if (ThreadPicker.pageSize * (this.state.currentPage + 1) < length) {
-        rightPager = (
-          <a
-            href="#"
-            className={css.pagerButton}
-            onClick={this.onNextPagerClick}
-          >
-            {rightPager}
-          </a>
-        );
-      }
-      pager = (
-        <div className={css.pagerContainer} key="pager">
-          <div className={css.pager}>
-            {leftPager}
-            <span className={css.pagerStatus}>
-              {`${firstIndex + 1}–${secondIndex} of ${length}`}
-            </span>
-            {rightPager}
-          </div>
-        </div>
-      );
-    }
 
-    const options = this.props.onScreenThreadInfos
-      .slice(firstIndex, secondIndex)
-      .map(threadInfo => (
-        <ThreadPickerOption
-          threadInfo={threadInfo}
-          createNewEntry={this.props.createNewEntry}
-          key={threadInfo.id}
-        />
-      ));
+    const options = this.props.onScreenThreadInfos.map(threadInfo => (
+      <ThreadPickerOption
+        threadInfo={threadInfo}
+        createNewEntry={this.props.createNewEntry}
+        key={threadInfo.id}
+      />
+    ));
 
     return (
       <div
         className={css.container}
         tabIndex="0"
         onBlur={this.props.closePicker}
         onKeyDown={this.onPickerKeyDown}
         onMouseDown={this.onMouseDown}
         ref={this.pickerDivRef}
       >
         {options}
-        {pager}
       </div>
     );
   }
 
   pickerDivRef = (pickerDiv: ?HTMLDivElement) => {
     this.pickerDiv = pickerDiv;
   };
 
   onPickerKeyDown = (event: SyntheticKeyboardEvent<HTMLDivElement>) => {
     if (event.keyCode === 27) {
       // Esc
       this.props.closePicker();
     }
   };
 
   onMouseDown = (event: SyntheticEvent<HTMLDivElement>) => {
     const target = htmlTargetFromEvent(event);
     invariant(this.pickerDiv, 'pickerDiv ref not set');
     if (this.pickerDiv.contains(target)) {
       // This prevents onBlur from firing
       event.preventDefault();
     }
   };
-
-  onBackPagerClick = (event: SyntheticEvent<HTMLAnchorElement>) => {
-    event.preventDefault();
-    this.setState(prevState => {
-      invariant(prevState.currentPage > 0, "can't go back from 0");
-      return { currentPage: prevState.currentPage - 1 };
-    });
-  };
-
-  onNextPagerClick = (event: SyntheticEvent<HTMLAnchorElement>) => {
-    event.preventDefault();
-    this.setState((prevState, props) => {
-      invariant(
-        ThreadPicker.pageSize * (prevState.currentPage + 1) <
-          props.onScreenThreadInfos.length,
-        'page is too high',
-      );
-      return { currentPage: prevState.currentPage + 1 };
-    });
-  };
 }
 
 const ConnectedThreadPicker: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedThreadPicker(props) {
     const onScreenThreadInfos = useSelector(onScreenEntryEditableThreadInfos);
     return (
       <ThreadPicker {...props} onScreenThreadInfos={onScreenThreadInfos} />
     );
   },
 );
 
 export default ConnectedThreadPicker;
diff --git a/web/vectors.react.js b/web/vectors.react.js
index fcbff2437..2ac011a02 100644
--- a/web/vectors.react.js
+++ b/web/vectors.react.js
@@ -1,124 +1,98 @@
 // @flow
 
 import * as React from 'react';
 
 type SVGProps = {
   className?: string,
   viewBox: string,
   preserveAspectRatio?: string,
   children?: React.Node,
 };
 
 function SVG(props: SVGProps): React.Node {
   return (
     <svg
       version="1.1"
       xmlns="http://www.w3.org/2000/svg"
       xmlSpace="preserve"
       xmlnsXlink="http://www.w3.org/1999/xlink"
       {...props}
     />
   );
 }
 
-export function LeftPager(props: { className?: string }): React.Node {
-  return (
-    <SVG className={props.className} viewBox="0 0 512 512">
-      <polygon
-        points={
-          '352,128.4 319.7,96 160,256 160,256 160,256 319.7,416 ' +
-          '352,383.6 224.7,256'
-        }
-      />
-    </SVG>
-  );
-}
-
-export function RightPager(props: { className?: string }): React.Node {
-  return (
-    <SVG className={props.className} viewBox="0 0 512 512">
-      <polygon
-        points={
-          '160,128.4 192.3,96 352,256 352,256 352,256 192.3,416 ' +
-          '160,383.6 287.3,256 '
-        }
-      />
-    </SVG>
-  );
-}
-
 export function UpCaret(props: { className?: string }): React.Node {
   return (
     <SVG
       viewBox="0 0 8 8"
       preserveAspectRatio="none"
       className={props.className}
     >
       <path d="M4 2l-4 4h8l-4-4z" />
     </SVG>
   );
 }
 
 export function DownCaret(props: { className?: string }): React.Node {
   return (
     <SVG
       viewBox="0 0 8 8"
       preserveAspectRatio="none"
       className={props.className}
     >
       <path d="M0 2l4 4 4-4h-8z" />
     </SVG>
   );
 }
 
 export function DeleteVector(props: { className?: string }): React.Node {
   return (
     <SVG className={props.className} viewBox="0 0 8 8">
       <path
         d={
           'M1.406 0l-1.406 1.406.688.719 1.781 1.781-1.781 1.781-.688.719 ' +
           '1.406 1.406.719-.688 1.781-1.781 1.781 1.781.719.688 1.406-1.406' +
           '-.688-.719-1.781-1.781 1.781-1.781.688-.719-1.406-1.406-.719.688' +
           '-1.781 1.781-1.781-1.781-.719-.688z'
         }
       />
     </SVG>
   );
 }
 
 export function AddVector(props: { className?: string }): React.Node {
   return (
     <SVG className={props.className} viewBox="0 0 8 8">
       <path d="M3 0v3h-3v2h3v3h2v-3h3v-2h-3v-3h-2z" />
     </SVG>
   );
 }
 
 export function HistoryVector(props: { className?: string }): React.Node {
   return (
     <SVG className={props.className} viewBox="0 0 8 8">
       <path
         d={
           'M.094 0c-.06 0-.094.034-.094.094v5.813c0 .06.034.094.094.094h5.' +
           '906l2 2v-7.906000000000001c0-.06-.034-.094-.094-.094h-7.813z'
         }
       />
     </SVG>
   );
 }
 
 export function MagnifyingGlass(props: { className?: string }): React.Node {
   return (
     <SVG className={props.className} viewBox="0 0 24 24">
       <path
         d={
           'M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 ' +
           '9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.' +
           '79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 ' +
           '14 7.01 14 9.5 11.99 14 9.5 14z'
         }
       />
       <path d="M0 0h24v24H0z" fill="none" />
     </SVG>
   );
 }