diff --git a/Changelog.md b/Changelog.md
--- a/Changelog.md
+++ b/Changelog.md
@@ -1,5 +1,21 @@
 # Change log for unwitch project
 
+## Version 3.1.0
+
+### Added
++ New Text conversions ported from the from-text library, using explicit
+  named functions instead of typeclasses:
+  - toLazyByteStringUtf8 — encode Text as UTF-8 lazy ByteString
+  - toByteStringBuilderUtf8 — encode Text as UTF-8 ByteString Builder
+  - toTextBuilder — convert Text to lazy Text Builder
+  - toShortByteStringUtf8 — encode Text as UTF-8 ShortByteString
+  - toPosixString — encode Text as UTF-8 PosixString (GHC only)
+  - toWindowsString — encode Text as UTF-16 LE WindowsString (GHC only)
+  - toOsString — encode Text to platform-native OsString (GHC only)
++ New dependency: os-string (for OsString/PosixString/WindowsString support)
++ All new conversions are guarded behind __GLASGOW_HASKELL__ for MicroHs
+  compatibility
+
 ## Version 3.0.0
 
 ### Breaking changes (GHC only)
diff --git a/src/Unwitch/Convert/Text.hs b/src/Unwitch/Convert/Text.hs
--- a/src/Unwitch/Convert/Text.hs
+++ b/src/Unwitch/Convert/Text.hs
@@ -9,6 +9,15 @@
   , toByteStringUtf32LE
   , toByteStringUtf32BE
   , toByteStringLatin1
+#ifdef __GLASGOW_HASKELL__
+  , toLazyByteStringUtf8
+  , toByteStringBuilderUtf8
+  , toTextBuilder
+  , toShortByteStringUtf8
+  , toPosixString
+  , toWindowsString
+  , toOsString
+#endif
   )
 where
 
@@ -19,6 +28,18 @@
 import Data.Text.Encoding qualified as TE
 import Data.Text.Lazy qualified as LT
 
+#ifdef __GLASGOW_HASKELL__
+import Data.ByteString.Lazy qualified as LBS
+import Data.ByteString.Builder qualified as BB
+import Data.ByteString.Short qualified as SBS
+import Data.ByteString.Short (ShortByteString)
+import Data.Coerce (coerce)
+import Data.Text.Lazy.Builder qualified as TLB
+import System.OsString qualified as OS
+import System.OsString.Internal.Types qualified as OSIT
+import System.OsString.Posix qualified as OSP
+#endif
+
 toLazyText :: Text -> LT.Text
 #ifdef __GLASGOW_HASKELL__
 toLazyText = LT.fromStrict
@@ -56,3 +77,36 @@
 
 isLatin1 :: Char -> Bool
 isLatin1 c = c <= '\xFF'
+
+#ifdef __GLASGOW_HASKELL__
+-- | Encode as UTF-8 lazy 'LBS.ByteString'.
+toLazyByteStringUtf8 :: Text -> LBS.ByteString
+toLazyByteStringUtf8 = LBS.fromStrict . TE.encodeUtf8
+
+-- | Encode as UTF-8 'BB.Builder'.
+toByteStringBuilderUtf8 :: Text -> BB.Builder
+toByteStringBuilderUtf8 = TE.encodeUtf8Builder
+
+-- | Convert to a lazy 'TLB.Builder'.
+toTextBuilder :: Text -> TLB.Builder
+toTextBuilder = TLB.fromText
+
+-- | Encode as UTF-8 'ShortByteString'.
+toShortByteStringUtf8 :: Text -> ShortByteString
+toShortByteStringUtf8 = SBS.toShort . TE.encodeUtf8
+
+-- | Encode as UTF-8 'OSP.PosixString'.
+toPosixString :: Text -> OSP.PosixString
+toPosixString = coerce . SBS.toShort . TE.encodeUtf8
+
+-- | Encode as UTF-16 LE 'OSIT.WindowsString'.
+toWindowsString :: Text -> OSIT.WindowsString
+toWindowsString = coerce . SBS.toShort . TE.encodeUtf16LE
+
+-- | Encode to the platform's native 'OS.OsString'.
+-- UTF-16 LE on Windows, UTF-8 on POSIX.
+toOsString :: Text -> OS.OsString
+toOsString = case OS.coercionToPlatformTypes of
+  Left{}  -> coerce . toWindowsString
+  Right{} -> coerce . toPosixString
+#endif
diff --git a/test/Test/Convert/TextSpec.hs b/test/Test/Convert/TextSpec.hs
--- a/test/Test/Convert/TextSpec.hs
+++ b/test/Test/Convert/TextSpec.hs
@@ -6,6 +6,16 @@
 import qualified Unwitch.Convert.LazyText as LazyText
 import qualified Unwitch.Convert.ByteString as ByteString
 
