diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
old mode 100755
new mode 100644
index a771a08..24c31d0
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -1,5 +1,6 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
+    <option name="RIGHT_MARGIN" value="120" />
     <JetCodeStyleSettings>
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
     </JetCodeStyleSettings>
diff --git a/.idea/kotlinc.xml b/.idea/kotlinc.xml
index f8467b4..e805548 100644
--- a/.idea/kotlinc.xml
+++ b/.idea/kotlinc.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="KotlinJpsPluginSettings">
-    <option name="version" value="1.9.10" />
+    <option name="version" value="1.9.20" />
   </component>
 </project>
\ No newline at end of file
diff --git a/antipiracy/src/main/kotlin/com/kevlar/antipiracy/KevlarAntipiracy.kt b/antipiracy/src/main/kotlin/com/kevlar/antipiracy/KevlarAntipiracy.kt
index 88cdc3d..a9838e3 100755
--- a/antipiracy/src/main/kotlin/com/kevlar/antipiracy/KevlarAntipiracy.kt
+++ b/antipiracy/src/main/kotlin/com/kevlar/antipiracy/KevlarAntipiracy.kt
@@ -27,7 +27,7 @@ import java.util.concurrent.atomic.AtomicInteger
  * Main class for `:antipiracy` package.
  * */
 public class KevlarAntipiracy(
-    block: AntipiracySettingsBuilder.() -> Unit = DefaultAntipiracySettings
+    block: AntipiracySettingsBuilder.() -> Unit
 ) {
     private val settings: AntipiracySettings = AntipiracySettingsBuilder().apply(block).build()
 
@@ -47,12 +47,60 @@ public class KevlarAntipiracy(
          * */
         public fun blankAttestation(index: Int = 0): AntipiracyAttestation = AntipiracyAttestation.Blank(index)
     }
-}
 
