diff --git a/src/v2/guide/render-function.md b/src/v2/guide/render-function.md
index 08f6597315..91764042f0 100644
--- a/src/v2/guide/render-function.md
+++ b/src/v2/guide/render-function.md
@@ -1,30 +1,30 @@
 ---
-title: Render Functions (En)
+title: Fonctions de rendu
 type: guide
 order: 15
 ---
 
-## Basics
+## Les bases
 
-<p class="tip">**Cette page est en cours de traduction française. Revenez une autre fois pour lire une traduction achevée ou [participez à la traduction française ici](https://github.com/vuejs-fr/vuejs.org).**</p><p>Vue recommends using templates to build your HTML in the vast majority of cases. There are situations however, where you really need the full programmatic power of JavaScript. That's where you can use the **render function**, a closer-to-the-compiler alternative to templates.</p>
+Vue vous recommande l'utilisation de templates pour construire votre HTML dans la grande majorité des cas. Il y a cependant des situations où vous aurez réellement besoin de toute la puissance programmatique de JavaScript. C'est là que vous pouvez utiliser les **fonctions de rendu**, une alternative aux templates qui est plus proche du compilateur.
 
-Let's dive into a simple example where a `render` function would be practical. Say you want to generate anchored headings:
+Examinons un exemple simple où une fonction `render` serait plus pratique. Imaginons que nous souhaitons générer des titres avec une ancre :
 
 ``` html
 <h1>
   <a name="hello-world" href="#hello-world">
-    Hello world!
+    Hello world !
   </a>
 </h1>
 ```
 
-For the HTML above, you decide you want this component interface:
+Pour le HTML ci-dessus, vous décidez d'utiliser cette interface de composant :
 
 ``` html
 <anchored-heading :level="1">Hello world!</anchored-heading>
 ```
 
-When you get started with a component that just generates a heading based on the `level` prop, you quickly arrive at this:
+Quand vous commencez avec un composant se basant sur la prop `level` pour simplement générer des niveaux de titre, vous arrivez rapidement à cela :
 
 ``` html
 <script type="text/x-template" id="anchored-heading-template">
@@ -63,16 +63,16 @@ Vue.component('anchored-heading', {
 })
 ```
 
-That template doesn't feel great. It's not only verbose, but we're duplicating `<slot></slot>` for every heading level and will have to do the same when we add the anchor element. The whole thing is also wrapped in a useless `div` because components must contain exactly one root node.
+Ce template ne semble pas génial. Il n'est pas uniquement verbeux, il duplique `<slot></slot>` dans tous les niveaux de titre et nous allons devoir refaire la même chose quand nous ajoutons l'élément ancre. Tout cela est également encapsulé dans une `div` inutile car un composant doit contenir exactement un seul nœud racine.
 
-While templates work great for most components, it's clear that this isn't one of them. So let's try rewriting it with a `render` function:
+Alors que les templates fonctionnent bien pour la plupart des composants, il est clair que celui-là n'est pas l'un d'entre eux. Aussi essayons de le réécrire avec une fonction `render` :
 
 ``` js
 Vue.component('anchored-heading', {
   render: function (createElement) {
     return createElement(
-      'h' + this.level,   // tag name
-      this.$slots.default // array of children
+      'h' + this.level,   // nom de balise
+      this.$slots.default // tableau des enfants
     )
   },
   props: {
@@ -84,29 +84,29 @@ Vue.component('anchored-heading', {
 })
 ```
 
-Much simpler! Sort of. The code is shorter, but also requires greater familiarity with Vue instance properties. In this case, you have to know that when you pass children without a `slot` attribute into a component, like the `Hello world!` inside of `anchored-heading`, those children are stored on the component instance at `$slots.default`. If you haven't already, **it's recommended to read through the [instance properties API](../api/#vm-slots) before diving into render functions.**
+C'est bien plus simple ! Le code est plus court mais demande une plus grande familiarité avec les propriétés d'une instance de Vue. Dans ce cas, vous devez savoir que lorsque vous passez des enfants dans attribut `slot` dans un composant, comme le `Hello world !` à l'intérieur de `anchored-heading`, ces enfants sont stockés dans l'instance du composant via la propriété `$slots.default`. Si vous ne l'avez pas encore fait, **il est recommandé d'en lire plus sur les [propriétés d'instance de l'API](../api/#vm-slots) avant d'entrer plus en profondeur dans les fonctions de rendu.**
 
-## `createElement` Arguments
+## Les arguments de `createElement`
 
-The second thing you'll have to become familiar with is how to use template features in the `createElement` function. Here are the arguments that `createElement` accepts:
+La seconde chose à laquelle vous allez devoir vous familiariser est la manière d'utiliser les fonctionnalités des templates avec la fonction `createElement`. Voici les arguments que la fonction `createElement` accepte :
 
 ``` js
 // @returns {VNode}
 createElement(
   // {String | Object | Function}
-  // An HTML tag name, component options, or function
-  // returning one of these. Required.
+  // Un nom de balise HTML, des options de composant, ou une fonction
+  // retournant l'un des deux. Requis.
   'div',
 
   // {Object}
-  // A data object corresponding to the attributes
-  // you would use in a template. Optional.
+  // Un objet de données correspondant aux attributs
+  // que vous souhaitez utiliser dans le template. Optionnel.
   {
-    // (see details in the next section below)
+    // (vu en détails dans la prochaine section)
   },
 
   // {String | Array}
-  // Children VNodes. Optional.
+  // Des VNodes enfants. Optionnel.
   [
     createElement('h1', 'hello world'),
     createElement(MyComponent, {
@@ -119,50 +119,50 @@ createElement(
 )
 ```
 
-### The Data Object In-Depth
+### L'objet de données dans le détail
 
-One thing to note: similar to how `v-bind:class` and `v-bind:style` have special treatment in templates, they have their own top-level fields in VNode data objects. This object also allows you to bind normal HTML attributes as well as DOM properties such as `innerHTML` (this would replace the `v-html` directive):
+Une chose est à noter : de la même manière que `v-bind:class` et `v-bind:style` ont un traitement spécial dans les templates, ils ont leurs propres champs dans les objets de données VNode. Cet objet vous permet également d'insérer des attributs HTML normaux ainsi que des propriétés du DOM comme `innerHTML` (cela remplace la directive `v-html`) :
 
 ``` js
 {
-  // Same API as `v-bind:class`
+  // Même API que `v-bind:class`
   'class': {
     foo: true,
     bar: false
   },
-  // Same API as `v-bind:style`
+  // Même API que `v-bind:style`
   style: {
     color: 'red',
     fontSize: '14px'
   },
-  // Normal HTML attributes
+  // Attributs HTML normaux
   attrs: {
     id: 'foo'
   },
-  // Component props
+  // Props des composants
   props: {
     myProp: 'bar'
   },
-  // DOM properties
+  // Propriétés du DOM
   domProps: {
     innerHTML: 'baz'
   },
-  // Event handlers are nested under "on", though
-  // modifiers such as in v-on:keyup.enter are not
-  // supported. You'll have to manually check the
-  // keyCode in the handler instead.
+  // La gestion d'évènements est regroupée sous `on` cependant
+  // les modificateurs comme `v-on:keyup.enter` ne sont pas
+  // supportés. Vous devez vérifier manuellement le code de touche
+  // dans le gestionnaire à la place.
   on: {
     click: this.clickHandler
   },
-  // For components only. Allows you to listen to
-  // native events, rather than events emitted from
-  // the component using vm.$emit.
+  // Pour les composants seulement. Vous permet d'écouter les
+  // évènements natifs, plutôt que ceux émis par
+  // le composant via `vm.$emit`.
   nativeOn: {
     click: this.nativeClickHandler
   },
-  // Custom directives. Note that the binding's
-  // oldValue cannot be set, as Vue keeps track
-  // of it for you.
+  // Directives personnalisées. Notez que la valeur `oldValue`
+  // de la liaison ne peut pas être affectée, car Vue la conserve
+  // pour vous.
   directives: [
     {
       name: 'my-custom-directive',
@@ -174,23 +174,23 @@ One thing to note: similar to how `v-bind:class` and `v-bind:style` have special
       }
     }
   ],
-  // Scoped slots in the form of
+  // Slots internes sous la forme
   // { name: props => VNode | Array<VNode> }
   scopedSlots: {
     default: props => createElement('span', props.text)
   },
-  // The name of the slot, if this component is the
-  // child of another component
+  // Le nom du slot, si ce composant est
+  // l'enfant d'un autre composant
   slot: 'name-of-slot'
-  // Other special top-level properties
+  // Autres propriétés spéciales de premier niveau
   key: 'myKey',
   ref: 'myRef'
 }
 ```
 
-### Complete Example
+### Exemple complet
 
-With this knowledge, we can now finish the component we started:
+Avec toutes ces informations, nous pouvons finir le composant que nous avons commencé :
 
 ``` js
 var getChildrenTextContent = function (children) {
@@ -203,7 +203,7 @@ var getChildrenTextContent = function (children) {
 
 Vue.component('anchored-heading', {
   render: function (createElement) {
-    // create kebabCase id
+    // créer un identifiant avec la kebab-case
     var headingId = getChildrenTextContent(this.$slots.default)
       .toLowerCase()
       .replace(/\W+/g, '-')
@@ -230,23 +230,23 @@ Vue.component('anchored-heading', {
 })
 ```
 
-### Constraints
+### Contraintes
 
-#### VNodes Must Be Unique
+#### Les VNodes doivent être uniques
 
-All VNodes in the component tree must be unique. That means the following render function is invalid:
+Tous les VNodes dans l'arbre des composants doivent être uniques. Cela signifie que les fonctions suivantes sont invalides :
 
 ``` js
 render: function (createElement) {
   var myParagraphVNode = createElement('p', 'hi')
   return createElement('div', [
-    // Yikes - duplicate VNodes!
+    // Aïe - VNodes dupliqués !
     myParagraphVNode, myParagraphVNode
   ])
 }
 ```
 
-If you really want to duplicate the same element/component many times, you can do so with a factory function. For example, the following render function is a perfectly valid way of rendering 20 identical paragraphs:
+Si vous souhaitez réellement dupliquer le même élément/composant plusieurs fois, vous pouvez le faire avec une fonction fabrique. Par exemple, la fonction de rendu suivante est parfaitement valide pour faire le rendu de 20 paragraphes identiques :
 
 ``` js
 render: function (createElement) {
@@ -258,20 +258,20 @@ render: function (createElement) {
 }
 ```
 
-## Replacing Template Features with Plain JavaScript
+## Remplacer les fonctionnalités de template en pur JavaScript
 
-### `v-if` and `v-for`
+### `v-if` et `v-for`
 
-Wherever something can be easily accomplished in plain JavaScript, Vue render functions do not provide a proprietary alternative. For example, in a template using `v-if` and `v-for`:
+Partout où quelque chose peut être accompli simplement en JavaScript, les fonctions de rendu de Vue ne fournissent pas d'alternative propriétaire. Par exemple, un template utilisant `v-if` et `v-for` :
 
 ``` html
 <ul v-if="items.length">
   <li v-for="item in items">{{ item.name }}</li>
 </ul>
-<p v-else>No items found.</p>
+<p v-else>Aucun élément trouvé.</p>
 ```
 
-This could be rewritten with JavaScript's `if`/`else` and `map` in a render function:
+Cela pourrait être réécrit avec les `if`/`else` et `map` du JavaScript dans une fonction de rendu
 
 ``` js
 render: function (createElement) {
@@ -280,14 +280,14 @@ render: function (createElement) {
       return createElement('li', item.name)
     }))
   } else {
-    return createElement('p', 'No items found.')
+    return createElement('p', 'Aucun élément trouvé.')
   }
 }
 ```
 
 ### `v-model`
 
-There is no direct `v-model` counterpart in render functions - you will have to implement the logic yourself:
+Il n'y a pas d'équivalent à `v-model` dans les fonctions de rendu. Vous devez implémenter la logique vous-même :
 
 ``` js
 render: function (createElement) {
@@ -306,19 +306,19 @@ render: function (createElement) {
 }
 ```
 
-This is the cost of going lower-level, but it also gives you much more control over the interaction details compared to `v-model`.
+C'est le prix à payer pour travailler au plus bas niveau, mais cela vous donne un meilleur contrôle sur le détail des interactions comparé à `v-model`.
 
-### Event & Key Modifiers
+### Modificateurs d'évènement et de code de touche
 
-For the `.capture` and `.once` event modifiers, Vue offers prefixes that can be used with `on`:
+Pour les modificateurs d'évènement `.capture` et `.once`, Vue offre des préfixes pouvant être utilisés dans `on`:
 
-| Modifier(s) | Prefix |
+| Modificateur(s) | Préfixes |
 | ------ | ------ |
 | `.capture` | `!` |
 | `.once` | `~` |
-| `.capture.once` or<br>`.once.capture` | `~!` |
+| `.capture.once` ou<br>`.once.capture` | `~!` |
 
-For example:
+Par exemple :
 
 ```javascript
 on: {
@@ -328,31 +328,31 @@ on: {
 }
 ```
 
-For all other event and key modifiers, no proprietary prefix is necessary, because you can simply use event methods in the handler:
+Pour tous les autres modificateurs d'évènement et de code de touche, aucun préfixe propriétaire n'est nécessaire car il suffit d'utiliser des méthodes d'évènement dans le gestionnaire :
 
-| Modifier(s) | Equivalent in Handler |
+| Modificateur(s) | Équivalence dans le gestionnaire |
 | ------ | ------ |
 | `.stop` | `event.stopPropagation()` |
 | `.prevent` | `event.preventDefault()` |
 | `.self` | `if (event.target !== event.currentTarget) return` |
-| Keys:<br>`.enter`, `.13` | `if (event.keyCode !== 13) return` (change `13` to [another key code](http://keycode.info/) for other key modifiers) |
-| Modifiers Keys:<br>`.ctrl`, `.alt`, `.shift`, `.meta` | `if (!event.ctrlKey) return` (change `ctrlKey` to `altKey`, `shiftKey`, or `metaKey`, respectively) |
+| Touches :<br>`.enter`, `.13` | `if (event.keyCode !== 13) return` (changez `13` en un [autre code de touche](http://keycode.info/) pour les autres modificateurs de code de touche) |
+| Modificateurs de Clés :<br>`.ctrl`, `.alt`, `.shift`, `.meta` | `if (!event.ctrlKey) return` (changez respectivement `ctrlKey` par `altKey`, `shiftKey`, ou `metaKey`) |
 
-Here's an example with all of these modifiers used together:
+Voici un exemple avec tous ces modificateurs utilisés ensemble :
 
 ```javascript
 on: {
   keyup: function (event) {
-    // Abort if the element emitting the event is not
-    // the element the event is bound to
+    // Annuler si l'élément qui émet l'évènement n'est pas
+    // l'élément auquel l'évènement est lié
     if (event.target !== event.currentTarget) return
-    // Abort if the key that went up is not the enter
-    // key (13) and the shift key was not held down
-    // at the same time
+    // Annuler si la touche relâchée n'est pas la touche
+    // Entrée (13) et si la touche `shift` n'est pas maintenue
+    // en même temps
     if (!event.shiftKey || event.keyCode !== 13) return
-    // Stop event propagation
+    // Arrêter la propagation d'évènement
     event.stopPropagation()
-    // Prevent the default keyup handler for this element
+    // Éviter la gestion par défaut de cet évènement pour cet élément
     event.preventDefault()
     // ...
   }
@@ -361,20 +361,20 @@ on: {
 
 ### Slots
 
-You can access static slot contents as Arrays of VNodes from [`this.$slots`](../api/#vm-slots):
+Vous pouvez accéder aux contenus des slots statiques en tant que tableaux de VNodes depuis [`this.$slots`](../api/#vm-slots) :
 
 ``` js
 render: function (createElement) {
-  // <div><slot></slot></div>
+  // `<div><slot></slot></div>`
   return createElement('div', this.$slots.default)
 }
 ```
 
-And access scoped slots as functions that return VNodes from [`this.$scopedSlots`](../api/#vm-scopedSlots):
+Et accéder aux slots de portée en tant que fonctions qui retournent des VNodes via [`this.$scopedSlots`](../api/#vm-scopedSlots) :
 
 ``` js
 render: function (createElement) {
-  // <div><slot :text="msg"></slot></div>
+  // `<div><slot :text="msg"></slot></div>`
   return createElement('div', [
     this.$scopedSlots.default({
       text: this.msg
@@ -383,13 +383,13 @@ render: function (createElement) {
 }
 ```
 
-To pass scoped slots to a child component using render functions, use the `scopedSlots` field in VNode data:
+Pour passer des slots internes à un composant enfant en utilisant des fonctions de rendu, utilisez la propriété `scopedSlots` dans les données du VNode :
 
 ``` js
 render (createElement) {
   return createElement('div', [
     createElement('child', {
-      // pass scopedSlots in the data object
+      // passer `scopedSlots` dans l'objet de données
       // in the form of { name: props => VNode | Array<VNode> }
       scopedSlots: {
         default: function (props) {
@@ -403,7 +403,7 @@ render (createElement) {
 
 ## JSX
 
-If you're writing a lot of `render` functions, it might feel painful to write something like this:
+Si vous écrivez beaucoup de fonctions `render`, cela pourra vous sembler fatiguant d'écrire des choses comme ça :
 
 ``` js
 createElement(
@@ -418,15 +418,15 @@ createElement(
 )
 ```
 
-Especially when the template version is so simple in comparison:
+Et d'autant plus quand la version template est vraiment simple en comparaison :
 
 ``` html
 <anchored-heading :level="1">
-  <span>Hello</span> world!
+  <span>Hello</span> world !
 </anchored-heading>
 ```
 
-That's why there's a [Babel plugin](https://github.com/vuejs/babel-plugin-transform-vue-jsx) to use JSX with Vue, getting us back to a syntax that's closer to templates:
+C'est pourquoi il y a un [plugin Babel](https://github.com/vuejs/babel-plugin-transform-vue-jsx) pour utiliser JSX avec Vue, nous permettant l'utilisation d'une syntaxe plus proche de celle des templates :
 
 ``` js
 import AnchoredHeading from './AnchoredHeading.vue'
@@ -436,60 +436,60 @@ new Vue({
   render (h) {
     return (
       <AnchoredHeading level={1}>
-        <span>Hello</span> world!
+        <span>Hello</span> world !
       </AnchoredHeading>
     )
   }
 })
 ```
 
-<p class="tip">Aliasing `createElement` to `h` is a common convention you'll see in the Vue ecosystem and is actually required for JSX. If `h` is not available in the scope, your app will throw an error.</p>
+<p class="tip">Utiliser `h` comme alias de `createElement` est une convention courante que vous verrez dans l'écosystème Vue et qui est en faite requise pour JSX. Si `h` n'est pas disponible dans votre portée courante, votre application va lever une erreur.</p>
 
-For more on how JSX maps to JavaScript, see the [usage docs](https://github.com/vuejs/babel-plugin-transform-vue-jsx#usage).
+Pour plus d'informations sur comment utiliser JSX dans du JavaScript, référez-vous à la [documentation d'utilisation](https://github.com/vuejs/babel-plugin-transform-vue-jsx#usage).
 
-## Functional Components
+## Composants fonctionnels
 
-The anchored heading component we created earlier is relatively simple. It doesn't manage any state, watch any state passed to it, and it has no lifecycle methods. Really, it's just a function with some props.
+Le composant de titre ancré que nous avons créé plus tôt était relativement simple. Il ne gère aucun état, n'observe aucun état qu'on lui passe, et il n'a pas de méthodes de cycle de vie. Non, ce n'est qu'une simple fonction avec quelques props.
 
-In cases like this, we can mark components as `functional`, which means that they're stateless (no `data`) and instanceless (no `this` context). A **functional component** looks like this:
+Dans des cas comme celui-ci, nous pouvons marquer les composants comme `functional`, ce qui signifie qu'ils sont sans état (« stateless » c.-à-d. sans `data`) et sans instance (« instanceless » c.-à-d. sans contexte `this`). Un composant fonctionnel ressemble à ça :
 
 ``` js
 Vue.component('my-component', {
   functional: true,
-  // To compensate for the lack of an instance,
-  // we are now provided a 2nd context argument.
+  // Pour compenser le manque d'instance,
+  // nous pouvons maintenant fournir en second argument un contexte.
   render: function (createElement, context) {
     // ...
   },
-  // Props are optional
+  // Les props sont optionnelles
   props: {
     // ...
   }
 })
 ```
 
-> Note: in versions <=2.3.0, the `props` option is required if you wish to accept props in a functional component. In 2.3.0+ you can omit the `props` option and all attributes found on the component node will be implicitly extracted as props.
+> Note : dans les versions <= 2.3.0, l'option `props` est requise si vous souhaitez accepter des props dans un composant fonctionnel. Dans les versions 2.3.0+ vous pouvez omettre l'option `props` et tous les attributs trouvés dans le nœud composant seront implicitement extraits comme des props.
 
-Everything the component needs is passed through `context`, which is an object containing:
+Tout ce dont le composant a besoin est passé dans l'objet `context`, qui est un objet contenant :
 
-- `props`: An object of the provided props
-- `children`: An array of the VNode children
-- `slots`: A function returning a slots object
-- `data`: The entire data object passed to the component
-- `parent`: A reference to the parent component
-- `listeners`: (2.3.0+) An object containing parent-registered event listeners. This is simply an alias to `data.on`
-- `injections`: (2.3.0+) if using the [`inject`](../api/#provide-inject) option, this will contain resolved injections.
+- `props` : un objet avec les props fournies,
+- `children` : un tableau de VNode enfants,
+- `slots` : une fonction retournant un objet de slots,
+- `data` : l'objet de données (`data`) complet passé au composant,
+- `parent` : une référence au composant parent,
+- `listeners` : (2.3.0+) un objet contenant les écouteurs d'évènement enregistrés dans le parent. C'est un simple alias de `data.on`,
+- `injections` : (2.3.0+) si vous utilisez l'option [`inject`](../api/#provide-inject), cela va contenir les injections résolues.
 
-After adding `functional: true`, updating the render function of our anchored heading component would simply require adding the `context` argument, updating `this.$slots.default` to `context.children`, then updating `this.level` to `context.props.level`.
+Après avoir ajouté `functional: true`, mettre à jour la fonction de rendu de notre composant de titres avec ancres va simplement nécessiter d'ajouter l'argument `context`, en remplaçant `this.$slots.default` par `context.children`, puis `this.level` par `context.props.level`.
 
-Since functional components are just functions, they're much cheaper to render. However, this also mean that functional components don't show up in VueJS Chrome dev tools component tree.
+Puisque les composants fonctionnels ne sont que des fonctions, leur rendu est plus rapide. Cependant, cela signifie également que les composants fonctionnels n'apparaissent pas dans l'arbre des composants de l'outil de développement Vue.js de Chrome.
 
-They're also very useful as wrapper components.  For example, when you need to:
+Ils sont également très utiles en tant que composants enveloppes. Par exemple, quand vous avez besoin de :
 
-- Programmatically choose one of several other components to delegate to
-- Manipulate children, props, or data before passing them on to a child component
+- Programmatiquement choisir un composant parmi plusieurs autres composants pour de la délégation ou
+- Manipuler les enfants, props, ou données avant de les passer au composant enfant.
 
-Here's an example of a `smart-list` component that delegates to more specific components, depending on the props passed to it:
+Voici un exemple d'un composant `smart-list` qui délègue à des composants plus spécifiques en fonction des props qui lui sont passées :
 
 ``` js
 var EmptyList = { /* ... */ }
@@ -526,37 +526,37 @@ Vue.component('smart-list', {
 })
 ```
 
-### `slots()` vs `children`
+### `slots()` vs. `children`
 
-You may wonder why we need both `slots()` and `children`. Wouldn't `slots().default` be the same as `children`? In some cases, yes - but what if you have a functional component with the following children?
+Vous vous demandez peut-être l'utilité d'avoir `slot()` et `children` en même temps. `slots().default` n'est-il pas la même chose que `children` ? Dans la majorité des cas, oui. Mais que faire si vous avez un composant fonctionnel avec les enfants suivants ?
 
 ``` html
 <my-functional-component>
   <p slot="foo">
-    first
+    premier
   </p>
   <p>second</p>
 </my-functional-component>
 ```
 
-For this component, `children` will give you both paragraphs, `slots().default` will give you only the second, and `slots().foo` will give you only the first. Having both `children` and `slots()` therefore allows you to choose whether this component knows about a slot system or perhaps delegates that responsibility to another component by simply passing along `children`.
+Pour ce composant, `children` va vous donner les deux paragraphes, `slots().default` ne vous donnera que le second, et `slots().foo` ne vous donnera que le premier. Avoir le choix entre `children` et `slots()` vous permet donc de choisir ce que le composant sait à propos du système de slot ou si vous déléguez peut-être la responsabilité à un autre composant en passant simplement `children`.
 
-## Template Compilation
+## Compilation de template
 
-You may be interested to know that Vue's templates actually compile to render functions. This is an implementation detail you usually don't need to know about, but if you'd like to see how specific template features are compiled, you may find it interesting. Below is a little demo using `Vue.compile` to live-compile a template string:
+Vous serez peut-être intéressé de savoir que les templates Vue sont en fait compilés en fonctions de rendu. C'est un détail d'implémentation dont vous n'avez en général pas à vous soucier, mais si vous souhaitez savoir comment un template spécifique est compilé, vous pourrez trouver cela intéressant. Vous trouverez ci-dessous une petite démo utilisant `Vue.compile` pour voir en live le rendu d'une chaîne de template :
 
 {% raw %}
 <div id="vue-compile-demo" class="demo">
   <textarea v-model="templateText" rows="10"></textarea>
   <div v-if="typeof result === 'object'">
-    <label>render:</label>
+    <label>rendu :</label>
     <pre><code>{{ result.render }}</code></pre>
-    <label>staticRenderFns:</label>
+    <label>staticRenderFns :</label>
     <pre v-for="(fn, index) in result.staticRenderFns"><code>_m({{ index }}): {{ fn }}</code></pre>
     <pre v-if="!result.staticRenderFns.length"><code>{{ result.staticRenderFns }}</code></pre>
   </div>
   <div v-else>
-    <label>Compilation Error:</label>
+    <label>Erreur de compilation :</label>
     <pre><code>{{ result }}</code></pre>
   </div>
 </div>
@@ -567,13 +567,13 @@ new Vue({
     templateText: '\
 <div>\n\
   <header>\n\
-    <h1>I\'m a template!</h1>\n\
+    <h1>Je suis un template !</h1>\n\
   </header>\n\
   <p v-if="message">\n\
     {{ message }}\n\
   </p>\n\
   <p v-else>\n\
-    No message.\n\
+    Pas de message.\n\
   </p>\n\
 </div>\
     ',
@@ -581,7 +581,7 @@ new Vue({
   computed: {
     result: function () {
       if (!this.templateText) {
-        return 'Enter a valid template above'
+        return 'Entrez ci-dessous un template valide'
       }
       try {
         var result = Vue.compile(this.templateText.replace(/\s{2,}/g, ''))