diff --git a/quasar.cabal b/quasar.cabal
index 8859d8fcf82e236d29ad20e1ece9469a584976e3..2e9af95cf0011a2f37ac1fc295c21c447fc51491 100644
--- a/quasar.cabal
+++ b/quasar.cabal
@@ -28,6 +28,7 @@ common shared-properties
     FunctionalDependencies
     GADTs
     GeneralizedNewtypeDeriving
+    ImportQualifiedPost
     InstanceSigs
     LambdaCase
     MultiParamTypeClasses
@@ -43,6 +44,22 @@ common shared-properties
     TypeApplications
     TypeFamilies
     TypeOperators
+  default-language: Haskell2010
+  ghc-options:
+    -Weverything
+    -Wno-missing-safe-haskell-mode
+    -Wno-missing-import-lists
+    -Wno-unsafe
+    -Wno-all-missed-specialisations
+
+common shared-executable-properties
+  import: shared-properties
+  ghc-options:
+    -threaded
+    -rtsopts "-with-rtsopts=-N -I0"
+
+library
+  import: shared-properties
   build-depends:
     base >=4.7 && <5,
     binary,
@@ -54,15 +71,6 @@ common shared-properties
     template-haskell,
     transformers,
     unordered-containers,
-  default-language: Haskell2010
-  ghc-options: -fwarn-unused-do-bind -fwarn-tabs -Wall -Wincomplete-uni-patterns -Wpartial-fields
-
-common shared-executable-properties
-  import: shared-properties
-  ghc-options: -fwarn-unused-do-bind -fwarn-tabs -Wall -Wincomplete-uni-patterns -Wpartial-fields -threaded -rtsopts "-with-rtsopts=-N -I0"
-
-library
-  import: shared-properties
   exposed-modules:
     Quasar.Core
     Quasar.Observable
@@ -79,8 +87,10 @@ test-suite quasar-test
   import: shared-executable-properties
   type: exitcode-stdio-1.0
   build-depends:
-    quasar,
+    base >=4.7 && <5,
     hspec,
+    quasar,
+    unordered-containers,
   main-is: Spec.hs
   other-modules:
     Quasar.ObservableSpec
diff --git a/src/Quasar/Core.hs b/src/Quasar/Core.hs
index ce8636a03a9309eecce7bdd1f02bc3a0c085a9d4..4559e213119ab34aac14ee3d44d5c12b46868e2b 100644
--- a/src/Quasar/Core.hs
+++ b/src/Quasar/Core.hs
@@ -17,7 +17,7 @@ module Quasar.Core (
   dummyDisposable,
 ) where
 
-import qualified Data.HashMap.Strict as HM
+import Data.HashMap.Strict qualified as HM
 import Quasar.Prelude
 
 -- * Async
diff --git a/src/Quasar/Observable.hs b/src/Quasar/Observable.hs
index 73ff419da6ce29332e928f2ee7b22fb061b338c5..e042873679faf17e2881fcb3add661b43f30e323 100644
--- a/src/Quasar/Observable.hs
+++ b/src/Quasar/Observable.hs
@@ -32,7 +32,7 @@ import Control.Concurrent.MVar
 import Control.Monad.Except
 import Control.Monad.Trans.Maybe
 import Data.Binary (Binary)
-import qualified Data.HashMap.Strict as HM
+import Data.HashMap.Strict qualified as HM
 import Data.IORef
 import Data.Unique
 import Quasar.Core
@@ -40,7 +40,7 @@ import Quasar.Prelude
 
 
 data MessageReason = Current | Update
-  deriving (Eq, Show, Generic)
+  deriving stock (Eq, Show, Generic)
 instance Binary MessageReason
 
 type ObservableMessage v = (MessageReason, v)
diff --git a/src/Quasar/Observable/Delta.hs b/src/Quasar/Observable/Delta.hs
index 93c2bc27a841cfef6c7b7f09d282dfbdc9a8efe9..f92480066e8dab177a31d6e07e0e7e16ba200209 100644
--- a/src/Quasar/Observable/Delta.hs
+++ b/src/Quasar/Observable/Delta.hs
@@ -1,18 +1,18 @@
-module Quasar.Observable.Delta where
+module Quasar.Observable.Delta (
+  IsDeltaObservable(..),
+  Delta(..),
+  DeltaObservable,
+) where
 
