diff --git a/artisan.md b/artisan.md
index 4199151..c9ec277 100644
--- a/artisan.md
+++ b/artisan.md
@@ -6,31 +6,31 @@
 <a name="introduction"></a>
 ## Introducción
 
-Artisan es el nombre de la utilidad para la línea de comandos incluída en Laravel. Provee varios comandos útiles para ser usados mientras desarrollas tu aplicación. It is driven by the powerful Symfony Console component.
+Artisan es el nombre de la línea de comandos incluída en Laravel. Esta proporciona una serie de comandos útiles para tu uso mientras desarrollas tu aplicación. Ésta es implusada por el potente componente 'Symfony Console'.
 
 <a name="usage"></a>
 ## Uso
 
-Para ver una lista de los comandos disponibles en Artisan puedes usar el comando `list`:
+#### Listar Todos los Comandos Disponibles
 
-#### Mostrar lista de todos los comandos disponibles
+Para ver la lista de los comandos disponibles en Artisan puedes usar el comando `list`:
 
 	php artisan list
 
-Cada comando además incluye una pantalla de ayuda que muestra y describe los argumentos y opciones disponibles del comando. Para ver la ayuda, simplemente agrega `help` antes del nombre del comando:
+#### Ver la Pantalla de Ayuda para un Comando
 
-#### Ver la ayuda de un comando
+Cada comando además incluye una pantalla de "ayuda" que muestra y describe los argumentos y opciones disponibles de un comando. Para ver la ayuda, simplemente agrega `help` antes del nombre del comando:
 
 	php artisan help migrate
 
-Puedes espeficar el entorno de configuración que debería usarse para correr el comando usando la opción `--env`:
+#### Especificar la Configuración del Entorno
 
-#### Especificar la configuración del entorno
+Puedes espeficar el entorno de configuración que debería usarse para correr el comando usando la opción `--env`:
 
 	php artisan migrate --env=local
 
-Puedes ver la versión de Laravel usando la opción `--version`:
+#### Mostrar Tu Versión Actual de Laravel
 
-#### Mostrar la versión de Laravel
+Puedes ver la versión actual de tu instalación de Laravel usando la opción `--version`:
 
 	php artisan --version
diff --git a/cache.md b/cache.md
index 097f6e1..7424455 100644
--- a/cache.md
+++ b/cache.md
@@ -1,132 +1,132 @@
-# Cache
+# Caché
 
