diff --git a/iOS/PostEditor/PostBodyTextView.swift b/iOS/PostEditor/PostBodyTextView.swift
index 9cde54d..e123c8d 100644
--- a/iOS/PostEditor/PostBodyTextView.swift
+++ b/iOS/PostEditor/PostBodyTextView.swift
@@ -1,124 +1,107 @@
 // Based on https://stackoverflow.com/a/56508132 and https://stackoverflow.com/a/48360549
 
 import SwiftUI
 
 class PostBodyCoordinator: NSObject, UITextViewDelegate, NSLayoutManagerDelegate {
     @Binding var text: String
     @Binding var isFirstResponder: Bool
-    @Binding var currentTextPosition: UITextRange?
     var lineSpacingMultiplier: CGFloat
     var didBecomeFirstResponder: Bool = false
     var postBodyTextView: PostBodyTextView
 
     weak var textView: UITextView?
 
     init(
         _ textView: PostBodyTextView,
         text: Binding<String>,
         isFirstResponder: Binding<Bool>,
-        currentTextPosition: Binding<UITextRange?>,
         lineSpacingMultiplier: CGFloat
     ) {
         self.postBodyTextView = textView
         _text = text
         _isFirstResponder = isFirstResponder
         self.lineSpacingMultiplier = lineSpacingMultiplier
-        _currentTextPosition = currentTextPosition
-    }
-
-    func textViewDidChange(_ textView: UITextView) {
-        DispatchQueue.main.async {
-            self.postBodyTextView.text = textView.text ?? ""
-        }
     }
 
     func textView(_ textView: UITextView, shouldChangeTextIn range: NSRange, replacementText text: String) -> Bool {
-        self.currentTextPosition = textView.selectedTextRange
         return true
     }
 
-    func textViewDidBeginEditing(_ textView: UITextView) {
-        if let textPosition = currentTextPosition {
-            textView.selectedTextRange = textPosition
-        }
-    }
-
     func textViewDidEndEditing(_ textView: UITextView) {
+        self.postBodyTextView.text = textView.text ?? ""
         self.isFirstResponder = false
         self.didBecomeFirstResponder = false
-        self.currentTextPosition = textView.selectedTextRange
     }
 
     func layoutManager(
         _ layoutManager: NSLayoutManager,
         lineSpacingAfterGlyphAt glyphIndex: Int,
         withProposedLineFragmentRect rect: CGRect
     ) -> CGFloat {
         // HACK: - This seems to be the only way to get line spacing to update dynamically on iPad
         //         when switching between full-screen, split-screen, and slide-over views.
         if let window = UIApplication.shared.windows.filter({ $0.isKeyWindow }).first {
             // Get the width of the window to determine the size class
             if window.frame.width < 600 {
                 // Use 0.25 multiplier for compact size class
                 return 17 * 0.25
             } else {
                 // Use 0.5 multiplier otherwise
                 return 17 * 0.5
             }
         } else {
             return 17 * lineSpacingMultiplier
         }
     }
 }
 
 struct PostBodyTextView: UIViewRepresentable {
     @Binding var text: String
     @Binding var textStyle: UIFont
     @Binding var isFirstResponder: Bool
-    @Binding var currentTextPosition: UITextRange?
     @State var lineSpacing: CGFloat
 
     func makeUIView(context: UIViewRepresentableContext<PostBodyTextView>) -> UITextView {
-        let textView = UITextView(frame: .zero)
+        let textView = UITextView()
 
         textView.isEditable = true
         textView.isUserInteractionEnabled = true
         textView.isScrollEnabled = true
         textView.alwaysBounceVertical = false
 
         context.coordinator.textView = textView
         textView.delegate = context.coordinator
         textView.layoutManager.delegate = context.coordinator
 
         let font = textStyle
         let fontMetrics = UIFontMetrics(forTextStyle: .largeTitle)
         textView.font = fontMetrics.scaledFont(for: font)
+
         textView.backgroundColor = UIColor.clear
 
         return textView
     }
 
     func makeCoordinator() -> PostBodyCoordinator {
         return Coordinator(
             self,
             text: $text,
             isFirstResponder: $isFirstResponder,
-            currentTextPosition: $currentTextPosition,
             lineSpacingMultiplier: lineSpacing
         )
     }
 
     func updateUIView(_ uiView: UITextView, context: UIViewRepresentableContext<PostBodyTextView>) {
         uiView.text = text
 
         let font = textStyle
         let fontMetrics = UIFontMetrics(forTextStyle: .largeTitle)
         uiView.font = fontMetrics.scaledFont(for: font)
 
         // We don't want the text field to become first responder every time SwiftUI refreshes the view.
         if isFirstResponder && !context.coordinator.didBecomeFirstResponder {
             uiView.becomeFirstResponder()
             context.coordinator.didBecomeFirstResponder = true
         }
     }
 }