+import Data.Binary (Binary)
+import Data.Binary qualified as B
+import Data.HashMap.Strict qualified as HM
 import Quasar.Core
 import Quasar.Observable
 import Quasar.Prelude
 
---import Conduit
-import qualified Data.HashMap.Strict as HM
-import Data.Binary (Binary)
-import qualified Data.Binary as B
-import Data.IORef
-import Data.Word (Word8)
-
 data Delta k v = Reset (HM.HashMap k v) | Insert k v | Delete k
-  deriving (Eq, Show, Generic)
+  deriving stock (Eq, Show, Generic)
 instance Functor (Delta k) where
   fmap f (Reset state) = Reset (f <$> state)
   fmap f (Insert key value) = Insert key (f value)
@@ -32,17 +32,17 @@ instance (Eq k, Hashable k, Binary k, Binary v) => Binary (Delta k v) where
 class IsObservable (HM.HashMap k v) o => IsDeltaObservable k v o | o -> k, o -> v where
   subscribeDelta :: o -> (Delta k v -> IO ()) -> IO Disposable
 
-observeHashMapDefaultImpl :: forall k v o. (Eq k, Hashable k) => IsDeltaObservable k v o => o -> (HM.HashMap k v -> IO ()) -> IO Disposable
-observeHashMapDefaultImpl o callback = do
-  hashMapRef <- newIORef HM.empty
-  subscribeDelta o (deltaCallback hashMapRef)
-  where
-    deltaCallback :: IORef (HM.HashMap k v) -> Delta k v -> IO ()
-    deltaCallback hashMapRef delta = callback =<< atomicModifyIORef' hashMapRef ((\x -> (x, x)) . applyDelta delta)
-    applyDelta :: Delta k v -> HM.HashMap k v -> HM.HashMap k v
-    applyDelta (Reset state) = const state
-    applyDelta (Insert key value) = HM.insert key value
-    applyDelta (Delete key) = HM.delete key
+--observeHashMapDefaultImpl :: forall k v o. (Eq k, Hashable k) => IsDeltaObservable k v o => o -> (HM.HashMap k v -> IO ()) -> IO Disposable
+--observeHashMapDefaultImpl o callback = do
+--  hashMapRef <- newIORef HM.empty
+--  subscribeDelta o (deltaCallback hashMapRef)
+--  where
+--    deltaCallback :: IORef (HM.HashMap k v) -> Delta k v -> IO ()
+--    deltaCallback hashMapRef delta = callback =<< atomicModifyIORef' hashMapRef ((\x -> (x, x)) . applyDelta delta)
+--    applyDelta :: Delta k v -> HM.HashMap k v -> HM.HashMap k v
+--    applyDelta (Reset state) = const state
+--    applyDelta (Insert key value) = HM.insert key value
+--    applyDelta (Delete key) = HM.delete key
 
 
 data DeltaObservable k v = forall o. IsDeltaObservable k v o => DeltaObservable o
diff --git a/src/Quasar/Observable/ObservableHashMap.hs b/src/Quasar/Observable/ObservableHashMap.hs
index e0673e7b7017f5a6756b77594a02f4b64c969790..7ac394ad90f1c4d76264214cc0235ec5572e4634 100644
--- a/src/Quasar/Observable/ObservableHashMap.hs
+++ b/src/Quasar/Observable/ObservableHashMap.hs
@@ -10,17 +10,16 @@ module Quasar.Observable.ObservableHashMap (
   lookupDelete,
 ) where
 
+import Data.HashMap.Strict qualified as HM
+import Data.Maybe (isJust)
+import Language.Haskell.TH.Syntax (mkName, nameBase)
+import Lens.Micro.Platform
 import Quasar.Core
 import Quasar.Observable
 import Quasar.Observable.Delta
 import Quasar.Prelude hiding (lookup, lookupDelete)
 import Quasar.Utils.ExtraT
 