-public val DefaultAntipiracySettings: AntipiracySettingsBuilder.() -> Unit = {
-    this.run {
-        scan {
-            pirate()
+    /**
+     * Contains relevant pre-packaged configurations for automatically configuring [KevlarAntipiracy].
+     * */
+    @Suppress("FunctionName")
+    public object Defaults {
+        public fun Full(): KevlarAntipiracy = KevlarAntipiracy(fullAntipiracySettingsDsl)
+        public fun JustPirateApps(): KevlarAntipiracy = KevlarAntipiracy(pirateOnlyAntipiracySettingsDsl)
+        public fun JustStores(): KevlarAntipiracy = KevlarAntipiracy(storeOnlyAntipiracySettingsDsl)
+        public fun PirateAndStore(): KevlarAntipiracy = KevlarAntipiracy(pirateAndStoreAntipiracySettingsDsl)
+        public fun Empty(): KevlarAntipiracy = KevlarAntipiracy(emptyAntipiracySettingsDsl)
+
+
+        private val fullAntipiracySettingsDsl: AntipiracySettingsBuilder.() -> Unit = {
+            this.run {
+                scan {
+                    pirate()
+                    store()
+                    collateral()
+                }
+            }
+        }
+
+        private val pirateOnlyAntipiracySettingsDsl: AntipiracySettingsBuilder.() -> Unit = {
+            this.run {
+                scan {
+                    pirate()
+                }
+            }
+        }
+
+        private val storeOnlyAntipiracySettingsDsl: AntipiracySettingsBuilder.() -> Unit = {
+            this.run {
+                scan {
+                    store()
+                }
+            }
+        }
+
+        private val pirateAndStoreAntipiracySettingsDsl: AntipiracySettingsBuilder.() -> Unit = {
+            this.run {
+                scan {
+                    pirate()
+                    store()
+                }
+            }
+        }
+
+        private val emptyAntipiracySettingsDsl: AntipiracySettingsBuilder.() -> Unit = {
+            this.run {
+                scan {
+                    // No scan parameters
+                }
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/docs/pages/modules/antipiracy/antipiracy.md b/docs/pages/modules/antipiracy/antipiracy.md
index 9db811e..796b5f2 100644
--- a/docs/pages/modules/antipiracy/antipiracy.md
+++ b/docs/pages/modules/antipiracy/antipiracy.md
@@ -30,32 +30,12 @@ Each attestation request will cause Kevlar to grab the package list, run the app
 
 The settings you provide influence what will be included in the attestation.
 
-??? note "Empty & default settings"
-	The settings on `antipiracy` are additive. If you leave a blank DSL, nothing will be detected, because no checks will be run, because the settings are empty. 
-
-	If you do not pass a DSL at all, the default settings will be used (they only scan for pirate apps, not stores nor collateral).
-
-	```kotlin title="Custom"
-    private val antipiracy = KevlarAntipiracy {
-        scan {
-            pirate()
-            store()
-            collateral()
-        }
-    }
-	```
 
-	```kotlin title="Empty"
-    private val antipiracy = KevlarAntipiracy {
-        scan {
 
-		}
-    }
-	```
 
-	```kotlin title="Default"
-    private val antipiracy = KevlarAntipiracy()
-	```
+
+
+
 
 
 ## Attestation process overview
@@ -87,4 +67,41 @@ Scan settings are taken into account intelligently to analyze and run the batter
 	
 	The full attestation process takes from start to finish ≈ 75-200ms for my devices and emulators (assuming the full app list is returned, which it won't for Android 11+ [which is actually good news for performance, since the time taken for computing the whole attestation is linearly proportional to the number of applications returned by `PackageManager`]). It is mainly influenced by the processing power of the device, the number of apps installed, and your scan configuration.
 
-	It is decently fast, given that it will be run in the background before business-critical transactions (e.g. when the user clicks "purchase", we first check that the device is clean and then actually contact Google Play to initiate the transaction).
\ No newline at end of file
+	It is decently fast, given that it is intended to be run quickly in the background before business-critical transactions (e.g. when the user clicks "purchase", we first check that the device is clean and then actually contact Google Play to initiate the high-value transaction).
+
+
+
+
+
+
+
+
+# Configuring `KevlarAntipiracy`
+The antipiracy module is easy to configure, since it works automatically: you just have to choose which search criteria is used.
+
+You may choose to configure the antipiracy module manually (using the dedicated DSL, more flexibility), or just using one of the default configurations.
+
+
+```kotlin title="Default Configurations"
+private val antipiracy = KevlarAntipiracy.Defaults.Full()
+```
+
+```kotlin title="Manual DSL"
+private val antipiracy = KevlarAntipiracy {
+    scan {
+        pirate()
+        collateral()
+    }
+}
+```
+
+You can find more information about each individual item in the [reference](reference.md) page.
+
+
+The settings are additive. If you leave a blank DSL, nothing will be detected, because no checks will be run, because the settings are empty.
+
+```kotlin title="Empty"
+private val antipiracy = KevlarAntipiracy {
+    scan {}
+}
+```
diff --git a/docs/pages/modules/integrity/integrity.md b/docs/pages/modules/integrity/integrity.md
index 45230ee..a445048 100644
--- a/docs/pages/modules/integrity/integrity.md
+++ b/docs/pages/modules/integrity/integrity.md
@@ -36,41 +36,9 @@ It is capable of detecting:
 To [implement](implementation.md) this, you initialize `KevlarIntegrity` and provide your desired settings (which influence what is to be checked and what not). Then you can submit attestation requests (which will be executed according to your settings).
 
 
-??? note "Empty & default settings"
-    The settings on `integrity` are additive. If you leave a blank DSL, nothing will be detected, because no checks will be run, because the settings are empty.
-
-    By default, only `debug` and `installer` checks are enbabled, since you need to provide additional arguments to enable `signature` and `packageName`
-
-    If you do not pass a DSL at all, the default settings will be used (they scan for signature, package name, and debug).
-
-    ```kotlin title="Custom (simplified)"
-    private val integrity = KevlarIntegrity {
-        checks {
-            packageName() {
-                // Allowed package name
-                hardcodedPackageName("com.kevlar.showcase")
-            }
-            signature() {
-                // Allowed signature
-                hardcodedSignatures("J+nqXLfuIO8B2AmhkMYHGE4jDyw=")
-            }
-            debug()
-            installer()
-        }
-    }
-    ```
 
-    ```kotlin title="Empty"
-    private val integrity = KevlarIntegrity {
-        checks {
 
-        }
-    }
-    ```
 
-    ```kotlin title="Default"
-    private val integrity = KevlarIntegrity()
-    ```
 
 
 ## Attestation process overview
@@ -90,5 +58,52 @@ The attestation is returned in `IntegrityAttestation` (it is a sealed class), wh
 !!! warning
     `Blank` is completely different from `Clear` (or `Failed`). It means that the software is initialized but that nothing has been done yet. Do not mix them up.
 
+
+
+
+
+
+
+## Configuring `KevlarIntegrity`
+The integrity module requires attentive and detailed configuration (since kevlar needs the "real" data that will be compared at against the runtime values when your app executes). 
+You can find details on the process of configuring and retrieving the necessary data in the [implementation](implementation.md) page.
+
+Thus there are no default configuration: you have to manually specify each item through the DSL.
+
+```kotlin title="Manual configuration (simplified)"
+private val integrity = KevlarIntegrity {
+    checks {
+        packageName() {
+            // Allowed package name
+            hardcodedPackageName("com.kevlar.showcase")
+        }
+        signature() {
+            // Allowed signature
+            hardcodedSignatures("J+nqXLfuIO8B2AmhkMYHGE4jDyw=")
+        }
+        debug()
+        installer()
+    }
+}
+```
+
+You can find more information about each individual item in the [reference](reference.md) page.
+
+The settings are additive. If you leave a blank DSL, nothing will be detected, because no checks will be run, because the settings are empty.
+
+```kotlin title="Empty"
+private val integrity = KevlarIntegrity {
+    checks {}
+}
+```
+
+
+
+
+
+
+
+
+
 ## Use cases
 This is a pretty typical scenario for any application where it is critical to preserve self-integrity and run unmodified code.
\ No newline at end of file
diff --git a/docs/pages/modules/rooting/implementation.md b/docs/pages/modules/rooting/implementation.md
index ff1fc59..266d407 100644
--- a/docs/pages/modules/rooting/implementation.md
+++ b/docs/pages/modules/rooting/implementation.md
@@ -75,7 +75,6 @@ private val rooting = KevlarRooting {
         root()
         magisk()
         busybox()
-        toybox()
         xposed()
     }
 
diff --git a/docs/pages/modules/rooting/reference.md b/docs/pages/modules/rooting/reference.md
new file mode 100644
index 0000000..371d4b3
--- /dev/null
+++ b/docs/pages/modules/rooting/reference.md
@@ -0,0 +1,42 @@
+# Reference
+
+The complete rooting configuration is as follows.
+
+```kotlin title="Complete Rooting settings"
+private val rooting = KevlarRooting {
+    targets {
+        root()
+        magisk()
+        busybox()
+        xposed()
+    }
+
+    status {
+        testKeys()
+        emulator()
+        selinux {
+            flagPermissive()
+        }
+    }
+
+    allowExplicitRootCheck()
+}
+```
+
+
+!!! warning
+	Bear in mind, this kind of configuration is exhaustive and should be used just in a few cases where you *really* need to detect all of those conditions.
+	Only including what your application's security environment requires is a key step in properly configuring the library.
+
+
+Unlike other Kevlar modules, here you can actually require two different types of attestation: you have `attestateTargets` and `attestateRooting`.
+Once you require the attestation through any of those two methods, any discrepancies between your expected configuration (w.r.t. the invoked attestation type) and the actual device status will be reported back to you.
+
+```kotlin
+withContext(externalDispatcher) {
+    val targetAttestation = rooting.attestateTargets(context)
+    val statusAttestation = rooting.attestateStatus()
+}
+```
+
+
diff --git a/docs/pages/modules/rooting/rooting.md b/docs/pages/modules/rooting/rooting.md
index b511ec6..b735899 100644
--- a/docs/pages/modules/rooting/rooting.md
+++ b/docs/pages/modules/rooting/rooting.md
@@ -22,16 +22,16 @@ It produces two different kinds of attestations: one searching for system modifi
 
 It is capable of detecting the following system modifications (through the `targets` attestation)
 
-- root access;
-- magisk installations (not hidden);
-- busybox binaries;
-- toybox binaries;
+- Root access;
+- Magisk installations (not hidden);
+- Busybox binaries;
+- Toybox binaries;
 - Xposed framework.
 
 And the following system conditions (through the `status` attestation)
 
-- emulator execution;
-- test keys;
+- Emulator execution;
+- Test keys;
 - SELinux status.
 
 
@@ -48,40 +48,11 @@ Depending on what you need to check, you may choose one or run both.
 
 To [implement](implementation.md) this, you initialize `KevlarRooting` and provide your desired settings (which influence what is to be checked and what not). Then you can submit attestation requests of whichever kind you prefer (which will be executed according to your settings).
 
-??? note "Empty & default settings"
-    The settings on `rooting` are additive. If you leave a blank DSL, nothing will be detected, because no checks will be run, because the settings are empty.
 
-    If you do not pass a DSL at all, the default settings will be used (they only scan for root access and emulator + SELinux).
 
-    ```kotlin title="Custom"
-    private val rooting = KevlarRooting {
-        targets {
-            root()
-            magisk()
-            busybox()
-        }
 
-        status {
-            emulator()
-            selinux {
-                flagPermissive()
-            }
-        }
 
-        allowExplicitRootCheck()
-    }
-    ```
-
-    ```kotlin title="Empty"
-    private val rooting = KevlarRooting {
-        targets {}
-        status {}
-    }
-    ```
 
-    ```kotlin title="Default"
-    private val rooting = KevlarRooting()
-    ```
 
 
 ## Attestation process overview
@@ -96,7 +67,7 @@ When you require an attestation, kevlar performs the following operations:
 
 - for the **status attestation** (through `rooting.attestateStatus()`):
     
-    1.  Depending on what system condition you selected, the appropriate check for that system status flag is initialized and ran;
+    1. Depending on what system condition you selected, the appropriate check for that system status flag is initialized and ran;
     2. The results are collected, processed, filtered, and returned.
 
 
@@ -111,5 +82,60 @@ The attestation is returned either in `TargetRootingAttestation` or `StatusRooti
     `Blank` is completely different from `Clear` (or `Failed`). It means that the software is initialized but that nothing has been done yet. Do not mix them up.
 
 
+
+## Configuring `KevlarRooting`
+Configuring the rooting module requires a bit of android technical knowledge, since you have to be aware of which items you are enabling.
+
+You may choose to configure the rooting module manually (using the dedicated DSL, more flexibility), or just grabbing one of the default configurations (which are the most commonly used and don't need DSL configuration)
+
+```kotlin title="Manual DSL Configuration"
+private val rooting = KevlarRooting {
+    targets {
+        root()
+        magisk()
+        busybox()
+    }
+
+    status {
+        emulator()
+        selinux {
+            flagPermissive()
+        }
+    }
+
+    allowExplicitRootCheck()
+}
+```
+
+
+```kotlin title="Default Configuration"
+private val rooting = KevlarRooting.Defaults.Standard()
+```
+
+You can find more information about each individual item in the [reference](reference.md) page.
+
+
+The settings are additive. If you leave a blank DSL, nothing will be detected, because no checks will be run, because the settings are empty.
+
+```kotlin title="Empty"
+private val rooting = KevlarRooting {
+    targets {}
+    status {}
+}
+```
+
+```kotlin title="Default"
+private val rooting = KevlarRooting()
+```
+
+
+
+
+
+
+
+
+
+
 ## Use cases
 This is a pretty typical scenario for any banking/financial application, game, or software managing sensitive resources (files, records, data)
\ No newline at end of file
diff --git a/integrity/src/main/kotlin/com/kevlar/integrity/KevlarIntegrity.kt b/integrity/src/main/kotlin/com/kevlar/integrity/KevlarIntegrity.kt
index fa6b527..141affc 100755
--- a/integrity/src/main/kotlin/com/kevlar/integrity/KevlarIntegrity.kt
+++ b/integrity/src/main/kotlin/com/kevlar/integrity/KevlarIntegrity.kt
@@ -25,7 +25,7 @@ import com.kevlar.integrity.dsl.settings.IntegritySettingsBuilder
 import java.util.concurrent.atomic.AtomicInteger
 
 public class KevlarIntegrity(
-    block: IntegritySettingsBuilder.() -> Unit = DefaultIntegritySettings
+    block: IntegritySettingsBuilder.() -> Unit
 ) {
     private val settings: IntegritySettings = IntegritySettingsBuilder().apply(block).build()
 
@@ -46,7 +46,6 @@ public class KevlarIntegrity(
          * */
         public fun blankAttestation(index: Int = 0): IntegrityAttestation = IntegrityAttestation.Blank(index)
 
-
         /**
          * Returns the current running application (oldest) signature.
          * */
@@ -56,17 +55,5 @@ public class KevlarIntegrity(
          * Returns the current running application signatures.
          * */
         public fun obtainCurrentAppSignatures(context: Context): List<String> = obtainBase64EncodedSignatures(context)
-
     }
 }
-
-public val DefaultIntegritySettings: IntegritySettingsBuilder.() -> Unit = {
-    this.run {
-        checks {
-            // signature()
-            // packageName()
-            debug()
-            installer()
-        }
-    }
-}
\ No newline at end of file
diff --git a/mkdocs.yml b/mkdocs.yml
index bebc469..5a5e072 100755
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -57,6 +57,14 @@ plugins:
           lang: en
     - redirects:
           redirect_maps:
+    - minify:
+          minify_html: true
+          minify_js: true
+          minify_css: true
+          htmlmin_opts:
+              remove_comments: true
+          cache_safe: true
+
 
 
 nav:
@@ -78,6 +86,7 @@ nav:
           - 'Tradeoffs' : pages/modules/antipiracy/tradeoffs.md
     - 'Rooting':
           - 'Overview' : pages/modules/rooting/rooting.md
+          - 'Reference' : pages/modules/rooting/reference.md
           - 'Implementation' : pages/modules/rooting/implementation.md
           - 'Internals' : pages/modules/rooting/internals.md
     - 'Integrity':
@@ -102,7 +111,7 @@ markdown_extensions:
     - abbr
     - admonition
     - pymdownx.emoji:
-          emoji_index: !!python/name:materialx.emoji.twemoji
+          emoji_index: !!python/name:material.extensions.emoji.twemoji
           emoji_generator: !!python/name:materialx.emoji.to_svg
     - def_list
     - md_in_html
diff --git a/rooting/src/main/kotlin/com/kevlar/rooting/KevlarRooting.kt b/rooting/src/main/kotlin/com/kevlar/rooting/KevlarRooting.kt
index 0b34eee..d44f311 100755
--- a/rooting/src/main/kotlin/com/kevlar/rooting/KevlarRooting.kt
+++ b/rooting/src/main/kotlin/com/kevlar/rooting/KevlarRooting.kt
@@ -29,7 +29,7 @@ import java.util.concurrent.atomic.AtomicInteger
  * Entry class for `:rooting` package.
  * */
 public class KevlarRooting(
-    block: RootingSettingsBuilder.() -> Unit = DefaultRootingSettings
+    block: RootingSettingsBuilder.() -> Unit
 ) {
     private val settings: RootingSettings = RootingSettingsBuilder().apply(block).build()
 
@@ -68,21 +68,91 @@ public class KevlarRooting(
          * */
         public fun blankStatusAttestation(index: Int = 0): StatusRootingAttestation = StatusRootingAttestation.Blank(index)
     }
-}
 
 
-/**
- * Default settings for [KevlarRooting].
- * */
-public val DefaultRootingSettings: RootingSettingsBuilder.() -> Unit = {
-    this.run {
-        targets {
-            root()
+
+    /**
+     * Contains relevant pre-packaged configurations for automatically configuring [KevlarRooting].
+     * */
+    @Suppress("FunctionName", "ObjectPrivatePropertyName")
+    public object Defaults {
+        public fun Standard(): KevlarRooting = KevlarRooting(stdRootingSettingsDsl)
+        public fun JustRooting(): KevlarRooting = KevlarRooting(rootSettingsDsl(explicit = false))
+        public fun JustRootingExplicit(): KevlarRooting = KevlarRooting(rootSettingsDsl(explicit = true))
+        public fun JustEmulator(): KevlarRooting = KevlarRooting(emulatorSettingsDsl)
+        public fun Empty(): KevlarRooting = KevlarRooting(emptyRootingSettingsDsl)
+        private fun Exhaustive(): KevlarRooting = KevlarRooting(__exhaustiveRootingSettingsDsl)
+
+
+        private val stdRootingSettingsDsl: RootingSettingsBuilder.() -> Unit = {
+            this.run {
+                targets {
+                    root()
+                    magisk()
+                }
+
+                status {
+                    emulator()
+                    selinux {
+                        flagPermissive()
+                    }
+                    testKeys()
+                }
+            }
         }
 
-        status {
-            emulator()
-            selinux()
+        private fun rootSettingsDsl(explicit: Boolean): RootingSettingsBuilder.() -> Unit = {
+            this.run {
+                targets {
+                    root()
+                    magisk()
+                }
+
+                status {}
+
+                if (explicit) {
+                    allowExplicitRootCheck()
+                }
+            }
+        }
+
+        private val emulatorSettingsDsl: RootingSettingsBuilder.() -> Unit = {
+            this.run {
+                targets {}
+
+                status {
+                    emulator()
+                    testKeys()
+                }
+            }
+        }
+
+        private val emptyRootingSettingsDsl: RootingSettingsBuilder.() -> Unit = {
+            this.run {
+                targets {}
+                status {}
+            }
+        }
+
+        private val __exhaustiveRootingSettingsDsl: RootingSettingsBuilder.() -> Unit = {
+            this.run {
+                targets {
+                    root()
+                    magisk()
+                    busybox()
+                    xposed()
+                }
+
+                status {
+                    testKeys()
+                    emulator()
+                    selinux {
+                        flagPermissive()
+                    }
+                }
+
+                allowExplicitRootCheck()
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/rooting/src/main/kotlin/com/kevlar/rooting/dsl/settings/RootingSettings.kt b/rooting/src/main/kotlin/com/kevlar/rooting/dsl/settings/RootingSettings.kt
index 9d1181f..dedaef1 100755
--- a/rooting/src/main/kotlin/com/kevlar/rooting/dsl/settings/RootingSettings.kt
+++ b/rooting/src/main/kotlin/com/kevlar/rooting/dsl/settings/RootingSettings.kt
@@ -47,6 +47,10 @@ public data class RootingSettings(
 public class RootingSettingsBuilder : DslBuilder<RootingSettings>() {
     private var systemTargets: SystemTargets = SystemTargets.default()
     private var systemStatus: SystemStatus = SystemStatus.default()
+
+    /**
+     * Whether root access can be requested directly through shell commands
+     * */
     private var allowExplicitRootCheck: Boolean = false
 
     public fun targets(block: SystemTargetsBuilder.() -> Unit) {
@@ -58,11 +62,13 @@ public class RootingSettingsBuilder : DslBuilder<RootingSettings>() {
     }
 
     /**
-     * By default kevlar does not run the `su` binary. Instead, it passively analyzes the
-     * system environment to detect root access.
+     * By default kevlar does not run the `su` binary.
+     * Instead, it passively analyzes the system environment to detect root access.
      *
      * If you don't mind having your application ask for root permission, you can enable this
      * flag, so that kevlar will be trying to acquire root access as an additional check.
+     *
+     * It is an aggressive type of detection. Use with care.
      * */
     public fun allowExplicitRootCheck() {
         allowExplicitRootCheck = true
diff --git a/showcase/build.gradle b/showcase/build.gradle
index 72e81b0..a02c32c 100755
--- a/showcase/build.gradle
+++ b/showcase/build.gradle
@@ -50,7 +50,7 @@ android {
     namespace 'com.kevlar.showcase'
 }
 
-def local = false
+def local = true
 
 dependencies {
     /**
diff --git a/showcase/src/main/kotlin/com/kevlar/showcase/data/repo/AntipiracyRepository.kt b/showcase/src/main/kotlin/com/kevlar/showcase/data/repo/AntipiracyRepository.kt
index 226d285..e71e6d6 100755
--- a/showcase/src/main/kotlin/com/kevlar/showcase/data/repo/AntipiracyRepository.kt
+++ b/showcase/src/main/kotlin/com/kevlar/showcase/data/repo/AntipiracyRepository.kt
@@ -32,7 +32,9 @@ class AntipiracyRepository @Inject constructor(
     @ApplicationContext val context: Context,
     @IoDispatcher val externalDispatcher: CoroutineDispatcher
 ) {
-    private val antipiracy = KevlarAntipiracy {
+    private val antipiracyAuto = KevlarAntipiracy.Defaults.JustPirateApps()
+
+    private val antipiracyManual = KevlarAntipiracy {
         scan {
             pirate()
             store()
@@ -41,6 +43,6 @@ class AntipiracyRepository @Inject constructor(
     }
 
     suspend fun attestate(): AntipiracyAttestation = withContext(externalDispatcher) {
-        antipiracy.attestate(context)
+        antipiracyManual.attestate(context)
     }
 }
\ No newline at end of file
diff --git a/showcase/src/main/kotlin/com/kevlar/showcase/data/repo/RootingRepository.kt b/showcase/src/main/kotlin/com/kevlar/showcase/data/repo/RootingRepository.kt
index f2d551c..372a4ee 100755
--- a/showcase/src/main/kotlin/com/kevlar/showcase/data/repo/RootingRepository.kt
+++ b/showcase/src/main/kotlin/com/kevlar/showcase/data/repo/RootingRepository.kt
@@ -33,12 +33,13 @@ class RootingRepository @Inject constructor(
     @ApplicationContext val context: Context,
     @IoDispatcher val externalDispatcher: CoroutineDispatcher
 ) {
+    private val rootingAuto = KevlarRooting.Defaults.JustRootingExplicit()
+
     private val rooting = KevlarRooting {
         targets {
             root()
             magisk()
             busybox()
-            toybox()
             xposed()
         }
 
diff --git a/showcase/src/main/kotlin/com/kevlar/showcase/ui/activities/antipiracy/AntipiracyActivity.kt b/showcase/src/main/kotlin/com/kevlar/showcase/ui/activities/antipiracy/AntipiracyActivity.kt
index 5f1ba5b..62faecc 100755
--- a/showcase/src/main/kotlin/com/kevlar/showcase/ui/activities/antipiracy/AntipiracyActivity.kt
+++ b/showcase/src/main/kotlin/com/kevlar/showcase/ui/activities/antipiracy/AntipiracyActivity.kt
@@ -16,6 +16,7 @@
 
 package com.kevlar.showcase.ui.activities.antipiracy
 
+import android.annotation.SuppressLint
 import android.os.Bundle
 import android.view.View
 import androidx.activity.viewModels
@@ -41,6 +42,7 @@ class AntipiracyActivity : AppCompatActivity() {
 
     private lateinit var binding: AntipiracyActivityBinding
 
+    @SuppressLint("SetTextI18n")
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         binding = DataBindingUtil.setContentView(this, R.layout.antipiracy_activity)
diff --git a/showcase/src/main/kotlin/com/kevlar/showcase/ui/activities/integrity/IntegrityActivity.kt b/showcase/src/main/kotlin/com/kevlar/showcase/ui/activities/integrity/IntegrityActivity.kt
index 0e08f24..0d56246 100755
--- a/showcase/src/main/kotlin/com/kevlar/showcase/ui/activities/integrity/IntegrityActivity.kt
+++ b/showcase/src/main/kotlin/com/kevlar/showcase/ui/activities/integrity/IntegrityActivity.kt
@@ -16,6 +16,7 @@
 
 package com.kevlar.showcase.ui.activities.integrity
 
+import android.annotation.SuppressLint
 import android.os.Bundle
 import android.util.Log
 import android.view.View
@@ -45,6 +46,7 @@ class IntegrityActivity : AppCompatActivity() {
 
     private lateinit var binding: IntegrityActivityBinding
 
+    @SuppressLint("SetTextI18n")
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         binding = DataBindingUtil.setContentView(this, R.layout.integrity_activity)
diff --git a/showcase/src/main/kotlin/com/kevlar/showcase/ui/activities/main/MainActivity.kt b/showcase/src/main/kotlin/com/kevlar/showcase/ui/activities/main/MainActivity.kt
index 7a07cc2..8c5f83f 100755
--- a/showcase/src/main/kotlin/com/kevlar/showcase/ui/activities/main/MainActivity.kt
+++ b/showcase/src/main/kotlin/com/kevlar/showcase/ui/activities/main/MainActivity.kt
@@ -31,6 +31,7 @@
  */
 package com.kevlar.showcase.ui.activities.main
 
+import android.annotation.SuppressLint
 import android.content.Intent
 import android.os.Bundle
 import android.util.Log
@@ -44,6 +45,7 @@ import com.kevlar.showcase.ui.activities.antipiracy.AntipiracyActivity
 import com.kevlar.showcase.ui.activities.integrity.IntegrityActivity
 import com.kevlar.showcase.ui.activities.rooting.RootingActivity
 import dagger.hilt.android.AndroidEntryPoint
+import timber.log.Timber
 
 @AndroidEntryPoint
 class MainActivity : AppCompatActivity() {
@@ -52,6 +54,7 @@ class MainActivity : AppCompatActivity() {
 
     private lateinit var binding: ActivityMainBinding
 
+    @SuppressLint("SetTextI18n")
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         binding = DataBindingUtil.setContentView(this, R.layout.activity_main)
@@ -76,6 +79,6 @@ class MainActivity : AppCompatActivity() {
             }
         }
 
-        Log.d("Signatures", KevlarIntegrity.obtainCurrentAppSignatures(applicationContext).toString())
+        Timber.tag("Signatures").d(KevlarIntegrity.obtainCurrentAppSignatures(applicationContext).toString())
     }
 }
\ No newline at end of file
diff --git a/showcase/src/main/kotlin/com/kevlar/showcase/ui/activities/rooting/RootingActivity.kt b/showcase/src/main/kotlin/com/kevlar/showcase/ui/activities/rooting/RootingActivity.kt
index 150a9bb..da19724 100755
--- a/showcase/src/main/kotlin/com/kevlar/showcase/ui/activities/rooting/RootingActivity.kt
+++ b/showcase/src/main/kotlin/com/kevlar/showcase/ui/activities/rooting/RootingActivity.kt
@@ -16,6 +16,7 @@
 
 package com.kevlar.showcase.ui.activities.rooting
 
+import android.annotation.SuppressLint
 import android.os.Bundle
 import android.view.View
 import androidx.activity.viewModels
@@ -43,6 +44,7 @@ class RootingActivity : AppCompatActivity() {
 
     private lateinit var binding: RootingActivityBinding
 
+    @SuppressLint("SetTextI18n")
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         binding = DataBindingUtil.setContentView(this, R.layout.rooting_activity)
@@ -52,16 +54,16 @@ class RootingActivity : AppCompatActivity() {
                 vm.rootAttestation.collectLatest {
                     when (it) {
                         is TargetRootingAttestation.Blank -> {
-                            binding.debugText1.text = "Blank attestation"
+                            binding.debugText1.text = "Blank Rooting attestation\n"
                             binding.progressBar.visibility = View.VISIBLE
                         }
                         is TargetRootingAttestation.Clear -> {
-                            binding.debugText1.text = "Clear attestation"
+                            binding.debugText1.text = "Clear Rooting attestation\n"
                             binding.progressBar.visibility = View.GONE
                         }
                         is TargetRootingAttestation.Failed -> {
                             binding.debugText1.text = buildString {
-                                appendLine("Failed attestation")
+                                appendLine("Failed Rooting attestation")
                                 appendLine()
 
                                 it.detectedTargets.detectedTargets.forEachIndexed { i, it: DetectableSystemTarget ->
@@ -83,16 +85,16 @@ class RootingActivity : AppCompatActivity() {
                 vm.statusAttestation.collectLatest {
                     when (it) {
                         is StatusRootingAttestation.Blank -> {
-                            binding.debugText2.text = "Blank attestation"
+                            binding.debugText2.text = "Blank Status attestation\n"
                             binding.progressBar.visibility = View.VISIBLE
                         }
                         is StatusRootingAttestation.Clear -> {
-                            binding.debugText2.text = "Clear attestation"
+                            binding.debugText2.text = "Clear Status attestation\n"
                             binding.progressBar.visibility = View.GONE
                         }
                         is StatusRootingAttestation.Failed -> {
                             binding.debugText2.text = buildString {
-                                appendLine("Failed attestation")
+                                appendLine("Failed Status attestation")
                                 appendLine()
 
                                 it.status.detectedStatuses.forEachIndexed { i, it: DetectableSystemStatus ->
@@ -109,6 +111,9 @@ class RootingActivity : AppCompatActivity() {
 
         CoroutineScope(Dispatchers.Main).launch {
             vm.requestAttestationRoot()
+        }
+
+        CoroutineScope(Dispatchers.Main).launch {
             vm.requestAttestationStatus()
         }
     }