diff --git a/python-ofensivo/08_librerias/05_threading.py b/python-ofensivo/08_librerias/05_threading.py
new file mode 100644
index 0000000..deb870f
--- /dev/null
+++ b/python-ofensivo/08_librerias/05_threading.py
@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""
+La librería threading nos permite crear hilos de ejecución en Python.
+Un hilo es un flujo de ejecución separado que puede ejecutar código 
+simultáneamente con otros hilos de ejecución de nuestro programa.
+
+Los hilos nos permiten ejecutar código concurrente en nuestro programa.
+
+Es importante tener en cuenta que el uso de hilos puede introducir problemas de 
+concurrencia, como condiciones de carrera, por lo que debes tener cuidado al 
+manipular datos compartidos entre hilos. 
+
+"""
+
+import threading
+import time
+
+
+def tarea(num_tarea):
+
+    print(f"\n[+] Hilo {num_tarea} iniciada")
+
+    time.sleep(2)
+
+    print(f"\n[+] Hilo {num_tarea} finalizada")
+
+# Configurar los hilos
+thread1 = threading.Thread(target=tarea, args=(1,))
+thread2 = threading.Thread(target=tarea, args=(2,))
+
+# Iniciar los hilos
+thread1.start()
+thread2.start()
+
+# Esperar a que los hilos terminen
+thread1.join()
+thread2.join()
+
+print(f"\n[+] Los hilos han finalizado con éxito")
diff --git a/python-ofensivo/08_librerias/06_multiprocessing.py b/python-ofensivo/08_librerias/06_multiprocessing.py
new file mode 100644
index 0000000..3d74032
--- /dev/null
+++ b/python-ofensivo/08_librerias/06_multiprocessing.py
@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""
+La librería multiprocessing permite crear procesos en Python. 
+Cada proceso tiene su propio espacio de memoria, por lo que no comparten 
+variables. 
+Para comunicar procesos se utilizan tuberías (pipes) o colas (queues). 
+La librería multiprocessing también permite crear hilos (threads) con la clase 
+Thread. Los hilos son procesos ligeros que comparten memoria y recursos. 
+Los hilos se utilizan para ejecutar tareas en paralelo. 
+En este ejemplo se crean dos hilos que ejecutan la misma tarea. 
+La función time.sleep() se utiliza para simular una tarea que tarda un tiempo en 
+ejecutarse. La función join() se utiliza para esperar a que los hilos terminen. 
+La función join() bloquea el hilo principal hasta que los hilos terminan. 
+La función is_alive() se utiliza para comprobar si un hilo está en ejecución. 
+La función enumerate() se utiliza para obtener una lista de los hilos en 
+ejecución. 
+La función active_count() se utiliza para obtener el número de hilos en 
+ejecución.
+
+"""
+
+import multiprocessing
+import time
+
+
+def tarea(num_tarea):
+
+    print(f"\n[+] Proceso {num_tarea} iniciada")
+
+    time.sleep(2)
+
+    print(f"\n[+] Proceso {num_tarea} finalizada")
+
+
+proceso1 = multiprocessing.Process(target=tarea, args=(1,))
+proceso2 = multiprocessing.Process(target=tarea, args=(2,))
+
+proceso1.start()
+proceso2.start()
+
+proceso1.join()
+proceso2.join()
+
+print(f"\n[+] Los procesos han finalizado")
diff --git a/python-ofensivo/08_librerias/07_threading_vs_multiprocessing.py b/python-ofensivo/08_librerias/07_threading_vs_multiprocessing.py
new file mode 100644
index 0000000..e9c7562
--- /dev/null
+++ b/python-ofensivo/08_librerias/07_threading_vs_multiprocessing.py
@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""
+Ejemplo práctico para ver la diferencia entre ejecutar un programa con hilos, con procesos y 
+sin ninguno de los anteriores.
+
+"""
+
+import time
+import requests
+import threading
+import multiprocessing
+
+dominios = {
+    "https://google.com",
+    "https://xvideos.com",
+    "https://wikimedia.org",
+    "https://yahoo.com"
+}
+
+# Ejecución sin hilos ni procesos separados
+start_time = time.time()
+
+for url in dominios:
+
+    r = requests.get(url)
+    print(
+        f"\n[+] URL {url}: {len(r.content)} bytes"
+    )
+
+
+end_time = time.time()
+
+print(
+    f"\n[i] Tiempo de ejecución SIN hilos: {end_time - start_time} segundos\n"
+)
+
+
+def realizar_peticion(url):
+
+    r = requests.get(url)
+    print(
+        f"\n[+] URL {url}: {len(r.content)} bytes"
+    )
+
+
+# Ejecución con hilos
+start_time = time.time()
+
+hilos = []
+for url in dominios:
+
+    hilo = threading.Thread(
+        target=realizar_peticion,
+        args=(url,)
+    )
+    hilo.start()
+    hilos.append(hilo)
+
+for hilo in hilos:
+
+    hilo.join()
+
+end_time = time.time()
+
+print(
+    f"\n[i] Tiempo de ejecución CON hilos: {end_time - start_time} segundos\n"
+)
+
+
+# Ejecución con procesos
+start_time = time.time()
+
+procesos = []
+for url in dominios:
+
+    proceso = multiprocessing.Process(
+        target=realizar_peticion,
+        args=(url,)
+    )
+    proceso.start()
+    procesos.append(proceso)
+
+for proceso in procesos:
+
+    proceso.join()
+
+end_time = time.time()
+
+print(
+    f"\n[i] Tiempo de ejecución CON procesos: {end_time - start_time} segundos\n"
+)