diff --git a/README.md b/README.md
index 8bf05ec904..a7f87b8081 100644
--- a/README.md
+++ b/README.md
@@ -1,13 +1,32 @@
 # vuejs.org
 
-This site is built with [hexo](http://zespia.tw/hexo/). Site content is written in Markdown format located in `source`. Pull requests welcome!
+该站点是通过 [hexo](http://hexo.io/) 搭建起来的。网站内容都是以 Markdown 格式放置在 `source` 目录下的。  
+欢迎认领翻译，并发 pull requests 给我：）  
+为了避免重复翻译，有劳大家在认领之前在 [wiki](https://github.com/Jinjiang/vuejs.org/wiki) 里查阅目前的翻译进度，然后在 [issues](https://github.com/Jinjiang/vuejs.org/issues) 里记录自己认领的页面。
 
-## Developing
+## 如何开始
 
-Start a dev server at `localhost:4000`:
+访问方式：`http://localhost:4000/vuejs.org/`:
 
 ```
-$ npm install -g hexo
+$ [sudo] npm install -g hexo@2.5.7
 $ npm install
 $ hexo server
-```
\ No newline at end of file
+```
+
+## 贡献者名单
+
+(首字母顺序排序)
+
+* [@etanxing](https://github.com/etanxing)
+* [@fengliu222](https://github.com/fengliu222)
+* [@Garfielt](https://github.com/Garfielt)
+* [@getive](https://github.com/getive)
+* [@kunth](https://github.com/kunth)
+* [@luin](https://github.com/luin)
+* [@nkCoding](https://github.com/nkCoding)
+* [@skyline0705](https://github.com/skyline0705)
+* [@SoAanyip](https://github.com/SoAanyip)
+* [@Suixinlei](https://github.com/Suixinlei)
+* [@titancat](http://github.com/titancat)
+* [@XfLoops](https://github.com/XfLoops)
diff --git a/_config.yml b/_config.yml
index cb1d5b0325..21d5b2a6da 100644
--- a/_config.yml
+++ b/_config.yml
@@ -12,8 +12,8 @@ language:
 
 # URL
 ## If your site is put in a subdirectory, set url as 'http://yoursite.com/child' and root as '/child/'
-url: http://vuejs.org
-root: /
+url: http://jinjiang.github.io/vuejs.org
+root: /vuejs.org/
 permalink: :year/:month/:day/:title/
 tag_dir: tags
 archive_dir: archives
@@ -97,4 +97,4 @@ markdown:
 ## Docs: http://zespia.tw/hexo/docs/deployment.html
 deploy:
   type: github
-  repository: git@github.com:vuejs/vuejs.org.git
\ No newline at end of file
+  repository: git@github.com:Jinjiang/vuejs.org.git
\ No newline at end of file
diff --git a/package.json b/package.json
index fa539e6626..2f83ce2d8b 100644
--- a/package.json
+++ b/package.json
@@ -1,10 +1,10 @@
 {
   "name": "hexo",
-  "version": "2.8.3",
+  "version": "2.5.7",
   "private": true,
   "dependencies": {
     "hexo-renderer-ejs": "^0.1.0",
     "hexo-renderer-marked": "^0.1.0",
     "hexo-renderer-stylus": "^0.1.0"
   }
-}
+}
\ No newline at end of file
diff --git a/source/CNAME b/source/CNAME
deleted file mode 100644
index 29f5db92ae..0000000000
--- a/source/CNAME
+++ /dev/null
@@ -1 +0,0 @@
-vuejs.org
\ No newline at end of file
diff --git a/source/api/directives.md b/source/api/directives.md
index dc870c911e..90b2c8213c 100644
--- a/source/api/directives.md
+++ b/source/api/directives.md
@@ -1,37 +1,37 @@
-title: Directives
+title: 指令
 type: api
 order: 6
 ---
 
-## Reactive Directives
-
-> These directives can bind themselves to a property on the Vue instance, or to an expression which is evaluated in the context of the instance. When the value of the underlying property or expression changes, the `update()` function of these directives will be called asynchronously on next tick.
-
+## 响应式指令 
+ 
+> Directive 可以将自己与一个 Vue 实例的属性绑定，也可以与一个运行在实例上下文中的表达式绑定。当底层属性或表达式的值发生改变时，指令的`update()`方法会在下个 tick 异步地调用。
 ### v-text
 
-Updates the element's `textContent`.
-
-Internally, {{ Mustache }} interpolations are also compiled as a `v-text` direcitve on a textNode.
+更新元素的`textContent`
 
+本质上来说，{{ Mustache }} 的插值也被当做文字节点上的`v-text`指令进行编译。
 ### v-html
 
-Updates the element's `innerHTML`.
+更新元素的`innerHTML`
 
-<p class="tip">Using `v-html` with user-supplied data can be dangerous. It is suggested that you only use `v-html` when you are absolutely sure about the security of the data source, or pipe it through a custom filter that sanitizes untrusted HTML.</p>
+<p class="tip">
+  在用户产生的数据中使用`v-html`比较危险。使用`v-html`时应确保数据的安全性，或通过自定义过滤器将不被信任的 HTML 内容进行处理。
+</p>
 
 ### v-show
 
-- This directive can trigger transitions.
+- 本指令可以触发动画效果。
 
-Set the element's display to `none` or its original value, depending on the truthy-ness of the binding's value.
+根据绑定的真实值将元素的 display 属性设置为`none`或它的原始值。
 
 ### v-class
 
-- This directive accepts an optional argument.
-
-If no argument is provided, it will add the binding's value to the element's classList, and update the class as the value changes.
+- 本元素接受配置参数
 
-If a directive argument is provided, the argument will be the class to be toggled depending on the binding value's truthy-ness. Combined with multiple clauses this can be pretty useful:
+如果没有提供参数名，将会直接将绑定值加入到元素的 classList 中，当绑定值改变时更新元素的 class.
+ 
+如果提供了参数名，则会根据绑定值的变化触发元素 class 的改变。多条合并使用会很方便。
 
 ``` html
 <span v-class="
@@ -43,32 +43,35 @@ If a directive argument is provided, the argument will be the class to be toggle
 
 ### v-attr
 
-- This directive requires an argument.
+- 本指令需要一个参数
 
-Updates the element's given attribute (indicated by the argument).
-
-**Example:**
+更新元素的指定属性（更新的属性由参数指定）
+**例子:**
 
 ``` html
 <canvas v-attr="width:w, height:h"></canvas>
 ```
 
-Internally, &#123;&#123; Mustache &#125;&#125; interpolations inside attributes are compiled into computed `v-attr` directives.
 
-<p class="tip">You should use `v-attr` instead of mustache binding when setting the `src` attribute on `<img>` elements. Your templates are parsed by the browser before being compiled by Vue.js, so the mustache binding will cause a 404 when the browser tries to fetch it as the image's URL.</p>
+本质上，普通属性中的 &#123;&#123; Mustache &#125;&#125; 插值会被编译到`v-attr`指令当中。
+ 
+<p class="tip">
+  在为`<img>`元素设置`src`属性时，应该使用`v-attr`绑定而不是 mustache 模板绑定。浏览器会先于 Vue.js 对你的模板进行解析。所以当浏览器试图获取图片 URL 时，使用 &#123;&#123;mustache&#125;&#125; 模板绑定的数据会导致404错误。
+</p>
 
 ### v-style
 
-- This directive accepts an optional argument.
 
-Apply inline CSS styles to the element.
+- 本指令接受一个配置参数
+
+将CSS属性以内联的形式应用到元素上。
 
-When there is no argument, the bound value can either be a String or an Object.
+如果没有参数名，绑定值也可以使一个字符串或者一个对象。
 
-- If it's a String, it will be set as the element's `style.cssText`.
-- If it's an Object, each key/value pair will be set on the element's `style` object.
+- 如果参数值为字符串，则会将该元素的`style.cssText`属性设置为参数的值。
+- 如果参数值为对象，则每一对 key/value 都会被设置到元素的`style`对象上。
 
-**Example:**
+**例子:**
 
 ``` html
 <div v-style="myStyles"></div>
@@ -86,9 +89,9 @@ When there is no argument, the bound value can either be a String or an Object.
 }
 ```
 
-When there is an argument, it will be used as the CSS property to apply. Combined with multiple clauses you can set multiple properties together:
+如果有参数名的话，参数名会被当作 CSS 属性名使用。可以通过合并多个参数的方式同时设置多个属性。
 
-**Example:**
+**例子:**
 
 ``` html
 <div v-style="
@@ -98,36 +101,41 @@ When there is an argument, it will be used as the CSS property to apply. Combine
 "></div>
 ```
 
-`v-style` is also smart to detect any required browser vendor prefixes, so you can just use the un-prefixed version:
+`v-style`也可以智能的查找 CSS 属性是否需要浏览器前缀，所以你可以放心的使用无前缀版本的 CSS 属性。
 
 ``` html
 <!-- will use -webkit-transform if needed, for example -->
 <div v-style="transform: 'scale(' + scale + ')'"></div>
 ```
 
-<p class="tip">It is recommended to use `v-style` instead of mustache bindings inside `style` attribute because Internet Explorer, regardless of version, will remove invalid inline styles when parsing the HTML.</p>
+<p class=“tip”>
+	因为 IE 浏览器的原因，这里推荐使用`v-style`指令来代替直接在 style 属性中使用 &#123;&#123;mustache&#125;&#125; 插值，这是因为在 IE 的所有版本中，都会在解析 HTML 时将非法的内联样式删除掉。
+</p>
 
 ### v-on
 
-- This directive requires an argument.
-- This directive requires the value to be a Function or a statement.
+- 本指令需要一个参数名。
+- 本指令所需的值应该是一个函数或者声明。
+
+
+为元素添加一个事件监听器。事件的类型由参数名来表示。这也是唯一可以和`key`过滤器一起使用的指令。详细请见[Listening for Events](../guide/events.html)。
 
-Attaches an event listener to the element. The event type is denoted by the argument. It is also the only directive that can be used with the `key` filter. For more details see [Listening for Events](/guide/events.html).
 
 ### v-model
 
-- This directive can only be used on `<input>`, `<select>` or `<textarea>` elements.
-- Directive params: `lazy`, `number`, `options`
+- 本指令只能用在`<input>`, `<select>` 或 `<textarea>` 元素上。
+- 指令的参数有：`lazy`, `number`, `options`
+
 
-Create a two-way binding on a form input element. Data is synced on every `input` event by default. For detailed examples see [Handling Forms](/guide/forms.html).
+在表单输入元素上创建双向绑定。默认情况下，每一个`input`事件都会让数据同步。详情请见[Handling Forms](../guide/forms.html).
 
 ### v-if
 
-- This directive can trigger transitions.
+- 本指令可以触发动画效果。
 
-Conditionally insert / remove the element based on the truthy-ness of the binding value. If the element is a `<template>` element, its content will be extracted as the conditional block.
+以绑定值为基础条件插入或删除元素。如果元素为`<template>`元素，则它的内容将会被提取出来作为条件块。
 
-**Example:**
+**例子:**
 
 ``` html
 <template v-if="test">
@@ -136,7 +144,7 @@ Conditionally insert / remove the element based on the truthy-ness of the bindin
 </template>
 ```
 
-Will render:
+渲染结果:
 
 ``` html
 <!--v-if-start-->
@@ -147,17 +155,17 @@ Will render:
 
 ### v-repeat
 
-- This directive creates child Vue instances.
-- This directive requires the value to be an Array, Object or Number.
-- This directive can trigger transitions.
-- This directive accepts an optional argument.
-- Directive params: `trackby`
+- 本指令会创建子 Vue 实例。
+- 本指令的值应为一个数组、对象或数字。
+- 本指令可以触发动画效果。
+- 本指令接受一个配置参数。
+- 指令的参数：`trackby`
 
-Create a child ViewModel for every item in the binding Array or Object. If the value is a whole Number then that many child ViewModels are created. These child ViewModels will be automatically created / destroyed when mutating methods, e.g. `push()`, are called on the Array or Object, or the number is increased or decreased.
 
-When no argument is provided, the child ViewModel will directly use the assigned element in the Array as its `$data`. If the value is not an object, a wrapper data object will be created and the value will be set on that object using the alias key `$value`.
+为每一个绑定的数组或对象中的项创建一个子 ViewModel 。如果值是整数，则创建多个子 ViewModel 。当数组或对象的变质方法（ mutating method ）被调用，如`push()`方法，或者当数字值有增加或减少时，子 ViewModel 都会自动被创建或删除。
 
-**Example:**
+如果没有提供参数名，子 ViewModel 会直接使用指定的数组作为`$data`。如果值不是一个对象，则会创建一个数据包装对象，而值会被设置在别名为`$value`的 key 上。
+**例子:**
 
 ``` html
 <ul>
@@ -167,8 +175,7 @@ When no argument is provided, the child ViewModel will directly use the assigned
 </ul>
 ```
 
-If an argument is provided, a wrapper data object will always be created, using the argument string as the alias key. This allows for more explicit property access in templates:
-
+如果提供了参数名，则通常会创建一个数据包装对象，用参数名字符串作为 key. 这使得模板中的属性访问更加的明确。
 ``` html
 <ul>
   <li v-repeat="user : users">
@@ -177,18 +184,18 @@ If an argument is provided, a wrapper data object will always be created, using
 </ul>
 ```
 
-For detailed examples, see [Displaying a List](/guide/list.html).
+查看详细的例子，点这里 [Displaying a List](../guide/list.html).
 
 ### v-with
 
-- This directive can only be used with `v-component`.
-- This directive accepts only keypaths, no expressions.
+- 本指令只能与`v-component`一起使用。
+- 本指令只接受 keypaths, 而不是表达式。
 
-Allows a child ViewModel to inherit data from the parents. You can either pass in an Object which will be used as the `data` option, or bind individual parent properties to the child with different keys. This directive must be used in combination with `v-component`.
+允许一个子 ViewModel 从父 ViewModel 继承数据。你可以传入一个对象，这个对象会被作为`data`项，或者也可以将单个的父级属性通过不同的 key 绑定到子级上。本指令必须与`v-component`组合使用。
 
-The data inheritance is one-way: when parent property changes, the child will be notified of the change and update accordingly; however if the child sets the property to something else, it will not affect the parent, and the modified property will be overwritten the next time parent property changes.
+数据继承是单向的——当父级属性改变时，会去更新和改变子元素。然而当子级属性被设置为其他值时，并不会影响到父级数据，并且修改后的属性将会在父级属性的下一次修改时被覆盖掉。
 
-Example inheriting an object:
+继承自一个对象的例子
 
 ``` js
 // parent data looks like this
@@ -207,8 +214,7 @@ Example inheriting an object:
 </my-component>
 ```
 
-Example inheriting individual properties (using the same data):
-
+继承自单个属性（使用相同数据）的例子。
 ``` 
 <my-component v-with="myName: user.name, myEmail: user.email">
   <!-- you can access properties with the new keys -->
@@ -218,71 +224,71 @@ Example inheriting individual properties (using the same data):
 
 ### v-events
 
-- This directive can only be used with `v-component`.
-- This directive accepts only keypaths, no expressions.
+- 本指令只能与`v-component`一起使用
+- 本指令只接受 keypaths, 而不是表达式。
 
-Allows a parent instance to listen to events on a child instance. The difference from `v-on` is that `v-events` listens to Vue's component system events created via `vm.$emit()` rather than DOM events. This directive allows more decoupled parent-child communication without having to hard-code event listeners into the parent component. Note that it can only be used together with `v-component`, i.e. on the root element of a child component.
+允许一个父 Vue 实例监听一个子 Vue 实例上的事件。不同于`v-on`的是，`v-events`监听的是通过`vm.$emit()`创建的 Vue 组件系统事件，而不是 DOM 事件。本指令让父子通信进一步解耦，不需要在父组件中“硬编写”事件监听器。需要注意的是，本指令只能与`v-component`同时使用，即只能用在子组件的根元素上。
 
-**Example:**
+**例子:**
 
 ``` html
 <!-- inside parent template -->
 <div v-component="child" v-events="change: onChildChange"></div>
 ```
 
-When the child component calls `this.$emit('change', ...)`, the parent's `onChildChange` method will be invoked with additional arguments passed to `$emit()`.
 
-## Literal Directives
+当子组件调用 `this.$emit('change', …)`时调用父元素的`onChildChange`方法，并将传给`$emit()`方法的额外参数会传入其中。
+
+## 字面指令
 
-> Literal directives treat their attribute value as a plain string; they do not attempt to bind themselves to anything. All they do is executing the `bind()` function with the string value once. Literal directives accept mustache expressions inside their value, but these expressions will be evaluated only once on first compile and do not react to data changes.
+> 字面指令将它的属性值当成纯字符串来处理。字面指令不把自己绑定到任何东西上。它们只将字符串值传入到`bind()`函数中执行一次。字面指令的值接受 &#123;&#123;mustache&#125;&#125; 表达式，但这个表达式只能随着首次编译执行一次，不会随着数据变化而变化。
 
 ### v-component
 
-- Directive params: `keep-alive`, `wait-for`, `transition-mode`
+- 指令参数：`keep-alive`,`wait-for`,`transition-mode`
 
-Compile this element as a child ViewModel with a registered component constructor. This can be used with `v-with` to inehrit data from the parent. For more details see [Component System](/guide/components.html).
+使用一个已经注册过的组件构造器编译这个元素作为子 ViewModel. 这个指令可以使用`v-with`从父级继承数据。详细请看[Component System](../guide/components.html).
 
 ### v-ref
 
-Register a reference to a child component on its parent for easier access. Only respected when used in combination with `v-component` or `v-repeat`. The component instance will be accessible on its parent's `$` object. For an example, see [child reference](/guide/components.html#Child_Reference).
+为了让父级更加方便的访问子级，可以在父级注册一个子组件的引用。本指令只有与`v-component`和`v-repeat`一起才能使用。在它父级的`$`对象上可以访问组件的实例。例子在[child reference](../guide/components.html#子组件引用).
 
-When used with `v-repeat`, the value will be an Array containing all the child Vue instances corresponding to the Array they are bound to.
+当该指令与`v-repeat`一起使用时，`v-ref`的值将会是一个包含了所有子 Vue 实例的数组，这个数组与子 Vue 实例绑定的数组是相对应的。
 
 ### v-el
 
-Register a reference to a DOM element on its owner Vue instance for easier access. e.g. `<div v-el="hi">` will be accessible as `vm.$$.hi`.
+在一个DOM元素上注册一个更容易被自身 Vue 实例访问的引用。如， `<div v-el="hi">`可以使用`vm.$$.hi`访问到。
 
 ### v-partial
 
-Replace the element's innerHTML with a registered partial. Partials can be registered with `Vue.partial()` or passed inside the `partials` option.
+使用一个注册过的 partial 替换元素的 innerHTML 值。可以使用`Vue.partial()`或传入`partials`参数的方式来注册一个 Partials 。 
 
-Using the mustache tag inside `v-partial` makes it reactive:
+在`v-partial`中使用 {&#123; mustache&#125;} 标签可以让元素响应数据的改变。
 
 ``` html
 <!-- content will change based on vm.partialId -->
 <div v-partial="{&#123;partialId&#125;}"></div>
 ```
 
-You can also use this syntax (which doesn't support reactivity):
-
+你也可以使用这样的语法（不支持相应数据改变）。
 ``` html
 <div>&#123;&#123;> my-partial&#125;&#125;</div>
 ```
 
 ### v-transition
 
-Notify Vue.js to apply transitions to this element. The transition classes are applied when certain transition-triggering directives modify the element, or when the Vue instance's DOM manipulation methods are called.
+通知 Vue.js 为元素应用动画效果。动画 class 将会在某些能触发过渡的指令修改了元素时或当 Vue 实例中操作 DOM 的方法被调用时引用到元素上。
+详情请见[the guide on transitions](../guide/transitions.html).
 
-For details, see [the guide on transitions](/guide/transitions.html).
 
-## Empty Directives
+## 空指令
 
-> Empty directives do not require and will ignore their attribute value.
+> 空指令不需要参数，并且会忽略它的属性值。
 
 ### v-pre
 
-Skip compilation for this element and all its children. Skipping large numbers of nodes with no directives on them can speed up compilation.
+跳过编译此元素和此元素所有的子元素。跳过大量没有指令的节点可以加快编译速度。
 
 ### v-cloak
 
-This property remains on the element until the associated ViewModel finishes compilation. Combined with CSS rules such as `[v-cloak] { display: none }`, this directive can be used to hide un-compiled mustache bindings until the ViewModel is ready.
+直到关联的 ViewModel 结束编译之前本属性都会留在元素上。与 `[v-cloak] { display: none }` 类似的样式结合，这个指令可以用来在 ViewModel 准备好之前隐藏没有被编译的 &#123;&#123; Mustache &#125;&#125; 模板。
\ No newline at end of file
diff --git a/source/api/filters.md b/source/api/filters.md
index 8edecb70f5..081555af9e 100644
--- a/source/api/filters.md
+++ b/source/api/filters.md
@@ -1,4 +1,4 @@
-title: Filters
+title: 过滤器
 type: api
 order: 7
 ---
@@ -17,19 +17,19 @@ order: 7
 
 ### currency
 
-- this filter takes one optional argument
+- 这个 filter 接受一个可选参数
 
 *12345 => $12,345.00*
 
-You can pass an optional argument which will be used as the currency symbol (default is $).
+你可以传递一个可选参数来表示货币符号
 
 ### pluralize
 
-- this filter takes at least one argument
+- 这个 filter 接受至少一个参数
 
-Pluralizes the argument based on the filtered value. When there is exactly one arg, plural forms simply add an "s" at the end. When there are more than one argument, the arguments will be used as array of strings corresponding to the single, double, triple ... forms of the word to be pluralized. When the number to be pluralized exceeds the length of the args, it will use the last entry in the array.
+根据要处理的值来将参数转换为复数。当只有一个参数时，其复数形式就是在参数末尾加上“s”。当参数多于一个时，所有的参数将会以字符串数组的形式对应要被转换为复数的单词的“一倍”、“两倍”、“三倍”......形式。当复数的数量超过参数个数时，会使用最后一个参数。
 
-**Example:**
+**例子：**
 
 ``` html
 {&#123;count&#125;} {&#123;count | pluralize item&#125;}
@@ -42,7 +42,7 @@ Pluralizes the argument based on the filtered value. When there is exactly one a
 {&#123;date&#125;}{&#123;date | pluralize st nd rd th&#125;}
 ```
 
-Will result in:
+结果为:
 
 *1 => '1st'*  
 *2 => '2nd'*
@@ -52,9 +52,9 @@ Will result in:
 
 ### json
 
-- this filter takes one optional argument
+- 这个 filter 接受一个可选参数
 
-JSON.stringify() incoming value rather than outputting the string representation (i.e. `[object Object]`). It also takes one optional argument which is the indent level (defaults to 2):
+使用 `JSON.stringify()` 来处理值而不是直接将其字符串化（如 `[object Object]`)。这个 filter 接受一个可选参数来指定缩进级别（默认是 2）。
 
 ``` html
 <pre>{&#123;$data | json 4&#125;}</pre>
@@ -62,10 +62,10 @@ JSON.stringify() incoming value rather than outputting the string representation
 
 ### key
 
-- this filter only works in `v-on`
-- this filter takes exactly one argument
+- 这个 filter 只工作于 `v-on`
+- 这个 filter 接收一个参数
 
-Wrap the handler so it only gets called when the keyCode matches the argument. You can also use string aliases for a few commonly-used keys:
+包裹 handler 使得其仅在 keyCode 是指定的参数时才被调用。你也可以使用几个常用键值的别名：
 
 - enter
 - tab
@@ -76,22 +76,22 @@ Wrap the handler so it only gets called when the keyCode matches the argument. Y
 - left
 - right
 
-**Example:**
+**例子：**
 
 ``` html
 <input v-on="keyup:doSomething | key enter">
 ```
 
-`doSomething` will only be called when the Enter key is pressed.
+只有按回车键（enter）时才会调用 `doSomething` 。
 
 ### filterBy
 
-**Syntax:** `filterBy searchKey [in dataKey]`.
+**语法：** `filterBy searchKey [in dataKey]`.
 
-- this filter only works in `v-repeat`
-- this is a computed filter
+- 这个 filter 只工作于 `v-repeat`
+- 这是一个 computed filter
 
-Make `v-repeat` only display a filtered version of the source Array. The `searchKey` argument is a property key on the context ViewModel. The value of that property will be used as the string to search for:
+使得 `v-repeat` 只显示数组过滤后的结果。`searchKey` 参数是当前 ViewModel 的一个属性名。这个属性的值会被用作查找的目标：
 
 ``` html
 <input v-model="searchText">
@@ -100,9 +100,9 @@ Make `v-repeat` only display a filtered version of the source Array. The `search
 </ul>
 ```
 
-When the filter is applied, it will filter the `users` Array by recursively searching for the current value of `searchText` on each item in the Array. For example, if an item is `{ name: 'Jack', phone: '555-123-4567' }` and `searchText` has value `'555'`, the item will be considered a match.
+当使用这个 filter 时，将递归遍历 `users` 数组的每一个元素来寻找 `searchText` 的当前值从而过滤该数组。举例来说，如果一个条目是 `{ name: 'Jack', phone: '555-123-4567' }`，而 `searchText` 的值是 `'555'`，这个条目就被认为是符合条件。
 
-Optionally, you can narrow down which specific property to search in with the optional `in dataKey` argument:
+可选地，你可以通过 `in dataKey` 参数来指定具体要查找哪个属性：
 
 ``` html
 <input v-model="searchText">
@@ -111,9 +111,9 @@ Optionally, you can narrow down which specific property to search in with the op
 </ul>
 ```
 
-Now the item will only match if the value of `searchText` is found in its `name` property. So `searchText` with value `'555'` will no longer match this item, but `'Jack'` will.
+现在只有当 `name` 属性包含 `searchText` 时这个条目才符合条件。所以当 `searchText` 的值是 `'555'` 时这个条目将不符合条件，而当值是 `'Jack'` 时即符合。
 
-Finally, you can use quotes to indicate literal arguments:
+最后，你可以使用引号来表示字面量参数：
 
 ``` html
 <ul>
@@ -123,12 +123,12 @@ Finally, you can use quotes to indicate literal arguments:
 
 ### orderBy
 
-**Syntax:** `orderBy sortKey [reverseKey]`.
+**语法：** `orderBy sortKey [reverseKey]`.
 
-- this filter only works in `v-repeat`
-- this is a computed filter
+- 这个 filter 只工作于 `v-repeat`
+- 这是一个 computed filter
 
-Sort `v-repeat`'s displayed result. The `sortKey` argument is a property key on the context ViewModel. The value of that property will be used as the key to sort the Array items with. The optional `reverseKey` argument is also a property key on the context ViewModel, but the value's truthiness will determine whether the result should be reversed.
+将 `v-repeat` 的结果排序。`sortKey`参数是当前 ViewModel 的一个属性名。这个属性的值表示用来排序的键名。可选的 `reverseKey` 参数也是当前 ViewModel 的一个属性名，如果这个属性值为真则数组会被倒序排列。
 
 ``` html
 <ul>
@@ -146,7 +146,7 @@ new Vue({
 })
 ```
 
-You can also use quotes for literal sort key. To indicate a literal reverse, use `-1`:
+你可以使用引号来表示字面量的排序键名。使用 `-1` 来表示字面量的 `reverse` 参数。
 
 ``` html
 <ul>
diff --git a/source/api/global-api.md b/source/api/global-api.md
index 5e55f23d1d..94da70e967 100644
--- a/source/api/global-api.md
+++ b/source/api/global-api.md
@@ -1,64 +1,63 @@
-title: Global API
+title: 全局 API
 type: api
 order: 5
 ---
 
 ### Vue.config
 
-`Vue.config` is an object containing Vue's global settings. Here are the list of all the avaiable settings with their default values:
+`Vue.config` 是包含 Vue 全局设置的对象。下面列出了所有可设置变量及其默认值：
 
 ``` js
 {
-  // print stack trace for warnings?
+  // 打印 warnings 的堆栈跟踪？
   debug: true,
-  // attribute prefix for directives
+  // 指令的属性前缀
   prefix: 'v-',
-  // interpolation delimiters
-  // for HTML interpolations, add
-  // 1 extra outer-most character.
+  // 插入分隔符
+  // 对于插入HTML，添加一个额外的最外层字符
   delimiters: ['{&#123;', '&#125;}'],
-  // suppress warnings?
+  // 抑制 warnings？
   silent: false,
-  // interpolate mustache bindings?
+  // 插入 mustache 绑定?
   interpolate: true,
-  // use async updates (for directives & watchers)?
+  // (对 directives 和 watchers)使用异步更新？
   async: true,
-  // allow altering observed Array's prototype chain?
+  // 允许改变所观察的Array的原型链？
   proto: true
 }
 ```
 
-You can modify them directly, for example:
+你可以直接对其修改，例如：
 
 ``` js
-Vue.config.debug = true // turn on debugging mode
+Vue.config.debug = true // 开启调试模式
 ```
 
-**Debug Mode**
+**调试模式**
 
-When `Vue.config.debug` is set to true, Vue will automatically use synchronous mode and throw a `debugger` statement when there is a warning. This enables the user to inspect the full stack trace in browser dev tools.
+当 `Vue.config.debug` 设置为 true 时，Vue 会自动启动同步模式，并在有警告时抛出一个 `debugger ` 语句。这使得用户能够在浏览器开发工具中检查完整的堆栈跟踪(full stack trace)
 
-<p class="tip">debug mode is not available in the minified production builds.</p>
+<p class="tip">调试模式在压缩的生产环境(minified production builds)下是不可用的</p>
 
-**Changing Delimiters**
+**改变分隔符(Delimiters)**
 
-When the delimiters are set for text interpolation, the delimiters for HTML interpolation will be generated by adding one outer-most symbol on both sides:
+当分隔符(delimiters)是设置为插入文本时，那么设置为插入HTML的分隔符可以通过在两边的最外层加上符号来生成。
 
 ``` js
 Vue.config.delimiters = ['(%', '%)']
-// tags now are (% %) for text
-// and ((% %)) for HTML
+// (% %)是文本的标签
+// 则((% %))是HTML的标签
 ```
 
 ### Vue.extend( options )
 
 - **options** `Object`
 
-Create a "subclass" of the base Vue constructor. All [instantiation options](/api/options.html) can be used here. The special cases to note here are `el` and `data`, which must be functions in this case.
+创建一个基类 Vue 构造函数的"子类"。所有的[实例化选项](../api/options.html)都可以在此用到。其中需要特殊提及的是 `el` 和 `data`，在这个类里他们必须作为函数使用。
 
-Internally, `Vue.extend()` is called on all component options before instantiating the components. For more details regarding components, see [Component System](/guide/components.html).
+在所有组件(components)被初始化之前，`Vue.extend()`被组件选项隐式地调用。关于组件更多的细节，可详见[组件系统](../guide/components.html)。
 
-**Example**
+**例子**
 
 ``` js
 var Profile = Vue.extend({
@@ -75,9 +74,10 @@ var profile = new Profile({
   }  
 })
 profile.$appendTo('body')
+
 ```
 
-Will result in:
+将输出：
 
 ``` html
 <p>Walter White aka Heisenberg</p>
@@ -86,40 +86,39 @@ Will result in:
 ### Vue.directive( id, [definition] )
 
 - **id** `String`
-- **definition** `Function` or `Object` *optional*
+- **definition** `Function` or `Object` *可选的*
 
-Register or retrieve a global custom directive. For more details see [Writing Custom Directives](/guide/custom-directive.html).
+注册或取得一个全局自定义的指令。详情见[编写自定义指令](../guide/custom-directive.html)。
 
 ### Vue.filter( id, [definition] )
 
 - **id** `String`
-- **definition** `Function` *optional*
+- **definition** `Function` *可选的*
 
-Register or retrieve a global custom filter. For more details see [Writing Custom Filters](/guide/custom-filter.html).
+注册或取得一个全局自定义的过滤器。详情见[编写自定义过滤器](../guide/custom-filter.html)。
 
 ### Vue.component( id, [definition] )
 
 - **id** `String`
-- **definition** `Function Constructor` or `Object` *optional*
+- **definition** `Function Constructor` or `Object` *可选的*
 
-Register or retrieve a global component. For more details see [Component System](/guide/components.html).
+注册或取得一个全局自定义的组件。详情见[组件系统](../guide/components.html)。
 
 ### Vue.transition( id, [definition] )
 
 - **id** `String`
-- **definition** `Object` *optional*
+- **definition** `Object` *可选的*
 
-Register or retrieve a global JavaScript transition effect definition. For more details see the guide for [JavaScript Transitions](/guide/transitions.html#JavaScript_Functions).
+注册或取得一个全局 JavaScript 转换效应(transition effect)定义。详见[JavaScript转换](../guide/transitions.html#JavaScript_Functions)的指导。
 
 ### Vue.partial( id, [definition] )
 
 - **id** `String`
-- **definition** `String | Node` *optional*
-
-Register or retrieve a global partial. The definition can be a template string, a querySelector that starts with `#`, a DOM element (whose innerHTML will be used as the template string), or a DocumentFragment.
+- **definition** `String | Node` *可选的*
 
-**Example**
+注册或取得一个全局的partial。定义可以是一个string模板，一个以`#`开头的querySelector，一个DOM元素(其内嵌HTML作为string模板使用)或者一个DocumentFragment
 
+**例子**
 HTML
 
 ``` html
@@ -141,7 +140,7 @@ new Vue({
 })
 ```
 
-Will result in:
+将输出:
 
 ``` html
 <div id="demo">
@@ -153,15 +152,15 @@ Will result in:
 
 - **callback** `Function`
 
-Vue.js batches view updates and executes them all asynchronously. It uses `requestAnimationFrame` if available and falls back to `setTimeout(fn, 0)`. This method calls the callback after the next view update, which can be useful when you want to wait until the view has been updated.
+Vue.js 批量处理视图更新并对其异步执行。如果可用的话它会使用 `requestAnimationFrame` 并返回到 `setTimeout(fn, 0)`。这个方法在下一个视图更新后调用回调，当你想一直等待到该视图被更新了，用这个方法会很好。
 
 ### Vue.use( plugin, [args...] )
 
 - **plugin** `Object` or `Function`
-- **args...** *optional*
+- **args...** *可选的*
 
-Mount a Vue.js plugin. If the plugin is an Object, it must have an `install` method. If it is a function itself, it will be treated as the install method. The install method will be called with Vue as the argument. For more details, see [Plugins](/guide/extending.html#Extend_with_Plugins).
+挂载一个 Vue.js 的插件。如果该插件是一个对象，它必须有一个 `install` 的方法。如果它本身就是一个方法，它必须被作为安装方法来对待。安装方法将会被 Vue 作为一个参数来调用。更多详情请阅[插件](../guide/extending.html#使用插件进行扩展)。
 
 ### Vue.util
 
-Exposes the internal `util` module, which contains a number of utility methods. This is intended for advanced plugin/directive authoring, so you will need to look at the source code to see what's available.
\ No newline at end of file
+公开内部的 `util` 模块。该模块包含一些列实用方法(utility methods)。这是被为用来编写高级插件/指令，因此你必须查看源码来确定哪些是可操作的。
diff --git a/source/api/index.md b/source/api/index.md
index f908cbd499..ccd26356e1 100644
--- a/source/api/index.md
+++ b/source/api/index.md
@@ -1,24 +1,24 @@
-title: "The Vue Constructor"
+title: "Vue 构造函数"
 type: api
 order: 1
 ---
 
-The `Vue` constructor is the core of Vue.js. It is a constructor function that allows you to create Vue instances. Creating a Vue instance is straightforward:
+`Vue`的构造函数是Vue.js的核心。它允许你创建Vue实例。创建一个Vue实例非常简单明了：
 
 ``` js
 var vm = new Vue({ /* options */ })
 ```
 
-When you instantiate a Vue instance, you need to pass in an option object which can include information about the DOM element, data object, mixin methods, lifecycle callbacks and more. See the full list of [Instantiation Options](/api/options.html).
+当你初始化一个Vue实例，你需要传递一个包括DOM对象，data对象，mixin方法，生命周期回调函数等内容的option对象。完整列表见[初始化参数](../api/options.html)。
 
-Each Vue instance is essentially a ViewModel (hence the variable name `vm` you will see throughout the docs). It has an associated DOM element `$el`, which is roughly the V in MVVM. It also has an associated JavaScript object `$data`, which corresponds to the M in MVVM. Changing the M results in updates in the V. For two-way bindings, user inputs triggered in the V results in changes in the M. For more details check out [Instance Properties](/api/instance-properties.html).
+每个Vue实例本质上就是一个ViewModel (因此在本文档中你会看到好多变量名叫`vm`)。每个实例都有一个DOM对象属性叫`$el`，它大致相当于MVVM中的V。每个实例也有一个JavaScript对象属性叫`$data`，相对应的就是MVVM中的M。改变M会触发V的更新。对于双向绑定，用户对V的介入会触发M中的变化。详细请看[实例属性](../api/instance-properties.html)。
 
-If you provided the `el` option at instantiation, the Vue instance will immediately enter the compilation phase. Otherwise, it will wait until `vm.$mount()` is called before it starts compilation. During the compilation phase, Vue walks through the DOM and collects the directives it runs into, and "links" the data and the DOM with these directives. Once linked, these DOM nodes are now said to be managed by the Vue instance. A DOM node can only be managed by one Vue instance, and should not be compiled more than once.
+初始化的时候，如果你提供了`el`，那么这个实例就会直接进入编译阶段(compilation phase)。否则只有执行了`vm.$mount()`才会开始编译。在编译过程，Vue会走遍DOM树来收集遇到的指令(directives)，然后通过这些指令建立数据和DOM的关系。一旦完成，就可以说现在这些DOM节点是被Vue实例来管理了。一个DOM节点只能被一个Vue实例管理，而且不会被2次编译。
 
-Vue instances proxy access to their `$data` objects, so if you have `vm.$data.msg` you can also access it as `vm.msg`. This might look a bit magical, but is totally optional. You can stick to `vm.$data.msg` for more explicit data access. However it is still important to notice the difference between `vm` and `vm.$data`, since the former cannot be observed by other Vue instances as data.
+Vue实例通过代理方法访问他们的`$data`对象，如果你有个变量叫msg，你可以通过`vm.$data.msg`访问也可以通过`vm.msg`来访问。看起来有点神奇，但这完全是可选的。你完全可以就用`vm.$data.msg` 这种方式来访问。但不管怎样，我们仍需要注意到`vm`和`vm.$data`的区别，因为前者是不能作为数据对象被别的Vue实例监视的。
 
-It's also worth noting that data objects do not necessarily belong to a single Vue instance - multiple ViewModels can observe the same piece of data, whether directly as `$data` or nested under it. This is useful when multiple components need to react to a shared global state object.
+还有一点值得注意的是数据对象(data objects)并不只属于一个Vue实例，多个ViewModel可以监视同一个数据对象，不论是`$data`本身还是它的属性。当多个组件需要共享一个全局状态数据对象的时候，这个特性就非常有用。
 
-Each Vue instance also has a number of [Instance Methods](/api/instance-methods.html) which cover data observation, event communication and DOM manipulation.
+每个Vue实例也有不少[实例方法](../api/instance-methods.html)，包括数据监视，事件通讯和DOM操作。
 
-Finally, the `Vue` constructor itself also exposes the [Global API](/api/global-api.html), which allow you to extend the `Vue` class, configure global settings and register global custom assets such as components, directives, filters and more.
+最后，`Vue`的构造函数本身还有几个[全局API](../api/global-api.html)，能够让你扩展`Vue`的类，配置全局属性以及注册全局自定义组件，像components，directives，filters等等。
\ No newline at end of file
diff --git a/source/api/instance-methods.md b/source/api/instance-methods.md
index f8474dced4..01c02b139d 100644
--- a/source/api/instance-methods.md
+++ b/source/api/instance-methods.md
@@ -1,11 +1,11 @@
-title: Instance Methods
+title: 实例方法
 type: api
 order: 4
 ---
 
 ## Data
 
-> You can observe data changes on a Vue instance. Note that all watch callbacks fire asynchronously. In addition, value changes are batched within an event loop. This means when a value changes multiple times within a single event loop, the callback will be fired only once with the latest value.
+> 你可以在Vue运行实例中监视数据的变化。你会注意到所有的watch回调都是异步发生的。而且，结果是在事件循环中被分批处理的。这就意味着一个结果假设在一次事件循环中改变多次，回调只会发生一次并直接变到最后的结果。
 
 ### vm.$watch( expression, callback, [deep, immediate] )
 
@@ -14,7 +14,7 @@ order: 4
 - **deep** `Boolean` *optional*
 - **immdediate** `Boolean` *optional*
 
-Watch an expression on the Vue instance for changes. The expression can be a single keypath or actual expressions:
+监听在Vue实例中改变的一个表达式。表达式可以是一个单独的路径或者是一个实际的表达式：
 
 ``` js
 vm.$watch('a + b', function (newVal, oldVal) {
@@ -22,26 +22,28 @@ vm.$watch('a + b', function (newVal, oldVal) {
 })
 ```
 
-To also detect nested value changes inside Objects, you need to pass in `true` for the third `deep` argument. Note that you don't need to do so to listen for Array mutations.
+也可以监视在对象中的属性，你需要为 `deep` 传递一个 `true` 来使用此功能 。
+
+请注意你不可以这么监视用来数组中元素的变化。
 
 ``` js
 vm.$watch('someObject', callback, true)
 vm.someObject.nestedValue = 123
-// callback is fired
+// 回调被触发
 ```
 
-Passing in `true` for the fourth `immediate` argument will trigger the callback immediately with the current value of the expression:
+如果传递一个 `true` 到第四个变量 `immediate` , 那么回调会带着现在表达式的结果被立即触发。
 
 ``` js
 vm.$watch('a', callback, false, true)
-// callback is fired immediately with current value of `a`
+// 回调使用现在表达式的结果 `a` 被立刻触发
 ```
 
-Finally, `vm.$watch` returns an unwatch function that stops firing the callback:
+最后，还需要使用 `vm.$watch` 来返回一个停止监视的函数用来停止继续触发回调。
 
 ``` js
 var unwatch = vm.$watch('a', cb)
-// later, teardown the watcher
+// 最后，停止监制
 unwatch()
 ```
 
@@ -49,33 +51,33 @@ unwatch()
 
 - **expression** `String`
 
-Retrieve a value from the Vue instance given an expression. Expressions that throw errors will be suppressed and return `undefined`.
+为 Vue 实例传递一个表达式来获得结果，如果这个表达式带有错误，那么错误不会被报告并且返回一个 `undefined` 。
 
 ### vm.$set( keypath, value )
 
 - **keypath** `String`
 - **value** `*`
 
-Set a data value on the Vue instance given a valid keypath. If the path doesn't exist it will be created.
+通过给 Vue 实例传递一个可用的路径来设置结果，如果路径不存在那么会被创建。 
 
 ### vm.$add( keypath, value )
 
 - **keypath** `String`
 - **value** `*`
 
-Add a root level property to the Vue instance (and also its `$data`). Due to the limitations of ES5, Vue cannot detect properties directly added to or deleted from an Object, so use this method and `vm.$delete` when you need to do so. Additionally, all observed objects are augmented with these two methods too.
+添加一个根等级（root level property）的属性到 Vue 实例（或者也可以说是它自己的 `$data`）。由于 ES5 的限制，Vue 不可以直接监视对象中属性的增加或者删除，所以当你需要做这些的时候请使用这个方法和 `vm.$delete`。另外，所以被监视的对象也都由这两个方法增大。
 
 ### vm.$delete( keypath )
 
 - **keypath** `String`
 
-Delete a root level property on the Vue instance (and also its `$data`).
+在 Vue 实例中删除一个根等级属性(或者是它的 `$data`)。
 
 ### vm.$eval( expression )
 
 - **expression** `String`
 
-Evaluate an expression that can also contain filters.
+求一个表达式的值，它可以包含数个筛选器。
 
 ``` js
 // assuming vm.msg = 'hello'
@@ -88,6 +90,7 @@ vm.$eval('msg | uppercase') // -> 'HELLO'
 
 Evaluate a piece of template string containing mustache interpolations. Note that this method simply performs string interpolation; attribute directives are not compiled.
 
+
 ``` js
 // assuming vm.msg = 'hello'
 vm.$interpolate('{&#123;msg&#125;} world!') // -> 'hello world!'
@@ -97,7 +100,7 @@ vm.$interpolate('{&#123;msg&#125;} world!') // -> 'hello world!'
 
 - **keypath** `String` *optional*
 
-Log the current instance data as a plain object, which is more console-inspectable than a bunch of getter/setters. Also accepts an optional key.
+记录当前的实例数据保存在一个空白的对象，这种是比很多取值方法/设值方法都更有可检查性(console-inspectable)。当然也可以传递一个路径(可选)进去。
 
 ``` js
 vm.$log() // logs entire ViewModel data
@@ -106,80 +109,80 @@ vm.$log('item') // logs vm.item
 
 ## Events
 
-> Each vm is also an event emitter. When you have multiple nested ViewModels, you can use the event system to communicate between them.
+> 每个 vm 都是一个事件的emitter。当你有很多的视图模型时，你可以用这种事件系统去在他们之间沟通数据。
 
 ### vm.$dispatch( event, [args...] )
 
 - **event** `String`
 - **args...** *optional*
 
-Dispatch an event from the current vm that propagates all the way up to its `$root`. If a callback returns `false`, it will stop the propagation at its owner instance.
+从当前的 vm 处理一个事件，这个 vm 一直传播到它的 `$root` 。如果其中一个回调返回了 `false` ，那么在它自己的实例中停止传播。
 
 ### vm.$broadcast( event, [args...] )
 
 - **event** `String`
 - **args...** *optional*
 
-Emit an event to all children vms of the current vm, which gets further broadcasted to their children all the way down. If a callback returns `false`, its owner instance will not broadcast the event any further.
+为当前 vm 的所有子 vm 注册该事件，这个 vm 会一直传播到到他的子vm。当一个回调返回 `false` 。当一个回调返回了 `false`，那么它的所有者实例就不会广播这个事件了。
 
 ### vm.$emit( event, [args...] )
 
 - **event** `String`
 - **args...** *optional*
 
-Trigger an event on this vm only.
+只在这个 vm 里面触发被传递的事件。 
 
 ### vm.$on( event, callback )
 
 - **event** `String`
 - **callback** `Function`
 
-Listen for an event on the current vm.
+在当前 vm 中监听事件。
 
 ### vm.$once( event, callback )
 
 - **event** `String`
 - **callback** `Function`
 
-Attach a one-time only listener for an event.
+为一个事件注册一个一次性的监听器。
 
 ### vm.$off( [event, callback] )
 
 - **event** `String` *optional*
 - **callback** `Function` *optional*
 
-If no arguments are given, stop listening for all events; if only the event is given, remove all callbacks for that event; if both event and callback are given, remove that specific callback only.
+如果没有传递变量，那么停止监视所有时间；如果传递了一个事件，那么移除该事件的所有回调；如果事件和回调都被传递，则只移除该回调。
 
 ## DOM
 
-> All vm DOM manipulation methods work like their jQuery counterparts - except they also trigger Vue.js transitions if there are any declared on vm's `$el`. For more details on transitions see [Adding Transition Effects](/guide/transitions.html).
+> 所有 vm 的操作 DOM 的方法都是类似于jQuery中相同功能一样 - 除了被声明为 vm 的 `$el` 会触发 Vue.js 的转换。对于转化的更多细节可以看 [Adding Transition Effects](../guide/transitions.html) 。
 
 ### vm.$appendTo( element|selector, [callback] )
 
 - **element** `HTMLElement` | **selector** `String`
 - **callback** `Function` *optional*
 
-Append the vm's `$el` to target element. The argument can be either an element or a querySelector string.
+在目标元素后面添加 vm 的 `$el` ,变量可以是一个元素或者是一个被选择器选中的字符串。
 
 ### vm.$before( element|selector, [callback] )
 
 - **element** `HTMLElement` | **selector** `String`
 - **callback** `Function` *optional*
 
-Insert the vm's `$el` before target element.
+在目标元素之前插入 vm 的 `$el` 。
 
 ### vm.$after( element|selector, [callback] )
 
 - **element** `HTMLElement` | **selector** `String`
 - **callback** `Function` *optional*
 
-Insert the vm's `$el` after target element.
+在目标元素之后插入 vm 的 `$el` 。
 
 ### vm.$remove( [callback] )
 
 - **callback** `Function` *optional*
 
-Remove the vm's `$el` from the DOM.
+从 DOM 中移除 vm 的 `$el` 。
 
 ## Lifecycle
 
@@ -187,29 +190,30 @@ Remove the vm's `$el` from the DOM.
 
 - **element** `HTMLElement` | **selector** `String` *optional*
 
-If the Vue instance didn't get an `el` option at instantiation, you can manually call `$mount()` to assign an element to it and start the compilation. If no argument is provided, an empty `<div>` will be automatically created. Calling `$mount()` on an already mounted instance will have no effect. The method returns the instance itself so you can chain other instance methods after it.
+如果 Vue 实例在实例化的时候没有被传递一个 `el` 的选项,你可以自己调用 `$mount()` 赋一个元素给它并且开始编译。如果没有变量提供，就会自动生成一个空的 `<div>` 。在已经被挂在的实例上调用 `$mount()` 上是没有作用的。这个方法会返回实例本身所以如果你可以在它后面连锁一些其他的实例方法。
 
 ### vm.$destroy( [remove] )
 
 - **remove** `Boolean` *optional*
 
-Completely destroy a vm. Clean up its connections with other existing vms, unbind all its directives and remove its `$el` from the DOM. Also, all `$on` and `$watch` listeners will be automatically removed.
+完全销毁一个 vm。清空它对其他存在的 vm 的连接，释放它的所有中间件并且从DOM中移除它的 `$el`。并且所有的 `$on` 和 `$watch` 监听器也都会被自动移除。
 
 ### vm.$compile( element )
 
 - **element** `HTMLElement`
 
-Partially compile a piece of DOM (Element or DocumentFragment). The method returns a `decompile` function that tearsdown the directives created during the process. Note the decompile function does not remove the DOM. This method is exposed primarily for writing advanced custom directives.
+局部编译一个 DOM (元素或者是文档的片段)。这个方法返回一个 `decompile` 函数会关闭所有过程中已经被创建的中间件。请注意 decompile 函数不会移除DOM，这个方法对于写入高级自定义中间件来说根本上就是暴露的(exposed)。
+
 
 ### vm.$addChild( [options, constructor] )
 
 - **options** `Object` *optional*
 - **constructor** `Function` *optional*
 
-Adds a child instance to the current instance. The options object is the same in manually instantiating an instance. Optionally you can pass in a constructor created from `Vue.extend()`.
+为当前的实例增加一个子实例。选项对象和手动实例化一个实例是相同的。传递一个用 `Vue.extend()` 创造的构造器进去也是可以的。
 
-There are three implications of a parent-child relationship between instances:
+对于实例间父子关系有三种含义：
 
-1. The parent and child can communicate via [the event system](#Events).
-2. The child has access to all parent assets (e.g. custom directives).
-3. The child, if inheriting parent scope, has access to parent scope data properties.
\ No newline at end of file
+1. 父实例和子实例可以通过[the event system](#Events)来沟通
+2. 子实例有对父实例所有资源的许可。（例子： 自定义中间件）
+3. 如果是继承了父实例作用域的子实例，那么对父实例作用域的数据属性也有许可
\ No newline at end of file
diff --git a/source/api/instance-properties.md b/source/api/instance-properties.md
index 542b9f2be7..980d1defea 100644
--- a/source/api/instance-properties.md
+++ b/source/api/instance-properties.md
@@ -1,4 +1,4 @@
-title: Instance Properties
+title: 实例属性
 type: api
 order: 3
 ---
@@ -6,21 +6,21 @@ order: 3
 ### vm.$el
 
 - **Type:** `HTMLElement`
-- **Read only**
+- **只读**
 
-The DOM element that the Vue instance is managing.
+返回Vue实例正在管理的Dom元素。
 
 ### vm.$data
 
 - **Type:** `Object`
 
-The data object that the Vue instance is observing. You can swap it with a new object. The Vue instance proxies access to the properties on its data object.
+返回Vue实例正在监视的数据对象(data object)。当然你可以用新的对象去替换它。Vue实例通过代理方法访问他们的$data对象的属性。
 
 ### vm.$options
 
 - **Type:** `Object`
 
-The instantiation options used for the current Vue instance. This is useful when you want to include custom properties in the options:
+返回当前Vue实例所使用的实例化选项。当你想要添加自定义的属性到实例化选项里面的时候，这个属性是很有用的:
 
 ``` js
 new Vue({
@@ -34,31 +34,31 @@ new Vue({
 ### vm.$parent
 
 - **Type:** `Vue`
-- **Read only**
+- **只读**
 
-The parent instance, if the current instance has one.
+如果当前Vue实例有父实例(parent instance)，将返回父实例。
 
 ### vm.$root
 
 - **Type:** `Vue`
-- **Read only**
+- **只读**
 
-The root Vue instance of the current component tree. If the current instance has no parents this value will be itself.
+返回当前Vue结构树(component tree)的根Vue实例。如果当前的 `vm` 已经没有父实例的话将会返回它自己。
 
 ### vm.$
 
 - **Type:** `Object`
-- **Read only**
+- **只读**
 
-An object that holds child components that have `v-ref` registered. For more details see [v-ref](/api/directives.html#v-ref).
+返回一个对象，这个对象管理着有着 `v-ref` 指令的子组件。更多细节请查看 [v-ref](../api/directives.html#v-ref).
 
 ### vm.$$
 
 - **Type:** `Object`
 - **Read only**
 
-An object that holds DOM elements that have `v-el` registered. For more details see [v-el](/api/directives.html#v-el).
+返回一个对象，这个对象管理所有有着 `v-el` 指令的DOM元素。更多细节请查看 [v-el](../api/directives.html#v-el).
 
 ### Meta Properties
 
-Instances created by `v-repeat` will also have some meta properties, e.g. `vm.$index`, `vm.$key` and `vm.$value`. For more details, see [the guide on using `v-repeat`](/guide/list.html).
\ No newline at end of file
+被 `v-repeat` 创建出来的实例也会拥有一些元属性(Meta properties)。例如 `vm.$index`, `vm.$key` 和 `vm.$value` 等。更多细节请查看 [the guide on using `v-repeat`](../guide/list.html).
\ No newline at end of file
diff --git a/source/api/options.md b/source/api/options.md
index 773884dc27..3100c1c70b 100644
--- a/source/api/options.md
+++ b/source/api/options.md
@@ -1,4 +1,4 @@
-title: Options
+title: 选项
 type: api
 order: 2
 ---
@@ -125,7 +125,7 @@ Vue.component('param-demo', {
 <param-demo size="100" message="hello!"></param-demo>
 ```
 
-Param attributes can also contain interpolation tags. The interpolation will be evaluated against the parent, and under the hood they will be compiled as [`v-with`](/api/directives.html#v-with), which means when the value of the interpolated expression changes, the component's corresponding property will also be updated:
+Param attributes can also contain interpolation tags. The interpolation will be evaluated against the parent, and under the hood they will be compiled as [`v-with`](../api/directives.html#v-with), which means when the value of the interpolated expression changes, the component's corresponding property will also be updated:
 
 ``` html
 <param-demo message="{&#123;parentMessage&#125;}"></param-demo>
@@ -158,7 +158,7 @@ If the option is available at instantiation, the instance will immediately enter
 
 - **Type:** `String`
 
-A string template to be inserted into `vm.$el`. Any existing markup inside `vm.$el` will be overwritten, unless [content insertion points](/guide/components.html#Content_Insertion) are present in the template. If the **replace** option is `true`, the template will replace `vm.$el` entirely.
+A string template to be inserted into `vm.$el`. Any existing markup inside `vm.$el` will be overwritten, unless [content insertion points](../guide/components.html#内容插入) are present in the template. If the **replace** option is `true`, the template will replace `vm.$el` entirely.
 
 If it starts with `#` it will be used as a querySelector and use the selected element's innerHTML and the template string. This allows the use of the common `<script type="x-template">` trick to include templates.
 
@@ -234,31 +234,31 @@ These are private assets that will be available only to this Vue instance and it
 
 - **Type:** `Object`
 
-A hash of directives to be made available to the Vue instance. For details on how to write a custom directive, see [Writing Custom Directives](/guide/custom-directive.html).
+A hash of directives to be made available to the Vue instance. For details on how to write a custom directive, see [Writing Custom Directives](../guide/custom-directive.html).
 
 ### filters
 
 - **Type:** `Object`
 
-A hash of filters to be made available to the Vue instance. For details on how to write a custom filter, see [Writing Custom Filters](/guide/custom-filter.html).
+A hash of filters to be made available to the Vue instance. For details on how to write a custom filter, see [Writing Custom Filters](../guide/custom-filter.html).
 
 ### components
 
 - **Type:** `Object`
 
-A hash of components to be made available to the Vue instance. For details on how to extend and compose Vue instances, see [Component System](/guide/components.html).
+A hash of components to be made available to the Vue instance. For details on how to extend and compose Vue instances, see [Component System](../guide/components.html).
 
 ### partials
 
 - **Type:** `Object`
 
-A hash of partials to be made available to the Vue instance. Also see [v-partial](/api/directives.html#v-partial).
+A hash of partials to be made available to the Vue instance. Also see [v-partial](../api/directives.html#v-partial).
 
 ### transitions
 
 - **Type:** `Object`
 
-A hash of transitions to be made available to the Vue instance. For details see the guide on [Transitions](/guide/transitions.html).
+A hash of transitions to be made available to the Vue instance. For details see the guide on [Transitions](../guide/transitions.html).
 
 ## Others
 
diff --git a/source/examples/commits.md b/source/examples/commits.md
index 681ac6dea5..ce601ba7a1 100644
--- a/source/examples/commits.md
+++ b/source/examples/commits.md
@@ -1,8 +1,8 @@
-title: GitHub Commits
+title: GitHub 提交
 type: examples
 order: 1
 ---
 
-> This example fetches latest Vue.js commits data from GitHub's API and displays them as a list. You can switch between the master and dev branches.
+> 这个例子会通过 GitHub 的 API 获取 Vue.js 最近的提交信息，并展示成为一个列表。你可以在 master、div 和 next 分支之间进行切换。
 
 <iframe width="100%" height="500" src="http://jsfiddle.net/yyx990803/wd64qs6f/embedded/result,html,js,css" allowfullscreen="allowfullscreen" frameborder="0"></iframe>
\ No newline at end of file
diff --git a/source/examples/firebase.md b/source/examples/firebase.md
index f4f0c12a54..5a64172277 100644
--- a/source/examples/firebase.md
+++ b/source/examples/firebase.md
@@ -1,8 +1,8 @@
-title: Firebase + Validation
+title: Firebase + 验证
 type: examples
 order: 2
 ---
 
-> This example uses [Firebase](https://www.firebase.com/) as the data persistence backend and syncs between clients in real time (you can try opening it in multiple browser tabs). In addition, it performs instant validation using Vue.js filters and triggers CSS transitions when adding/removing items.
+> 这个示例使用 [Firebase](https://www.firebase.com/) 完成后台数据存储，并在客户端之间保持同步 (你可以同时在多个浏览器标签中打开试用)。另外，它会利用 Vue.js 过滤器进行实时的校验，并且会在添加/删除项目的时候触发 CSS 过渡效果。
 
 <iframe width="100%" height="500" src="http://jsfiddle.net/yyx990803/2ok0hp6c/embedded/result,html,js,css" allowfullscreen="allowfullscreen" frameborder="0"></iframe>
\ No newline at end of file
diff --git a/source/examples/grid-component.md b/source/examples/grid-component.md
index f798e2b260..97480c1bac 100644
--- a/source/examples/grid-component.md
+++ b/source/examples/grid-component.md
@@ -1,8 +1,8 @@
-title: Grid Component
+title: 网格组件
 type: examples
 order: 3
 ---
 
-> This is an example of creating a reusable grid component and using it with external data.
+> 这个示例创建了一个可复用的网格组件并将其配合外部的数据使用。
 
 <iframe width="100%" height="500" src="http://jsfiddle.net/yyx990803/2kqzhhq4/embedded/result,html,js,css" allowfullscreen="allowfullscreen" frameborder="0"></iframe>
\ No newline at end of file
diff --git a/source/examples/hackernews.md b/source/examples/hackernews.md
index 51506da205..593741b1bd 100644
--- a/source/examples/hackernews.md
+++ b/source/examples/hackernews.md
@@ -1,12 +1,12 @@
-title: HackerNews Clone
+title: HackerNews 的克隆
 type: examples
 order: 8
 ---
 
-> This is a HackerNews clone built upon HN's official Firebase API, and using Browserify + Vueify for the build setup.
+> 这是个 HackerNews 的克隆，它基于 HN 的官方 Firebase API 构建，并且在构建过程中使用了 Browserify + Vueify。
 
 <div style="max-width:600px">
-  <a href="http://yyx990803.github.io/vue-hackernews" target="_blank"><img style="width:100%" src="/images/hn.png"></a>
+  <a href="http://yyx990803.github.io/vue-hackernews" target="_blank"><img style="width:100%" src="../images/hn.png"></a>
 </div>
 
-> [[Source](https://github.com/yyx990803/vue-hackernews)]
\ No newline at end of file
+> [[源代码](https://github.com/yyx990803/vue-hackernews)]
\ No newline at end of file
diff --git a/source/examples/image-slider.md b/source/examples/image-slider.md
index 99bb871617..8712f63ccc 100644
--- a/source/examples/image-slider.md
+++ b/source/examples/image-slider.md
@@ -1,8 +1,8 @@
-title: Image Slider Component
+title: 图片轮播组件
 type: examples
 order: 6
 ---
 
-> This example mainly showcases the spec-compliant &lt;content/&gt; insertion points implementation.
+> 这个例子主要展示了符合规范用法的 &lt;content/&gt; 插入点的实现。
 
 <iframe width="100%" height="500" src="http://jsfiddle.net/yyx990803/qnbmymfm/embedded/result,html,js,css" allowfullscreen="allowfullscreen" frameborder="0"></iframe>
\ No newline at end of file
diff --git a/source/examples/index.md b/source/examples/index.md
index 0b71d559c1..5515067750 100644
--- a/source/examples/index.md
+++ b/source/examples/index.md
@@ -1,8 +1,8 @@
-title: Markdown Editor
+title: Markdown 编辑器
 type: examples
 order: 0
 ---
 
-> Dead simple Markdown editor.
+> 极简的 Markdown 编辑器.
 
 <iframe width="100%" height="500" src="http://jsfiddle.net/yyx990803/wy2qf6yx/embedded/result,html,js,css" allowfullscreen="allowfullscreen" frameborder="0"></iframe>
\ No newline at end of file
diff --git a/source/examples/svg.md b/source/examples/svg.md
index 24a603f2dd..d63ef8828e 100644
--- a/source/examples/svg.md
+++ b/source/examples/svg.md
@@ -1,8 +1,8 @@
-title: SVG Graph
+title: SVG 图形
 type: examples
 order: 5
 ---
 
-> This example showcases a combination of custom component, computed property, two-way binding and SVG support.
+> 这个示例展示了对自定义组件、可推导的属性、双向绑定和 SVG 支持的结合。
 
 <iframe width="100%" height="500" src="http://jsfiddle.net/yyx990803/36ew1g5c/embedded/result,html,js,css" allowfullscreen="allowfullscreen" frameborder="0"></iframe>
\ No newline at end of file
diff --git a/source/examples/todomvc.md b/source/examples/todomvc.md
index 555f624c78..aec077319e 100644
--- a/source/examples/todomvc.md
+++ b/source/examples/todomvc.md
@@ -3,8 +3,8 @@ type: examples
 order: 7
 ---
 
-> This is a fully spec-compliant TodoMVC implementation in under 120 effective lines of JavaScript (excluding comments and blank lines).
+> 这是一个完整规范用法的 TodoMVC 实现，JavaScript 不超过 120 行 (不包括注释和空行)。
 
 <iframe width="100%" height="500" src="todomvc/index.html" allowfullscreen="allowfullscreen" frameborder="0"></iframe>
 
-> [[Source](https://github.com/yyx990803/vue/tree/master/examples/todomvc)]
\ No newline at end of file
+> [[源代码](https://github.com/yyx990803/vue/tree/master/examples/todomvc)]
\ No newline at end of file
diff --git a/source/examples/tree-view.md b/source/examples/tree-view.md
index 17a8d74baa..3784f6a134 100644
--- a/source/examples/tree-view.md
+++ b/source/examples/tree-view.md
@@ -1,8 +1,8 @@
-title: Tree View
+title: 树状饰图
 type: examples
 order: 4
 ---
 
-> Example of a simple tree view implementation showcasing recursive usage of components.
+> 实现简单树状视图的实例，用来展示对组件的递归使用。
 
 <iframe width="100%" height="500" src="http://jsfiddle.net/yyx990803/2e53p4wq/embedded/result,html,js,css" allowfullscreen="allowfullscreen" frameborder="0"></iframe>
\ No newline at end of file
diff --git a/source/guide/application.md b/source/guide/application.md
index 6cf0417071..b96ac6358d 100644
--- a/source/guide/application.md
+++ b/source/guide/application.md
@@ -1,34 +1,34 @@
-title: Building Larger Apps
+title: 创建大型应用
 type: guide
 order: 13
 ---
 
-Vue.js is designed to be as flexible as possible - it's just an interface library that doesn't enforce any architectural decisions. While this can be very useful for rapid prototyping, it could be a challenge for those with less experience to build larger scale applications with it. The following is an opinionated perspective on how to organize larger projects when using Vue.js.
+Vue.js 会设计得尽量灵活——它只是一个接口库，不迁就于任何架构决策。尽管它在快速原型开发中显得非常有用，但对于经验较少的人来说，用它来构建大规模应用程序会有一定的难度。接下来我们会在如何使用 Vue.js 组织大型项目这方面提供一些的观点。
 
-## Modularization
+## 模块化
 
-Although the standalone build of Vue.js can be used as a global, it is often better to utilize a modularized build system to better organize your code. The recommended approach of doing so is by writing your source code in CommonJS modules (the format used by Node.js, and also the format used by Vue.js source code) and bundle them using [Browserify](http://browserify.org/) or [Webpack](http://webpack.github.io/).
+虽然独立构建的 Vue.js 可以被用作一个全局变量，但是它通常更适合应用在一个模块化系统中，以便更好的组织你的代码。我们建议你在 CommonJS 的模块下撰写源代码 (这是 Node.js 使用的格式，也是 Vue.js 源代码使用的格式)，并通过 [Browserify](http://browserify.org/) 或 [Webpack](http://webpack.github.io/) 把它们捆绑起来。
 
-Here are some build setup examples on GitHub:
+Github上有一些构建的示例：
 
 - [Vue + Browserify](https://github.com/vuejs/vue-browserify-example)
 - [Vue + Webpack](https://github.com/vuejs/vue-webpack-example)
 
-## Single File Components
+## 一个文件对应一个组件
 
-In a typical Vue.js project we will be breaking up our code into many small components, and it would be nice to have each component encapsulate its CSS styles, template and JavaScript definition in the same place. A bonus for using the previously mentioned build tools is that they both provided mechanisms to transform the source code before bundling them together, and with a bit of pre-processing we can write our components like this:
+在一个典型的 Vue.js 项目里，我们将会打散我们的代码，变成若干小的组件，如果能够根据组件划分把 CSS 样式也独立封装起来就更好了。刚才提过的2个构建工具都有一个额外的机制，那就是在把源代码捆绑在一起之前可以对其进行转换。再结合一些预处理，我们就可以这样撰写组件了：
 
-<img src="/images/vueify.png">
+![](../images/vueify.png)
 
-If you are into pre-processors, you can even do this:
+如果你有预处理程序，你甚至可以这样写：
 
-<img src="/images/vueify_with_pre.png">
+![](../images/vueify_with_pre.png)
 
-This is achieved via using the [Vueify](https://github.com/vuejs/vueify) transform for Browserify, or with [Vue-loader](https://github.com/vuejs/vue-loader) for Webpack.
+它已经通过 [Vueify](https://github.com/vuejs/vueify) 为 Browserify 进行转换，或通过 [Vue-loader](https://github.com/vuejs/vue-loader) 为 Webpack 进行转换。
 
-## Routing
+## 路由
 
-You can implement some rudimentary routing logic by manually listening on hashchange and utilizing a dynamic `v-component`.
+你可以手动监听 hashchange 并利用一个动态的 `v-component` 实现一些基本的路由逻辑。
 
 **Example:**
 
@@ -51,17 +51,17 @@ var app = new Vue({
 app.currentView = 'page1'
 ```
 
-With this mechanism it's very easy to leverage standalone routing libraries such as [Page.js](https://github.com/visionmedia/page.js) or [Director](https://github.com/flatiron/director).
+利用这种机制很容易接入独立的路由库，如 [Page.js](https://github.com/visionmedia/page.js) 或 [Director](https://github.com/flatiron/director)。
 
-## Communication with Server
+## 服务器通信
 
-All Vue instances can have their raw `$data` directly serialized with `JSON.stringify()` with no additional effort. You can use any Ajax component you like, for example [SuperAgent](https://github.com/visionmedia/superagent). It also plays nicely with no-backend services such as Firebase.
+所有的 Vue 实例都可以通过 `JSON.stringify()` 得到它们原始的 `$data`，没有任何副作用。你可以使用任何你喜欢的 Ajax 组件，比如 [SuperAgent](https://github.com/visionmedia/superagent)。也可以和诸如 Firebase 这样的 no-backend 服务完美配合。
 
-## Unit Testing
+## 单元测试
 
-Anything compatible with a CommonJS-based build system works. A recommendation is using the [Karma](http://karma-runner.github.io/0.12/index.html) test runner together with is [CommonJS pre-processor](https://github.com/karma-runner/karma-commonjs) to test your code modually.
+任何兼容 Common-JS 的构建系统都可以。建议使用 [Karma](http://karma-runner.github.io/0.12/index.html) test runner 结合 [CommonJS pre-processor](https://github.com/karma-runner/karma-commonjs) 对你的代码进行模块化测试。
 
-The best practice is to export raw options / functions inside modules. Consider this example:
+最佳实践是暴露出模块内的原始选项/函数。考虑一下这个示例：
 
 ``` js
 // my-component.js
@@ -72,7 +72,7 @@ module.exports = {
 }
 ```
 
-You can use that file in your entry module like this:
+你可以在你的入口模块中如下使用这个文件：
 
 ``` js
 // main.js
@@ -86,7 +86,7 @@ var app = new Vue({
 })
 ```
 
-And you can test that module like this:
+然后你可以如下测试该模块：
 
 ``` js
 // Some Jasmine 2.0 tests
@@ -104,8 +104,8 @@ describe('my-component', function () {
 })
 ```
 
-<p class="tip">Since Vue.js directives react to data updates asynchronously, when you are asserting DOM state after changing the data, you will have to do so in a `Vue.nextTick` callback. Alternatively you can set `Vue.config.async = false` during tests, so you can assert the DOM state synchronously right after the data change.</p>
+<p class="tip">因为 Vue.js 指令异步反映数据的更新，当你需要在改变数据之后断言 DOM 的状态时，你需要在一个 `Vue.nextTick` 回调里完成断言。另外你可以在测试中设置 `Vue.config.async = false`，这样你就可以在数据改变之后同步断言 DOM 的状态了。</p>
 
-## An Example
+## 一个示例
 
-The [Vue.js Hackernews Clone](https://github.com/yyx990803/vue-hackernews) is an example application that uses Browserify + Vueify for code organization, Director.js for routing, and HackerNews' official Firebase API as the backend. It's by no means a big application, but it demonstrates the combined usage of the concepts discussed on this page.
\ No newline at end of file
+[Vue.js Hackernews Clone](https://github.com/yyx990803/vue-hackernews) 是一个应用的例子，它把 Browserify + Vueify 用来代码组织、Director.js 用来做路由、HackerNews 官方的 Firebase API 为后端。这不算什么特别大的应用，但它结合并展示了本页面讨论到的各方面概念。
diff --git a/source/guide/components.md b/source/guide/components.md
index 69e8545a95..db27008f7e 100644
--- a/source/guide/components.md
+++ b/source/guide/components.md
@@ -1,20 +1,20 @@
-title: Component System
+title: 组件系统
 type: guide
 order: 11
 ---
 
-## Using Components
+## 使用组件
 
-Vue.js allows you to treat extended Vue subclasses as reusable components that are conceptually similar to [Web Components](http://www.w3.org/TR/components-intro/), without requiring any polyfills. To create a component, just create a subclass constructor of Vue using `Vue.extend()`:
+Vue.js 支持把扩展而来的 Vue 的子类用作概念上与 [Web Components](http://www.w3.org/TR/components-intro/) 类似的可复用组件，无需任何 polyfill。要创建组件，只需借助 `Vue.extend()` 创建一个 Vue 的子类构造函数：
 
 ``` js
-// Extend Vue to get a reusable constructor
+// 扩展 Vue 得到一个可复用的构造函数
 var MyComponent = Vue.extend({
   template: 'A custom component!'
 })
 ```
 
-Most of the options that can be passed into the Vue constructor can be used in `Vue.extend()`, however, there are two special cases, `data` and `el`. Since each Vue instance should have its own `$data` and `$el`, we obviously don't want the value we passed into `Vue.extend()` to be shared across all instances created from that constructor. So when you want to define how a component should initalize its default data or element, you should pass in a function instead:
+Vue 的构造函数可接收的大部分选项都能在 `Vue.extend()` 中使用，不过也有两个特例：`data` 和 `el`。由于每个 Vue 的实例都应该有自己的 `$data` 和 `$el`，我们显然不希望传递给 `Vue.extend()` 的值被所有通过这个构造函数创建的实例所共享。因此如果要定义组件初始化默认数据和元素的方式，应该传入一个函数：
 
 ``` js
 var ComponentWithDefaultData = Vue.extend({
@@ -26,53 +26,53 @@ var ComponentWithDefaultData = Vue.extend({
 })
 ```
 
-Then, you can **register** that constructor with `Vue.component()`:
+接下来，就可以用 `Vue.component()` 来**注册**这个构造函数了：
 
 ``` js
-// Register the constructor with id: my-component
+// 把构造函数注册到 my-component 这个 id
 Vue.component('my-component', MyComponent)
 ```
 
-To make things easier, you can also directly pass in the option object instead of an actual constructor. `Vue.component()` will implicitly call `Vue.extend()` for you if it receives an object:
+为了更简单，也可以直接传入 option 对象来代替构造函数。如果接收到的是一个对象，`Vue.component()` 会为你隐式调用 `Vue.extend()`：
 
 ``` js
-// Note: this method returns the global Vue,
-// not the registered constructor.
+// 注意：该方法返回全局 Vue 对象，
+// 而非注册的构造函数
 Vue.component('my-component', {
   template: 'A custom component!'
 })
 ```
 
-Then you can use the registered component in a parent instance's template (make sure the component is registered **before** you instantiate your root Vue instance):
+之后就能在父级实例的模板中使用注册过的组件了（确保在初始化根实例**之前**已经注册了组件）：
 
 ``` html
-<!-- inside parent template -->
+<!-- 父级模板 -->
 <div v-component="my-component"></div>
 ```
 
-If you prefer, components can also be used in the form of a custom element tag:
+如果你愿意，也能以自定义元素标签的形式使用组件：
 
 ``` html
 <my-component></my-component>
 ```
 
-<p class="tip">To avoid naming collisions with native elements and stay consistent with the W3C Custom Elements specification, the component's ID **must** contain a hyphen `-` to be usable as a custom tag.</p>
+<p class="tip">为了避免与本地元素发生命名冲突，也为了与 W3C 自定义元素规范一致，组件的 ID **必须**包含一个连字符 `-` 才能作为自定义标签使用。</p>
 
-It is important to understand the difference between `Vue.extend()` and `Vue.component()`. Since `Vue` itself is a constructor, `Vue.extend()` is a **class inheritance method**. Its task is to create a sub-class of `Vue` and return the constructor. `Vue.component()`, on the other hand, is an **asset registration method** similar to `Vue.directive()` and `Vue.filter()`. Its task is to associate a given constructor with a string ID so Vue.js can pick it up in templates. When directly passing in options to `Vue.component()`, it calls `Vue.extend()` under the hood.
+理解 `Vue.extend()` 和 `Vue.component()` 的区别至关重要。由于 `Vue` 本身是一个构造函数， `Vue.extend()` 是一个**类继承方法**。它用来创建一个 `Vue` 的子类并返回其构造函数。而另一方面，`Vue.component()` 是一个类似 `Vue.directive()` 和 `Vue.filter()` 的**资源注册方法**。它作用是建立指定的构造函数与 ID 字符串间的关系，从而让 Vue.js 能在模板中使用它。直接向 `Vue.component()` 传递 options 时，它会在内部调用 `Vue.extend()`。
 
-Vue.js supports two different API paradigms: the class-based, imperative, Backbone style API, and the markup-based, declarative, Web Components style API. If you are confused, think about how you can create an image element with `new Image()`, or with an `<img>` tag. Each is useful in its own right and Vue.js provides both for maximum flexibility.
+Vue.js 支持两种不同的 API 规范：基于类的命令式的 Backbone 风格 API，以及基于标记的声明式的 Web Components 风格 API。如果你感到困惑，想一下通过 `new Image()` 和通过 `<img>` 标签这两种创建图片元素的方式。它们都在各自的适用场景下发挥着作用，为了尽可能灵活，Vue.js 同时提供这两种方式。
 
-## Data Inheritance
+## 数据继承
 
-### Explicit Data Passing
+### 显式数据传递
 
-By default, components have **isolated scope**. This means you cannot reference parent data in a child component's template. To explicitly pass data to child components with isolated scope, we can use the `v-with` directive.
+默认情况下，组件有**独立作用域**。这意味着你无法在子组件的模板中引用父级的数据。可以通过 `v-with` 命令把数据显式传递给拥有独立作用域的子组件。
 
-#### Passing Down Child `$data`
+#### 向下传递子 `$data` 对象
 
-When given a single keypath without an argument, the corresponding value on the parent will be passed down to the child as its `$data`. This means the passed-down value must be an object, and it will overwrite the default `$data` object the child component might have.
+只给出 keypath 而不传递参数时，父级上相应的数据会传递给子级作为 `$data` 对象。这意味着传递的数据必须是一个对象，并且它会覆盖子组件可能包含的默认 `$data` 对象。
 
-**Example:**
+**示例：**
 
 ``` html
 <div id="demo-1">
@@ -81,12 +81,12 @@ When given a single keypath without an argument, the corresponding value on the
 ```
 
 ``` js
-// registering the component first
+// 先注册组件
 Vue.component('user-profile', {
   template: '{&#123;name&#125;}<br>{&#123;email&#125;}'
 })
-// the `user` object will be passed to the child
-// component as its $data
+// `user` 对象会传递给子级
+// 作为 $data
 var parent = new Vue({
   el: '#demo-1',
   data: {
@@ -98,7 +98,7 @@ var parent = new Vue({
 })
 ```
 
-**Result:**
+**结果：**
 
 <div id="demo-1" class="demo"><p v-component="user-profile" v-with="user"></p></div>
 <script>
@@ -116,17 +116,17 @@ var parent = new Vue({
   })
 </script>
 
-#### Passing Down Individual Properties
+#### 向下传递独立属性
 
-`v-with` can also be used with an argument in the form of `v-with="childProp: parentProp"`. This means passing down `parent[parentProp]` to the child as `child[childProp]`. Note this data inheritance is one-way: when `parentProp` changes, `childProp` will be updated accordingly, however not the other way around.
+`v-with` 也能以 `v-with="childProp: parentProp"` 的形式传入一个参数来使用。也就是把 `parent[parentProp]` 向下传递给子级，作为子级的属性 `child[childProp]`。要注意的是这种数据继承是单向的：当 `parentProp` 发生改变时，`childProp` 会相应更新，反之则不然。
 
-**Example:**
+**示例：**
 
 ``` html
 <div id="demo-2">
   <input v-model="parentMsg">
   <p v-component="child" v-with="childMsg : parentMsg">
-    <!-- essentially means "bind `parentMsg` on me as `childMsg`" -->
+    <!-- 实际上表示 "把 `parentMsg` 绑定到我的 `childMsg` 属性上" -->
   </p>
 </div>
 ```
@@ -145,7 +145,7 @@ new Vue({
 })
 ```
 
-**Result:**
+**结果**
 
 <div id="demo-2" class="demo"><input v-model="parentMsg"><p v-component="child" v-with="childMsg:parentMsg"></p></div>
 <script>
@@ -162,9 +162,9 @@ new Vue({
 })
 </script>
 
-#### Using `paramAttributes`
+#### 使用 `paramAttributes` 参数标识
 
-It is also possible to use the [`paramAttributes`](/api/options.html#paramAttributes) option, which compiles into `v-with`, to expose an interface that looks more like custom elements:
+同样可以通过 [`paramAttributes`](../api/options.html#paramAttributes) 选项（会被编译成 `v-with` ）来暴露一个看起来更像自定义元素的接口。
 
 ``` html
 <div id="demo-3">
@@ -182,17 +182,17 @@ new Vue({
   components: {
     'child-component': {
       paramAttributes: ['child-msg'],
-      // dashed attributes are camelized,
-      // so 'child-msg' becomes 'this.childMsg'
+      // 连字符分隔的属性会被转成驼峰形式，
+      // 所以“child-msg”成了“this.childMsg”
       template: '<span>{&#123;childMsg&#125;}</span>'
     }
   }
 })
 ```
 
-### Scope Inheritance
+### 作用域继承
 
-If you want, you can also use the `inherit: true` option for your child component to make it prototypally inherit all parent properties:
+如果有需要，你也可以使用 `inherit: true` 选项来让子组件通过原型链继承父级的全部属性：
 
 ``` js
 var parent = new Vue({
@@ -200,8 +200,8 @@ var parent = new Vue({
     a: 1
   }
 })
-// $addChild() is an instance method that allows you to
-// programatically create a child instance.
+// $addChild() 是一个实例方法，
+// 它允许你用代码创建子实例。
 var child = parent.$addChild({
   inherit: true,
   data: {
@@ -214,7 +214,7 @@ parent.a = 3
 console.log(child.a) // -> 3
 ```
 
-Note this comes with a caveat: because data properties on Vue instances are getter/setters, setting `child.a = 2` will change `parent.a` instead of creating a new property on the child shadowing the parent one:
+这里有一点需要注意：由于 Vue 示例上的数据属性都是 getter/setter，设置 `child.a = 2` 会直接改变 `parent.a` 的值，而非在子级创建一个新属性遮蔽父级中的属性：
 
 ``` js
 child.a = 4
@@ -222,22 +222,22 @@ console.log(parent.a) // -> 4
 console.log(child.hasOwnProperty('a')) // -> false
 ```
 
-### A Note on Scope
+### 作用域注意事项
 
-When a component is used in a parent template, e.g.:
+当组件被用在父模板中时，例如：
 
 ``` html
-<!-- parent template -->
+<!-- 父模板 -->
 <div v-component v-show="active" v-on="click:onClick"></div>
 ```
 
-The directives here (`v-show` and `v-on`) will be compiled in the parent's scope, so the value of `active` and `onClick` will be resolved against the parent. Any directives/interpolations inside the child's template will be compiled in the child's scope. This ensures a cleaner separation between parent and child components.
+这里的命令（ `v-show` 和 `v-on` ）会在父作用域编译，所以 `active` 和 `onClick` 的取值取决于父级。任何子模版中的命令和插值都会在子作用域中编译。这样使得上下级组件间更好地分离。
 
-This rule also applies to [content insertion](#Content_Insertion), as explained later in this guide.
+这条规则同样适用于 [内容插入](#内容插入)，这一点会在下文中详述。
 
-## Component Lifecycle
+## 组件生命周期
 
-Every component, or Vue instance, has its own lifecycle: it will be created, compiled, attached or detached, and finally destroyed. At each of these key moments the instance will emit corresponding events, and when creating an instance or defining a component, we can pass in lifecycle hook functions to react to these events. For example:
+每一个组件，或者说 Vue 的实例，都有着自己的生命周期：它会被创建、编译、附加、分离，最终销毁。在这每一个关键点，实例都会触发相应的事件，而在创建实例或者定义组件时，我们可以传入生命周期钩子函数来响应这些事件。例如：
 
 ``` js
 var MyComponent = Vue.extend({
@@ -247,11 +247,11 @@ var MyComponent = Vue.extend({
 })
 ```
 
-Check out the API reference for a [full list of lifecycle hooks](/api/options.html#Lifecycle) that are availble.
+查阅 API 文档中可用的 [生命周期钩子函数完整列表](../api/options.html#Lifecycle)。
 
-## Dynamic Components
+## 动态组件
 
-You can dynamically switch between components by using Mustache tags inside the `v-component` direcitve, which can be used together with routers to achieve "page switching":
+你可以通过在 `v-component` 命令中使用 Mustache 标签的方式在组件间动态切换，还能与路由一起使用实现“页面切换”：
 
 ``` js
 new Vue({
@@ -269,36 +269,36 @@ new Vue({
 
 ``` html
 <div v-component="{&#123;currentView&#125;}">
-  <!-- content changes when vm.currentview changes! -->
+  <!-- 内容随 vm.currentview 一同改变！ -->
 </div>
 ```
 
-If you want to keep the switched-out components alive so that you can preserve its state or avoid re-rendering, you can add a `keep-alive` directive param:
+如果希望被切换出去的组件保持存活，从而保留它的当前状态或者避免反复重新渲染，你可以加上 `keep-alive` 命令参数：
 
 ``` html
 <div v-component="{&#123;currentView&#125;}" keep-alive>
-  <!-- inactive components will be cached! -->
+  <!-- 不活跃的的组件会被缓存！ -->
 </div>
 ```
 
-### Transition Control
+### 过渡控制
 
-There are two additional attribute parameters that allows advanced control of how dynamic components should transition from one to another.
+有两个额外的属性能够支持对动态组件间的切换方式进行高级控制。
 
-#### `wait-for`
+#### `wait-for` 等待事件
 
-An event name to wait for on the incoming child component before switching it with the current component. This allows you to wait for asynchronous data to be loaded before triggering the transition to avoid unwanted flash of emptiness in between.
+等待即将进入的组件触发该事件后再用新组件替换当前组件。这就允许你等待数据异步加载完成后再触发过渡，避免切换过程中出现空白闪烁。
 
-**Example:**
+**示例：**
 
 ``` html
 <div v-component="{{view}}" wait-for="data-loaded"></div>
 ```
 ``` js
-// component definition
+// 组件定义
 {
-  // fetch data and fire the event asynchronously in the
-  // compiled hook. Using jQuery just for example.
+  // 获取数据并在编译完成钩子函数中异步触发事件。
+  // 这里jQuery只是用作演示。
   compiled: function () {
     var self = this
     $.ajax({
@@ -312,30 +312,30 @@ An event name to wait for on the incoming child component before switching it wi
 }
 ```
 
-#### `transition-mode`
+#### `transition-mode` 过渡模式
 
-By default, the transitions for incoming and outgoing components happen simultaneously. This param allows you to configure two other modes:
+默认情况下，进入组件和退出组件的过渡是同时进行的。这个参数允许设置成另外两种模式：
 
-- `in-out`: New component transitions in first, current component transitions out after incoming transition has finished.
-- `out-in`: Current component transitions out first, new componnent transitions in after outgoing transition has finished.
+- `in-out`：先进后出；先执行新组件过渡，当前组件在新组件过渡结束后执行过渡并退出。
+- `out-in`：先出后进；当前组件首先执行过渡并退出，新组件在当前组件过渡结束后执行过渡并进入。
 
-**Example**
+**示例：**
 
 ``` html
-<!-- fade out first, then fade in -->
+<!-- 先淡出，之后淡入 -->
 <div v-component="{{view}}"
   v-transition="fade"
   transition-mode="out-in">
 </div>
 ```
 
-## List and Components
+## 列表与组件
 
-For an Array of Objects, you can combine `v-component` with `v-repeat`. In this case, for each Object in the Array, a child ViewModel will be created using that Object as data, and the specified component as the constructor.
+对于一个对象数组，你可以把 `v-component` 和 `v-repeat` 组合使用。这种场景下，对于数组中的每个对象，都以该对象为数据创建一个子 ViewModel，以指定组件作为构造函数。
 
 ``` html
 <ul id="demo-4">
-  <!-- reusing the user-profile component we registered before -->
+  <!-- 复用我们之前注册过的 user-profile 组件 -->
   <li v-repeat="users" v-component="user-profile"></li>
 </ul>
 ```
@@ -358,7 +358,7 @@ var parent2 = new Vue({
 })
 ```
 
-**Result:**
+**结果：**
 
 <ul id="demo-4" class="demo"><li v-repeat="users" v-component="user-profile"></li></ul>
 <script>
@@ -379,9 +379,9 @@ var parent2 = new Vue({
 })
 </script>
 
-## Child Reference
+## 子组件引用
 
-Sometimes you might need to access nested child components in JavaScript. To enable that you have to assign a reference ID to the child component using `v-ref`. For example:
+某些情况下需要通过 JavaScript 访问嵌套的子组件。要实现这种操作，需要使用 `v-ref` 为子组件分配一个 ID。例如：
 
 ``` html
 <div id="parent">
@@ -391,15 +391,15 @@ Sometimes you might need to access nested child components in JavaScript. To ena
 
 ``` js
 var parent = new Vue({ el: '#parent' })
-// access child component
+// 访问子组件
 var child = parent.$.profile
 ```
 
-When `v-ref` is used together with `v-repeat`, the value you get will be an Array containing the child components mirroring the data Array.
+当 `v-ref` 与 `v-repeat` 一同使用时，会获得一个与数据数组对应的子组件数组。
 
-## Event System
+## 事件系统
 
-Although you can directly access a ViewModels children and parent, it is more convenient to use the built-in event system for cross-component communication. It also makes your code less coupled and easier to maintain. Once a parent-child relationship is established, you can dispatch and trigger events using each ViewModel's [event instance methods](/api/instance-methods.html#Events).
+虽然你可以直接访问一个 ViewModel 的子级与父级，但是通过内建的事件系统进行跨组件通讯更为便捷。这还能使你的代码进一步解耦，变得更易于维护。一旦建立了上下级关系，就能使用 ViewModel 的 [事件示例方法](../api/instance-methods.html#Events) 来分发和触发事件。
 
 ``` js
 var Child = Vue.extend({
@@ -444,15 +444,15 @@ var parent = new Vue({
 })
 </script>
 
-## Private Assets
+## 私有资源
 
-Sometimes a component needs to use assets such as directives, filters and its own child components, but might want to keep these assets encapsulated so the component itself can be reused elsewhere. You can do that using the private assets instantiation options. Private assets will only be accessible by the instances of the owner component and its child components.
+有时一个组件需要使用类似命令、过滤器和子组件这样的资源，但是又希望把这些资源封装起来以便自己在别处复用。这一点可以用私有资源实例化选项来实现。私有资源只能被拥有该资源的组件的实例及其子组件访问。
 
 ``` js
-// All 5 types of assets
+// 全部5种类型的资源
 var MyComponent = Vue.extend({
   directives: {
-    // id : definition pairs same with the global methods
+    // “id : 定义”键值对，与处理全局方法的方式相同
     'private-directive': function () {
       // ...
     }
@@ -472,7 +472,7 @@ var MyComponent = Vue.extend({
 })
 ```
 
-Alternatively, you can add private assets to an existing Component constructor using a chaining API similar to the global asset registration methods:
+又或者，可以用与全局资源注册方法类似的链式 API 为现有组件构造方法添加私有资源：
 
 ``` js
 MyComponent
@@ -482,24 +482,24 @@ MyComponent
   // ...
 ```
 
-## Content Insertion
+## 内容插入
 
-When creating reusable components, we often need to access and reuse the original content in the hosting element, which are not part of the component (similar to the Angular concept of "transclusion".) Vue.js implements a content insertion mechanism that is compatible with the current Web Components spec draft, using the special `<content>` element to serve as insertion points for the original content.
+在创建可复用组件时，我们通常需要在宿主元素中访问和重用原始数据，而它们并非组件的一部分（类似 Angular 的“transclusion”概念）。 Vue.js 实现了一套内容插入机制，它和目前的 Web Components 规范草案兼容，使用特殊的 `<content>` 元素作为原始内容的插入点。
 
-<p class="tip">Note: "transcluded" contents are compiled in the parent component's scope.</p>
+<p class="tip">注意：“transcluded”内容在父组件的作用域中编译。</p>
 
-### Single Insertion Point
+### 单插入点
 
-When there is only one `<content>` tag with no attributes, the entire original content will be inserted at its position in the DOM and replaces it. Anything originally inside the `<content>` tags is considered **fallback content**. Fallback content will only be displayed if the hosting element is empty and has no content to be inserted. For example:
+只有一个不带属性的 `<content>` 标签时，整个原始内容都会被插入到它在 DOM 中的位置并把它替换掉。原来在 `<content>` 标签内部的所有内容会被视为 **后备内容**。后备内容只有在宿主元素为空且没有要插入的内容时才会被显示。例如：
 
-Template for `my-component`:
+`my-component` 的模板：
 
 ``` html
 <h1>This is my component!</h1>
 <content>This will only be displayed if no content is inserted</content>
 ```
 
-Parent markup that uses the component:
+使用该组件的父标签：
 
 ``` html
 <div v-component="my-component">
@@ -508,7 +508,7 @@ Parent markup that uses the component:
 </div>
 ```
 
-The rendered result will be:
+渲染结果如下：
 
 ``` html
 <div>
@@ -518,11 +518,11 @@ The rendered result will be:
 </div>
 ```
 
-### Multiple Insertion Points
+### 多插入点
 
-`<content>` elements have a special attribute, `select`, which expects a CSS selector. You can have multiple `<content>` insertion points with different `select` attributes, and each of them will be replaced by the elements matching that selector from the original content.
+`<content>` 元素有一个特殊属性 `select`，需要赋值为一个 CSS 选择器。可以使用多个包含不同 `select` 属性的 `<content>` 插入点，它们会被原始内容中与选择器匹配的部分所替代。
 
-Template for `multi-insertion-component`:
+`multi-insertion-component` 的模板：
 
 ``` html
 <content select="p:nth-child(3)"></content>
@@ -530,7 +530,7 @@ Template for `multi-insertion-component`:
 <content select="p:nth-child(1)"></content>
 ```
 
-Parent markup:
+父标签：
 
 ``` html
 <div v-component="multi-insertion-component">
@@ -540,7 +540,7 @@ Parent markup:
 </div>
 ```
 
-The rendered result will be:
+渲染结果如下：
 
 ``` html
 <div>
@@ -550,6 +550,6 @@ The rendered result will be:
 </div>
 ```
 
-The content insertion mechanism provides fine control over how original content should be manipulated or displayed, making components extremely flexible and composable.
+内容插入机制能很好地控制对原始内容的操作和显示，使组件极为灵活多变易于组合。
 
-Next: [Applying Transition Effects](/guide/transitions.html).
+下一节：[过渡效果](../guide/transitions.html)
diff --git a/source/guide/computed.md b/source/guide/computed.md
index 888d11b52f..4d93c9f53c 100644
--- a/source/guide/computed.md
+++ b/source/guide/computed.md
@@ -1,11 +1,11 @@
-title: Computed Properties
+title: 可推导的属性
 type: guide
 order: 8
 ---
 
-Vue.js' inline expressions are very convenient, but the best use cases for them are simple boolean operations or string concatenations. For more complicated logic, you should use **computed properties**.
+Vue.js 的内联表达式非常方便，但它最好的用武之地其实是简单的布尔操作或字符串拼接。如果涉及更复杂的逻辑，你应该使用**可推导的属性**。
 
-In Vue.js, you define computed properties with the `computed` option:
+在 Vue.js 中，你可以通过 `computed` 选项定义可推导的属性：
 
 ``` js
 var demo = new Vue({
@@ -32,7 +32,7 @@ var demo = new Vue({
 demo.fullName // 'Foo Bar'
 ```
 
-When you only need the getter, you can provide a single function instead of an object:
+当你只需要 getter 的时候，你可以用一个简单的函数替代该对象：
 
 ``` js
 // ...
@@ -44,8 +44,8 @@ computed: {
 // ...
 ```
 
-A computed property is essentially a property defined with getter/setter functions. You can use a computed property just like a normal property, but when you access it, you get the value returned by the getter function; when you change its value, you trigger the setter function passing in the new value as its argument.
+一个可推导的属性本质上是一个被 getter/setter 函数定义了的属性。可推导的属性使用起来和一般属性一样，只是在访问它的时候，你会得到 getter 函数返回的值，改变它的时候，你会触发 setter 函数并接收新赋的值。
 
-<p class="tip">Before Vue.js 0.11 there used to be a dependency collection gotcha which requires users to explicitly list dependencies when conditional statements are involved. Starting with 0.11 it is no longer necessary to do so.</p>
+<p class="tip">在 Vue.js 0.11 之前的版本中，曾经有依赖收集机制，需要用户在条件语句中显性列出依赖关系。而在 0.11 之后你已经无需这样做了。</p>
 
-Next, let's learn about how to [write a custom directive](/guide/custom-directive.html).
\ No newline at end of file
+接下来，我们学一学如何[撰写一个自定义的指令](../guide/custom-directive.html).
\ No newline at end of file
diff --git a/source/guide/custom-directive.md b/source/guide/custom-directive.md
index 6977f92dd4..3663288b89 100644
--- a/source/guide/custom-directive.md
+++ b/source/guide/custom-directive.md
@@ -1,15 +1,15 @@
-title: Custom Directives
+title: 自定义指令
 type: guide
 order: 9
 ---
 
-## The Basics
+## 基础
 
-Vue.js allows you to register custom directives, essentially enabling you to teach Vue new tricks on how to map data changes to DOM behavior. You can register a global custom directive with the `Vue.directive(id, definition)` method, passing in a **directive id** followed by a **definition object**. A definition object can provide several hook functions (all optional):
+Vue.js允许你注册自定义指令，实质上是让你教Vue一些新技巧：怎样将数据的变化映射成DOM的行为。你可以使用`Vue.directive(id, definition) `的方法传入**指令名称**和**定义对象**来注册一个全局自定义指令。定义对象要能提供一些钩子函数（全都可选）：
 
-- **bind**: called only once, when the directive is first bound to the element.
-- **update**: called for the first time immediately after `bind` with the initial value, then again whenever the binding value changes. The new value and the previous value are provided as the argument.
-- **unbind**: called only once, when the directive is unbound from the element.
+- **bind**:仅调用一次，当指令第一次绑定元素的时候。
+-	**update**: 第一次调用是在 bind之后，用的是初始值；以后每当绑定的值发生变化就会被调用，新值与旧值作为参数。
+-	**unbind**：仅调用一次，当指令解绑元素的时候。
 
 **Example**
 
@@ -31,13 +31,13 @@ Vue.directive('my-directive', {
 })
 ```
 
-Once registered, you can use it in Vue.js templates like this (you need to add the Vue.js prefix to it):
+一旦注册好自定义指令，你就可以在Vue.js模板中像这样来使用它（你需要提前加上Vue.js）：
 
 ``` html
 <div v-my-directive="someValue"></div>
 ```
 
-When you only need the `update` function, you can pass in a single function instead of the definition object:
+当你只用到`update`函数，你就可以只传入一个函数，而不用传定义对象：
 
 ``` js
 Vue.directive('my-directive', function (value) {
@@ -45,18 +45,18 @@ Vue.directive('my-directive', function (value) {
 })
 ```
 
-All the hook functions will be copied into the actual **directive object**, which you can access inside these functions as their `this` context. The directive object exposes some useful properties:
+所有的钩子函数会被复制到实际的**指令对象**中，而指令对象就是访问这些函数时的 `this`上下文环境。指令对象有一些有用的公开属性：
 
-- **el**: the element the directive is bound to.
-- **vm**: the context ViewModel that owns this directive.
-- **expression**: the expression of the binding, excluding arguments and filters.
-- **arg**: the argument, if present.
-- **raw**: the raw, unparsed expression.
-- **name**: the name of the directive, without the prefix.
+- **el**: 指令绑定的元素
+- **vm**: 拥有该指令的上下文视图模型
+- **expression**: 绑定的表达式，不包括参数和过滤器
+- **arg**: 当前参数
+- **raw**: 未被解析的原始表达式
+- **name**: 不带前缀的指令名
 
-<p class="tip">You should treat all these properties as read-only and refrain from changing them. You can attach custom properties to the directive object too, but be careful not to accidentally overwrite existing internal ones.</p>
+<p class="tip"> 你应该把所有的这些属性看成是只读的，并且限制它们发生改变。你也可以给指令对象附加自定义的属性，但是注意不要重写已有的内部属性。
 
-An example of a custom directive using some of these properties:
+下面是自定义指令使用其中一些属性的例子：
 
 ``` html
 <div id="demo" v-demo="LightSlateGray : msg"></div>
@@ -111,9 +111,10 @@ var demo = new Vue({
 })
 </script>
 
-## Literal Directives
+## 直接指令
 
-If you pass in `isLiteral: true` when creating a custom directive, the attribute value will be taken as a literal string and assigned as that directive's `expression`. The directive will not attempt to setup data observation.
+如果在创建自定义指令的时候传入 `isLiteral: true` ，那么属性值就会被看成直接字符串，并被指定为该指令的`表达式`。指令不会试图建
+立数据监视。
 
 Example:
 
@@ -130,19 +131,20 @@ Vue.directive('literal-dir', {
 })
 ```
 
-### Dynamic Literal
+### 动态直接量
 
-However, in the case that the literal directive contains mustache tags, the behavior is as follows:
+然而，在直接指令含有mustache标签的情形下，指令的行为如下所示：
 
-- The directive instance will have a flag `this._isDynamicLiteral` set to `true`;
+- 指令实例会有一个标记，`this._isDynamicLiteral` 被设为 `true`
 
-- If no `update` function is provided, the mustache expression will be evaluated only once and assigned to `this.expression`. No data observation happens.
+- 如果没有提供 `update` 函数，mustache表达式只会被计算一次，并将值赋给 `this.expression` 。不会对表达式进行数据监视。
 
-- If an `update` function is provided, the directive **will** setup data observation for that expression and call `update` when the evaluated result changes.
+- 如果提供了 `update` 函数，指令**将**会为表达式建立一个数据监视，并且在计算结果变化的时候调用 `update` 
 
-## Two-way Directives
 
-If your directive expects to write data back to the Vue instance, you need to pass in `twoWay: true`. This option allows the use of `this.set(value)` inside the directive:
+## 双向指令
+
+如果你的指令想向 Vue 实例写回数据，你需要传入 `twoWay: true` 。该选项允许在指令中使用 `this.set(value)`
 
 ``` js
 Vue.directive('example', {
@@ -163,9 +165,9 @@ Vue.directive('example', {
 })
 ```
 
-## Inline Statements
+## 内联声明
 
-Passing in `acceptStatement:true` enables your custom directive to accept inline statements like `v-on` does:
+传入 `acceptStatement:true` 可以让自定义指令像 `v-on` 一样接受内联声明：
 
 ``` html
 <div v-my-directive="a++"></div>
@@ -182,11 +184,11 @@ Vue.directive('my-directive', {
 })
 ```
 
-Use this wisely though, because in general you want to avoid side-effects in your templates.
+但是要聪明地使用它，因为通常情况下你是想避免它在你的模板中产生副作用。
 
-## Deep Observation
+## 深度监视
 
-If your custom directive is expected to be used on an Object, and it needs to trigger `update` when a nested property inside the object changes, you need to pass in `deep: true` in your directive definition.
+如果你希望在一个 `Object` 上使用自定义指令，并且当对象的内嵌属性发生变化时触发指令的 `update` 函数，那么你就要在指令的定义中传入 `deep: true` 。
 
 ``` html
 <div v-my-directive="obj"></div>
@@ -202,10 +204,10 @@ Vue.directive('my-directive', {
 })
 ```
 
-## Directive Priority
+## 指令优先级
 
-You can optionally provide a priority number for your directive (defaults to 0). A directive with a higher priority will be processed earlier than other directives on the same element. Directives with the same priority will be processed in the order they appear in the element's attribute list, although that order is not guaranteed to be consistent in different browsers.
+你可以选择给指令提供一个优先级数（默认是0）。同一个元素上优先级越高的指令会比其他的指令处理得早一些。优先级一样的指令会按照其在元素属性列表中出现的顺序依次处理，但是不能保证这个顺序在不同的浏览器中是一致的。
 
-You can checkout the priorities for some built-in directives in the [API reference](/api/directives.html). Additionally, `v-repeat`, `v-if` and `v-component` are considered "terminal directives" and they always have the highest priority in the compilation process.
+你可以去[API reference](../api/directives.html)看一些内置指令的优先级。另外，`v-repeat`, `v-if` 以及 `v-component` 被视为“终端指令”，它们在编译过程中始终拥有最高的优先级。
 
-Next, we'll see how to [write a custom filter](/guide/custom-filter.html).
\ No newline at end of file
+下面，我们来看怎样写一个[自定义过滤器](../guide/custom-filter.html)。
diff --git a/source/guide/custom-filter.md b/source/guide/custom-filter.md
index 556f25ea04..1fd51b79e1 100644
--- a/source/guide/custom-filter.md
+++ b/source/guide/custom-filter.md
@@ -1,11 +1,11 @@
-title: Custom Filters
+title: 自定义过滤器
 type: guide
 order: 10
 ---
 
-## The Basics
+## 基本用法
 
-Similar to custom directives, you can register a custom filter with the global `Vue.filter()` method, passing in a **filterID** and a **filter function**. The filter function takes a value as the argument and returns the transformed value:
+和自定义指令类似，你可以用全局方法 `Vue.filter()`，传递一个**过滤器 ID**和一个**过滤器函数**，注册一个自定义过滤器。过滤器函数会接受一个参数值并返回将其转换后的值：
 
 ``` js
 Vue.filter('reverse', function (value) {
@@ -18,7 +18,7 @@ Vue.filter('reverse', function (value) {
 <span v-text="message | reverse"></span>
 ```
 
-The filter function also receives any inline arguments:
+过滤器函数也接受任何内联的参数：
 
 ``` js
 Vue.filter('wrap', function (value, begin, end) {
@@ -31,9 +31,9 @@ Vue.filter('wrap', function (value, begin, end) {
 <span v-text="message | wrap before after"></span>
 ```
 
-## Two-way Filters
+## 双向过滤器
 
-Up till now we have used filters to transform values coming from the model and before displaying them in the view. But it is also possible to define a filter that transforms the value before it is written back to the model from the view (input elements):
+现在我们已经在展示视图之前用过滤器把模型里的值进行了转换。其实我们也可以定义一个过滤器在值从视图 (input 元素) 写回模型之前进行转换：
 
 ``` js
 Vue.filter('check-email', {
@@ -50,9 +50,9 @@ Vue.filter('check-email', {
 })
 ```
 
-## Filter Context
+## 过滤器上下文
 
-When a filter is invoked, its `this` context is set to the Vue instance that is invoking it. This allows it to output dynamic results based on the state of the owner Vue instance.
+当一个过滤器被调用的时候，其 `this` 上下文会被设置为调用它的 Vue 实例。这使得我们可以根据其所属的 Vue 实例动态输出结果。
 
 For example:
 
@@ -67,8 +67,8 @@ Vue.filter('concat', function (value, key) {
 <span>{&#123;msg | concat userInput&#125;}</span>
 ```
 
-For this simple example above, you can achieve the same result with just an expression, but for more complicated procedures that need more than one statements, you need to put them either in a computed property or a custom filter.
+在上面这个例子中，你用表达式即可完成相同的结果。但是面对更复杂的处理时，如果需要不止一个语句，你就得把它们放到一个可推导的属性中或一个自定义过滤器中。
 
-The built-in `filterBy` and `orderBy` filters are both filters that perform non-trivial work on the Array being passed in and relies on the current state of the owner Vue instance.
+内建的 `filterBy` 和 `orderBy` 过滤器都是根据传入的数组以及所属 Vue 实例状态而运行的过滤器。
 
-Alright! Now it's time to learn how the [Component System](/guide/components.html) works.
\ No newline at end of file
+Alright！是时候了解[组件系统](../guide/components.html)的工作方式了。
\ No newline at end of file
diff --git a/source/guide/directives.md b/source/guide/directives.md
index 02248e56b3..2c7565ef1a 100644
--- a/source/guide/directives.md
+++ b/source/guide/directives.md
@@ -1,11 +1,11 @@
-title: Directives
+title: 指令
 type: guide
 order: 3
 ---
 
-## Synopsis
+## 摘要
 
-If you have not used AngularJS before, you probably don't know what a directive is. Essentially, a directive is some special token in the markup that tells the library to do something to a DOM element. In Vue.js, the concept of directive is drastically simpler than that in Angular. A Vue.js directive can only appear in the form of a prefixed HTML attribute that takes the following format:
+如果你还没有使用过 AngularJS，你可能不太清楚指令 (directive) 是什么。一个指令的本质是一个特殊的标记符号，使得该库对一个 DOM 元素进行一些处理。在 Vue.js 中，指令的概念和 Angular 是完全一样的。Vue.js 中的指令就是带有特殊前缀的 HTML 特性，它会以下面的格式出现：
 
 ``` html
 <element
@@ -13,41 +13,41 @@ If you have not used AngularJS before, you probably don't know what a directive
 </element>
 ```
 
-## A Simple Example
+## 一个简单的例子
 
 ``` html
 <div v-text="message"></div>
 ```
 
-Here the prefix is `v` which is the default. The directive ID is `text` and the the expression is `message`. This directive instructs Vue.js to update the div's `textContent` whenever the `message` property on the Vue instance changes.
+这里默认的前缀是 `v`。指令 ID 是 `text`，表达式是 `message`。该指令会在该 Vue 实例的 `message` 属性发生变化时更新这个 div 的 `textContent`。
 
-## Inline Expressions
+## 内联表达式
 
 ``` html
 <div v-text="'hello ' + user.firstName + ' ' + user.lastName"></div>
 ```
 
-Here we are using a computed expression instead of a single property key. Vue.js automatically tracks the properties an expression depends on and refreshes the directive whenever a dependency changes. Thanks to async batch updates, even when multiple dependencies change, an expression will only be updated once every event loop.
+这里我们用一个可推导的表达式 (computed expression) 提到了简单的属性名。Vue.js 会自动跟踪表达式中依赖的属性并在这些依赖发生变化的时候更新指令。而且因为有异步批处理更新机制，哪怕多个依赖同时变化时，表达式也只会在时间循环里触发一次。
 
-You should use expressions wisely and avoid putting too much logic in your templates, especially statements with side effects (with the exception of event listener expressions). To discourage the overuse of logic inside templates, Vue.js inline expressions are limited to **one statement only**. For bindings that require more complicated operations, use [Computed Properties](/guide/computed.html) instead.
+你应该灵活的使用表达式，以避免在你的模板里放入过多的逻辑，尤其是有边界效应的语句 (事件监听表达式除外)。为了在模板内防止逻辑被滥用，Vue.js 把内联表达式限制为**只能是一条语句**。如果需要绑定更复杂的操作，请使用[可推导的属性](../guide/computed.html)。
 
-<p class="tip">For security reasons, in inline expressions you can only access properties and methods present on the current context Vue instance and its parents.</p>
+<p class="tip">由于安全方面的原因，在内联表达式中你只能访问当前上下文中 Vue 实例及其祖先的属性和方法。</p>
 
-## Argument
+## 参数
 
 ``` html
 <div v-on="click : clickHandler"></div>
 ```
 
-Some directives require an argument before the keypath or expression. In this example the `click` argument indicates we want the `v-on` directive to listen for a click event and then call the `clickHandler` method of the ViewModel instance.
+有些指令需要在路径或表达式前加一个参数。在这个例子中 `click` 参数代表了我们希望 `v-on` 指令监听到点击事件之后调用该 ViewModel 实例的 `clickHandler` 方法。
 
-## Filters
+## 过滤器
 
-Filters can be appended to directive keypaths or expressions to further process the value before updating the DOM. Filters are denoted by a single pipe (`|`) as in shell scripts. For more details see [Filters in Depth](/guide/filters.html).
+过滤器可以紧跟在指令的路径或表达式之后，在更新 DOM 之前对值进行进一步处理。过滤器会被像 shell 脚本一样表示在一个竖线 (`|`) 之后。更多内容请移步至[深入了解过滤器](../guide/filters.html)。
 
-## Multiple Clauses
+## 多重语句指令
 
-You can create multiple bindings of the same directive in a single attribute, separated by commas. Under the hood they are bound as multiple directive instances.
+你可以在同一个特性的同一个指令里创建多个绑定。这些绑定是用逗号分隔开的。它们在底层被分解为多个指令实例进行绑定。
 
 ``` html
 <div v-on="
@@ -58,31 +58,31 @@ You can create multiple bindings of the same directive in a single attribute, se
 </div>
 ```
 
-## Literal Directives
+## 字面量指令
 
-Some directives don't create data bindings - they simply take the attribute value as a literal string. For example the `v-component` directive:
+有些指令不会创建数据绑定——它们的值只是一个字符串字面量。比如 `v-component` 指令：
 
 ``` html
 <div v-component="my-component"></div>
 ```
 
-Here `"my-component"` is not a data property - it's a string ID that Vue.js uses to lookup the corresponding Component constructor.
+这里的 `"my-component"` 并不是一个数据属性——它是一个字符串 ID，用来让 Vue.js 查找对应的组件构造函数。
 
-You can also use mustache expressions inside literal directives. For example, the following code allows you to dynamically resolve the type of component you want to use:
+你也可以在字面量指令中使用 mustache 表达式。比如，下面的代码允许你动态的解析你想要的组件类型：
 
 ``` html
 <div v-component="{&#123; isOwner ? 'owner-panel' : 'guest-panel' &#125;}"></div>
 ```
 
-When the expression inside the mustaches change, the rendered component will also change accordingly!
+当花括号内部的表达式改变时，渲染出来的组件也会随之改变哦！
 
-However, note that `v-component` and `v-partial` are the only literal directives that have this kind of reactive behavior. Mustache expressions in other literal directives, e.g. `v-ref`, are evaluated **only once**. After the directive has been compiled, it will no longer react to value changes.
+尽管如此，值得注意的是只有 `v-component` 和 `v-partial` 这两个字面量指令有这种可响应的行为。Mustache 表达式在别的字面量指令，如 `v-ref` 中，是**只运行一次**的。在指令被编译之后，就不再响应值的变化了。
 
-A full list of literal directives can be found in the [API reference](/api/directives.html#Literal_Directives).
+完整的字面量指令列表可以在 [API 索引](../api/directives.html#字面指令) 中找到。
 
-## Empty Directives
+## 空指令
 
-Some directives don't even expect an attribute value - they simply do something to the element once and only once. For example the `v-pre` directive:
+有些指令并不需要判断特性的值——这些操作对某个元素处理且仅处理一次。比如 `v-pre` 指令：
 
 ``` html
 <div v-pre>
@@ -90,6 +90,6 @@ Some directives don't even expect an attribute value - they simply do something
 </div>
 ```
 
-A full list of empty directives can be found in the [API reference](/api/directives.html#Empty_Directives).
+完整的空指令列表可以在 [API 索引](../api/directives.html#空指令) 中找到。
 
-Next, let's talk about [Filters](/guide/filters.html).
\ No newline at end of file
+接下来，我们来看一看[过滤器](../guide/filters.html)。
\ No newline at end of file
diff --git a/source/guide/events.md b/source/guide/events.md
index f8eef8f9e3..8cb656a483 100644
--- a/source/guide/events.md
+++ b/source/guide/events.md
@@ -1,9 +1,9 @@
-title: Listening for Events
+title: 事件监听
 type: guide
 order: 6
 ---
 
-You can use the `v-on` directive to bind event listeners to DOM events. It can be bound to either an event handler function (without the invocation parentheses) or an inline expression. If a handler function is provided, it will get the original DOM event as the argument. The event also comes with an extra property: `targetVM`, pointing to the particular ViewModel the event was triggered on:
+你可以使用 `v-on` 指令来绑定并监听 DOM 事件。绑定的内容可以是一个事件句柄函数 (后面无需跟括号) 或一个内联表达式。如果提供的是一个句柄函数，则原来的 DOM event 对象会被作为第一个参数传入，同时这个 event 对象会附带 `targetVM` 属性，指向触发该事件的相应的 ViewModel：
 
 ``` html
 <div id="demo">
@@ -27,9 +27,9 @@ new Vue({
 })
 ```
 
-## Invoke Handler with Expression
+## 执行表达式句柄
 
-`targetVM` could be useful when `v-on` is used with `v-repeat`, since the latter creates a lot of child ViewModels. However, it is often more convenient to use an invocation expression passing in `this`, which equals the current context ViewModel:
+`targetVM` 在 `v-repeat` 里使用 `v-on` 时显得特别有用，因为 `v-repeat` 会创建大量子 ViewModel。这样的话，通过执行表达式的方式，把代表当前上下文 ViewModel 的 `this` 传进去，就显得非常方便。
 
 ``` html
 <ul id="list">
@@ -54,7 +54,7 @@ new Vue({
 })
 ```
 
-When you want to access the original DOM event in an expression handler, you can pass it in as `$event`:
+当你想要在表达式句柄中访问原来的 DOM event，你可以传递一个 `$event` 参数进去：
 
 ``` html
 <button v-on="click: submit('hello!', $event)">Submit</button>
@@ -72,30 +72,30 @@ When you want to access the original DOM event in an expression handler, you can
 /* ... */
 ```
 
-## The Special `key` Filter
+## 特殊的 `key` 过滤器
 
-When listening for keyboard events, we often need to check for common key codes. Vue.js provides a special `key` filter that can only be used with `v-on` directives. It takes a single argument that denotes the key code to check for:
+当监听键盘事件时，我们常常需要判断常用的 key code。Vue.js 提供了一个特殊的只能用在 `v-on` 指令的过滤器：`key`。它接收一个表示 key code 的参数并完成判断：
 
 ```
 <!-- only call vm.submit() when the keyCode is 13 -->
 <input v-on="keyup:submit | key 13">
 ```
 
-It also has a few presets for commonly used keys:
+它也预置了一些常用的按键名：
 
 ```
 <!-- same as above -->
 <input v-on="keyup:submit | key enter">
 ```
 
-Check the API reference for a [full list of key filter presets](/api/filters.html#key).
+API 索引中有 [key 过滤器预置的完整列表](../api/filters.html#key).
 
-## Why Listeners in HTML?
+## 为什么要在 HTML 中写监听器？
 
-You might be concerned about this whole event listening approach violates the good old rules about "separation of concern". Rest assured - since all Vue.js handler functions and expressions are strictly bound to the ViewModel that's handling the current View, it won't cause any maintainance difficulty. In fact, there are several benefits in using `v-on`:
+你可能会注意到整个事件监听的方式违背了“separation of concern”的传统理念。不必担心，因为所有的 Vue.js 句柄函数和表达式都严格绑定在当前视图的 ViewModel 上，它不会导致任何维护困难。实际上，使用 `v-on` 还有更多好处：
 
-1. It makes it easier to locate the handler function implementations within your JS code by simply skimming the HTML template.
-2. Since you don't have to manually attach event listeners in JS, your ViewModel code can be pure logic and DOM-free. This makes it easier to test.
-3. When a ViewModel is destroyed, all event listeners are automatically removed. You don't need to worry about cleaning it up yourself.
+1. 它便于在 HTML 模板中轻松定位 JS 代码里的句柄函数实现。
+2. 因为你无须在 JS 里手动绑定事件，你的 ViewModel 代码可以是非常纯粹的逻辑而和 DOM 无关。这会更易于测试。
+3. 当一个 ViewModel 被销毁时，所有的事件监听都会被自动移除。你无须担心如何自行清理它们。
 
-Next up: [Handling Forms](/guide/forms.html).
\ No newline at end of file
+接下来：[处理表单](../guide/forms.html).
\ No newline at end of file
diff --git a/source/guide/extending.md b/source/guide/extending.md
index 69a4f501dd..8fb42fec89 100644
--- a/source/guide/extending.md
+++ b/source/guide/extending.md
@@ -1,11 +1,11 @@
-title: Extending Vue
+title: 扩展 Vue
 type: guide
 order: 14
 ---
 
-## Extend with Mixins
+## 使用 Mixin 进行扩展
 
-Mixins are a flexible way to distribute reusable functionalities for Vue components. You can write a mixin just like a normal Vue component option object:
+Mixin 是一种为 Vue 组件分发可复用功能的灵活的方式。你可以像写一个普通 Vue 组件的选项对象一样写出一个 mixin：
 
 ``` js
 // mixin.js
@@ -30,17 +30,17 @@ var Component = Vue.extend({
 var component = new Component() // -> "hello from mixin!"
 ```
 
-## Extend with Plugins
+## 使用插件进行扩展
 
-Plugins usually adds global-level functionality to Vue.
+通常插件会为 Vue 添加一个全局的功能。
 
-### Writing a Plugin
+### 撰写插件
 
-There are typically several types of plugins you can write:
+你可以撰写以下几种典型类型的插件：
 
-1. Add one or more global methods. e.g. [vue-element](https://github.com/vuejs/vue-element)
-2. Add one or more global assets: directives/filters/transitions etc. e.g. [vue-touch](https://github.com/vuejs/vue-touch)
-3. Add some Vue instance methods by attaching them to Vue.prototype. The convention here is Vue instance methods should be prefixed with `$`, so that they don't conflict with user data and methods.
+1. 添加一个或几个全局方法。比如 [vue-element](https://github.com/vuejs/vue-element)
+2. 添加一个或几个全局资源：指令、过滤器、过渡效果等。比如 [vue-touch](https://github.com/vuejs/vue-touch)
+3. 通过绑定到 `Vue.prototype` 的方式添加一些 Vue 实例方法。这里有个约定，就是 Vue 的实例方法应该带有 `$` 前缀，这样就不会和用户的数据和方法产生冲突了。
 
 ``` js
 exports.install = function (Vue, options) {
@@ -50,9 +50,9 @@ exports.install = function (Vue, options) {
 }
 ```
 
-### Using a Plugin
+### 使用插件
 
-Assuming using a CommonJS build system:
+假设我们使用的构建系统是 CommonJS，则：
 
 ``` js
 var vueTouch = require('vue-touch')
@@ -60,7 +60,7 @@ var vueTouch = require('vue-touch')
 Vue.use(vueTouch)
 ```
 
-You can also pass in additional options to the plugin:
+你也可以向插件里传递额外的选项：
 
 ```js
 Vue.use('my-plugin', {
@@ -68,9 +68,9 @@ Vue.use('my-plugin', {
 })
 ```
 
-## Existing Tools
+## 现有的工具
 
-- [vue-devtools](https://github.com/vuejs/vue-devtools): A Chrome devtools extension for debugging Vue.js applications.
-- [vue-touch](https://github.com/vuejs/vue-touch): Add touch-gesture directives using Hammer.js.
-- [vue-element](https://github.com/vuejs/vue-element): Register Custom Elements with Vue.js.
-- [List of User Contributed Tools](https://github.com/yyx990803/vue/wiki/User-Contributed-Components-&-Tools)
\ No newline at end of file
+- [vue-devtools](https://github.com/vuejs/vue-devtools)：一个用来 debug Vue.js 应用程序的 Chrome 开发者工具扩展。
+- [vue-touch](https://github.com/vuejs/vue-touch)：添加基于 Hammer.js 的触摸手势的指令。
+- [vue-element](https://github.com/vuejs/vue-element): 用 Vue.js 注册 Custom Elements。
+- [用户贡献的工具列表](https://github.com/yyx990803/vue/wiki/User-Contributed-Components-&-Tools)
\ No newline at end of file
diff --git a/source/guide/faq.md b/source/guide/faq.md
index 4ba4de9bc0..b0770d14fb 100644
--- a/source/guide/faq.md
+++ b/source/guide/faq.md
@@ -1,62 +1,62 @@
-title: Common FAQs
+title: 常见问题
 type: guide
 order: 15
 ---
 
-- **Why doesn't Vue.js support IE8?**
+- **为什么Vue.js不支持IE8?**
 
-  Vue.js is able to deliver the plain JavaScript object syntax without resorting to dirty checking by using `Object.defineProperty`, which is an ECMAScript 5 feature. It only works on DOM elements in IE8 and there's no way to polyfill it for JavaScript objects.
+  Vue.js能够在不使用`Object.defineProperty`的情况下进行脏检查来输出纯真的JavaScript对象语法，这是ECMAScript 5的一个特性。但它只在IE8的DOM元素中起作用，目前没有办法将其适用于JavaScript对象。
 
-- **So Vue.js modifies my data?**
+- **那么Vue.js修改了我的数据喽?**
 
-  Yes and No. Vue.js only converts normal properties into getters and setters so it can get notified when the properties are accessed or changed. When serialized, your data will look exactly the same. There are, of course, some caveats:
+  是也不是。Vue.js只转换正常的属性到getters和setters，这样它才能在属性被访问或更改时得到通知。而序列化时，你的数据将是完全相同。当然，这里有一些注意事项：
 
-  1. When you `console.log` observed objects you will only see a bunch of getter/setters. However you can use `vm.$log()` to log a more inspectable output.
+  1. 当你使用`console.log`观察对象时你将只能看到一串getter/setters. 但你可以使用`vm.$log()`来打印出一个更直观的输出。
 
-  2. You cannot define your own getter/setters on data objects. This isn't much of a problem because data objects are expected to be obtained from plain JSON and Vue.js provides computed properties.
+  2. 你不能定义数据对象的getter/setters。这不会是问题，因为数据对象都期望从纯JSON中取得，而且vue.js提供该提取属性。
 
-  3. Vue.js adds a few extra properties/methods to obsesrved objects: `__ob__`, `$add` and `$delete`. These properties are inenumberable so they will not show up in `for ... in ...` loops. However if you overwrite them things will likely break.
+  3. Vue.js添加了一些拓展的属性或方法来观察对象: `__ob__`, `$add`以及`$delete`. 这些属性是内部的所以它们不会显示在`for ... in ...`循环中. 但是如果你覆盖了它们这可能就破坏掉了。
 
-  That's pretty much it. Accessing properties on the object is the same as before, `JSON.stringify` and `for ... in ...` loops will work as normal. 99.9% of the time you don't even need to think about it.
+  类似的东西还有一些。基于对象访问属性和以前一样,`JSON.stringify`和`for ... in ...`循环照常运行。99.9%的情况下你甚至不需要考虑它们。
 
-- **What is the current status of Vue.js? Can I use it in production?**
+- **Vue.js目前的状态怎样? 我能把它应用在生产环节么?**
 
-  Vue.js has undergone some major rewrite for the 0.11 update, and we are now working towards the 1.0 release. Vue.js is already being used in production at companies like Optimizely.
+  Vue.js 0.11的更新已经经历了一些重大的修改，我们正在朝着1.0的发布版本迈进。Vue.js已经被像Optimizely这样的公司应用在生产环境中。
 
-- **Is Vue.js free to use?**
+- **Vue.js是免费试用的吗?**
 
-  Vue.js is free and fully open sourced under the MIT License.
+  Vue.js遵循MIT协议是免费且完全开源的.
 
-- **What is the difference between Vue.js and AngularJS?**
+- **Vue.js和AngularJS之间的区别是什么?**
 
-  There are a few reasons to use Vue over Angular, although they might not apply for everyone:
+  下面是一些使用Vue而不是Angular的原因，但它们不适用于每一个人：
 
-  1. Vue.js is a more flexible, less opinionated solution. That allows you to structure your app the way you want it to be, instead of being forced to do everything the Angular way. It's only an interface layer so you can use it as a light feature in pages instead of a full blown SPA. It gives you bigger room to mix and match with other libraries. This is probably the most important distinction.
+  1. Vue.js是一个更加灵活开放的解决方案。它允许你以希望的方式组织你的应用程序，而不是像Angular那样强迫去做。它仅仅是一个接口层，所以你可以将它作为一个页面的轻特性而不是一个全栈的SPA。在结合和匹配其他库方面它给了你更大的的空间。这可能是最为重要的区别。
 
-  2. Vue.js is much simpler than Angular in general, so you can learn almost everything about it really fast and get productive.
+  2. 总体来说Vue.js比Angular简单, 因此你可以快速地学习它的方方面面并投入生产.
 
-  3. Vue.js has better performance because it doesn't use dirty checking. Angular gets slow when there are a lot of watchers, because every time anything in the scope changes, all these watchers need to be re-evaluated again. Vue.js doesn't suffer from this because it uses an event based observing mechanism, so all changes trigger independently unless they have explicit dependency relationships.
+  3. Vue.js拥有更好的性能，因为它不使用脏检查。当观察点越来越多时Angular会变得越来越慢，因为作用域内的每一次变更所有的这些观察点都需要被重新评估。Vue.js不面临这些问题，这是因为它采用了基于事件的观察机制，所以所有的触发都是独立的，除非它们之间有明确的依赖关系。
 
-  4. Vue.js has a clearer separation between directives and components. Directives are meant to encapsulate DOM manipulations only, while Components stand for a self-contained unit that has its own view and data logic. In Angular there's a lot of confusion between the two.
+  4. Vue.js指令和组件间具有一个清晰隔离。指令只意味着封装DOM操作，而组件代表一个子独立的单元——它拥有自己的视图和数据逻辑。在Angular中它们两者间有不少混淆。
 
-  But also note that Vue.js is a relatively young project, while Angular is battle-proven, Google-sponsored, and has a larger community.
+  但是需要指出的是Vue.js还是一个相对年轻的项目，而Angular已经久经项目验证，并且是谷歌发起的且有一个更大的社区。
 
-- **What makes Vue.js different from KnockoutJS?**
+- **是什么使得Vue.js不同于KnockoutJS?**
 
-  First, Vue provides a cleaner syntax in getting and setting VM properties.
+  首先，Vue在获取和设置虚拟属性上提供了更清晰的语法。
 
-  On a higher level, Vue differs from Knockout in that Vue's component system encourages you to take a top-down, structure first, declarative design strategy, instead of imperatively build up ViewModels from bottom up. In Vue the source data are plain, logic-less objects (ones that you can directly JSON.stringify and throw into a post request), and the ViewModel simply proxies access to that data on itself. A Vue VM instance always connects raw data to a corresponding DOM element. In Knockout, the ViewModel essentially **is** the data and the line between Model and ViewModel is pretty blurry. This lack of differentiation makes Knockout more flexible, but also much more likely to result in convoluted ViewModels.
+  从更高层次来说，Vue区别于Knockout是因为Vue的组件系统鼓励你采取自上而下，结构第一，陈述性设计的策略，而不是命令式的自下向上来建立ViewModel。在Vue中源数据是纯粹的无逻辑的对象（这些对象你可以直接JSON.stringify并扔到POST请求中），而ViewModel只是代理访问数据本身。Vue的VM实例往往连接原始数据及与其对应的DOM元素。在Knockout中，ViewModel基本**是**数据，Model和ViewModel之间的连线是很模糊的。这种分化的缺乏使得Knockout更灵活，但也更可能导致复杂的ViewModels。
 
-- **What makes Vue.js different from React.js?**
+- **是什么使得Vue.js不同于React.js?**
 
-  React.js and Vue.js do have some similarity in that they both provide reactive & composable View components. However the internal implementation is fundamentally different. React is built upon a virtual DOM - an in-memory representation of what the actual DOM should look like. Data in React is largely immutable and DOM manipulations are calculated via diffing. On the contrary data in Vue.js is mutable and stateful by default, and changes are triggered through events. Instead of a virtual DOM, Vue.js uses the actual DOM as the template and keeps references to actual nodes for data bindings.
+  React.js和Vue.js确实有一些相似——它们都提供反射和组合视图组件。然而，它们的内部实现是完全不同的。React是基于虚拟DOM —— 在内存中的表述DOM看起来应该是怎样的。React中的数据大部分是不变的，而且DOM操作通过比较来计算的。与之相反Vue.js中的数据默认情况下是可变且优雅的，变更通过事件触发。相比于虚拟DOM，Vue.js使用实际的DOM作为模板，并且保持对真实节点的引用来进行数据绑定。
 
-  The virtual-DOM approach provides a functional way to describe your view at any point of time, which is really nice. Because it doesn't use observables and re-renders the entire app on every update, the view is by definition guaranteed to be in sync with the data. It also opens up possiblities to isomorphic JavaScript applications.
+  虚拟DOM的方法提供了一个功能性的方式以便在任何时候描述视图，这确实很好。因为它不使用观测值，且不需要为每个更新重新渲染整个应用，视图通过定义保证与数据保持同步。它也开辟了与JavaScript应用同构的可能性。
 
-  Overall I'm a big fan of React's design philosophy myself. But one issue with React is that your logic and your view are tightly knit together. For some developers this is a bonus, but for designer/developer hybrids like me, having a template makes it much easier to think visually about the design and CSS. JSX mixed with JavaScript logic breaks that visual model I need to map the code to the design. In contrast, Vue.js pays the cost of a lightweight DSL (directives) so that we have a visually scannable template and with logic encapsulated into directives and filters.
+  总的来说我自己就是React设计理念的忠实粉丝。但React有一个问题就是你的逻辑和视图是紧密结合在一起的。对于部分开发者来说这是件让人高兴的事，但对那些像我一样设计/开发混合进行的人来说，更希望能有一个模板，它能够更容易地在视觉上考虑设计和CSS。JSX和JavaScript逻辑的混合打破了我映射代码到设计的视觉模型。相反，Vue.js扮演了一个轻量级的DSL(指令型的) 的角色，这样我们有了一个直观的扫描模板，且能够将逻辑封装进指令和过滤器中。
 
-  Another issue with React is that because DOM updates are completely delegated to the Virtual DOM, it's a bit tricky when you actually **want** to control the DOM yourself (although theoretically you can, you'd be essentially working against the library when you do that). For applications that needs complex time-choreographed animations, this can become a pretty annoying restriction. On this front, Vue.js allows for more flexibility and there are [multiple FWA/Awwwards winning sites](https://github.com/yyx990803/vue/wiki/Projects-Using-Vue.js#interactive-experiences) built with Vue.js.
+  React的另一个问题是：由于DOM更新完全下放给虚拟DOM，当你真的**想**自己控制DOM是就有点棘手了（虽然理论上你可以，但这样做时你本质上在对抗库原本的原则）。对于需要复杂时间控制的动画应用来说这就变成了一项很讨人厌的限制。在这方面，Vue.js允许更多的灵活性并且有不少用Vue.js构建的事例[一些FWA/Awwwards获奖站点](https://github.com/yyx990803/vue/wiki/Projects-Using-Vue.js#interactive-experiences)
 
-- **I want to help!**
+- **我要提供帮助!**
 
-    Great! Read the [contribution guide](https://github.com/yyx990803/vue/blob/master/CONTRIBUTING.md) and join discussions on IRC (#vuejs).
\ No newline at end of file
+  很好! 阅读 [贡献指导](https://github.com/yyx990803/vue/blob/master/CONTRIBUTING.md) 并加入IRC上的讨论 (#vuejs).
\ No newline at end of file
diff --git a/source/guide/filters.md b/source/guide/filters.md
index 03e74b398c..0422b84022 100644
--- a/source/guide/filters.md
+++ b/source/guide/filters.md
@@ -1,39 +1,39 @@
-title: Filters
+title: 过滤器
 type: guide
 order: 4
 ---
 
-## Synopsis
+## 摘要
 
-A Vue.js filter is essentially a function that takes a value, processes it, and then returns the processed value. In the markup it is denoted by a single pipe (`|`) and can be followed by one or more arguments:
+一个 Vue.js 的过滤器本质上是一个函数，这个函数会接收一个值，将其处理并返回。它被标记在一个竖线 (`|`) 之后，并可以跟随一个或多个参数：
 
 ``` html
 <element directive="expression | filterId [args...]"></element>
 ```
 
-## Examples
+## 示例
 
-Filters must be placed at the end of a directive's value:
+过滤器必须放置在一个指令的值的最后：
 
 ``` html
 <span v-text="message | capitalize"></span>
 ```
 
-You can also use them inside mustache-style bindings:
+你也可以用在 mustache 风格的绑定的内部：
 
 ``` html
 <span>&#123;&#123;message | uppercase&#125;&#125;</span>
 ```
 
-Multiple filters can be chained together:
+可以把多个过滤器链在一起：
 
 ``` html
 <span>&#123;&#123;message | lowercase | reverse&#125;&#125;</span>
 ```
 
-## Arguments
+## 参数
 
-Some filters can take optional arguments. Simply add arguments separated by spaces:
+一些过滤器是可以附带参数的。只需用空格分隔开：
 
 ``` html
 <span>&#123;&#123;order | pluralize st nd rd th&#125;&#125;</span>
@@ -43,6 +43,6 @@ Some filters can take optional arguments. Simply add arguments separated by spac
 <input v-on="keyup: submitForm | key enter">
 ```
 
-For their specific use of the above examples see the [full list of built-in filters](/api/filters.html).
+上述示例的具体用法参见[完整的内建过滤器列表](../api/filters.html)。
 
-Now that you know what directives and filters are, let's get our hands dirty and try to [display a list of items](/guide/list.html).
\ No newline at end of file
+现在你已经了解了指令和过滤器，接下来我们趁热打铁[展示一个列表](../guide/list.html)吧。
\ No newline at end of file
diff --git a/source/guide/forms.md b/source/guide/forms.md
index b36d78dcf8..23b9246e07 100644
--- a/source/guide/forms.md
+++ b/source/guide/forms.md
@@ -1,13 +1,13 @@
-title: Handling Forms
+title: 处理表单
 type: guide
 order: 7
 ---
 
-## The Basics
+## 基本用法
 
-You can use the `v-model` directive to create two-way data bindings on form input elements. It automatically picks the correct way to update the element based on the input type.
+你可以在表单的 input 元素上使用 `v-model` 指令来创建双向数据绑定。它会根据 input type 自动选取正确的方式更新元素。
 
-**Example**
+**示例**
 
 ``` html
 <form id="demo">
@@ -61,7 +61,7 @@ new Vue({
 })
 ```
 
-**Result**
+**效果**
 
 <form id="demo"><p><input type="text" v-model="msg"> {&#123;msg&#125;}</p><p><input type="checkbox" v-model="checked"> {&#123;checked ? &quot;yes&quot; : &quot;no&quot;&#125;}</p><p><input type="radio" v-model="picked" name="picked" value="one"><input type="radio" v-model="picked" name="picked" value="two"> {&#123;picked&#125;}</p><p><select v-model="selected"><option>one</option><option>two</option></select> {&#123;selected&#125;}</p><p><select v-model="multiSelect" multiple><option>one</option><option>two</option><option>three</option></select>{&#123;multiSelect&#125;}</p><p>data:<pre style="font-size:13px;background:transparent;line-height:1.5em">{&#123;$data | json 2&#125;}</pre></p></form>
 <script>
@@ -77,34 +77,34 @@ new Vue({
 })
 </script>
 
-## Lazy Updates
+## 懒更新
 
-By default, `v-model` syncs the input with the data after each `input` event. You can add a `lazy` attribute to change the behavior to sync after `change` events:
+默认情况下，`v-model` 会在每个 `input` 事件之后同步输入的数据。你可以添加一个 `lazy` 特性，将其改变为在每个 `change` 事件之后才完成同步。
 
 ``` html
 <!-- synced after "change" instead of "input" -->
 <input v-model="msg" lazy>
 ```
 
-## Casting Value as Number
+## 当做数来处理
 
-If you want user input to be automatically persisted as numbers, you can add a `number` attribute to your `v-model` managed inputs:
+如果你希望用户的输入自动处理为一个数，你可以在 `v-model` 所在的 input 上添加一个 `number` 特性。
 
 ``` html
 <input v-model="age" number>
 ```
 
-## Dynamic Select Options
+## 动态 select 选项
 
-When you need to dynamically render a list of options for a `<select>` element, it's recommended to use an `options` attribute together with `v-model`:
+当你需要为一个 `<select>` 元素动态渲染列表选项时，我们推荐 `options` 和 `v-model` 特性配合使用：
 
 ``` html
 <select v-model="selected" options="myOptions"></select>
 ```
 
-In your data, `myOptions` should be an keypath/expression that points to an Array to use as its options. The Array can contain plain strings, or contain objects.
+在你的数据里，`myOptions` 应该是一个代表选项数组的路径/表达式。该数组可以包含普通字符串或对象。
 
-The object can be in the format of `{text:'', value:''}`. This allows you to have the option text displayed differently from its underlying value:
+该数组里对象的格式可以是 `{text:'', value:''}`。这允许你把展示的文字和其背后对应的值区分开来。
 
 ``` js
 [
@@ -113,7 +113,7 @@ The object can be in the format of `{text:'', value:''}`. This allows you to hav
 ]
 ```
 
-Will render:
+会渲染成：
 
 ``` html
 <select>
@@ -122,7 +122,8 @@ Will render:
 </select>
 ```
 
-Alternatively, the object can be in the format of `{ label:'', options:[...] }`. In this case it will be rendered as an `<optgroup>`:
+<!-- Alternatively, the object can be in the format of `{ label:'', options:[...] }`. In this case it will be rendered as an `<optgroup>`:
+-->另外，该数组里对象的格式也可以是 `{label:'', options:[...]}`。这样的数据会被渲染成为一个 `<optgroup>`：
 
 ``` js
 [
@@ -131,7 +132,7 @@ Alternatively, the object can be in the format of `{ label:'', options:[...] }`.
 ]
 ```
 
-Will render:
+会渲染成：
 
 ``` html
 <select>
@@ -146,4 +147,4 @@ Will render:
 </select>
 ```
 
-Next: [Computed Properties](/guide/computed.html).
\ No newline at end of file
+接下来：[可推导的属性](../guide/computed.html).
\ No newline at end of file
diff --git a/source/guide/index.md b/source/guide/index.md
index e24f21ffb5..f4680c0754 100644
--- a/source/guide/index.md
+++ b/source/guide/index.md
@@ -1,113 +1,114 @@
-title: Getting Started
+title: 起步
 type: guide
 order: 2
 ---
 
-## Introduction
+## 介绍
 
-Vue.js is a library for building interactive web interfaces.
+Vue.js 是一个用于创建 web 交互界面的库。
 
-Technically, Vue.js is focused on the [ViewModel](#ViewModel) layer of the MVVM pattern. It connects the [View](#View) and the [Model](#Model) via two way data bindings. Actual DOM manipulations and output formatting are abstracted away into [Directives](#Directives) and [Filters](#Filters).
+从技术角度讲，Vue.js 专注于 MVVM 模型的 [ViewModel](#ViewModel) 层。它通过双向数据绑定把 [View](#View) 层和 [Model](#Model) 层连接了起来。实际的 DOM 封装和输出格式都被抽象为了 [Directives](#Directives) 和 [Filters](#Filters)。
 
-Philosophically, the goal is to provide the benefits of reactive data binding and composable view components with an API that is as simple as possible. It is not a full-blown framework - it is designed to be a view layer that is simple and flexible. You can use it alone for rapid prototyping, or mix and match with other libraries for a custom front-end stack. It's also a natural fit for no-backend services such as Firebase.
+从哲学角度讲，我们希望创造的价值，在于通过一个尽量简单的 API 产生可反映的数据绑定和可组合的视图组件。它不是一个大而全的框架——它为简单灵活的视图层而生。您可以独立使用它快速开发原型、也可以混合别的库做更多的事情。它同时天然的适用于诸如 Firebase 的 no-backend 服务。
 
-Vue.js' API is heavily influenced by [AngularJS], [KnockoutJS], [Ractive.js] and [Rivets.js]. Despite the similarities, I believe Vue.js offers a valuable alternative to these existing libraries by finding a sweetspot between simplicity and functionality.
+Vue.js 的 API 设计深受 [AngularJS]、[KnockoutJS]、[Ractive.js] 和 [Rivets.js] 的影响。尽管有不少雷同，但我们相信 Vue.js 能够通过在简约和功能两者之间的巧妙契合，体现出其特殊的价值。
 
-Even if you are already familiar with some of these terms, it is recommended that you go through the following concepts overview because your notion of these terms might be different from what they mean in the Vue.js context.
+即便您已经熟悉了一些这类的库或框架，我们还是推荐您继续阅读接下来的概览，因为您对它们的认识也许和 Vue.js 中的情景不尽相同。
 
-## Concepts Overview
+## 概览
 
 ### ViewModel
 
-An object that syncs the Model and the View. In Vue.js, every Vue instance is a ViewModel. They are instantiated with the `Vue` constructor or its sub-classes:
+一个同步 Model 和 View 的对象。在 Vue.js 中，每个 Vue 实例都是一个 ViewModel。它们是通过构造函数 `Vue` 或其子类被初始化出来的。
 
 ```js
 var vm = new Vue({ /* options */ })
 ```
 
-This is the primary object that you will be interacting with as a developer when using Vue.js. For more details see [The Vue Constructor](/api/).
+这是您作为一个开发者在使用 Vue.js 时主要打交道的对象。更多的细节请移步至[Vue 构造函数](../api/)。
 
-### View
+### 视图 (View)
 
-The actual DOM that is managed by Vue instances.
+实际被 Vue 实例管理的 DOM。
 
 ```js
 vm.$el // The View
 ```
 
-Vue.js uses DOM-based templating. Each Vue instance is associated with a corresponding DOM element. When a Vue instance is created, it recursively walks all child nodes of its root element while setting up the necessary data bindings. After the View is compiled, it becomes reactive to data changes.
+Vue.js 使用基于 DOM 的模板。每个 Vue 实例都关联着一个相应的 DOM 元素。当一个 Vue 实例被创建时，它会递归遍历根元素的所有子结点，同时完成必要的数据绑定。当这个视图被编译之后，它就会自动反映数据的变化。
 
-When using Vue.js, you rarely have to touch the DOM yourself except in custom directives (explained later). View updates will be automatically triggered when the data changes. These view updates are highly granular with the precision down to a textNode. They are also batched and executed asynchronously for greater performance.
+在使用 Vue.js 时，除了自定义的指令 (directives) 您几乎不必直接接触 DOM (稍后会有解释)。当数据发生变化时，视图将会自动触发更新。这些更新的颗粒度是精确到 textNode 的。同时为了更好的性能，这些更新是批量异步执行的。
 
-### Model
+### 模型 (Model)
 
-A slightly modified plain JavaScript object.
+一个轻微改动过的普通 JavaScript 对象。
 
 ```js
 vm.$data // The Model
 ```
 
-In Vue.js, models are simply plain JavaScript objects, or **data objects**. You can manipulate their properties and Vue instances that are observing them will be notified of the changes. Vue.js achieves transparent reactivity by converting the properties on data objects into ES5 getter/setters. There's no need for dirty checking, nor do you have to explicitly signal Vue to update the View. Whenever the data changes, the View is updated on the next frame.
+Vue.js 中的模型就是普通的 JavaScript 对象——也可以称为**数据对象**。你可以操作它们的属性，同时 Vue 实例观察到这些属性的变化时也会被提示。Vue.js 把数据对象的属性都转换成了 ES5 中的 getter/setters，以此达到无副作用的数据观察效果。无需 dirty checking，也不需要刻意给 Vue 任何更新视图的信号。每当数据变化时，视图都会在下一帧自动更新。
 
-Vue instances proxy all properties on data objects they observe. So once an object `{ a: 1 }` has been observed, both `vm.$data.a` and `vm.a` will return the same value, and setting `vm.a = 2` will modify `vm.$data`.
+Vue 实例代理了它们观察到的数据对象的所有属性。所以一旦一个对象 `{ a: 1 }` 被观察，那么 `vm.$data.a` 和 `vm.a` 将会返回相同的值，而设置 `vm.a = 2` 则也会修改 `vm.$data`。
 
-The data objects are mutated in place, so modifying it by reference has the same effects as modifying `vm.$data`. This makes it possible for multiple Vue instances to observe the same piece of data. In larger applications it is also recommended to treat Vue instances as pure views, and externalize the data manipulation logic into a more discrete store layer.
+数据对象有时是突变的，所以修改数据的引用和修改 `vm.$data` 具有相同的效果。这也意味着多个 Vue 实例可以观察同一份数据。在较大型的应用程序中，我们也推荐将 Vue 实例作为纯粹的视图看待，同时把数据处理逻辑放在更独立的外部数据层。
 
-One caveat here is that once the observation has been initiated, Vue.js will not be able to detect newly added or deleted properties. To get around that, observed objects are augmented with `$add` and `$delete` methods.
+值得提醒的是，一旦数据被观察，Vue.js 就不会再侦测到新加入或删除的属性了。作为弥补，我们会为被观察的对象增加 `$add` 和 `$delete` 方法。
 
-### Directives
+### 指令 (Directives)
 
-Prefixed HTML attributes that tell Vue.js to do something about a DOM element.
+带特殊前缀的 HTML 特性，可以让 Vue.js 对一个 DOM 元素做各种处理。
 
 ```html
 <div v-text="message"></div>
 ```
 
-Here the div element has a `v-text` directive with the value `message`. What it does is telling Vue.js to keep the div's textContent in sync with the Vue instance's `message` property.
+这里的 div 元素有一个 `v-text` 指令，其值为 `message`。Vue.js 会让该 div 的文本内容是和 Vue 实例中的 `message` 属性值保持一致。
 
-Directives can encapsulate arbitrary DOM manipulations. For example `v-attr` manipulates an element's attributes, `v-repeat` clones an element based on an Array, `v-on` attaches event listeners... we will cover them later.
+Directives 可以封装任何 DOM 操作。比如 `v-attr` 会操作一个元素的特性；`v-repeat` 会基于一个数组克隆某个元素；`v-on` 会绑定事件等。稍后会有更多的介绍。
 
-### Mustache Bindings
+### Mustache 风格的绑定
 
-You can also use mustache-style bindings, both in text and in attributes. They are translated into `v-text` and `v-attr` directives under the hood. For example:
+你也可以使用 mustache 风格的绑定，不管在文本中还是在特性中。它们在底层会被转换成 `v-text` 和 `v-attr` 的指令。比如：
 
 ```html
 <div id="person-&#123;&#123;id&#125;&#125;">Hello &#123;&#123;name&#125;&#125;!</div>
 ```
 
-Although it is convenient, there are a few things you need to be aware of:
+这很方便，不过有一些注意事项：
 
-<p class="tip">The `src` attribute on an `<image>` element makes an HTTP request when a value is set, so when the template is first parsed it will result in a 404. In this case `v-attr` is preferred.</p>
+<p class="tip">一个 `<image>` 的 `src` 特性在赋值时会产生一个 HTTP 请求，所以当模板在第一次被解析时会产生一个 404 请求。这种情况下更适合用 `v-attr`。</p>
 
-<p class="tip">Internet Explorer will remove invalid inline `style` attributes when parsing HTML, so always use `v-style` when binding inline CSS if you want to support IE.</p>
+<p class="tip">Internet Explorer 在解析 HTML 时会移除非法的内联 `style` 特性，所以如果你想支持 IE，请在绑定内联 CSS 的时候始终使用 `v-style`。</p>
 
-You can use triple mustaches for unescaped HTML, which translates to `v-html` internally:
+
+你可以使用三对花括号来回避 HTML 代码，而这种写法会在底层转换为 `v-html`：
 
 ``` html
 {&#123;&#123; safeHTMLString &#125;&#125;}
 ```
 
-However, this can open up windows for potential XSS attacks, therefore it is suggested that you only use triple mustaches when you are absolutely sure about the security of the data source, or pipe it through a custom filter that sanitizes untrusted HTML.
+不过这种用法会留下 XSS 攻击的隐患，所以建议只对绝对信任的数据来源使用三对花括号的写法，或者先通过自定义的过滤器 (filter) 对不可信任的 HTML 进行过滤。
 
-Finally, you can add `*` to your mustache bindings to indicate a one-time only interpolation, which does not react to data changes:
+最后，你可以在你的 mustache 绑定里加入 `*` 来注明这是一个一次性撰写的数据，这样的话它就不会反应后续的数据变化：
 
 ``` html
 {&#123;* onlyOnce &#125;}
 ```
 
-### Filters
+### 过滤器 (Filters)
 
-Filters are functions used to process the raw values before updating the View. They are denoted by a "pipe" inside directives or bindings:
+过滤器是用于在更新视图之前处理原始值的函数。它们通过一个“管道”在指令或绑定中进行处理：
 
 ```html
 <div>&#123;&#123;message | capitalize&#125;&#125;</div>
 ```
 
-Now before the div's textContent is updated, the `message` value will first be passed through the `capitalize` function. For more details see [Filters in Depth](/guide/filters.html).
+这样在 div 的文本内容被更新之前，`message` 的值会先传给 `capitalizie` 函数处理。更多内容可移步至[深入了解过滤器 (Filters)](../guide/filters.html)。
 
-### Components
+### 组件 (Components)
 
-In Vue.js, every component is simply a Vue instance. Components form a nested tree-like hierarchy that represents your application interface. They can be instantiated by a custom constructor returned from `Vue.extend`, but a more declarative approach is registering them with `Vue.component(id, constructor)`. Once registered, they can be declaratively nested in other Vue instance's templates with the `v-component` directive:
+在 Vue.js，每个组件都是一个简单的 Vue 实例。一个树形嵌套的各种组件就代表了你的应用程序的各种接口。通过 `Vue.extend` 返回的自定义构造函数可以把这些组件实例化，不过更声明式的建议是通过 `Vue.component(id, constructor)` 注册这些组件。一旦组件被注册，它们就可以在 Vue 实例的模板中以声明的形式嵌套使用了。
 
 ``` html
 <div v-component="my-component">
@@ -115,9 +116,9 @@ In Vue.js, every component is simply a Vue instance. Components form a nested tr
 </div>
 ```
 
-This simple mechanism enables declarative reuse and composition of Vue instances in a fashion similar to [Web Components](http://www.w3.org/TR/components-intro/), without the need for latest browsers or heavy polyfills. By breaking an application into smaller components, the result is a highly decoupled and maintainable codebase. For more details, see [Component System](/guide/components.html).
+这个简单的机制使得我们可以以类似 [Web Components](http://www.w3.org/TR/components-intro/) 的声明形式对 Vue 实例进行复用和组合，无需最新版的浏览器或笨重的 polyfills。通过将一个应用程序拆分成简单的组件，代码库可以被尽可能的解耦，同时更易于维护。更多内容可移步至[组件系统](../guide/components.html)。
 
-## A Quick Example
+## 一个简单的例子
 
 ``` html
 <div id="demo">
@@ -174,11 +175,11 @@ var demo = new Vue({
 })
 </script>
 
-Also available on [jsfiddle](http://jsfiddle.net/yyx990803/yMv7y/).
+也可以通过 [jsfiddle](http://jsfiddle.net/yyx990803/yMv7y/) 查看。
 
-You can click on a todo to toggle it, or you can open your Browser's console and play with the `demo` object - for example, change `demo.title`, push a new object into `demo.todos`, or toggle a todo's `done` state.
+你可以点击一个 todo 来开关它，也可以打开你的浏览器命令行直接操作 `demo` 对象：比如改变 `demo.title`、向 `demo.todos` 里放入一个新的对象、或开关某个 todo 的 `done` 状态值。
 
-You probably have a few questions in mind now - don't worry, we'll cover them soon. Next up: [Directives in Depth](/guide/directives.html).
+也许你脑海中还有一些问题，别担心，我们稍后都会提到的。接下来可移步至：[深入了解指令 (Directives)](../guide/directives.html)。
 
 [AngularJS]: http://angularjs.org
 [KnockoutJS]: http://knockoutjs.com
diff --git a/source/guide/installation.md b/source/guide/installation.md
index 0ba09cf137..3b8202c184 100644
--- a/source/guide/installation.md
+++ b/source/guide/installation.md
@@ -1,4 +1,4 @@
-title: Installation
+title: 安装
 type: guide
 order: 1
 vue_version: 0.11.4
@@ -7,32 +7,32 @@ min_size: 55.18
 gz_size: 18.11
 ---
 
-> **Compatibility Note:** Vue.js does not support IE8 and below.
+> **兼容性提示：**Vue.js 不支持 IE8 及其以下版本。
 
-## Standalone
+## 直接下载
 
-Simply download and include with a script tag. `Vue` will be registered as a global variable.
+直接下载并写入一个 script 标签中，`Vue` 就会被注册为一个全局变量。
 
 <div id="downloads">
-<a class="button" href="https://raw.github.com/yyx990803/vue/{{vue_version}}/dist/vue.js" download>Development Version</a><span class="light info">{{dev_size}}kb, plenty of comments and debug/warning messages.</span>
+<a class="button" href="https://raw.github.com/yyx990803/vue/{{vue_version}}/dist/vue.js" download>开发者版本</a><span class="light info">{{dev_size}}kb, plenty of comments and debug/warning messages.</span>
 
-<a class="button" href="https://raw.github.com/yyx990803/vue/{{vue_version}}/dist/vue.min.js" download>Production Version</a><span class="light info">{{min_size}}kb minified / {{gz_size}}kb gzipped</span>
+<a class="button" href="https://raw.github.com/yyx990803/vue/{{vue_version}}/dist/vue.min.js" download>生产版本</a><span class="light info">{{min_size}}kb minified / {{gz_size}}kb gzipped</span>
 </div>
 
-Also available on [cdnjs](//cdnjs.cloudflare.com/ajax/libs/vue/{{vue_version}}/vue.min.js) (takes some time to sync so the latest version might not be available yet).
+也可以在 [cdnjs](http://cdnjs.cloudflare.com/ajax/libs/vue/{{vue_version}}/vue.min.js) 使用 (版本更新会略滞后)。
 
 ## NPM
 
 ``` bash
 $ npm install vue
-# for edge version:
+# 获得尖端版本：
 $ npm install yyx990803/vue#dev
 ```
 
 ## Bower
 
 ``` bash
-# only stable version is available through Bower
+# Bower 只能够获得稳定版本
 $ bower install vue
 ```
 
@@ -40,7 +40,7 @@ $ bower install vue
 
 ```js
 var Vue = require('yyx990803/vue')
-// for edge version:
+// 获得尖端版本：
 var Vue = require('yyx990803/vue@dev')
 ```
 
@@ -48,14 +48,14 @@ var Vue = require('yyx990803/vue@dev')
 
 ``` bash
 $ component install yyx990803/vue
-# for edge version:
+# 获得尖端版本：
 $ component install yyx990803/vue@dev
 ```
 
-## AMD Module Loaders
+## AMD 模块加载器
 
-The standalone downloads or versions installed via Bower are wrapped with UMD so they can be used directly as an AMD module.
+直接下载或通过 Bower 安装的版本可以用 UMD 包裹起来直接作为 AMD 模块使用。
 
-## Ready?
+## 准备好了吗？
 
-[Let's Get Started](/guide/).
\ No newline at end of file
+[走起！](../guide/)
\ No newline at end of file
diff --git a/source/guide/list.md b/source/guide/list.md
index d5aab1612b..7118644ab2 100644
--- a/source/guide/list.md
+++ b/source/guide/list.md
@@ -1,11 +1,11 @@
-title: Displaying a List
+title: 列表展示
 type: guide
 order: 5
 ---
 
-You can use the `v-repeat` directive to repeat a template element based on an Array of objects on the ViewModel. For every object in the Array, the directive will create a child Vue instance using that object as its `$data` object. These child instances inherit all data on the parent, so in the repeated element you have access to properties on both the repeated instance and the parent instance. In addition, you get access to the `$index` property, which will be the corresponding Array index of the rendered instance.
+你可以使用 `v-repeat` 指令基于ViewModel上的对象数组来重复显示模板元素。对于数组中的每个对象，该指令将创建一个以该对象作为其 `$data` 对象的子Vue实例。这些子实例继承父实例的所有数据，因此在重复的模板元素中你既可以访问子实例的属性，也可以访问父实例的属性。此外,你还可以访问 `$index` 属性，其表示所呈现的实例在对象数组中对应的索引。.
 
-**Example:**
+**示例:**
 
 ``` html
 <ul id="demo">
@@ -28,7 +28,7 @@ var demo = new Vue({
 })
 ```
 
-**Result:**
+**结果:**
 
 <ul id="demo"><li v-repeat="items" class="item-{&#123;$index&#125;}">{&#123;$index&#125;} - {&#123;parentMsg&#125;} {&#123;childMsg&#125;}</li></ul>
 <script>
@@ -44,9 +44,9 @@ var demo = new Vue({
 })
 </script>
 
-## Arrays of Primitive Values
+## 简单值数组
 
-For Arrays containing primitive values, you can access the value simply as `$value`:
+对于包含简单值的数组，你可用 `$value` 直接访问值:
 
 ``` html
 <ul id="tags">
@@ -65,7 +65,7 @@ new Vue({
 })
 ```
 
-**Result:**
+**结果:**
 <ul id="tags" class="demo"><li v-repeat="tags">{&#123;$value&#125;}</li></ul>
 <script>
 new Vue({
@@ -76,9 +76,9 @@ new Vue({
 })
 </script>
 
-## Using an identifier
+## 使用标识符
 
-Sometimes we might want to have more explicit variable access instead of implicitly falling back to parent scope. You can do that by providing an argument to the `v-repeat` directive and use it as the identifier for the item being iterated:
+有时我们可能想要更明确地访问变量而不是隐式地回退到父作用域。你可以通过提供一个参数给 `v-repeat` 指令并用它作为将被迭代项的标识符:
 
 ``` html
 <ul id="users">
@@ -101,7 +101,7 @@ new Vue({
 })
 ```
 
-**Result:**
+**结果:**
 <ul id="users" class="demo"><li v-repeat="user: users">{&#123;user.name&#125;} - {&#123;user.email&#125;}</li></ul>
 <script>
 new Vue({
@@ -115,9 +115,9 @@ new Vue({
 })
 </script>
 
-## Mutation Methods
+## 修改方法
 
-Under the hood, Vue.js intercepts an observed Array's mutating methods (`push()`, `pop()`, `shift()`, `unshift()`, `splice()`, `sort()` and `reverse()`) so they will also trigger View updates.
+在内部，Vue.js截获一个观察数组的修改方法（`unshift()`, `splice()`, `sort()` 和`reverse()`），因此它们也将触发视图更新。
 
 ``` js
 // the DOM will be updated accordingly
@@ -125,27 +125,27 @@ demo.items.unshift({ childMsg: 'Baz' })
 demo.items.pop()
 ```
 
-## Augmented Methods
+## 增加的方法
 
-Vue.js augments observed Arrays with two convenience methods: `$set()` and `$remove()`.
+Vue.js 给观察数组添加了两个便捷方法：`$set()` 和 `$remove()` 。
 
-You should avoid directly setting elements of a data-bound Array with indices, because those changes will not be picked up by Vue.js. Instead, use the agumented `$set()` method:
+你应该避免直接通过索引来设置数据绑定数组中的元素，因为这些改变将不能被Vue.js检出，而应该使用增加的 `$set()` 方法:
 
 ``` js
 // same as `demo.items[0] = ...` but triggers view update
 demo.items.$set(0, { childMsg: 'Changed!'})
 ```
 
-`$remove()` is just syntax sugar for `splice()`. It will remove the element at the given index. When the argument is not a number, `$remove()` will search for that value in the array and remove the first occurrence.
+`$remove()` 只不过是 `splice()`方法的语法糖。它将移除给定索引处的元素。当参数不是数值时，`$remove()` 将在数组中搜索该值并删除第一个发现的数组项.
 
 ``` js
 // remove the item at index 0
 demo.items.$remove(0)
 ```
 
-## Replacing an Array
+## 替换数组
 
-When you are using non-mutating methods, e.g. `filter()`, `concat()` or `slice()`, the returned Array will be a different instance. In that case, you can just replace the old Array with the new one:
+当你使用非修改方法，比如`filter()`, `concat()` 或 `slice()`，返回的数组将是一个不同的实例。在此情况下，你可以用新数组替换旧的数组W:
 
 ``` js
 demo.items = demo.items.filter(function (item) {
@@ -153,13 +153,13 @@ demo.items = demo.items.filter(function (item) {
 })
 ```
 
-You might think this will blow away the existing DOM and re-build everything. But worry not - Vue.js recognizes array elements that already have an associated Vue instance and will reuse those instances whenever possible.
+你可能会认为这将失去已有的DOM并重建一切。但别担心，Vue.js能够识别一个数组元素是否已有关联的Vue实例， 并只要有可能就会重用那些实例。
 
-## Using `track-by`
+## 使用 `track-by`
 
-In some cases, you might need to replace the Array with completely new objects - e.g. ones returned from an API call. If your data objects have a unique id property, then you can use a `track-by` attribute to give Vue.js a hint so that it can reuse an existing instance with data that has the same id.
+在某些情况下，你可能需要以全新的对象（比如API调用所返回的对象）去替换数组。如果你的数据对象有一个值唯一的id属性，那么你可以使 `track-by` 属性给Vue.js一个提示，那样它可以重用已有的具有相同id的数据实例。
 
-For example, if your data looks like this:
+例如，如果你的数据像这样:
 
 ``` js
 {
@@ -170,7 +170,7 @@ For example, if your data looks like this:
 }
 ```
 
-Then you can give the hint like this:
+那么你可以像这样给出提示:
 
 ``` html
 <div v-repeat="items" track-by="_uid">
@@ -178,9 +178,9 @@ Then you can give the hint like this:
 </div>
 ```
 
-## Iterating Through An Object
+## 遍历对象
 
-You can also use `v-repeat` to iterate through the properties of an Object. Each repeated instance will have a special property `$key`. For primitive values, you also get `$value` which is similar to primitive values in Arrays.
+你也可以使用 `v-repeat` 遍历一个对象的所有属性。每个重复的实例会有一个特殊的属性 `$key`。对于简单值，你也可以象访问数组中的简单值那样使用 `$value` 属性。
 
 ``` html
 <ul id="repeat-object">
@@ -211,7 +211,7 @@ new Vue({
 })
 ```
 
-**Result:**
+**结果:**
 <ul id="repeat-object" class="demo"><li v-repeat="primitiveValues">{&#123;$key&#125;} : {&#123;$value&#125;}</li><li>===</li><li v-repeat="objectValues">{&#123;$key&#125;} : {&#123;msg&#125;}</li></ul>
 <script>
 new Vue({
@@ -234,11 +234,11 @@ new Vue({
 })
 </script>
 
-<p class="tip">In ECMAScript 5 there is no way to detect when a new property is added to an Object, or when a property is deleted from an Object. To deal with that, observed objects will be augmented with two methods: `$add(key, value)` and `$delete(key)`. These methods can be used to add / delete properties from observed objects while triggering the desired View updates.</p>
+<p class="tip">在ECMAScript 5中，当一个新属性添加到对象中时，或者从对象中删除一个属性时，没有办法检测到。要解决这个问题，观察对象将被添加两个方法：`$add(key, value)` 和 `$delete(key)`。这些方法可以被用于在添加、删除观察对象的属性时触发期望的视图更新。</p>
 
-## Iterating Over a Range
+## 迭代值域
 
-`v-repeat` can also take an integer Number. In this case it will repeat the template that many times.
+`v-repeat` 也可以接受一个整数。在这种情况下，它将重复显示一个模板多次.
 
 ``` html
 <div id="range">
@@ -254,7 +254,7 @@ new Vue({
   }
 });
 ```
-**Result:**
+**结果:**
 <ul id="range" class="demo"><li v-repeat="val">Hi! {&#123;$index&#125;}</li></ul>
 <script>
 new Vue({
@@ -263,8 +263,8 @@ new Vue({
 });
 </script>
 
-## Array Filters
+## 数组过滤器
 
-Sometimes we only need to display a filtered or sorted version of the Array without actually mutating or resetting the original data. Vue provides two built-in filters to simplify such usage: `filterBy` and `orderBy`. Check out their [documentations](/api/filters.html#filterBy) for more details.
+有时候我们只需要显示一个数组的过滤或排序过的版本，而不需要实际改变或重置原始数据。Vue提供了两个内置的过滤器来简化此类需求： `filterBy` 和 `orderBy`。可查看[方法文档](../api/filters.html#filterBy)获得更多细节。
 
-Next up: [Listening for Events](/guide/events.html).
+接下来进入: [事件监听](../guide/events.html)部分。
diff --git a/source/guide/transitions.md b/source/guide/transitions.md
index 061a7dc2b5..ba7e39cda3 100644
--- a/source/guide/transitions.md
+++ b/source/guide/transitions.md
@@ -1,29 +1,29 @@
-title: Transitions
+title: 过渡效果
 type: guide
 order: 12
 ---
 
-With Vue.js' transition system you can apply automatic transition effects when elements are inserted into or removed from the DOM. There are two options to do so: defining CSS classes with transitions/animations, or by registering a definition object containing custom JavaScript hook functions.
+通过Vue.js的过渡系统，在节点插入/移除DOM的过程中，你可以轻松的运用自动过渡效果。这里有两个方式可以使用过渡系统：定义带有过渡效果/动画的css class，或者注册一个包含自定义JavaScript钩子函数的对象。
 
-With the directive `v-transition="my-transition"` applied, Vue will:
+通过使用`v-transition="my-transition"`指令的运用，Vue将会：
 
-1. Try to find a JavaScript transtion definition registered either through `Vue.transition(id, def)` or passed in with the `transitions` option, with the id `"my-transition"`. If it finds it, it will use that definition object to perform the custom JavaScript based transition.
+1. 试着找到一个id为`"my-transition"`,并且通过`Vue.transition(id, def)`或经过`transitions`选项处理的Javascript过渡定义。当找到时，Vue将会使用该定义对象执行自定义的JavaScript过渡。
 
-2. If no custom JavaScript transition is found, it will automatically sniff whether the target element has CSS transitions or CSS animations applied, and add/remove the CSS classes at the appropriate times.
+2. 如果没有找到自定义的Javacript过渡定义，那么Vue将会自动发现使用了CSS过渡/动画效果的目标元素，并在适当的时机添加/移除CSS class。
 
-3. If no transitions/animations are detected, the DOM manipulation is executed on next frame.
+3. 如果没有检测到过渡/动画，那么就会在下一帧直接执行DOM操作
 
-<p class="tip">All Vue.js transitions are triggered only if the DOM manipulation was applied by Vue.js, either through built-in directives, e.g. `v-if`, or through Vue instance methods, e.g. `vm.$appendTo()`.</p>
+<p class="tip">所有的Vue.js过渡效果只会在Vue.js执行DOM操作时才会被触发；或者通过内建指令集，例如`v-if`；或者通过Vue实例方法，例如`vm.$appendTo()`</p>
 
-## CSS Transitions
+## CSS 过渡效果
 
-A typical CSS transition looks like this:
+一个典型的CSS过渡效果定义如下：
 
 ``` html
 <p class="msg" v-if="show" v-transition="expand">Hello!</p>
 ```
 
-You also need to define CSS rules for `.expand-enter` and `.expand-leave` classes:
+你需要给`.expand-enter` 和 `.expand-leave`定义CSS规则：
 
 ``` css
 .msg {
@@ -65,28 +65,28 @@ new Vue({
 })
 </script>
 
-The classes being toggled are based on the value of your `v-transition` directive. In the case of `v-transition="fade"`, the classes being toggled will be `.fade-enter` and `.fade-leave`. When no value is provided they will default to `.v-enter` and `.v-leave`.
+这些class根据`v-transition`指令指定的值进行触发。在指定`v-transition="fade"`这个例子中，通过`.fade-enter`和`.fade-leave`来触发class变换。当未指定值的时候，则使用默认`.v-enter`和`.v-leave`
 
-When the `show` property changes, Vue.js will insert or remove the `<p>` element accordingly, and apply transition classes as specified below:
+当`show`属性发生变化，Vue.js依据其变化来插入/移除`<p>`元素，并使用过渡class，具体如下：
 
-- When `show` becomes false, Vue.js will:
-  1. Apply `v-leave` class to the element to trigger the transition;
-  2. Wait for the transition to finish; (listening to a `transitionend` event)
-  3. Remove the element from the DOM and remove `v-leave` class.
+- 当`show`为false时，Vue.js将会：
+  1. 将`v-leave`类应用于元素并触发过渡效果；
+  2. 等待过渡效果执行完毕； (通过监听一个`transitionend`事件)
+  3. 从DOM中移除节点并移除class `v-leave`.
 
-- When `show` becomes true, Vue.js will:
-  1. Apply `v-enter` class to the element;
-  2. Insert it into the DOM;
-  3. Force a CSS layout so `v-enter` is actually applied;
-  4. Remove the `v-enter` class to trigger a transition back to the element's original state.
+- 当`show`为true时，Vue.js将会：
+  1. 将class`v-enter`应用于节点上；
+  2. 将节点插入DOM；
+  3. 触发CSS布局变化，`v-enter`定义的效果将会被自动应用；
+  4. 移除class`v-enter`，触发节点过渡效果，回到节点默认状态。
 
-<p class="tip">When multiple elements are being transitioned together, Vue.js batches them and only applies one forced layout.</p>
+<p class="tip">当多个节点同时触发过渡效果时，Vue.js将会进行批量处理，只触发一次布局修改</p>
 
-## CSS Animations
+## CSS 动画
 
-CSS animations are applied in the same way with CSS transitions, the difference being that `v-enter` is not removed immediately after the element is inserted, but on an `animationend` callback.
+CSS 动画通过与CSS过渡效果一样的方式进行调用，区别就是动画中`v-enter`并不会在节点插入DOM后马上移除，而是在`animationend`回调中移除
 
-**Example:** (omitting prefixed CSS rules here)
+**示例：** (省略了css前缀的规则)
 
 ``` html
 <p class="animated" v-if="show" v-transition="bounce">Look at me!</p>
@@ -199,9 +199,9 @@ new Vue({
 })
 </script>
 
-## JavaScript Functions
+## Javascript 方法
 
-The following example registers a custom JavaScript transition definition using jQuery:
+以下的例子中，使用了jQuery注册一个自定义Javascript的过渡效果：
 
 ``` js
 Vue.transition('fade', {
@@ -232,11 +232,9 @@ Vue.transition('fade', {
   }
 })
 ```
-
-Then you can use it by providing the transition id to `v-transition`. Note this has higher priority than CSS transitions.
+之后你就可以通过给`v-transition`指定过渡ID来应用。注意，通过Javascript声明的过渡比CSS过渡优先级高。
 
 ``` html
 <p v-transition="fade"></p>
 ```
-
-Next: [Building Larger Apps](/guide/application.html).
\ No newline at end of file
+下一节：[创建大型应用](../guide/application.html).
\ No newline at end of file
diff --git a/source/perf/index.md b/source/perf/index.md
index 01953b6cbf..add5b70900 100644
--- a/source/perf/index.md
+++ b/source/perf/index.md
@@ -1,14 +1,14 @@
-title: Performance Comparisons
+title: 性能对比
 ---
 
-## TodoMVC Benchmark
+## TodoMVC 跑分
 
 > *Last Updated: 2014-10-12*
 
-Looking for the TodoMVC Benchmark? It's been removed because after discussion with some other framework authors we have agreed that:
+找不到 TodoMVC 跑分了？因为我们已经把它去掉了。在跟一些框架的作者交流之后，我们达成了以下几点共识：
 
-1. The original intention of these benchmarks were for comparing Browser performance rather than that of frameworks. The "synchrorously trigger an action xxx times" test routine doesn't reflect meaningful real world user actions.
+1. 这些跑分的初衷是比较浏览器们的性能，而不是比较框架们的性能。“同时触发一个动作多少次”的测试惯例并不能反映用户真实的使用场景。
 
-2. Due to internal implementation differences, frameworks that uses async rendering (e.g. Vue, Om, Mercury) gains the advantage by skipping part of the calculations that happened in the same event loop. The real world user experience doesn't demonstrate such dramatic difference.
+2. 由于内部实现的不同，(诸如 Vue、Om、Mercury 等) 采用异步方式渲染的框架由于跳过了同一个时间循环 (event loop) 的计算而在跑分中获益。而真实的用户体验并不会因此而变得不同。
 
-3. Overall this benchmark suite gave rise to more controversy than constructive insights, so it's been removed and I'd be happy to replace it with a more meaningful way to measure front-end performance.
\ No newline at end of file
+3. 总体上，跑分程序带来的争议多于它带来的建设性意见，所以我们把它删除了，同时我们也乐于将其改换为更有意义的测量前端性能的方式。
\ No newline at end of file
diff --git a/themes/vue/layout/layout.ejs b/themes/vue/layout/layout.ejs
index bd12605f08..c240eec5ad 100644
--- a/themes/vue/layout/layout.ejs
+++ b/themes/vue/layout/layout.ejs
@@ -5,19 +5,19 @@
         <meta charset="utf-8">
         <meta name="description" content="Vue.js - Intuitive, Fast and Composable MVVM for building interactive interfaces.">
         <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
-        <link href='http://fonts.googleapis.com/css?family=Source+Sans+Pro:400,600|Lato|Inconsolata' rel='stylesheet' type='text/css'>
-        <link rel="icon" href="/images/logo.png" type="image/x-icon">
+        <!-- <link href='http://fonts.googleapis.com/css?family=Source+Sans+Pro:400,600|Lato|Inconsolata' rel='stylesheet' type='text/css'> -->
+        <link rel="icon" href="<%- config.root %>images/logo.png" type="image/x-icon">
         <script>
             window.PAGE_TYPE = "<%- page.type %>"
         </script>
         <%- css(page.index ? 'css/index' : 'css/page') %>
         <%- partial('partials/ga') %>
-        <script src="/js/vue.min.js"></script>
+        <script src="<%- config.root %>js/vue.min.js"></script>
     </head>
     <body>
         <div id="mobile-bar">
             <a class="menu-button"></a>
-            <a class="logo" href="/"></a>
+            <a class="logo" href="<%- config.root %>"></a>
         </div>
         
         <% if (page.index) { %>
@@ -35,8 +35,8 @@
         </div>
 
         <% if (!page.index) { %>
-            <script src="/js/smooth-scroll.min.js"></script>
-            <script src="/js/common.js"></script>
+            <script src="<%- config.root %>js/smooth-scroll.min.js"></script>
+            <script src="<%- config.root %>js/common.js"></script>
         <% } %>
 
     </body>
diff --git a/themes/vue/layout/page.ejs b/themes/vue/layout/page.ejs
index 3b57ae1b9d..6164eead81 100644
--- a/themes/vue/layout/page.ejs
+++ b/themes/vue/layout/page.ejs
@@ -2,10 +2,10 @@
     <%- partial('partials/sidebar', { type: page.type, index: page.index }) %>
 <% } %>
 <div class="content <%- page.type ? page.type + ' with-sidebar' : '' %>">
-    <h1><%- page.title %><%- page.type === 'examples' ? ' Example' : '' %></h1>
+    <h1><%- page.type === 'examples' ? '示例: ' : '' %><%- page.title %></h1>
     <div id="ad">
         <script async type="text/javascript" src="//cdn.carbonads.com/carbon.js?zoneid=1673&serve=C6AILKT&placement=vuejs" id="_carbonads_js"></script>
     </div>
     <%- page.content %>
-    <div class="footer">Caught a mistake or want to contribute to the documentation? <a href="https://github.com/vuejs/vuejs.org" target="_blank">Fork this site on Github</a>!</div>
+    <div class="footer">发现了问题或想要贡献？来 Github 给 Vue.js <a href="https://github.com/vuejs/vuejs.org" target="_blank">英文站点</a>或<a href="https://github.com/Jinjiang/vuejs.org/tree/lang-zh" target="_blank">中文翻译</a>来个 Fork 吧！</div>
 </div>
\ No newline at end of file
diff --git a/themes/vue/layout/partials/blog.ejs b/themes/vue/layout/partials/blog.ejs
index 0005f2c8c1..f2e49401fc 100644
--- a/themes/vue/layout/partials/blog.ejs
+++ b/themes/vue/layout/partials/blog.ejs
@@ -7,10 +7,10 @@
 <h1 style="text-align: center; margin-bottom:.5em">The Vue.js Blog</h1>
 <% site.posts.sort('date', -1).each(function (post) { %>
     <div class="post">
-        <h2><a href="/<%- post.path %>"><%- post.title %></a></h2>
+        <h2><a href="<%- config.root %><%- post.path %>"><%- post.title %></a></h2>
         <h4><%- post.date.format('MMM D[,] YYYY') %></h4>
         <div><%- post.excerpt %></div>
-        <a href="/<%- post.path %>">... continue reading</a>
+        <a href="<%- config.root %><%- post.path %>">... continue reading</a>
     </div>
 <% }) %>
 </div>
\ No newline at end of file
diff --git a/themes/vue/layout/partials/header.ejs b/themes/vue/layout/partials/header.ejs
index ac6837fab0..8153c323b3 100644
--- a/themes/vue/layout/partials/header.ejs
+++ b/themes/vue/layout/partials/header.ejs
@@ -1,6 +1,6 @@
 <div id="header">
-    <a id="logo" href="/">
-        <img src="/images/logo.png">
+    <a id="logo" href="<%- config.root %>">
+        <img src="<%- config.root %>images/logo.png">
         <span>Vue.js</span>
     </a>
     <ul id="nav">
diff --git a/themes/vue/layout/partials/index.ejs b/themes/vue/layout/partials/index.ejs
index c72e8a251e..5e64a9e01b 100644
--- a/themes/vue/layout/partials/index.ejs
+++ b/themes/vue/layout/partials/index.ejs
@@ -10,18 +10,19 @@
 <div id="hero">
     <div class="inner">
         <ul id="nav">
-            <li><a href="/guide/" class="nav-link">Guide</a></li>
-            <li><a href="/api/" class="nav-link">API Reference</a></li>
-            <li><a href="/examples/" class="nav-link">Examples</a></li>
-            <li><a href="/blog/" class="nav-link">Blog</a></li>
+            <li><a href="<%- config.root %>guide/" class="nav-link">入门</a></li>
+            <li><a href="<%- config.root %>api/" class="nav-link">API 索引</a></li>
+            <li><a href="<%- config.root %>examples/" class="nav-link">示例</a></li>
+            <li><a href="http://vuejs.org/blog/" target="_blank" class="nav-link">Blog (英文)</a></li>
+            <li><a href="http://vuejs.org/" target="_blank" class="nav-link">English</a></li>
         </ul>
-        <img id="logo" src="/images/logo.png">
+        <img id="logo" src="<%- config.root %>images/logo.png">
         <h1>Vue.js</h1>
-        <p class="sub">MVVM Made Simple</p>
-        <p class="desc">Vue.js is a library for building interactive web interfaces. <br>It provides data-reactive components with a simple and flexible API.</p>
+        <p class="sub">精简的 MVVM</p>
+        <p class="desc">Vue.js 是一个用于创建 web 交互界面的库。<br>它具有简单而灵活的 API，创建出来的组件可以实时反映数据的变化。</p>
         <p class="buttons">
-            <a href="/guide/installation.html" class="button">Get Vue.js v<%- theme.vue_version %></a>
-            <a href="https://github.com/yyx990803/vue" target="_blank" class="button">Source on GitHub</a>
+            <a href="<%- config.root %>guide/installation.html" class="button">获取 Vue.js v<%- theme.vue_version %></a>
+            <a href="https://github.com/yyx990803/vue" target="_blank" class="button">源代码在 GitHub 上</a>
         </p>
         <ul id="social">
             <li><a href="https://twitter.com/share" class="twitter-share-button" data-lang="en" data-url="http://vuejs.org" data-text="Vue.js - MVVM made simple" data-via="vuejs">Tweet</a><script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0];if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src="https://platform.twitter.com/widgets.js";fjs.parentNode.insertBefore(js,fjs);}}(document,"script","twitter-wjs");</script></li>
@@ -30,11 +31,11 @@
             <li><g:plusone href="http://vuejs.org" size="medium"></g:plusone></li>
         </ul>
     </div>
-    <div class="down"><img src="/images/down.png"></div>
+    <div class="down"><img src="<%- config.root %>images/down.png"></div>
 </div>
 
 <div id="example">
-    <h2>10 Second Example</h2>
+    <h2>10 秒钟看懂 Vue.js</h2>
     <div class="block">
         <figure class="highlight lang-html"><table><tbody><tr><td class="gutter"><pre>1
 2
@@ -85,43 +86,61 @@
 <div id="features">
     <div class="feats">
         <div class="feat">
-            <h2><span class="icon simple"></span>Simple</h2>
-            <p>Write some HTML, grab some JSON, create a Vue instance, that's it.</p>
+            <h2><span class="icon simple"></span>简单</h2>
+            <p>写点 HTML，拿来 JSON，创建一个 Vue 示例，就这么简单。</p>
         </div>
         <div class="feat">
-            <h2><span class="icon fast"></span>Fast</h2>
-            <p>Precise and efficient async batch DOM updates.</p>
+            <h2><span class="icon fast"></span>快速</h2>
+            <p>以精确有效的异步批处理方式更新 DOM。</p>
         </div>
         <div class="feat">
-            <h2><span class="icon composable"></span>Composable</h2>
-            <p>Compose your application with decoupled, reusable components.</p>
+            <h2><span class="icon composable"></span>组合</h2>
+            <p>用解耦的、可复用的组件组合你的应用程序。</p>
         </div>
         <div class="feat">
-            <h2><span class="icon compact"></span>Compact</h2>
-            <p>~18kb min+gzip, no dependency.</p>
+            <h2><span class="icon compact"></span>紧凑</h2>
+            <p>~18kb min+gzip，且无依赖。</p>
         </div>
         <div class="feat">
-            <h2><span class="icon powerful"></span>Powerful</h2>
-            <p>Expressions & computed properties with transparent dependency tracking.</p>
+            <h2><span class="icon powerful"></span>强大</h2>
+            <p>表达式 & 无需声明依赖的可推导属性 (computed properties)。</p>
         </div>
         <div class="feat">
-            <h2><span class="icon module"></span>Module Friendly</h2>
-            <p>Install via NPM, Bower or Duo - leverage your favorite eco system!</p>
+            <h2><span class="icon module"></span>对模块友好</h2>
+            <p>可以通过 NPM、Bower 或 Duo 安装——无缝融入你的生命！</p>
         </div>
     </div>
 </div>
 <div id="why">
-    <h2>You should try it out if you like:</h2>
+    <h2>不妨试试看，如果你喜欢：</h2>
     <ul>
-        <li>Extendable Data bindings</li>
-        <li>Plain JS object models</li>
-        <li>API that simply makes sense</li>
-        <li>Build UI by composing components</li>
-        <li>Mix &amp; matching small libraries</li>
+        <li>可扩展的数据绑定</li>
+        <li>将普通的 JS 对象作为 model</li>
+        <li>简洁明了的 API</li>
+        <li>组件化 UI 构建</li>
+        <li>配合别的库使用</li>
     </ul>
 </div>
 <div id="footer">
-    <a class="start" href="/guide/index.html">Get Started</a>
-    <p>Released under the <a href="http://opensource.org/licenses/MIT" target="_blank">MIT License</a></p>
+    <a class="start" href="<%- config.root %>guide/index.html">现在开始学习 Vue.js</a>
+    <p>基于 <a href="http://opensource.org/licenses/MIT" target="_blank">MIT License</a> 发布</p>
+    <p>中文翻译:
+
+    <a href="https://github.com/etanxing" target="_blank">etanxing</a>
+    <a href="https://github.com/fengliu222" target="_blank">fengliu222</a>
+    <a href="https://github.com/Garfielt" target="_blank">Garfielt</a>
+    <a href="https://github.com/getive" target="_blank">getive</a>
+    <a href="https://github.com/kunth" target="_blank">kunth</a>
+    <a href="https://github.com/luin" target="_blank">luin</a>
+    <a href="https://github.com/nkCoding" target="_blank">nkCoding</a>
+    <!--a href="https://github.com/skyline0705" target="_blank">skyline0705</a-->
+    <a href="https://github.com/SoAanyip" target="_blank">SoAanyip</a>
+    <a href="https://github.com/Suixinlei" target="_blank">Suixinlei</a>
+    <a href="https://github.com/titancat" target="_blank">titancat</a>
+    <a href="https://github.com/XfLoops" target="_blank">XfLoops</a>
+
+    <a href="http://jiongks.name" target="_blank">勾三股四</a>
+
+    (<a href="https://github.com/Jinjiang/vuejs.org/tree/lang-zh" target="_blank">我要加入翻译!</a>)</p>
     <p>Copyright (c) <%- date(Date.now(), 'YYYY') %> <a href="http://evanyou.me" target="_blank">Evan You</a></p>
 </div>
\ No newline at end of file
diff --git a/themes/vue/layout/partials/main_menu.ejs b/themes/vue/layout/partials/main_menu.ejs
index 24ed194f76..aba8bb7601 100644
--- a/themes/vue/layout/partials/main_menu.ejs
+++ b/themes/vue/layout/partials/main_menu.ejs
@@ -1,5 +1,6 @@
-<li><a href="/guide/" class="nav-link<%- page.path.match(/guide/) ? ' current' : '' %>">Guide</a></li>
-<li><a href="/api/" class="nav-link<%- page.path.match(/api/) ? ' current' : '' %>">API Reference</a></li>
-<li><a href="/examples/" class="nav-link<%- page.path.match(/examples/) ? ' current' : '' %>">Examples</a></li>
-<li><a href="/blog/" class="nav-link<%- (page.path.match(/blog/) || is_post()) ? ' current' : '' %>">Blog</a></li>
-<li><a href="https://github.com/yyx990803/vue" target="_blank" class="nav-link">GitHub</a></li>
\ No newline at end of file
+<li><a href="<%- config.root %>guide/" class="nav-link<%- page.path.match(/guide/) ? ' current' : '' %>">入门</a></li>
+<li><a href="<%- config.root %>api/" class="nav-link<%- page.path.match(/api/) ? ' current' : '' %>">API 索引</a></li>
+<li><a href="<%- config.root %>examples/" class="nav-link<%- page.path.match(/examples/) ? ' current' : '' %>">示例</a></li>
+<li><a href="http://vuejs.org/blog/" target="_blank" class="nav-link<%- (page.path.match(/blog/) || is_post()) ? ' current' : '' %>">Blog (英文)</a></li>
+<li><a href="https://github.com/yyx990803/vue" target="_blank" class="nav-link">GitHub</a></li>
+<li><a href="http://vuejs.org/" target="_blank" class="nav-link<%- (page.path.match(/blog/) || is_post()) ? ' current' : '' %>">English</a></li>
\ No newline at end of file
diff --git a/themes/vue/layout/partials/sidebar.ejs b/themes/vue/layout/partials/sidebar.ejs
index d9c790ce76..89c899981d 100644
--- a/themes/vue/layout/partials/sidebar.ejs
+++ b/themes/vue/layout/partials/sidebar.ejs
@@ -6,9 +6,9 @@
         <h2><%- type.charAt(0).toUpperCase() + type.slice(1) %></h2>
         <ul class="menu-root">
             <% site.pages.find({type: type}).sort('order').each(function (p) { %>
-                <li><a href="/<%- p.path %>" class="sidebar-link<%- page.title === p.title ? ' current' : '' %>"><%- p.title %></a></li>
+                <li><a href="<%- config.root %><%- p.path %>" class="sidebar-link<%- page.title === p.title ? ' current' : '' %>"><%- p.title %></a></li>
             <% }) %>
-            <li><a href="http://legacy.vuejs.org">Looking for 0.10 docs?</a></li>
+            <li><a href="http://legacy.vuejs.org">旧版 0.10 文档</a></li>
             <li style="margin:10px 0 3px">
               <script data-gittip-username="yyx990803"
                 data-gittip-widget="button"
diff --git a/themes/vue/layout/post.ejs b/themes/vue/layout/post.ejs
index 2704e82303..c30729fd5f 100644
--- a/themes/vue/layout/post.ejs
+++ b/themes/vue/layout/post.ejs
@@ -7,7 +7,7 @@
         <ul>
         <% site.posts.sort('date', -1).limit(10).each(function (post) { %>
             <li>
-                <a href="/<%- post.path %>" class="sidebar-link<%- page.title === post.title ? ' current' : '' %>"><%- post.title %></a>
+                <a href="<%- config.root %><%- post.path %>" class="sidebar-link<%- page.title === post.title ? ' current' : '' %>"><%- post.title %></a>
             </li>
         <% }) %>
         <li style="margin:10px 0 3px">