diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+## v1.0.0.0 (2026-08-16)
+
++ Switch to using `ghc-hs-meta` when parsing interpolations, for faster compile times
+
 ## v0.3.4.0 (2024-07-09)
 
 + Fixed a performance bug causing exponential compilation times when using
diff --git a/src/lib/Data/String/Interpolate.hs b/src/lib/Data/String/Interpolate.hs
--- a/src/lib/Data/String/Interpolate.hs
+++ b/src/lib/Data/String/Interpolate.hs
@@ -62,10 +62,7 @@
 import Data.Foldable ( traverse_ )
 import Data.List     ( intercalate )
 
-import qualified Language.Haskell.Exts.Extension as Ext
-import           Language.Haskell.Exts.Parser
-  ( ParseMode(..), ParseResult(..), defaultParseMode, parseExpWithMode )
-import           Language.Haskell.Meta           ( ToExp(..) )
+import           Language.Haskell.Meta.Parse ( parseExpWithExts )
 import           Language.Haskell.TH
 import           Language.Haskell.TH.Quote       ( QuasiQuoter(..) )
 
@@ -275,12 +272,12 @@
 reifyExpression :: String -> Q Exp
 reifyExpression s = do
   -- We want to explicitly use whatever extensions are enabled in current module
-  exts      <- (fmap . fmap) (Ext.parseExtension . show) extsEnabled
-  parseMode <- pure (defaultParseMode { extensions = exts })
-  case parseExpWithMode parseMode s of
-    ParseFailed _ err  -> fail $
+  exts <- extsEnabled
+  case parseExpWithExts exts s of
+    Left (_, _, err) -> fail $
       "Data.String.Interpolate.i: got error: '" ++ err ++ "' while parsing expression: " ++ s
-    ParseOk e -> pure (toExp e)
+    Right e ->
+      pure e
 
 reportIndentWarning :: IndentWarning -> Q ()
 reportIndentWarning (IndentWarning line base) = do
diff --git a/string-interpolate.cabal b/string-interpolate.cabal
--- a/string-interpolate.cabal
+++ b/string-interpolate.cabal
@@ -1,7 +1,7 @@
 cabal-version: 1.18
 
 name:           string-interpolate
-version:        0.3.4.0
+version:        1.0.0.0
 synopsis:       Haskell string/text/bytestring interpolation that just works
 description:    Unicode-aware string interpolation that handles all textual types.
                 .
@@ -74,9 +74,8 @@
       , bytestring <0.13
       , text <2.2
       , split <0.3
-      , haskell-src-exts <1.24
-      , haskell-src-meta <0.9
-      , template-haskell <2.22
+      , ghc-hs-meta <0.2
+      , template-haskell <2.25
       , text-conversions <0.4
       , utf8-string <1.1
     default-language: Haskell2010
@@ -91,13 +90,13 @@
     build-depends:
         base ==4.*
       , string-interpolate
-      , QuickCheck <2.16
+      , QuickCheck <2.19
       , bytestring <0.13
       , text <2.2
-      , template-haskell <2.22
+      , template-haskell <2.25
       , hspec ==2.*
       , hspec-core ==2.*
-      , quickcheck-instances <0.4
+      , quickcheck-instances <0.5
       , quickcheck-text <0.2
       , quickcheck-unicode <1.1
       , unordered-containers <0.3
@@ -112,7 +111,7 @@
     build-depends:
         base ==4.*
       , string-interpolate
-      , QuickCheck <2.16
+      , QuickCheck <2.19
       , bytestring <0.13
       , text <2.2
       , deepseq <1.6
diff --git a/test/spec.hs b/test/spec.hs
--- a/test/spec.hs
+++ b/test/spec.hs
@@ -3,14 +3,14 @@
 {-# LANGUAGE DerivingStrategies         #-}
 {-# LANGUAGE FlexibleContexts           #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE LambdaCase                 #-}
 {-# LANGUAGE OverloadedStrings          #-}
 {-# LANGUAGE PackageImports             #-}
 {-# LANGUAGE QuasiQuotes                #-}
-{-# LANGUAGE TemplateHaskell            #-}
 {-# LANGUAGE ScopedTypeVariables        #-}
+{-# LANGUAGE TemplateHaskell            #-}
 {-# LANGUAGE TypeApplications           #-}
 {-# LANGUAGE TypeFamilies               #-}
-{-# LANGUAGE LambdaCase                 #-}
 
 import qualified Data.ByteString         as B
 import qualified Data.ByteString.Builder as LB
@@ -18,7 +18,7 @@
 import           Data.Char               ( chr, isSpace )
 import           Data.Foldable           ( foldMap )
 import qualified Data.HashMap.Strict     as HM
-import           Data.List               ( sort, intersperse )
+import           Data.List               ( intersperse, sort )
 import           Data.Semigroup
 import qualified Data.Text               as T
 import qualified Data.Text.Lazy          as LT
@@ -30,18 +30,18 @@
 import Control.Monad.IO.Class ( liftIO )
 
 import "hspec" Test.Hspec
-import "hspec" Test.Hspec.QuickCheck
 import "hspec-core" Test.Hspec.Core.Runner
+import "hspec" Test.Hspec.QuickCheck
 import "QuickCheck" Test.QuickCheck
 import "quickcheck-instances" Test.QuickCheck.Instances.ByteString ()
 import "QuickCheck" Test.QuickCheck.Monadic
 import "quickcheck-unicode" Test.QuickCheck.Unicode
 
-import Data.String.Interpolate ( i, iii, __i, __i'E, __i'L, iii'E, iii'L )
+import Data.String.Interpolate            ( __i, __i'E, __i'L, i, iii, iii'E, iii'L )
 import Data.String.Interpolate.Conversion hiding
-  ( build, finalize, interpolate, ofString, chompSpaces )
-import Data.String.Interpolate.Types ( InterpSegment(..) )
-import Data.String.Interpolate.Parse ( parseInterpSegments )
+  ( build, chompSpaces, finalize, interpolate, ofString )
+import Data.String.Interpolate.Parse      ( parseInterpSegments )
+import Data.String.Interpolate.Types      ( InterpSegment(..) )
 
 main :: IO ()
 main = hspecWith testConfig $ parallel $ do
@@ -535,10 +535,10 @@
     , Tabs <$> arbitrary
     ]
 
-  shrink (Verbatim t) = Verbatim <$> shrink t
+  shrink (Verbatim t)   = Verbatim <$> shrink t
   shrink (Expression t) = []
-  shrink (Spaces n) = [Spaces (n `div` 2), Spaces (n-1)]
-  shrink (Tabs n) = [Tabs (n `div` 2), Tabs (n-1)]
+  shrink (Spaces n)     = [Spaces (n `div` 2), Spaces (n-1)]
+  shrink (Tabs n)       = [Tabs (n `div` 2), Tabs (n-1)]
 
 charFrequencies :: T.Text -> HM.HashMap Char Int
 charFrequencies = T.foldl' (flip $ HM.alter increment) HM.empty . T.filter (not . isSpace)