-import qualified Data.HashMap.Strict as HM
-import Data.Maybe (isJust)
-import Language.Haskell.TH.Syntax (mkName, nameBase)
-import Lens.Micro.Platform
-
 
 newtype ObservableHashMap k v = ObservableHashMap (MVar (Handle k v))
 data Handle k v = Handle {
diff --git a/src/Quasar/Observable/ObservablePriority.hs b/src/Quasar/Observable/ObservablePriority.hs
index 86a23d822331f1eddc9cda40575b0f15baf2c698..5a09cd12a0bb5d128d134b12b6c270b34b1cc43b 100644
--- a/src/Quasar/Observable/ObservablePriority.hs
+++ b/src/Quasar/Observable/ObservablePriority.hs
@@ -4,15 +4,14 @@ module Quasar.Observable.ObservablePriority (
   insertValue,
 ) where
 
-import Quasar.Core
-import Quasar.Observable
-import Quasar.Prelude
-
-import qualified Data.HashMap.Strict as HM
+import Data.HashMap.Strict qualified as HM
 import Data.List (maximumBy)
 import Data.List.NonEmpty (NonEmpty(..), nonEmpty)
-import qualified Data.List.NonEmpty as NonEmpty
+import Data.List.NonEmpty qualified as NonEmpty
 import Data.Ord (comparing)
+import Quasar.Core
+import Quasar.Observable
+import Quasar.Prelude
 
 type Entry v = (Unique, v)
 
diff --git a/src/Quasar/Prelude.hs b/src/Quasar/Prelude.hs
index edcaccf177797faecae877c170434fb4824bba4f..cc72c750f8fe8a3d6ebb252dad560d0fee36110c 100644
--- a/src/Quasar/Prelude.hs
+++ b/src/Quasar/Prelude.hs
@@ -64,26 +64,25 @@ import Prelude hiding
     return,
     undefined,
   )
-import qualified Prelude as P
+import Prelude qualified as P
 
-import Quasar.PreludeExtras
-
-import qualified Control.Applicative
+import Control.Applicative qualified
 import Control.Concurrent.MVar
-import qualified Control.Exception
-import qualified Control.Monad
+import Control.Exception qualified
 import Control.Monad ((>=>), (<=<))
+import Control.Monad qualified
 import Control.Monad.IO.Class (MonadIO, liftIO)