+#ifdef __GLASGOW_HASKELL__
+import Data.ByteString.Lazy qualified as LBS
+import Data.ByteString.Builder qualified as BB
+import Data.ByteString.Short qualified as SBS
+import Data.Text.Lazy qualified as LT
+import Data.Text.Lazy.Builder qualified as TLB
+import qualified System.OsString as OS
+import qualified System.OsString.Posix as OSP
+#endif
+
 spec :: Spec
 spec = describe "Unwitch.Convert.Text" $ do
 
@@ -66,3 +76,40 @@
     it "fails for chars above 0xFF" $
       let t = T.pack "\x0100" -- Latin Extended-A
       in Text.toByteStringLatin1 t `shouldBe` Nothing
+
+#ifdef __GLASGOW_HASKELL__
+  describe "toLazyByteStringUtf8" $ do
+    it "encodes ASCII" $
+      Text.toLazyByteStringUtf8 "hello" `shouldBe` "hello"
+    it "produces same bytes as toByteStringUtf8" $
+      let t = T.pack "caf\x00E9"
+      in LBS.toStrict (Text.toLazyByteStringUtf8 t) `shouldBe` Text.toByteStringUtf8 t
+
+  describe "toByteStringBuilderUtf8" $
+    it "produces same bytes as toByteStringUtf8" $
+      let t = T.pack "caf\x00E9 \x1F600"
+      in LBS.toStrict (BB.toLazyByteString (Text.toByteStringBuilderUtf8 t))
+           `shouldBe` Text.toByteStringUtf8 t
+
+  describe "toTextBuilder" $
+    it "produces same text as input" $
+      let t = T.pack "hello \x00E9\x1F600"
+      in LT.toStrict (TLB.toLazyText (Text.toTextBuilder t)) `shouldBe` t
+
+  describe "toShortByteStringUtf8" $
+    it "produces same bytes as toByteStringUtf8" $
+      let t = T.pack "caf\x00E9 \x1F600"
+      in SBS.fromShort (Text.toShortByteStringUtf8 t) `shouldBe` Text.toByteStringUtf8 t
+
+  describe "toPosixString" $
+    it "matches encodeUtf from os-string" $
+      let t = T.pack "caf\x00E9"
+          expected = OSP.unsafeEncodeUtf (T.unpack t)
+      in Text.toPosixString t `shouldBe` expected
+
+  describe "toOsString" $
+    it "matches encodeUtf from os-string" $
+      let t = T.pack "hello/world.txt"
+          expected = OS.unsafeEncodeUtf (T.unpack t)
+      in Text.toOsString t `shouldBe` expected
+#endif
diff --git a/unwitch.cabal b/unwitch.cabal
--- a/unwitch.cabal
+++ b/unwitch.cabal
@@ -1,7 +1,7 @@
 cabal-version:      3.0
 
 name:           unwitch
-version:        3.0.0
+version:        3.1.0
 homepage:       https://github.com/jappeace/unwitch#readme
 synopsis:  converts between primitives
 description: 
@@ -80,6 +80,7 @@
   build-depends:
       base >=4.18.0.0 && <4.23,
       bytestring >= 0.10 && < 0.13,
+      os-string >= 2.0 && < 2.1,
       text >= 1.2 && < 2.2
 
   default-language: Haskell2010