-- [Configuration](#configuration)
-- [Cache Usage](#cache-usage)
-- [Increments & Decrements](#increments-and-decrements)
-- [Cache Tags](#cache-tags)
-- [Database Cache](#database-cache)
+- [Configuración](#configuration)
+- [Uso de Caché](#cache-usage)
+- [Incrementos & Decrementos](#increments-and-decrements)
+- [Etiquetas de Caché](#cache-tags)
+- [Caché en Base de Datos](#database-cache)
 
 <a name="configuration"></a>
-## Configuration
+## Configuración
 
-Laravel provides a unified API for various caching systems. The cache configuration is located at `app/config/cache.php`. In this file you may specify which cache driver you would like used by default throughout your application. Laravel supports popular caching backends like [Memcached](http://memcached.org) and [Redis](http://redis.io) out of the box.
+Laravel provee una API unificada para vario sistemas de almacenamiento en caché. La configuración de la caché se encuentra en `app/config/cache.php`. En este archivo puedes especificar cuál controlador de caché te gustaría usar por defecto en a lo largo de tu aplicación. Laravel soporta backends de almacenamiento en caché populares como [Memcached](http://memcached.org) and [Redis](http://redis.io) los cuales funcionan inmediatamente después de la instalación sin ninguna configuración o modificación ("out of the box").
 
-The cache configuration file also contains various other options, which are documented within the file, so make sure to read over these options. By default, Laravel is configured to use the `file` cache driver, which stores the serialized, cached objects in the filesystem. For larger applications, it is recommended that you use an in-memory cache such as Memcached or APC.
+El archivo de configuración de la caché además contiene otras opciones, las cuales estan documentadas dentro del archivo mismo, así que asegurate de leer más de estas opciones. Por defecto, Laravel está configurado para usar el controlador de caché `file`, el cual almacena los objetos serealizados en cache, en el sistema de archivos. Para grandes aplicaciones, se recomienda que uses caché en memoria como Memcached o APC.
 
 <a name="cache-usage"></a>
-## Cache Usage
+## Uso de Caché
 
-#### Storing An Item In The Cache
+#### Almacenar un Elmento en la Caché
 
 	Cache::put('key', 'value', $minutes);
 
-#### Using Carbon Objects To Set Expire Time
+#### Usar Objetos Carbon para Establecer el Tiempo de Caducidad
 
 	$expiresAt = Carbon::now()->addMinutes(10);
 
 	Cache::put('key', 'value', $expiresAt);
 
-#### Storing An Item In The Cache If It Doesn't Exist
+#### Almacenar un Elemento en la Caché sí este no Existe
 
 	Cache::add('key', 'value', $minutes);
 
-The `add` method will return `true` if the item is actually **added** to the cache. Otherwise, the method will return `false`.
+El método `add` retornará `true` si el elemento efectivamente fué **añadido** a la caché. Si no, el método retornará `false`.
 
-#### Checking For Existence In Cache
+#### Comprobar la Existencia de un Elemento en Caché
 
 	if (Cache::has('key'))
 	{
 		//
 	}
 
-#### Retrieving An Item From The Cache
+#### Obtener un Elemento de la Caché
 
-	$value = Cache::get('key');
+	$value = Caché::get('key');
 
-#### Retrieving An Item Or Returning A Default Value
+#### Obtener un Elemento o Retornar un Valor por Defecto
 
-	$value = Cache::get('key', 'default');
+	$value = Caché::get('key', 'default');
 
-	$value = Cache::get('key', function() { return 'default'; });
+	$value = Caché::get('key', function() { return 'default'; });
 
-#### Storing An Item In The Cache Permanently
+#### Almacenar un Elemento Permanentemente en la Caché
 
 	Cache::forever('key', 'value');
 
-Sometimes you may wish to retrieve an item from the cache, but also store a default value if the requested item doesn't exist. You may do this using the `Cache::remember` method:
+Algunas veces es posible que desees obtener un elemento de la caché, pero también almacenar un valor por defecto cuando el elemento solicitado no existe. Puedes hacer esto usando el método `Cache::remember`:
 
-	$value = Cache::remember('users', $minutes, function()
+	$value = Caché::remember('users', $minutes, function()
 	{
 		return DB::table('users')->get();
 	});
 
-You may also combine the `remember` and `forever` methods:
+También puedes combinar los métodos `remember` y `forever`:
 
-	$value = Cache::rememberForever('users', function()
+	$value = Caché::rememberForever('users', function()
 	{
 		return DB::table('users')->get();
 	});
 
-Note that all items stored in the cache are serialized, so you are free to store any type of data.
+Nota que todos los elementos almacenados en la chacé están serializados, asi que eres libre de almacenar cualquier tipo de dato.
 
-#### Removing An Item From The Cache
+#### Eliminar un Elemento de la Caché
 
 	Cache::forget('key');
 
 <a name="increments-and-decrements"></a>
-## Increments & Decrements
+## Incrementos & Decrementos
 
-All drivers except `file` and `database` support the `increment` and `decrement` operations:
+Todos los controladores exceptuando `file` y `database` soportan las operaciones `increment` y `decrement`:
 
-#### Incrementing A Value
+#### Incrementar un Valor
 
 	Cache::increment('key');
 
 	Cache::increment('key', $amount);
 
-#### Decrementing A Value
+#### Decrementar un Valor
 
 	Cache::decrement('key');
 
 	Cache::decrement('key', $amount);
 
 <a name="cache-tags"></a>
-## Cache Tags
+## Etiquetas de Caché
 
-> **Note:** Cache tags are not supported when using the `file` or `database` cache drivers. Furthermore, when using multiple tags with caches that are stored "forever", performance will be best with a driver such as `memcached`, which automatically purges stale records.
+> **Nota:** Las etiquetas Caché no son soportadas cuando se usan los controladores de caché `file` o `database`. Es más, al usar varias etiquetas con cachés que están almacenados permanentemente "forever", el desempeño será mejor con un controlador como `memcached`, el cual atomáticamente depura los registros obsoletos.
 
-Cache tags allow you to tag related items in the cache, and then flush all caches tagged with a given name. To access a tagged cache, use the `tags` method:
+Las etiquetas Caché te permiten etiquetar elementos relacionados en la caché, y luego vaciar todas las cachés etiquetadas con un nombre dado. Para acceder  una caché etiquetada, usa el método `tags`:
 
-#### Accessing A Tagged Cache
+#### Acceder una Caché Etiquetada
 
-You may store a tagged cache by passing in an ordered list of tag names as arguments, or as an ordered array of tag names.
+Puedes almacenar una caché etiquetada pasando como argumentos una lista ordenada o un arreglo ordenado de nombres de etiquetas.
 
 	Cache::tags('people', 'authors')->put('John', $john, $minutes);
 
 	Cache::tags(array('people', 'artists'))->put('Anne', $anne, $minutes);
 
-You may use any cache storage method in combination with tags, including `remember`, `forever`, and `rememberForever`. You may also access cached items from the tagged cache, as well as use the other cache methods such as `increment` and `decrement`:
+Puedes usar cualquier método de almacenamiento de caché en combinación con etiquetas, incluyendo `remember`, `forever`, y `rememberForever`. También puedes accesar los elementos cacheados de la caché etiquetada, así como usar otros métodos de caché como lo son `increment` y `decrement`:
 
-#### Accessing Items In A Tagged Cache
+#### Acceder a Elementos en una Caché Etiquetada
 
-To access a tagged cache, pass the same ordered list of tags used to save it.
+Para acceder una caché etiquetada, pasa la misma lista ordenada de etiquetas usada para guardarla.
 
-	$anne = Cache::tags('people', 'artists')->get('Anne');
+	$anne = Caché::tags('people', 'artists')->get('Anne');
 
-	$john = Cache::tags(array('people', 'authors'))->get('John');
+	$john = Caché::tags(array('people', 'authors'))->get('John');
 
-You may flush all items tagged with a name or list of names. For example, this statement would remove all caches tagged with either `people`, `authors`, or both. So, both "Anne" and "John" would be removed from the cache:
 
+Puedes vaciar todos los elementos etiquetados con un nombre o lista de nombres. Por ejemplo, esta sentencia eliminará todas las cachés etiquetadas ya sea con `people`, `authors`, o ambos. Asi que, ambos "Anne" y "John" serán eliminados de la caché:
 	Cache::tags('people', 'authors')->flush();
 
-In contrast, this statement would remove only caches tagged with `authors`, so "John" would be removed, but not "Anne".
+Por el contrario, esta sentencia elimina unicamente las cachés etiquetadas con `authors`, asi que "John" será eliminado, pero "Anne" no.
 
 	Cache::tags('authors')->flush();
 
 <a name="database-cache"></a>
-## Database Cache
+## Caché en Base de Datos
 
-When using the `database` cache driver, you will need to setup a table to contain the cache items. You'll find an example `Schema` declaration for the table below:
+Cuando se está usando el controlador de caché `database`, necesitarás configurar una tabla que contenga los elementos de caché. Debajo encontrarás un ejemplo de declaración `Schema` para la tabla:
 
 	Schema::create('cache', function($table)
 	{
diff --git a/commands.md b/commands.md
index c926409..f3aac44 100644
--- a/commands.md
+++ b/commands.md
@@ -1,139 +1,139 @@
 # Desarrollo con Artisan
 
-- [Introduction](#introduction)
-- [Building A Command](#building-a-command)
-- [Registering Commands](#registering-commands)
-- [Calling Other Commands](#calling-other-commands)
+- [Introdución](#introduction)
+- [Construir un Comando](#building-a-command)
+- [Registrar Comandos](#registering-commands)
+- [Llamar a Otros Comandos](#calling-other-commands)
 
 <a name="introduction"></a>
-## Introduction
+## Introdución
 
-In addition to the commands provided with Artisan, you may also build your own custom commands for working with your application. You may store your custom commands in the `app/commands` directory; however, you are free to choose your own storage location as long as your commands can be autoloaded based on your `composer.json` settings.
+Ademas de los comandos provistos con Artisan, puedes tambien construir tus propios comandos personalizados para trabajar con tu aplicación. Debes almacenar tus comandos personalizados en el directorio `app/commands`; Sin embargo, eres libre de seleccionar tu propia ubicación de almacenamiento siempre que tus comandos puedan ser autocargados basado en las configuraciones de tu `composer.json`.
 
 <a name="building-a-command"></a>
-## Building A Command
+## Construir un Comando
 
-### Generating The Class
+### Generar la Clase
 
-To create a new command, you may use the `command:make` Artisan command, which will generate a command stub to help you get started:
+Para generar un nuevo comando, debes uar el comando de Artisan `command:make`, el cual generará un trozo de código del comando para ayudarte a empezar:
 
-#### Generate A New Command Class
+#### Generar una Nueva Clase de Comando
 
 	php artisan command:make FooCommand
 
-By default, generated commands will be stored in the `app/commands` directory; however, you may specify custom path or namespace:
+Por defecto, los comandos generados serán alamacenados en el direcrorio `app/commands`; No obstante, puedes especificar la ruta o espacio de nombres:
 
 	php artisan command:make FooCommand --path=app/classes --namespace=Classes
 
-When creating the command, the `--command` option may be used to assign the terminal command name:
+Cuando se está creando el comando, la opción `--command` puede ser usada para asignar el nombre del comando en la consola:
 
 	php artisan command:make AssignUsers --command=users:assign
 
-### Writing The Command
+### Escribir el Comando
 
-Once your command is generated, you should fill out the `name` and `description` properties of the class, which will be used when displaying your command on the `list` screen.
+Ua vez tu comando es generado, debes llenar las propiedades `name` y `description` de la clase, la cuales serán usadas cuando se muestre tu comando en la pantalla `list`.
 
-The `fire` method will be called when your command is executed. You may place any command logic in this method.
+El método `fire` se llamará cuando tu comando es ejeutado. Debes poner cualquier logica del comando en este método.
 
-### Arguments & Options
+### Argumentos & Opciones
 
-The `getArguments` and `getOptions` methods are where you may define any arguments or options your command receives. Both of these methods return an array of commands, which are described by a list of array options.
+Los métodos `getArguments` y `getOptions` están donde definas argumentos u opciones que tu comando reciba. Ambos métodos retornan un arreglo de comandos, los cuales son descritos por una lista de opciones de arreglo.
 
-When defining `arguments`, the array definition values represent the following:
+Al definir `argumentos`, la definición de valores del arreglo representa lo siguiente:
 
 	array($name, $mode, $description, $defaultValue)
 
-The argument `mode` may be any of the following: `InputArgument::REQUIRED` or `InputArgument::OPTIONAL`.
+El argumento `mode` puede ser cualquiera de los siguientes: `InputArgument::REQUIRED` or `InputArgument::OPTIONAL`.
 
-When defining `options`, the array definition values represent the following:
+Al definir `opciones`, la definición de valores del arreglo representa lo siguiente:
 
 	array($name, $shortcut, $mode, $description, $defaultValue)
 
-For options, the argument `mode` may be: `InputOption::VALUE_REQUIRED`, `InputOption::VALUE_OPTIONAL`, `InputOption::VALUE_IS_ARRAY`, `InputOption::VALUE_NONE`.
+Para opciones, el argumento `mode` puede ser: `InputOption::VALUE_REQUIRED`, `InputOption::VALUE_OPTIONAL`, `InputOption::VALUE_IS_ARRAY`, `InputOption::VALUE_NONE`.
 
-The `VALUE_IS_ARRAY` mode indicates that the switch may be used multiple times when calling the command:
+El modo `VALUE_IS_ARRAY` indica que la opción puede usarse multiples veces cuando se llame el comando:
 
 	php artisan foo --option=bar --option=baz
 
-The `VALUE_NONE` option indicates that the option is simply used as a "switch":
+La opción `VALUE_NONE` indica que la opción es usada simplemente como un interruptor "switch":
 
 	php artisan foo --option
 
-### Retrieving Input
+### Obtener una Entrada "Input"
 
-While your command is executing, you will obviously need to access the values for the arguments and options accepted by your application. To do so, you may use the `argument` and `option` methods:
+Mientras tu comando se está ejecutando, obviamente necesitaras acceder a los valores para los argumentos y opciones aceptados por tu aplicación. Para hacerlo,puedes usar los métodos `argument` y `option`:
 
-#### Retrieving The Value Of A Command Argument
+#### Obtener el Valor de un Argumento en un Comando
 
 	$value = $this->argument('name');
 
-#### Retrieving All Arguments
+#### Obtener Todos los Argumentos
 
 	$arguments = $this->argument();
 
-#### Retrieving The Value Of A Command Option
+#### Obtener el Valor de una Opción en un Comando
 
 	$value = $this->option('name');
 
-#### Retrieving All Options
+#### Obtener Todas las Opciones
 
 	$options = $this->option();
 
-### Writing Output
+### Escribir una Salida "Output"
 
-To send output to the console, you may use the `info`, `comment`, `question` and `error` methods. Each of these methods will use the appropriate ANSI colors for their purpose.
+Para enviar una salida a la consola, puedes usar los métodos `info`, `comment`, `question` y `error`. Cada uno de estos métodos usa los colores ANSI apropiados para su propósito.
 
-#### Sending Information To The Console
+#### Enviar Información a la Consola
 
 	$this->info('Display this on the screen');
 
-#### Sending An Error Message To The Console
+#### Enviar un Mensaje de Error a la Consola
 
 	$this->error('Something went wrong!');
 
-### Asking Questions
+### Hacer Preguntas
 
-You may also use the `ask` and `confirm` methods to prompt the user for input:
+También puedes usar los métodos `ask` y `confirm` para solicitarle una entrada al usuario:
 
-#### Asking The User For Input
+#### Solicitar una Entrada al Usuario
 
 	$name = $this->ask('What is your name?');
 
-#### Asking The User For Secret Input
+#### Solicitar una Entrada Secreta al Usuario
 
 	$password = $this->secret('What is the password?');
 
-#### Asking The User For Confirmation
+#### Solicitar una Confirmación al Usuario
 
 	if ($this->confirm('Do you wish to continue? [yes|no]'))
 	{
 		//
 	}
 
-You may also specify a default value to the `confirm` method, which should be `true` or `false`:
+También puedes especificar un valor por defecto para el método `confirm`, el cual que debe ser `true` or `false`:
 
 	$this->confirm($question, true);
 
 <a name="registering-commands"></a>
-## Registering Commands
+## Registrar Comandos
 
-Once your command is finished, you need to register it with Artisan so it will be available for use. This is typically done in the `app/start/artisan.php` file. Within this file, you may use the `Artisan::add` method to register the command:
+Una vez tu comando esté finalizado, necesitas registrarlo con Artisan para que esté disponible para su uso. Esto se hace tipicamente en el archivo `app/start/artisan.php`. Dentro de este archivo, puedes usar el método `Artisan::add` para registrar el comando:
 
-#### Registering An Artisan Command
+#### Registrar un Comando de Artisan
 
 	Artisan::add(new CustomCommand);
 
-If your command is registered in the application [IoC container](/page/ioc), you may use the `Artisan::resolve` method to make it available to Artisan:
+Si tu comando está registrado en la aplicación [IoC container](/page/ioc), puedes usar el método `Artisan::resolve` para que esté disponibla en Artisan:
 
-#### Registering A Command That Is In The IoC Container
+#### Registrar un Comando que está en el IoC Container
 
 	Artisan::resolve('binding.name');
 
 <a name="calling-other-commands"></a>
-## Calling Other Commands
+## LLamar a Otros Comandos
 
-Sometimes you may wish to call other commands from your command. You may do so using the `call` method:
+Algunas veces es posbile que desees llamar a otros comandos desde tu comando. Puedes hacerlo usando el método `call`:
 
-#### Calling Another Command
+#### Llamar a Otro Comando
 
 	$this->call('command:name', array('argument' => 'foo', '--option' => 'bar'));