diff --git a/components/NodeCard.vue b/components/NodeCard.vue
index 11b7c22..75dafe6 100644
--- a/components/NodeCard.vue
+++ b/components/NodeCard.vue
@@ -4,6 +4,12 @@
   import { Handle, Position } from '@vue-flow/core'
 
   const ignoreTypes = ["topics", "transparent"]
+  const positions = {
+      top: Position.Top,
+      left: Position.Left,
+      right: Position.Right,
+      bottom: Position.Bottom,
+  }
 
   const props = defineProps({
     data: Object,
@@ -32,24 +38,26 @@
     console.log(node)
   })
 
-  const checkSourceHandle = (ty) => {
-    return Object.values(props.data.sourcePosition || {}).includes(ty)
-  }
-  const checkTargetHandle = (ty) => {
-    return Object.values(props.data.targetPosition || {}).includes(ty)
+  const generateStyle = (handle, index) => {
+    return { [handle]: `${index * 10}px` }
   }
 </script>
 
 <template>
-  <Handle v-if="checkSourceHandle('right')" type="source" :position="Position.Right"  />
-  <Handle v-if="checkSourceHandle('top')" type="source" :position="Position.Top"  />
-  <Handle v-if="checkSourceHandle('left')" type="source" :position="Position.Left" />
-  <Handle v-if="checkSourceHandle('bottom')" type="source" :position="Position.Bottom"/>
-
-  <Handle v-if="checkTargetHandle('right')" type="target" :position="Position.Right" />
-  <Handle v-if="checkTargetHandle('top')" type="target" :position="Position.Top" />
-  <Handle v-if="checkTargetHandle('left')" type="target" :position="Position.Left" />
-  <Handle v-if="checkTargetHandle('bottom')" type="target" :position="Position.Bottom" />
+  <Handle
+    v-for="(handle, index) in Object.values(props.data.sourcePosition || {})"
+    :position="positions[handle]"
+    :key="`source-${index}-${handle}`"
+    :id="`source-${index}-${handle}`"
+    type="source"
+    />
+  <Handle
+    v-for="(handle, index) in Object.values(props.data.targetPosition || {})"
+    :position="positions[handle]"
+    :key="`target-${index}-${handle}`"
+    :id="`target-${index}-${handle}`"
+    type="target"
+    />
 
   {{ props.data.position }}
   <Card class="flex flex-row gap-x-2" :class="'topic-' + props.data.topicLevel" :moreTransparency="props.data.moreTransparency" :noInteractive="props.data.noInteractive">
diff --git a/content/1.introduction/0.index.md b/content/1.introduction/0.index.md
new file mode 100644
index 0000000..cdf7031
--- /dev/null
+++ b/content/1.introduction/0.index.md
@@ -0,0 +1,61 @@
+---
+title: 'Introducción a Rust'
+description: 'Introducción a Rust: El Lenguaje del Futuro en Programación de Sistemas'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: 320
+    y: 100
+  sourcePosition:
+    rust: 'top'
+  targetPosition: 
+    basic: 'bottom'
+    why-rust: 'right'
+    rust-channels: 'right'
+    environment: 'right'
+  externalLinks:
+    - name: 'Web Oficial'
+      english: true
+      link: 'https://rust-lang.org'
+    - name: 'Hicimos el sitio web de nuestra boda en Angular y Rust'
+      english: false
+      link: 'https://blog.rustlang-es.org/articles/hicimos-el-sitio-web-de-nuestra-boda-en-angular-y-rust-pk8'
+---
+## Introducción a Rust: El Lenguaje del Futuro en Programación de Sistemas
+
+En el vasto universo de los lenguajes de programación, Rust ha emergido como una estrella en ascenso, atrayendo la atención de desarrolladores de todo el mundo por su enfoque único en la seguridad y el rendimiento. Rust no solo promete, sino que cumple con la difícil tarea de ofrecer un control de bajo nivel sin sacrificar la seguridad y la facilidad de uso. En este post, exploraremos qué hace que Rust sea tan especial y por qué deberías considerarlo para tus próximos proyectos.
+
+### ¿Qué es Rust?
+
+Rust es un lenguaje de programación de sistemas que fue desarrollado por Mozilla Research, con su primera versión estable lanzada en 2015. A diferencia de muchos lenguajes modernos que priorizan la productividad y la simplicidad en detrimento de la eficiencia y el control, Rust busca ofrecer lo mejor de ambos mundos. Está diseñado para ser seguro, concurrente y práctico, permitiendo a los desarrolladores escribir código de bajo nivel sin temor a errores comunes como los desbordamientos de búfer y las condiciones de carrera.
+
+### Características Clave de Rust
+
+1. **Seguridad de Memoria sin Recolección de Basura:**
+   Una de las características más distintivas de Rust es su enfoque en la seguridad de la memoria. A diferencia de otros lenguajes que utilizan un recolector de basura para gestionar la memoria, Rust emplea un sistema de propiedad y préstamo. Este sistema permite que el compilador gestione la memoria de manera segura y eficiente, previniendo errores comunes como los punteros colgantes y las fugas de memoria.
+
+2. **Control y Rendimiento:**
+   Rust proporciona un control de bajo nivel similar al de C y C++, permitiendo a los desarrolladores optimizar su código para un rendimiento máximo. Esto lo hace ideal para aplicaciones donde el rendimiento es crítico, como los motores de juegos, los sistemas embebidos y las aplicaciones de tiempo real.
+
+3. **Concurrencia sin Miedo:**
+   La concurrencia es uno de los aspectos más complejos y propensos a errores en la programación. Rust aborda este problema con su sistema de tipos y el análisis estático en tiempo de compilación, lo que ayuda a evitar las condiciones de carrera y otros errores de concurrencia. Su modelo de propiedad garantiza que dos hilos no puedan acceder al mismo recurso mutable simultáneamente, asegurando así una concurrencia segura.
+
+4. **Ecosistema y Herramientas:**
+   Rust cuenta con un ecosistema robusto y en constante crecimiento. Herramientas como Cargo, el gestor de paquetes y compilador de Rust, facilitan la gestión de dependencias y la compilación del código. Además, la comunidad de Rust es conocida por ser extremadamente acogedora y activa, lo que hace que aprender y resolver problemas sea más accesible.
+
+### ¿Por Qué Elegir Rust?
+
+1. **Proyectos Críticos de Alto Rendimiento:**
+   Si estás trabajando en proyectos donde el rendimiento y la eficiencia son cruciales, como sistemas operativos, navegadores web o motores de juegos, Rust es una excelente opción. Su capacidad para ofrecer un control de bajo nivel sin sacrificar la seguridad lo hace ideal para estos entornos exigentes.
+
+2. **Seguridad en Aplicaciones:**
+   Para aplicaciones donde la seguridad es una prioridad, Rust proporciona una base sólida para prevenir vulnerabilidades comunes. Su sistema de tipos riguroso y su énfasis en la seguridad de la memoria ayudan a evitar errores que pueden ser explotados en ataques de seguridad.
+
+3. **Desarrollo Moderno:**
+   Rust no solo se trata de rendimiento y seguridad; también está diseñado para ser agradable de usar. Su sintaxis moderna y expresiva, junto con herramientas avanzadas, hacen que el desarrollo sea más eficiente y menos propenso a errores.
+
+### Conclusión
+
+Rust está cambiando la forma en que pensamos sobre la programación de sistemas. Su capacidad para ofrecer seguridad y rendimiento sin compromisos lo convierte en una herramienta poderosa para los desarrolladores modernos. Si aún no has explorado Rust, ahora es el momento de sumergirte y descubrir cómo puede transformar tus proyectos. Con una comunidad en crecimiento y un ecosistema robusto, Rust está preparado para ser un pilar en el desarrollo de software del futuro.
diff --git a/content/1.introduction/1.why-rust.md b/content/1.introduction/1.why-rust.md
new file mode 100644
index 0000000..00a8261
--- /dev/null
+++ b/content/1.introduction/1.why-rust.md
@@ -0,0 +1,96 @@
+---
+title: '¿Por Qué Rust?'
+description: '¿Por Qué Usar Rust Hoy en Día? Casos de Éxito que Demuestran su Potencial'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: 620
+    y: 100
+  width: 320
+  sourcePosition:
+    introduction: 'left'
+  externalLinks:
+    - name: 'Web Oficial'
+      english: true
+      link: 'https://rust-lang.org'
+    - name: 'Un paseo por Rust'
+      english: false
+      link: 'https://blog.rustlang-es.org/articles/un-pequeno-paseo-por-rust-4lko'
+    - name: 'Herramientas integradas en Rust'
+      english: false
+      link: 'https://www.rust-lang.org/es/tools'
+---
+## ¿Por Qué Rust?
+
+En el competitivo mundo de la programación, elegir el lenguaje adecuado puede marcar una gran diferencia en la eficiencia, seguridad y escalabilidad de tus proyectos. Rust, un lenguaje relativamente nuevo, ha captado la atención de la comunidad de desarrolladores por su enfoque innovador en la seguridad y el rendimiento. A medida que más empresas e individuos adoptan Rust, los casos de éxito continúan demostrando su valor en aplicaciones del mundo real. En este post, exploraremos por qué deberías considerar usar Rust hoy en día y examinaremos algunos ejemplos notables de su éxito.
+
+### ¿Por Qué Elegir Rust?
+
+1. **Seguridad de Memoria:**
+    Rust es conocido por su enfoque en la seguridad de memoria, lo que ayuda a prevenir errores comunes como los desbordamientos de búfer, los punteros colgantes y las fugas de memoria. Este enfoque se logra a través de su sistema de propiedad y préstamo, que garantiza la seguridad en tiempo de compilación sin necesidad de un recolector de basura.
+
+2. **Rendimiento:**
+    Al ser un lenguaje de bajo nivel, Rust permite un control preciso sobre el hardware, lo que se traduce en un rendimiento cercano al de C y C++. Esto lo hace ideal para aplicaciones de alto rendimiento, como motores de juegos, sistemas embebidos y software de tiempo real.
+
+3. **Concurrencia Segura:**
+    La concurrencia es una de las características más difíciles de manejar en la programación. Rust aborda este desafío con su sistema de tipos y análisis estático, previniendo condiciones de carrera y asegurando que los programas concurrentes sean seguros y eficientes.
+
+4. **Ecosistema y Comunidad:**
+    Rust cuenta con un ecosistema robusto, con herramientas como Cargo, su gestor de paquetes y compilador, que facilita la gestión de dependencias y la compilación de proyectos. Además, la comunidad de Rust es conocida por ser acogedora y activa, proporcionando un entorno de aprendizaje colaborativo.
+
+Ademas Rust ofrece ventajas significativas en el proceso de desarrollo, respaldadas por sus herramientas, su compilador y sus características:
+
+1. **Compilador Robusto:**
+    El compilador de Rust es conocido por ser riguroso y detectar errores en tiempo de compilación. Esto significa que muchos errores comunes que suelen pasar desapercibidos hasta la ejecución se descubren de inmediato. Esto conduce a un desarrollo más rápido y menos errores en el código final.
+
+2. **Gestión de Memoria sin Problemas:**
+    Rust elimina la necesidad de lidiar con problemas de asignación y liberación de memoria manualmente, ya que utiliza su sistema de propriedad de memoria y sistema de préstamo de referencias, lo que disminuye la posibilidad de fugas de memoria y corrupciones de datos.
+
+3. **Ecosistema de Paquetes:**
+    Cargo, el sistema de gestión de paquetes de Rust, es fácil de usar y eficiente. Facilita la importación de bibliotecas y la gestión de dependencias de proyectos, lo que agiliza el desarrollo.
+
+4. **Concurrencia Segura:**
+    Rust ofrece facilidades para escribir código concurrente de manera segura a través de su sistema de hilos y canales (threads y channels) sin preocupaciones por problemas de carrera. Esto es vital para aplicaciones modernas que necesitan explotar la capacidad de las CPU multinúcleo.
+
+5. **Documentación en Línea Clara:**
+    La documentación en línea de Rust es de alta calidad y accesible. Esto facilita el aprendizaje del lenguaje y la resolución de problemas durante el desarrollo.
+
+6. **Testing Integrado:**
+    Rust incluye herramientas de prueba integradas, lo que facilita la escritura y ejecución de pruebas unitarias y de integración.
+
+7. **Compatibilidad con WebAssembly (Wasm):**
+    Rust es ampliamente utilizado en el desarrollo de aplicaciones web a través de WebAssembly, lo que permite la ejecución de código Rust en navegadores web.
+
+8. **Herramientas de Análisis Estático:**
+    Rust cuenta con herramientas de análisis estático como Clippy, que ayudan a identificar problemas de estilo y posibles errores en el código.
+
+9. **Facilidad de Refactorización:**
+    La concordancia de patrones y la tipificación fuerte hacen que la refactorización del código sea más segura y sencilla.
+
+10. **Seguridad y Mantenibilidad a Largo Plazo:**
+    El énfasis en la seguridad y la eliminación de errores comunes en tiempo de compilación contribuye a una mayor confiabilidad y mantenibilidad del código a lo largo del tiempo.
+
+### Casos de Éxito con Rust
+
+1. [**Mozilla y Servo:**](https://github.com/servo/servo)
+    Uno de los ejemplos más conocidos del uso de Rust es el navegador experimental Servo, desarrollado por Mozilla. Servo está diseñado para ser rápido, seguro y paralelizable, aprovechando al máximo las capacidades de Rust. El proyecto ha demostrado cómo Rust puede mejorar la seguridad y el rendimiento en aplicaciones de alto impacto como los navegadores web .
+
+2. [**Dropbox:**](https://dropbox.tech/application/why-we-built-a-custom-rust-library-for-capture)
+    Dropbox ha utilizado Rust para mejorar el rendimiento de su infraestructura. En particular, han reescrito partes críticas de su backend en Rust, logrando mejoras significativas en la eficiencia y la confiabilidad. Rust ha permitido a Dropbox manejar grandes volúmenes de datos con un alto grado de seguridad y rendimiento .
+
+3. [**Amazon Web Services (AWS):**](https://aws.amazon.com/es/blogs/opensource/sustainability-with-rust)
+    AWS ha adoptado Rust para varios de sus servicios, incluyendo el servicio de monitoreo de redes Firecracker, que es utilizado para lanzar microVMs. Rust proporciona la seguridad y el rendimiento necesarios para gestionar la infraestructura en la nube a gran escala de AWS, asegurando que los servicios sean rápidos y seguros  .
+
+4. [**Discord:**](https://discord.com/blog/why-discord-is-switching-from-go-to-rust)
+    La popular plataforma de comunicación Discord ha integrado Rust en sus sistemas backend para mejorar la velocidad y la eficiencia. Rust ha permitido a Discord manejar una gran cantidad de tráfico de manera eficiente, reduciendo la latencia y mejorando la experiencia del usuario final .
+
+5. [**Linux**](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=8aebac82933ff1a7c8eede18cab11e1115e2062b)
+    La integración de Rust en el kernel de Linux representa un cambio significativo en el desarrollo de uno de los sistemas operativos más fundamentales y ampliamente utilizados en el mundo. Este movimiento tiene profundas implicaciones para la seguridad, el rendimiento y la sostenibilidad del desarrollo del kernel. En este post, exploraremos las razones detrás de la adopción de Rust en Linux, cómo se está llevando a cabo esta integración y qué significa esto para el futuro del sistema operativo.
+
+### Conclusión
+
+Rust no es solo una moda pasajera; es un lenguaje que ofrece soluciones reales a problemas complejos en el desarrollo de software moderno. Su enfoque en la seguridad de la memoria, el rendimiento y la concurrencia segura lo convierte en una opción atractiva para una amplia gama de aplicaciones. Los casos de éxito de empresas como Mozilla, Dropbox, AWS y Discord son testimonios contundentes del potencial de Rust para transformar proyectos críticos. Si buscas un lenguaje que combine eficiencia, seguridad y modernidad, Rust es una opción que vale la pena explorar.
+
+Adoptar Rust hoy puede prepararte para enfrentar los desafíos del desarrollo de software del mañana, proporcionando una base sólida para construir aplicaciones robustas y de alto rendimiento. ¡Es el momento perfecto para empezar a explorar todo lo que Rust tiene para ofrecer!
diff --git a/content/1.introduction/2.rust-channels.md b/content/1.introduction/2.rust-channels.md
new file mode 100644
index 0000000..735d0c3
--- /dev/null
+++ b/content/1.introduction/2.rust-channels.md
@@ -0,0 +1,57 @@
+---
+title: 'Stable, Beta, Nightly. ¿Que es esto?'
+description: 'Stable, Beta, Nightly. Los canales de distribucion y versiones de Rust'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: 620
+    y: 140
+  sourcePosition:
+    introduction: 'left'
+  externalLinks:
+    - name: 'Web Oficial'
+      english: true
+      link: 'https://rust-lang.org'
+    - name: 'Enlace de Referencia'
+      english: true
+      link: 'https://rust-lang.github.io/rustup/concepts/channels.html'
+---
+## Stable, Beta, Nightly. ¿Que es esto?
+
+Rust es conocido por su enfoque en la seguridad, el rendimiento y la confiabilidad, y parte de lo que hace a Rust tan robusto es su cuidadoso ciclo de lanzamiento. Para mantener el equilibrio entre la estabilidad y la innovación, Rust se distribuye a través de tres canales diferentes: Stable, Beta y Nightly. En este post, exploraremos qué significa cada uno de estos canales y cuándo deberías usarlos.
+
+### Canal Stable: Seguridad y Confiabilidad
+
+El canal Stable es la versión más importante de Rust para la mayoría de los desarrolladores. Como su nombre indica, las versiones en este canal son las más estables y han pasado por un riguroso proceso de prueba. Aquí están las características clave del canal Stable:
+
+- **Lanzamientos Regulares:** Las versiones estables de Rust se lanzan cada seis semanas, lo que proporciona un flujo constante de mejoras y correcciones de errores.
+- **Compatibilidad Garantizada:** El canal Stable garantiza la compatibilidad hacia atrás, lo que significa que el código que compila en una versión estable continuará compilando en versiones futuras.
+- **Seguridad y Confiabilidad:** Dado que estas versiones han sido exhaustivamente probadas, son ideales para proyectos de producción donde la estabilidad es crucial.
+
+**Cuándo usar Stable:** Siempre que estés trabajando en un proyecto de producción o necesites asegurarte de que tu código funcione de manera confiable y segura, debes usar el canal Stable.
+
+### Canal Beta: Probando lo Nuevo
+
+El canal Beta de Rust es una vista previa de lo que vendrá en la próxima versión estable. Esta versión se congela dos semanas antes del lanzamiento estable, y se centra en la corrección de errores y la estabilización de nuevas características.
+
+- **Vista Previa de Nuevas Características:** El canal Beta te permite probar las nuevas características que se incluirán en la próxima versión estable.
+- **Corrección de Errores:** Aunque es menos estable que el canal Stable, el canal Beta todavía es bastante fiable y se utiliza para encontrar y corregir errores antes del lanzamiento oficial.
+
+**Cuándo usar Beta:** Si quieres estar al tanto de las próximas características y contribuir a la detección de errores, usar el canal Beta es una excelente opción. Es ideal para pruebas y para preparar tu código para futuros lanzamientos estables.
+
+### Canal Nightly: Innovación y Experimentación
+
+El canal Nightly es la vanguardia del desarrollo de Rust. Las versiones Nightly se generan cada noche con las últimas características y correcciones de errores que aún no están listas para el canal Beta.
+
+- **Acceso a Características Experimentales:** El canal Nightly te da acceso a las características más nuevas y experimentales, incluyendo aquellas que aún están en fase de pruebas.
+- **Sin Garantías de Estabilidad:** Dado que estas versiones son las menos probadas, pueden contener errores y no se garantiza que sean estables.
+
+**Cuándo usar Nightly:** Si eres un desarrollador que quiere experimentar con las últimas innovaciones y no te importa lidiar con posibles inestabilidades, el canal Nightly es para ti. Es especialmente útil para contribuyentes de Rust y aquellos que necesitan características específicas que aún no están disponibles en los canales Beta o Stable.
+
+### Conclusión
+
+El sistema de canales de Rust permite a los desarrolladores elegir el equilibrio adecuado entre estabilidad e innovación para sus necesidades específicas. El canal Stable ofrece seguridad y confiabilidad para proyectos de producción, el canal Beta proporciona una vista previa de las próximas características, y el canal Nightly permite a los desarrolladores experimentar con las últimas novedades del lenguaje.
+
+Al comprender y utilizar estos canales de manera efectiva, puedes maximizar tu productividad y mantener tu códigobase actualizada y segura. ¡Elige el canal que mejor se adapte a tus necesidades y empieza a explorar todo lo que Rust tiene para ofrecer!
diff --git a/content/1.introduction/3.environment.yml b/content/1.introduction/3.environment.yml
new file mode 100644
index 0000000..c6c615f
--- /dev/null
+++ b/content/1.introduction/3.environment.yml
@@ -0,0 +1,11 @@
+title: 'Configura tu Entorno'
+description: ''
+data:
+  type: 'transparent'
+  topicLevel: 'start'
+  position:
+    x: 620
+    y: 200
+  width: 320
+  sourcePosition:
+    introduction: 'left'
diff --git a/content/1.introduction/4.install-rust.md b/content/1.introduction/4.install-rust.md
new file mode 100644
index 0000000..d2c9824
--- /dev/null
+++ b/content/1.introduction/4.install-rust.md
@@ -0,0 +1,173 @@
+---
+title: 'Instala Rust'
+description: 'Instalación de Rust con Rustup: Una Guía Rápida en pocos minutos'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: 620
+    y: 240
+  width: 320
+  externalLinks:
+    - name: 'Web Oficial de Rustup'
+      english: true
+      link: 'https://rustup.rs'
+---
+## Instalación de Rust con Rustup: Una Guía Rápida
+
+Rust es un lenguaje de programación que ha ganado popularidad rápidamente debido a su enfoque en la seguridad, el rendimiento y la facilidad de uso. Si estás interesado en comenzar a desarrollar con Rust, el primer paso es instalarlo en tu sistema. La forma más recomendada y sencilla de instalar Rust es usando Rustup, una herramienta de línea de comandos para gestionar tus instalaciones de Rust. En este post, te guiaremos a través del proceso de instalación de Rust utilizando Rustup.
+
+### ¿Qué es Rustup?
+
+Rustup es una herramienta de instalación y gestión de Rust que facilita la configuración de múltiples versiones de Rust y la administración de diferentes toolchains (conjuntos de herramientas) en tu sistema. Con Rustup, puedes acceder fácilmente a los canales Stable, Beta y Nightly de Rust y cambiar entre ellos según sea necesario.
+
+### Pasos para Instalar Rust con Rustup
+
+### Instalación en Windows
+
+#### 1. Descargar e Instalar Rustup
+
+1. Visita [rustup.rs](https://rustup.rs/) en tu navegador.
+2. Haz clic en el enlace de instalación para Windows. Esto descargará un archivo ejecutable `rustup-init.exe`.
+3. Ejecuta el archivo descargado. Aparecerá una ventana de terminal.
+
+#### 2. Ejecutar el Instalador
+
+1. En la ventana de terminal, se te pedirá que confirmes la instalación. Pulsa `1` y luego `Enter` para proceder con la instalación predeterminada.
+2. El instalador configurará Rust y Rustup en tu sistema. 
+
+#### 3. Configurar el Entorno
+
+El instalador generalmente configura el entorno de manera automática. Para verificar, abre una nueva ventana de terminal (PowerShell o cmd) y ejecuta:
+
+```sh
+rustc --version
+```
+
+Si ves la versión de Rust, la instalación se ha realizado correctamente.
+
+### Instalación en Linux
+
+#### 1. Descargar e Instalar Rustup
+
+Abre una terminal y ejecuta el siguiente comando:
+
+```sh
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+```
+
+#### 2. Ejecutar el Instalador
+
+Sigue las instrucciones en la terminal. Acepta las opciones predeterminadas presionando `Enter`.
+
+#### 3. Configurar el Entorno
+
+Añade Rust a tu PATH ejecutando:
+
+```sh
+source $HOME/.cargo/env
+```
+
+También puedes añadir esta línea al final de tu archivo de configuración de shell (`.bashrc`, `.zshrc`, etc.) para que se ejecute automáticamente al abrir una nueva terminal.
+
+Para verificar la instalación, ejecuta:
+
+```sh
+rustc --version
+```
+
+Si ves la versión de Rust, la instalación ha sido exitosa.
+
+### Instalación en macOS
+
+#### 1. Descargar e Instalar Rustup
+
+Abre una terminal y ejecuta el siguiente comando:
+
+```sh
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+```
+
+#### 2. Ejecutar el Instalador
+
+Sigue las instrucciones en la terminal. Acepta las opciones predeterminadas presionando `Enter`.
+
+#### 3. Configurar el Entorno
+
+Añade Rust a tu PATH ejecutando:
+
+```sh
+source $HOME/.cargo/env
+```
+
+Para asegurarte de que este paso se realice automáticamente al abrir una nueva terminal, añade esta línea al final de tu archivo de configuración de shell (`.bash_profile`, `.zshrc`, etc.).
+
+Para verificar la instalación, ejecuta:
+
+```sh
+rustc --version
+```
+
+Si ves la versión de Rust, la instalación ha sido exitosa.
+
+
+#### 2. Configurar tu Entorno
+
+Una vez que Rustup haya terminado de instalarse, necesitas asegurarte de que tu entorno de línea de comandos esté configurado para usar Rust. Rustup te indicará agregar la ruta de Rust a tu archivo de configuración de shell (`.bashrc`, `.zshrc`, etc.). Puedes hacerlo manualmente o dejar que Rustup lo haga automáticamente.
+
+Si decides hacerlo manualmente, añade la siguiente línea al final de tu archivo de configuración de shell:
+
+```sh
+source $HOME/.cargo/env
+```
+
+Después de hacer esto, asegúrate de recargar tu archivo de configuración ejecutando `source ~/.bashrc` o `source ~/.zshrc`, dependiendo de tu shell.
+
+#### 3. Verificar la Instalación
+
+Para verificar que Rust se ha instalado correctamente, puedes ejecutar:
+
+```sh
+rustc --version
+```
+
+Este comando debería mostrar la versión de Rust que tienes instalada. Si ves algo similar a `rustc 1.XX.X (XXXXX YYYY-MM-DD)`, ¡felicidades, ya tienes Rust instalado en tu sistema!
+
+#### 4. Usar los Canales de Rust
+
+Una de las ventajas de usar Rustup es la facilidad con la que puedes cambiar entre diferentes versiones de Rust. Por defecto, Rustup instala la versión Stable. Sin embargo, puedes instalar y usar las versiones Beta y Nightly fácilmente.
+
+Para instalar y usar el canal Beta:
+
+```sh
+rustup install beta
+rustup default beta
+```
+
+Para instalar y usar el canal Nightly:
+
+```sh
+rustup install nightly
+rustup default nightly
+```
+
+Si en algún momento deseas volver al canal Stable, puedes hacerlo con:
+
+```sh
+rustup default stable
+```
+
+#### 5. Actualizar Rust
+
+Mantener tu instalación de Rust actualizada es fácil con Rustup. Simplemente ejecuta:
+
+```sh
+rustup update
+```
+
+Este comando actualizará Rustup y todos los toolchains instalados a sus versiones más recientes.
+
+### Conclusión
+
+Instalar Rust usando Rustup es un proceso sencillo que te permitirá empezar a desarrollar en Rust rápidamente. Con Rustup, puedes gestionar fácilmente las versiones de Rust y asegurarte de que siempre tienes acceso a las últimas características y mejoras. Ahora que tienes Rust instalado, estás listo para explorar todo lo que este poderoso lenguaje tiene para ofrecer. ¡Feliz codificación!
diff --git a/content/1.introduction/5.code-editor.md b/content/1.introduction/5.code-editor.md
new file mode 100644
index 0000000..a4e82db
--- /dev/null
+++ b/content/1.introduction/5.code-editor.md
@@ -0,0 +1,122 @@
+---
+title: 'Configurando Tu Entorno'
+description: 'Guía de configuracion para los Editores de Texto Más Comunes (Vs Code, Visual Studio, IntelliJ IDEA, Vim, Neovim, Sublime Text)'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: 620
+    y: 280
+  width: 320
+  externalLinks:
+    - name: 'Manual oficial de instalacion'
+      english: true
+      link: 'https://rust-analyzer.github.io/manual.html#installation'
+    - name: 'Extension de Rust para VsCode'
+      english: true
+      link: 'https://code.visualstudio.com/docs/languages/rust'
+    - name: 'Extension de Rust para Visual Studio'
+      english: true
+      link: 'https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer'
+    - name: 'Rust Enhanced (Sublime Text Extension)'
+      english: true
+      link: 'https://github.com/rust-lang/rust-enhanced'
+    - name: 'LSP de Rust Analyzer para Neovim/Vim'
+      english: true
+      link: 'https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md#rust_analyzer'
+    - name: 'Lapce Code Editor'
+      english: true
+      link: 'https://lapce.dev/'
+    - name: 'Editor de texto Zed'
+      english: true
+      link: 'https://zed.dev/'
+    - name: 'Helix Code Editor (Terminal)'
+      english: true
+      link: 'https://helix-editor.com/'
+    - name: 'RustRover (Jetbrains IDE)'
+      english: true
+      link: 'https://www.jetbrains.com/rust/'
+---
+## Configurando Tu Entorno de Desarrollo para Rust: Guía para los Editores de Texto Más Comunes
+
+Rust es un lenguaje poderoso y eficiente, y para aprovecharlo al máximo, es importante configurar correctamente tu entorno de desarrollo. En este post, exploraremos cómo configurar algunos de los editores de texto más populares para trabajar con Rust, así como una mención a nuevos editores hechos en Rust que están ganando popularidad.
+
+> Para todos los editores debes asegurarte de haber instalado Rust correctamente, para eso aprovecha nuestra guia anterior.
+
+### Visual Studio Code (VSCode)
+
+VSCode es uno de los editores más populares y versátiles disponibles. Configurarlo para Rust es bastante sencillo:
+
+1. **Instala VSCode** desde [su sitio web](https://code.visualstudio.com/).
+2. **Abre VSCode** y ve a la **extensiones** (icono de cuadrado en la barra lateral izquierda).
+3. Busca e instala la extensión **Rust (rust-lang.rust)**. Esta extensión proporciona soporte para el lenguaje Rust.
+4. Opcionalmente, instala **rust-analyzer** para una experiencia mejorada de desarrollo. Busca **rust-analyzer** en la pestaña de extensiones e instálalo.
+5. Configura **rust-analyzer** y otras herramientas de Rust en el archivo de configuración de VSCode (`settings.json`) si es necesario. La configuración básica suele ser suficiente para empezar.
+
+### Visual Studio
+
+Para aquellos que prefieren el entorno de desarrollo de Visual Studio:
+
+1. **Instala Visual Studio** desde [su sitio web](https://visualstudio.microsoft.com/).
+2. Durante la instalación, asegúrate de incluir la **carga de trabajo de desarrollo de escritorio con C++**, ya que contiene herramientas necesarias para compilar Rust.
+3. Instala la extensión **Rust** desde el **Administrador de Extensiones** en Visual Studio.
+4. Abre un proyecto de Rust y Visual Studio debería configurarse automáticamente para proporcionar soporte básico.
+
+### IntelliJ IDEA
+
+JetBrains ofrece un excelente soporte para Rust a través de su IDE IntelliJ IDEA:
+
+1. **Descarga e instala IntelliJ IDEA** desde [su sitio web](https://www.jetbrains.com/idea/).
+2. Abre IntelliJ IDEA y ve a **Configuración > Plugins**.
+3. Busca e instala el plugin **Rust**.
+4. Reinicia IntelliJ IDEA para aplicar los cambios.
+5. Crea un nuevo proyecto de Rust o abre uno existente. IntelliJ IDEA proporcionará soporte completo para Rust, incluyendo resaltado de sintaxis, autocompletado y más.
+
+### Sublime Text
+
+Sublime Text es un editor ligero y rápido que también puede configurarse para Rust:
+
+1. **Descarga e instala Sublime Text** desde [su sitio web](https://www.sublimetext.com/).
+2. Abre Sublime Text y ve a **Preferences > Package Control**.
+3. Instala **Rust Enhanced** utilizando Package Control. Abre la paleta de comandos (`Ctrl+Shift+P` o `Cmd+Shift+P`), selecciona **Package Control: Install Package** y busca **Rust Enhanced**.
+4. Esta extensión proporciona resaltado de sintaxis, compilación y ejecución de código Rust.
+
+### Vim
+
+Vim es un editor muy popular entre los desarrolladores que prefieren trabajar en la terminal:
+
+1. Instala el plugin **rust.vim**. Si usas un gestor de plugins como **Vundle** o **Plug**, añade lo siguiente a tu archivo de configuración (`.vimrc`):
+
+   Con Vundle:
+   ```vim
+   Plugin 'rust-lang/rust.vim'
+   ```
+
+   Con Plug:
+   ```vim
+   Plug 'rust-lang/rust.vim'
+   ```
+
+2. Recarga tu archivo de configuración y ejecuta el comando para instalar el plugin (`:PluginInstall` o `:PlugInstall`).
+3. Para mejorar aún más la experiencia, considera instalar **coc.nvim** para soporte de LSP y autocompletado. Configura `coc.nvim` para usar `rust-analyzer` siguiendo las instrucciones en su [documentación](https://github.com/neoclide/coc.nvim).
+
+> Para Vim o Neovim tambien puedes optar por instalar el LSP correspondiente desde [Mason](https://github.com/williamboman/mason.nvim), el LSP de Rust por defecto es [rust-analyzer](https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md#rust_analyzer)
+
+### Nuevos Editores Hechos en Rust
+
+Además de los editores mencionados anteriormente, hay algunos nuevos editores desarrollados en Rust que están ganando popularidad:
+
+1. **Helix**: Helix es un editor moderno y potente que ofrece una experiencia de edición eficiente y rápida. Es altamente configurable y aprovecha las capacidades de Rust para ofrecer un rendimiento excelente. Puedes obtener más información y descargarlo desde [su repositorio en GitHub](https://github.com/helix-editor/helix).
+
+2. **Zed**: Zed es otro editor prometedor desarrollado en Rust. Aún en desarrollo, Zed promete ser un editor rápido y minimalista con un fuerte enfoque en la usabilidad y el rendimiento. Visita [el sitio web de Zed](https://zed.dev/) para más detalles.
+
+3. **Lapce**: Lapce es un editor de texto rápido y ligero que utiliza Rust para su backend y GUI, proporcionando una experiencia de edición moderna y eficiente. Puedes encontrar más información y descargar Lapce desde [su repositorio en GitHub](https://github.com/lapce/lapce).
+
+4. **RustRover**: RustRover es un entorno de desarrollo integrado (IDE) creado por JetBrains, diseñado específicamente para el lenguaje de programación Rust. Aprovechando la experiencia de JetBrains en la creación de herramientas de desarrollo robustas y eficientes, RustRover ofrece una serie de características avanzadas que facilitan el desarrollo con Rust.
+
+> RustRover cuenta con una licencia gratuita para proyectos personales.
+
+### Conclusión
+
+Configurar tu entorno de desarrollo para Rust puede mejorar significativamente tu productividad y experiencia de desarrollo. Ya sea que prefieras un editor ligero como Sublime Text o Vim, o un IDE completo como VSCode o IntelliJ IDEA, hay opciones disponibles para satisfacer tus necesidades. Además, los nuevos editores desarrollados en Rust como Helix, Zed y Lapce están abriendo nuevas posibilidades con su rendimiento y características avanzadas. ¡Elige tu editor favorito y comienza a disfrutar de la potencia de Rust!
diff --git a/content/1.introduction/6.first-program.md b/content/1.introduction/6.first-program.md
new file mode 100644
index 0000000..152b1a6
--- /dev/null
+++ b/content/1.introduction/6.first-program.md
@@ -0,0 +1,108 @@
+---
+title: 'Tu Primer Programa'
+description: 'Escribiendo Tu Primer Programa en Rust: Una Guía Paso a Paso'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: 620
+    y: 320
+  width: 320
+  externalLinks:
+    - name: '¡Hola, mundo!'
+      english: false
+      link: 'https://book.rustlang-es.org/ch01-02-hello-world'
+    - name: '¡Hola, Cargo!'
+      english: false
+      link: 'https://book.rustlang-es.org/ch01-03-hello-cargo'
+---
+## Escribiendo Tu Primer Programa en Rust: Una Guía Paso a Paso
+
+Rust es un lenguaje de programación moderno que se destaca por su seguridad y rendimiento. Si estás listo para dar tus primeros pasos en Rust, esta guía te ayudará a configurar tu entorno y a escribir tu primer programa sencillo. Vamos a crear un proyecto llamado "hola_mundo" utilizando Cargo, la herramienta de gestión de proyectos de Rust.
+
+### ¿Qué es Cargo?
+
+Cargo es la navaja suiza de Rust. Permite gestionar proyectos, probar código, manejar dependencias, y mucho más. Es una herramienta esencial para cualquier desarrollador de Rust.
+
+### Paso 1: Crear un Proyecto con Cargo
+
+Para crear tu primer proyecto con Cargo, abre una terminal y ejecuta el siguiente comando:
+
+```sh
+cargo new hola_mundo
+```
+
+Este comando creará un nuevo directorio y un proyecto llamado "hola_mundo". Cargo generará los archivos necesarios y un directorio para ti. Vamos a explorar lo que ha creado.
+
+### Paso 2: Explorar la Estructura del Proyecto
+
+Navega al directorio del proyecto y lista los archivos:
+
+```sh
+cd hola_mundo
+ls
+```
+
+Deberías ver los siguientes elementos:
+
+- `Cargo.toml`: Archivo de configuración de Cargo.
+- `src`: Directorio de código fuente.
+  - `main.rs`: Archivo principal de Rust que contiene el punto de entrada del programa.
+
+Cargo también inicializa un nuevo repositorio Git junto con un archivo `.gitignore`.
+
+### Paso 3: Entender el Código Generado
+
+Abre el archivo `src/main.rs` en tu editor de texto favorito. Verás el siguiente código:
+
+```rs
+fn main() {
+    println!("Hello, world!");
+}
+```
+
+Vamos a desglosar este código línea por línea.
+
+#### La Función `main`
+
+```rs
+fn main() {
+
+}
+```
+
+Estas líneas definen una función llamada `main`. La función `main` es especial: siempre es el primer código que se ejecuta en cada programa ejecutable de Rust. Aquí, la primera línea declara una función llamada `main` que no tiene parámetros y no devuelve nada. Si hubiera parámetros, irían dentro de los paréntesis `()`.
+
+El cuerpo de la función está envuelto en `{}`. Rust requiere llaves alrededor de todos los cuerpos de función. Es buena costumbre colocar la llave de apertura en la misma línea que la declaración de la función, agregando un espacio entre ambos.
+
+#### El Cuerpo de la Función `main`
+
+```rs
+println!("Hello, world!");
+```
+
+Esta línea hace todo el trabajo en este pequeño programa: imprime texto en la pantalla.
+
+`println!` llama a una macro de Rust. Si hubiéramos llamado a una función en su lugar, habríamos ingresado `println` (sin el `!`). Hablaremos de macros en Rust más adelante. Por ahora, solo necesitas saber que usar un `!` significa que estamos llamando a una macro en lugar de una función normal y que las macros no siempre siguen las mismas reglas que las funciones.
+
+Terminamos la línea con un punto y coma (`;`), lo que indica que esta expresión ha terminado y la siguiente está lista para comenzar. La mayoría de las líneas de código de Rust terminan con un punto y coma.
+
+### Paso 4: Ejecutar el Programa
+
+Ahora que entendemos el código, es hora de ejecutarlo. En la terminal, ejecuta:
+
+```sh
+cargo run
+```
+
+Deberías ver una salida similar a esta:
+
+```sh
+$ cargo run
+    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
+     Running `target/debug/hola_mundo`
+Hello, world!
+```
+
+Si todo funciona correctamente, ¡felicitaciones! Has escrito y ejecutado tu primer programa en Rust.
diff --git a/content/1.introduction/index.md b/content/1.introduction/index.md
deleted file mode 100644
index 52beeac..0000000
--- a/content/1.introduction/index.md
+++ /dev/null
@@ -1,27 +0,0 @@
----
-title: 'Introducción al Lenguaje'
-description: 'Un introduccion al lenguaje Rust'
-draft: true
-data:
-  type: 'custom'
-  topicLevel: 'start'
-  position:
-    x: 320
-    y: 100
-  sourcePosition:
-    rust: 'top'
-  targetPosition: 
-    basic: 'bottom'
-externalLinks:
-  oficial:
-    english: true
-    link: 'https://rust-lang.org'
----
-# Introducción al Lenguaje
-Rust es un lenguaje de programación moderno y de alto rendimiento que se enfoca en la seguridad, la concurrencia y la eficiencia. Fue creado por Mozilla Research y lanzado en 2010. Desde entonces, ha ganado popularidad debido a varias razones:
-
-- 1. Seguridad y Confiabilidad: Rust se destaca por su sistema de tipos y su enfoque en la seguridad de la memoria. Su compilador atrapa muchos errores comunes de programación en tiempo de compilación, como el acceso a memoria no válida o los problemas de concurrencia, lo que hace que sea más difícil que los errores de este tipo se filtren en el código en producción.
-- 2. Concurrencia sin Problemas: Rust ofrece herramientas poderosas para escribir código concurrente de forma segura. Su sistema de tipo de datos llamado "ownership" permite que el compilador garantice en tiempo de compilación que no hay carreras de datos o problemas de concurrencia en el código.
-- 3. Eficiencia: Rust proporciona un alto rendimiento comparable al de C++ o C, pero con menos riesgos de errores comunes asociados con estos lenguajes, gracias a su sistema de tipos y su enfoque en la seguridad de la memoria.
-- 4. Comunidad Activa: La comunidad de Rust es conocida por ser acogedora y activa. Hay una gran cantidad de recursos en línea, como libros, tutoriales, y una gran cantidad de bibliotecas de código abierto que hacen que sea fácil comenzar a trabajar con Rust y resolver problemas comunes.
-- 5. Apoyo de Grandes Empresas: Rust ha ganado el apoyo de grandes empresas como Mozilla, Microsoft, Amazon, y Google, que están utilizando Rust en proyectos importantes. Esto ha contribuido a la popularidad y la adopción del lenguaje en una variedad de industrias.
diff --git a/content/rust.yml b/content/rust.yml
index ddcae9b..2f592c6 100644
--- a/content/rust.yml
+++ b/content/rust.yml
@@ -4,7 +4,7 @@ data:
   type: 'transparent'
   topicLevel: 'start'
   position:
-    x: 400
+    x: 390
     y: -100
   sourcePosition:
     none: 'top'