Update Spanish translation and Solve problem with invalid paths (#87)

* Add unofficial/unsupported installation methods.

* Update from_scratch.md

* Remove https: from .gitignore

* Translated client development section to ES.

* Include missing file for translation.

* Translation progress Contributing section.

* Add title.

* Translated contributing section to ES.

* Updated translation.

* Add missing file release_process.md

* Update websocket_api.md

* Add Troubleshooting section in README

* change `route` to `path`

* Translate from_scratch.md and on_aws.md. Update README

* Remove `espeak` mention from both EN and ES.

src/en/administration/from_scratch.md

@@ -26,7 +26,6 @@ I had to switch from using `sudo` to `su`'ing in some places as the user was doi
 | dev-db                       | [postgresql](https://www.postgresql.org/) |
 | www-servers                  | [nginx](https://nginx.org/en/)            |
 | sys-apps                     | [yarn](https://yarnpkg.com/)              |
-| (optional) app-accessibility | espeak                                    |
 | app-shells                   | bash-completion                           |
 
 

src/en/client_development/websocket_api.md

@@ -1 +1,2 @@
-# [WebSocket API](https://join-lemmy.org/api/index.html)
+# WebSocket API
+[Lemmy WebSocket API 2.0 documentation](https://join-lemmy.org/api/index.html)

src/en/contributing/local_development.md

@@ -1,3 +1,5 @@
+# Local Development
+
 ### Install build requirements
 Install Rust using [the recommended option on rust-lang.org](https://www.rust-lang.org/tools/install) (rustup).
 

src/es/SUMMARY.md

@@ -8,7 +8,8 @@
 - [Administración](administration/administration.md)
   - [Instalación con Docker](administration/install_docker.md)
   - [Instalación con Ansible](administration/install_ansible.md)
-  - [Otros Métodos de Instalación](administration/other_installation_methods.md)
+  - [Instalar desde Cero](administration/from_scratch.md)
+  - [Instalar en AWS](administration/on_aws.md)
   - [Configuración](administration/configuration.md)
   - [Introducción a la Federación](administration/federation_getting_started.md)
   - [Solución de Problemas](administration/troubleshooting.md)
@@ -17,15 +18,16 @@
   - [Visión General de la Federación](federation/overview.md)
   - [Recursos](federation/resources.md)
   - [Protocolo de Lemmy](federation/lemmy_protocol.md)
-- [Client Development](client_development/client_development.md)
+- [Desarrollo de clientes](client_development/client_development.md)
-  - [Theming Guide](client_development/theming.md)
+  - [Guiá para Temas](client_development/theming.md)
-  - [API reference](client_development/api_reference.md)
+  - [Referencia de la API](client_development/api_reference.md)
-  - [WebSocket API](client_development/websocket_api.md)
+  - [API del WebSocket](client_development/websocket_api.md)
-  - [HTTP API](client_development/http_api.md)
+  - [API HTTP](client_development/http_api.md)
-  - [Creating a Custom Frontend](client_development/custom_frontend.md)
+  - [Crear un Frontend Personalizado](client_development/custom_frontend.md)
-- [Contributing](contributing/contributing.md)
+- [Contribuir al Proyecto](contributing/contributing.md)
-  - [Docker Development](contributing/docker_development.md)
+  - [Desarrollo con Docker](contributing/docker_development.md)
-  - [Local Development](contributing/local_development.md)
+  - [Desarrollo Local](contributing/local_development.md)
-  - [Tests](contributing/tests.md)
+  - [Pruebas](contributing/tests.md)
-  - [Federation Development](contributing/federation_development.md)
+  - [Desarrollo de la Federación](contributing/federation_development.md)
+  - [Bifurcaciones y Liberaciones](contributing/release_process.md)
 - [Código de Conducta](code_of_conduct.md)

src/es/administration/administration.md

@@ -3,9 +3,17 @@
 Información para administradores de las instancias de Lemmy, y para aquellos que quieran gestionar un servidor.
 
 ## Instalación
+### Métodos oficiales/soportados
 
-Lemmy tiene dos métodos principales de instalación, [manual con Docker](install_docker.md), y [automatizado con Ansible](install_ansible.md). Recomendamos usar Ansible, porque simplifica la instalación y también facilita la actualización.
+Lemmy tiene dos métodos principales de instalación:
+- [Manual con Docker](install_docker.md)
+- [Automatizado con Ansible](install_ansible.md).
 
-## Otros métodos de instalación
+Recomendamos usar Ansible, porque simplifica la instalación y también facilita la actualización.
 
-En algunos casos, puede ser necesario utilizar [otros métodos de instalación](other_installation_methods.md). Pero no lo recomendamos y no podemos dar soporte para ellos.
+### Otros métodos de instalación
+> ⚠️ **Bajo tu propio riesgo.**
+
+En algunos casos, puede ser necesario utilizar diferentes métodos de instalación. Pero no los recomendamos y no podemos dar soporte para ellos.
+- [Instalar desde Cero](from_scratch.md)
+- [En Amazon Web Services (AWS)](on_aws.md)

src/es/administration/from_scratch.md

@@ -0,0 +1,394 @@
+# Instalar desde Cero
+
+> ⚠️ **Descargo de responsabilidad:** este método de instalación no está recomendado por los desarrolladores de Lemmy. Si tienes algún problema, debes resolverlo tú mismo o preguntar a los respectivos autores. Si observas algún fallo de Lemmy en una instancia instalada de este modo, por favor, menciónalo en el informe de fallos.
+
+## Instalando Lemmy desde el código fuente
+
+Instrucciones para instalar Lemmy de forma Nativa, sin depender de docker. Originalmente fue publicado en [Some resources on setting Lemmy up from source - Lemmy dot C.A.](https://lemmy.ca/post/1066) **La transcripción actual se ha adaptado para mejorar su legibilidad**.
+
+### Importante
+
+> Las referencias de los paquetes de software a continuación **son todas basadas en Gentoo** - Hay información en los archivos de docker sobre lo que se requiere en los sistemas tipo debian, y para cualquier otra cosa probablemente podrás ajustar fácilmente como sea necesario.
+
+Ten en cuenta que la construcción de Lemmy requiere de una gran cantidad de recursos de hardware. Si quieres ejecutar Lemmy en un pequeño VPS con una memoria RAM muy limitada (que parece una forma perfectamente aceptable para ejecutar una instancia de producción), es mejor seguir con la imagen docker, o usar un sistema que tenga más RAM. El uso de RAM es enorme con las builds de Rust.
+
+Las versiones de etiqueta/lanzamiento incluidas en esta nota provienen de lemmy/docker/prod/docker-compose.yml y estaban actualizadas en el momento en que se creó este documento.  **Definitivamente ajustar a las versiones apropiadas como sea necesario**.
+
+Tuve que cambiar de usar `sudo` a `su` en algunos lugares ya que el usuario estaba haciendo algo raro/incompleto con el env de sudo para pictrs
+
+## Configuración
+
+| Dependencias                 |                                           |
+|------------------------------|-------------------------------------------|
+| app-admin                    | sudo                                      |
+| dev-vcs                      | [git](https://git-scm.com/)               |
+| dev-lang                     | [rust](https://www.rust-lang.org/)        |
+| dev-db                       | [postgresql](https://www.postgresql.org/) |
+| www-servers                  | [nginx](https://nginx.org/en/)            |
+| sys-apps                     | [yarn](https://yarnpkg.com/)              |
+| app-shells                   | bash-completion                           |
+|                              |                                           |
+
+
+### Poner en marcha el postgresql
+
+```bash
+emerge --config dev-db/postgresql
+rc-service postgresql-12 start
+useradd -m -s /bin/bash lemmy
+cd ~lemmy
+sudo -Hu lemmy git clone https://github.com/LemmyNet/lemmy.git
+cd lemmy
+```
+
+### Lista las etiquetas(tags)/lanzamientos(releases) disponibles
+
+```bash
+sudo -Hu lemmy git tag -l
+sudo -Hu lemmy git checkout tags/v0.11.0
+```
+
+### Build para producción?  (Remover --release para dev)
+
+```bash
+sudo -Hu lemmy cargo build --release
+cd ..
+sudo -Hu lemmy git clone https://github.com/LemmyNet/lemmy-ui.git
+cd lemmy-ui
+```
+
+### Lista las etiquetas(tags)/lanzamientos(releases) disponibles
+
+```bash
+sudo -Hu lemmy git tag -l
+sudo -Hu lemmy git checkout tags/v0.8.10
+sudo -Hu lemmy git submodule init
+sudo -Hu lemmy git submodule update --remote
+```
+
+### Construir el frontend
+
+#### Esto es para desarrollo
+
+```bash
+sudo -Hu lemmy yarn
+```
+
+#### Esto es para producción
+
+```bash
+sudo -Hu lemmy yarn install --pure-lockfile
+sudo -Hu lemmy yarn build:prod
+```
+
+**Esto es solo para correr un entorno de desarrollo, pero creo que es preferible para producción - usar el script de inicio**
+
+```bash
+sudo -Hu lemmy yarn dev
+```
+
+Para producción, usaremos el [script de inicio](#initlemmy), pero el comando para producción es:
+
+```bash
+sudo -Hu node dist/js/server.js
+```
+
+### Configurar la base de datos
+
+#### Ajustar la contraseña:
+
+```bash
+sudo -u postgres psql -c "create user lemmy with password 'password' superuser;" -U postgres
+sudo -u postgres psql -c 'create database lemmy with owner lemmy;' -U postgres
+```
+
+### Instalar iFramely
+
+Son requeridos git y nodejs, pero nodejs debe ser instalado como dependencia de yarn.
+
+#### En caso de que iFramely sea instalado en otro sistema
+
+```bash
+useradd -m -s /bin/bash iframely
+
+cd ~iframely
+sudo -Hu iframely git clone https://github.com/itteco/iframely.git
+cd iframely
+sudo -Hu iframely git tag -l
+sudo -Hu iframely git checkout tags/v1.5.0
+sudo -Hu iframely npm install
+```
+
+**Opcional** Remplazar puerto 80 por 8061; también remplazar o desabilitar el almacenamiento del cache por ahora (CACHE_ENGINE: 'no-cache')
+
+```bash
+sudo -Hu iframely cp ~lemmy/lemmy/docker/iframely.config.local.js ~lemmy/iframely/config.local.js
+```
+
+Iniciar el servidor iframely o, usar un [script de inicio](#initiframely) en su lugar, el cual es la mejor opción que correr esto manualmente.
+
+```bash
+sudo -Hu iframely node server
+```
+
+### Instalar pict-rs
+
+```bash
+useradd -m -s /bin/bash pictrs
+cp target/release/pict-rs .
+```
+
+Añadido **hdri** ya que **magick_rust** falla al compilar si no está. Mencionado en [error[E0425]: cannot find value QuantumRange in module bindings](https://github.com/nlfiedler/magick-rust/issues/40)
+
+```bash
+echo "media-gfx/imagemagick hdri jpeg lzma png webp" >> /etc/portage/package.use
+echo "*/* -llvm_targets_NVPTX -llvm_targets_AMDGPU" >> /etc/portage/package.use
+
+```
+
+Instalar paquetes extra requeridos para pict-rs:
+
+| Paquetes    |                                                  |
+|-------------|--------------------------------------------------|
+| media-libs  | [gexiv2](https://gitlab.gnome.org/GNOME/gexiv2)  |
+| media-gfx   | [imagemagick](https://imagemagick.org/index.php) |
+| media-video | [ffmpeg](https://ffmpeg.org/)                    |
+| sys-devel   | [clang](https://clang.llvm.org/)                 |
+
+Paquetes requeridos para pict-rs (en caso de un sistema separado):
+
+| Paquetes |                                    |
+|----------|------------------------------------|
+| dev-lang | [rust](https://www.rust-lang.org/) |
+
+**Opcional** Hacer un script o ejecutarlo manualmente como usuario.
+
+```bash
+su - pictrs
+git clone https://git.asonix.dog/asonix/pict-rs.git
+cd pict-rs
+git tag -l
+git checkout tags/v0.2.5-r0
+
+cargo build --release
+cp target/release/pict-rs .
+cd ~pictrs
+mkdir pictrs-data
+```
+
+**Falta algo en el README de pict-rs - creó y utilaza una carpeta pict-rs in /tmp**
+
+Si haces algo raro como yo (cambiar el usuario con el que se ejecuta pict-rs) y terminas con problemas de permisos (que los registros no te dicen *Qué* está teniendo un problema de permisos), este podría ser tu problema. Además, el tiempo dirá si esta carpeta se limpia adecuadamente o no.
+
+Ejecutar pictrs de acuerdo a la siguiente línea:
+
+```bash
+pict-rs/pict-rs -a 127.0.0.1:9000 -p ~pictrs/pictrs-data/
+```
+
+Pero sólo usaremos el script init. 
+
+En este punto, corre todo a través de los [scripts de inicio](#scripts-de-inicio-init-scripts). Configura los scripts de inicio para que se ejecuten en el tiempo de arranque. Presumiblemente has configurado nginx y puedes llegar a tu instancia.
+
+
+---
+
+## Actualizando
+
+```bash
+su - lemmy
+cd lemmy
+```
+
+Haz BACKUP [config/config.hjson](#configuración-1) en algún lugar.
+
+```bash
+git fetch
+git tag -l
+git checkout tags/WHATEVER
+
+cargo build --release
+
+cd ~/lemmy-ui
+```
+
+### Lista las etiquetas(tags)/lanzamientos(releases) disponibles
+
+```bash
+git fetch
+git tag -l
+git checkout tags/WHATEVER
+git submodule update --remote
+```
+
+### Construir el frontend
+
+#### Esto es para producción
+
+```bash
+yarn install --pure-lockfile   # Is this step really needed?
+#yarn upgrade --pure-lockfile  # ?? Did I get it?
+#yarn   # Is this step really needed?  One of these steps is for sure. (Should be unnecessary)
+yarn build:prod
+```
+
+Reiniciar lemmy-ui
+
+### Actualizar iFramely
+
+```bash
+su - iframely
+cd iframely
+git fetch
+git tag -l
+git checkout tags/v1.6.0  # Or whatever the current appropriate release is
+npm install
+```
+
+Reinicia iframely
+
+### Actualizar pict-rs
+
+```bash
+su - pictrs
+cd pict-rs
+git fetch
+git tag -l
+git checkout tags/v0.2.5-r0  # (or whatever is currently mentioned in the lemmy docker file)
+
+cargo build --release
+cp target/release/pict-rs .
+```
+
+Reinicia pictrs
+
+---
+
+## Índice
+
+### configuración
+
+ejemplo de config/config.hjson
+
+```json
+{
+  database: {
+    user: "lemmy"
+    password: "whatever"
+    host: "localhost"
+    port: 5432
+    database: "lemmy"
+    pool_size: 5
+  }
+  hostname: "lemmy.ca"
+  bind: "127.0.0.1"
+  port: 8536
+  docs_dir: "/home/lemmy/lemmy/docs/book"
+  pictrs_url: "http://localhost:9000"
+  iframely_url: "http://localhost:8061"
+  federation: {
+    enabled: true
+    allowed_instances: ""
+    blocked_instances: ""
+  }
+  email: {
+    smtp_server: "localhost:25"
+    smtp_from_address: "lemmy@lemmy.ca"
+    use_tls: false
+  }
+}
+```
+
+### Scripts de inicio (init scripts)
+
+##### init/iframely
+
+```bash
+#!/sbin/openrc-run
+
+name="Iframely Daemon"
+
+depend() {
+        need localmount
+        need net
+}
+
+start() {
+        ebegin "Starting Iframely"
+        start-stop-daemon --start --background --make-pidfile --user iframely --group iframely --pidfile /home/iframely/iframely.pid --chdir /home/iframely/iframely -3 /usr/bin/logger -4 /usr/bin/logger --exec node -- server
+        eend $?
+}
+
+stop() {
+        start-stop-daemon --stop --signal TERM --pidfile /home/iframely/iframely.pid
+        eend $?
+}
+```
+
+##### init/lemmy
+
+```bash
+#!/sbin/openrc-run
+
+name="Lemmy Backend"
+
+depend() {
+        need localmount
+        need net
+}
+
+start() {
+        ebegin "Starting Lemmy"
+        start-stop-daemon --start --background --make-pidfile --user lemmy --group lemmy --pidfile /home/lemmy/lemmy.pid --chdir /home/lemmy/lemmy -3 /usr/bin/logger -4 /usr/bin/logger --exec ~lemmy/lemmy/target/release/lemmy_server
+        eend $?
+}
+
+stop() {
+        start-stop-daemon --stop --signal TERM --pidfile /home/lemmy/lemmy.pid
+        eend $?
+}
+```
+
+##### init/lemmy-ui
+
+```bash
+#!/sbin/openrc-run
+
+name="Lemmy UI"
+
+depend() {
+        need localmount
+        need net
+}
+
+start() {
+        ebegin "Starting Lemmy UI"
+        start-stop-daemon --start --background --make-pidfile --user lemmy --group lemmy --pidfile /home/lemmy/lemmy-ui.pid --chdir /home/lemmy/lemmy-ui -3 /usr/bin/logger -4 /usr/bin/logger --exec node dist/js/server.js --env LEMMY_INTERNAL_HOST=127.0.0.1:8536 --env LEMMY_EXTERNAL_HOST=lemmy.ca --env LEMMY_HTTPS=true
+        eend $?
+}
+```
+
+##### init/pict-rs
+
+```bash
+#!/sbin/openrc-run
+
+name="pict-rs Daemon"
+
+depend() {
+        need localmount
+        need net
+}
+
+start() {
+        ebegin "Starting pictrs"
+        start-stop-daemon --start --background --make-pidfile --user pictrs --group pictrs --pidfile /home/pictrs/pictrs.pid --chdir /home/pictrs/pict-rs -3 /usr/bin/logger -4 /usr/bin/logger --exec /home/pictrs/pict-rs/pict-rs -- -a 127.0.0.1:9000 -p ~pictrs/pictrs-data
+        eend $?
+}
+
+stop() {
+        start-stop-daemon --stop --signal TERM --pidfile /home/pictrs/pictrs.pid
+        eend $?
+}
+```
+

src/es/administration/on_aws.md

@@ -0,0 +1,53 @@
+# Instalando en AWS
+
+> ⚠️ **Descargo de responsabilidad:** este método de instalación no está recomendado por los desarrolladores de Lemmy. Si tienes algún problema, debes resolverlo tú mismo o preguntar a los respectivos autores. Si observas algún fallo de Lemmy en una instancia instalada de este modo, por favor, menciónalo en el informe de fallos.
+
+## Lemmy AWS CDK
+
+Contiene las definiciones de infraestructura necesarias para desplegar [Lemmy](https://github.com/LemmyNet/lemmy) en AWS su [Cloud Development Kit](https://docs.aws.amazon.com/cdk/latest/guide/home.html).
+
+### Incluye:
+
+* ECS fargate cluster
+  * Lemmy-UI
+  * Lemmy
+  * Pictrs
+  * IFramely
+* CloudFront CDN
+* Almacenamiento EFS para subir imágenes.
+* Aurora Serverless Postgres DB
+* Bastion VPC host
+* Balanceadores de carga para Lemmy y IFramely
+* Registros DNS para tu sitio.
+
+## Inicio rápido
+
+Clona el [Lemmy-CDK]( https://github.com/jetbridge/lemmy-cdk). 
+
+Clona [Lemmy](https://github.com/LemmyNet/lemmy) y [Lemmy-UI](https://github.com/LemmyNet/lemmy-ui) en el directorio de arriba.
+
+```shell
+cp example.env.local .env.local
+# edit .env.local
+```
+
+Debes editar .env.local con la configuración de tu sitio.
+
+```shell
+npm install -g aws-cdk
+npm install
+cdk bootstrap
+cdk deploy
+```
+
+## Coste
+Esta *no* es la forma más barata de ejecutar Lemmy. La base de datos sin servidor (serverless) Aurora puede costarte ~$90/mes (en dólares) si no duerme.
+
+## Comandos del CDK útiles
+
+* `npm run build`   compila typescript a js
+* `npm run watch`   vigila los cambios y compila
+* `npm run test`    realiza las pruebas unitarias de jest
+* `cdk deploy`      despliega esta pila en tu cuenta/región de AWS por defecto
+* `cdk diff`        compara la pila desplegada con el estado actual
+* `cdk synth`       emite la plantilla de CloudFormation sintetizada

src/es/administration/other_installation_methods.md

@@ -1,15 +0,0 @@
-# Otros Métodos de Instalación
-
-**Descargo de responsabilidad:** los desarrolladores de Lemmy no recomiendan estos métodos de instalación. Si tienes algún problema, debes resolverlo tú mismo o preguntar a los respectivos autores. Si observas algún fallo de Lemmy en una instancia instalada de esta manera, menciónalo en el informe de fallos.
-
-## Instalación de Lemmy sin Docker
-
-Instrucciones para instalar Lemmy de forma nativa, sin depender de Docker.
-
-[https://lemmy.ca/post/1066](https://lemmy.ca/post/1066)
-
-## Instalación en Amazon Web Services (AWS)
-
-Contiene las definiciones de infraestructura necesarias para desplegar Lemmy en [AWS](https://aws.amazon.com/) utilizando su [Kit de Desarrollo en la Nube](https://docs.aws.amazon.com/cdk/latest/guide/home.html).
-
-[https://github.com/jetbridge/lemmy-cdk](https://github.com/jetbridge/lemmy-cdk)

src/es/client_development/api_reference.md

@@ -1,49 +1,49 @@
-# API reference
+# Referencia de la API
 
-Lemmy has two, intertwined APIs:
+Lemmy tiene dos APIs entrelazadas:
 - [WebSocket](https://join-lemmy.org/api/index.html)
 - [HTTP](http_api.md)
 
-This page describes concepts that are common to both.
+Esta página describe conceptos que son comúnes para ambas.
 
 <!-- toc -->
 
-- [Basic usage](#basic-usage)
+- [Uso básico](#uso-básico)
-- [Data types](#data-types)
+- [Tipos de datos](#tipos-de-datos)
-  * [Lemmy types](#lemmy-types)
+  * [Tipos de Lemmy](#tipos-de-lemmy)
-  * [Lower-level types](#lower-level-types)
+  * [Tipos de bajo nivel](#tipos-de-bajo-nivel)
-- [Default rate limits](#default-rate-limits)
+- [Límites de tarifa por defecto](#límites-de-tarifa-por-defecto)
 
 <!-- tocstop -->
 
-## Basic usage
+## Uso básico
 
-Request and response strings are in [JSON format](https://www.json.org).
+Las cadenas de solicitud `request` y respuesta `response` están en [formato JSON](https://www.json.org/json-es.html).
 
-## Data types
+## Tipos de datos
 
-### Lemmy types
+### Tipos de Lemmy
 
-- [Source tables, that have the columns / fields](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/interfaces/source.ts)
+- [tablas que tienen las columnas / campos](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/interfaces/source.ts)
-- [Aggregates (for things like scores)](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/interfaces/aggregates.ts)
+- [Aggregates (para cosas como las puntuaciones)](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/interfaces/aggregates.ts)
-- [Views - The main lemmy return types](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/interfaces/views.ts)
+- [Views (vistas) - The main lemmy return types](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/interfaces/views.ts)
-- [Request Forms / Responses are in this folder](https://github.com/LemmyNet/lemmy-js-client/tree/main/src/interfaces/api)
+- [Los formularios de solicitud (Request) / respuesta (Responses)](https://github.com/LemmyNet/lemmy-js-client/tree/main/src/interfaces/api)
 
-### Lower-level types
+### Tipos de bajo nivel
 
-- `?` designates an option which may be omitted in requests and not be present in responses. It will be of type ***SomeType***.
+- `?` designa una opción que puede omitirse en las solicitudes y no estar presenet en las respuestas. Será de tipo ***SomeType*** (AlgúnTipo).
-- `[SomeType]` is a list which contains objects of type ***SomeType***.
+- `[SomeType]` es una lista que contiene objetos del tipo ***SomeType***.
-- Times and dates are timestamp strings in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format. Timestamps will be UTC, your client must do the UTC to local conversion.
+- Las horas (times) y fechas (dates) son cadenas de marcas de tiempo (timestamp) en formato [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601). Timestamps serán UTC, tú cliente debe hacer la conversión de UTC a local.
 
-## Default rate limits
+## Límites de tasa por defecto
 
-These can be edited in your `lemmy.hjson` file, by copying the relevant section from [defaults.hjson](https://github.com/LemmyNet/lemmy/blob/main/config/defaults.hjson).
+Estos límites pueden ser editados en tú archivo `lemmy.hjson`, copiando la sección relevante de [defaults.hjson](https://github.com/LemmyNet/lemmy/blob/main/config/defaults.hjson).
 
-- 3 per hour for signups and community creation.
+- 3 por hora para inscripciones y creación de comunidades.
-- 6 per hour for image posting.
+- 6 por hora para publicación de imágenes.
-- 6 per 10 minutes for post creation.
+- 6 por 10 minutos para la creación de publicaciones.
-- 180 actions per minute for post voting and comment creation.
+- 180 acciones por minuto para la votación de publicaciones y la creación de comentarios.
 
-Everything else is not rate-limited.
+El resto no cuenta con límites de tasa.
 
-**See also:** [rate limiting for custom front-ends](custom_frontend.md#rate-limiting).
+**Véase también:** [Limitación de la tasa para front-ends personalizados](custom_frontend.md#limitación-de-la-tasa).

src/es/client_development/client_development.md

@@ -1,6 +1,8 @@
-# Client Development
+# Desarrollo de clientes
 
-- [Theming Guide](client_development/theming.md)
+Esta sección es para cualquiera que quiera colaborar con la [aplicación web oficial para Lemmy](https://github.com/LemmyNet/lemmy-ui) o quiera desarrollar su propio cliente para el ecosistema Lemmy. 
-- [API reference](client_development/api_reference.md)
+
-- [WebSocket API](https://join-lemmy.org/api/index.html)
+- [Guía para Temas](client_development/theming.md)
-- [HTTP API](client_development/http_api.md)
+- [Referencia de la API](client_development/api_reference.md)
+- [API del WebSocket](https://join-lemmy.org/api/index.html)
+- [API HTTP](client_development/http_api.md)

src/es/client_development/custom_frontend.md

@@ -1,14 +1,14 @@
-# Creating a Custom Frontend
+# Crear un Frontend Personalizado
 
-The backend and frontend are completely decoupled, and run in independent Docker containers. They only communicate over the [Lemmy API](api_reference.md), which makes it quite easy to write alternative frontends.
+El backend y el frontend están completamente desacoplados y se ejecutan en contenedores Docker independientes. Solo se comunican a través de la [API de Lemmy](api_reference.md), lo que hace que sea bastante fácil escribir interfaces alternativas.
 
-This creates a lot of potential for custom frontends, which could change much of the design and user experience of Lemmy. For example, it would be possible to create a frontend in the style of a traditional forum like [phpBB](https://www.phpbb.com/), or a question-and-answer site like [stackoverflow](https://stackoverflow.com/). All without having to think about database queries, authentification or ActivityPub, which you essentially get for free.
+Esto crea un gran potencial para las interfaces personalizadas, que podrían cambiar gran parte del diseño y la experiencia del usuario de Lemmy. Por ejemplo, sería posible crear un frontend al estilo de un foro tradicional como [phpBB](https://www.phpbb.com/), o un sitio de preguntas y respuestas como [stackoverflow](https://stackoverflow.com/). Todo ello sin tener que pensar en las consultas a la base de datos, en la autentificación o en el ActivityPub, que esencialmente se obtiene de forma gratuita.
 
-## Development
+## Desarrollo
 
-You can use any language to create a custom frontend. The easiest option would be forking our [official frontend](https://github.com/LemmyNet/lemmy-ui), [lemmy-lite](https://github.com/IronOxidizer/lemmy-lite), or the [lemmy-frontend-example](https://github.com/LemmyNet/lemmy-front-end-example). In any case, the principle is the same: bind to `LEMMY_EXTERNAL_HOST` (default: `localhost:8536`) and handle requests using the Lemmy API at `LEMMY_INTERNAL_HOST` (default: `lemmy:8536`). Also use `LEMMY_HTTPS` to generate links with the correct protocol.
+Puedes utilizar cualquier lenguaje para crear un frontend personalizado. La opción más fácil sería hacer un fork de nuestro [frontend oficial](https://github.com/LemmyNet/lemmy-ui), [lemmy-lite](https://github.com/IronOxidizer/lemmy-lite), o el [lemmy-frontend-example](https://github.com/LemmyNet/lemmy-front-end-example). En cualquier caso, el principio es el mismo: enlazar con `LEMMY_EXTERNAL_HOST` (por defecto: `localhost:8536`) y gestionar las peticiones utilizando la API de Lemmy en `LEMMY_INTERNAL_HOST` (por defecto: `lemmy:8536`). Utilice también `LEMMY_HTTPS` para generar enlaces con el protocolo correcto.
 
-The next step is building a Docker image from your frontend. If you forked an existing project, it should already include a `Dockerfile` and instructions to build it. Otherwise, try searching for your language on [dockerhub](https://hub.docker.com/), official images usually have build instructions in their readme. Build a Docker image with a tag, then look for the following section in `docker/dev/docker-compose.yml`:
+El siguiente paso es construir una imagen Docker desde tu frontend. Si has bifurcado (fork) un proyecto existente, debería incluir un archivo Docker y las instrucciones para construirlo. Si no, intenta buscar para tu lenguaje en [dockerhub](https://hub.docker.com/), las imágenes oficiales suelen tener instrucciones para construir en su readme. Construye una imagen Docker con una etiqueta, luego busca la siguiente sección en `docker/dev/docker-compose.yml`:
 
 ```
   lemmy-ui:
@@ -24,25 +24,25 @@ The next step is building a Docker image from your frontend. If you forked an ex
       - lemmy
 ```
 
-All you need to do is replace the value for `image` with the tag of your own Docker image (and possibly the environment variables if you need different ones). Then run `./docker_update.sh`, and after compilation, your frontend will be available on `http://localhost:1235`. You can also make the same change to `docker/federation/docker-compose.yml` and run `./start-local-instances.bash` to test federation with your frontend.
+Todo lo que tienes que hacer es sustituir el valor de `image` por la etiqueta de tu propia imagen Docker (y posiblemente las variables de entorno si necesitas otras diferentes). A continuación, ejecuta `./docker_update.sh`, y después de la compilación, tu frontend estará disponible en `http://localhost:1235`. También puedes hacer el mismo cambio en `docker/federation/docker-compose.yml` y ejecutar `./start-local-instances.bash` para probar la federación con tu frontend.
 
-## Deploy with Docker
+## Desplegar con Docker
 
-After building the Docker image, you need to push it to a Docker registry (such as [dockerhub](https://hub.docker.com/)). Then update the `docker-compose.yml` on your server, replacing the `image` for `lemmy-ui`, just as described above. Run `docker-compose.yml`, and after a short wait, your instance will use the new frontend.
+Después de construir la imagen Docker, necesitas empujarla (hacer push) a un registro Docker (como [dockerhub](https://hub.docker.com/)). A continuación, actualiza el `docker-compose.yml` en tu servidor, sustituyendo la `image` por `lemmy-ui`, tal y como se ha descrito anteriormente. Ejecuta `docker-compose.yml` y, tras una breve espera, tu instancia utilizará el nuevo frontend.
 
-Note, if your instance is deployed with Ansible, it will override `docker-compose.yml` with every run, reverting back to the default frontend. In that case you should copy the `ansible/` folder from this project to your own repository, and adjust `docker-compose.yml` directly in the repo.
+Toma en cuenta que si tu instancia se despliega con Ansible, éste anulará (sobreescribirá) `docker-compose.yml` con cada ejecución, volviendo al frontend por defecto. En ese caso debes copiar la carpeta `ansible/` de este proyecto a tu propio repositorio, y ajustar `docker-compose.yml` directamente en el repo.
 
-It is also possible to use multiple frontends for the same Lemmy instance, either using subdomains or subfolders. To do that, don't edit the `lemmy-ui` section in `docker-compose.yml`, but duplicate it, adjusting the name, image and port so they are distinct for each. Then edit your nginx config to pass requests to the appropriate frontend, depending on the subdomain or path.
+También es posible utilizar varios frontends para la misma instancia de Lemmy, ya sea utilizando subdominios o subcarpetas. Para ello, no edites la sección `lemmy-ui` en `docker-compose.yml`, sino duplícala, ajustando el nombre, la imagen y el puerto para que sean distintos para cada uno. Luego edita tu configuración de nginx para pasar las peticiones al frontend apropiado, dependiendo del subdominio o la ruta.
 
-## Translations
+## Traducciones
 
-You can add the [lemmy-translations](https://github.com/LemmyNet/lemmy-translations) repository to your project as a [git submodule](https://git-scm.com/book/en/v2/Git-Tools-Submodules). That way you can take advantage of same translations used in the official frontend, and you will also receive new translations contributed via weblate.
+Puedes añadir el repositorio [lemmy-translations](https://github.com/LemmyNet/lemmy-translations) a tu proyecto como un [submódulo git](https://git-scm.com/book/en/v2/Git-Tools-Submodules). De este modo, podrás aprovechar las mismas traducciones que se utilizan en el frontend oficial, y también recibirás las nuevas traducciones aportadas a través de [weblate](https://weblate.org/es/).
 
-## Rate limiting
+## Limitación de la tasa
 
-Lemmy does rate limiting for many actions based on the client IP. But if you make any API calls on the server side (eg in the case of server-side rendering, or javascript pre-rendering), Lemmy will take the IP of the Docker container. Meaning that all requests come from the same IP, and get rate limited much earlier. To avoid this problem, you need to pass the headers `X-REAL-IP` and `X-FORWARDED-FOR` on to Lemmy (the headers are set by our nginx config).
+Lemmy limita la tasa de muchas acciones en función de la IP del cliente. Pero si haces alguna llamada a la API en el lado del servidor (por ejemplo, en el caso de la renderización del lado del servidor, o la pre-renderización de javascript), Lemmy tomará la IP del contenedor Docker. Lo que significa que todas las peticiones provienen de la misma IP, y obtienen la tasa limitada mucho antes. Para evitar este problema, es necesario pasar las cabeceras `X-REAL-IP` y `X-FORWARDED-FOR` a Lemmy (las cabeceras son establecidas por nuestra configuración de nginx).
 
-Here is an example snipped for NodeJS:
+Aquí hay un ejemplo recortado para NodeJS:
 
 ```javascript
 function setForwardedHeaders(

src/es/client_development/http_api.md

@@ -1,35 +1,36 @@
-# Lemmy HTTP API
+# API HTTP de Lemmy
 
 
 <!-- toc -->
 
-- [Websocket vs HTTP API](#websocket-vs-http-api)
+- [Websocket vs API HTTP](#websocket-vs-api-http)
-- [Examples](#examples)
+- [Ejemplos](#ejemplos)
   * [TypeScript](#typescript)
   * [Curl](#curl)
-    + [GET](#get-example)
+    + [GET](#ejemplo-get)
-    + [POST](#post-example)
+    + [POST](#ejemplo-post)
-- [HTTP API exclusive features](#http-api-exclusive-features)
+- [Características exclusivas de la API HTTP](#características-exclusivas-de-la-api-http)
   * [RSS/Atom feeds](#rss-atom-feeds)
-  * [Images](#images)
+  * [Imagenes](#imagenes)
-    + [Create (request)](#create-request)
+    + [Crear (request)](#crear-request)
-    + [Create (response)](#create-response)
+    + [Crear (response)](#crear-response)
     * [Delete](#delete)
 
 <!-- tocstop -->
 
-## WebSocket vs HTTP API
+## WebSocket vs API HTTP
-Lemmy's HTTP API is almost identical to its WebSocket API:
+La API HTTP de Lemmy es casi parecida a la API del Websocket:
-- **WebSocket API** needs `let send = { op: userOperation[op], data: form}` as shown in [the WebSocketAPI specification](https://join-lemmy.org/api/index.html)
+- **API WebSocket** necesita `let send = { op: userOperation[op], data: form}` como se muestra en [la especificación de la API WebSocket](https://join-lemmy.org/api/index.html)
-- **HTTP API** needs the form (data) at the top level, an HTTP operation (GET, PUT or POST) and endpoint (at `http(s)://host/api/v2/endpoint`). For example:
+- **API HTTP** necesita el formulario (datos) en el primer nivel; una operación HTTP (GET, PUT o POST) y endpoint (en `http(s)://host/api/v2/endpoint`). Por ejemplo:
 
 > `POST {username_or_email: X, password: X}`
 
-For more information, see the [http.ts](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/http.ts) file.
+Para más información. Véase el archivo
+[http.ts](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/http.ts) .
 
-[The WebSocket API](https://join-lemmy.org/api/index.html) should be regarded as the primary source for the HTTP API since it also provides information about how to form HTTP API calls.
+[El API del WebSocket](https://join-lemmy.org/api/index.html) debería considerarse como la fuente principal para la API HTPP, ya que también proporciona información sobre cómo formular las llamadas a la API HTTP.
 
-## Examples
+## Ejemplos
 
 ### TypeScript
 
@@ -39,19 +40,19 @@ For more information, see the [http.ts](https://github.com/LemmyNet/lemmy-js-cli
   }
 ```
 
-| Type | URL | Body type | Return type |
+| Tipo | URL | Tipo de cuerpo | Tipo de Retorno |
 | --- | --- | --- | --- |
 | `PUT` | `/comment` | `EditComment` | `CommentResponse` |
 
 ### Curl
 
-**GET example**
+#### Ejemplo GET
 
 ```
 curl "http://localhost:8536/api/v2/community/list?sort=Hot"`
 ```
 
-**POST example**
+#### Ejemplo POST
 
 ```
 curl -i -H \
@@ -65,34 +66,36 @@ curl -i -H \
 http://localhost:8536/api/v2/comment/like
 ```
 
-## HTTP API exclusive features
+## Características exclusivas de la API HTTP
 
-These features cannot be accessed from the WebSocket API:
+Estas características no pueden ser accesadas desde la API del WebSocket:
 
 - [RSS/Atom feeds](#rss-atom-feeds)
-- [Images](#images)
+- [Imagenes](#imagenes)
 
 ### RSS/Atom feeds
 
-- All - `/feeds/all.xml?sort=Hot`
+- All (Todo) - `/feeds/all.xml?sort=Hot`
-- Community - `/feeds/c/community-name.xml?sort=Hot`
+- Community (Comunidad) - `/feeds/c/community-name.xml?sort=Hot`
-- User - `/feeds/u/user-name.xml?sort=Hot`
+- User (usuario) - `/feeds/u/user-name.xml?sort=Hot`
 
-### Images
+### Imagenes
 
-Lemmy forwards image requests to a locally running Pictrs.
+Leemy reenvía las peticiones de imagenes a un Pictrs que se ejecuta localmenet.
 
 `GET /pictrs/image/{filename}?format={webp, jpg, ...}&thumbnail={96}`
 
-*Format and thumbnail are optional.*
+*El formato (format) y la miniatura (thumbnail) son opcionales*
 
-#### Create (request)
+#### Crear (request)
+
+El contenido subido debe ser un formulario (multipart/form-data) válido con una matriz de imagenes situada dentro de la clave `images[]`.
 
 Uploaded content must be valid multipart/form-data with an image array located within the images[] key.
 
 `POST /pictrs/image` 
 
-#### Create (response)
+#### Crear (response)
 
 ```
 {
@@ -111,6 +114,7 @@ Uploaded content must be valid multipart/form-data with an image array located w
 `GET /pictrs/image/delete/{delete_token}/{file}`
 
 
-# Note
+# Nota
 
-This documentation may lag behind the actual [API endpoints](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/http.ts) and the API itself should be considered unstable (since it may change at any time).
+Esta documentación puede tener un retraso con respecto a la actual
+[API endpoints](https://github.com/LemmyNet/lemmy-js-client/blob/main/src/http.ts). La API misma debería ser considerada inestable (está sujeta a cambios en cualquier momento).

src/es/client_development/theming.md

@@ -1,19 +1,19 @@
-# Theming Guide
+# Guía para Temas
 
-Lemmy uses [Bootstrap v4](https://getbootstrap.com/), and very few custom css classes, so any bootstrap v4 compatible theme should work fine.
+Lemmy usa [Bootstrap v4](https://getbootstrap.com/), y algunas clases css customizadas por lo que cualquier tema compatible con bootstrap v4 debería de funcionar.
 
-## Creating
+## Creación
 
-- Use a tool like [bootstrap.build](https://bootstrap.build/) to create a bootstrap v4 theme. Export the `bootstrap.min.css` once you're done, and save the `_variables.scss` too.
+- Usa una herramienta, por ejemplo [bootstrap.build](https://bootstrap.build/) para crear tú tema de bootstrap v4. Exporta el archivo `bootstrap.min.css` una vez terminado el tema, y conserva támbién el archivo generado `_variables.scss`.
 
-## Testing
+## Prueba
 
-- To test out a theme, you can either use your browser's web tools, or a plugin like stylus to copy-paste a theme, when viewing Lemmy.
+- Para probar el tema, puedes también usar las herramientas del navegador web, o un plugin como *stylus* para copiar/pegar un tema, y verlo en Lemmy.
 
-## Adding
+## Subir / Publicar
 
-1. Fork the [lemmy-ui](https://github.com/LemmyNet/lemmy-ui).
+1. Haz un *fork* de [lemmy-ui](https://github.com/LemmyNet/lemmy-ui).
-1. Copy `{my-theme-name}.min.css` to `src/assets/css/themes`. (You can also copy the `_variables.scss` here if you want).
+1. Copia el archivo `{nombre-de-mi-tema}.min.css` a la carpeta `src/assets/css/themes`. (Aquí puedes copiar el archivo `_variables.scss` si lo deseas).
-1. Go to `src/shared/utils.ts` and add `{my-theme-name}` to the themes list.
+1. Abre el archivo `src/shared/utils.ts` y agregas `{nombre-de-mi-tema}` a la lista de temas.
-1. Test locally
+1. Pruebalo localmente
-1. Do a pull request with those changes.
+1. Haz *pull request* con los cambios que hiciste.

src/es/client_development/websocket_api.md

@@ -1 +1,2 @@
-# [WebSocket API](https://join-lemmy.org/api/index.html)
+# API del WebSocket
+[Documentación de la API del WebSocket de Lemmy](https://join-lemmy.org/api/index.html)

src/es/contributing/contributing.md

@@ -1,40 +1,39 @@
-# Contributing
+# Contribuir al Proyecto
 
-Information about contributing to Lemmy, whether it is translating, testing, designing or programming.
+Información sobre como contribuir a Lemmy, ya sea traduciendo, probando, diseñando o programando.
 
-## Issue tracking / Repositories
+## Seguimiento de problemas (issues) / Repositorios
 
-- [GitHub (for issues and pull requests)](https://github.com/LemmyNet/lemmy)
+- [GitHub (para issues y pull requests)](https://github.com/LemmyNet/lemmy)
-- [Gitea (only for pull requests)](https://yerbamate.ml/LemmyNet/lemmy)
+- [Gitea (solo para pull requests)](https://yerbamate.ml/LemmyNet/lemmy)
 - [Codeberg](https://codeberg.org/LemmyNet/lemmy)
 
-## Translating
+## Traduciendo
 
-Check out [Lemmy's Weblate](https://weblate.yerbamate.ml/projects/lemmy/) for translations. You can also help by [translating this documentation](https://github.com/LemmyNet/lemmy-docs#adding-a-new-language).
+Mira el  [Weblate de Lemmy](https://weblate.yerbamate.ml/projects/lemmy/) para las traducciones. Tú también puedes ayudar [traduciendo esta documentación](https://github.com/LemmyNet/lemmy-docs#adding-a-new-language).
 
-
+## Arquitectura
-## Architecture
 
 ### Front end
 
-- The front end is written in `typescript`, using a react-like framework called [inferno](https://infernojs.org/). All UI elements are reusable `.tsx` components.
+- El front end está escrito en `typescript`, usando un framework similar a React llamado [inferno](https://infernojs.org/). Todos los elementos de la interfaz de usuario (UI) son componentes `.tsx` reutilizables.
-- The front end repository is [lemmy-ui](https://github.com/LemmyNet/lemmy-ui).
+- El repositorio del front end es [lemmy-ui](https://github.com/LemmyNet/lemmy-ui).
-- The routes are at `src/shared/routes.ts`.
+- Las rutas están en `src/shared/routes.ts`.
-- The components are located in `src/shared/components`.
+- Los componentes están localizados en `src/shared/components`.
 
 ### Back end
 
-- The back end is written in `rust`, using `diesel`, and `actix`.
+- El back end está escrito en `rust`, usando `diesel`, y `actix`.
-- The server source code is split into main sections in `src`. These include: 
+- El código fuente del servidor está divido en secciones *main* in `src`. Estos incluyen:
-  - `db` - The low level database actions.
+  - `db` - Las acciones de bajo nivel de la base de datos.
-    - Database additions are done using diesel migrations. Run `diesel migration generate xxxxx` to add new things.
+    - Las adiciones a la base de datos se realizan mediante migraciones. Ejecuta `diesel migration generate xxxxx` para añadir cosas nuevas.
-  - `api` - The high level user interactions (things like `CreateComment`)
+  - `api` - Las iteracciones de alto nivel del usuario (cosas como `CreateComment`)
-  - `routes` - The server endpoints .
+  - `routes` - Los puntos finales (endpoints) del servidor.
-  - `apub` - The activitypub conversions.
+  - `apub` - Las conversiones activitypub.
-  - `websocket` - Creates the websocket server. 
+  - `websocket` - Crea el sevidor del websocket. 
 
-## Linting / Formatting
+## Linting / Formateo
 
-- Every front and back end commit is automatically formatted then linted using `husky`, and `lint-staged`.
+- Cada commit del front end y back end se formatea automáticamente y luego se hace un linting usando `husky`, y `lint-staged`.
-- Rust with `cargo fmt` and `cargo clippy`.
+- Rust con `cargo fmt` y `cargo clippy`.
-- Typescript with `prettier` and `eslint`.
+- Typescript con `prettier` y `eslint`.

src/es/contributing/docker_development.md

@@ -1,6 +1,8 @@
-# Docker Development
+# Desarrollo con Docker
 
-## Dependencies (on Ubuntu)
+## Dependencias
+
+### Distro basada en Debian
 
 ```bash
 sudo apt install git docker-compose
@@ -8,18 +10,26 @@ sudo systemctl start docker
 git clone https://github.com/LemmyNet/lemmy
 ```
 
-## Running
+### Distro basada en Arch
+
+```bash
+sudo -S git docker-compose
+sudo systemctl start docker
+git clone https://github.com/LemmyNet/lemmy
+```
+
+## Ejecución
 
 ```bash
 cd docker/dev
 ./docker_update.sh
 ```
 
-and go to http://localhost:1235.
+Finalmente abre la siguiente dirección en tu navegador: `http://localhost:1235`.
 
-*Note: many features (like docs and pictures) will not work without using an nginx profile like that in `ansible/templates/nginx.conf`.
+**Nota:** muchas características (como docs e imagenes) no funcionarán sin usar un perfil de nginx como en `ansible/templates/nginx.conf`.
 
-To speed up the Docker compile, add the following to `/etc/docker/daemon.json` and restart Docker.
+Para acelerar la compilación de Docker, añade el siguiente código a `/etc/docker/daemon.json` y reinicia Docker.
 ```
 {
   "features": {
@@ -28,5 +38,4 @@ To speed up the Docker compile, add the following to `/etc/docker/daemon.json` a
 }
 ```
 
-If the build is still too slow, you will have to use a
+Si la compilación sigue siendo muy lenta, tendrás que usar un [desarrollo local](local_development.md) en su lugar.
-[local build](local_development.md) instead.

src/es/contributing/federation_development.md

@@ -1,43 +1,41 @@
-# Federation Development
+# Desarrollo de la Federación
 
-## Running locally
+## Ejecutando localmente
 
-Install the dependencies as described in [Docker development](docker_development.md). Then run the following
+Instala las dependencias necesarias como esta descrito en el documento [Desarrollo con Docker](docker_development.md). Enseguida ejecuta lo siguiente:
 
 ```bash
 cd docker/federation
 ./start-local-instances.bash
 ```
 
-The federation test sets up 5 instances:
+Las pruebas de federación establecen 5 instancias:
 
-Instance | Username | Location | Notes
+Instancia | Nombre de usuario | Localización | Notas
 --- | --- | --- | ---
-lemmy-alpha | lemmy_alpha | [127.0.0.1:8540](http://127.0.0.1:8540) | federated with all other instances
+lemmy-alpha | lemmy_alpha | [127.0.0.1:8540](http://127.0.0.1:8540) | federada con todas las demás instancias
-lemmy-beta | lemmy_beta | [127.0.0.1:8550](http://127.0.0.1:8550) | federated with all other instances
+lemmy-beta | lemmy_beta | [127.0.0.1:8550](http://127.0.0.1:8550) | federada con todas las demás instancias
-lemmy-gamma | lemmy_gamma | [127.0.0.1:8560](http://127.0.0.1:8560) | federated with all other instances
+lemmy-gamma | lemmy_gamma | [127.0.0.1:8560](http://127.0.0.1:8560) | federada con todas las demás instancias
-lemmy-delta | lemmy_delta | [127.0.0.1:8570](http://127.0.0.1:8570) | only allows federation with lemmy-beta
+lemmy-delta | lemmy_delta | [127.0.0.1:8570](http://127.0.0.1:8570) | solo permite federación con lemmy-beta
-lemmy-epsilon | lemmy_epsilon | [127.0.0.1:8580](http://127.0.0.1:8580) | uses blocklist, has lemmy-alpha blocked
+lemmy-epsilon | lemmy_epsilon | [127.0.0.1:8580](http://127.0.0.1:8580) | usa la lista de bloqueo, tiene lemmy-alpha bloqueada
 
-You can log into each using the instance name, and `lemmy` as the password, IE (`lemmy_alpha`, `lemmy`). 
+Puedes registrarte en cada una usando el nombre de la instancia, y `lemmy` como la contraseña, ejemplo: (`lemmy_alpha`, `lemmy`). 
 
-To start federation between instances, visit one of them and search for a user, community or post, like this. Note that
+Para iniciar la federación entre instancias, visita una de ellas y busca un
-the Lemmy backend runs on a different port than the frontend, so you have to increment the port number from 
+usuario, comunidad o publicación, como en este ejemplo. Nota que el backend de Lemmy se ejecuta en un puerto diferente al del frontend, por lo que tienes que incrementar en uno el número de puerto de la barra de URL.
-the URL bar by one.
 - `!main@lemmy-alpha:8541`
 - `http://lemmy-beta:8551/post/3`
 - `@lemmy-gamma@lemmy-gamma:8561`
 
-Firefox containers are a good way to test them interacting.
+Los contenedores de Firefox son una buena forma de probar su interacción.
 
-## Running on a server
+## Ejecutando en un servidor
 
-Note that federation is currently in alpha. **Only use it for testing**, not on any production server, and be aware that turning on federation may break your instance.
+Ten en cuenta que la federación está actualmente en fase alfa. **Únicamente utilícela para pruebas**, no en un servidor de producción, y sé cuidadoso, que activar la federación puede romper tu instancia.
 
-Follow the normal installation instructions, either with [Ansible](../administration/install_ansible.md) or
+Sigue las instrucciones normales de instalación, ya sea con [Ansible](../administration/install_ansible.md) o
-[manually](../administration/install_docker.md). Then replace the line `image: dessalines/lemmy:v0.x.x` in 
+[manualmente con Docker](../administration/install_docker.md). Luego reemplaza la linea `image: dessalines/lemmy:v0.x.x` en 
-`/lemmy/docker-compose.yml` with `image: dessalines/lemmy:federation`. Also add the following in
+`/lemmy/docker-compose.yml` con `image: dessalines/lemmy:federation`. También añade lo siguiente en `/lemmy/lemmy.hjson`:
-`/lemmy/lemmy.hjson`:
 
 ```
     federation: {
@@ -47,7 +45,7 @@ Follow the normal installation instructions, either with [Ansible](../administra
     }
 ```
 
-Afterwards, and whenever you want to update to the latest version, run these commands on the server:
+Después, y siempre que quieras actualizar a la última versión, ejecuta estos comandos en el servidor:
 
 ```
 cd /lemmy/
@@ -55,15 +53,10 @@ sudo docker-compose pull
 sudo docker-compose up -d
 ```
 
-## Security Model
+## Modelo de seguridad
 
-- HTTP signature verify: This ensures that activity really comes from the activity that it claims
+- Verificación de la firma HTTP: Garantiza que la actividad proviene realmente de la actividad que afirma
-- check_is_apub_valid : Makes sure its in our allowed instances list
+- check_is_apub_valid : Asegura que está en nuestra lista de instancias permitidas
-- Lower level checks: To make sure that the user that creates/updates/removes a post is actually on the same instance as that post
+- Comprobaciones de nivel inferior: Para asegurarse de que el usuario que crea/actualiza/elimina una publicación está realmente en la misma instancia que esa publicación
 
-For the last point, note that we are *not* checking whether the actor that sends the create activity for a post is
+Para el último punto, ten en cuenta que *no* estamos comprobando si el actor que envía la actividad de creación para una publicación es realmente idéntico al creador de la publicación, o si el usuario que elimina una entrada es un mod/admin. Estas cosas se comprueban por el código de la API, y es responsabilidad de cada instancia comprobar los permisos de los usuarios. Esto no deja ningún vector de ataque, ya que un usuario normal de la instancia no puede realizar acciones que violen las reglas de la API. El único que podría hacerlo es el administrador (y el software desplegado por el administrador). Pero el administrador puede hacer cualquier cosa en la instancia, incluso enviar actividades desde otras cuentas de usuario. Así que en realidad no ganaríamos nada de seguridad comprobando los permisos de los mods o similares.
-actually identical to the post's creator, or that the user that removes a post is a mod/admin. These things are checked
-by the API code, and its the responsibility of each instance to check user permissions. This does not leave any attack
-vector, as a normal instance user cant do actions that violate the API rules. The only one who could do that is the
-admin (and the software deployed by the admin). But the admin can do anything on the instance, including send activities
-from other user accounts. So we wouldnt actually gain any security by checking mod permissions or similar.

src/es/contributing/local_development.md

@@ -1,5 +1,9 @@
-### Install build requirements
+# Desarrollo Local
-#### Ubuntu
+
+### Instalar requisitos
+Instala Rust utilizando [la opción recomendada en rust-lang.org](https://www.rust-lang.org/tools/install) (rustup).
+
+#### Distro basada en Debian
 ```
 sudo apt install git cargo libssl-dev pkg-config libpq-dev yarn curl gnupg2 espeak
 # install yarn
@@ -8,38 +12,42 @@ echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/source
 sudo apt update && sudo apt install yarn
 ```
 
+#### Distro basada en Arch
+```
+sudo pacman -S git cargo libssl-dev pkg-config libpq-dev yarn curl gnupg2 espeak
+# install yarn (stable)
+curl -o- -L https://yarnpkg.com/install.sh | bash
+```
+
 #### macOS
+Instala [Homebrew](https://brew.sh/) si aún no lo has instalado.
 
-Install Rust using [the recommended option on rust-lang.org](https://www.rust-lang.org/tools/install) (rustup).
+Finalmente, instala Node y Yarn.
-
-Then, install [Homebrew](https://brew.sh/) if you don't already have it installed.
-
-Finally, install Node and Yarn.
 
 ```
 brew install node yarn
 ```
 
-### Get the back end source code
+### Obtener el código fuente del back end
 ```
 git clone https://github.com/LemmyNet/lemmy.git
 # or alternatively from gitea
 # git clone https://yerbamate.ml/LemmyNet/lemmy.git
 ```
 
-### Build the backend (Rust)
+### Compila el backend (Rust)
 ```
 cargo build
-# for development, use `cargo check` instead)
+# para desarrollo, usa `cargo check` en su lugar)
 ```
 
-### Get the front end source code
+### Obtener el código fuente del front end
 ```
 git clone https://github.com/LemmyNet/lemmy-ui.git --recurse-submodules
 ```
 
-### Setup postgresql
+### Configurar postgresql
-#### Ubuntu
+#### Distro basada en Debian
 ```
 sudo apt install postgresql
 sudo systemctl start postgresql
@@ -50,6 +58,17 @@ sudo -u postgres psql -c 'create database lemmy with owner lemmy;' -U postgres
 export LEMMY_DATABASE_URL=postgres://lemmy:password@localhost:5432/lemmy
 ```
 
+#### Distro basada en Arch
+```
+sudo pacman -S postgresql
+sudo systemctl start postgresql
+
+# Either execute db-init.sh, or manually initialize the postgres database:
+sudo -u postgres psql -c "create user lemmy with password 'password' superuser;" -U postgres
+sudo -u postgres psql -c 'create database lemmy with owner lemmy;' -U postgres
+export LEMMY_DATABASE_URL=postgres://lemmy:password@localhost:5432/lemmy
+```
+
 #### macOS
 ```
 brew install postgresql
@@ -62,15 +81,15 @@ psql -c 'create database lemmy with owner lemmy;' -U postgres
 export LEMMY_DATABASE_URL=postgres://lemmy:password@localhost:5432/lemmy
 ```
 
-### Run a local development instance
+### Ejecutar una instancia de desarrollo local
 ```
 cd lemmy
 cargo run
 ```
 
-Then open [localhost:1235](http://localhost:1235) in your browser. To reload back-end changes, you will have to rerun `cargo run`. You can use `cargo check` as a faster way to find compilation errors.
+Después abre [localhost:1235](http://localhost:1235) en tu navegador. Para recargar los cambios en el back-end, tendrás que volver ejecutar `cargo run`. Puedes usar `cargo check` como una manera mas rapida de econtrar errores de compilación.
 
-To do front end development:
+Para hacer desarrollo front end:
 
 ```
 cd lemmy-ui
@@ -78,8 +97,6 @@ yarn
 yarn dev
 ```
 
-and go to [localhost:1234](http://localhost:1234). Front end saves should rebuild the project.
+Enseguida entra a [localhost:1234](http://localhost:1234). Al guardar cambios, el frond end se debe recargar automáticamenete. 
 
-Note that this setup doesn't include image uploads or link previews (provided by pict-rs and
+Toma en cuenta que esta configuración no incluye la carga de imagenes ni la previsualización de enlaces (proporcionada por pict-rs y iframely respectivamente). Si quieres probarlos, debes de usar el [desarrollo Docker](docker_development.md).
-iframely respectively). If you want to test those, you should use the
-[Docker development](docker_development.md).

src/es/contributing/release_process.md

@@ -0,0 +1,19 @@
+# Bifurcaciones y Liberaciones
+
+## Bifurcaciones
+
+En general, nuestro manejo de las ramas es el descrito en [Un modelo de bifurcación de líneal principal estable para Git](https://www.bitsnbites.eu/a-stable-mainline-branching-model-for-git/). Una diferencia es que evitamos el rebase `rebase`, y en su lugar fusionamos `merge` la rama base en la rama de trabajo actual. Esto ayuda a evitar empujes `push` forzados y conflictos.
+
+## Liberaciones
+
+- Para una versión mayo `major release`: crea una nueva rama `release/v0.x`
+- Para una versión menor `minor release`: selecciona los cambios deseados en la rama `release/v0.x`
+- Hacer una versión beta `beta` o candidata `release candidate` con `docker/prod/deploy.sh`
+- Hacer lo mismo para `lemmy-ui`: `./deploy.sh 0.x.0-rc-x`
+- Despliega en las instancias de prueba de la federación
+    -  Mantener una instancia en la última versión estable para probar la compatibilidad de la federación (automatizar esto con ansible)
+    -  `ansible-playbook -i federation playbooks/site.yml --vault-password-file vault_pass -e rc_version=0.x.0-rc.x`
+- Prueba que todo funciona como se espera, haz nuevas versiones beta/rc si es necesario
+- Despliega en lemmy.ml, para descubrir los problemas restantes
+- Si todo ha ido bien, haz la versión oficial `0.x.0` con `docker/prod/deploy.sh`
+- Anuncia el lanzamiento en Lemmy, Matrix, Mastodon

src/es/contributing/tests.md

@@ -1,18 +1,17 @@
-### Tests
+### Pruebas
 
 #### Rust
 
-After installing [local development dependencies](local_development.md), run the
+Después de instalar las [dependencias para el desarrollo local](local_development.md), ejecuta el siguiente comando:
-following commands:
 
 ```bash
 psql -U lemmy -c "DROP SCHEMA public CASCADE; CREATE SCHEMA public;"
 ./test.sh
 ```
 
-### Federation
+### Federación
 
-Install the [Local development dependencies](local_development.md), and add the following lines to `/etc/hosts`:
+Instala las [dependencias para el desarrollo local](local_development.md), y agrega las siguientes a `/etc/hosts`:
 
 ```
 127.0.0.1       lemmy-alpha
@@ -22,7 +21,8 @@ Install the [Local development dependencies](local_development.md), and add the
 127.0.0.1       lemmy-epsilon
 ```
 
-Then use the following script to run the tests:
+Después usa el siguiente script para correr las pruebas:
+
 ```
 cd api_tests
 ./run-federation-test.bash

src/es/federation/federation.md

@@ -0,0 +1,2 @@
+# Federación
+

src/fr/client_development/websocket_api.md

@@ -1 +1,2 @@
-# [WebSocket API](https://join-lemmy.org/api/index.html)
+# WebSocket API
+[Lemmy WebSocket API 2.0 documentation](https://join-lemmy.org/api/index.html)

src/ru/client_development/websocket_api.md

@@ -1 +1,2 @@
-# [WebSocket API](https://join-lemmy.org/api/index.html)
+# WebSocket API
+[Lemmy WebSocket API 2.0 documentation](https://join-lemmy.org/api/index.html)