-import qualified Data.Hashable as Hashable
-import qualified Data.Int
-import qualified Data.Maybe
-import qualified Data.Unique
-import qualified Data.Void
-import qualified Data.Word
-import qualified Debug.Trace as Trace
-import qualified GHC.Generics
-import qualified GHC.Stack.Types
-import qualified GHC.Types
+import Data.Hashable qualified as Hashable
+import Data.Int qualified
+import Data.Maybe qualified
+import Data.Unique qualified
+import Data.Void qualified
+import Data.Word qualified
+import Debug.Trace qualified as Trace
+import GHC.Generics qualified
+import GHC.Stack.Types qualified
+import GHC.Types qualified
+import Quasar.PreludeExtras
 
 {-# DEPRECATED head "Partial Function." #-}
 head :: [a] -> a
diff --git a/src/Quasar/PreludeExtras.hs b/src/Quasar/PreludeExtras.hs
index 9489b5af89174e39d7b5a9d50e6368ed258f9b33..d70ab6c6621b10d014a911ce8ec9001ffa821fd3 100644
--- a/src/Quasar/PreludeExtras.hs
+++ b/src/Quasar/PreludeExtras.hs
@@ -1,23 +1,25 @@
+-- This module only contains helper functions that are added to the prelude
+{-# OPTIONS_GHC -Wno-missing-export-lists #-}
+
 module Quasar.PreludeExtras where
 
 -- Use prelude from `base` to prevent module import cycle.
 import Prelude
 
-import Quasar.Utils.ExtraT
-
 import Control.Applicative (liftA2)
 import Control.Concurrent (threadDelay)
 import Control.Monad.State.Lazy as State
-import qualified Data.Char as Char
-import qualified Data.Hashable as Hashable
-import qualified Data.HashMap.Strict as HM
-import qualified Data.HashSet as HS
-import qualified Data.List as List
-import qualified Data.Maybe as Maybe
+import Data.Char qualified as Char
+import Data.HashMap.Strict qualified as HM
+import Data.HashSet qualified as HS
+import Data.Hashable qualified as Hashable
+import Data.List qualified as List
+import Data.Maybe qualified as Maybe
 import GHC.Records.Compat (HasField, getField, setField)
-import qualified GHC.Stack.Types
+import GHC.Stack.Types qualified
 import GHC.TypeLits (Symbol)
 import Lens.Micro.Platform (Lens', lens)
+import Quasar.Utils.ExtraT
 
 impossibleCodePath :: GHC.Stack.Types.HasCallStack => a
 impossibleCodePath = error "Code path marked as impossible was reached"
diff --git a/src/Quasar/Utils/ExtraT.hs b/src/Quasar/Utils/ExtraT.hs
index 72806a618dfad2d52912e3785de04eec9c060349..e1988635d5943620e675ad2c7da3ea0dcc39b043 100644
--- a/src/Quasar/Utils/ExtraT.hs
+++ b/src/Quasar/Utils/ExtraT.hs
@@ -1,4 +1,7 @@
-module Quasar.Utils.ExtraT where
+module Quasar.Utils.ExtraT (
+  ExtraT(..),
+  Extra(..),
+) where
 
 -- Use prelude from `base` to prevent module import cycle. This allows using ExtraT in PreludeExtras.
 import Prelude
diff --git a/test/Quasar/Observable/ObservableHashMapSpec.hs b/test/Quasar/Observable/ObservableHashMapSpec.hs
index 7cdbd02391042bea173715726f4fdd2978b2b8a4..e103bc5f378db185353efba95356a9a1ed37d90d 100644
--- a/test/Quasar/Observable/ObservableHashMapSpec.hs
+++ b/test/Quasar/Observable/ObservableHashMapSpec.hs
@@ -1,12 +1,12 @@
-module Quasar.Observable.ObservableHashMapSpec where
+module Quasar.Observable.ObservableHashMapSpec (spec) where
 
 import Quasar.Core
 import Quasar.Observable
 import Quasar.Observable.Delta
-import qualified Quasar.Observable.ObservableHashMap as OM
+import Quasar.Observable.ObservableHashMap qualified as OM
 
 import Control.Monad (void)
-import qualified Data.HashMap.Strict as HM
+import Data.HashMap.Strict qualified as HM
 import Data.IORef
 import Prelude
 import Test.Hspec
diff --git a/test/Quasar/Observable/ObservablePrioritySpec.hs b/test/Quasar/Observable/ObservablePrioritySpec.hs
index 8aa81cc94760d2e7902ca6bb91380bd620eeaab9..466c54de7226d090121ec2e97cd66ca8f5b80b48 100644
--- a/test/Quasar/Observable/ObservablePrioritySpec.hs
+++ b/test/Quasar/Observable/ObservablePrioritySpec.hs
@@ -1,9 +1,9 @@
-module Quasar.Observable.ObservablePrioritySpec where
+module Quasar.Observable.ObservablePrioritySpec (spec) where
 
 import Quasar.Core
 import Quasar.Observable
 import Quasar.Observable.ObservablePriority (ObservablePriority)
-import qualified Quasar.Observable.ObservablePriority as OP
+import Quasar.Observable.ObservablePriority qualified as OP
 
 import Control.Monad (void)
 import Data.IORef
diff --git a/test/Quasar/ObservableSpec.hs b/test/Quasar/ObservableSpec.hs
index d60ddd176902166bd5e63df822d07263273233e9..cbc5cfa71c76fc39085abdf678fe5900ac2b00bc 100644
--- a/test/Quasar/ObservableSpec.hs
+++ b/test/Quasar/ObservableSpec.hs
@@ -1,4 +1,4 @@
-module Quasar.ObservableSpec where
+module Quasar.ObservableSpec (spec) where
 
 import Quasar.Observable
 
diff --git a/test/Spec.hs b/test/Spec.hs
index a824f8c30c8d0402a34ed34ad58153e59f95b76f..e286043c3cdaa89fe9e09b0e534ce30346510712 100644
--- a/test/Spec.hs
+++ b/test/Spec.hs
@@ -1 +1,3 @@
 {-# OPTIONS_GHC -F -pgmF hspec-discover #-}
+{-# OPTIONS_GHC -Wno-missing-export-lists #-}
+{-# OPTIONS_GHC -Wno-prepositive-qualified-module #-}