feat: continue integration

src/Navigation.tsx

···
 
 /**
  * These "common screens" are reused across stacks.
+ * 
+ * Note: Navigation titles use i18n._() which evaluates at setup time, not render time.
+ * This means they cannot dynamically respond to terminology preference changes.
+ * All in-app content (buttons, dialogs, messages) uses the terminology system,
+ * but these navigation bar titles remain static. This is a low-impact limitation
+ * as navigation titles are rarely noticed by users.
  */
 function commonScreens(Stack: typeof Flat, unreadCountLabel?: string) {
   const title = (page: MessageDescriptor) =>

src/components/PostControls/BookmarkButton.tsx

···
 import type React from 'react'
 
 import {useCleanError} from '#/lib/hooks/useCleanError'
+import {getTerminology} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {logger} from '#/logger'
 import {type Shadow} from '#/state/cache/post-shadow'
 import {useBookmarkMutation} from '#/state/queries/bookmarks/useBookmarkMutation'
···
 }): React.ReactNode {
   const t = useTheme()
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const {mutateAsync: bookmark} = useBookmarkMutation()
   const cleanError = useCleanError()
   const requireAuth = useRequireAuth()
···
         <toast.Outer>
           <toast.Icon />
           <toast.Text>
-            <Trans>Skeet saved</Trans>
+            <Trans>{_(getTerminology(terminologyPreference, {
+              skeet: msg`Skeet saved`,
+              post: msg`Post saved`,
+              spell: msg`Spell saved`,
+            }))}</Trans>
           </toast.Text>
           {!disableUndo && (
             <toast.Action
···
         <toast.Outer>
           <toast.Icon icon={TrashIcon} />
           <toast.Text>
-            <Trans>Removed from saved skeets</Trans>
+            <Trans>{_(getTerminology(terminologyPreference, {
+              skeet: msg`Removed from saved skeets`,
+              post: msg`Removed from saved posts`,
+              spell: msg`Removed from saved spells`,
+            }))}</Trans>
           </toast.Text>
           {!disableUndo && (
             <toast.Action
···
       big={big}
       label={
         isBookmarked
-          ? _(msg`Remove from saved skeets`)
-          : _(msg`Add to saved skeets`)
+          ? _(getTerminology(terminologyPreference, {
+              skeet: msg`Remove from saved skeets`,
+              post: msg`Remove from saved posts`,
+              spell: msg`Remove from saved spells`,
+            }))
+          : _(getTerminology(terminologyPreference, {
+              skeet: msg`Add to saved skeets`,
+              post: msg`Add to saved posts`,
+              spell: msg`Add to saved spells`,
+            }))
       }
       onPress={onHandlePress}
       hitSlop={hitSlop}>

src/components/PostControls/PostMenu/PostMenuItems.tsx

···
 import {useFeedFeedbackContext} from '#/state/feed-feedback'
 import {useLanguagePrefs} from '#/state/preferences'
 import {useHiddenPosts, useHiddenPostsApi} from '#/state/preferences'
+import {useTerminology} from '#/lib/hooks/useTerminology'
 import {usePinnedPostMutation} from '#/state/queries/pinned-post'
 import {
   usePostDeleteMutation,
···
     postUri: post.uri,
     rootPostUri: rootUri,
   })
+  const terminology = useTerminology()
 
   const href = useMemo(() => {
     const urip = new AtUri(postUri)
···
   const onDeletePost = () => {
     deletePostMutate({uri: postUri}).then(
       () => {
-        Toast.show(_(msg({message: 'Skeet deleted', context: 'toast'})))
+        Toast.show(_(msg({message: `${_(terminology.post)} deleted`, context: 'toast'})))
 
         const route = getCurrentRoute(navigation.getState())
         if (route.name === 'PostThread') {
···
       },
       e => {
         logger.error('Failed to delete post', {message: e})
-        Toast.show(_(msg`Failed to delete skeet, please try again`), 'xmark')
+        Toast.show(_(msg`Failed to delete ${_(terminology.post)}, please try again`), 'xmark')
       },
     )
   }
···
       })
       Toast.show(
         isDetach
-          ? _(msg`Quote skeet was successfully detached`)
-          : _(msg`Quote skeet was re-attached`),
+          ? _(msg`Quote ${_(terminology.post)} was successfully detached`)
+          : _(msg`Quote ${_(terminology.post)} was re-attached`),
       )
     } catch (e: any) {
       Toast.show(
···
     <>
       <Prompt.Basic
         control={redraftPromptControl}
-        title={_(msg`Redraft this skeet?`)}
+        title={_(msg`Redraft this ${_(terminology.post)}?`)}
         description={_(
-          msg`This will delete the original skeet and open the composer with its content.`,
+          msg`This will delete the original ${_(terminology.post)} and open the composer with its content.`,
         )}
         onConfirm={onConfirmRedraft}
         confirmButtonCta={_(msg`Redraft`)}
···
 
               <Menu.Item
                 testID="postDropdownCopyTextBtn"
-                label={_(msg`Copy post text`)}
+                label={_(msg`Copy ${_(terminology.post)} text`)}
                 onPress={onCopyPostText}>
-                <Menu.ItemText>{_(msg`Copy skeet text`)}</Menu.ItemText>
+                <Menu.ItemText>{_(msg`Copy ${_(terminology.post)} text`)}</Menu.ItemText>
                 <Menu.ItemIcon icon={ClipboardIcon} position="right" />
               </Menu.Item>
             </>
           ) : (
             <Menu.Item
               testID="postDropdownSignInBtn"
-              label={_(msg`Sign in to view skeet`)}
+              label={_(msg`Sign in to view ${_(terminology.post)}`)}
               onPress={onSignIn}>
-              <Menu.ItemText>{_(msg`Sign in to view skeet`)}</Menu.ItemText>
+              <Menu.ItemText>{_(msg`Sign in to view ${_(terminology.post)}`)}</Menu.ItemText>
               <Menu.ItemIcon icon={Eye} position="right" />
             </Menu.Item>
           )}
···
                     label={
                       isReply
                         ? _(msg`Hide reply for me`)
-                        : _(msg`Hide skeet for me`)
+                        : _(msg`Hide ${_(terminology.post)} for me`)
                     }
                     onPress={() => hidePromptControl.open()}>
                     <Menu.ItemText>
                       {isReply
                         ? _(msg`Hide reply for me`)
-                        : _(msg`Hide skeet for me`)}
+                        : _(msg`Hide ${_(terminology.post)} for me`)}
                     </Menu.ItemText>
                     <Menu.ItemIcon icon={EyeSlash} position="right" />
                   </Menu.Item>
···
 
                   <Menu.Item
                     testID="postDropdownReportBtn"
-                    label={_(msg`Report skeet`)}
+                    label={_(msg`Report ${_(terminology.post)}`)}
                     onPress={() => reportDialogControl.open()}>
-                    <Menu.ItemText>{_(msg`Report skeet`)}</Menu.ItemText>
+                    <Menu.ItemText>{_(msg`Report ${_(terminology.post)}`)}</Menu.ItemText>
                     <Menu.ItemIcon icon={Warning} position="right" />
                   </Menu.Item>
                 </>
···
                   </Menu.Item>
                   <Menu.Item
                     testID="postDropdownDeleteBtn"
-                    label={_(msg`Delete post`)}
+                    label={_(msg`Delete ${_(terminology.post)}`)}
                     onPress={() => deletePromptControl.open()}>
-                    <Menu.ItemText>{_(msg`Delete skeet`)}</Menu.ItemText>
+                    <Menu.ItemText>{_(msg`Delete ${_(terminology.post)}`)}</Menu.ItemText>
                     <Menu.ItemIcon icon={Trash} position="right" />
                   </Menu.Item>
                 </>
···
 
       <Prompt.Basic
         control={deletePromptControl}
-        title={_(msg`Delete this skeet?`)}
+        title={_(msg`Delete this ${_(terminology.post)}?`)}
         description={_(
-          msg`If you remove this skeet, you won't be able to recover it.`,
+          msg`If you remove this ${_(terminology.post)}, you won't be able to recover it.`,
         )}
         onConfirm={onDeletePost}
         confirmButtonCta={_(msg`Delete`)}
···
 
       <Prompt.Basic
         control={hidePromptControl}
-        title={isReply ? _(msg`Hide this reply?`) : _(msg`Hide this skeet?`)}
+        title={isReply ? _(msg`Hide this reply?`) : _(msg`Hide this ${_(terminology.post)}?`)}
         description={_(
-          msg`This skeet will be hidden from feeds and threads. This cannot be undone.`,
+          msg`This ${_(terminology.post)} will be hidden from feeds and threads. This cannot be undone.`,
         )}
         onConfirm={onHidePost}
         confirmButtonCta={_(msg`Hide`)}
···
 
       <Prompt.Basic
         control={quotePostDetachConfirmControl}
-        title={_(msg`Detach quote skeet?`)}
+        title={_(msg`Detach quote ${_(terminology.post)}?`)}
         description={_(
-          msg`This will remove your skeet from this quote skeet for all users, and replace it with a placeholder.`,
+          msg`This will remove your ${_(terminology.post)} from this quote ${_(terminology.post)} for all users, and replace it with a placeholder.`,
         )}
         onConfirm={onToggleQuotePostAttachment}
         confirmButtonCta={_(msg`Yes, detach`)}

src/components/PostControls/PostMenu/index.tsx

···
 import {useLingui} from '@lingui/react'
 
 import {type Shadow} from '#/state/cache/post-shadow'
+import {useTerminology} from '#/lib/hooks/useTerminology'
 import {EventStopper} from '#/view/com/util/EventStopper'
 import {DotGrid_Stroke2_Corner0_Rounded as DotsHorizontal} from '#/components/icons/DotGrid'
 import {useMenuControl} from '#/components/Menu'
···
   hitSlop?: Insets
 }): React.ReactNode => {
   const {_} = useLingui()
+  const terminology = useTerminology()
 
   const menuControl = useMenuControl()
   const [hasBeenOpen, setHasBeenOpen] = useState(false)
···
   return (
     <EventStopper onKeyDown={false}>
       <Menu.Root control={lazyMenuControl}>
-        <Menu.Trigger label={_(msg`Open skeet options menu`)}>
+        <Menu.Trigger label={_(msg`Open ${_(terminology.post)} options menu`)}>
           {({props}) => {
             return (
               <PostControlButton

src/components/PostControls/RepostButton.tsx

···
 import {useLingui} from '@lingui/react'
 
 import {useHaptics} from '#/lib/haptics'
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {useRequireAuth} from '#/state/session'
 import {atoms as a, useTheme} from '#/alf'
 import {Button, ButtonText} from '#/components/Button'
···
 }: Props): React.ReactNode => {
   const t = useTheme()
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const requireAuth = useRequireAuth()
   const dialogControl = Dialog.useDialogControl()
   const formatPostStatCount = useFormatPostStatCount()
···
 }): React.ReactNode => {
   const t = useTheme()
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const playHaptic = useHaptics()
   const control = Dialog.useDialogContext()
 
···
   const onPressClose = useCallback(() => control.close(), [control])
 
   return (
-    <Dialog.ScrollableInner label={_(msg`Reskeet or quote skeet`)}>
+    <Dialog.ScrollableInner label={_(getTerminology(terminologyPreference, {
+      skeet: msg`Reskeet or quote skeet`,
+      post: msg`Repost or quote post`,
+      spell: msg`Respell or quote spell`,
+    }))}>
       <View style={a.gap_xl}>
         <View style={a.gap_xs}>
           <Button
             style={[a.justify_start, a.px_md, a.gap_sm]}
             label={
               isReposted
-                ? _(msg`Remove reskeet`)
-                : _(msg({message: `Reskeet`, context: 'action'}))
+                ? _(getTerminology(terminologyPreference, {
+                    skeet: msg`Remove reskeet`,
+                    post: msg`Remove repost`,
+                    spell: msg`Remove respell`,
+                  }))
+                : _(getTerminology(terminologyPreference, {
+                    skeet: msg({message: `Reskeet`, context: 'action'}),
+                    post: msg({message: `Repost`, context: 'action'}),
+                    spell: msg({message: `Respell`, context: 'action'}),
+                  }))
             }
             onPress={onPressRepost}
             size="large"
···
             <RepostIcon size="lg" fill={t.palette.primary_500} />
             <Text style={[a.font_semi_bold, a.text_xl]}>
               {isReposted ? (
-                <Trans>Remove reskeet</Trans>
+                <Trans>{_(getTerminology(terminologyPreference, {
+                  skeet: msg`Remove reskeet`,
+                  post: msg`Remove repost`,
+                  spell: msg`Remove respell`,
+                }))}</Trans>
               ) : (
-                <Trans context="action">Reskeet</Trans>
+                <Trans>{_(getTerminology(terminologyPreference, {
+                  skeet: msg({message: `Reskeet`, context: 'action'}),
+                  post: msg({message: `Repost`, context: 'action'}),
+                  spell: msg({message: `Respell`, context: 'action'}),
+                }))}</Trans>
               )}
             </Text>
           </Button>
···
             style={[a.justify_start, a.px_md, a.gap_sm]}
             label={
               embeddingDisabled
-                ? _(msg`Quote skeets disabled`)
-                : _(msg`Quote skeet`)
+                ? _(getTerminology(terminologyPreference, {
+                    skeet: msg`Quote skeets disabled`,
+                    post: msg`Quote posts disabled`,
+                    spell: msg`Quote spells disabled`,
+                  }))
+                : _(getTerminology(terminologyPreference, {
+                    skeet: msg`Quote skeet`,
+                    post: msg`Quote post`,
+                    spell: msg`Quote spell`,
+                  }))
             }
             onPress={onPressQuote}
             size="large"
···
                 embeddingDisabled && t.atoms.text_contrast_low,
               ]}>
               {embeddingDisabled ? (
-                <Trans>Quote skeets disabled</Trans>
+                <Trans>{_(getTerminology(terminologyPreference, {
+                  skeet: msg`Quote skeets disabled`,
+                  post: msg`Quote posts disabled`,
+                  spell: msg`Quote spells disabled`,
+                }))}</Trans>
               ) : (
-                <Trans>Quote skeet</Trans>
+                <Trans>{_(getTerminology(terminologyPreference, {
+                  skeet: msg`Quote skeet`,
+                  post: msg`Quote post`,
+                  spell: msg`Quote spell`,
+                }))}</Trans>
               )}
             </Text>
           </Button>
         </View>
         <Button
-          label={_(msg`Cancel quote skeet`)}
+          label={_(getTerminology(terminologyPreference, {
+            skeet: msg`Cancel quote skeet`,
+            post: msg`Cancel quote post`,
+            spell: msg`Cancel quote spell`,
+          }))}
           onPress={onPressClose}
           size="large"
           color="secondary">

src/components/PostControls/RepostButton.web.tsx

···
 import {msg} from '@lingui/macro'
 import {useLingui} from '@lingui/react'
 
+import {getTerminology} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {useRequireAuth} from '#/state/session'
 import {useSession} from '#/state/session'
 import {EventStopper} from '#/view/com/util/EventStopper'
···
 }: Props) => {
   const t = useTheme()
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const {hasSession} = useSession()
   const requireAuth = useRequireAuth()
   const formatPostStatCount = useFormatPostStatCount()
···
   return hasSession ? (
     <EventStopper onKeyDown={false}>
       <Menu.Root>
-        <Menu.Trigger label={_(msg`Repost or quote post`)}>
+        <Menu.Trigger label={_(getTerminology(terminologyPreference, {
+          skeet: msg`Reskeet or quote skeet`,
+          post: msg`Repost or quote post`,
+          spell: msg`Respell or quote spell`,
+        }))}>
           {({props}) => {
             return (
               <PostControlButton
···
           <Menu.Item
             label={
               isReposted
-                ? _(msg`Undo reskeet`)
-                : _(msg({message: `Reskeet`, context: `action`}))
+                ? _(getTerminology(terminologyPreference, {
+                    skeet: msg`Undo reskeet`,
+                    post: msg`Undo repost`,
+                    spell: msg`Undo respell`,
+                  }))
+                : _(getTerminology(terminologyPreference, {
+                    skeet: msg({message: `Reskeet`, context: `action`}),
+                    post: msg({message: `Repost`, context: `action`}),
+                    spell: msg({message: `Respell`, context: `action`}),
+                  }))
             }
             testID="repostDropdownRepostBtn"
             onPress={onRepost}>
             <Menu.ItemText>
               {isReposted
-                ? _(msg`Undo reskeet`)
-                : _(msg({message: `Reskeet`, context: `action`}))}
+                ? _(getTerminology(terminologyPreference, {
+                    skeet: msg`Undo reskeet`,
+                    post: msg`Undo repost`,
+                    spell: msg`Undo respell`,
+                  }))
+                : _(getTerminology(terminologyPreference, {
+                    skeet: msg({message: `Reskeet`, context: `action`}),
+                    post: msg({message: `Repost`, context: `action`}),
+                    spell: msg({message: `Respell`, context: `action`}),
+                  }))}
             </Menu.ItemText>
             <Menu.ItemIcon icon={Repost} position="right" />
           </Menu.Item>
···
             disabled={embeddingDisabled}
             label={
               embeddingDisabled
-                ? _(msg`Quote skeets disabled`)
-                : _(msg`Quote skeet`)
+                ? _(getTerminology(terminologyPreference, {
+                    skeet: msg`Quote skeets disabled`,
+                    post: msg`Quote posts disabled`,
+                    spell: msg`Quote spells disabled`,
+                  }))
+                : _(getTerminology(terminologyPreference, {
+                    skeet: msg`Quote skeet`,
+                    post: msg`Quote post`,
+                    spell: msg`Quote spell`,
+                  }))
             }
             testID="repostDropdownQuoteBtn"
             onPress={onQuote}>
             <Menu.ItemText>
               {embeddingDisabled
-                ? _(msg`Quote skeets disabled`)
-                : _(msg`Quote skeet`)}
+                ? _(getTerminology(terminologyPreference, {
+                    skeet: msg`Quote skeets disabled`,
+                    post: msg`Quote posts disabled`,
+                    spell: msg`Quote spells disabled`,
+                  }))
+                : _(getTerminology(terminologyPreference, {
+                    skeet: msg`Quote skeet`,
+                    post: msg`Quote post`,
+                    spell: msg`Quote spell`,
+                  }))}
             </Menu.ItemText>
             <Menu.ItemIcon icon={Quote} position="right" />
           </Menu.Item>
···
       onPress={() => requireAuth(() => {})}
       active={isReposted}
       activeColor={t.palette.positive_500}
-      label={_(msg`Reskeet or quote skeet`)}
+      label={_(getTerminology(terminologyPreference, {
+        skeet: msg`Reskeet or quote skeet`,
+        post: msg`Repost or quote post`,
+        spell: msg`Respell or quote spell`,
+      }))}
       big={big}>
       <PostControlButtonIcon icon={Repost} />
       {typeof repostCount !== 'undefined' && repostCount > 0 && (

src/components/PostControls/ShareMenu/ShareMenuItems.tsx

···
 import {makeProfileLink} from '#/lib/routes/links'
 import {type NavigationProp} from '#/lib/routes/types'
 import {shareText, shareUrl} from '#/lib/sharing'
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
 import {toShareUrl, toShareUrlBsky} from '#/lib/strings/url-helpers'
 import {logger} from '#/logger'
 import {isIOS} from '#/platform/detection'
 import {useProfileShadow} from '#/state/cache/profile-shadow'
+import {useTerminologyPreference} from '#/state/preferences'
 import {useShowExternalShareButtons} from '#/state/preferences/external-share-buttons'
 import {useSession} from '#/state/session'
 import * as Toast from '#/view/com/util/Toast'
···
 }: ShareMenuItemsProps): React.ReactNode => {
   const {hasSession} = useSession()
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const navigation = useNavigation<NavigationProp>()
   const sendViaChatControl = useDialogControl()
   const [devModeEnabled] = useDevMode()
···
             {isBridgedPost && (
               <Menu.Item
                 testID="postDropdownOpenOriginalPost"
-                label={_(msg`Open original post`)}
+                label={_(getTerminology(terminologyPreference, {
+                  skeet: msg`Open original skeet`,
+                  post: msg`Open original post`,
+                  spell: msg`Open original spell`,
+                }))}
                 onPress={onOpenOriginalPost}>
                 <Menu.ItemText>
-                  <Trans>Open original skeet</Trans>
+                  <Trans>{_(getTerminology(terminologyPreference, {
+                    skeet: msg`Open original skeet`,
+                    post: msg`Open original post`,
+                    spell: msg`Open original spell`,
+                  }))}</Trans>
                 </Menu.ItemText>
                 <Menu.ItemIcon icon={ExternalIcon} position="right" />
               </Menu.Item>
···
 
             <Menu.Item
               testID="postDropdownOpenInPdsls"
-              label={_(msg`Open post in PDSls`)}
+              label={_(getTerminology(terminologyPreference, {
+                skeet: msg`Open skeet in PDSls`,
+                post: msg`Open post in PDSls`,
+                spell: msg`Open spell in PDSls`,
+              }))}
               onPress={onOpenPostInPdsls}>
               <Menu.ItemText>
-                <Trans>Open skeet in PDSls</Trans>
+                <Trans>{_(getTerminology(terminologyPreference, {
+                  skeet: msg`Open skeet in PDSls`,
+                  post: msg`Open post in PDSls`,
+                  spell: msg`Open spell in PDSls`,
+                }))}</Trans>
               </Menu.ItemText>
               <Menu.ItemIcon icon={ExternalIcon} position="right" />
             </Menu.Item>
···
 
           <Menu.Item
             testID="postDropdownShareBtn"
-            label={_(msg`Copy link to post`)}
+            label={_(getTerminology(terminologyPreference, {
+              skeet: msg`Copy link to skeet`,
+              post: msg`Copy link to post`,
+              spell: msg`Copy link to spell`,
+            }))}
             onPress={onCopyLink}>
             <Menu.ItemText>
-              <Trans>Copy link to skeet</Trans>
+              <Trans>{_(getTerminology(terminologyPreference, {
+                skeet: msg`Copy link to skeet`,
+                post: msg`Copy link to post`,
+                spell: msg`Copy link to spell`,
+              }))}</Trans>
             </Menu.ItemText>
             <Menu.ItemIcon icon={ChainLinkIcon} position="right" />
           </Menu.Item>
···
               <Admonition
                 type="warning"
                 style={[a.flex_1, a.border_0, a.p_0, a.bg_transparent]}>
-                <Trans>This skeet is only visible to logged-in users.</Trans>
+                <Trans>{_(getTerminology(terminologyPreference, {
+                  skeet: msg`This skeet is only visible to logged-in users.`,
+                  post: msg`This post is only visible to logged-in users.`,
+                  spell: msg`This spell is only visible to logged-in users.`,
+                }))}</Trans>
               </Admonition>
             </Menu.ContainerItem>
           </Menu.Group>
···
           <Menu.Group>
             <Menu.Item
               testID="postAtUriShareBtn"
-              label={_(msg`Share post at:// URI`)}
+              label={_(getTerminology(terminologyPreference, {
+                skeet: msg`Share skeet at:// URI`,
+                post: msg`Share post at:// URI`,
+                spell: msg`Share spell at:// URI`,
+              }))}
               onPress={onShareATURI}>
               <Menu.ItemText>
-                <Trans>Share skeet at:// URI</Trans>
+                <Trans>{_(getTerminology(terminologyPreference, {
+                  skeet: msg`Share skeet at:// URI`,
+                  post: msg`Share post at:// URI`,
+                  spell: msg`Share spell at:// URI`,
+                }))}</Trans>
               </Menu.ItemText>
               <Menu.ItemIcon icon={ClipboardIcon} position="right" />
             </Menu.Item>

src/components/PostControls/ShareMenu/ShareMenuItems.web.tsx

···
 import {makeProfileLink} from '#/lib/routes/links'
 import {type NavigationProp} from '#/lib/routes/types'
 import {shareText, shareUrl} from '#/lib/sharing'
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
 import {toShareUrl, toShareUrlBsky} from '#/lib/strings/url-helpers'
 import {logger} from '#/logger'
 import {isWeb} from '#/platform/detection'
 import {useProfileShadow} from '#/state/cache/profile-shadow'
+import {useTerminologyPreference} from '#/state/preferences'
 import {useShowExternalShareButtons} from '#/state/preferences/external-share-buttons'
 import {useSession} from '#/state/session'
 import {useBreakpoints} from '#/alf'
···
   const {hasSession} = useSession()
   const {gtMobile} = useBreakpoints()
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const navigation = useNavigation<NavigationProp>()
   const embedPostControl = useDialogControl()
   const sendViaChatControl = useDialogControl()
···
     <Menu.Group>
       <Menu.Item
         testID="postDropdownShareBtn"
-        label={_(msg`Copy link to post`)}
+        label={_(getTerminology(terminologyPreference, {
+          skeet: msg`Copy link to skeet`,
+          post: msg`Copy link to post`,
+          spell: msg`Copy link to spell`,
+        }))}
         onPress={onCopyLink}>
         <Menu.ItemText>
-          <Trans>Copy link to skeet</Trans>
+          <Trans>{_(getTerminology(terminologyPreference, {
+            skeet: msg`Copy link to skeet`,
+            post: msg`Copy link to post`,
+            spell: msg`Copy link to spell`,
+          }))}</Trans>
         </Menu.ItemText>
         <Menu.ItemIcon icon={ChainLinkIcon} position="right" />
       </Menu.Item>
···
         {showExternalShareButtons && isBridgedPost && (
           <Menu.Item
             testID="postDropdownOpenOriginalPost"
-            label={_(msg`Open original post`)}
+            label={_(getTerminology(terminologyPreference, {
+              skeet: msg`Open original skeet`,
+              post: msg`Open original post`,
+              spell: msg`Open original spell`,
+            }))}
             onPress={onOpenOriginalPost}>
             <Menu.ItemText>
-              <Trans>Open original skeet</Trans>
+              <Trans>{_(getTerminology(terminologyPreference, {
+                skeet: msg`Open original skeet`,
+                post: msg`Open original post`,
+                spell: msg`Open original spell`,
+              }))}</Trans>
             </Menu.ItemText>
             <Menu.ItemIcon icon={ExternalIcon} position="right" />
           </Menu.Item>
···
         {showExternalShareButtons && (
           <Menu.Item
             testID="postDropdownOpenInPdsls"
-            label={_(msg`Open post in PDSls`)}
+            label={_(getTerminology(terminologyPreference, {
+              skeet: msg`Open skeet in PDSls`,
+              post: msg`Open post in PDSls`,
+              spell: msg`Open spell in PDSls`,
+            }))}
             onPress={onOpenPostInPdsls}>
             <Menu.ItemText>
-              <Trans>Open skeet in PDSls</Trans>
+              <Trans>{_(getTerminology(terminologyPreference, {
+                skeet: msg`Open skeet in PDSls`,
+                post: msg`Open post in PDSls`,
+                spell: msg`Open spell in PDSls`,
+              }))}</Trans>
             </Menu.ItemText>
             <Menu.ItemIcon icon={ExternalIcon} position="right" />
           </Menu.Item>
···
         {canEmbed && (
           <Menu.Item
             testID="postDropdownEmbedBtn"
-            label={_(msg`Embed post`)}
+            label={_(getTerminology(terminologyPreference, {
+              skeet: msg`Embed skeet`,
+              post: msg`Embed post`,
+              spell: msg`Embed spell`,
+            }))}
             onPress={() => {
               logger.metric('share:press:embed', {}, {statsig: true})
               embedPostControl.open()
             }}>
-            <Menu.ItemText>{_(msg`Embed skeet`)}</Menu.ItemText>
+            <Menu.ItemText>{_(getTerminology(terminologyPreference, {
+              skeet: msg`Embed skeet`,
+              post: msg`Embed post`,
+              spell: msg`Embed spell`,
+            }))}</Menu.ItemText>
             <Menu.ItemIcon icon={CodeBracketsIcon} position="right" />
           </Menu.Item>
         )}
···
             {hasSession && <Menu.Divider />}
             {copyLinkItem}
             <Menu.LabelText style={{maxWidth: 220}}>
-              <Trans>
-                Note: This skeet is only visible to logged-in users.
-              </Trans>
+              <Trans>{_(getTerminology(terminologyPreference, {
+                skeet: msg`Note: This skeet is only visible to logged-in users.`,
+                post: msg`Note: This post is only visible to logged-in users.`,
+                spell: msg`Note: This spell is only visible to logged-in users.`,
+              }))}</Trans>
             </Menu.LabelText>
           </>
         )}
···
             <Menu.Divider />
             <Menu.Item
               testID="postAtUriShareBtn"
-              label={_(msg`Copy post at:// URI`)}
+              label={_(getTerminology(terminologyPreference, {
+                skeet: msg`Copy skeet at:// URI`,
+                post: msg`Copy post at:// URI`,
+                spell: msg`Copy spell at:// URI`,
+              }))}
               onPress={onShareATURI}>
               <Menu.ItemText>
-                <Trans>Copy skeet at:// URI</Trans>
+                <Trans>{_(getTerminology(terminologyPreference, {
+                  skeet: msg`Copy skeet at:// URI`,
+                  post: msg`Copy post at:// URI`,
+                  spell: msg`Copy spell at:// URI`,
+                }))}</Trans>
               </Menu.ItemText>
               <Menu.ItemIcon icon={ClipboardIcon} position="right" />
             </Menu.Item>

src/components/WhoCanReply.tsx

···
 
 import {HITSLOP_10} from '#/lib/constants'
 import {makeListLink, makeProfileLink} from '#/lib/routes/links'
+import {getTerminology} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {logger} from '#/logger'
 import {isNative} from '#/platform/detection'
 import {
···
   embeddingDisabled: boolean
 }) {
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
 
   return (
     <Dialog.Outer control={control} nativeOptions={{preventExpansion: true}}>
···
         style={web({maxWidth: 400})}>
         <View style={[a.gap_sm]}>
           <Text style={[a.font_semi_bold, a.text_xl, a.pb_sm]}>
-            <Trans>Who can interact with this skeet?</Trans>
+            <Trans>{_(getTerminology(terminologyPreference, {
+              skeet: msg`Who can interact with this skeet?`,
+              post: msg`Who can interact with this post?`,
+              spell: msg`Who can interact with this spell?`,
+            }))}</Trans>
           </Text>
           <Rules
             post={post}
···
   embeddingDisabled: boolean
 }) {
   const t = useTheme()
+  const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
 
   return (
     <>
···
           t.atoms.text_contrast_medium,
         ]}>
         {settings.length === 0 ? (
-          <Trans>
-            This skeet has an unknown type of threadgate on it. Your app may be
-            out of date.
-          </Trans>
+          <Trans>{_(getTerminology(terminologyPreference, {
+            skeet: msg`This skeet has an unknown type of threadgate on it. Your app may be out of date.`,
+            post: msg`This post has an unknown type of threadgate on it. Your app may be out of date.`,
+            spell: msg`This spell has an unknown type of threadgate on it. Your app may be out of date.`,
+          }))}</Trans>
         ) : settings[0].type === 'everybody' ? (
-          <Trans>Everybody can reply to this skeet.</Trans>
+          <Trans>{_(getTerminology(terminologyPreference, {
+            skeet: msg`Everybody can reply to this skeet.`,
+            post: msg`Everybody can reply to this post.`,
+            spell: msg`Everybody can reply to this spell.`,
+          }))}</Trans>
         ) : settings[0].type === 'nobody' ? (
-          <Trans>Replies to this skeet are disabled.</Trans>
+          <Trans>{_(getTerminology(terminologyPreference, {
+            skeet: msg`Replies to this skeet are disabled.`,
+            post: msg`Replies to this post are disabled.`,
+            spell: msg`Replies to this spell are disabled.`,
+          }))}</Trans>
         ) : (
           <Trans>
             Only{' '}
···
             a.flex_wrap,
             t.atoms.text_contrast_medium,
           ]}>
-          <Trans>No one but the author can quote this skeet.</Trans>
+          <Trans>{_(getTerminology(terminologyPreference, {
+            skeet: msg`No one but the author can quote this skeet.`,
+            post: msg`No one but the author can quote this post.`,
+            spell: msg`No one but the author can quote this spell.`,
+          }))}</Trans>
         </Text>
       )}
     </>

src/components/dialogs/Embed.tsx

···
 
 import {EMBED_SCRIPT} from '#/lib/constants'
 import {niceDate} from '#/lib/strings/time'
+import {getTerminology} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {toShareUrl} from '#/lib/strings/url-helpers'
 import {atoms as a, useTheme} from '#/alf'
 import {Button, ButtonIcon, ButtonText} from '#/components/Button'
···
 }: Omit<EmbedDialogProps, 'control'>) {
   const t = useTheme()
   const {_, i18n} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const [copied, setCopied] = useState(false)
   const [showCustomisation, setShowCustomisation] = useState(false)
   const [colorMode, setColorMode] = useState<ColorModeValues>('system')
···
   }, [i18n, postUri, postCid, record, timestamp, postAuthor, colorMode])
 
   return (
-    <Dialog.Inner label={_(msg`Embed post`)} style={[{maxWidth: 500}]}>
+    <Dialog.Inner label={_(getTerminology(terminologyPreference, {
+      skeet: msg`Embed skeet`,
+      post: msg`Embed post`,
+      spell: msg`Embed spell`,
+    }))} style={[{maxWidth: 500}]}>
       <View style={[a.gap_lg]}>
         <View style={[a.gap_sm]}>
           <Text style={[a.text_2xl, a.font_bold]}>
-            <Trans>Embed skeet</Trans>
+            <Trans>{_(getTerminology(terminologyPreference, {
+              skeet: msg`Embed skeet`,
+              post: msg`Embed post`,
+              spell: msg`Embed spell`,
+            }))}</Trans>
           </Text>
           <Text
             style={[a.text_md, t.atoms.text_contrast_medium, a.leading_normal]}>
-            <Trans>
-              Embed this skeet in your website. Simply copy the following snippet
-              and paste it into the HTML code of your website.
-            </Trans>
+            <Trans>{_(getTerminology(terminologyPreference, {
+              skeet: msg`Embed this skeet in your website. Simply copy the following snippet and paste it into the HTML code of your website.`,
+              post: msg`Embed this post in your website. Simply copy the following snippet and paste it into the HTML code of your website.`,
+              spell: msg`Embed this spell in your website. Simply copy the following snippet and paste it into the HTML code of your website.`,
+            }))}</Trans>
           </Text>
         </View>
         <View

src/lib/api/index.ts

···
 
 import {isNetworkError} from '#/lib/strings/errors'
 import {parseMarkdownLinks,shortenLinks, stripInvalidMentions} from '#/lib/strings/rich-text-manip'
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
 import {logger} from '#/logger'
 import {compressImage} from '#/state/gallery'
 import {
···
   replyTo?: string
   onStateChange?: (state: string) => void
   langs?: string[]
+  terminologyPreference?: string
 }
 
 export async function post(
···
     })
     if (isNetworkError(e)) {
       throw new Error(
-        t`Skeet failed to upload. Please check your Internet connection and try again.`,
+        getTerminology(opts.terminologyPreference || 'skeet', TERMINOLOGY.uploadFailed),
       )
     } else {
       throw e

src/lib/hooks/useTerminology.ts

···
+import {useMemo} from 'react'
+import {defineMessage} from '@lingui/macro'
+
+import {useTerminologyPreference} from '#/state/preferences'
+
+export type TerminologyKey =
+  | 'post'
+  | 'posts'
+  | 'repost'
+  | 'reposts'
+  | 'reposted'
+  | 'reposting'
+
+const terminologyMap = {
+  skeet: {
+    post: defineMessage({message: 'skeet'}),
+    posts: defineMessage({message: 'skeets'}),
+    repost: defineMessage({message: 'reskeet'}),
+    reposts: defineMessage({message: 'reskeets'}),
+    reposted: defineMessage({message: 'reskeeted'}),
+    reposting: defineMessage({message: 'reskeeting'}),
+  },
+  post: {
+    post: defineMessage({message: 'post'}),
+    posts: defineMessage({message: 'posts'}),
+    repost: defineMessage({message: 'repost'}),
+    reposts: defineMessage({message: 'reposts'}),
+    reposted: defineMessage({message: 'reposted'}),
+    reposting: defineMessage({message: 'reposting'}),
+  },
+  spell: {
+    post: defineMessage({message: 'spell'}),
+    posts: defineMessage({message: 'spells'}),
+    repost: defineMessage({message: 'respell'}),
+    reposts: defineMessage({message: 'respells'}),
+    reposted: defineMessage({message: 'respelled'}),
+    reposting: defineMessage({message: 'respelling'}),
+  },
+}
+
+/**
+ * Hook to get the correct terminology based on user preference
+ * @returns An object with all terminology variants
+ */
+export function useTerminology() {
+  const preference = useTerminologyPreference()
+  
+  return useMemo(() => {
+    const selectedTerminology = preference || 'skeet'
+    return terminologyMap[selectedTerminology]
+  }, [preference])
+}
+
+/**
+ * Hook to get a specific terminology term
+ * @param key - The terminology key to retrieve
+ * @returns The localized terminology message
+ */
+export function useTerm(key: TerminologyKey) {
+  const terminology = useTerminology()
+  return terminology[key]
+}

src/lib/strings/terminology.ts

···
+import {msg} from '@lingui/macro'
+
+export type TerminologyPreference = 'skeet' | 'post' | 'spell'
+
+/**
+ * Returns the appropriate terminology based on the user's preference
+ * @param preference - The user's terminology preference ('skeet', 'post', or 'spell')
+ * @param variants - An object with message descriptors for each terminology option
+ * @returns The appropriate message descriptor based on the preference
+ */
+export function getTerminology<T extends {skeet: any; post: any; spell: any}>(
+  preference: TerminologyPreference | undefined,
+  variants: T,
+): T[keyof T] {
+  const pref = preference ?? 'skeet'
+  return variants[pref]
+}
+
+/**
+ * Common terminology variants used throughout the app
+ */
+export const TERMINOLOGY = {
+  // Single post
+  singular: {
+    skeet: msg`skeet`,
+    post: msg`post`,
+    spell: msg`spell`,
+  },
+  // Multiple posts
+  plural: {
+    skeet: msg`skeets`,
+    post: msg`posts`,
+    spell: msg`spells`,
+  },
+  // "Skeet by @handle"
+  byHandle: (handle: string) => ({
+    skeet: msg`Skeet by @${handle}`,
+    post: msg`Post by @${handle}`,
+    spell: msg`Spell by @${handle}`,
+  }),
+  // Repost terminology
+  repost: {
+    singular: {
+      skeet: msg`reskeet`,
+      post: msg`repost`,
+      spell: msg`respell`,
+    },
+    plural: {
+      skeet: msg`reskeets`,
+      post: msg`reposts`,
+      spell: msg`respells`,
+    },
+    pastTense: {
+      skeet: msg`reskeeted`,
+      post: msg`reposted`,
+      spell: msg`respelled`,
+    },
+    byLine: {
+      skeet: msg`Reskeeted By`,
+      post: msg`Reposted By`,
+      spell: msg`Respelled By`,
+    },
+    action: {
+      skeet: msg`reskeet`,
+      post: msg`repost`,
+      spell: msg`respell`,
+    },
+  },
+  // For metrics/counts
+  metrics: {
+    skeet: msg`skeets metrics`,
+    post: msg`posts metrics`,
+    spell: msg`spells metrics`,
+  },
+  // For carousel
+  carousel: {
+    skeet: msg`Combine reskeets into a horizontal carousel`,
+    post: msg`Combine reposts into a horizontal carousel`,
+    spell: msg`Combine respells into a horizontal carousel`,
+  },
+  // For notifications
+  viaRepostNotification: {
+    skeet: msg`Disable "via reskeet" notifications`,
+    post: msg`Disable "via repost" notifications`,
+    spell: msg`Disable "via respell" notifications`,
+  },
+  viaRepostPrivacy: {
+    skeet: msg`Forcefully disables the notifications other people receive when you like/reskeet a skeet someone else has reskeeted for privacy.`,
+    post: msg`Forcefully disables the notifications other people receive when you like/repost a post someone else has reposted for privacy.`,
+    spell: msg`Forcefully disables the notifications other people receive when you like/respell a spell someone else has respelled for privacy.`,
+  },
+  // For external share buttons
+  externalShareButtons: {
+    skeet: msg`Show "Open original skeet" and "Open skeet in PDSls" buttons`,
+    post: msg`Show "Open original post" and "Open post in PDSls" buttons`,
+    spell: msg`Show "Open original spell" and "Open spell in PDSls" buttons`,
+  },
+  // For metrics labels
+  repostMetrics: {
+    skeet: msg`Disable reskeets metrics`,
+    post: msg`Disable reposts metrics`,
+    spell: msg`Disable respells metrics`,
+  },
+  // For deletion messages
+  deleted: {
+    skeet: msg`This skeet was deleted by its author`,
+    post: msg`This post was deleted by its author`,
+    spell: msg`This spell was deleted by its author`,
+  },
+  deletedShort: {
+    skeet: msg`Skeet has been deleted`,
+    post: msg`Post has been deleted`,
+    spell: msg`Spell has been deleted`,
+  },
+  // For error messages
+  notFound: {
+    skeet: msg`Skeet not found`,
+    post: msg`Post not found`,
+    spell: msg`Spell not found`,
+  },
+  blocked: {
+    skeet: msg`Skeet blocked`,
+    post: msg`Post blocked`,
+    spell: msg`Spell blocked`,
+  },
+  errorLoading: {
+    skeet: msg`Error loading skeet`,
+    post: msg`Error loading post`,
+    spell: msg`Error loading spell`,
+  },
+  // For success messages
+  sent: {
+    skeet: msg`Your skeet was sent`,
+    post: msg`Your post was sent`,
+    spell: msg`Your spell was sent`,
+  },
+  sentPlural: {
+    skeet: msg`Your skeets were sent`,
+    post: msg`Your posts were sent`,
+    spell: msg`Your spells were sent`,
+  },
+  pinned: {
+    skeet: msg`Skeet pinned`,
+    post: msg`Post pinned`,
+    spell: msg`Spell pinned`,
+  },
+  unpinned: {
+    skeet: msg`Skeet unpinned`,
+    post: msg`Post unpinned`,
+    spell: msg`Spell unpinned`,
+  },
+  failedToPin: {
+    skeet: msg`Failed to pin skeet`,
+    post: msg`Failed to pin post`,
+    spell: msg`Failed to pin spell`,
+  },
+  // For composer
+  addAnother: {
+    skeet: msg`Add another skeet`,
+    post: msg`Add another post`,
+    spell: msg`Add another spell`,
+  },
+  anythingBut: {
+    skeet: msg`Anything but skeet`,
+    post: msg`Anything but post`,
+    spell: msg`Anything but spell`,
+  },
+  delete: {
+    skeet: msg`Delete skeet`,
+    post: msg`Delete post`,
+    spell: msg`Delete spell`,
+  },
+  discard: {
+    skeet: msg`Discard skeet?`,
+    post: msg`Discard post?`,
+    spell: msg`Discard spell?`,
+  },
+  discardConfirm: {
+    skeet: msg`Are you sure you'd like to discard this skeet?`,
+    post: msg`Are you sure you'd like to discard this post?`,
+    spell: msg`Are you sure you'd like to discard this spell?`,
+  },
+  view: {
+    skeet: msg`View skeet`,
+    post: msg`View post`,
+    spell: msg`View spell`,
+  },
+  // For composer actions
+  composeNew: {
+    skeet: msg`Compose new skeet`,
+    post: msg`Compose new post`,
+    spell: msg`Compose new spell`,
+  },
+  newAction: {
+    skeet: msg`New Skeet`,
+    post: msg`New Post`,
+    spell: msg`New Spell`,
+  },
+  postAll: {
+    skeet: msg`Skeet All`,
+    post: msg`Post All`,
+    spell: msg`Spell All`,
+  },
+  postSingle: {
+    skeet: msg`Skeet`,
+    post: msg`Post`,
+    spell: msg`Spell`,
+  },
+  // For language selection
+  selectLanguage: {
+    skeet: msg`Select skeet language`,
+    post: msg`Select post language`,
+    spell: msg`Select spell language`,
+  },
+  chooseLanguages: {
+    skeet: msg`Choose Skeet Languages`,
+    post: msg`Choose Post Languages`,
+    spell: msg`Choose Spell Languages`,
+  },
+  languageDescription: {
+    skeet: msg`Select up to 3 languages used in this skeet`,
+    post: msg`Select up to 3 languages used in this post`,
+    spell: msg`Select up to 3 languages used in this spell`,
+  },
+  replyingLanguage: (langs: string) => ({
+    skeet: msg`The skeet you're replying to was marked as being written in ${langs}`,
+    post: msg`The post you're replying to was marked as being written in ${langs}`,
+    spell: msg`The spell you're replying to was marked as being written in ${langs}`,
+  }),
+  // For interaction settings
+  interactionSettings: {
+    skeet: msg`Skeet interaction settings`,
+    post: msg`Post interaction settings`,
+    spell: msg`Spell interaction settings`,
+  },
+  editInteractionSettings: {
+    skeet: msg`Edit skeet interaction settings`,
+    post: msg`Edit post interaction settings`,
+    spell: msg`Edit spell interaction settings`,
+  },
+  whoCanInteract: {
+    skeet: msg`Who can interact with this skeet?`,
+    post: msg`Who can interact with this post?`,
+    spell: msg`Who can interact with this spell?`,
+  },
+  // For embedding
+  embed: {
+    skeet: msg`Embed skeet`,
+    post: msg`Embed post`,
+    spell: msg`Embed spell`,
+  },
+  embedDescription: {
+    skeet: msg`Embed this skeet in your website. Simply copy the following snippet and paste it into the HTML code of your website.`,
+    post: msg`Embed this post in your website. Simply copy the following snippet and paste it into the HTML code of your website.`,
+    spell: msg`Embed this spell in your website. Simply copy the following snippet and paste it into the HTML code of your website.`,
+  },
+  // For sharing
+  copyLink: {
+    skeet: msg`Copy link to skeet`,
+    post: msg`Copy link to post`,
+    spell: msg`Copy link to spell`,
+  },
+  shareUri: {
+    skeet: msg`Share skeet at:// URI`,
+    post: msg`Share post at:// URI`,
+    spell: msg`Share spell at:// URI`,
+  },
+  copyUri: {
+    skeet: msg`Copy skeet at:// URI`,
+    post: msg`Copy post at:// URI`,
+    spell: msg`Copy spell at:// URI`,
+  },
+  sendTo: {
+    skeet: msg`Send skeet to...`,
+    post: msg`Send post to...`,
+    spell: msg`Send spell to...`,
+  },
+  openOriginal: {
+    skeet: msg`Open original skeet`,
+    post: msg`Open original post`,
+    spell: msg`Open original spell`,
+  },
+  openInPDSls: {
+    skeet: msg`Open skeet in PDSls`,
+    post: msg`Open post in PDSls`,
+    spell: msg`Open spell in PDSls`,
+  },
+  // For reporting
+  report: {
+    skeet: msg`Report this skeet`,
+    post: msg`Report this post`,
+    spell: msg`Report this spell`,
+  },
+  reportWhy: {
+    skeet: msg`Why should this skeet be reviewed?`,
+    post: msg`Why should this post be reviewed?`,
+    spell: msg`Why should this spell be reviewed?`,
+  },
+  // For search and browse
+  search: {
+    skeet: msg`Search skeets`,
+    post: msg`Search posts`,
+    spell: msg`Search spells`,
+  },
+  searchProfile: (handle: string) => ({
+    skeet: msg`Search @${handle}'s skeets`,
+    post: msg`Search @${handle}'s posts`,
+    spell: msg`Search @${handle}'s spells`,
+  }),
+  searchMy: {
+    skeet: msg`Search my skeets`,
+    post: msg`Search my posts`,
+    spell: msg`Search my spells`,
+  },
+  browse: (tag: string) => ({
+    skeet: msg`Browse skeets about ${tag}`,
+    post: msg`Browse posts about ${tag}`,
+    spell: msg`Browse spells about ${tag}`,
+  }),
+  browseTagged: (tag: string) => ({
+    skeet: msg`Browse skeets tagged with ${tag}`,
+    post: msg`Browse posts tagged with ${tag}`,
+    spell: msg`Browse spells tagged with ${tag}`,
+  }),
+  seeTag: (tag: string) => ({
+    skeet: msg`See ${tag} skeets`,
+    post: msg`See ${tag} posts`,
+    spell: msg`See ${tag} spells`,
+  }),
+  seeTagByUser: (tag: string) => ({
+    skeet: msg`See ${tag} skeets by user`,
+    post: msg`See ${tag} posts by user`,
+    spell: msg`See ${tag} spells by user`,
+  }),
+  // For loading and errors
+  loadNew: {
+    skeet: msg`Load new skeets`,
+    post: msg`Load new posts`,
+    spell: msg`Load new spells`,
+  },
+  fetchError: {
+    skeet: msg`There was an issue fetching skeets. Tap here to try again.`,
+    post: msg`There was an issue fetching posts. Tap here to try again.`,
+    spell: msg`There was an issue fetching spells. Tap here to try again.`,
+  },
+  uploadFailed: {
+    skeet: msg`Skeet failed to upload. Please check your Internet connection and try again.`,
+    post: msg`Post failed to upload. Please check your Internet connection and try again.`,
+    spell: msg`Spell failed to upload. Please check your Internet connection and try again.`,
+  },
+  // For feeds and filtering
+  ranOut: {
+    skeet: msg`We ran out of skeets from your follows. Here's the latest from`,
+    post: msg`We ran out of posts from your follows. Here's the latest from`,
+    spell: msg`We ran out of spells from your follows. Here's the latest from`,
+  },
+  // For quote posts
+  quoteAction: {
+    skeet: msg`Quote skeet`,
+    post: msg`Quote post`,
+    spell: msg`Quote spell`,
+  },
+  quoteDisabled: {
+    skeet: msg`Quote skeets disabled`,
+    post: msg`Quote posts disabled`,
+    spell: msg`Quote spells disabled`,
+  },
+  allowQuote: {
+    skeet: msg`Allow quote skeets`,
+    post: msg`Allow quote posts`,
+    spell: msg`Allow quote spells`,
+  },
+  quoteAuthorDisabled: {
+    skeet: msg`This skeet's author has disabled quote skeets.`,
+    post: msg`This post's author has disabled quote posts.`,
+    spell: msg`This spell's author has disabled quote spells.`,
+  },
+  cancelQuote: {
+    skeet: msg`Cancel quote skeet`,
+    post: msg`Cancel quote post`,
+    spell: msg`Cancel quote spell`,
+  },
+  noQuoteYet: {
+    skeet: msg`No one but the author can quote this skeet.`,
+    post: msg`No one but the author can quote this post.`,
+    spell: msg`No one but the author can quote this spell.`,
+  },
+  // For reply settings
+  repliesDisabled: {
+    skeet: msg`Replies to this skeet are disabled.`,
+    post: msg`Replies to this post are disabled.`,
+    spell: msg`Replies to this spell are disabled.`,
+  },
+  everyoneCanReply: {
+    skeet: msg`Everybody can reply to this skeet.`,
+    post: msg`Everybody can reply to this post.`,
+    spell: msg`Everybody can reply to this spell.`,
+  },
+  unknownThreadgate: {
+    skeet: msg`This skeet has an unknown type of threadgate on it. Your app may be out of date.`,
+    post: msg`This post has an unknown type of threadgate on it. Your app may be out of date.`,
+    spell: msg`This spell has an unknown type of threadgate on it. Your app may be out of date.`,
+  },
+  // For replies
+  repliedTo: {
+    skeet: msg`Replied to a skeet`,
+    post: msg`Replied to a post`,
+    spell: msg`Replied to a spell`,
+  },
+  repliedToBlocked: {
+    skeet: msg`Replied to a blocked skeet`,
+    post: msg`Replied to a blocked post`,
+    spell: msg`Replied to a blocked spell`,
+  },
+  replyWasDeleted: {
+    skeet: msg`We're sorry! The skeet you are replying to has been deleted.`,
+    post: msg`We're sorry! The post you are replying to has been deleted.`,
+    spell: msg`We're sorry! The spell you are replying to has been deleted.`,
+  },
+  sortReplies: {
+    skeet: msg`Sort replies to the same skeet by:`,
+    post: msg`Sort replies to the same post by:`,
+    spell: msg`Sort replies to the same spell by:`,
+  },
+  showRepliesTree: {
+    skeet: msg`Show skeet replies in a threaded tree view`,
+    post: msg`Show post replies in a threaded tree view`,
+    spell: msg`Show spell replies in a threaded tree view`,
+  },
+  // For visibility
+  onlyLoggedIn: {
+    skeet: msg`This skeet is only visible to logged-in users.`,
+    post: msg`This post is only visible to logged-in users.`,
+    spell: msg`This spell is only visible to logged-in users.`,
+  },
+  noteOnlyLoggedIn: {
+    skeet: msg`Note: This skeet is only visible to logged-in users.`,
+    post: msg`Note: This post is only visible to logged-in users.`,
+    spell: msg`Note: This spell is only visible to logged-in users.`,
+  },
+}

src/screens/Bookmarks/index.tsx

···
 import {useCleanError} from '#/lib/hooks/useCleanError'
 import {useInitialNumToRender} from '#/lib/hooks/useInitialNumToRender'
 import {usePostViewTracking} from '#/lib/hooks/usePostViewTracking'
+import {getTerminology} from '#/lib/strings/terminology'
 import {
   type CommonNavigatorParams,
   type NativeStackScreenProps,
 } from '#/lib/routes/types'
 import {logger} from '#/logger'
 import {isIOS} from '#/platform/detection'
+import {useTerminologyPreference} from '#/state/preferences'
 import {useBookmarkMutation} from '#/state/queries/bookmarks/useBookmarkMutation'
 import {useBookmarksQuery} from '#/state/queries/bookmarks/useBookmarksQuery'
 import {useSetMinimalShellMode} from '#/state/shell'
···
 type Props = NativeStackScreenProps<CommonNavigatorParams, 'Bookmarks'>
 
 export function BookmarksScreen({}: Props) {
+  const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const setMinimalShellMode = useSetMinimalShellMode()
 
   useFocusEffect(
···
         <Layout.Header.BackButton />
         <Layout.Header.Content>
           <Layout.Header.TitleText>
-            <Trans>Saved Skeets</Trans>
+            <Trans>{_(getTerminology(terminologyPreference, {
+              skeet: msg`Saved Skeets`,
+              post: msg`Saved Posts`,
+              spell: msg`Saved Spells`,
+            }))}</Trans>
           </Layout.Header.TitleText>
         </Layout.Header.Content>
         <Layout.Header.Slot />
···
 }) {
   const t = useTheme()
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const {mutateAsync: bookmark} = useBookmarkMutation()
   const cleanError = useCleanError()
 
   const remove = async () => {
     try {
       await bookmark({action: 'delete', uri: post.uri})
-      toast.show(_(msg`Removed from saved skeets`), {
+      toast.show(_(getTerminology(terminologyPreference, {
+        skeet: msg`Removed from saved skeets`,
+        post: msg`Removed from saved posts`,
+        spell: msg`Removed from saved spells`,
+      })), {
         type: 'info',
       })
     } catch (e: any) {
···
             a.italic,
             t.atoms.text_contrast_medium,
           ]}>
-          <Trans>This skeet was deleted by its author</Trans>
+          <Trans>{_(getTerminology(terminologyPreference, {
+            skeet: msg`This skeet was deleted by its author`,
+            post: msg`This post was deleted by its author`,
+            spell: msg`This spell was deleted by its author`,
+          }))}</Trans>
         </Text>
       </View>
       <Button
-        label={_(msg`Remove from saved skeets`)}
+        label={_(getTerminology(terminologyPreference, {
+          skeet: msg`Remove from saved skeets`,
+          post: msg`Remove from saved posts`,
+          spell: msg`Remove from saved spells`,
+        }))}
         size="tiny"
         color="secondary"
         onPress={remove}>

src/screens/Post/PostLikedBy.tsx

···
 import {useFocusEffect} from '@react-navigation/native'
 
 import {useSetTitle} from '#/lib/hooks/useSetTitle'
+import {useTerminology} from '#/lib/hooks/useTerminology'
 import {
   type CommonNavigatorParams,
   type NativeStackScreenProps,
···
 export const PostLikedByScreen = ({route}: Props) => {
   const {_} = useLingui()
   const setMinimalShellMode = useSetMinimalShellMode()
+  const terminology = useTerminology()
   const {name, rkey} = route.params
   const uri = makeRecordUri(name, 'app.bsky.feed.post', rkey)
   const {data: post} = usePostQuery(uri)
···
   const {data: resolvedDid} = useResolveDidQuery(name)
   const {data: profile} = useProfileQuery({did: resolvedDid})
 
-  useSetTitle(profile ? _(msg`Skeet by @${profile.handle}`) : undefined)
+  useSetTitle(
+    profile ? `${_(terminology.post)} ${_(msg`by`)} @${profile.handle}` : undefined,
+  )
 
   let likeCount
   if (post) {

src/screens/Post/PostQuotes.tsx

···
 import {useFocusEffect} from '@react-navigation/native'
 
 import {useSetTitle} from '#/lib/hooks/useSetTitle'
+import {useTerminology} from '#/lib/hooks/useTerminology'
 import {
   type CommonNavigatorParams,
   type NativeStackScreenProps,
···
 export const PostQuotesScreen = ({route}: Props) => {
   const {_} = useLingui()
   const setMinimalShellMode = useSetMinimalShellMode()
+  const terminology = useTerminology()
   const {name, rkey} = route.params
   const uri = makeRecordUri(name, 'app.bsky.feed.post', rkey)
   const {data: post} = usePostQuery(uri)
···
   const {data: resolvedDid} = useResolveDidQuery(name)
   const {data: profile} = useProfileQuery({did: resolvedDid})
 
-  useSetTitle(profile ? _(msg`Skeet by @${profile.handle}`) : undefined)
+  useSetTitle(
+    profile ? `${_(terminology.post)} ${_(msg`by`)} @${profile.handle}` : undefined,
+  )
 
   let quoteCount
   if (post) {

src/screens/Post/PostRepostedBy.tsx

···
 import {useFocusEffect} from '@react-navigation/native'
 
 import {useSetTitle} from '#/lib/hooks/useSetTitle'
+import {useTerminology} from '#/lib/hooks/useTerminology'
 import {
   type CommonNavigatorParams,
   type NativeStackScreenProps,
···
 type Props = NativeStackScreenProps<CommonNavigatorParams, 'PostRepostedBy'>
 export const PostRepostedByScreen = ({route}: Props) => {
   const {_} = useLingui()
+  const terminology = useTerminology()
   const {name, rkey} = route.params
   const uri = makeRecordUri(name, 'app.bsky.feed.post', rkey)
   const setMinimalShellMode = useSetMinimalShellMode()
···
   const {data: resolvedDid} = useResolveDidQuery(name)
   const {data: profile} = useProfileQuery({did: resolvedDid})
 
-  useSetTitle(profile ? _(msg`Skeet by @${profile.handle}`) : undefined)
+  useSetTitle(
+    profile ? `${_(terminology.post)} ${_(msg`by`)} @${profile.handle}` : undefined,
+  )
 
   let quoteCount
   if (post) {
···
           {post && (
             <>
               <Layout.Header.TitleText>
-                <Trans>Reskeeted By</Trans>
+                <Trans>{_(terminology.reposted)} By</Trans>
               </Layout.Header.TitleText>
               <Layout.Header.SubtitleText>
                 <Plural
                   value={quoteCount ?? 0}
-                  one="# reskeet"
-                  other="# reskeets"
+                  one={_(terminology.repost)}
+                  other={_(terminology.reposts)}
                 />
               </Layout.Header.SubtitleText>
             </>

src/screens/PostThread/components/ThreadError.tsx

···
 import {useLingui} from '@lingui/react'
 
 import {useCleanError} from '#/lib/hooks/useCleanError'
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {OUTER_SPACE} from '#/screens/PostThread/const'
 import {atoms as a, useTheme} from '#/alf'
 import {Button, ButtonIcon, ButtonText} from '#/components/Button'
···
 }) {
   const t = useTheme()
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const cleanError = useCleanError()
 
   const {title, message} = useMemo(() => {
-    let title = _(msg`Error loading skeet`)
+    let title = _(getTerminology(terminologyPreference, TERMINOLOGY.errorLoading))
     let message = _(msg`Something went wrong. Please try again in a moment.`)
 
     const {raw, clean} = cleanError(error)
 
     if (error.message.startsWith('Post not found')) {
-      title = _(msg`Skeet not found`)
+      title = _(getTerminology(terminologyPreference, TERMINOLOGY.notFound))
       message = clean || raw || message
     }
 
     return {title, message}
-  }, [_, error, cleanError])
+  }, [_, error, cleanError, terminologyPreference])
 
   return (
     <Layout.Center>

src/screens/PostThread/components/ThreadItemAnchor.tsx

···
 import {useLingui} from '@lingui/react'
 
 import {useActorStatus} from '#/lib/actor-status'
+import {useTerminology} from '#/lib/hooks/useTerminology'
 import {useOpenComposer} from '#/lib/hooks/useOpenComposer'
 import {useTranslate} from '#/lib/hooks/useTranslate'
 import {makeProfileLink} from '#/lib/routes/links'
···
 
 function ThreadItemAnchorDeleted({isRoot}: {isRoot: boolean}) {
   const t = useTheme()
+  const {_} = useLingui()
+  const terminology = useTerminology()
 
   return (
     <>
···
           </View>
           <Text
             style={[a.text_md, a.font_semi_bold, t.atoms.text_contrast_medium]}>
-            <Trans>Skeet has been deleted</Trans>
+            <Trans>{_(terminology.post)} has been deleted</Trans>
           </Text>
         </View>
       </View>
···
   const {currentAccount, hasSession} = useSession()
   const feedFeedback = useFeedFeedback(postSource?.feedSourceInfo, hasSession)
   const formatPostStatCount = useFormatPostStatCount()
+  const terminology = useTerminology()
 
   const post = postShadow
   const record = item.value.post.record
···
               {post.repostCount != null &&
               post.repostCount !== 0 &&
               !disableRepostsMetrics ? (
-                <Link to={repostsHref} label={_(msg`Reskeets of this skeet`)}>
+                <Link to={repostsHref} label={_(msg`${_(terminology.reposts)} of this ${_(terminology.post)}`)}>
                   <Text
                     testID="repostCount-expanded"
                     style={[a.text_md, t.atoms.text_contrast_medium]}>
                     <Text style={[a.text_md, a.font_semi_bold, t.atoms.text]}>
                       {formatPostStatCount(post.repostCount)}
                     </Text>{' '}
-                    <Plural
-                      value={post.repostCount}
-                      one="reskeet"
-                      other="reskeets"
-                    />
+                    {post.repostCount === 1 ? _(terminology.repost) : _(terminology.reposts)}
                   </Text>
                 </Link>
               ) : null}
···
               post.quoteCount !== 0 &&
               !post.viewer?.embeddingDisabled &&
               !disableQuotesMetrics ? (
-                <Link to={quotesHref} label={_(msg`Quotes of this skeet`)}>
+                <Link to={quotesHref} label={_(msg`Quotes of this ${_(terminology.post)}`)}>
                   <Text
                     testID="quoteCount-expanded"
                     style={[a.text_md, t.atoms.text_contrast_medium]}>
···
               {post.likeCount != null &&
               post.likeCount !== 0 &&
               !disableLikesMetrics ? (
-                <Link to={likesHref} label={_(msg`Likes on this skeet`)}>
+                <Link to={likesHref} label={_(msg`Likes on this ${_(terminology.post)}`)}>
                   <Text
                     testID="likeCount-expanded"
                     style={[a.text_md, t.atoms.text_contrast_medium]}>
···
   const {_, i18n} = useLingui()
   const control = Prompt.usePromptControl()
   const enableSquareButtons = useEnableSquareButtons()
+  const terminology = useTerminology()
 
   const indexedAt = new Date(post.indexedAt)
   const createdAt = bsky.dangerousIsType<AppBskyFeedPost.Record>(
···
   return (
     <>
       <Button
-        label={_(msg`Archived post`)}
-        accessibilityHint={_(
-          msg`Shows information about when this skeet was created`,
-        )}
+        label={`${_(msg`Archived`)} ${_(terminology.post)}`}
+        accessibilityHint={`${_(msg`Shows information about when this`)} ${_(terminology.post)} ${_(msg`was created`)}`}
         onPress={e => {
           e.preventDefault()
           e.stopPropagation()
···
 
       <Prompt.Outer control={control}>
         <Prompt.TitleText>
-          <Trans>Archived post</Trans>
+          <Trans>Archived {_(terminology.post)}</Trans>
         </Prompt.TitleText>
         <Prompt.DescriptionText>
           <Trans>
-            This skeet claims to have been created on{' '}
+            This {_(terminology.post)} claims to have been created on{' '}
             <RNText style={[a.font_semi_bold]}>
               {niceDate(i18n, createdAt)}
             </RNText>

src/screens/PostThread/components/ThreadItemPost.tsx

···
   RichText as RichTextAPI,
 } from '@atproto/api'
 import {Trans} from '@lingui/macro'
+import {useLingui} from '@lingui/react'
 
 import {useActorStatus} from '#/lib/actor-status'
 import {MAX_POST_LINES} from '#/lib/constants'
 import {useOpenComposer} from '#/lib/hooks/useOpenComposer'
 import {makeProfileLink} from '#/lib/routes/links'
 import {countLines} from '#/lib/strings/helpers'
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {
   POST_TOMBSTONE,
   type Shadow,
···
   overrides,
 }: Pick<ThreadItemPostProps, 'item' | 'overrides'>) {
   const t = useTheme()
+  const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
 
   return (
     <ThreadItemPostOuterWrapper item={item} overrides={overrides}>
···
         </View>
         <Text
           style={[a.text_md, a.font_semi_bold, t.atoms.text_contrast_medium]}>
-          <Trans>Skeet has been deleted</Trans>
+          <Trans>{_(getTerminology(terminologyPreference, TERMINOLOGY.deletedShort))}</Trans>
         </Text>
       </View>
 

src/screens/PostThread/components/ThreadItemPostTombstone.tsx

···
 import {msg} from '@lingui/macro'
 import {useLingui} from '@lingui/react'
 
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {LINEAR_AVI_WIDTH, OUTER_SPACE} from '#/screens/PostThread/const'
 import {atoms as a, useTheme} from '#/alf'
 import {PersonX_Stroke2_Corner0_Rounded as PersonXIcon} from '#/components/icons/Person'
···
 export function ThreadItemPostTombstone({type}: ThreadItemPostTombstoneProps) {
   const t = useTheme()
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const {copy, Icon} = useMemo(() => {
     switch (type) {
       case 'blocked':
-        return {copy: _(msg`Skeet blocked`), Icon: PersonXIcon}
+        return {copy: _(getTerminology(terminologyPreference, TERMINOLOGY.blocked)), Icon: PersonXIcon}
       case 'not-found':
       default:
-        return {copy: _(msg`Skeet not found`), Icon: TrashIcon}
+        return {copy: _(getTerminology(terminologyPreference, TERMINOLOGY.notFound)), Icon: TrashIcon}
     }
-  }, [_, type])
+  }, [_, type, terminologyPreference])
 
   return (
     <View

src/screens/Profile/Header/Metrics.tsx

···
 import {useLingui} from '@lingui/react'
 
 import {makeProfileLink} from '#/lib/routes/links'
+import {getTerminology} from '#/lib/strings/terminology'
 import {type Shadow} from '#/state/cache/types'
+import {useTerminologyPreference} from '#/state/preferences'
 import {useDisableFollowersMetrics} from '#/state/preferences/disable-followers-metrics'
 import {useDisableFollowingMetrics} from '#/state/preferences/disable-following-metrics'
 import {useDisablePostsMetrics} from '#/state/preferences/disable-posts-metrics'
···
 }) {
   const t = useTheme()
   const {_, i18n} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const following = formatCount(i18n, profile.followsCount || 0)
   const followers = formatCount(i18n, profile.followersCount || 0)
   const pluralizedFollowers = plural(profile.followersCount || 0, {
···
             <Text style={[a.font_semi_bold, t.atoms.text, a.text_md]}>
               {formatCount(i18n, profile.postsCount || 0)}{' '}
               <Text style={[t.atoms.text_contrast_medium, a.font_normal, a.text_md]}>
-                {plural(profile.postsCount || 0, {one: 'skeet', other: 'skeets'})}
+                {_(getTerminology(terminologyPreference, {
+                  skeet: msg`${plural(profile.postsCount || 0, {one: 'skeet', other: 'skeets'})}`,
+                  post: msg`${plural(profile.postsCount || 0, {one: 'post', other: 'posts'})}`,
+                  spell: msg`${plural(profile.postsCount || 0, {one: 'spell', other: 'spells'})}`,
+                }))}
               </Text>
             </Text>
           ) : null}

src/screens/Profile/ProfileFeed/index.tsx

···
 import {type CommonNavigatorParams} from '#/lib/routes/types'
 import {type NavigationProp} from '#/lib/routes/types'
 import {makeRecordUri} from '#/lib/strings/url-helpers'
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
 import {s} from '#/lib/styles'
 import {isNative} from '#/platform/detection'
 import {listenSoftReset} from '#/state/events'
 import {FeedFeedbackProvider, useFeedFeedback} from '#/state/feed-feedback'
+import {useTerminologyPreference} from '#/state/preferences'
 import {
   type FeedSourceFeedInfo,
   useFeedSourceInfoQuery,
···
   feedParams: FeedParams | undefined
 }) {
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const {hasSession} = useSession()
   const {openComposer} = useOpenComposer()
   const isScreenFocused = useIsFocused()
···
       {(isScrolledDown || hasNew) && (
         <LoadLatestBtn
           onPress={onScrollToTop}
-          label={_(msg`Load new skeets`)}
+          label={_(getTerminology(terminologyPreference, TERMINOLOGY.loadNew))}
           showIndicator={hasNew}
         />
       )}

src/screens/Profile/ProfileSearch.tsx

···
 import {useLingui} from '@lingui/react'
 
 import {useSetTitle} from '#/lib/hooks/useSetTitle'
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {
   type CommonNavigatorParams,
   type NativeStackScreenProps,
···
 export const ProfileSearchScreen = ({route}: Props) => {
   const {name, q: queryParam = ''} = route.params
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const {currentAccount} = useSession()
 
   const {data: resolvedDid} = useResolveDidQuery(name)
   const {data: profile} = useProfileQuery({did: resolvedDid})
 
-  useSetTitle(profile ? _(msg`Search @${profile.handle}'s skeets`) : undefined)
+  useSetTitle(profile ? _(getTerminology(terminologyPreference, TERMINOLOGY.searchProfile(profile.handle))) : undefined)
 
   const fixedParams = useMemo(
     () => ({
···
       inputPlaceholder={
         profile
           ? currentAccount?.did === profile.did
-            ? _(msg`Search my skeets`)
-            : _(msg`Search @${profile.handle}'s skeets`)
+            ? _(getTerminology(terminologyPreference, TERMINOLOGY.searchMy))
+            : _(getTerminology(terminologyPreference, TERMINOLOGY.searchProfile(profile.handle)))
           : _(msg`Search...`)
       }
       fixedParams={fixedParams}

src/screens/Profile/Sections/Feed.tsx

···
 import {useQueryClient} from '@tanstack/react-query'
 
 import {useInitialNumToRender} from '#/lib/hooks/useInitialNumToRender'
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
 import {isIOS, isNative} from '#/platform/detection'
+import {useTerminologyPreference} from '#/state/preferences'
 import {
   type FeedDescriptor,
   RQKEY as FEED_RQKEY,
···
   emptyStateIcon,
 }: FeedSectionProps) {
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const queryClient = useQueryClient()
   const [hasNew, setHasNew] = useState(false)
   const [isScrolledDown, setIsScrolledDown] = useState(false)
···
       {(isScrolledDown || hasNew) && (
         <LoadLatestBtn
           onPress={onScrollToTop}
-          label={_(msg`Load new skeets`)}
+          label={_(getTerminology(terminologyPreference, TERMINOLOGY.loadNew))}
           showIndicator={hasNew}
         />
       )}

src/screens/Settings/DeerSettings.tsx

···
 import {APPVIEW_DID_PROXY} from '#/lib/constants'
 import {usePalette} from '#/lib/hooks/usePalette'
 import {type CommonNavigatorParams} from '#/lib/routes/types'
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
 import {type Gate} from '#/lib/statsig/gates'
 import {
   resetDeerGateCache,
···
             </SettingsList.ItemText>
             <Toggle.Item
               name="external_share_buttons"
-              label={_(
-                msg`Show "Open original skeet" and "Open skeet in PDSls" buttons`,
-              )}
+              label={_(getTerminology(terminologyPreference, TERMINOLOGY.externalShareButtons))}
               value={showExternalShareButtons}
               onChange={value => setShowExternalShareButtons(value)}
               style={[a.w_full]}>
               <Toggle.LabelText style={[a.flex_1]}>
-                <Trans>
-                  Show "Open original skeet" and "Open skeet in PDSls" buttons
-                </Trans>
+                <Trans>{_(getTerminology(terminologyPreference, TERMINOLOGY.externalShareButtons))}</Trans>
               </Toggle.LabelText>
               <Toggle.Platform />
             </Toggle.Item>
···
 
             <Toggle.Item
               name="repost_carousel"
-              label={_(msg`Combine reskeets into a horizontal carousel`)}
+              label={_(getTerminology(terminologyPreference, TERMINOLOGY.carousel))}
               value={repostCarouselEnabled}
               onChange={value => setRepostCarouselEnabled(value)}
               style={[a.w_full]}>
               <Toggle.LabelText style={[a.flex_1]}>
-                <Trans>Combine reskeets into a horizontal carousel</Trans>
+                <Trans>{_(getTerminology(terminologyPreference, TERMINOLOGY.carousel))}</Trans>
               </Toggle.LabelText>
               <Toggle.Platform />
             </Toggle.Item>
···
 
             <Toggle.Item
               name="disable_via_repost_notification"
-              label={_(msg`Disable "via reskeet" notifications`)}
+              label={_(getTerminology(terminologyPreference, TERMINOLOGY.viaRepostNotification))}
               value={disableViaRepostNotification}
               onChange={value => setDisableViaRepostNotification(value)}
               style={[a.w_full]}>
               <Toggle.LabelText style={[a.flex_1]}>
-                <Trans>Disable "via reskeet" notifications</Trans>
+                <Trans>{_(getTerminology(terminologyPreference, TERMINOLOGY.viaRepostNotification))}</Trans>
               </Toggle.LabelText>
               <Toggle.Platform />
             </Toggle.Item>
             <Admonition type="info" style={[a.flex_1]}>
-              <Trans>
-                Forcefully disables the notifications other people receive when
-                you like/reskeet a skeet someone else has reskeeted for privacy.
-              </Trans>
+              <Trans>{_(getTerminology(terminologyPreference, TERMINOLOGY.viaRepostPrivacy))}</Trans>
             </Admonition>
 
             <Toggle.Item
···
 
             <Toggle.Item
               name="disable_reposts_metrics"
-              label={_(msg`Disable reskeets metrics`)}
+              label={_(getTerminology(terminologyPreference, TERMINOLOGY.repostMetrics))}
               value={disableRepostsMetrics}
               onChange={value => setDisableRepostsMetrics(value)}
               style={[a.w_full]}>
               <Toggle.LabelText style={[a.flex_1]}>
-                <Trans>Disable reskeets metrics</Trans>
+                <Trans>{_(getTerminology(terminologyPreference, TERMINOLOGY.repostMetrics))}</Trans>
               </Toggle.LabelText>
               <Toggle.Platform />
             </Toggle.Item>
···
 
             <Toggle.Item
               name="disable_posts_metrics"
-              label={_(msg`Disable skeets metrics`)}
+              label={_(getTerminology(terminologyPreference, TERMINOLOGY.metrics))}
               value={disablePostsMetrics}
               onChange={value => setDisablePostsMetrics(value)}
               style={[a.w_full]}>
               <Toggle.LabelText style={[a.flex_1]}>
-                <Trans>Disable skeets metrics</Trans>
+                <Trans>{_(getTerminology(terminologyPreference, TERMINOLOGY.metrics))}</Trans>
               </Toggle.LabelText>
               <Toggle.Platform />
             </Toggle.Item>

src/screens/Settings/FollowingFeedPreferences.tsx

···
   type CommonNavigatorParams,
   type NativeStackScreenProps,
 } from '#/lib/routes/types'
+import {getTerminology} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {
   usePreferencesQuery,
   useSetFeedViewPreferencesMutation,
···
 >
 export function FollowingFeedPreferencesScreen({}: Props) {
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
 
   const {data: preferences} = usePreferencesQuery()
   const {mutate: setFeedViewPref, variables} =
···
           <Toggle.Item
             type="checkbox"
             name="show-reposts"
-            label={_(msg`Show reskeets`)}
+            label={_(getTerminology(terminologyPreference, {
+              skeet: msg`Show reskeets`,
+              post: msg`Show reposts`,
+              spell: msg`Show respells`,
+            }))}
             value={showReposts}
             onChange={value =>
               setFeedViewPref({
···
             <SettingsList.Item>
               <SettingsList.ItemIcon icon={RepostIcon} />
               <SettingsList.ItemText>
-                <Trans>Show reskeets</Trans>
+                <Trans>{_(getTerminology(terminologyPreference, {
+                  skeet: msg`Show reskeets`,
+                  post: msg`Show reposts`,
+                  spell: msg`Show respells`,
+                }))}</Trans>
               </SettingsList.ItemText>
               <Toggle.Platform />
             </SettingsList.Item>
···
           <Toggle.Item
             type="checkbox"
             name="show-quotes"
-            label={_(msg`Show quote skeets`)}
+            label={_(getTerminology(terminologyPreference, {
+              skeet: msg`Show quote skeets`,
+              post: msg`Show quote posts`,
+              spell: msg`Show quote spells`,
+            }))}
             value={showQuotePosts}
             onChange={value =>
               setFeedViewPref({
···
             <SettingsList.Item>
               <SettingsList.ItemIcon icon={QuoteIcon} />
               <SettingsList.ItemText>
-                <Trans>Show quote skeets</Trans>
+                <Trans>{_(getTerminology(terminologyPreference, {
+                  skeet: msg`Show quote skeets`,
+                  post: msg`Show quote posts`,
+                  spell: msg`Show quote spells`,
+                }))}</Trans>
               </SettingsList.ItemText>
               <Toggle.Platform />
             </SettingsList.Item>

src/screens/Settings/NotificationSettings/LikesOnRepostsNotificationSettings.tsx

···
 import {View} from 'react-native'
-import {Trans} from '@lingui/macro'
+import {msg, Trans} from '@lingui/macro'
+import {useLingui} from '@lingui/react'
 
 import {
   type AllNavigatorParams,
   type NativeStackScreenProps,
 } from '#/lib/routes/types'
+import {getTerminology} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {useNotificationSettingsQuery} from '#/state/queries/notifications/settings'
 import {atoms as a} from '#/alf'
 import {Admonition} from '#/components/Admonition'
···
   'LikesOnRepostsNotificationSettings'
 >
 export function LikesOnRepostsNotificationSettingsScreen({}: Props) {
+  const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const {data: preferences, isError} = useNotificationSettingsQuery()
 
   return (
···
             <SettingsList.ItemIcon icon={LikeRepostIcon} />
             <ItemTextWithSubtitle
               bold
-              titleText={<Trans>Likes of your reskeets</Trans>}
+              titleText={<Trans>{_(getTerminology(terminologyPreference, {
+                skeet: msg`Likes of your reskeets`,
+                post: msg`Likes of your reposts`,
+                spell: msg`Likes of your respells`,
+              }))}</Trans>}
               subtitleText={
-                <Trans>
-                  Get notifications when people like skeets that you've reskeeted.
-                </Trans>
+                <Trans>{_(getTerminology(terminologyPreference, {
+                  skeet: msg`Get notifications when people like skeets that you've reskeeted.`,
+                  post: msg`Get notifications when people like posts that you've reposted.`,
+                  spell: msg`Get notifications when people like spells that you've respelled.`,
+                }))}</Trans>
               }
             />
           </SettingsList.Item>

src/screens/Settings/NotificationSettings/RepostNotificationSettings.tsx

···
 import {View} from 'react-native'
-import {Trans} from '@lingui/macro'
+import {msg, Trans} from '@lingui/macro'
+import {useLingui} from '@lingui/react'
 
 import {
   type AllNavigatorParams,
   type NativeStackScreenProps,
 } from '#/lib/routes/types'
+import {getTerminology} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {useNotificationSettingsQuery} from '#/state/queries/notifications/settings'
 import {atoms as a} from '#/alf'
 import {Admonition} from '#/components/Admonition'
···
   'RepostNotificationSettings'
 >
 export function RepostNotificationSettingsScreen({}: Props) {
+  const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const {data: preferences, isError} = useNotificationSettingsQuery()
 
   return (
···
             <SettingsList.ItemIcon icon={RepostIcon} />
             <ItemTextWithSubtitle
               bold
-              titleText={<Trans>Reskeets</Trans>}
+              titleText={<Trans>{_(getTerminology(terminologyPreference, {
+                skeet: msg`Reskeets`,
+                post: msg`Reposts`,
+                spell: msg`Respells`,
+              }))}</Trans>}
               subtitleText={
-                <Trans>Get notifications when people reskeet your skeets.</Trans>
+                <Trans>{_(getTerminology(terminologyPreference, {
+                  skeet: msg`Get notifications when people reskeet your skeets.`,
+                  post: msg`Get notifications when people repost your posts.`,
+                  spell: msg`Get notifications when people respell your spells.`,
+                }))}</Trans>
               }
             />
           </SettingsList.Item>

src/screens/Settings/NotificationSettings/RepostsOnRepostsNotificationSettings.tsx

···
 import {View} from 'react-native'
-import {Trans} from '@lingui/macro'
+import {msg, Trans} from '@lingui/macro'
+import {useLingui} from '@lingui/react'
 
 import {
   type AllNavigatorParams,
   type NativeStackScreenProps,
 } from '#/lib/routes/types'
+import {getTerminology} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {useNotificationSettingsQuery} from '#/state/queries/notifications/settings'
 import {atoms as a} from '#/alf'
 import {Admonition} from '#/components/Admonition'
···
   'RepostsOnRepostsNotificationSettings'
 >
 export function RepostsOnRepostsNotificationSettingsScreen({}: Props) {
+  const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const {data: preferences, isError} = useNotificationSettingsQuery()
 
   return (
···
             <SettingsList.ItemIcon icon={RepostRepostIcon} />
             <ItemTextWithSubtitle
               bold
-              titleText={<Trans>Reskeets of your reskeets</Trans>}
+              titleText={<Trans>{_(getTerminology(terminologyPreference, {
+                skeet: msg`Reskeets of your reskeets`,
+                post: msg`Reposts of your reposts`,
+                spell: msg`Respells of your respells`,
+              }))}</Trans>}
               subtitleText={
-                <Trans>
-                  Get notifications when people reskeet skeets that you've
-                  reskeeted.
-                </Trans>
+                <Trans>{_(getTerminology(terminologyPreference, {
+                  skeet: msg`Get notifications when people reskeet skeets that you've reskeeted.`,
+                  post: msg`Get notifications when people repost posts that you've reposted.`,
+                  spell: msg`Get notifications when people respell spells that you've respelled.`,
+                }))}</Trans>
               }
             />
           </SettingsList.Item>

src/state/queries/pinned-post.ts

···
 import {useMutation, useQueryClient} from '@tanstack/react-query'
 
 import {logger} from '#/logger'
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {RQKEY as FEED_RQKEY} from '#/state/queries/post-feed'
 import * as Toast from '#/view/com/util/Toast'
 import {updatePostShadow} from '../cache/post-shadow'
···
 
 export function usePinnedPostMutation() {
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const {currentAccount} = useSession()
   const agent = useAgent()
   const queryClient = useQueryClient()
···
         })
 
         if (pinCurrentPost) {
-          Toast.show(_(msg({message: 'Skeet pinned', context: 'toast'})))
+          Toast.show(_(getTerminology(terminologyPreference, TERMINOLOGY.pinned)))
         } else {
-          Toast.show(_(msg({message: 'Skeet unpinned', context: 'toast'})))
+          Toast.show(_(getTerminology(terminologyPreference, TERMINOLOGY.unpinned)))
         }
 
         queryClient.invalidateQueries({
···
           ),
         })
       } catch (e: any) {
-        Toast.show(_(msg`Failed to pin skeet`))
+        Toast.show(_(getTerminology(terminologyPreference, TERMINOLOGY.failedToPin)))
         logger.error('Failed to pin post', {message: String(e)})
         // revert optimistic update
         updatePostShadow(queryClient, postUri, {

src/view/com/composer/Composer.tsx

···
 import {type NavigationProp} from '#/lib/routes/types'
 import {logEvent} from '#/lib/statsig/statsig'
 import {cleanError} from '#/lib/strings/errors'
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
 import {colors} from '#/lib/styles'
 import {logger} from '#/logger'
 import {isAndroid, isIOS, isNative, isWeb} from '#/platform/detection'
···
   pasteImage,
 } from '#/state/gallery'
 import {useModalControls} from '#/state/modals'
-import {useRequireAltTextEnabled} from '#/state/preferences'
+import {useRequireAltTextEnabled, useTerminologyPreference} from '#/state/preferences'
 import {useEnableSquareButtons} from '#/state/preferences/enable-square-buttons'
 import {
   fromPostLanguages,
···
   const currentDid = currentAccount!.did
   const {closeComposer} = useComposerControls()
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const requireAltTextEnabled = useRequireAltTextEnabled()
   const langPrefs = useLanguagePrefs()
   const setLangPrefs = useLanguagePrefsApi()
···
           replyTo: replyTo?.uri,
           onStateChange: setPublishingStage,
           langs: currentLanguages,
+          terminologyPreference,
         })
       ).uris[0]
 
···
 
       let err = cleanError(e.message)
       if (err.includes('not locate record')) {
-        err = _(
-          msg`We're sorry! The skeet you are replying to has been deleted.`,
-        )
+        err = _(getTerminology(terminologyPreference, TERMINOLOGY.replyWasDeleted))
       } else if (e instanceof EmbeddingDisabledError) {
-        err = _(msg`This skeet's author has disabled quote skeets.`)
+        err = _(getTerminology(terminologyPreference, TERMINOLOGY.quoteAuthorDisabled))
       }
       setError(err)
       setIsPublishing(false)
···
           <Toast.Icon />
           <Toast.Text>
             {thread.posts.length > 1
-              ? _(msg`Your skeets were sent`)
+              ? _(getTerminology(terminologyPreference, TERMINOLOGY.sentPlural))
               : replyTo
                 ? _(msg`Your reply was sent`)
-                : _(msg`Your skeet was sent`)}
+                : _(getTerminology(terminologyPreference, TERMINOLOGY.sent))}
           </Toast.Text>
           {postUri && (
             <Toast.Action
-              label={_(msg`View skeet`)}
+              label={_(getTerminology(terminologyPreference, TERMINOLOGY.view))}
               onPress={() => {
                 const {host: name, rkey} = new AtUri(postUri)
                 navigation.navigate('PostThread', {name, rkey})
···
   const selectTextInputPlaceholder = isReply
     ? isFirstPost
       ? _(msg`Write your reply`)
-      : _(msg`Add another skeet`)
-    : _(msg`Anything but skeet`)
+      : _(getTerminology(terminologyPreference, TERMINOLOGY.addAnother))
+    : _(getTerminology(terminologyPreference, TERMINOLOGY.anythingBut))
   const discardPromptControl = Prompt.usePromptControl()
 
   const enableSquareButtons = useEnableSquareButtons()
···
       {canRemovePost && isActive && (
         <>
           <Button
-            label={_(msg`Delete skeet`)}
+            label={_(getTerminology(terminologyPreference, TERMINOLOGY.delete))}
             size="small"
             color="secondary"
             variant="ghost"
···
           </Button>
           <Prompt.Basic
             control={discardPromptControl}
-            title={_(msg`Discard skeet?`)}
-            description={_(msg`Are you sure you'd like to discard this skeet?`)}
+            title={_(getTerminology(terminologyPreference, TERMINOLOGY.discard))}
+            description={_(getTerminology(terminologyPreference, TERMINOLOGY.discardConfirm))}
             onConfirm={() => {
               dispatch({
                 type: 'remove_post',
···
               {isReply ? (
                 <Trans context="action">Reply</Trans>
               ) : isThread ? (
-                <Trans context="action">Skeet All</Trans>
+                <Trans context="action">{_(getTerminology(terminologyPreference, TERMINOLOGY.postAll))}</Trans>
               ) : (
-                <Trans context="action">Skeet</Trans>
+                <Trans context="action">{_(getTerminology(terminologyPreference, TERMINOLOGY.postSingle))}</Trans>
               )}
             </ButtonText>
           </Button>

src/view/com/composer/select-language/PostLanguageSelect.tsx

···
 
 import {LANG_DROPDOWN_HITSLOP} from '#/lib/constants'
 import {codeToLanguageName} from '#/locale/helpers'
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {
   toPostLanguages,
   useLanguagePrefs,
···
   onSelectLanguage?: (language: string) => void
 }) {
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const langPrefs = useLanguagePrefs()
   const setLangPrefs = useLanguagePrefsApi()
   const languageDialogControl = Dialog.useDialogControl()
···
   return (
     <>
       <Menu.Root>
-        <Menu.Trigger label={_(msg`Select skeet language`)}>
+        <Menu.Trigger label={_(getTerminology(terminologyPreference, TERMINOLOGY.selectLanguage))}>
           {({props}) => (
             <LanguageBtn currentLanguages={currentLanguages} {...props} />
           )}
···
   },
 ) {
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const langPrefs = useLanguagePrefs()
   const t = useTheme()
 
···
       testID="selectLangBtn"
       size="small"
       hitSlop={LANG_DROPDOWN_HITSLOP}
-      label={_(
-        msg({
-          message: `Skeet language selection`,
-          comment: `Accessibility label for button that opens dialog to choose post language settings`,
-        }),
-      )}
+      label={_(getTerminology(terminologyPreference, TERMINOLOGY.selectLanguage))}
       accessibilityHint={_(msg`Opens post language settings`)}
       style={[a.mr_xs]}
       {...props}>

src/view/com/composer/select-language/PostLanguageSelectDialog.tsx

···
 import {languageName} from '#/locale/helpers'
 import {type Language, LANGUAGES, LANGUAGES_MAP_CODE2} from '#/locale/languages'
 import {isNative, isWeb} from '#/platform/detection'
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {useEnableSquareButtons} from '#/state/preferences/enable-square-buttons'
 import {
   toPostLanguages,
···
   const setLangPrefs = useLanguagePrefsApi()
   const t = useTheme()
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
 
   const enableSquareButtons = useEnableSquareButtons()
 
···
               a.text_xl,
               a.mb_sm,
             ]}>
-            <Trans>Choose Skeet Languages</Trans>
+            <Trans>{_(getTerminology(terminologyPreference, TERMINOLOGY.chooseLanguages))}</Trans>
           </Text>
           <Text
             nativeID="dialog-description"
···
               a.text_md,
               a.mb_lg,
             ]}>
-            <Trans>Select up to 3 languages used in this skeet</Trans>
+            <Trans>{_(getTerminology(terminologyPreference, TERMINOLOGY.languageDescription))}</Trans>
           </Text>
         </View>
 

src/view/com/post-thread/PostRepostedBy.tsx

···
 
 import {useInitialNumToRender} from '#/lib/hooks/useInitialNumToRender'
 import {cleanError} from '#/lib/strings/errors'
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {logger} from '#/logger'
 import {usePostRepostedByQuery} from '#/state/queries/post-reposted-by'
 import {useResolveUriQuery} from '#/state/queries/resolve-uri'
···
 
 export function PostRepostedBy({uri}: {uri: string}) {
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const initialNumToRender = useInitialNumToRender()
 
   const [isPTRing, setIsPTRing] = useState(false)
···
         isLoading={isLoadingUri || isLoadingRepostedBy}
         isError={isError}
         emptyType="results"
-        emptyTitle={_(msg`No reskeets yet`)}
-        emptyMessage={_(
-          msg`Nobody has reskeeted this yet. Maybe you should be the first!`,
-        )}
+        emptyTitle={_(getTerminology(terminologyPreference, {
+          skeet: msg`No reskeets yet`,
+          post: msg`No reposts yet`,
+          spell: msg`No respells yet`,
+        }))}
+        emptyMessage={_(getTerminology(terminologyPreference, {
+          skeet: msg`Nobody has reskeeted this yet. Maybe you should be the first!`,
+          post: msg`Nobody has reposted this yet. Maybe you should be the first!`,
+          spell: msg`Nobody has respelled this yet. Maybe you should be the first!`,
+        }))}
         errorMessage={cleanError(resolveError || error)}
         sideBorders={false}
       />

src/view/com/posts/PostFeedReason.tsx

···
 import {isReasonFeedSource, type ReasonFeedSource} from '#/lib/api/feed/types'
 import {createSanitizedDisplayName} from '#/lib/moderation/create-sanitized-display-name'
 import {makeProfileLink} from '#/lib/routes/links'
+import {getTerminology, TERMINOLOGY} from '#/lib/strings/terminology'
+import {useTerminologyPreference} from '#/state/preferences'
 import {useSession} from '#/state/session'
 import {atoms as a, useTheme} from '#/alf'
 import {Pin_Stroke2_Corner0_Rounded as PinIcon} from '#/components/icons/Pin'
···
 }) {
   const t = useTheme()
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
 
   const {currentAccount} = useSession()
 
···
         style={styles.includeReason}
         to={makeProfileLink(reason.by)}
         label={
-          isOwner ? _(msg`Reskeeted by you`) : _(msg`Reskeeted by ${reposter}`)
+          isOwner
+            ? _(getTerminology(terminologyPreference, TERMINOLOGY.repost.byLine))
+            : `${_(getTerminology(terminologyPreference, TERMINOLOGY.repost.byLine))} ${reposter}`
         }
         onPress={onOpenReposter}>
         <RepostIcon
···
             ]}
             numberOfLines={1}>
             {isOwner ? (
-              <Trans>Reskeeted by you</Trans>
+              <Trans>{_(getTerminology(terminologyPreference, TERMINOLOGY.repost.byLine))}</Trans>
             ) : (
-              <Trans>Reskeeted by {reposter}</Trans>
+              <Trans>{_(getTerminology(terminologyPreference, TERMINOLOGY.repost.byLine))} {reposter}</Trans>
             )}
           </Text>
         </ProfileHoverCard>

src/view/shell/desktop/LeftNav.tsx

···
 import {useGate} from '#/lib/statsig/statsig'
 import {sanitizeDisplayName} from '#/lib/strings/display-names'
 import {isInvalidHandle, sanitizeHandle} from '#/lib/strings/handles'
+import {getTerminology} from '#/lib/strings/terminology'
 import {emitSoftReset} from '#/state/events'
 import {useHomeBadge} from '#/state/home-badge'
 import {useEnableSquareButtons} from '#/state/preferences/enable-square-buttons'
+import {useTerminologyPreference} from '#/state/preferences'
 import {useFetchHandle} from '#/state/queries/handle'
 import {useUnreadMessageCount} from '#/state/queries/messages/list-conversations'
 import {useUnreadNotifications} from '#/state/queries/notifications/unread'
···
   const {getState} = useNavigation()
   const {openComposer} = useOpenComposer()
   const {_} = useLingui()
+  const terminologyPreference = useTerminologyPreference()
   const {leftNavMinimal} = useLayoutBreakpoints()
   const [isFetchingHandle, setIsFetchingHandle] = useState(false)
   const fetchHandle = useFetchHandle()
···
     <View style={[a.flex_row, a.pl_md, a.pt_xl]}>
       <Button
         disabled={isFetchingHandle}
-        label={_(msg`Compose new post`)}
+        label={_(getTerminology(terminologyPreference, {
+          skeet: msg`Compose new skeet`,
+          post: msg`Compose new post`,
+          spell: msg`Compose new spell`,
+        }))}
         onPress={onPressCompose}
         size="large"
         variant="solid"
···
         style={enableSquareButtons ? [a.rounded_sm] : [a.rounded_full]}>
         <ButtonIcon icon={EditBig} position="left" />
         <ButtonText>
-          <Trans context="action">New Skeet</Trans>
+          <Trans>{_(getTerminology(terminologyPreference, {
+            skeet: msg({message: `New Skeet`, context: 'action'}),
+            post: msg({message: `New Post`, context: 'action'}),
+            spell: msg({message: `New Spell`, context: 'action'}),
+          }))}</Trans>
         </ButtonText>
       </Button>
     </View>