diff --git a/iOS/PostEditor/PostTextEditingView.swift b/iOS/PostEditor/PostTextEditingView.swift
index 90a1e5c..a58fbae 100644
--- a/iOS/PostEditor/PostTextEditingView.swift
+++ b/iOS/PostEditor/PostTextEditingView.swift
@@ -1,104 +1,102 @@
 import SwiftUI
 
 struct PostTextEditingView: View {
     @Environment(\.horizontalSizeClass) var horizontalSizeClass
     @ObservedObject var post: WFAPost
     @Binding var updatingTitleFromServer: Bool
     @Binding var updatingBodyFromServer: Bool
     @State private var appearance: PostAppearance = .serif
     @State private var titleTextStyle: UIFont = UIFont(name: "Lora-Regular", size: 26)!
     @State private var titleTextHeight: CGFloat = 50
     @State private var titleIsFirstResponder: Bool = true
     @State private var bodyTextStyle: UIFont = UIFont(name: "Lora-Regular", size: 17)!
     @State private var bodyIsFirstResponder: Bool = false
-    @State private var bodyCursorPosition: UITextRange?
     private let lineSpacingMultiplier: CGFloat = 0.5
 
     init(
         post: ObservedObject<WFAPost>,
         updatingTitleFromServer: Binding<Bool>,
         updatingBodyFromServer: Binding<Bool>
     ) {
         self._post = post
         self._updatingTitleFromServer = updatingTitleFromServer
         self._updatingBodyFromServer = updatingBodyFromServer
         UITextView.appearance().backgroundColor = .clear
     }
 
     var titleFieldHeight: CGFloat {
         let minHeight: CGFloat = 50
         if titleTextHeight < minHeight {
             return minHeight
         }
         return titleTextHeight
     }
 
     var body: some View {
         VStack {
             ZStack(alignment: .topLeading) {
                 if post.title.count == 0 {
                     Text("Title (optional)")
                         .font(Font(titleTextStyle))
                         .foregroundColor(Color(UIColor.placeholderText))
                         .padding(.horizontal, 4)
                         .padding(.vertical, 8)
                 }
                 PostTitleTextView(
                     text: $post.title,
                     textStyle: $titleTextStyle,
                     height: $titleTextHeight,
                     isFirstResponder: $titleIsFirstResponder,
                     lineSpacing: horizontalSizeClass == .compact ? lineSpacingMultiplier / 2 : lineSpacingMultiplier
                 )
                 .frame(height: titleFieldHeight)
                 .onChange(of: post.title) { _ in
                     if post.status == PostStatus.published.rawValue && !updatingTitleFromServer {
                         post.status = PostStatus.edited.rawValue
                     }
                     if updatingTitleFromServer {
                         updatingTitleFromServer = false
                     }
                 }
             }
             ZStack(alignment: .topLeading) {
                 if post.body.count == 0 {
                     Text("Write…")
                         .font(Font(bodyTextStyle))
                         .foregroundColor(Color(UIColor.placeholderText))
                         .padding(.horizontal, 4)
                         .padding(.vertical, 8)
                 }
                 PostBodyTextView(
                     text: $post.body,
                     textStyle: $bodyTextStyle,
                     isFirstResponder: $bodyIsFirstResponder,
-                    currentTextPosition: $bodyCursorPosition,
                     lineSpacing: horizontalSizeClass == .compact ? lineSpacingMultiplier / 2 : lineSpacingMultiplier
                 )
                 .onChange(of: post.body) { _ in
                     if post.status == PostStatus.published.rawValue && !updatingBodyFromServer {
                         post.status = PostStatus.edited.rawValue
                     }
                     if updatingBodyFromServer {
                         updatingBodyFromServer = false
                     }
                 }
             }
         }
         .onChange(of: titleIsFirstResponder, perform: { _ in
             self.bodyIsFirstResponder.toggle()
         })
         .onAppear(perform: {
             switch post.appearance {
             case "sans":
                 self.appearance = .sans
             case "wrap", "mono", "code":
                 self.appearance = .mono
             default:
                 self.appearance = .serif
             }
             self.titleTextStyle = UIFont(name: appearance.rawValue, size: 26)!
             self.bodyTextStyle = UIFont(name: appearance.rawValue, size: 17)!
         })
     }
 }