diff --git a/packages/xpad.scm_explanation.md b/packages/xpad.scm_explanation.md
new file mode 100644
index 0000000..6bcd8bd
--- /dev/null
+++ b/packages/xpad.scm_explanation.md
@@ -0,0 +1,179 @@
+### Full Code Explanation:
+
+This code defines a Guix package for a Linux kernel module called `xpad-module`. Let's break it down:
+
+1. **Package Definition**:
+   - The package contains metadata such as name, version, source location (a Git repository), build system (using `linux-module-build-system`), and licensing information.
+   - It represents a Linux kernel module for Xbox controllers.
+
+    ```scheme
+    (define-public xpad-module
+      (package
+        (name "xpad-module")
+        (version "0.4")
+        (source (origin
+                  (method git-fetch)
+                  (uri (git-reference
+                        (url "https://github.com/paroj/xpad")
+                        (commit "3a215825f981643d164aa4e10fd2ab584fd9987c")))
+                  (file-name (git-file-name name version))
+                  (sha256
+                   (base32
+                    "1mh4ms5023bcj4ys3qkgchi68q1df4741pr4sv3cp4c3xf6g4ikr"))))
+        (build-system linux-module-build-system)
+        (arguments
+         (list #:tests? #f))
+        (home-page "https://github.com/paroj/xpad")
+        (synopsis
+         "Linux Kernel module for the Xbox/ Xbox 360/ Xbox One Controllers.")
+        (description
+         "Linux Kernel module for the Xbox/ Xbox 360/ Xbox One Controllers.")
+        (license license:gpl2+)))
+    ```
+
+2. **Customizing Kernel Version**:
+   - A helper function `linux-libre-module->linux-module` is defined. This function takes a Linux module package and optionally a kernel version.
+   - It creates a new package that inherits properties from the original module but substitutes the kernel version in its build arguments.
+
+    ```scheme
+    (define* (linux-libre-module->linux-module module #:optional (linux linux))
+      (package
+        (inherit module)
+        (arguments
+         (substitute-keyword-arguments (package-arguments module)
+           ((#:linux _) linux)))))
+    ```
+
+3. **Adapting for Linux Kernel 6.1**
+
+To make sure our xpad kernel module works with a specific Linux kernel version (6.1 in this case), we need to tweak the module to be built against that version. Here’s how we do it step-by-step:
+
+3.1. Defining a Variable
+
+First, we define a new variable to hold our customized module:
+
+```scheme
+
+(define xpad-module-for-linux-6.1
+  (linux-libre-module->linux-module xpad-module linux-6.1))
+```
+    What This Does: We’re creating a new variable called xpad-module-for-linux-6.1.
+
+3.2. Assigning a Value
+
+We assign this variable a value by calling a function:
+
+```scheme
+
+(linux-libre-module->linux-module xpad-module linux-6.1)
+```
+    What's Happening Here:
+        We’re calling a function named linux-libre-module->linux-module.
+        We pass it two arguments:
+            xpad-module: This is the original kernel module we defined earlier.
+            linux-6.1: This specifies the Linux kernel version we want to target.
+
+3.3. Under the Hood
+
+Let’s break down what happens inside the function:
+
+```scheme
+
+(define* (linux-libre-module->linux-module module #:optional (linux linux))
+  (package
+    (inherit module)
+    (arguments
+     (substitute-keyword-arguments (package-arguments module)
+       ((#:linux _) linux)))))
+
+    Function Definition: define* is used to define a function named linux-libre-module->linux-module.
+    Parameters:
+        module: The original kernel module package.
+        #:optional (linux linux): This allows an optional parameter linux, defaulting to a predefined value if not specified.
+
+
+Explanation of Parameters and Arguments:
+
+    module: This is the package we want to modify (in this case, xpad-module).
+    #
+    (linux linux): This parameter allows you to specify a kernel version. If you don’t provide one, it defaults to whatever is set in the environment.
+
+How Arguments Work:
+
+    Package Arguments:
+
+    ```scheme
+
+(package-arguments module)
+```
+    This function retrieves the current build arguments of the module package.
+    Arguments typically include details like the source code location, build instructions, dependencies, and other metadata needed to build the package.
+
+Substituting Arguments:
+
+scheme
+
+    (substitute-keyword-arguments (package-arguments module)
+      ((#:linux _) linux))
+
+        substitute-keyword-arguments: This function is used to modify specific arguments within the package’s build instructions.
+        Current Arguments: It takes the current arguments from the module package.
+        Substitution: It looks for the argument specified by #:linux and replaces its value with the new linux value we provided (linux-6.1).
+
+Detailed Breakdown:
+
+    Inherit:
+
+    scheme
+
+(inherit module)
+
+    This keyword means that our new package (xpad-module-for-linux-6.1) will inherit all properties from the original xpad-module.
+    Properties include the package name, version, source, build system, description, license, etc.
+
+Arguments Field:
+
+scheme
+
+    (arguments
+     (substitute-keyword-arguments (package-arguments module)
+       ((#:linux _) linux)))
+
+        arguments: This defines the build arguments for the new package.
+        substitute-keyword-arguments: This function is used to selectively replace certain arguments.
+        #
+        : This is the keyword argument we are targeting for replacement.
+        _: This is a placeholder for the current value of the #:linux argument in the original package.
+        linux: This is the new value we are assigning to the #:linux argument (i.e., linux-6.1).
+
+3.4. Variable Assignment
+
+Finally, the result of this function call is assigned to xpad-module-for-linux-6.1:
+
+scheme
+
+(define xpad-module-for-linux-6.1
+  (linux-libre-module->linux-module xpad-module linux-6.1))
+
+    What This Means: xpad-module-for-linux-6.1 now holds a version of the xpad module that is specifically configured to be built against Linux kernel version 6.1.
+
+Low-Level Details
+
+When a package is passed to a variable in Scheme, it's not just a simple copy of the code. Here’s a deeper look:
+
+    Copy by Value: The function receives the package object and copies its structure.
+    Inheritance: When using the inherit keyword, the properties (like metadata, build instructions, etc.) of the original package are duplicated in the new package.
+    Modification: The copied structure is then modified as specified (e.g., changing the kernel version in the arguments).
+
+This approach means the new package (xpad-module-for-linux-6.1) is a full-fledged package object with its own definition, derived from the original (xpad-module) but tailored for a specific kernel version.
+
+4. Summary
+
+Here’s the gist of what we’ve done:
+
+    Define the Original Module: We have a kernel module (xpad-module) ready to go.
+    Create a Custom Version: We use a function to modify this module so it’s compatible with a specific kernel version (6.1).
+    Assign the Customized Module: The result is stored in a new variable (xpad-module-for-linux-6.1), which we can use to build the module specifically for Linux 6.1.
+
+This approach allows us to flexibly adapt kernel modules for different kernel versions without manually rewriting the module for each version.
+