diff --git a/cookbook/Insert.zh-cn.md b/cookbook/Insert.zh-cn.md
index 41a646e0..e88edfd3 100644
--- a/cookbook/Insert.zh-cn.md
+++ b/cookbook/Insert.zh-cn.md
@@ -5,10 +5,10 @@ title: db.insert 向数据库中新增数据
 
 # db.insert 向数据库中新增数据
 
-###问题
+### 问题
 如何向数据加新增数据？
 
-###解决办法
+### 解决办法
 
 在 0.3 中，数据库连接如下：
 
@@ -28,18 +28,17 @@ sequence_id = db.insert('mytable', firstname="Bob",lastname="Smith",joindate=web
 * _test
 * \**values
 
-
-##tablename
+## tablename
 表名，即你希望向哪个表新增数据。
 
-##seqname
+## seqname
 可选参数，默认 None。Set `seqname` to the ID if it's not the default, or to `False`.
 
-##_test
+## _test
 `_test` 参数可以让你看到 SQL 的执行过程：
 
     results = db.select('mytable', offset=10, _test=True)
     ><sql: 'SELECT * FROM mytable OFFSET 10'>
 
-##\**values
+## \**values
 字段参数。如果没有赋值，数据库可能创建默认值或者发出警告。
diff --git a/cookbook/alternating_style.md b/cookbook/alternating_style.md
index 4398c448..69774258 100644
--- a/cookbook/alternating_style.md
+++ b/cookbook/alternating_style.md
@@ -13,7 +13,6 @@ Solution: Give templetor access to the `int` built-in and use modulo to test.
 
     web.template.Template.globals['int'] = int
 
-
 ## template.html ##
 
     <ul>
@@ -28,16 +27,13 @@ Solution: Give templetor access to the `int` built-in and use modulo to test.
         ">$track.title</li>
     </ul>
 
-
 ## New Templetor ##
 
 In the new implementation of templetor (which will be the default when version .3 is released), within any template loop you have access to a $loop variable.  This works like so:
 
-
     <ul>
     $for foo in foos:
         <li class="$loop.parity">
         $foo
         </li>
     </ul>
-
diff --git a/cookbook/alternating_style.zh-cn.md b/cookbook/alternating_style.zh-cn.md
index 3d6bd22b..a6bb8365 100644
--- a/cookbook/alternating_style.zh-cn.md
+++ b/cookbook/alternating_style.zh-cn.md
@@ -33,12 +33,10 @@ web.template.Template.globals['int'] = int
         ">$track.title</li>
     </ul>
 
-
 ## New Templetor ##
 
 In the new implementation of templetor (which will be the default when version .3 is released), within any template loop you have access to a $loop variable.  This works like so:
 
-
     <ul>
     $for foo in foos:
         <li class="$loop.parity">
diff --git a/cookbook/application_processors.fr.md b/cookbook/application_processors.fr.md
index 6239e43d..2a15ca1c 100644
--- a/cookbook/application_processors.fr.md
+++ b/cookbook/application_processors.fr.md
@@ -5,7 +5,7 @@ title: Application processors, hooks
 
 # Application processors, hooks
 
-Autre langages [english](/../application_processors) | ...
+Autre langages: [English](/../application_processors) | ...
 
 ##  Probleme
 
@@ -41,8 +41,7 @@ Vous pouvez écrire ou utiliser les variables globales dans les fonctions hook,
 
     app.add_processor(web.loadhook(my_loadhook))
 
-
-###Tip: et vous pouvez également utiliser web.ctx ou web.input() dans un hook.
+### Tip: et vous pouvez également utiliser web.ctx ou web.input() dans un hook.
 
     def my_loadhook():
         input = web.input()
diff --git a/cookbook/application_processors.md b/cookbook/application_processors.md
index 9fa640dd..599d96ee 100644
--- a/cookbook/application_processors.md
+++ b/cookbook/application_processors.md
@@ -5,7 +5,7 @@ title: Application processors, hooks
 
 # Application processors, hooks
 
-Other languages : [français](/../cookbook/application_processors.fr) | ...
+Other languages: [Français](/../cookbook/application_processors.fr) | ...
 
 ##  Problem
 
@@ -41,7 +41,7 @@ you can write or use global variables in hook function, for example: web.header(
 
     app.add_processor(web.loadhook(my_loadhook))
 
-###Tip: and also can use web.ctx or web.input() in hook.
+### Tip: and also can use web.ctx or web.input() in hook.
 
     def my_loadhook():
         input = web.input()
diff --git a/cookbook/cgi-apache.md b/cookbook/cgi-apache.md
index ddb0569b..0a2df4b4 100644
--- a/cookbook/cgi-apache.md
+++ b/cookbook/cgi-apache.md
@@ -44,7 +44,7 @@ That's it. Your application is accessible via `http://server/app/app.py/`. Addit
 
 Here it is assumed that your application is called index.py. The above htaccess checks if some static file/directory exists failing which it routes the data to your index.py. Change the Rewrite Base to a sub-directory if needed.
 
-#Hiding the script name using mod_rewrite (tested with webpy 0.33)
+# Hiding the script name using mod_rewrite (tested with webpy 0.33)
 
 (warning: this section written by someone new to webpy; it works, but may not follow prescribed practices)
 
@@ -60,7 +60,7 @@ So now if you go to `http://server/app/` you'll hit `app.py`'s handler for `'/'`
 
 Are we done? Well, that's what I thought. There's still one problem: webpy doesn't know how things were rewritten on the way *in*, so it doesn't know how to rewrite them on the way *out*.
 
-For instance, one can normally use `web.url()` to compose urls such that the right content is found. Want `static/style.css`? Call `web.url('/static/style.css') and you'll get ... `/app/app.py/static/style.css` ... not what we wanted. That doesn't exist. Problem.
+For instance, one can normally use `web.url()` to compose urls such that the right content is found. Want `static/style.css`? Call `web.url('/static/style.css') and you'll get... `/app/app.py/static/style.css` ...not what we wanted. That doesn't exist. Problem.
 
 If you don't use `web.url()`, it can still bite you because *webpy* does. Say `raise web.seeother('/')` and you'll end up at `http://server/app/app.py/`, which defeats the purpose of hiding it using mod_rewrite.
 
diff --git a/cookbook/cookies.fr.md b/cookbook/cookies.fr.md
index b4b92461..daf58d53 100644
--- a/cookbook/cookies.fr.md
+++ b/cookbook/cookies.fr.md
@@ -5,18 +5,19 @@ title: Travailler avec les cookies
 
 # Travailler avec les cookies
 
-Autre langages: [english](/../cookies) | ...
+Autre langages: [English](/../cookies) | ...
 
-##Problème:
+## Problème:
 
 Comment déposer et récupérer les cookies d'un utilisateur qui navigue sur le site?
 
-##Solution:
+## Solution:
 
 Web.py permet d'une façon très simple d'utiliser les méthodes de dépot/récupération de cookies (setting/getting).
 
-###Déposer des cookies
-####Vue d'ensemble
+### Déposer des cookies
+
+#### Vue d'ensemble
 
     setcookie(name, value, expires="", domain=None, secure=False):
 
@@ -26,7 +27,7 @@ Web.py permet d'une façon très simple d'utiliser les méthodes de dépot/récu
 * *domain* `(string)` - Le nom de domaine pour lequel le cookie est valide. Par défaut, réglé sur le site d'accueil, cela vous permet de définir le domaine, plutôt que simplement un hôte(tel que `.webpy.org`).
 * *secure* `(bool)`- Si vrai, exige que le cookie soit envoyé via HTTPS.
 
-####Exemple
+#### Exemple
 
 `web.setcookie()` peut être utilisé pour déposer un cookie à un utilisateur, comme ceci:
 
@@ -36,31 +37,31 @@ Web.py permet d'une façon très simple d'utiliser les méthodes de dépot/récu
             web.setcookie('age', i.age, 3600)
             return "Age set in your cookie"
 
-
 L'appel de la classe ci-dessus avec GET déposera un cookie nommé "age" ayant pour valeur par défaut "25" (cette valeur par défaut provient en fait de web.input et non de la fonction setcookie), et qui expirera dans une heure (3600 secondes).
 
-
 Le troisième (et optionnel) argument de `web.setcookie()`, "expires", vous permet de définir quand vous voulez que votre cookie expire. Tout nombre négatif expirera le cookie immédiatement. Un nombre positif est le nombre de secondes durant lequel le cookie va durer (3600 se traduirait en une heure de durée du cookie). Laisser cet argument vide a pour conséquence, d'expirer le cookie session quand le navigateur s'arrête. Pour créer un cookie permanent, mettez à jour le temps d'expiration du cookie à intervalles réguliers (exemple : quand un utilisateur s'est connecté)
 
+### Récuperer des cookies
 
-###Récuperer des cookies
-####Vue d'ensemble
+#### Vue d'ensemble
 
 Il existe de nombreuses méthodes pour retrouver des cookies, en fonction de la réaction souhaitée à un cookie manquant.
 
-#####Méthode 1 (Renvoi None si le cookie n'est pas trouvé):
+##### Méthode 1 (Renvoi None si le cookie n'est pas trouvé):
+
     web.cookies().get(cookieName)
         #cookieName est le nom du cookie présenté par le navigateur
-#####Méthode  2 (Lève une exception AttributeError si le cookie n'est pas trouvé):
+##### Méthode  2 (Lève une exception AttributeError si le cookie n'est pas trouvé):
+
     foo = web.cookies()
     foo.cookieName
-#####Méthode  3 (Evite la levée d'exception en attribuant une valeur par défaut au cookie qui n'a pas été trouvé):
+##### Méthode  3 (Evite la levée d'exception en attribuant une valeur par défaut au cookie qui n'a pas été trouvé):
+
     foo = web.cookies(cookieName=defaultValue)
     foo.cookieName   # renvoi la valeur (qui pourrait être par défaut)
         #cookieName est le nom du cookie présenté par le navigateur
 
-####Exemple
-
+#### Exemple
 
 `web.cookies()` peut être utilisé pour accéder à un cookie déjà défini. Si un cookie est créé en utilisant le code `web.setcookie()` plus haut, il peut être retrouvé de cette façon:
 
diff --git a/cookbook/cookies.md b/cookbook/cookies.md
index fbdd19fa..fb9cfd08 100644
--- a/cookbook/cookies.md
+++ b/cookbook/cookies.md
@@ -5,7 +5,7 @@ title: cookies
 
 # cookies
 
-Other languages: [français](/../cookbook/cookies.fr) | ...
+Other languages: [Français](/../cookbook/cookies.fr) | ...
 
 ## Problem
 
@@ -16,6 +16,7 @@ You want to set and retrieve cookies for a user browsing the site.
 Web.py *comes* with an easy to use method for setting/getting cookies.
 
 ### Setting Cookies
+
 #### Overview
 
 ```
@@ -46,6 +47,7 @@ Calling the above class with GET will set a cookie named `age` with a default va
 The third (and optional) argument to `web.setcookie()`, `expires`, allows you to set when you want your cookie to expire.  Any negative number will expire the cookie immediately.  Any positive number is the number of seconds that the cookie will last (3600 would result in an hour long cookie).  Leaving this argument empty results in a session cookie, which expires when your browser shuts down.  To make the cookie permanent, simply update cookie expiration time at regular interval (e.g. when user logged in).
 
 ### Retrieving Cookies
+
 #### Overview
 
 There are many methods to retrieve cookies, depending on the desired reaction to a missing cookie.
diff --git a/cookbook/cookies.zh-cn.md b/cookbook/cookies.zh-cn.md
index dfc3a7d3..6fe9d33e 100644
--- a/cookbook/cookies.zh-cn.md
+++ b/cookbook/cookies.zh-cn.md
@@ -14,6 +14,7 @@ title: 如何操作Cookie
 对web.py而言，设置/获取Cookie非常方便。
 
 ### 设置 Cookies
+
 #### 概述
 
     setcookie(name, value, expires="", domain=None, secure=False):
@@ -33,12 +34,12 @@ title: 如何操作Cookie
             web.setcookie('age', i.age, 3600)
             return "Age set in your cookie"
 
-
 用 GET方式调用上面的类将设置一个名为age,默认值是25的cookie(实际上，默认值25是在web.input中赋予i.age的，从而间接赋予 cookie，而不是在setcookie函式中直接赋予cookie的)。这个cookie将在一小时后(即3600秒)过期。
 
 `web.setcookie()`的第三个参数－"expires"是一个可选参数，它用来设定cookie过期的时间。如果是负数，cookie将立刻过期。如果是正数，就表示cookie的有效时间是多久，以秒为单位。如果该参数为空，cookie就永不过期。
 
 ### 获得Cookies
+
 #### 概述
 
 获取Cookie的值有很多方法，它们的区别就在于找不到cookie时如何处理。
@@ -60,6 +61,7 @@ title: 如何操作Cookie
         #cookieName is the name of the cookie submitted by the browser
 
 #### 示例：
+
 用`web.cookies()` 访问cookie.  如果已经用`web.setcookie()`设置了Cookie, 就可以象下面这样获得Cookie:
 
     class CookieGet:
diff --git a/cookbook/csrf.md b/cookbook/csrf.md
index 59de11b6..a4e1a029 100644
--- a/cookbook/csrf.md
+++ b/cookbook/csrf.md
@@ -28,7 +28,6 @@ We need 4 things:
 
 1. Add `<input type="hidden" name="csrf_token" value="$csrf_token()"/>` to the forms in the templates.
 
-
 We define `csrf_token()` like this:
 
     def csrf_token():
diff --git a/cookbook/ctx.fr.md b/cookbook/ctx.fr.md
index 28d10d2f..3f8a016a 100644
--- a/cookbook/ctx.fr.md
+++ b/cookbook/ctx.fr.md
@@ -5,55 +5,48 @@ title: web.ctx
 
 # web.ctx
 
-Autre langages: [english](/../ctx) | ...
+Autre langages: [English](/../ctx) | ...
 
-Probleme
--------
+## Probleme
 
 Vous souhaitez utiliser des variables contextuelles dans votre code comme la page référante ou le navigateur du client.
 
-
-Solution
---------
+## Solution
 
 C'est possible en utilisant 'web.ctx'. D'abord un peu d'architecture: 'web.ctx' est basée sur la classe 'threadeddict', alias 'ThreadedDict'. Cette classe crée un objet de type dictionnaire qui possède des attributs spécifiques au processus id de thread. C'est élégant dans la mesure ou cela nous permet d'utiliser un objet de type dictionnaire, tandis que beaucoup d'utilisateurs accèdent au système simultanément, et l'objet ne contiendra que les données de la requête HTTP donnée. (aucune données n'est partagée donc l'objet est ["thread-safe"](http://fr.wikipedia.org/wiki/Threadsafe) -- _On dit qu’un programme ou qu'une portion de code est thread-safe s’il fonctionne correctement durant une exécution simultanée par plusieurs threads (processus légers)_.)
 
-
 'web.ctx' contient des variables pour chaque requête qui comprennent des informations spécifiques pour chaque demande, comme les variables environnement du client. En supposant que vous vouliez déterminer quelle était la page référante d'un utilisateur accédant à une page:
 
-Exemple
--------
+## Exemple
 
     class example:
         def GET(self):
             referer = web.ctx.env.get('HTTP_REFERER', 'http://google.com')
             raise web.seeother(referer)
 
-
 Ce code utilise 'web.ctx.env' pour accéder à l'environnement variables 'HTTP_REFERER'. Si il n'y en a pas, ce sera par défaut google.com. Enfin, il redirige l'utilisateur vers la page d'où il vient.
 
-
 'web.ctx' est aussi très pratique car il peut-être rêglé par un ['loadhook'] (../application_processors/fr). Les données session, par exemple, sont fixées chaque fois qu'une demande est traitée et les données sont stockées dans 'web.ctx'. Depuis que 'web.ctx' est ["thread-safe"](http://fr.wikipedia.org/wiki/Threadsafe), vous pouvez utiliser les données session comme si elles étaient un objet régulier python.
 
-
-Données que l'on trouve dans 'ctx'
--------------------
+## Données que l'on trouve dans 'ctx'
 
 ### Request ###
-*   `environ` alias 'env' &ndash; un dictionnaire contenant les variables environnement standard de [WSGI](http://www.python.org/dev/peps/pep-0333/#environ-variables)
-*   `home` &ndash; le chemin de base pour l'application, y compris tout élément «consommée» par les applications extérieures *http://example.org/admin*
-*   `homedomain` &ndash; ? (semble être le protocole + l'hôte) *http://example.org*
-*   `homepath` &ndash; La partie du chemin requise par l'utilisateur, déduite de l'application courante. C'est à dire homepath + path = le chemin actuellement requis en HTTP par l'utilisateur. Exemple: */admin*
-
-*   `host` &ndash; le nom d'hôte (domaine) et (si ce n'est pas celui par défaut) le port requis par l'utilisateur. Exemple: *example.org*, *example.org:8080*
-*   `ip` &ndash; L'adresse ip de l'utilisateur. exemple: *xxx.xxx.xxx.xxx*
-*   `method` &ndash; la méthode HTTP utilisée. exemple: *GET*
-*   `path` &ndash; Le chemin demandé par l'utilisateur, relatif à l'aaplication en cours. Si vous utilisez des sous-applications, chaque partie de l'url filtrée par l'application externe sera déduite. Par exemple: vous avez une application principale dans code.py, et une sous application appelée 'admin.py'. Dans 'code.py', vous pointez '/admin' vers 'admin.app'. Dans 'admin.py', vous pointez '/stories' sur une classe nommée 'stories'. Au sein de 'stories', 'web.ctx.path' sera '/stories' et pas '/admin/stories'. Exemple: */articles/845*
-*   `protocol` &ndash; Le protocole utilisé. Exemple:  *https*
-*   `query` &ndash; Une chaîne vide s'il n'y a pas d'argument de requête autre que '?' suivit par la chaine de requête. Exemple *?fourlegs=good&twolegs=bad*
-*   `fullpath` alias 'path + query' &ndash; Le chemin demandé inclut les arguments de requête mais n'inclut *pas* 'homepath'. Exemple : */articles/845?fourlegs=good&twolegs=bad*
+
+* `environ` alias 'env' &ndash; un dictionnaire contenant les variables environnement standard de [WSGI](http://www.python.org/dev/peps/pep-0333/#environ-variables)
+* `home` &ndash; le chemin de base pour l'application, y compris tout élément «consommée» par les applications extérieures *http://example.org/admin*
+* `homedomain` &ndash; ? (semble être le protocole + l'hôte) *http://example.org*
+* `homepath` &ndash; La partie du chemin requise par l'utilisateur, déduite de l'application courante. C'est à dire homepath + path = le chemin actuellement requis en HTTP par l'utilisateur. Exemple: */admin*
+
+* `host` &ndash; le nom d'hôte (domaine) et (si ce n'est pas celui par défaut) le port requis par l'utilisateur. Exemple: *example.org*, *example.org:8080*
+* `ip` &ndash; L'adresse ip de l'utilisateur. exemple: *xxx.xxx.xxx.xxx*
+* `method` &ndash; la méthode HTTP utilisée. exemple: *GET*
+* `path` &ndash; Le chemin demandé par l'utilisateur, relatif à l'aaplication en cours. Si vous utilisez des sous-applications, chaque partie de l'url filtrée par l'application externe sera déduite. Par exemple: vous avez une application principale dans code.py, et une sous application appelée 'admin.py'. Dans 'code.py', vous pointez '/admin' vers 'admin.app'. Dans 'admin.py', vous pointez '/stories' sur une classe nommée 'stories'. Au sein de 'stories', 'web.ctx.path' sera '/stories' et pas '/admin/stories'. Exemple: */articles/845*
+* `protocol` &ndash; Le protocole utilisé. Exemple:  *https*
+* `query` &ndash; Une chaîne vide s'il n'y a pas d'argument de requête autre que '?' suivit par la chaine de requête. Exemple *?fourlegs=good&twolegs=bad*
+* `fullpath` alias 'path + query' &ndash; Le chemin demandé inclut les arguments de requête mais n'inclut *pas* 'homepath'. Exemple : */articles/845?fourlegs=good&twolegs=bad*
 
 ### Response ###
-*   `status` &ndash; Le code statut HTTP (par defaut '200 OK') *401 Unauthorized*
-*   `headers` &ndash; Une liste de deux tuples contenant les en-têtes HTTP (headers)
-*   `output` &ndash; Une chaîne contenant l'entité de réponse
+
+* `status` &ndash; Le code statut HTTP (par defaut '200 OK') *401 Unauthorized*
+* `headers` &ndash; Une liste de deux tuples contenant les en-têtes HTTP (headers)
+* `output` &ndash; Une chaîne contenant l'entité de réponse
diff --git a/cookbook/ctx.md b/cookbook/ctx.md
index b7fbbfe3..b7b473c0 100644
--- a/cookbook/ctx.md
+++ b/cookbook/ctx.md
@@ -5,22 +5,19 @@ title: ctx
 
 # ctx
 
-Other languages: [français](/../cookbook/ctx.fr) | ...
+Other languages: [Français](/../cookbook/ctx.fr) | ...
 
-Problem
--------
+## Problem
 
 You want to use contextual variables in your code such as the referring page or the client's browser.
 
-Solution
---------
+## Solution
 
 Using `web.ctx` makes this possible. First a little architecture: `web.ctx` is based on the class `threadeddict` a.k.a. `ThreadedDict`. This class creates a dictionary-like object that has attributes specific to the thread process id. This is nice because it lets us use a dictionary-like object when many users are accessing the system simultaneously, and the object will only have the data for the given HTTP request (no data is shared so the object is thread-safe).
 
 `web.ctx` holds variables for each request that contain specific information to each request such as the client environment variable. Assuming you want to determine what the referring page was for a user accessing a page:
 
-Example
--------
+## Example
 
     class example:
         def GET(self):
@@ -31,23 +28,24 @@ This code uses `web.ctx.env` to access the `HTTP_REFERER` environment variable.
 
 `web.ctx` is also useful because it can be set by a `loadhook`. Session data, for example, is set each time a request is handled and the data is stored in `web.ctx`. Since `web.ctx` is thread-safe, you can use the session data as if it were a regular python object.
 
-Data Found in `ctx`
--------------------
+## Data Found in `ctx`
 
 ### Request ###
-*   `environ` a.k.a. `env` &ndash; a dictionary containing the standard [WSGI environment variables](http://www.python.org/dev/peps/pep-0333/#environ-variables)
-*   `home` &ndash; the base path for the application, including any parts "consumed" by outer applications *http://example.org/admin*
-*   `homedomain` &ndash; ? (appears to be protocol + host) *http://example.org*
-*   `homepath` &ndash; The part of the path requested by the user which was trimmed off the current app. That is homepath + path = the path actually requested in HTTP by the user. E.g. */admin* This seems to be derived during startup from the environment variable REAL_SCRIPT_NAME. It affects what web.url() will prepend to supplied urls. This in turn affects where web.seeother() will go, which might interact badly with your url rewriting scheme (e.g. mod_rewrite)
-*   `host` &ndash; the hostname (domain) and (if not default) the port requested by the user. E.g. *example.org*, *example.org:8080*
-*   `ip` &ndash; the IP address of the user. E.g. *xxx.xxx.xxx.xxx*
-*   `method` &ndash; the HTTP method used. E.g. *GET*
-*   `path` &ndash; the path requested by the user, relative to the current application. If you are using subapplications, any part of the url matched by the outer application will be trimmed off. E.g. you have a main app in `code.py`, and a subapplication called `admin.py`. In `code.py`, you point `/admin` to `admin.app`.  In `admin.py`, you point `/stories` to a class called `stories`. Within `stories`, `web.ctx.path` will be `/stories`, not `/admin/stories`. E.g. */articles/845*
-*   `protocol` &ndash; the protocol used. E.g. *https*
-*   `query` &ndash; an empty string if there are no query arguments otherwise a `?` followed by the query string. E.g. *?fourlegs=good&twolegs=bad*
-*   `fullpath` a.k.a. `path + query` &ndash; the path requested *including* query arguments but *not* including `homepath`. E.g. */articles/845?fourlegs=good&twolegs=bad*
+
+* `environ` a.k.a. `env` &ndash; a dictionary containing the standard [WSGI environment variables](http://www.python.org/dev/peps/pep-0333/#environ-variables)
+* `home` &ndash; the base path for the application, including any parts "consumed" by outer applications *http://example.org/admin*
+* `homedomain` &ndash; ? (appears to be protocol + host) *http://example.org*
+* `homepath` &ndash; The part of the path requested by the user which was trimmed off the current app. That is homepath + path = the path actually requested in HTTP by the user. E.g. */admin* This seems to be derived during startup from the environment variable REAL_SCRIPT_NAME. It affects what web.url() will prepend to supplied urls. This in turn affects where web.seeother() will go, which might interact badly with your url rewriting scheme (e.g. mod_rewrite)
+* `host` &ndash; the hostname (domain) and (if not default) the port requested by the user. E.g. *example.org*, *example.org:8080*
+* `ip` &ndash; the IP address of the user. E.g. *xxx.xxx.xxx.xxx*
+* `method` &ndash; the HTTP method used. E.g. *GET*
+* `path` &ndash; the path requested by the user, relative to the current application. If you are using subapplications, any part of the url matched by the outer application will be trimmed off. E.g. you have a main app in `code.py`, and a subapplication called `admin.py`. In `code.py`, you point `/admin` to `admin.app`.  In `admin.py`, you point `/stories` to a class called `stories`. Within `stories`, `web.ctx.path` will be `/stories`, not `/admin/stories`. E.g. */articles/845*
+* `protocol` &ndash; the protocol used. E.g. *https*
+* `query` &ndash; an empty string if there are no query arguments otherwise a `?` followed by the query string. E.g. *?fourlegs=good&twolegs=bad*
+* `fullpath` a.k.a. `path + query` &ndash; the path requested *including* query arguments but *not* including `homepath`. E.g. */articles/845?fourlegs=good&twolegs=bad*
 
 ### Response ###
-*   `status` &ndash; the HTTP status code (default '200 OK') *401 Unauthorized*
-*   `headers` &ndash; a list of 2-tuples containing HTTP headers
-*   `output` &ndash; a string containing the response entity
+
+* `status` &ndash; the HTTP status code (default '200 OK') *401 Unauthorized*
+* `headers` &ndash; a list of 2-tuples containing HTTP headers
+* `output` &ndash; a string containing the response entity
diff --git a/cookbook/ctx.zh-cn.md b/cookbook/ctx.zh-cn.md
index 7a699cc3..c5bf437a 100644
--- a/cookbook/ctx.zh-cn.md
+++ b/cookbook/ctx.zh-cn.md
@@ -5,20 +5,17 @@ title: web.ctx
 
 # web.ctx
 
-问题
--------
+## 问题
 
 如何在代码中得到客户端信息？比如：来源页面(referring page)或是客户端浏览器类型
 
-解法
---------
+## 解法
 
 使用web.ctx即可。首先讲一点架构的东西：web.ctx基于threadeddict类，又被叫做ThreadDict。这个类创建了一个类似字典(dictionary-like)的对象，对象中的值都是与线程id相对应的。这样做很妙,因为很多用户同时访问系统时，这个字典对象能做到仅为某一特定的HTTP请求提供数据(因为没有数据共享，所以对象是线程安全的)
 
 web.ctx保存每个HTTP请求的特定信息，比如客户端环境变量。假设，我们想知道正在访问某页面的用户是从哪个网页跳转而来的：
 
-例子
--------
+## 例子
 
     class example:
         def GET(self):
@@ -29,23 +26,22 @@ web.ctx保存每个HTTP请求的特定信息，比如客户端环境变量。假
 
 web.ctx另一个特性，是它可以被loadhook赋值。例如：当一个请求被处理时，会话(Session)就会被设置并保存在web.ctx中。由于web.ctx是线程安全的，所以我们可以象使用普通的python对象一样，来操作会话(Session)。
 
-'ctx'中的数据成员
--------------------
+## 'ctx'中的数据成员
 
 ### Request ###
-*   `environ` 又被写做. `env` &ndash; 包含标准WSGI环境变量的字典。
-*   `home` &ndash; 应用的http根路径(译注：可以理解为应用的起始网址，协议＋站点域名＋应用所在路径)例：*http://example.org/admin*
-*   `homedomain` &ndash; 应用所在站点(可以理解为协议＋域名) *http://example.org*
-*   `homepath` &ndash; 当前应用所在的路径，例如： */admin*
-*   `host` &ndash; 主机名（域名）＋用户请求的端口（如果没有的话，就是默认的80端口），例如： *example.org*, *example.org:8080*
-*   `ip` &ndash; 用户的IP地址，例如： *xxx.xxx.xxx.xxx*
-*   `method` &ndash; 所用的HTTP方法，例如： *GET*
-*   `path` &ndash; 用户请求路径，它是基于当前应用的相对路径。在子应用中，匹配外部应用的那部分网址将被去掉。例如：主应用在`code.py`中，而子应用在`admin.py`中。在`code.py`中, 我们将`/admin`关联到`admin.app`。 在`admin.py`中, 将`/stories`关联到`stories`类。在 `stories`中, `web.ctx.path`就是`/stories`, 而非`/admin/stories`。形如： */articles/845*
-*   `protocol` &ndash; 所用协议，例如： *https*
-*   `query` &ndash; 跟在'？'字符后面的查询字符串。如果不存在查询参数，它就是一个空字符串。例如： *?fourlegs=good&twolegs=bad*
-*   `fullpath` 可以视为 `path + query` &ndash; 包含查询参数的请求路径，但不包括'homepath'。例如：*/articles/845?fourlegs=good&twolegs=bad*
+* `environ` 又被写做. `env` &ndash; 包含标准WSGI环境变量的字典。
+* `home` &ndash; 应用的http根路径(译注：可以理解为应用的起始网址，协议＋站点域名＋应用所在路径)例：*http://example.org/admin*
+* `homedomain` &ndash; 应用所在站点(可以理解为协议＋域名) *http://example.org*
+* `homepath` &ndash; 当前应用所在的路径，例如： */admin*
+* `host` &ndash; 主机名（域名）＋用户请求的端口（如果没有的话，就是默认的80端口），例如： *example.org*, *example.org:8080*
+* `ip` &ndash; 用户的IP地址，例如： *xxx.xxx.xxx.xxx*
+* `method` &ndash; 所用的HTTP方法，例如： *GET*
+* `path` &ndash; 用户请求路径，它是基于当前应用的相对路径。在子应用中，匹配外部应用的那部分网址将被去掉。例如：主应用在`code.py`中，而子应用在`admin.py`中。在`code.py`中, 我们将`/admin`关联到`admin.app`。 在`admin.py`中, 将`/stories`关联到`stories`类。在 `stories`中, `web.ctx.path`就是`/stories`, 而非`/admin/stories`。形如： */articles/845*
+* `protocol` &ndash; 所用协议，例如： *https*
+* `query` &ndash; 跟在'？'字符后面的查询字符串。如果不存在查询参数，它就是一个空字符串。例如： *?fourlegs=good&twolegs=bad*
+* `fullpath` 可以视为 `path + query` &ndash; 包含查询参数的请求路径，但不包括'homepath'。例如：*/articles/845?fourlegs=good&twolegs=bad*
 
 ### Response ###
-*   `status` &ndash; HTTP状态码（默认是'200 OK') *401 Unauthorized 未经授权*
-*   `headers` &ndash; 包含HTTP头信息(headers)的二元组列表。
-*   `output` &ndash; 包含响应实体的字符串。
\ No newline at end of file
+* `status` &ndash; HTTP状态码（默认是'200 OK') *401 Unauthorized 未经授权*
+* `headers` &ndash; 包含HTTP头信息(headers)的二元组列表。
+* `output` &ndash; 包含响应实体的字符串。
\ No newline at end of file
diff --git a/cookbook/custom_notfound.fr.md b/cookbook/custom_notfound.fr.md
index 19a5e900..d6d3662b 100644
--- a/cookbook/custom_notfound.fr.md
+++ b/cookbook/custom_notfound.fr.md
@@ -5,7 +5,7 @@ title: Personnaliser le message NotFound
 
 # Personnaliser le message NotFound
 
-Autre langages: [english](/../custom_notfound) | ...
+Autre langages: [English](/../custom_notfound) | ...
 
 ## Probleme
 
@@ -27,7 +27,6 @@ Comment personnaliser les messages notfound et autres?
 
     app.notfound = notfound
 
-
 Puis, pour renvoyer la 404 personnalisée depuis votre code, faites juste:
 
     class example:
diff --git a/cookbook/custom_notfound.md b/cookbook/custom_notfound.md
index aa2d73e7..fc05e72c 100644
--- a/cookbook/custom_notfound.md
+++ b/cookbook/custom_notfound.md
@@ -5,7 +5,7 @@ title: Custom NotFound message
 
 # Custom NotFound message
 
-Other languages:  [français](/../cookbook/custom_notfound.fr) | ...
+Other languages:  [Français](/../cookbook/custom_notfound.fr) | ...
 
 ## Problem
 
@@ -27,7 +27,6 @@ How to customize notfound and other messages?
 
     app.notfound = notfound
 
-
 And to return the custom 404 from your code, just do:
 
     class example:
diff --git a/cookbook/custom_notfound.zh-cn.md b/cookbook/custom_notfound.zh-cn.md
index efb5ec26..f326b275 100644
--- a/cookbook/custom_notfound.zh-cn.md
+++ b/cookbook/custom_notfound.zh-cn.md
@@ -25,7 +25,6 @@ title: 自定义NotFound消息
 
     app.notfound = notfound
 
-
 要返回自定义的NotFound消息，这么做即可：
 
     class example:
diff --git a/cookbook/fastcgi-apache.md b/cookbook/fastcgi-apache.md
index 9d3e8212..601da4ca 100644
--- a/cookbook/fastcgi-apache.md
+++ b/cookbook/fastcgi-apache.md
@@ -67,12 +67,11 @@ Note the following line is required: `web.wsgi.runwsgi = lambda func, addr=None:
     if __name__ == "__main__":
         app.run()
 
-
 ### Run
 
 1. Start your server.
-1. Open your application with your browser
-1. To confirm your application is running try:
+2. Open your application with your browser
+3. To confirm your application is running try:
 
 ```
 ps aux | grep code.py
@@ -102,9 +101,11 @@ Is your Alias path correct in your apache configuration?
 web.py spawns http://0.0.0.0:8080, dies unexpectedly, or returns nothing.
 
 Did you add this line?
-<pre>
+
+```
  web.wsgi.runwsgi = lambda func, addr=None: web.wsgi.runfcgi(func, addr)
-</pre>
+```
+
 #### Misc
 
 * After updating your application you may need to restart your web server to see the changes.
diff --git a/cookbook/fastcgi-apache.zh-cn.md b/cookbook/fastcgi-apache.zh-cn.md
index 15fb48c4..0025779d 100644
--- a/cookbook/fastcgi-apache.zh-cn.md
+++ b/cookbook/fastcgi-apache.zh-cn.md
@@ -5,14 +5,17 @@ title: Web.py using FastCGI and Apache 2
 
 # Web.py using FastCGI and Apache 2
 
-#Requirements
+# Requirements
+
 * Apache 2.x
 * [mod_fcgid](http://fastcgi.coremail.cn/)
 * [mod_rewrite](http://httpd.apache.org/docs/2.0/rewrite/)
 * [Flup](http://trac.saddi.com/flup)
 
 Note, on CentOS compiling mod_fcgid requires apache-devel be installed (available via yum).
-#Apache Configuration
+
+# Apache Configuration
+
 Replace '/var/www/myapp/' with the path to your apps directory
 
     LoadModule rewrite_module modules/mod_rewrite.so
@@ -45,10 +48,8 @@ Replace '/var/www/myapp/' with the path to your apps directory
           SetHandler None
       </Directory>
 
+# Hello World
 
-
-
-#Hello World
 Note the following line is required:
 web.wsgi.runwsgi = lambda func, addr=None: web.wsgi.runfcgi(func, addr)
 
@@ -67,41 +68,44 @@ web.wsgi.runwsgi = lambda func, addr=None: web.wsgi.runfcgi(func, addr)
     if __name__ == "__main__":
         app.run()
 
+# Run
 
-#Run
 1. Start your server.
-1. Open your application with your browser
-1. To confirm your application is running try:
+2. Open your application with your browser
+3. To confirm your application is running try:
 
-<code>
+```
  ps aux | grep code.py
-</code>
+```
+
+# Troubleshooting
 
-#Troubleshooting
+### Check your apache error log for information!
 
-<br>
-###Check your apache error log for information!
+## Common problems
 
-<br>
-##Common problems
-<br>
+### File permissions.
 
-###File permissions.
 You might see error code 255 in your logs.
 Ensure the directory is readable and that code. py is executable:
 
-<code>
+```
 chmod +x code.py
-</code>
+```
+
+### 404 Not Found.
 
-###404 Not Found.
 Is your Alias path correct in your apache configuration?
 
-###Other problems
+### Other problems
+
 Web.py spawns http://0.0.0.0:8080, dies unexpectedly, or returns nothing.
 Did you add this line?
-<pre>
+
+```
  web.wsgi.runwsgi = lambda func, addr=None: web.wsgi.runfcgi(func, addr)
-</pre>
-#Misc
+```
+
+# Misc
+
 After updating your application you may need to restart your web server to see the changes.
diff --git a/cookbook/fastcgi-lighttpd.fr.md b/cookbook/fastcgi-lighttpd.fr.md
index 9e443df3..b0988eae 100644
--- a/cookbook/fastcgi-lighttpd.fr.md
+++ b/cookbook/fastcgi-lighttpd.fr.md
@@ -5,31 +5,30 @@ title: Webpy + LightTTPD avec FastCGi
 
 # Webpy + LightTTPD avec FastCGi
 
-Autre langages: [english](/../fastcgi-lighttpd) | ...
+Autre langages: [English](/../fastcgi-lighttpd) | ...
 
-##Problème:
+## Problème:
 
 Comment configurer [lighttpd](http://www.lighttpd.net/) sous Debian GNU/Linux ?
 
-##Solution:
+## Solution:
 
 *Si vous avez des problèmes avec cette astuce, veuillez lire ce [fil](http://www.mail-archive.com/webpy@googlegroups.com/msg02800.html).
 Ce qui suit s'applique à la version 1.4.18 de lighttpd.*
 
-###Note:
-* Vous devez remplacer <code>code.py</code> par le nom de votre propre fichier.
-* <code>/path-to/webpy-app</code> que vous trouverez ci-dessous, concerne le chemin vers le répertoire contenant votre <code>code.py</code>
-* <code>/path-to/webpy-app/code.py</code> est le chemin complet de votre **fichier python**
+### Note:
 
+* Vous devez remplacer `code.py` par le nom de votre propre fichier.
+* `/path-to/webpy-app` que vous trouverez ci-dessous, concerne le chemin vers le répertoire contenant votre `code.py`
+* `/path-to/webpy-app/code.py` est le chemin complet de votre **fichier python**
 
-Si vous n'êtes pas certain de savoir quelle version de [lighttpd](http://www.lighttpd.net/) s'execute, tapez : <code>lighttpd -v</code> dans la console.
+Si vous n'êtes pas certain de savoir quelle version de [lighttpd](http://www.lighttpd.net/) s'execute, tapez : `lighttpd -v` dans la console.
 
 *Note: La version précédente de lighttpd organise les fichiers .conf différemment. Cependant, les mêmes principes s'appliquent aussi bien sur eux.*
 
+## Configuration de lighttpd sous Debian GNU/Linux
 
-##Configuration de lighttpd sous Debian GNU/Linux
-
-<pre>
+```
 Fichiers er répertoires de /etc/lighttpd:
 ---------------------------------------
 
@@ -53,24 +52,19 @@ conf-enabled/
 l'Activation et désactivation des modules peut se faire en lançant:
 	/usr/sbin/lighty-enable-mod
  	/usr/sbin/lighty-disable-mod scripts.
-</pre>
-
-<strong>
-
-Pour web.py vous devrez activer mod_fastcgi et mod_rewrite en executant:
-<code>/usr/sbin/lighty-enable-mod</code> et en fournissant <code>fastcgi</code>
-(mod_rewrite sera activé dans le fichier <code>10-fastcgi.conf</code>, comme vous pourrez le voir dans un instant.)
+```
 
+**Pour web.py vous devrez activer mod_fastcgi et mod_rewrite en executant: `/usr/sbin/lighty-enable-mod` et en fournissant `fastcgi` (mod_rewrite sera activé dans le fichier `10-fastcgi.conf`, comme vous pourrez le voir dans un instant.)**
 
-##Voici les instructions pour les fichiers suivants:
+## Voici les instructions pour les fichiers suivants:
 
-* <code>/etc/lighttpd/lighttpd.conf</code>
-* <code>/etc/lighttpd/conf-available/10-fastcgi.conf</code>
-* <code>code.py</code>
+* `/etc/lighttpd/lighttpd.conf`
+* `/etc/lighttpd/conf-available/10-fastcgi.conf`
+* `code.py`
 
-### <code>/etc/lighttpd/lighttpd.conf</code>
+### `/etc/lighttpd/lighttpd.conf`
 
-<pre>
+```
 server.modules              = (
             "mod_access",
             "mod_alias",
@@ -78,18 +72,17 @@ server.modules              = (
             "mod_compress",
 )
 server.document-root       = "/path-to/webpy-app"
-</pre>
-
+```
 
 *Dans mon cas, j'ai utilisé [postgreSQL](http://doc.ubuntu-fr.org/postgresql). Pour executer lighttpd avec postgres et afin d'accorder des autorisations à la base de donnée, j'ai ajouté la ligne:*
 
-<pre>
+```
 server.username = "postgres"
-</pre>
+```
 
-###<code>/etc/lighttpd/conf-available/10-fastcgi.conf</code>
+### `/etc/lighttpd/conf-available/10-fastcgi.conf`
 
-<pre>
+```
 server.modules   += ( "mod_fastcgi" )
 server.modules   += ( "mod_rewrite" )
 
@@ -109,17 +102,18 @@ server.modules   += ( "mod_rewrite" )
    "^/static/(.*)$" => "/static/$1",
    "^/(.*)$" => "/code.py/$1",
  )
-</pre>
+```
+
+### `code.py`
 
-###<code>code.py</code>
 En haut du fichier, ajoutez:
 
-<pre>
+```
 #!/usr/bin/env python
-</pre>
+```
 
-.. et n'oubliez pas de le rendre executable (Autrement, vous aurez une erreur "permission denied"):
+...et n'oubliez pas de le rendre executable (Autrement, vous aurez une erreur "permission denied"):
 
-<pre>
+```
 $ chmod 755 /path-to/webpy-app/code.py
-</pre>
+```
diff --git a/cookbook/fastcgi-lighttpd.md b/cookbook/fastcgi-lighttpd.md
index e1c2aade..156129ec 100644
--- a/cookbook/fastcgi-lighttpd.md
+++ b/cookbook/fastcgi-lighttpd.md
@@ -5,24 +5,25 @@ title: Webpy + LightTTPD with FastCGi
 
 # Webpy + LightTTPD with FastCGi
 
-Other languages: [français](/../cookbook/fastcgi-lighttpd.fr) | ...
+Other languages: [Français](/../cookbook/fastcgi-lighttpd.fr) | ...
 
 *If you have problems with this recipe read this [thread](http://www.mail-archive.com/webpy@googlegroups.com/msg02800.html)*
 
 *The following applies on lighttpd version 1.4.18*
 
-##Note:
-* You may replace <code>code.py</code> with your own file name.
-* <code>/path-to/webpy-app</code> found below refers to the path to the directory contains your <code>code.py</code>
-* <code>/path-to/webpy-app/code.py</code> is the full path to your **python file**
+## Note:
 
-If you are not certain what version you are running simply type: <code>lighttpd -v</code> at your console.
+* You may replace `code.py` with your own file name.
+* `/path-to/webpy-app` found below refers to the path to the directory contains your `code.py`
+* `/path-to/webpy-app/code.py` is the full path to your **python file**
+
+If you are not certain what version you are running simply type: `lighttpd -v` at your console.
 
 Note: Earlier version of lighttpd may organize the .conf files differently. Yet, the same principles applied on them as well.
 
 ### lighttpd Configuration under Debian GNU/Linux
 
-<pre>
+```
 Files and Directories in /etc/lighttpd:
 ---------------------------------------
 
@@ -42,20 +43,19 @@ conf-enabled/
 
 Enabling and disabling modules could be done by provided
 /usr/sbin/lighty-enable-mod and /usr/sbin/lighty-disable-mod scripts.
-</pre>
+```
+
+**For web py you should enable mod_fastcgi and mod_rewrite, thus run: `/usr/sbin/lighty-enable-mod` and supply `fastcgi` (mod_rewrite will be enabled within `10-fastcgi.conf` file as you will see in a moment).**
 
-<strong>
-For web py you should enable mod_fastcgi and mod_rewrite, thus run: <code>/usr/sbin/lighty-enable-mod</code> and supply <code>fastcgi</code>
-(mod_rewrite will be enabled within <code>10-fastcgi.conf</code> file as you will see in a moment).
+## Below are instructions for the following files:
 
-##Below are instructions for the following files:
-* <code>/etc/lighttpd/lighttpd.conf</code>
-* <code>/etc/lighttpd/conf-available/10-fastcgi.conf</code>
-* <code>code.py</code>
+* `/etc/lighttpd/lighttpd.conf`
+* `/etc/lighttpd/conf-available/10-fastcgi.conf`
+* `code.py`
 
-###<code>/etc/lighttpd/lighttpd.conf</code>
+### `/etc/lighttpd/lighttpd.conf`
 
-<pre>
+```
 server.modules              = (
             "mod_access",
             "mod_alias",
@@ -63,17 +63,17 @@ server.modules              = (
             "mod_compress",
 )
 server.document-root       = "/path-to/webpy-app"
-</pre>
+```
 
 In my case I used postgresql and therefore runs lighttpd as postgres in order to grant permissions to the database, therefore I added the line:
 
-<pre>
+```
 server.username = "postgres"
-</pre>
+```
 
-###<code>/etc/lighttpd/conf-available/10-fastcgi.conf</code>
+### `/etc/lighttpd/conf-available/10-fastcgi.conf`
 
-<pre>
+```
 server.modules   += ( "mod_fastcgi" )
 server.modules   += ( "mod_rewrite" )
 
@@ -93,17 +93,18 @@ server.modules   += ( "mod_rewrite" )
    "^/static/(.*)$" => "/static/$1",
    "^/(.*)$" => "/code.py/$1",
  )
-</pre>
+```
+
+### `/code.py`
 
-###<code>/code.py</code>
 At the top of the file add:
 
-<pre>
+```
 #!/usr/bin/env python
-</pre>
+```
 
 and don't forget to make it executable (otherwise you will get a "permission denied" error):
 
-<pre>
+```
 $ chmod 755 /path-to/webpy-app/code.py
-</pre>
+```
diff --git a/cookbook/fastcgi-lighttpd.zh-cn.md b/cookbook/fastcgi-lighttpd.zh-cn.md
index 371d5061..a4365ec4 100644
--- a/cookbook/fastcgi-lighttpd.zh-cn.md
+++ b/cookbook/fastcgi-lighttpd.zh-cn.md
@@ -13,17 +13,17 @@ http://www.mail-archive.com/webpy@googlegroups.com/msg02800.html
 
 ## 注意事项
 
-* 你可以重命名 <code>code.py</code>为任何你自己愿意的名字，该例子还是以code.py为例。
-* <code>/path-to/webpy-app</code> 为包含你的 <code>code.py</code>代码的路径。
-* <code>/path-to/webpy-app/code.py</code> 应该是你的**python file**的完整路径。
+* 你可以重命名 `code.py`为任何你自己愿意的名字，该例子还是以code.py为例。
+* `/path-to/webpy-app` 为包含你的 `code.py`代码的路径。
+* `/path-to/webpy-app/code.py` 应该是你的**python file**的完整路径。
 
 如果你还不确定你的lighttpd版本的话，你可以在命令行中使用<code>lighttpd -v</vode>查看相应的版本信息。
 
 Note: 较早版本的lighttpd可能会按照不同的方式组织.conf文件，但是它们应该遵循的是相同的原则。
 
-###lighttpd 在 Debian GNU/Linux 下的配置文件
+### lighttpd 在 Debian GNU/Linux 下的配置文件
 
-<pre>
+```
 Files and Directories in /etc/lighttpd:
 ---------------------------------------
 
@@ -43,22 +43,20 @@ conf-enabled/
 
 Enabling and disabling modules could be done by provided
 /usr/sbin/lighty-enable-mod and /usr/sbin/lighty-disable-mod scripts.
-</pre>
+```
 
-<strong>
-对于web py， 你需要允许 mod_fastcgi 模块和 mod_rewrite模块, 运行: <code>/usr/sbin/lighty-enable-mod</code> 启用 <code>fastcgi</code> （Mac OS X可能不需要）
-(mod_rewrite 模块可能需要启用 <code>10-fastcgi.conf</code>文件).
+**对于web py， 你需要允许 mod_fastcgi 模块和 mod_rewrite模块, 运行: `/usr/sbin/lighty-enable-mod` 启用 `fastcgi` （Mac OS X可能不需要）(mod_rewrite 模块可能需要启用 `10-fastcgi.conf`文件).**
 
 ##下面是文件的基本结构（Mac OS X不同）:
-* <code>/etc/lighttpd/lighttpd.conf</code>
-* <code>/etc/lighttpd/conf-available/10-fastcgi.conf</code>
-* <code>code.py</code>
+* `/etc/lighttpd/lighttpd.conf`
+* `/etc/lighttpd/conf-available/10-fastcgi.conf`
+* `code.py`
 
 对于Mac OS X或任何以Mac Ports邓方式安装的lighttpd，可以直接在路径下编写.conf文件并用lighttpd -f xxx.conf启动lighttpd，而无需去修改或考虑任何文件结构。
 
-<code>/etc/lighttpd/lighttpd.conf</code>
+`/etc/lighttpd/lighttpd.conf`
 
-<pre>
+```
 server.modules              = (
             "mod_access",
             "mod_alias",
@@ -66,17 +64,17 @@ server.modules              = (
             "mod_compress",
 )
 server.document-root       = "/path-to/webpy-app"
-</pre>
+```
 
 对我来说，我使用 postgresql，因此需要授予对的数据库权限，可以添加行如下（如果不使用则不需要）。
 
-<pre>
+```
 server.username = "postgres"
-</pre>
+```
 
-<code>/etc/lighttpd/conf-available/10-fastcgi.conf</code>
+`/etc/lighttpd/conf-available/10-fastcgi.conf`
 
-<pre>
+```
 server.modules   += ( "mod_fastcgi" )
 server.modules   += ( "mod_rewrite" )
 
@@ -98,17 +96,17 @@ server.modules   += ( "mod_rewrite" )
    "^/static/(.*)$" => "/static/$1",
    "^/(.*)$" => "/code.py/$1",
  )
-</pre>
+```
 
-<code>/code.py</code>
+`/code.py`
 在代码头部添加以下代码，让系统环境使用系统环境中当前的python
 
-<pre>
+```
 #!/usr/bin/env python
-</pre>
+```
 
 最后不要忘记了要对需要执行的py代码设置执行权限，否则你可能会遇到“permission denied”错误。
 
-<pre>
+```
 $ chmod 755 /path-to/webpy-app/code.py
-</pre>
+```
diff --git a/cookbook/fastcgi-nginx.md b/cookbook/fastcgi-nginx.md
index e13c47fd..3818d59a 100644
--- a/cookbook/fastcgi-nginx.md
+++ b/cookbook/fastcgi-nginx.md
@@ -118,7 +118,6 @@ And to stop:
 
 	/path/to/nginx/sbin/nginx -s stop
 
-
 ## NOTES
 
 ### problem child exited with 2
@@ -128,5 +127,3 @@ solution:  insert `#!/usr/bin/env python` into header of main.py
 ### problem spawn-fcgi child exited with 126
 
 solution: `chmod +x main.py`
-
-
diff --git a/cookbook/fileupload.fr.md b/cookbook/fileupload.fr.md
index eb808d14..f34bc752 100644
--- a/cookbook/fileupload.fr.md
+++ b/cookbook/fileupload.fr.md
@@ -5,7 +5,7 @@ title: Uploader un fichier
 
 # Uploader un fichier
 
-Autre langages: [english](/../fileupload) | ...
+Autre langages: [English](/../fileupload) | ...
 
 ## Problème:
 
diff --git a/cookbook/fileupload.md b/cookbook/fileupload.md
index 0f78e936..49fedfe7 100644
--- a/cookbook/fileupload.md
+++ b/cookbook/fileupload.md
@@ -5,7 +5,7 @@ title: File Upload Recipe
 
 # File Upload Recipe
 
-Other languages: [français](/../cookbook/fileupload.fr) | ...
+Other languages: [Français](/../cookbook/fileupload.fr) | ...
 
 ## Problem
 
diff --git a/cookbook/forms.fr.md b/cookbook/forms.fr.md
index 43ec7d25..27639f7c 100644
--- a/cookbook/forms.fr.md
+++ b/cookbook/forms.fr.md
@@ -5,7 +5,7 @@ title: Comment utiliser les formulaires
 
 # Comment utiliser les formulaires
 
-Autre langages: [english](/../forms) | ...
+Autre langages: [English](/../forms) | ...
 
 ## Problème:
 
@@ -16,7 +16,6 @@ Comment utiliser les formulaires ?
 Le module `web.form`  fournit un support pour créer, valider et interpréter les formulaires.
 Ce module contient une classe `Form` et des classes pour diverses entrées de type `Textbox`, `Password`, etc...
 
-
 Chaque entrée peut prendre une liste de validateurs comme arguments qui sont validées par rapport à l'entrée lorsque `form.validates ()` est appelée.
 
 La classe `Form` peut aussi prendre le mot-clé supplémentaire `validators` en arguments pour valider le formulaire en utilisant la saisie complète.
diff --git a/cookbook/forms.md b/cookbook/forms.md
index 64173c0b..be85510b 100644
--- a/cookbook/forms.md
+++ b/cookbook/forms.md
@@ -5,7 +5,7 @@ title: How to use forms
 
 # How to use forms
 
-Other languages: [français](/../cookbook/forms.fr) | ...
+Other languages: [Français](/../cookbook/forms.fr) | ...
 
 ## Problem
 
diff --git a/cookbook/forms.zh-cn.md b/cookbook/forms.zh-cn.md
index 62fbab86..d85b258c 100644
--- a/cookbook/forms.zh-cn.md
+++ b/cookbook/forms.zh-cn.md
@@ -51,7 +51,6 @@ title: 怎样使用表单 forms
             else:
                 # do whatever is required for registration
 
-
 然后注册的模板应该像是这样：
 
     $def with(form)
diff --git a/cookbook/google_app_engine.md b/cookbook/google_app_engine.md
index 375e9aac..8fbbbf55 100644
--- a/cookbook/google_app_engine.md
+++ b/cookbook/google_app_engine.md
@@ -17,6 +17,7 @@ This cookbook entry explains how to run web.py as a google app engine applicatio
 * [Google App Engine](https://developers.google.com/appengine/downloads#Google_App_Engine_SDK_for_Python)
 
 ###  Notes
+
 * The mechanisms for running GAE in python2.7 and 2.5 are different, change the app.yaml accordingly
 * code.py is the main file of your application (2.5)
 * code.app is the object that cointains the return value of gaerun() (2.7)
diff --git a/cookbook/helloworld.fr.md b/cookbook/helloworld.fr.md
index 81f33c70..af1c2152 100644
--- a/cookbook/helloworld.fr.md
+++ b/cookbook/helloworld.fr.md
@@ -5,13 +5,12 @@ title: Hello World!
 
 # Hello World!
 
-Autre langages : [english](/../helloworld) | ...
+Autre langages: [English](/../helloworld) | ...
 
 ## Probleme
 
 Comment écrire un "Hello World" avec web.py
 
-
 ## Solution
 
     import web
@@ -26,13 +25,12 @@ Comment écrire un "Hello World" avec web.py
     if __name__ == "__main__":
         app.run()
 
-###Tip: Ecrire une url avec ou sans "/", pointe sur la même classe.
+### Tip: Ecrire une url avec ou sans "/", pointe sur la même classe.
 
 Ajoutez ce qui suit au début des urls.
 
     '/(.*)/', 'redirect',
 
-
 et vous utiliserez la classe suivante pour traiter ces urls.
 
     class redirect:
diff --git a/cookbook/helloworld.md b/cookbook/helloworld.md
index 27d22ab1..5eff59cf 100644
--- a/cookbook/helloworld.md
+++ b/cookbook/helloworld.md
@@ -5,7 +5,7 @@ title: Hello World!
 
 # Hello World!
 
-Other languages : [français](/helloworld.fr) | ...
+Other languages: [Français](/helloworld.fr) | ...
 
 ## Problem
 
@@ -25,7 +25,7 @@ How to write hello world with web.py
     if __name__ == "__main__":
         app.run()
 
-###Tip: Make url ending with or without '/' going to the same class.
+### Tip: Make url ending with or without '/' going to the same class.
 
 add the following to the beginning of urls.
 
diff --git a/cookbook/helloworld.ru.md b/cookbook/helloworld.ru.md
index 17e0c6b5..adf5c1b4 100644
--- a/cookbook/helloworld.ru.md
+++ b/cookbook/helloworld.ru.md
@@ -23,7 +23,7 @@ title: Привет мир!!!
     if __name__ == "__main__":
         app.run()
 
-###Tip: Make url ending with or without '/' going to the same class.
+### Tip: Make url ending with or without '/' going to the same class.
 
 добавьте следующую строчкув начало списка urls.
 
diff --git a/cookbook/i18n_support_in_template_file.md b/cookbook/i18n_support_in_template_file.md
index 29009ac1..361b742b 100644
--- a/cookbook/i18n_support_in_template_file.md
+++ b/cookbook/i18n_support_in_template_file.md
@@ -14,7 +14,7 @@ Solution:
 
 Project directory structure:
 
-<pre>
+```
 proj/
    |- code.py
    |- i18n/
@@ -26,11 +26,11 @@ proj/
    |- templates/
        |- hello.html
 
-</pre>
+```
 
 File: proj/code.py
 
-<pre>
+```
 #!/usr/bin/env python
 # encoding: utf-8
 
@@ -59,35 +59,44 @@ class hello:
 app = web.application(urls, globals())
 if __name__ == "__main__":
     app.run()
-</pre>
+```
 
 Template file: proj/templates/hello.html.
-<pre>$_("Message")</pre>
+
+```
+$_("Message")
+```
 
 Create locale dir and use pygettext.py which shipped within Python-2.6 (in directory: Tools/i18n/) to extract messages from python scripts and templates files:
-<pre>
+
+```
 shell> cd /path/to/proj/
 shell> mkdir -p i18n/en_US/LC_MESSAGES/
 shell> python /path/to/pygettext.py -a -v -d messages -o i18n/messages.po \*.py templates/\*.html
 Working on code.py
 Working on templates/hello.html
-</pre>
+```
 
 You will get pot file: i18n/messages.po. Its contents looks like below ('msgstr' contains translated message):
-<pre>
+
+```
 #: code.py:40
 msgid "Message"
 msgstr "This is translated message in file: code.py."
-</pre>
+```
 
 Copy file 'i18n/messages.po' to directory 'i18n/en_US/LC_MESSAGES/', and then translate it. Use 'msgfmt' tool from 'gettext' package (not python moudule) or use file 'msgfmt.py' shipped within Python-2.6 (in directory: Tools/i18n/) to compile pot file to mo file:
-<pre>
+
+```
 shell> msgfmt -o i18n/en_US/LC_MESSAGES/messages.mo i18n/en_US/LC_MESSAGES/messages.po
-</pre>
+```
+
 Start webpy http server:
-<pre>
+
+```
 shell> cd /path/to/proj/
 shell> python code.py
 http://0.0.0.0:8000/
-</pre>
+```
+
 Start your web browser, e.g. firefox, and visit url: http://192.168.0.3:8000/, you will see translated message.
diff --git a/cookbook/i18n_support_in_template_file.zh-cn.md b/cookbook/i18n_support_in_template_file.zh-cn.md
index 1bc366a8..5c547593 100644
--- a/cookbook/i18n_support_in_template_file.zh-cn.md
+++ b/cookbook/i18n_support_in_template_file.zh-cn.md
@@ -15,7 +15,7 @@ title: i18n support in template file
 
 项目目录结构:
 
-<pre>
+```
 proj/
    |- code.py
    |- i18n/
@@ -27,11 +27,11 @@ proj/
    |- templates/
        |- hello.html
 
-</pre>
+```
 
 文件: proj/code.py
 
-<pre>
+```
 #!/usr/bin/env python
 # encoding: utf-8
 
@@ -60,38 +60,45 @@ class hello:
 app = web.application(urls, globals())
 if __name__ == "__main__":
     app.run()
-</pre>
+```
 
 模板文件: proj/templates/hello.html.
-<pre>$_("Message")</pre>
+
+```
+$_("Message")
+```
 
 创建一个locale目录并使用python2.6内建的pygettext.py从python脚本和模板文件中导出翻译:
-<pre>
+
+```
 shell> cd /path/to/proj/
 shell> mkdir -p i18n/en_US/LC_MESSAGES/
 shell> python /path/to/pygettext.py -a -v -d messages -o i18n/messages.po *.py templates/*.html
 Working on code.py
 Working on templates/hello.html
-</pre>
+```
 
 你将会得到pot file: i18n/messages.po. 它的内容和下面的差不多
 ('msgstr'包含了翻译后的信息):
-<pre>
+
+```
  # 文件 code.py:40
 msgid "Message"
 msgstr "This is translated message in file: code.py."
-</pre>
+```
 
 拷贝文件'i18n/messages.po'到目录'i18n/en_US/LC_MESSAGES/'下, 然后翻译它. 使用gettext包的msgfmt工具或者使用python2.6内建的'msgfmt.py'文件将一个pot文件编译称mo文件:
-<pre>
+
+```
 shell> msgfmt -o i18n/en_US/LC_MESSAGES/messages.mo i18n/en_US/LC_MESSAGES/messages.po
-</pre>
+```
 
 运行web.py的服务器:
 
-<pre>
+```
 shell> cd /path/to/proj/
 shell> python code.py
 http://0.0.0.0:8000/
-</pre>
+```
+
 打开你的浏览器, 比如说firefox, 然后访问地址: http://192.168.0.3:8000/, 你将会看过翻译过的信息.
diff --git a/cookbook/iis7_iis6_windows_pyisapie.md b/cookbook/iis7_iis6_windows_pyisapie.md
index 5b13833c..44ecc363 100644
--- a/cookbook/iis7_iis6_windows_pyisapie.md
+++ b/cookbook/iis7_iis6_windows_pyisapie.md
@@ -49,7 +49,6 @@ I set up a website under IIS using the IIS Management Console. Since I was worki
 
 I decided to keep the PyISAPIe folder inside the folder where `code.py` rested. This PyISAPIe folder contained the `PyISAPIe.dll` file, and the `Http` folder. Inside the `Http` folder, I placed the most important file of all: the `Isapi.py`. That file could be thought of as the starting point for each request that is made, what glues the Request to the proper Handler and code. I worked with the `Examples\WSGI\Isapi.py` available as part of PyISAPIe. I tweaked the file to look like this:
 
-
     from Http.WSGI import RunWSGI
     from Http import Env
     #from md5 import md5
diff --git a/cookbook/index.fr.md b/cookbook/index.fr.md
index d732e7fa..0cdf67a1 100644
--- a/cookbook/index.fr.md
+++ b/cookbook/index.fr.md
@@ -5,12 +5,12 @@ title: Web.py Cookbook
 
 # Web.py Cookbook
 
-Autres langages : [japan 日本語](/ja) | [chinese 简体中文](/zh-cn) | [english](/../cookbook) | ...
+Autres langages: [Japan 日本語](/ja) | [Chinese 简体中文](/zh-cn) | [English](/../cookbook) | ...
 
 Documentation de type Cookbook pour web.py 0.3. Veuillez noter que certaines de ces fonctions ne sont pas disponibles dans les versions précedentes.
 La version actuelle 0.3 est la branche développement.
 
-#Mise en forme
+# Mise en forme
 
 1. En termes de mise en forme, essayez d'utiliser un format de type cookbook... Comme ceci:
 
@@ -22,9 +22,10 @@ La version actuelle 0.3 est la branche développement.
 
 1. Cette documentation est finalement pour la version 0.3, donc veuillez ajouter du code qui ne fonctionne qu'avec cette version.
 
--------------------------------------------------
+---
+
+## Basique:
 
-##Basique:
 * [Hello World](/helloworld/fr).
 * [Servir des fichiers statiques](/staticfiles/fr).
 * [Comprendre la gestion des URLs](/url_handling/fr).
@@ -33,8 +34,8 @@ La version actuelle 0.3 est la branche développement.
 * [Servir du XML](/xmlfiles/fr).
 * [Lire les données brutes d'un post](/postbasic/fr).
 
+## Avancé
 
-##Avancé
 * [web.ctx](/ctx/fr).
 * [Application processors, charger et décharger des hooks](/application_processors/fr).
 * [Comment utiliser web.background](/background). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
@@ -44,7 +45,8 @@ La version actuelle 0.3 est la branche développement.
 * [Configurer le support SSL dans le serveur intégré](/ssl/fr).
 * [Run-time language switch](/runtime-language-switch). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
 
-##Sessions et état des utilisateurs:
+## Sessions et état des utilisateurs:
+
 * [Travailler avec les sessions](/sessions/fr).
 * [Utiliser session avec reloader](/session_with_reloader/fr).
 * [Utiliser session dans les gabarits](/session_in_template/fr).
@@ -53,13 +55,14 @@ La version actuelle 0.3 est la branche développement.
 * [Authentification des utilisateurs avec base de données Postgresql](/userauthpgsql). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
 * [Utiliser les sessions avec les sous-applications](/sessions_with_subapp/fr).
 
+## Utils:
 
-##Utils:
 * [Envoi de Mail](/sendmail). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
 * [Envoi de Mail en utilisant Gmail](/sendmail_using_gmail/fr).
 * [Webservice en utilisant soaplib + WSDL](/webservice). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
 
-##Modèles de mise en forme, gabarits de mise en page:
+## Modèles de mise en forme, gabarits de mise en page:
+
 * [Templetor: le système de gabarits de web.py](/docs/0.3/templetor.fr )
 * [Mise en page selon un gabarit](/layout_template/fr).
 * [Alterner un style](/alternating_style). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
@@ -70,11 +73,13 @@ La version actuelle 0.3 est la branche développement.
 * [Utiliser le moteur de gabarit  Jinja2 dans webpy](/template_jinja). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
 * [Comment utiliser les gabarits sur Google App Engine](/templates_on_gae). - traduction demandée, voir [Todo](/docs/0.3.fr/todo))
 
-##Essais:
+## Essais:
+
 * [Tester avec Paste et Nose](/testing_with_paste_and_nose). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
 * [RESTful doctesting using an application's request method](/restful_doctesting_using_request). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
 
-##Entrées utilisateurs:
+## Entrées utilisateurs:
+
 * [Uploader un fichier](/fileupload/fr).
 * [Stocker un fichier uploadé](/storeupload/fr).
 * [Comment limiter la taille des fichiers uploadés](/limiting_upload_size/fr).
@@ -82,7 +87,8 @@ La version actuelle 0.3 est la branche développement.
 * [Comment utiliser les formulaires](/forms/fr).
 * [Rendu individuel des champs de formulaires](/form_fields). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
 
-##Base de données:
+## Base de données:
+
 * [Multiples bases de données](/multidbs). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
 * [Select: Récupérer les entrées d'une base de données](/select). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
 * [Update: Mettre à jour les entrées d'une base de données](/update). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
@@ -94,8 +100,8 @@ La version actuelle 0.3 est la branche développement.
 * [Intégrer SQLite UDF (user-defined-functions) à la couche de base de données webpy](/sqlite-udf). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
 * [Utiliser un dictionnaire comme clause where](/where_dict). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
 
+## Déploiement:
 
-##Déploiement:
 * [Déploiement Fastcgi au travers lighttpd](/fastcgi-lighttpd/fr).
 * [Déploiement Fastcgi au travers Apache](/fastcgi-apache).  - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
 * [Déploiement CGI au travers Apache](/cgi-apache). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
@@ -104,5 +110,6 @@ La version actuelle 0.3 est la branche développement.
 * [Déploiement mod_wsgi au travers Nginx](/mod_wsgi-nginx ). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
 * [Déploiement Fastcgi au travers Nginx](/fastcgi-nginx). - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
 
-##Sous-domaines:
+## Sous-domaines:
+
 * Sous-domaines et comment accéder au nom utilisateur (requis)
diff --git a/cookbook/index.ja.md b/cookbook/index.ja.md
index cd2a6947..8b73ee77 100644
--- a/cookbook/index.ja.md
+++ b/cookbook/index.ja.md
@@ -21,43 +21,43 @@ web.py 0.3 ベースのCookbookスタイルのドキュメントです。
 
 1. 最後に、このドキュメンテーションはバージョン 0.3向けですので、あなたの知っている新バージョン用のコードを加えてください。
 
--------------------------------------------------
+---
 
-##Basics:
+## Basics:
 * [Hello World](/helloworld/ja)
 * [staticファイル(js、css、画像など)について](/staticfiles/ja)
 * [Seeother(HTTP/1.1 コード : 303)とRedirect](/redirect+seeother)
 * [サブアプリケーションの使い方について(別ファイルのインクルード)](/subapp/ja)
 * [Serving XML](/xmlfiles)
 
-##Advanced
+## Advanced
 * [web.ctx](/ctx)
 * [Application processors, loadhooks and unloadhooks](/application_processors)
 * [How to use web.background](/background)
 * [Custom NotFound message](/custom_notfound)
 
-##Sessions and user state:
+## Sessions and user state:
 * [Session機能](/sessions)
 * [Using session with reloader](/session_with_reloader)
 * [Cookies機能](/cookies)
 * ユーザ認証 (requested)
 
-##Utils:
+## Utils:
 * [メール送信](/sendmail)
 * [GMailへのメール送信](/sendmail_using_gmail)
 
-##Templates:
+## Templates:
 * [Using Site Layout Templates](/layout_template)
 * [Alternating Style](/alternating_style)
 * [makoテンプレートエンジンの使用について](/template_mako/ja)
 * [Cheetahテンプレートエンジンの使用について](/template_cheetah/ja)
 
-##User Input:
+## User Input:
 * [ファイルアップロード](/fileupload)
 * [リクエストデータ(web.inputを利用)へのアクセス](/input)
 * Using basic forms (requested)
 
-##Database:
+## Database:
 * [複数データベース](/multidbs)
 * [Select: データ検索(SELECT文)](/select)
 * [Update: データ更新(UPDATE文)](/update)
@@ -66,7 +66,7 @@ web.py 0.3 ベースのCookbookスタイルのドキュメントです。
 * [問い合わせ(SQL文の発行)](/query)
 * [トランザクションの使用](transactions)
 
-##Deployment:
+## Deployment:
 * [Lighttpd + Fastcgiの配置](/fastcgi-lighttpd)
 * [Apache + Fastcgiの配置](/fastcgi-apache)
 * [Apache + CGIの配置](/cgi-apache/ja)
@@ -75,8 +75,5 @@ web.py 0.3 ベースのCookbookスタイルのドキュメントです。
 * [mod_wsgi deployment through Nginx](/mod_wsgi-nginx )
 * nginx deployment (requested)
 
-
-
-
-##Subdomains:
+## Subdomains:
 * サブドメインおよびユーザー名を使用してにアクセスする方法 (requested)
diff --git a/cookbook/index.md b/cookbook/index.md
index 53a0f45e..63fc7a05 100644
--- a/cookbook/index.md
+++ b/cookbook/index.md
@@ -87,7 +87,6 @@ Other languages: [简体中文](/cookbook/index.zh-cn) | [日本語](/cookbook/i
 * [Integrating SQLite UDF (user-defined-functions) with webpy database layer](/cookbook/sqlite-udf)
 * [Using a dictionary as where clause](/cookbook/where_dict)
 
-
 ## Deployment
 
 * [Fastcgi deployment through lighttpd](/cookbook/fastcgi-lighttpd)
diff --git a/cookbook/index.zh-cn.md b/cookbook/index.zh-cn.md
index 842c3dbf..4de496ac 100644
--- a/cookbook/index.zh-cn.md
+++ b/cookbook/index.zh-cn.md
@@ -18,7 +18,7 @@ title: Web.py Cookbook 简体中文版
 
 1. 该手册适用于0.3版本，所以您在添加代码时，请确认代码能在新版本中工作。
 
--------------------------------------------------
+---
 
 ## 基本应用
 
@@ -51,7 +51,6 @@ title: Web.py Cookbook 简体中文版
 * [一个在postgreSQL数据库环境下的用户认证的例子](userauthpgsql.zh-cn)
 * [如何在子应用中操作Session](sessions_with_subapp.zh-cn)
 
-
 ## Utils 实用工具
 
 * [如何发送邮件](sendmail.zh-cn)
diff --git a/cookbook/input.fr.md b/cookbook/input.fr.md
index 0289fba6..d55c940d 100644
--- a/cookbook/input.fr.md
+++ b/cookbook/input.fr.md
@@ -5,8 +5,7 @@ title: Accéder aux entrées utilisateurs par le biais de web.input
 
 # Accéder aux entrées utilisateurs par le biais de web.input
 
-Autre langages: [english](/../input) | ...
-
+Autre langages: [English](/../input) | ...
 
 ### Problème:
 
@@ -29,14 +28,12 @@ Parfois, vous aurez besoin de spécifier une variable par défaut, dans le cas o
             user_data = web.input(id="no data")
             return "<h1>" + user_data.id + "</h1>"
 
-
 *Notez que les valeurs de web.input() sont des chaînes, même si ce sont des numéros qui lui sont passées*
 
 Que faire si vous passez plusieurs noms de variable équivalents, comme ceci:
 
 <select multiple size="3"><option>foo</option><option>bar</option><option>baz</option></select>
 
-
 Vous aurez besoin de faire savoir à web.input qu'il doit s'attendre à des entrées multiples, sinon il les référencera tous, sauf un. Passez la valeur par défaut d'une liste à web.input et il fonctionnera correctement. Par exemple,  http://example.com?id=10&id=20:
 
     class SomePage:
diff --git a/cookbook/input.md b/cookbook/input.md
index 6afaa83a..0dc3c8df 100644
--- a/cookbook/input.md
+++ b/cookbook/input.md
@@ -5,14 +5,16 @@ title: web.input
 
 # web.input
 
-Other languages: [français](/../cookbook/input.fr) | ...
+Other languages: [Français](/../cookbook/input.fr) | ...
 
-##web.input
+## web.input
 
 ### Problem
+
 You want user data from a form, or a url encoded parameter.
 
 ### Solution
+
 The web.input() method returns a web.storage object (a dictionary-like object) that contains the variables from the url (in a GET) or in the http header (in a POST).  For example, if you go to the page http://example.com/test?id=10, on the Python backend you'll want to extract that the id=10.  Using web.input(), this becomes trivial:
 
     class SomePage:
@@ -29,7 +31,6 @@ Sometimes you may want to specify a default variable, in case none is given.  Th
 
 Note that the web.input() values will be strings even if there are numbers passed to it.
 
-
 What if you pass several of the same variable names, like this:
 
 <select multiple size="3"><option>foo</option><option>bar</option><option>baz</option></select>
diff --git a/cookbook/input.zh-cn.md b/cookbook/input.zh-cn.md
index c0fa76a0..56d8f97e 100644
--- a/cookbook/input.zh-cn.md
+++ b/cookbook/input.zh-cn.md
@@ -5,12 +5,14 @@ title: web.input
 
 # web.input
 
-##web.input
+## web.input
 
 ### 问题
+
 如何从form或是url参数接受用户数据.
 
 ### 解决方法
+
 web.input()方法返回一个包含从url(GET方法)或http header(POST方法,即表单POST)获取的变量的web.storage对象(类似字典).举个例子,如果你访问页面http://example.com/test?id=10,在Python后台你想取得 id=10 ,那么通过web.input()那就是小菜一碟:
 
     class SomePage:
@@ -27,7 +29,6 @@ web.input()方法返回一个包含从url(GET方法)或http header(POST方法,
 
 注意,web.input()取得的值都会被当作string类型,即使你传递的是一些数字.
 
-
 如果你想传递一个多值变量,比如像这样:
 
 <select multiple size="3"><option>foo</option><option>bar</option><option>baz</option></select>
diff --git a/cookbook/layout_template.fr.md b/cookbook/layout_template.fr.md
index f37b9c67..3c5f0ca9 100644
--- a/cookbook/layout_template.fr.md
+++ b/cookbook/layout_template.fr.md
@@ -5,27 +5,20 @@ title: Mise en page selon un gabarit
 
 # Mise en page selon un gabarit
 
-Autres langages : [english](/../layout_template) | ...
-
-
+Autres langages: [English](/../layout_template) | ...
 
 ### Problème
 
-
 Comment puis-je utiliser un modèle/gabarit de site qui s'affiche dans chaque page? (Dans d'autres frameworks, cela s'appelle l'héritage des templates - template inheritance)
 
 ### Solution
 
-
 Cela peut être fait en utilisant l'attribut de base:
 
     render = web.template.render('templates/', base='layout')
 
-
 Maintenant si vous faites quelque chose comme `render.foo ()` il cherchera le gabarit `templates/foo.html`, puis l'enveloppera dans le gabarit `templates/layout.html`
 
-
-
 Le format de "layout.html" doit être un simple gabarit qui contient une variable. Par exemple:
 
     $def with (content)
@@ -38,19 +31,20 @@ Le format de "layout.html" doit être un simple gabarit qui contient une variabl
     </body>
     </html>
 
-
 Si vous ne souhaitez pas utiliser le modèle de base, il suffit de créer un deuxième objet, sans l'attribut "base", ainsi:
 
     render_plain = web.template.render('templates/')
 
-###Astuce: Le titre de page est défini dans d'autres fichiers gabarits qui sont ensuite utilisés par la mise en page (layout.html). Par exemple:
+### Astuce: Le titre de page est défini dans d'autres fichiers gabarits qui sont ensuite utilisés par la mise en page (layout.html). Par exemple:
+
+##### templates/index.html
 
-#####templates/index.html
     $var title: This is title.
 
     <h3>Hello, world</h3>
 
-#####templates/layout.html
+##### templates/layout.html
+
     $def with (content)
     <html>
     <head>
@@ -61,16 +55,15 @@ Si vous ne souhaitez pas utiliser le modèle de base, il suffit de créer un deu
     </body>
     </html>
 
+### Astuce: Ajouter des fichiers css dans d'autres fichiers gabarits. Exemple:
 
-###Astuce: Ajouter des fichiers css dans d'autres fichiers gabarits. Exemple:
-
-####templates/login.html
+#### templates/login.html
 
     $var cssfiles: static/login.css static/login2.css
 
     hello, world.
 
-####templates/layout.html
+#### templates/layout.html
 
     $def with (content)
     <html>
diff --git a/cookbook/layout_template.md b/cookbook/layout_template.md
index a4930143..6ab68f6f 100644
--- a/cookbook/layout_template.md
+++ b/cookbook/layout_template.md
@@ -5,7 +5,7 @@ title: Site Layout Template
 
 # Site Layout Template
 
-Other languages : [français](/layout_template.fr) | ...
+Other languages: [Français](/layout_template.fr) | ...
 
 ### Problem
 
@@ -35,14 +35,16 @@ If you don't want to use the base template for something, just create a second r
 
     render_plain = web.template.render('templates/')
 
-###Tip: Page title is set in other template files which are then used by the layout (layout.html). Example:
+### Tip: Page title is set in other template files which are then used by the layout (layout.html). Example:
+
+##### templates/index.html
 
-#####templates/index.html
     $var title: This is title.
 
     <h3>Hello, world</h3>
 
-#####templates/layout.html
+##### templates/layout.html
+
     $def with (content)
     <html>
     <head>
@@ -53,14 +55,15 @@ If you don't want to use the base template for something, just create a second r
     </body>
     </html>
 
-###Tip: Add css files in other template files. Example:
-####templates/login.html
+### Tip: Add css files in other template files. Example:
+
+#### templates/login.html
 
     $var cssfiles: static/login.css static/login2.css
 
     hello, world.
 
-####templates/layout.html
+#### templates/layout.html
 
     $def with (content)
     <html>
diff --git a/cookbook/layout_template.zh-cn.md b/cookbook/layout_template.zh-cn.md
index a5aedc9a..1090a0f3 100644
--- a/cookbook/layout_template.zh-cn.md
+++ b/cookbook/layout_template.zh-cn.md
@@ -36,11 +36,13 @@ title: 站点布局模板
 ### Tip: 在布局文件（layout.html）中定义的页面标题变量，如何在其他模板文件中赋值，如下:
 
 ##### templates/index.html
+
     $var title: This is title.
 
     <h3>Hello, world</h3>
 
 ##### templates/layout.html
+
     $def with (content)
     <html>
     <head>
@@ -52,6 +54,7 @@ title: 站点布局模板
     </html>
 
 ### Tip: 在其他模板中引用css文件，如下:
+
 #### templates/login.html
 
     $var cssfiles: static/login.css static/login2.css
diff --git a/cookbook/limiting_upload_size.fr.md b/cookbook/limiting_upload_size.fr.md
index b010fecc..a34a0067 100644
--- a/cookbook/limiting_upload_size.fr.md
+++ b/cookbook/limiting_upload_size.fr.md
@@ -5,7 +5,7 @@ title: Comment limiter la taille des fichiers uploadés
 
 # Comment limiter la taille des fichiers uploadés
 
-Autre langages: [english](/../limiting_upload_size) | ...
+Autre langages: [English](/../limiting_upload_size) | ...
 
 ## Problème:
 
@@ -23,7 +23,6 @@ Le code suivant limite la taille des données entrantes à 10 Mo.
     # 0 ==> Données entrantes illimitées
     cgi.maxlen = 10 * 1024 * 1024 # 10Mo
 
-
 Noter que cela limite la taille des données POST, pas des fichiers uploadés. Cependant, ce sera presque pareil s'il n'y a pas d'autre entrée.
 
 Le module `cgi` lève l'exception `ValueError` quand la taille des données entrées est supérieure à `cgi.maxlen`. Elle peut être interceptée pour afficher le message d'erreur requis.
diff --git a/cookbook/limiting_upload_size.md b/cookbook/limiting_upload_size.md
index eef69810..0bc9ed0c 100644
--- a/cookbook/limiting_upload_size.md
+++ b/cookbook/limiting_upload_size.md
@@ -5,7 +5,7 @@ title: How to put a limit on upload size
 
 # How to put a limit on upload size
 
-Other languages: [français](/../cookbook/limiting_upload_size.fr) | ...
+Other languages: [Français](/../cookbook/limiting_upload_size.fr) | ...
 
 ## Problem
 
diff --git a/cookbook/logging.fr.md b/cookbook/logging.fr.md
index 4b317f81..eb4bb379 100644
--- a/cookbook/logging.fr.md
+++ b/cookbook/logging.fr.md
@@ -5,7 +5,7 @@ title: Contrôler les évènements sur le serveur intégré par défaut
 
 # Contrôler les évènements sur le serveur intégré par défaut
 
-Autre langages: [english](/../logging) | ...
+Autre langages: [English](/../logging) | ...
 
 ## Problème:
 
diff --git a/cookbook/logging.md b/cookbook/logging.md
index 16864ce6..0b27e8b7 100644
--- a/cookbook/logging.md
+++ b/cookbook/logging.md
@@ -5,7 +5,7 @@ title: Logging
 
 # Logging
 
-Other languages: [français](/../cookbook/logging.fr) | ...
+Other languages: [Français](/../cookbook/logging.fr) | ...
 
 ## Problem:
 
@@ -34,7 +34,6 @@ This code works for wsgilog version 0.2
                 backups = config.log_backups
                 )
 
-
 Then when you run your app, you pass a reference to to the class e.g. (if the above was part of the module 'mylog')
 
     from mylog import Log
diff --git a/cookbook/mod_wsgi-apache-ubuntu.md b/cookbook/mod_wsgi-apache-ubuntu.md
index e62210a1..3ba95dea 100644
--- a/cookbook/mod_wsgi-apache-ubuntu.md
+++ b/cookbook/mod_wsgi-apache-ubuntu.md
@@ -85,6 +85,7 @@ If you use sessions with `mod_wsgi`, you should change your code like below:
     application = app.wsgifunc()
 
 ### mod_wsgi performance:
+
 For mod_wsgi performance, please refer to mod_wsgi wiki page:
 
 <http://code.google.com/p/modwsgi/wiki/PerformanceEstimates>
diff --git a/cookbook/mod_wsgi-apache.md b/cookbook/mod_wsgi-apache.md
index 880e698e..b99d35c5 100644
--- a/cookbook/mod_wsgi-apache.md
+++ b/cookbook/mod_wsgi-apache.md
@@ -50,7 +50,7 @@ Steps:
 
 * Point your browser to 'http://your_server_name/appname' to verify whether it works for you.
 
-#Note: mod_wsgi + sessions
+# Note: mod_wsgi + sessions
 
 If you use sessions with mod_wsgi, you should change you code like below:
 
@@ -61,7 +61,8 @@ If you use sessions with mod_wsgi, you should change you code like below:
 
     application = app.wsgifunc()
 
-#mod_wsgi performance:
+# mod_wsgi performance:
+
 For mod_wsgi performance, please refer to mod_wsgi wiki page:
 
 <http://code.google.com/p/modwsgi/wiki/PerformanceEstimates>
\ No newline at end of file
diff --git a/cookbook/mod_wsgi-nginx.md b/cookbook/mod_wsgi-nginx.md
index 286d0688..b8b09c60 100644
--- a/cookbook/mod_wsgi-nginx.md
+++ b/cookbook/mod_wsgi-nginx.md
@@ -9,7 +9,6 @@ It is possible to deploy web.py with nginx using a mod_wsgi similar to the modul
 
 After compiling and installing nginx with mod_wsgi, you can easily get a web.py app up and running with the following config* (edit the paths and settings with your own):
 
-
     wsgi_python_executable  /usr/bin/python;
 
     server {
diff --git a/cookbook/mod_wsgi-nginx.zh-cn.md b/cookbook/mod_wsgi-nginx.zh-cn.md
index ef1e6ce1..59ee101f 100644
--- a/cookbook/mod_wsgi-nginx.zh-cn.md
+++ b/cookbook/mod_wsgi-nginx.zh-cn.md
@@ -9,7 +9,6 @@ title: 使用 Nginx 加 mod_wsgi 模块部署 web.py
 
 在编译并安装好 Nginx 的 mod_wsgi 模块后，使用下面配置文件提供的形式(注意需要修改相应的配置和路径)，即可部署一个 web.py 应用程序。
 
-
     wsgi_python_executable  /usr/bin/python;
 
     server {
@@ -23,7 +22,6 @@ title: 使用 Nginx 加 mod_wsgi 模块部署 web.py
          }
     }
 
-
 *注意：本段配置是 mod_wsgi 方式部署Web应用程序的示例，不是 Nginx 配置的完整信息。
 
 参考链接:<br />
diff --git a/cookbook/multidbs.md b/cookbook/multidbs.md
index 0a9cc7f1..e509053d 100644
--- a/cookbook/multidbs.md
+++ b/cookbook/multidbs.md
@@ -6,6 +6,7 @@ title: Multiple Databases
 # Multiple Databases
 
 ## Problem
+
 You want to access multiple databases in a single project.
 
 ## Solution
diff --git a/cookbook/multidbs.zh-cn.md b/cookbook/multidbs.zh-cn.md
index 1ed454fe..5f316a2e 100644
--- a/cookbook/multidbs.zh-cn.md
+++ b/cookbook/multidbs.zh-cn.md
@@ -6,6 +6,7 @@ title: 多数据库使用
 # 多数据库使用
 
 ## 问题
+
 如何在单独项目中应用多数据库?
 
 ## 解决办法
diff --git a/cookbook/postbasic.fr.md b/cookbook/postbasic.fr.md
index 78f9de85..e399d4c9 100644
--- a/cookbook/postbasic.fr.md
+++ b/cookbook/postbasic.fr.md
@@ -5,7 +5,7 @@ title: Lire les données brutes d un post
 
 # Lire les données brutes d un post
 
-Autres langages [english](/../postbasic) | ...
+Autres langages: [English](/../postbasic) | ...
 
 ## Probleme:
 
diff --git a/cookbook/postbasic.md b/cookbook/postbasic.md
index ca8427ae..d2309b00 100644
--- a/cookbook/postbasic.md
+++ b/cookbook/postbasic.md
@@ -5,13 +5,12 @@ title: Reading raw data from post
 
 # Reading raw data from post
 
-Other languages: [français](/../cookbook/postbasic.fr) | ...
+Other languages: [Français](/../cookbook/postbasic.fr) | ...
 
 ## Introduction
 
 Sometimes, the client sends a lot of data by the POST method. In webpy, you can handle it like this.
 
-
 ## Code
 
     class RequestHandler(object):
diff --git a/cookbook/postbasic.zh-cn.md b/cookbook/postbasic.zh-cn.md
index 132ec2d0..2da4bf79 100644
--- a/cookbook/postbasic.zh-cn.md
+++ b/cookbook/postbasic.zh-cn.md
@@ -9,7 +9,6 @@ title: 从post读取原始数据
 
 有时候，浏览器会通过post发送很多数据。在webpy，你可以这样操作。
 
-
 ## 代码
 
     class RequestHandler(object):
diff --git a/cookbook/redirect+seeother.fr.md b/cookbook/redirect+seeother.fr.md
index 312f4203..4b4ce71f 100644
--- a/cookbook/redirect+seeother.fr.md
+++ b/cookbook/redirect+seeother.fr.md
@@ -5,8 +5,7 @@ title: web.redirect et web.seeother
 
 # web.redirect et web.seeother
 
-Autres langages [english](/../redirect+seeother/) | ...
-
+Autres langages: [English](/../redirect+seeother/) | ...
 
 ### Probleme
 
@@ -19,7 +18,6 @@ Après le traitement des entrées utilisateurs (depuis un formulaire, par exempl
             # Executez une application logique ici, puis:
             raise web.seeother('/someotherpage')
 
-
 Quand un post est envoyé à cette fonction, à la fin il enverra au navigateur un code HTTP 303, et le nouvel emplacement. Le navigateur va alors effectuer un GET sur l'emplacement défini dans l'argument seeother.
 
 Note: web.seeother et web.redirect génèrent des exceptions dans la version 0.3.
diff --git a/cookbook/redirect+seeother.md b/cookbook/redirect+seeother.md
index 257675e3..ab3baa97 100644
--- a/cookbook/redirect+seeother.md
+++ b/cookbook/redirect+seeother.md
@@ -5,11 +5,12 @@ title: web.redirect and web.seeother
 
 # web.redirect and web.seeother
 
-Other languages:  [français](/../cookbook/redirect+seeother.fr) | ...
+Other languages:  [Français](/../cookbook/redirect+seeother.fr) | ...
 
 ## web.redirect and web.seeother
 
 ### Problem
+
 After processing user input (from a form, let's say), you want to redirect them to another page.
 
 ### Solution
@@ -24,4 +25,5 @@ When a post is sent to this function, on completion it will send the browser an
 Note: web.seeother and web.redirect are made exceptions in 0.3.
 
 ### Hangups
+
 It's unlikely that you want to use the web.redirect function very often -- it appears to do the same thing, but it sends the http code 301, which is a permanent redirect.  Most web browsers will cache the new redirection, and will send you to that location automatically when you try to perform the action again.  A good use case for redirect is when you're changing the URL structure of your site, but want the old links to work due to bookmarking.
diff --git a/cookbook/runtime-language-switch.md b/cookbook/runtime-language-switch.md
index d8afe601..d98771dd 100644
--- a/cookbook/runtime-language-switch.md
+++ b/cookbook/runtime-language-switch.md
@@ -6,6 +6,7 @@ title: Run-time language switch
 # Run-time language switch
 
 ## Problem:
+
 How to implement run-time language switch?
 
 ## Solution:
@@ -99,7 +100,6 @@ File: code.py
 
     if __name__ == "__main__": app.run()
 
-
 Template file: templates/index.html.
 
     $_('Hello')
diff --git a/cookbook/runtime-language-switch.zh-cn.md b/cookbook/runtime-language-switch.zh-cn.md
index 84495454..ef1ed795 100644
--- a/cookbook/runtime-language-switch.zh-cn.md
+++ b/cookbook/runtime-language-switch.zh-cn.md
@@ -6,6 +6,7 @@ title: 实时语言切换
 # 实时语言切换
 
 ## 问题:
+
 如何实现实时语言切换？
 
 ## 解法:
@@ -99,7 +100,6 @@ title: 实时语言切换
 
     if __name__ == "__main__": app.run()
 
-
 模板文件: templates/index.html.
 
     $_('Hello')
diff --git a/cookbook/select.md b/cookbook/select.md
index 523191df..6d0fa1cf 100644
--- a/cookbook/select.md
+++ b/cookbook/select.md
@@ -54,8 +54,8 @@ print(results[1])   # works too
 If SQL column is defined as binary format, e.g. `VARBINARY` in MySQL/MariaDB, `BYTEA` in PostgreSQL, returned value will be a `bytes` string, not `str`. For example:
 
 1. Create a SQL table in MySQL/MariaDB with command: `CREATE TABLE mytable (email VARBINARY(255));`
-1. Insert a sample record: `INSERT INTO mytable (email) VALUES ("test@domain.com");`
-1. Query it with web.py db module:
+2. Insert a sample record: `INSERT INTO mytable (email) VALUES ("test@domain.com");`
+3. Query it with web.py db module:
 
 ```
 qr = db.select("mytable", what="email", limit=1)
diff --git a/cookbook/sendmail_using_gmail.fr.md b/cookbook/sendmail_using_gmail.fr.md
index b7077657..873e111b 100644
--- a/cookbook/sendmail_using_gmail.fr.md
+++ b/cookbook/sendmail_using_gmail.fr.md
@@ -5,25 +5,22 @@ title: Envoi de mails en utilisant Gmail
 
 # Envoi de mails en utilisant Gmail
 
-Autre langages: [english](/../sendmail_using_gmail) | ...
+Autre langages: [English](/../sendmail_using_gmail) | ...
 
-
-##Problème:
+## Problème:
 
 Comment envoyer un mail en utilisant Gmail ?
 
-##Solution:
+## Solution:
 
 Il est souvent fastidieux de configurer et de maintenir un serveur de messagerie. Si vous possédez un compte Gmail, vous pouvez utiliser Gmail comme serveur SMTP pour envoyer des mails. Pour cela, vous aurez besoin de spécifier le nom d'utilisateur et le mot de passe du compte Gmail dans `web.config`.
 
-
     web.config.smtp_server = 'smtp.gmail.com'
     web.config.smtp_port = 587
     web.config.smtp_username = 'cookbook@gmail.com'
     web.config.smtp_password = 'secret'
     web.config.smtp_starttls = True
 
-
 Une fois la configuration définie, `web.sendmail` peut être employé pour envoyer des mails en utilisant le compte Gmail. Gmail signe tous ces mails.
 
     web.sendmail('cookbook@gmail.com', 'user@example.com', 'subject', 'message')
diff --git a/cookbook/sendmail_using_gmail.md b/cookbook/sendmail_using_gmail.md
index 0869e02a..ecd0346b 100644
--- a/cookbook/sendmail_using_gmail.md
+++ b/cookbook/sendmail_using_gmail.md
@@ -5,13 +5,13 @@ title: Sending mail using gmail
 
 # Sending mail using gmail
 
-Other languages: [français](/../cookbook/sendmail_using_gmail.fr) | ...
+Other languages: [Français](/../cookbook/sendmail_using_gmail.fr) | ...
 
-##Problem:
+## Problem:
 
 How to send mail using gmail.
 
-##Solution:
+## Solution:
 
 Often it is tedious to setup and maintain a mail server. If you have a
 gmail accout, you can use gmail as SMTP server to send mail. To do
diff --git a/cookbook/session_in_template.fr.md b/cookbook/session_in_template.fr.md
index fe9d05a4..68de85bd 100644
--- a/cookbook/session_in_template.fr.md
+++ b/cookbook/session_in_template.fr.md
@@ -5,14 +5,13 @@ title: Utiliser session dans les gabarits
 
 # Utiliser session dans les gabarits
 
-Autre langages: [english](/../session_in_template) | ...
+Autre langages: [English](/../session_in_template) | ...
 
-
-##Problème:
+## Problème:
 
 Vous souhaitez utiliser session dans votre gabarit (par exemple pour obtenir session.username et l'afficher)
 
-##Solution:
+## Solution:
 
 Dans le code de votre application:
 
diff --git a/cookbook/session_in_template.md b/cookbook/session_in_template.md
index c33704ee..a64ff35e 100644
--- a/cookbook/session_in_template.md
+++ b/cookbook/session_in_template.md
@@ -5,13 +5,13 @@ title: Using session in template
 
 # Using session in template
 
-Other languages: [français](/../cookbook/session_in_template.fr) | ...
+Other languages: [Français](/../cookbook/session_in_template.fr) | ...
 
-##Problem:
+## Problem:
 
 I want to use session in template (e.g. get session.username to display)
 
-##Solution:
+## Solution:
 
 In your application code:
 
diff --git a/cookbook/session_with_reloader.fr.md b/cookbook/session_with_reloader.fr.md
index 1456da56..11c367cb 100644
--- a/cookbook/session_with_reloader.fr.md
+++ b/cookbook/session_with_reloader.fr.md
@@ -5,7 +5,7 @@ title: Utiliser les sessions avec reloader
 
 # Utiliser les sessions avec reloader
 
-Autre langages: [english](./session_with_reloader) | ...
+Autre langages: [English](./session_with_reloader) | ...
 
 # Probleme
 
@@ -22,7 +22,6 @@ Un simple correctif pour ceci, est de désactiver le mode debug, ce qui peut êt
 
     # Le reste de votre code
 
-
 Si vous voulez utiliser les sessions en mode debug, voici une solution de fortune.
 
 Depuis que le mode de débogage permet le module reloading, le reloader charge le module principal à deux reprises (une fois comme __main__ et une fois avec son nom), deux objets session sont créés. Cela peut être évité en stockant la session dans un emplacement global afin d'éviter la création de la seconde.
diff --git a/cookbook/session_with_reloader.md b/cookbook/session_with_reloader.md
index ea88781c..45a0948a 100644
--- a/cookbook/session_with_reloader.md
+++ b/cookbook/session_with_reloader.md
@@ -5,7 +5,7 @@ title: Using session with reloader
 
 # Using session with reloader
 
-Other languages: [français](/../cookbook/session_with_reloader.fr) | ...
+Other languages: [Français](/../cookbook/session_with_reloader.fr) | ...
 
 # Problem
 
@@ -21,7 +21,6 @@ Simplest fix for this is to disable debug mode, which can be done by setting `we
 
     # rest of your code
 
-
 If you want to use sessions in debug mode then here is a work-around.
 
 Since debug mode enables module reloading, the reloader loads the main module twice (once as __main__ and once with its name), 2 session objects will be created. This can be avoided by storing the session in some global place to avoid creating the second one.
diff --git a/cookbook/session_with_reloader.zh-cn.md b/cookbook/session_with_reloader.zh-cn.md
index c1b81e9f..a0a659d4 100644
--- a/cookbook/session_with_reloader.zh-cn.md
+++ b/cookbook/session_with_reloader.zh-cn.md
@@ -18,7 +18,6 @@ title: 在调试模式下使用session
 
     # rest of your code
 
-
 如果非要用调试模式下使用session，可以用非主流的一些办法。哈哈
 
 因为调试模式支持模块重载入(重载入，绝非重载。是reload,而非override)，所以reloader会载入主模块两次，因此，就会创建两个session对象。但我们只要把session存储在全局的数据容器中，就能避免二次创建session。
diff --git a/cookbook/sessions.fr.md b/cookbook/sessions.fr.md
index 67c09efc..c3961879 100644
--- a/cookbook/sessions.fr.md
+++ b/cookbook/sessions.fr.md
@@ -5,7 +5,7 @@ title: Travailler avec les sessions
 
 # Travailler avec les sessions
 
-Autre langages: [english](/../sessions) | ...
+Autre langages: [English](/../sessions) | ...
 
 ### Problème
 
@@ -43,7 +43,6 @@ L'objet session est chargé avec des données session avant le traitement de la
 
 L'argument optionnel `initializer` de Session spécifie la session initiale.
 
-
 Vous pouvez utiliser `DBStore` à la place de `DiskStore` si vous préférez stocker les sessions dans une base de donnée au lieu du disque. Pour utiliser DBStore, vous avez besoin d'une table avec la structure suivante:
 
      create table sessions (
@@ -58,7 +57,6 @@ Puis vous devez passer l'objet `db` et le nom de la table de session au constuct
     store = web.session.DBStore(db, 'sessions')
     session = web.session.Session(app, store, initializer={'count': 0})
 
-
 Des options relatives aux sessions peuvent être modifiées en utilisant le dictionnaire `sessions_parameters` dans `web.config`. Les valeurs par défaut sont montrées ci-dessous:
 
     web.config.session_parameters['cookie_name'] = 'webpy_session_id'
diff --git a/cookbook/sessions.md b/cookbook/sessions.md
index 89262ea0..51fc0bbb 100644
--- a/cookbook/sessions.md
+++ b/cookbook/sessions.md
@@ -5,7 +5,7 @@ title: Sessions
 
 # Sessions
 
-Other languages: [français](./sessions.fr) | ...
+Other languages: [Français](./sessions.fr) | ...
 
 ### Problem
 
diff --git a/cookbook/sessions.zh-cn.md b/cookbook/sessions.zh-cn.md
index 83cdd40c..6f800666 100644
--- a/cookbook/sessions.zh-cn.md
+++ b/cookbook/sessions.zh-cn.md
@@ -55,7 +55,6 @@ web.py在处理请求之前，就加载session对象及其数据；在请求处
     store = web.session.DBStore(db, 'sessions')
     session = web.session.Session(app, store, initializer={'count': 0})
 
-
 `web.config`中的`sessions_parameters`保存着session的相关设置，`sessions_parameters`本身是一个字典，可以对其修改。默认设置如下：
 
     web.config.session_parameters['cookie_name'] = 'webpy_session_id'
diff --git a/cookbook/sessions_with_subapp.fr.md b/cookbook/sessions_with_subapp.fr.md
index 81c3a94a..d7385b2d 100644
--- a/cookbook/sessions_with_subapp.fr.md
+++ b/cookbook/sessions_with_subapp.fr.md
@@ -5,31 +5,31 @@ title: Utiliser les sessions avec les sous-applications
 
 # Utiliser les sessions avec les sous-applications
 
-Autre langages: [english](/../sessions_with_subapp) | ...
+Autre langages: [English](/../sessions_with_subapp) | ...
 
-###Note
+### Note
 
 *Cette solution est issue de ce [post](http://www.mail-archive.com/webpy@googlegroups.com/msg02557.html) de la mailing liste de web.py.*
 
-##Problème:
+## Problème:
 
 Dans le comportement par défaut, les informations de session ne peuvent être partagées qu'au sein de l'application principale, même si vous «importez» la session depuis d'autres modules. Vous devez être en mesure d'accéder aux informations de session depuis une sous-application, mais comment?
 
-##Solution:
+## Solution:
 
 Dans votre application principale (code.py par defaut), initialisez votre session de cette façon:
 
     session = web.session.Session(app, web.session.DiskStore('sessions'),
     initializer = {'test': 'woot', 'foo':''})
 
-.. puis créez un processor via web.loadhook
+...puis créez un processor via web.loadhook
 
     def session_hook():
         web.ctx.session = session
 
     app.add_processor(web.loadhook(session_hook))
 
-.. et maintenant dans votre sous-application (par exemple sub-app.py) vous pouvez accèder aux informations de session de cette manière:
+...et maintenant dans votre sous-application (par exemple sub-app.py) vous pouvez accèder aux informations de session de cette manière:
 
     print web.ctx.session.test
     web.ctx.session.foo = 'bar'
\ No newline at end of file
diff --git a/cookbook/sessions_with_subapp.md b/cookbook/sessions_with_subapp.md
index 72444974..278496da 100644
--- a/cookbook/sessions_with_subapp.md
+++ b/cookbook/sessions_with_subapp.md
@@ -5,40 +5,42 @@ title: Sessions with Sub-apps
 
 # Sessions with Sub-apps
 
-Other languages: [français](/../cookbook/sessions_with_subapp.fr) | ...
+Other languages: [Français](/../cookbook/sessions_with_subapp.fr) | ...
+
+### Note
 
-###Note
 *This solutions is taken from [this](http://www.mail-archive.com/webpy@googlegroups.com/msg02557.html) post on the web.py mailing list.*
 
-##Problem
+## Problem
+
 In its default behavior, session information can only be shared from within the main application, even if you 'import' the session from other modules. You need to be able to access session information from 'sub applications' but how?
 
-##Solution
+## Solution
 
 In your app.py (or main.py) initialize your session like this:
 
     session = web.session.Session(app, web.session.DiskStore('sessions'),
     initializer = {'test': 'woot', 'foo':''})
 
-.. and create a processor via web.loadhook:
+...and create a processor via web.loadhook:
 
     def session_hook():
         web.ctx.session = session
 
     app.add_processor(web.loadhook(session_hook))
 
-.. and now in your 'sub-apps' (like sub-app.py) you can access the the session information like this:
+...and now in your 'sub-apps' (like sub-app.py) you can access the the session information like this:
 
     print web.ctx.session.test
     web.ctx.session.foo = 'bar'
 
-.. if you want to make sessions avaible in templates you should change session_hook function like this:
+...if you want to make sessions avaible in templates you should change session_hook function like this:
 
     def session_hook():
         web.ctx.session = session
         web.template.Template.globals['session'] = session
 
-.. and now you can write in template something like this:
+...and now you can write in template something like this:
 
     $session.get('logged_in', ''):
         <p>You are $session.username</p>
diff --git a/cookbook/sessions_with_subapp.zh-cn.md b/cookbook/sessions_with_subapp.zh-cn.md
index 20e86e37..4f2905dd 100644
--- a/cookbook/sessions_with_subapp.zh-cn.md
+++ b/cookbook/sessions_with_subapp.zh-cn.md
@@ -18,14 +18,14 @@ web.py默认session信息只能在主应用中共享，即便在其他模块中i
     session = web.session.Session(app, web.session.DiskStore('sessions'),
     initializer = {'test': 'woot', 'foo':''})
 
-.. 接下来创建一个被web.loadhook加载的处理器(processor)
+...接下来创建一个被web.loadhook加载的处理器(processor)
 
     def session_hook():
         web.ctx.session = session
 
     app.add_processor(web.loadhook(session_hook))
 
-.. 在子应用(假设是sub-app.py)中，可以这样操作session:
+...在子应用(假设是sub-app.py)中，可以这样操作session:
 
     print web.ctx.session.test
     web.ctx.session.foo = 'bar'
\ No newline at end of file
diff --git a/cookbook/sqlalchemy.md b/cookbook/sqlalchemy.md
index 98c69657..c1367044 100644
--- a/cookbook/sqlalchemy.md
+++ b/cookbook/sqlalchemy.md
@@ -13,7 +13,6 @@ How to use sqlalchemy with web.py
 
 create a load hook and use sqlalchemy's [scoped session] (http://docs.sqlalchemy.org/en/rel_0_8/orm/session.html#using-thread-local-scope-with-web-applications)
 
-
     import string
     import random
     import web
@@ -72,8 +71,7 @@ create a load hook and use sqlalchemy's [scoped session] (http://docs.sqlalchemy
     if __name__ == "__main__":
         app.run()
 
-
-###models.py
+### models.py
 
     from sqlalchemy import create_engine
     from sqlalchemy import Column, Integer, String
@@ -107,6 +105,4 @@ create a load hook and use sqlalchemy's [scoped session] (http://docs.sqlalchemy
     if __name__ == "__main__":
         metadata.create_all(engine)
 
-
-
 before running the application. run `python models.py` to setup the sqlite database.
diff --git a/cookbook/sqlalchemy.zh-cn.md b/cookbook/sqlalchemy.zh-cn.md
index 76c02cc8..085aef9d 100644
--- a/cookbook/sqlalchemy.zh-cn.md
+++ b/cookbook/sqlalchemy.zh-cn.md
@@ -14,7 +14,6 @@ title: sqlalchemy
 创建一个钩子并使用sqlalchemy的scoped session
 (http://www.sqlalchemy.org/docs/05/session.html#unitofwork_contextual)
 
-
     import string
     import random
     import web
@@ -67,8 +66,7 @@ title: sqlalchemy
     if __name__ == "__main__":
         app.run()
 
-
-###models.py
+### models.py
 
     from sqlalchemy import create_engine
     from sqlalchemy import Column, Integer, String
@@ -102,5 +100,4 @@ title: sqlalchemy
     if __name__ == "__main__":
         metadata.create_all(engine)
 
-
 在跑程序之前,运行'python models.py'来初始化一次数据库.
\ No newline at end of file
diff --git a/cookbook/sqlite-udf.md b/cookbook/sqlite-udf.md
index d7128ae7..a792f921 100644
--- a/cookbook/sqlite-udf.md
+++ b/cookbook/sqlite-udf.md
@@ -10,7 +10,8 @@ A user asked at the mailing list and I thought of putting it here for future use
 You can add python functions to sqlite and have them called within your queries.
 
 Example:
-<pre>
+
+```
 >>> import sqlite3 as db
 >>> conn = db.connect(":memory:")
 >>> conn.create_function("sign", 1, lambda val: val and (val > 0 and 1 or -1))
@@ -23,16 +24,18 @@ Example:
 &lt;sqlite3.Cursor object at 0xb759f2c0&gt;
 >>> print cur.fetchall()
 [(1, -1, 0, -1, 1)]
->>> conn.close()</pre>
+>>> conn.close()
+```
 
 In webpy, you can get a reference to the connection object via the cursor
 i.e. db._db_cursor().connection
 
 Example:
-<pre>
+
+```
 >>> import web
 >>> db = web.database(dbn="sqlite", db=":memory:")
 >>> db._db_cursor().connection.create_function("sign", 1, lambda val: val and (val > 0 and 1 or -1))
 >>> print db.query("select sign(1), sign(-1), sign(0), sign(-99), sign(99)").list()
 [&lt;Storage {'sign(1)': 1, 'sign(-1)': -1, 'sign(99)': 1, 'sign(-99)': -1, 'sign(0)': 0}&gt;]
-</pre>
+```
diff --git a/cookbook/sqlite-udf.zh-cn.md b/cookbook/sqlite-udf.zh-cn.md
index 8213b35f..8c317d1e 100644
--- a/cookbook/sqlite-udf.zh-cn.md
+++ b/cookbook/sqlite-udf.zh-cn.md
@@ -1,10 +1,10 @@
----
-layout: default
-title: 整合 SQLite UDF (用户定义函数) 到 webpy 数据库层
----
-
-# 整合 SQLite UDF (用户定义函数) 到 webpy 数据库层
-
+---
+layout: default
+title: 整合 SQLite UDF (用户定义函数) 到 webpy 数据库层
+---
+
+# 整合 SQLite UDF (用户定义函数) 到 webpy 数据库层
+
 问题：
 
 用户在邮件列表中询问，我把它放在这里作为将来使用和参考。
@@ -15,7 +15,7 @@ title: 整合 SQLite UDF (用户定义函数) 到 webpy 数据库层
 
 示例：
 
-<pre>
+```
 >>> import sqlite3 as db
 >>> conn = db.connect(":memory:")
 >>> conn.create_function("sign", 1, lambda val: val and (val > 0 and 1 or -1))
@@ -28,15 +28,17 @@ title: 整合 SQLite UDF (用户定义函数) 到 webpy 数据库层
 &lt;sqlite3.Cursor object at 0xb759f2c0&gt;
 >>> print cur.fetchall()
 [(1, -1, 0, -1, 1)]
->>> conn.close()</pre>
+>>> conn.close()
+```
 
 在webpy中，你可以通过游标如db._db_cursor().connection 取得连接对象的引用。
 
 示例：
-<pre>
+
+```
 >>> import web
 >>> db = web.database(dbn="sqlite", db=":memory:")
 >>> db._db_cursor().connection.create_function("sign", 1, lambda val: val and (val > 0 and 1 or -1))
 >>> print db.query("select sign(1), sign(-1), sign(0), sign(-99), sign(99)").list()
 [&lt;Storage {'sign(1)': 1, 'sign(-1)': -1, 'sign(99)': 1, 'sign(-99)': -1, 'sign(0)': 0}&gt;]
-</pre>
\ No newline at end of file
+```
\ No newline at end of file
diff --git a/cookbook/ssl.fr.md b/cookbook/ssl.fr.md
index 15570ed3..d26442d4 100644
--- a/cookbook/ssl.fr.md
+++ b/cookbook/ssl.fr.md
@@ -5,7 +5,7 @@ title: Configurer le support SSL dans le serveur intégré
 
 # Configurer le support SSL dans le serveur intégré
 
-Autre langages: [english](/../ssl) | ...
+Autre langages: [English](/../ssl) | ...
 
 ## Probleme
 
diff --git a/cookbook/ssl.md b/cookbook/ssl.md
index a2261352..71cf8fdc 100644
--- a/cookbook/ssl.md
+++ b/cookbook/ssl.md
@@ -5,7 +5,7 @@ title: SSL support in built-in cherrypy server
 
 # SSL support in built-in cherrypy server
 
-Other languages: [français](/../cookbook/ssl.fr) | ...
+Other languages: [Français](/../cookbook/ssl.fr) | ...
 
 ## Problem
 
@@ -29,6 +29,7 @@ If you need to include `certificate_chain`, it can passed as additional keyword
 See [cheroot code](https://github.com/cherrypy/cheroot/blob/master/cheroot/ssl/builtin.py) for more details.
 
 ## Solution (Requires latest web.py version [0.37 installed from source as of this writing])
+
     import web
     from web.wsgiserver import CherryPyWSGIServer
 
diff --git a/cookbook/staticfiles.fr.md b/cookbook/staticfiles.fr.md
index 0f10d160..63ee2a09 100644
--- a/cookbook/staticfiles.fr.md
+++ b/cookbook/staticfiles.fr.md
@@ -5,20 +5,18 @@ title: Servir des fichiers statiques (tels que .js, .css et des images)
 
 # Servir des fichiers statiques (tels que .js, .css et des images)
 
-Autre langages : [english](/../staticfiles) | ...
+Autre langages: [English](/../staticfiles) | ...
 
-Probleme
--------
+## Probleme
 Comment servir des fichiers statiques ?
 
-Solution
---------
+## Solution
 
 ### Serveur web.py
 
-Créez un répertoire (ou dossier) que vous nommerez <code>static</code> au même endroit ou se situe le script qui fait tourner web.py (par defaut code.py). Puis plaçez les fichiers statiques que vous servirez dans le repertoire "static".
+Créez un répertoire (ou dossier) que vous nommerez `static` au même endroit ou se situe le script qui fait tourner web.py (par defaut code.py). Puis plaçez les fichiers statiques que vous servirez dans le repertoire "static".
 
-Par exemple, l'url <code>http://localhost/static/logo.png</code> enverra l'image <code>./static/logo.png</code> au client.
+Par exemple, l'url `http://localhost/static/logo.png` enverra l'image `./static/logo.png` au client.
 
 ### Apache
 
diff --git a/cookbook/staticfiles.ja.md b/cookbook/staticfiles.ja.md
index e0e8806f..b8796727 100644
--- a/cookbook/staticfiles.ja.md
+++ b/cookbook/staticfiles.ja.md
@@ -10,7 +10,7 @@ web.pyのサーバーに静的ファイルを配置したいのですが？
 
 ### 解決手段
 
-web.pyサーバを実行するスクリプトファイル(チュートリアルでは <code>code.py</code> を指す)のディレクトリに、新しく静的ファイル用のディレクトリ <code>static</code> を作成してください。
-次に、作成したディレクトリに静的ファイル <code>logo.png</code> を配置してください。
+web.pyサーバを実行するスクリプトファイル(チュートリアルでは `code.py` を指す)のディレクトリに、新しく静的ファイル用のディレクトリ `static` を作成してください。
+次に、作成したディレクトリに静的ファイル `logo.png` を配置してください。
 
-たとえば、画像のURLが <code>http://localhost:8080/static/logo.png</code> ならば <code>./static/logo.png</code> がクライアントに送られます。
\ No newline at end of file
+たとえば、画像のURLが `http://localhost:8080/static/logo.png` ならば `./static/logo.png` がクライアントに送られます。
\ No newline at end of file
diff --git a/cookbook/staticfiles.md b/cookbook/staticfiles.md
index 31c3e8f0..9bc04398 100644
--- a/cookbook/staticfiles.md
+++ b/cookbook/staticfiles.md
@@ -5,7 +5,7 @@ title: Serving Static Files (such as js, css and images)
 
 # Serving Static Files (such as js, css and images)
 
-Other languages : [français](/staticfiles.fr) | ...
+Other languages: [Français](/staticfiles.fr) | ...
 
 # Problem
 
@@ -15,12 +15,12 @@ How to serve static files?
 
 ## web.py server
 
-Create a directory (also known as a folder) called <code>static</code> in the
+Create a directory (also known as a folder) called `static` in the
 location of the script that runs the web.py server. Then place the static
 files you wish to serve in the static folder.
 
-For example, the URL <code>http://localhost/static/logo.png</code> will send
-the image <code>./static/logo.png</code> to the client.
+For example, the URL `http://localhost/static/logo.png` will send
+the image `./static/logo.png` to the client.
 
 ## Apache
 
diff --git a/cookbook/staticfiles.zh-cn.md b/cookbook/staticfiles.zh-cn.md
index 8d0384b5..9d394117 100644
--- a/cookbook/staticfiles.zh-cn.md
+++ b/cookbook/staticfiles.zh-cn.md
@@ -13,7 +13,7 @@ title: 提供静态文件 (诸如js脚本, css样式表和图象文件)
 ### web.py 服务器
 在当前应用的目录下，创建一个名为static的目录，把要提供访问的静态文件放在里面即可。
 
-例如, 网址 <code>http://localhost/static/logo.png</code> 将发送 <code>./static/logo.png</code> 给客户端。
+例如, 网址 `http://localhost/static/logo.png` 将发送 `./static/logo.png` 给客户端。
 
 ### Apache
 在 Apache 中可以使用 [Alias](http://httpd.apache.org/docs/2.2/mod/mod_alias.html#alias) 指令，在处理 web.py 之前将请求映射到指定的目录。
diff --git a/cookbook/storeupload.fr.md b/cookbook/storeupload.fr.md
index cf21fb4a..b640fe8a 100644
--- a/cookbook/storeupload.fr.md
+++ b/cookbook/storeupload.fr.md
@@ -5,7 +5,7 @@ title: Stocker un fichier uploadé
 
 # Stocker un fichier uploadé
 
-Autre langages: [english](/../storeupload) | ...
+Autre langages: [English](/../storeupload) | ...
 
 ## Problème
 
diff --git a/cookbook/storeupload.md b/cookbook/storeupload.md
index b566d0f0..df0f22cf 100644
--- a/cookbook/storeupload.md
+++ b/cookbook/storeupload.md
@@ -5,7 +5,7 @@ title: Store an uploaded file
 
 # Store an uploaded file
 
-Other languages: [français](/../cookbook/storeupload/fr) | ...
+Other languages: [Français](/../cookbook/storeupload/fr) | ...
 
 ## Problem
 
diff --git a/cookbook/streaming_large_files.fr.md b/cookbook/streaming_large_files.fr.md
index 58a9ab9d..cb3ec7ff 100644
--- a/cookbook/streaming_large_files.fr.md
+++ b/cookbook/streaming_large_files.fr.md
@@ -5,7 +5,7 @@ title: Comment streamer de gros fichiers
 
 # Comment streamer de gros fichiers
 
-Autre langages: [english](/../streaming_large_files) | ...
+Autre langages: [English](/../streaming_large_files) | ...
 
 ## Problème:
 
@@ -15,7 +15,6 @@ Vous souhaitez utiliser web.py pour streamer de gros fichiers.
 
 Voici un exemple qui vous permettra d'utiliser web.py pour streamer de larges fichiers. Vous verrez qu'il fonctionne comme annoncé, mais vous devez vous assurer que vous avez ajouté 'chunked' dans l'en-tête Transfer-Encoding pour qu'il s'affiche correctement. Sinon, le navigateur va mettre en cache toutes les données avant de vous les afficher.
 
-
 Vous ne pouvez pas mélanger une chaîne de base et les retours [ Yield](http://fr.wikipedia.org/wiki/Yield_(instruction)) dans la même méthode. Si vous utilisez [ Yield](http://fr.wikipedia.org/wiki/Yield_(instruction)), vous devrez utiliser [ Yield](http://fr.wikipedia.org/wiki/Yield_(instruction)) pour tout, parce que votre fonction devient un générateur.
 
 ## Simple exemple
diff --git a/cookbook/streaming_large_files.md b/cookbook/streaming_large_files.md
index bf255701..aa5616ee 100644
--- a/cookbook/streaming_large_files.md
+++ b/cookbook/streaming_large_files.md
@@ -5,7 +5,7 @@ title: How to Stream Large Files
 
 # How to Stream Large Files
 
-Other languages: [français](/../cookbook/streaming_large_files.fr) | ...
+Other languages: [Français](/../cookbook/streaming_large_files.fr) | ...
 
 ## Problem
 
@@ -17,7 +17,6 @@ This is an example of how you can use web.py to stream large files. You'll find
 
 You can't mix basic string and yield returns in the same method.  If you use yield, you'll have to use yield for everything because your function becomes a generator.
 
-
 ## Simple Example
 
 ```
diff --git a/cookbook/subapp.fr.md b/cookbook/subapp.fr.md
index 0187dada..d1b4a09f 100644
--- a/cookbook/subapp.fr.md
+++ b/cookbook/subapp.fr.md
@@ -5,7 +5,7 @@ title: Utiliser les sous-applications
 
 # Utiliser les sous-applications
 
-Autre langages: [english](/../subapp) | ...
+Autre langages: [English](/../subapp) | ...
 
 ## Probleme
 
diff --git a/cookbook/subapp.ja.md b/cookbook/subapp.ja.md
index 809352f7..be567eb2 100644
--- a/cookbook/subapp.ja.md
+++ b/cookbook/subapp.ja.md
@@ -9,7 +9,6 @@ title: サブアプリケーションの使い方について(別ファイルの
 
 別ファイルのWebアプリケーション(ここではblog.py)をインクルードするにはどうすればいいですか？
 
-
 ## 解決手段
 
 In `blog.py`:
diff --git a/cookbook/subapp.md b/cookbook/subapp.md
index dc9e1ae4..15ba1b21 100644
--- a/cookbook/subapp.md
+++ b/cookbook/subapp.md
@@ -5,7 +5,7 @@ title: using subapplications
 
 # using subapplications
 
-Other languages [français](/../cookbook/subapp.fr) | ...
+Other languages: [Français](/../cookbook/subapp.fr) | ...
 
 ## Problem
 
diff --git a/cookbook/template_cheetah.md b/cookbook/template_cheetah.md
index 07c1fd23..ff3ac51c 100644
--- a/cookbook/template_cheetah.md
+++ b/cookbook/template_cheetah.md
@@ -6,6 +6,7 @@ title: Use Cheetah template engine in webpy
 # Use Cheetah template engine in webpy
 
 ### Problem
+
 How to use Cheetah template engine in webpy?
 
 ### Solution
diff --git a/cookbook/template_cheetah.zh-cn.md b/cookbook/template_cheetah.zh-cn.md
index d5e91174..6e7747b3 100644
--- a/cookbook/template_cheetah.zh-cn.md
+++ b/cookbook/template_cheetah.zh-cn.md
@@ -1,11 +1,12 @@
----
-layout: default
-title: 在webpy中使用Cheetah模板引擎
----
-
-# 在webpy中使用Cheetah模板引擎
-
+---
+layout: default
+title: 在webpy中使用Cheetah模板引擎
+---
+
+# 在webpy中使用Cheetah模板引擎
+
 ### 问题：
+
 怎样在webpy中使用Cheetah模板引擎？
 
 ### 解决：
diff --git a/cookbook/template_import.zh-cn.md b/cookbook/template_import.zh-cn.md
index 6d535ea4..c24364e4 100644
--- a/cookbook/template_import.zh-cn.md
+++ b/cookbook/template_import.zh-cn.md
@@ -24,7 +24,6 @@ def status(c):
 当您进行更多的web.py开发时，您将在模板中的各种地方编写更多此类函数。这会使
 模板凌乱，并且违反DRY（Don't Repeat Yourself，不要重复自己）原则。
 
-
 自然地，您可能需要编写一个模块，例如 `display_logic.py` ，并将该模块导入每个
 需要这些函数的模板中。遗憾的是，出于安全原因，模板里禁止使用 `import`。不过，
 可以通过将需要的函数导入全局命名空间来解决此问题：
diff --git a/cookbook/template_jinja.md b/cookbook/template_jinja.md
index f8a6c0ca..ac268dc4 100644
--- a/cookbook/template_jinja.md
+++ b/cookbook/template_jinja.md
@@ -6,6 +6,7 @@ title: Use Jinja2 template engine in webpy
 # Use Jinja2 template engine in webpy
 
 ### Problem
+
 How to use Jinja2 (http://jinja.pocoo.org/2/) template engine in webpy?
 
 ### Solution 1
@@ -43,9 +44,9 @@ if __name__ == "__main__":
 
 ### Template file: templates/hello.html
 
-~~~
+```
 Hello, {{ name }}.
-~~~
+```
 
 ### Solution 2
 
diff --git a/cookbook/template_jinja.zh-cn.md b/cookbook/template_jinja.zh-cn.md
index 38e81fb4..d8d8d2a3 100644
--- a/cookbook/template_jinja.zh-cn.md
+++ b/cookbook/template_jinja.zh-cn.md
@@ -44,6 +44,6 @@ if __name__ == "__main__":
 
 ### 模板文件: templates/hello.html
 
-~~~
+```
 Hello, {{ name }}.
-~~~
+```
diff --git a/cookbook/template_mako.md b/cookbook/template_mako.md
index f4314ac7..272ddc2f 100644
--- a/cookbook/template_mako.md
+++ b/cookbook/template_mako.md
@@ -6,6 +6,7 @@ title: Use Mako template engine in webpy
 # Use Mako template engine in webpy
 
 ### Problem
+
 How to use Mako template engine in webpy?
 
 ### Solution
@@ -49,7 +50,7 @@ Template file:
 
     Hello, ${name}.
 
-###Note:
+### Note:
 
 if you use Apache + mod_wsgi to deploy webpy apps, you may get the similar error msg in your apache error log:
 
@@ -68,14 +69,16 @@ You can use relative paths in order to make it easier too. e.g.
             output_encoding='utf-8',
             )
 
+# Reference:
 
-#Reference:
 * http://code.google.com/p/modwsgi/wiki/ApplicationIssues
 
-#i18n support in Mako template file:
+# i18n support in Mako template file:
+
 Please refer to cookbook 'i18n support in webpy template file' for i18n support in mako template file:
 
 * Cookbook: [i18n support in webpy template file](i18n_support_in_template_file )
 
-#Note:
+# Note:
+
 Babel is only needed to generate the .mo files.
\ No newline at end of file
diff --git a/cookbook/template_mako.zh-cn.md b/cookbook/template_mako.zh-cn.md
index b591176a..1072c161 100644
--- a/cookbook/template_mako.zh-cn.md
+++ b/cookbook/template_mako.zh-cn.md
@@ -9,7 +9,8 @@ title: 在webpy中使用Mako模板引擎
 如何在webpy中使用Mako模板引擎?
 ### 解决方案
 首先需要安装Mako和web.py(0.3):http://www.makotemplates.org/ 然后尝试下面的代码:
-<pre>
+
+```
 # encoding: utf-8
 # File: code.py
 import web
@@ -35,15 +36,15 @@ class hello:
 
 if __name__ == "__main__":
     app.run()
-</pre>
+```
 
 ### 模板文件
 
-<pre>
+```
 ## File: templates/hello.html
 
 Hello, ${name}.
-</pre>
+```
 
 ### 注意:
 如果你使用Apache+mod_wsgi来部署webpy程序, 你也许会在Apache错误日志中得到下面的错误信息:
@@ -51,7 +52,8 @@ Hello, ${name}.
 
 你必须使用绝对路径指出模板的位置.
 你也可以使用相对路径来让它更简单一些:
-<pre>
+
+```
 import os
 
 render = render_mako(
@@ -59,6 +61,7 @@ render = render_mako(
         input_encoding='utf-8',
         output_encoding='utf-8',
         )
-</pre>
+```
+
 ### 参考:
 http://code.google.com/p/modwsgi/wiki/ApplicationIssues
\ No newline at end of file
diff --git a/cookbook/transactions.md b/cookbook/transactions.md
index 8c11551b..8650a99f 100644
--- a/cookbook/transactions.md
+++ b/cookbook/transactions.md
@@ -9,7 +9,6 @@ title: How to use database transactions
 
 How to use database transactions
 
-
 ### Solution
 
 The database object has a method `transaction` which starts a new transaction and returns the transaction object. The transaction object can be used to commit or rollback that transaction.
@@ -37,7 +36,6 @@ With python 2.5+, transaction can be used as with statement also.
         db.insert('person', name='foo')
         db.insert('person', name='bar')
 
-
 It is also possible to have nested transactions.
 
     def post(title, body, tags):
@@ -60,5 +58,4 @@ It is also possible to have nested transactions.
         else:
             t.commit()
 
-
 Nested transactions are ignored for sqlite as they are not supported.
diff --git a/cookbook/trasactions.md b/cookbook/trasactions.md
index 99d49b3d..592be970 100644
--- a/cookbook/trasactions.md
+++ b/cookbook/trasactions.md
@@ -9,7 +9,6 @@ title: How to use database transactions
 
 How to use database transactions
 
-
 ### Solution
 
 The web.DB class has a method `transaction` which returns a transaction object. The transaction object can be used to commit or rollback a transaction.
@@ -35,7 +34,6 @@ With python 2.5+, transaction can be used as with statement also.
         db.insert('person', name='foo')
         db.insert('person', name='bar')
 
-
 It is also possible to have nested transactions.
 
     def post(title, body, tags):
@@ -58,5 +56,4 @@ It is also possible to have nested transactions.
         else:
             t.commit()
 
-
 Nested transactions are ignored for sqlite as they are not supported.
diff --git a/cookbook/unpack_postgres_session.md b/cookbook/unpack_postgres_session.md
index a355f77c..67f0ab99 100644
--- a/cookbook/unpack_postgres_session.md
+++ b/cookbook/unpack_postgres_session.md
@@ -5,7 +5,7 @@ title: Exploit sessions stored in a postgresql database.
 
 # Exploit sessions stored in a postgresql database.
 
-##Problem:
+## Problem:
 
 When using session and storing some ids or any kind of stuff referencing a database, you'll do a lot of queries like this one:
 "select foo, bar from foobar_table where id=%s and id_foor=%s" % (session.id, session.id_foo)
@@ -16,8 +16,7 @@ At the other end, this is also weird to take data in your database to bring them
 
 A cleaner approach would be to access directly these informations in postgresql to read and/or write them.
 
-
-##Solution:
+## Solution:
 
 To apply this recipe, you'll need to use postgresql DBStore for your sessions.
 You'll also need to install the plpythonu in your database.
@@ -79,7 +78,6 @@ With a plpythonu function, we are able to unpack these informations and use them
     $$
     language plpythonu;
 
-
 This function should be as simple as this to use:
 
     select * from unpack_this_session('8982d61db185462b983242beb7009ad12a716aef')
diff --git a/cookbook/update.md b/cookbook/update.md
index b7d4e03d..be95bfaa 100644
--- a/cookbook/update.md
+++ b/cookbook/update.md
@@ -18,5 +18,4 @@ You want to update data that's been entered into a database.
 
 See the [select](/cookbook/select) for more information on arguments that are accepted by update.
 
-
 The update method returns the number of rows updated.
diff --git a/cookbook/update.zh-cn.md b/cookbook/update.zh-cn.md
index b1d957a4..87c51abb 100644
--- a/cookbook/update.zh-cn.md
+++ b/cookbook/update.zh-cn.md
@@ -18,5 +18,4 @@ title: db.upate 数据更新
 
 在 [查询](/cookbook/select/zh-cn) 中有更多关于可用参数的信息。
 
-
 该更新操作会返回更新的影响行数。
diff --git a/cookbook/url_handling.fr.md b/cookbook/url_handling.fr.md
index 07461448..8c0cc1be 100644
--- a/cookbook/url_handling.fr.md
+++ b/cookbook/url_handling.fr.md
@@ -5,16 +5,14 @@ title: Comprendre la gestion des urls
 
 # Comprendre la gestion des urls
 
-Autres langages [english](/../url_handling) | ...
+Autres langages: [English](/../url_handling) | ...
 
-##Probleme: Comment conçevoir un gestionnaire d'url / distribuer un schéma pour l'ensemble du site
+## Probleme: Comment conçevoir un gestionnaire d'url / distribuer un schéma pour l'ensemble du site
 
-
-##Solution:
+## Solution:
 
 Le schéma de traitement des urls de web.py est simple, mais puissant et flexible. Au sommet de chaque application, vous trouverez habituellement le schéma complet de distribution des urls défini comme un tuple:
 
-
     urls = (
         "/tasks/?", "signin",
         "/tasks/list", "listing",
@@ -25,22 +23,18 @@ Le schéma de traitement des urls de web.py est simple, mais puissant et flexibl
         "/tasks/signup", "signup"
     )
 
-
 Le format de ce tuple est: _motif du chemin url_, _gestionnaire de classe_ ce modèle se répètera tant que des motifs de chemins urls sont définis. Si vous ne comprenez pas la relation entre les motifs des chemins urls et les gestionnaire de classe, veuillez lire l'exemple [Hello World](/../helloworld/fr) ou le [rapide tutorial](./tutorial.fr) avant de lire d'autres astuces cookbook.
 
 ## Correspondance des chemins
 
-
 Vous pouvez utiliser la puissance des expressions régulières pour conçevoir des modèles urls plus flexibles. Par exemple,
 /(test1|test2) capturera soit /test1, soit /test2. Le point clef à comprendre est que ce filtrage se déroule sur le 'chemin' même de l'url. Par exemple, pour l'url suivante:
 
     http://localhost/myapp/greetings/hello?name=Joe
 
-
 Le chemin de cette URL est _/myapp/greetings/hello_. web.py ajoutera en interne ^ et $ à la structure de l'url, ce qui fait que le motif _/task/_ ne filtrera pas _/tasks/addnew_. Tandis qu'il filtre le chemin, vous ne pouvez pas utiliser un motif de type: _/tasks/delete?name=(.+)_ alors que la partie après ? appelée 'requête' n'est pas filtrée. Pour une description détaillée des éléments d'URL, veuillez lire [web.ctx](/cookbook/ctx).
 
-
-##Capture de paramètres
+## Capture de paramètres
 
 Dans un motif url vous pouvez capturer des paramètres qui peuvent être utilisés dans votre gestionnaire de classe:
 
@@ -54,7 +48,7 @@ Les blocs après _list/_  sont capturés et peuvent être utilisés comme param
 
 Vous pouvez définir plusieurs paramètres si vous le souhaitez. Notez simplement, que les paramètres de requête URL (qui apparaissent après le ?) peuvent être obtenues à l'aide de [web.input()](/cookbook/input)
 
-##Note sur les sous_applications
+## Note sur les sous_applications
 
 Afin de mieux traiter de grandes applications Web, web.py encourage l'utilisation des [sous-applications](/cookbook/subapp/fr). Tout en concevant des mécanismes d'URL avec des sous-applications, gardez à l'esprit que le chemin (web.ctx.path) trouvera un  chemin parent dépouillé.
 Par exemple, si dans l'application principale, vous transmettez un format d'url "/blog" à la sous-application 'blog', dans votre sous-application blog, tous les formats d'url commençeront avec "/", et non avec /blog. Lisez les astuces cookbook [web.ctx](/cookbook/ctx) pour plus de détails.
diff --git a/cookbook/url_handling.md b/cookbook/url_handling.md
index 69e59d9c..f4e1085a 100644
--- a/cookbook/url_handling.md
+++ b/cookbook/url_handling.md
@@ -5,7 +5,7 @@ title: Understanding URL Handling
 
 # Understanding URL Handling
 
-Other languages : [français](./url_handling.fr) | ...
+Other languages: [Français](./url_handling.fr) | ...
 
 ## Problem: how to design a url handling / dispatching scheme for the entire site
 
diff --git a/cookbook/userauth.fr.md b/cookbook/userauth.fr.md
index 64e2b6c3..f6a46f4a 100644
--- a/cookbook/userauth.fr.md
+++ b/cookbook/userauth.fr.md
@@ -5,15 +5,12 @@ title: Authentification des utilisateurs
 
 # Authentification des utilisateurs
 
-Autres langages : [english](/../userauth) | ...
-
-
+Autres langages: [English](/../userauth) | ...
 
 ## Problème
 
 Vous souhaitez mettre en place un système pour authentifier les utilisateurs.
 
-
 ## Solution
 
 Un système d'authentification des utilisateurs est constitué de plusieurs éléments. L'ajout d'utilisateurs, la connexion des utilisateurs, leurs déconnexion, et vérifier s'ils sont déjà enregistrés. Cela nécessite aussi une base de données. Dans cet exemple nous allons utiliser MD5 et SQLite.
diff --git a/cookbook/userauth.md b/cookbook/userauth.md
index ea42b5b1..973e4afa 100644
--- a/cookbook/userauth.md
+++ b/cookbook/userauth.md
@@ -7,7 +7,7 @@ title: user authentication
 
 #I'm still working on this page, please no body else edit
 
-Other languages : [français](/userauth.fr) | ...
+Other languages: [Français](/userauth.fr) | ...
 
 ## Problem
 
diff --git a/cookbook/userauth.zh-cn.md b/cookbook/userauth.zh-cn.md
index 65471aca..31a05a7b 100644
--- a/cookbook/userauth.zh-cn.md
+++ b/cookbook/userauth.zh-cn.md
@@ -15,7 +15,8 @@ title: 用户认证
 
 用户认证系统由这几个部分组成：用户添加，用户登录，用户注销以及验证用户是否已登录。用户认证系统一般都需要一个数据库。在这个例子中，我们要用到MD5和SQLite。
 
-##
+## 
+
     import hashlib
     import web
 
diff --git a/cookbook/userauthbasic.md b/cookbook/userauthbasic.md
index 36759f60..5602a330 100644
--- a/cookbook/userauthbasic.md
+++ b/cookbook/userauthbasic.md
@@ -5,13 +5,15 @@ title: Basic authentication
 
 # Basic authentication
 
-##Problem
+## Problem
+
 This is a proof of concept implementation of doing basic authentication
 with web.py.
 You may want to read [RFC 2617](http://www.ietf.org/rfc/rfc2617.txt) or
 [http://en.wikipedia.org/wiki/Basic_access_authentication](http://en.wikipedia.org/wiki/Basic_access_authentication) for reference.
 
-##Solution
+## Solution
+
 Create a python file containing the code below and start the script.
 When you enter the url [http://localhost:8080/](http://localhost:8080/) you will be redirected
 to the url [http://localhost:8080/login](http://localhost:8080/login).
@@ -63,5 +65,6 @@ index page.
     if __name__=='__main__':
         app.run()
 
-##Notes
+## Notes
+
 Do not use this code on real site - this is only for illustration.
diff --git a/cookbook/userauthpgsql.md b/cookbook/userauthpgsql.md
index 27f8fa1f..6aaacf22 100644
--- a/cookbook/userauthpgsql.md
+++ b/cookbook/userauthpgsql.md
@@ -13,7 +13,7 @@ You want a system to authenticate users, with a postgresql database.
 
 A user authentication system could have a lot of functions. For this example, we're only going to manage the authentication process, through a postgresql database.
 
-##Needed
+## Needed
 
 web.py for all the web functions, and `hashlib` to store the passwords securely:
 
@@ -38,8 +38,8 @@ First of all, we need a table for the users. This scheme is very simple, but is
 
 There will be 2 states during the login/logout session:
 
-- "Login" is for the login page
-- "Reset" for the logout page.
+* "Login" is for the login page
+* "Reset" for the logout page.
 
 *sessions doesn't work in [debug](./tutorial#developing) mode because it interfere with reloading. see [session_with_reloader](session_with_reloader) for more details.*
 
@@ -97,8 +97,8 @@ def create_render(privilege):
 
 Now, let's have fun:
 
-- If you are already logged, you are redirecting to the login_double.html template file
-- Else, to the login.html.
+* If you are already logged, you are redirecting to the login_double.html template file
+* Else, to the login.html.
 
 ```
 class Login:
@@ -111,10 +111,10 @@ class Login:
             return '%s' % render.login()
 ```
 
-- Ok, ok. Now, for the POST(). According to the .html file, we recover the variables posted in the form (see the login.html), and we compare it to the example_users.user row.
-- For security, we don't store passwords in the database directly, but store the hash of the password + salt; this is kind of line one-way encryption, so we can tell if the user's passwords match, but an attacker couldn't figure out what the password was to start with.
-- If the login/pass is ok, redirect to the login_ok.html.
-- If not, redirect to the login_error.html.
+* Ok, ok. Now, for the POST(). According to the .html file, we recover the variables posted in the form (see the login.html), and we compare it to the example_users.user row.
+* For security, we don't store passwords in the database directly, but store the hash of the password + salt; this is kind of line one-way encryption, so we can tell if the user's passwords match, but an attacker couldn't figure out what the password was to start with.
+* If the login/pass is ok, redirect to the login_ok.html.
+* If not, redirect to the login_error.html.
 
 	    def POST(self):
 	        name, passwd = web.input().name, web.input().passwd
@@ -136,7 +136,6 @@ class Login:
 	            render = create_render(session.privilege)
 	            return render.login_error()
 
-
 For the reset function, we just kill the session, and redirect to the logout.html template file.
 
 	class Reset:
@@ -147,8 +146,8 @@ For the reset function, we just kill the session, and redirect to the logout.htm
 	        render = create_render(session.privilege)
 	        return render.logout()
 
-
 ## 6th: HTML templates help
+
 Well, I think that nobody will need this, but, I prefer to give all the informations. The most important is the login.html.
 
 	<form action="/login" method="POST">
@@ -170,7 +169,7 @@ Well, I think that nobody will need this, but, I prefer to give all the informat
 
 ## 7th: Some problems or questions ?
 
-- Mail: you can contact me at guillaume(at)process-evolution(dot)fr
-- IRC: #webpy on irc.freenode.net (pseudo: Ephedrax)
-- Translations: I'm french, and my english is bad...you can edit my work
-- Revision: Vayn <vayn at vayn dot de>
+* Mail: you can contact me at guillaume(at)process-evolution(dot)fr
+* IRC: #webpy on irc.freenode.net (pseudo: Ephedrax)
+* Translations: I'm french, and my english is bad...you can edit my work
+* Revision: Vayn <vayn at vayn dot de>
diff --git a/cookbook/userauthpgsql.zh-cn.md b/cookbook/userauthpgsql.zh-cn.md
index 9b6256ff..c5e199bc 100644
--- a/cookbook/userauthpgsql.zh-cn.md
+++ b/cookbook/userauthpgsql.zh-cn.md
@@ -40,15 +40,14 @@ CREATE TABLE example_users (
 
 登录和注销对应两个网址：
 
-- "Login" 对应登录页
-- "Reset" 对应注销页
+* "Login" 对应登录页
+* "Reset" 对应注销页
 
 	urls = (
 	 	'/login', 'login',
 		'/reset', 'reset',
     )
 
-
 ## 第三步：判断用户是否登录
 
 要判断用户是否已登录，是非常简单的，只要有个变量记录用户登录的状态即可。在login/reset类中使用这段代码:
@@ -96,8 +95,8 @@ CREATE TABLE example_users (
 ## 第五：登录(Login)和注销(Reset)的python类
 
 现在，让我们用个轻松的方法来解决：
-- 如果你已登录，就直接重定向到login_double.html模板文件
-- 否则，还是到login.html。
+* 如果你已登录，就直接重定向到login_double.html模板文件
+* 否则，还是到login.html。
 
 	class login:
 		def GET(self):
@@ -108,9 +107,9 @@ CREATE TABLE example_users (
 				render = create_render(session.privilege)
 				return "%s" % (render.login())
 
-- 好了。现在写POST()方法。从.html文件中，我们得到表单提交的变量值(见login.html)，并根据变量值得到example_users表中对应的user数据
-- 如果登录通过了，就重定向到login_ok.html。
-- 如果没通过，就重定向到login_error.html。
+* 好了。现在写POST()方法。从.html文件中，我们得到表单提交的变量值(见login.html)，并根据变量值得到example_users表中对应的user数据
+* 如果登录通过了，就重定向到login_ok.html。
+* 如果没通过，就重定向到login_error.html。
 
 		def POST(self):
 			user, passwd = web.input().user, web.input().passwd
@@ -166,5 +165,5 @@ CREATE TABLE example_users (
 
 ## 第七：问题或疑问？
 
-- 邮件：您可以联想我，我的邮箱是guillaume(at)process-evolution(dot)fr
-- IRC：#webpy on irc.freenode.net (pseudo: Ephedrax)
+* 邮件：您可以联想我，我的邮箱是guillaume(at)process-evolution(dot)fr
+* IRC：#webpy on irc.freenode.net (pseudo: Ephedrax)
diff --git a/cookbook/webservice.md b/cookbook/webservice.md
index 160598d4..81f40e38 100644
--- a/cookbook/webservice.md
+++ b/cookbook/webservice.md
@@ -7,8 +7,6 @@ title: Webservice + WSDL
 
 Optio's  [soaplib](http://trac.optio.webfactional.com/) makes it really straightforward to write SOAP web service views by using a decorator to specify types. Plus it's the only Python library, as of today, which is able to generate WSDL documents for your web service.
 
-
-
     import web
     from soaplib.wsgi_soap import SimpleWSGISoapApp
     from soaplib.service import soapmethod
diff --git a/cookbook/webservice.zh-cn.md b/cookbook/webservice.zh-cn.md
index 742261b1..1b735b51 100644
--- a/cookbook/webservice.zh-cn.md
+++ b/cookbook/webservice.zh-cn.md
@@ -12,8 +12,6 @@ title: 用soaplib实现webservice
 ### 解法
 Optio的[soaplib](http://trac.optio.webfactional.com/)通过用装饰器指定类型，从而直接编写SOAP web service。而且它也是到目前为止，唯一为web service提供WSDL文档的Python类库。
 
-
-
     import web
     from soaplib.wsgi_soap import SimpleWSGISoapApp
     from soaplib.service import soapmethod
@@ -59,9 +57,6 @@ Optio的[soaplib](http://trac.optio.webfactional.com/)通过用装饰器指定
     if __name__ == "__main__":
         app.run()
 
-
-
-
 可以用soaplib客户端测试一下：
 
     >>> from soaplib.client import make_service_client
diff --git a/cookbook/where_dict.md b/cookbook/where_dict.md
index 4dc3db94..c2eecf0c 100644
--- a/cookbook/where_dict.md
+++ b/cookbook/where_dict.md
@@ -5,13 +5,11 @@ title: Using a dictionary as where clause
 
 # Using a dictionary as where clause
 
-Problem
--------
+## Problem
 
 You want to create a dictionary of where clauses dynamically and use it in a query.
 
-Solution
---------
+## Solution
 
     >>> import web
     >>> db = web.database(dbn='postgres', db='mydb', user='postgres')
@@ -19,8 +17,7 @@ Solution
     >>> db.delete('mytable', where=web.db.sqlwhere(where_dict), _test=True)
     <sql: "DELETE FROM mytable WHERE col1 = 1 AND col2 = 'sometext'">
 
-Explanation
------------
+## Explanation
 
 `web.db.sqlwhere` takes a Python dictionary as an argument and converts it into a string useful for where clause in different queries. You can also use an optional `grouping` argument to define the exact gouping of the individual keys. For instance:
 
diff --git a/cookbook/where_dict.zh-cn.md b/cookbook/where_dict.zh-cn.md
index 591a625b..df686c36 100644
--- a/cookbook/where_dict.zh-cn.md
+++ b/cookbook/where_dict.zh-cn.md
@@ -1,17 +1,15 @@
----
-layout: default
-title: 使用字典动态构造where子句
----
-
-# 使用字典动态构造where子句
-
-问题
--------
+---
+layout: default
+title: 使用字典动态构造where子句
+---
+
+# 使用字典动态构造where子句
+
+## 问题
 
 你希望创建一个字典来构造动态的where子句并且希望能够在查询语句中使用。
 
-解决
---------
+## 解决
 
     >>> import web
     >>> db = web.database(dbn='postgres', db='mydb', user='postgres')
@@ -19,8 +17,7 @@ title: 使用字典动态构造where子句
     >>> db.delete('mytable', where=web.db.sqlwhere(where_dict), _test=True)
     <sql: "DELETE FROM mytable WHERE col1 = 1 AND col2 = 'sometext'">
 
-解释
------------
+## 解释
 
 `web.db.sqlwhere` takes a Python dictionary as an argument and converts it into a string useful for where clause in different queries. You can also use an optional `grouping` argument to define the exact gouping of the individual keys. For instance:
 
diff --git a/cookbook/xmlfiles.fr.md b/cookbook/xmlfiles.fr.md
index 9c7264ae..5e347948 100644
--- a/cookbook/xmlfiles.fr.md
+++ b/cookbook/xmlfiles.fr.md
@@ -5,28 +5,25 @@ title: Servir du XML
 
 # Servir du XML
 
-Autres langages [english](/../xmlfiles) | ...
+Autres langages: [English](/../xmlfiles) | ...
 
 ### Probleme
 
 Comment servir des fichiers XML correctement?
 
-
 Cela est nécessaire lorsque vous avez une application tierce postant des données au service et attendant une réponse XML.
 
 ### Solution
 
 Créez votre gabarit XML avec le fichier XML que vous souhaitez servir (par exemple : response.xml). Si le XML a des variables, utilisez le code gabarit  correspondant de web.py comme dans cet exemple:
 
-
     $def with (code)
     <?xml version="1.0"?>
     <RequestNotification-Response>
     <Status>$code</Status>
     </RequestNotification-Response>
 
-
-Pour servir ce fichier, créez un programme standard web.py ( par exemple: response.py) et utilisez le code suivant. Soyez conscient que vous devez utiliser <code>web.header('Content-Type', 'text/xml')</code> pour dire au client que vous envoyez un fichier XML. (Vous n'avez pas besoin de définir explicitement l'en-tête des fichiers XML si votre fichier gabarit a l'extension '.xml' )
+Pour servir ce fichier, créez un programme standard web.py ( par exemple: response.py) et utilisez le code suivant. Soyez conscient que vous devez utiliser `web.header('Content-Type', 'text/xml')` pour dire au client que vous envoyez un fichier XML. (Vous n'avez pas besoin de définir explicitement l'en-tête des fichiers XML si votre fichier gabarit a l'extension '.xml' )
 
     import web
 
diff --git a/cookbook/xmlfiles.md b/cookbook/xmlfiles.md
index 7e39ba2a..5d709ed0 100644
--- a/cookbook/xmlfiles.md
+++ b/cookbook/xmlfiles.md
@@ -5,7 +5,7 @@ title: Serving XML
 
 # Serving XML
 
-Other languages:  [français](/../cookbook/xmlfiles.fr) | ...
+Other languages:  [Français](/../cookbook/xmlfiles.fr) | ...
 
 ### Problem
 
@@ -23,8 +23,7 @@ Create your XML template with the XML file you want to serve (i.e. response.xml)
     <Status>$code</Status>
     </RequestNotification-Response>
 
-To serve this file, create a standard Web.Py program (i.e. response.py) and use the following code. Be aware that you should use <code>web.header('Content-Type', 'text/xml')</code> to tell the client that you are sending a XML file. (You don't need to set the header explicitly for XML files if your template file has the ``.xml`` extension.)
-
+To serve this file, create a standard Web.Py program (i.e. response.py) and use the following code. Be aware that you should use `web.header('Content-Type', 'text/xml')` to tell the client that you are sending a XML file. (You don't need to set the header explicitly for XML files if your template file has the ``.xml`` extension.)
 
     import web
 
diff --git a/cookbook/xmlfiles.zh-cn.md b/cookbook/xmlfiles.zh-cn.md
index 87977e6a..988efc7c 100644
--- a/cookbook/xmlfiles.zh-cn.md
+++ b/cookbook/xmlfiles.zh-cn.md
@@ -23,7 +23,6 @@ title: 提供XML访问
 
 为了提供这个XML，需要创建一个单独的web.py程序(如response.py)，它要包含下面的代码。注意：要用"web.header('Content-Type', 'text/xml')"来告知客户端－－正在发送的是一个XML文件。
 
-
     import web
 
     render = web.template.render('templates/', cache=False)
diff --git a/docs/0.2/index.md b/docs/0.2/index.md
index e5df28c0..af4d5426 100644
--- a/docs/0.2/index.md
+++ b/docs/0.2/index.md
@@ -5,9 +5,6 @@ title: web.py 0.2 documentation
 
 # web.py 0.2 documentation
 
-
 * [Tutorial](/tutorial2)
 * [Templetor](/templetor)
 * [API Docs](/docs/0.2/api)
-
-
diff --git a/docs/0.2/tutorial2.de.md b/docs/0.2/tutorial2.de.md
index e7287440..11613c62 100644
--- a/docs/0.2/tutorial2.de.md
+++ b/docs/0.2/tutorial2.de.md
@@ -40,7 +40,6 @@ Nun müssen wir die `index`-Klasse schreiben. Die meisten Leute bemerken es beim
 
 `GET` ist die bekannteste Funktion. Sie wird verwendet, um den Text oder Inhalt einer Webseite anzufordern. Wenn du in deinem Browser `harvard.edu` eintippst, dann forderst du im wahrsten Sinne des Wortes den Harvard Webserver auf "to `GET /`". Am zweit bekanntesten ist `POST`. POST wird oft verwendet, wenn man ein Formular abschickt, wie zum Beispiel eine Anfrage etwas zu kaufen. Du benutzt `POST` immer dann, wenn das Abschicken der Anfrage etwas bewirkt (wenn du die Kreditkarte belastest oder eine Bestellung aufgibst). Das ist sehr wichtig, denn `GET` URLs können herum gereicht werden und von Suchmaschinen indexiert werden. Das ist zwar etwas, was du für einen Großteil deiner Seite willst, aber bestimmt _nicht_ für Dinge wie Bestellungen aufgeben. (Stell dir vor, Google würde versuchen alles auf deiner Seite zu kaufen).
 
-
 In unserem web.py-Quellcode können wir diese zwei Funktionen unterscheiden:
 
     class index:
@@ -68,7 +67,6 @@ Dann wird deine web.py-Applikation einen Webserver auf deinem Computer laufen la
 
     $ python code.py 1234
 
-
 ## Developing
 
 Web.py hat ebenso ein paar Tools, die uns beim Debugging helfen. Füge in der letzten Zeile vor `if __name__` folgendes hinzu:
diff --git a/docs/0.2/tutorial2.el.md b/docs/0.2/tutorial2.el.md
index 9a56236a..5e2fa78c 100644
--- a/docs/0.2/tutorial2.el.md
+++ b/docs/0.2/tutorial2.el.md
@@ -64,7 +64,6 @@ title: Φροντιστήριο για το web.py 0.2
 
     $ python code.py 1234
 
-
 ## Κατά την ανάπτυξη
 
 Το web.py έχει μερικά εργαλεία που μας βοηθάνε στο debbuging. Πριν το `if __name__` στην τελευταία γραμμή, προσθέστε:
diff --git a/docs/0.2/tutorial2.en.md b/docs/0.2/tutorial2.en.md
index 8fa12a91..7e060762 100644
--- a/docs/0.2/tutorial2.en.md
+++ b/docs/0.2/tutorial2.en.md
@@ -5,7 +5,7 @@ title: web.py 0.2 tutorial
 
 # web.py 0.2 tutorial
 
-**This documentation refers to an old version of web.py. <a href="/docs/0.3/tutorial">Checkout the new version</a>.
+**This documentation refers to an old version of web.py. [Checkout the new version](/docs/0.3/tutorial).
 
 ## Starting
 
diff --git a/docs/0.2/tutorial2.es.md b/docs/0.2/tutorial2.es.md
index e5ee0f7b..a795e37e 100644
--- a/docs/0.2/tutorial2.es.md
+++ b/docs/0.2/tutorial2.es.md
@@ -6,6 +6,7 @@ title: tutorial2.es
 # tutorial2.es
 
 ## Tutorial de web.py 0.2
+
 Esta es la versión en español del tutorial en [Inglés](http://webpy.infogami.com/tutorial2.en) de web.py v 0.2, que se encuentra en este mismo sitio. El trabajo de traducción está en desarrollo. Todo aquel que desee colaborar sólo debe crear su cuenta.
 
 ## Iniciando.
@@ -39,7 +40,6 @@ Esta linea dice que queremos que el URL `/` (ej: la página principal) debe ser
 
 Por lo tanto, todo lo que se require es escribir la clase `index`. Aunque la mayoría de las personas no lo saben, su navegador web, utiliza un lenguaje conocido como HTTP para comunicarse con la World Wide Web. Los detalles no son relevantes, pero la idea básica es que los visitantes de su sitio web le solicitan al servidor de web que realice una función especifica (como `GET` o `POST`) con las URLs (como en `/` o `/foo?f=1`).
 
-
 `GET` es el que nos resulta familiar a todos, es el que se usa para pedir el texto de una página web. Cuando escribe `harvard.edu` en su navegador web, éste le pide literarmente al servidor web de Harvard que `GET /`. El segundo más famoso, `POST`, se usa a menudo para enviar ciertos tipos de formularios, como una petición de compra de algún artículo. Usted usa `POST` siempre que el acto de enviar un formulario _hace algo_ (como utilizar su tarjeta de crédito y procesar un recibo). Esta es la clave, porque las `GET` URLs pueden circular y se indexadas por los motores de búsqueda, lo que realmente quieres para la mayoría de tus páginas pero, definitivamente, _no quieres_ que procesen recibos (¡imagina que Google intentase comprar todo lo que hay en tu sitio web!).
 
 En el código de nuestro web.py, distinguiremos las dos claramente:
diff --git a/docs/0.2/tutorial2.fr.md b/docs/0.2/tutorial2.fr.md
index d1a68878..e024ed4a 100644
--- a/docs/0.2/tutorial2.fr.md
+++ b/docs/0.2/tutorial2.fr.md
@@ -6,15 +6,15 @@ title: web.py 0.2 tutorial
 # web.py 0.2 tutorial
 
 ## Installation
+
 Vous  connaissez Python et vous voulez construire un site web. Web.py fournit le code pour faire cela d'une manière simple.
 
 Si vous voulez faire l’ensemble de ce tutoriel vous devrez installer Python, web.py, flup, psycopg2 et Postgres (ou une autre base de données avec son driver pour Python, par exemple : MySQL et mysqldb). Pour plus de détails voir le site de [webpy.org](http://webpy.org/).
 
 Si vous avez un projet web.py existant, regardez la page de [upgrade](http://webpy.infogami.com/upgrade_to_point2) pour plus d’informations sur la migration vers la nouvelle version.
 
-
-
 ## Gestion des URLs
+
 La partie la plus importante pour chaque site web  est la structure des URLs. Les URLs ne sont pas seulement ce que les visiteurs regarde et partage avec d’autres amis, mais ils sont aussi un modèle mental qui indique comment un Site Web fonctionne. (Dans les sites populaires comme [del.icio.us](http://del.icio.us/), les URLs font partie de l’interface de l’utilisateur). Pour cela Web.py facilite la création et la gestion des URL.
 
 Pour commencer l’application  web.py , Créez un nouveau fichier et appelez le code.py par exemple et écrivez ceci dedans:
@@ -28,7 +28,6 @@ Maintenant on implémente la structure de nos URLs, on commence par quelque chos
     urls = (
       '/', 'index'    )
 
-
 La première partie est l’[expression régulière](http://osteele.com/tools/rework/)  qui représente un chemin. Par exemple : ‘/’, ‘/aide/faq’, ‘/article/(\d+)’, etc. Le \d+ représente une séquence de chiffres. Les parenthèses (..) servent à capturer les éléments retournés pour plus tard. La deuxième partie est le nom d’une classe à laquelle envoyer la requête, comme view, welcomes.hello (qui utilise la classe hello du module welcomes), ou bien get_\1. \1 est remplacé par la première capture de l’expression régulière. Toutes captures restantes seront passées à la fonction.
 
 La ligne ('/', 'index') dis qu’on a besoin de l’URL ‘/’ (i.e la page d’accueil) qui sera prit en charge  par la classe nommé ‘index’.
diff --git a/docs/0.2/tutorial2.md b/docs/0.2/tutorial2.md
index 6ef4ed97..34315434 100644
--- a/docs/0.2/tutorial2.md
+++ b/docs/0.2/tutorial2.md
@@ -5,7 +5,7 @@ title: web.py 0.2 tutorial
 
 # web.py 0.2 tutorial
 
-* [english](./tutorial2)
+* [English](./tutorial2)
 * [简体中文](http://www.dup2.org/files/web.py%200.2%20tutorial.html)
 * [Español](./tutorial2.es)
 * [Português (Brasil)](./tutorial2.pt-br)
@@ -15,25 +15,3 @@ title: web.py 0.2 tutorial
 * [Françai](./tutorial2.fr)<a href="http://www.from-thailand.com/" title="Grossiste, Décoration asiatique, Thailande, Import Export" alt="Grossiste, Décoration asiatique, Import Export, Thailande">s</a>
 * [Polish](./tutorial2.pl)
 * [ελληνικά](./turorial2.el)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/docs/0.2/tutorial2.ru.md b/docs/0.2/tutorial2.ru.md
index 816d1d07..f6d6715d 100644
--- a/docs/0.2/tutorial2.ru.md
+++ b/docs/0.2/tutorial2.ru.md
@@ -13,7 +13,6 @@ title: tutorial2.ru
 * web.py (лучше из svn, командой **svn co http://webpy.org/svn/trunk/web**)
 * flup - **wget http://www.saddi.com/software/flup/dist/flup-r2016.tar.gz**
 
-
 после этого разожмите последний архив, скопируйте содержимое папки flup в каталог, где вы работаете, и удалите ненужный хлам. Например так:
 
     $ tar xf flup-r2016.tar.gz
@@ -39,7 +38,6 @@ title: tutorial2.ru
 
 Это ваш лист соответствия urlов и функций. Первая  часть - регулярное выражение с помощью которого определяется путь. Например **'/'**, или **'/help/faq'**, или даже **/item/(\d+)**. Строка **d+** обозначает "некоторая ненулевая последовательность цифр", подробнее смотрите об этом в [Python Regex HowTo](http://www.amk.ca/python/howto/regex/) или воспользуйтесь [удобной генерилкой regex](http://osteele.com/tools/rework/). Скобки вокруг **\d+** нужны для того, чтобы удобно исользовать эти цифры в дальнейшем. Вторая часть - имя класса, которому будет передан запрос. Например, **'index'**, **'welcomes.hello'** (то есть класс **hello** из модуля **welcomes**) или **'get_\1'**. **\1** заменяется на первое совпадание выделенного регулярного выражения. Все остальные элементы выделенного регулярного выражения (помните **(\d+)**? ) передаются в класс-обработчик.
 
-
 Собственно в нашем случае сказано что URL "/" (т.е. первая страница) будет обрабатываться классом **'index'**
 
 Теперь нам надо написать сам класс. В то время как большая часть людей не обращая ни на что внимание бродит по сайтам, внутри веба используется архитектурный стиль, известный как REST. Детали не так уж и важны, но основная идея в том, что посетители сайтов просят сервер применить определенные действия (например "GET" и "POST") на ссылки (такие как "/" или "/wtf?f=1").
@@ -83,7 +81,7 @@ python, в том числе **scgi** и **mod_python**.
 
 Написание HTML внутри кода на Python это отвратительно. Куда веселее писать на Python внутри HTML. К счастью web.py позволяет нам это делать, с легкостью.
 
-Cоздадим каталог для наших темплейтов (назовем его... ммм.... "templates"). Внутри этого каталога создадим файлик с расширением .html (скажем **index.html**). Теперь внутри это файла напиешем нормальный HTML:
+Cоздадим каталог для наших темплейтов (назовем его... ммм... "templates"). Внутри этого каталога создадим файлик с расширением .html (скажем **index.html**). Теперь внутри это файла напиешем нормальный HTML:
 
     <em>Превед</em>, орлы!
 
@@ -141,7 +139,6 @@ Cоздадим каталог для наших темплейтов (назо
 
     INSERT INTO todo (title) VALUES ('Заучить web.py');
 
-
 В **index.py** давайте опять переделаем `index.GET`:
 
     def GET(self):
@@ -179,13 +176,11 @@ Cоздадим каталог для наших темплейтов (назо
 
 В общем это всё к чему - теперь вы можете добавлять новые элементы в список.
 
-Объект-хранилище
-----------------
+## Объект-хранилище
 
 И **web.input**, и **web.query**, а также большинство других функций **web.py** возвращают в качестве результата объект-хранилище. Этот объект похож на стандартный dictionary языка python, однако позволяет обращаться к элементам не только через d['figna'], но и d.figna, что на 3 символа короче :)
 
-Куки
-----
+## Куки
 
 А также спамы и трояны...
 
diff --git a/docs/0.3.fr/index.md b/docs/0.3.fr/index.md
index 22051d0e..4366ebaf 100644
--- a/docs/0.3.fr/index.md
+++ b/docs/0.3.fr/index.md
@@ -5,9 +5,10 @@ title: Documentation de web.py 0.3
 
 # Documentation de web.py 0.3
 
-Autre langages : [english](/docs/0.3) | ...
+Autre langages: [English](/docs/0.3) | ...
 
 ## Installation
+
 * [Installation](/install/fr). Installer web.py, configurer LightTPD, Apache, Nginx ...(CGI, FastCgi, ...)
 
 ## Tutorial
@@ -20,6 +21,7 @@ Autre langages : [english](/docs/0.3) | ...
 * [Code samples](https://github.com/webpy/webpy-examples/). Example code of how to write some basic applications. (traduction demandée)
 
 ## Documentation des composants
+
 * [Applications](/docs/0.3/apps/fr). Comment mapper des urls à du code python.
     * [Basic app](/docs/0.3/apps/basic/fr). Mapper des expressions régulières à des classes.
     * [Auto app](/docs/0.3/apps/auto/fr). Webpy suit les urls basées sur le nom des classes.
@@ -36,7 +38,6 @@ Autre langages : [english](/docs/0.3) | ...
 
 * [Upgrade to 0.3 versions of web.py](/docs/0.3/upgrade)  - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
 
-
 ## API Documentation 
 
 * [API documentation](/docs/0.3/api) - traduction demandée, voir [Todo](/docs/0.3.fr/todo)
diff --git a/docs/0.3.fr/todo.md b/docs/0.3.fr/todo.md
index c0289a8a..39f26d5f 100644
--- a/docs/0.3.fr/todo.md
+++ b/docs/0.3.fr/todo.md
@@ -5,7 +5,7 @@ title: TODO - A faire
 
 # TODO - A faire
 
-#Traduction française
+# Traduction française
 
 Ici sera réunie la liste des travaux à réaliser et ceux en cours de réalisation, conçernant la traduction française de web.py.
 
@@ -16,27 +16,22 @@ Ici sera réunie la liste des travaux à réaliser et ceux en cours de réalisat
 1. Les chemins des pages traduites devront ressembler à l'exemple ci-dessous et respecter la hierarchie du schéma anglais:
 	*cookbook/helloworld* --> *cookbook/helloworld/fr*
 
--------------------------------------------------
+---
 
 # En cours
 
-
-
-
 ---
 
 # A faire
 
 ## Documentation de web.py 0.3
 
-
 ### Exemples de code
 
 * [Code samples](https://github.com/webpy/webpy-examples/). - traduction demandée
 
 ### Documentation des composants
 
-
 * [Subdir app](/docs/0.3/apps/subdir). - traduction demandée
 * [Subdomain app](/docs/0.3/apps/subdomain). - traduction demandée
 
@@ -48,11 +43,9 @@ Ici sera réunie la liste des travaux à réaliser et ceux en cours de réalisat
 
 * [API documentation](/docs/0.3/api) -  traduction demandée
 
-
 ## Cookbook
 
-
-###Avancé
+### Avancé
 
 * [Select: Récupérer les entrées d'une base de données](/cookbook/select). - traduction demandée
 * [Update: Mettre à jour les entrées d'une base de données](/cookbook/update).  - traduction demandée
@@ -62,19 +55,16 @@ Ici sera réunie la liste des travaux à réaliser et ceux en cours de réalisat
 * [Comment utiliser web.background](/cookbook/background). - traduction demandée
 * [Run-time language switch](/cookbook/runtime-language-switch). - traduction demandée
 
-###Sessions et état des utilisateurs:
-
+### Sessions et état des utilisateurs:
 
 * [Authentification des utilisateurs avec base de données Postgresql](/cookbook/userauthpgsql). - traduction demandée
 
-
-###Utils:
+### Utils:
 
 * [Envoi de Mail](/cookbook/sendmail). - traduction demandée
 * [Webservice en utilisant soaplib + WSDL](/cookbook/webservice). - traduction demandée
 
-###Modèles de mise en forme, gabarits de mise en page:
-
+### Modèles de mise en forme, gabarits de mise en page:
 
 * [Alterner un style](/cookbook/alternating_style). - traduction demandée
 * [Importer des fonctions dans les gabarits](/cookbook/template_import). - traduction demandée
@@ -84,17 +74,16 @@ Ici sera réunie la liste des travaux à réaliser et ceux en cours de réalisat
 * [Utiliser le moteur de gabarit  Jinja2 dans webpy](/cookbook/template_jinja). - traduction demandée
 * [Comment utiliser les gabarits sur Google App Engine](/cookbook/templates_on_gae). - traduction demandée
 
-###Essais:
+### Essais:
 
 * [Tester avec Paste et Nose](/cookbook/testing_with_paste_and_nose). - traduction demandée
 * [RESTful doctesting using an application's request method](/cookbook/restful_doctesting_using_request). - traduction demandée
 
-###Entrées utilisateurs:
-
+### Entrées utilisateurs:
 
 * [Rendu individuel des champs de formulaires](/cookbook/form_fields). - traduction demandée
 
-###Base de données:
+### Base de données:
 
 * [Multiples bases de données](/cookbook/multidbs). - traduction demandée
 
@@ -103,7 +92,7 @@ Ici sera réunie la liste des travaux à réaliser et ceux en cours de réalisat
 * [Intégrer SQLite UDF (user-defined-functions) à la couche de base de données webpy](/cookbook/sqlite-udf). - traduction demandée
 * [Utiliser un dictionnaire comme clause where](/cookbook/where_dict). - traduction demandée
 
-###Déploiement:
+### Déploiement:
 
 * [Déploiement Fastcgi au travers Apache](/cookbook/fastcgi-apache).  - traduction demandée
 * [Déploiement CGI au travers Apache](/cookbook/cgi-apache). - traduction demandée
diff --git a/docs/0.3/app_processors.fr.md b/docs/0.3/app_processors.fr.md
index d4ca4eef..0eceddac 100644
--- a/docs/0.3/app_processors.fr.md
+++ b/docs/0.3/app_processors.fr.md
@@ -5,11 +5,10 @@ title: Application processors
 
 # Application processors
 
-Autres langues : [english](/../app_processors) | ...
+Autres langues : [English](/../app_processors) | ...
 
 les Application processors permettent au programmeur d'executer du code commun avant que chaque requête soit traitée. Ceci est utile pour les schémas d'authentification ou pour organiser l'état des utilisateurs à chaque requête. Des processors multiples peuvent être ajoutés par application, et ils seront executés dans l'ordre ou ils ont été ajoutés. Le plus basique processor ressemble à ça:
 
-
     def proc(handle):
         # faire tout ce dont vous avez besoin ici
         web.ctx.user = web.cookies(user=None).user
@@ -29,11 +28,10 @@ Le "handle" de l'application processor se réfère au code qui sera envoyé à l
                 log_error('Uh oh')
             return ret
 
-
 Voici un exemple de base sur la façon dont un système d'authentification est créé en utilisant les applications processors. Ce n'est pas sécurisé pour une utilisation réelle; Cela ne vise qu'à démontrer comment les application processors pouvent vérifier quelque chose avant que chaque URL ne soit traitée.
 
-
 ## Exemple
+
     """ Application processors dans web.py """
     import web
     
diff --git a/docs/0.3/app_processors.md b/docs/0.3/app_processors.md
index 1af9023e..1cd65307 100644
--- a/docs/0.3/app_processors.md
+++ b/docs/0.3/app_processors.md
@@ -5,7 +5,7 @@ title: Application processors
 
 # Application processors
 
-Other languages : [français](/app_processors/fr) | ...
+Other languages: [Français](/app_processors/fr) | ...
 
 Application processors allow the programmer to execute common code before each request is processed.  This is helpful for authentication schemes or for setting up user state on each request.  Multiple processors can be added per application, and they will be executed in the order which they are added.  The most basic processor looks like this:
 
@@ -28,10 +28,10 @@ The "handle" of the app processor refers to the code that will be dispatched by
                 log_error('Uh oh')
             return ret
 
-
 Here's a basic example of how an authentication scheme is created using app processors.  This is not secure for actual use; it is only meant to demonstrate how app processors can check something before each url is processed.
 
 ## Example
+
     """ Application processors in web.py """
     import web
     
diff --git a/docs/0.3/apps.fr.md b/docs/0.3/apps.fr.md
index 15b376f7..2e026320 100644
--- a/docs/0.3/apps.fr.md
+++ b/docs/0.3/apps.fr.md
@@ -5,11 +5,10 @@ title: Applications webpy
 
 # Applications webpy
 
-Autres langages : [english](/../apps) | ...
+Autres langages: [English](/../apps) | ...
 
 Les Applications webpy apparient les urls et les traitements qui sont mappés vers elles. Elles se répartissent en plusieurs catégories:
 
-
 * [Basic app](/docs/0.3/apps/basic/fr). Défini les urls et les classes pour les traiter.
 * [Auto app](/docs/0.3/apps/auto/fr). Les urls sont déterminées automatiquement en se basant sur les classes.
 * [Subdir app](/docs/0.3/apps/subdir). Run multiple apps on a single domain based on url. (traduction demandée)
diff --git a/docs/0.3/apps/auto.fr.md b/docs/0.3/apps/auto.fr.md
index 1efdaddb..a7b66ce5 100644
--- a/docs/0.3/apps/auto.fr.md
+++ b/docs/0.3/apps/auto.fr.md
@@ -5,7 +5,7 @@ title: Auto Application
 
 # Auto Application
 
-Autre langages : [english](/docs/0.3/apps/auto) | ...
+Autre langages: [English](/docs/0.3/apps/auto) | ...
 
 L'auto application agit comme la [basic application](/docs/0.3/apps/basic/fr), seulement il ne nécessite pas un mapping d'url pour être créé. Le mapping est dérivé des noms de classe (utilisant les métaclasses). Dans sa forme la plus basique :
 
@@ -20,8 +20,6 @@ L'auto application agit comme la [basic application](/docs/0.3/apps/basic/fr), s
      if __name__ == '__main__':
          app.run() # goto http://hostname:8080/hello
 
-
-
 Vous pouvez également modifier le chemin par défaut (qui est le nom de la classe) en définissant une variable de classe "path". Voir ci-dessous:
 
 ## Exemple:
diff --git a/docs/0.3/apps/auto.md b/docs/0.3/apps/auto.md
index 2b8cd2fd..1605c64a 100644
--- a/docs/0.3/apps/auto.md
+++ b/docs/0.3/apps/auto.md
@@ -5,7 +5,7 @@ title: Auto Application
 
 # Auto Application
 
-Other languages : [français](/docs/0.3/apps/auto/fr) | ...
+Other languages: [Français](/docs/0.3/apps/auto/fr) | ...
 
 The auto application acts like the [basic application](/docs/0.3/apps/basic), only it doesn't require a URL mapping to be created.  The mapping is derived from the class names (using metaclasses). In it's most basic form:
 
@@ -20,10 +20,8 @@ The auto application acts like the [basic application](/docs/0.3/apps/basic), on
      if __name__ == '__main__':
          app.run() # goto http://hostname:8080/hello
 
-
 You can also override the default path (which is the name of the class) by setting a class variable "path".  See below:
 
-
 ## More Example code 
 
     app = web.auto_application() 
diff --git a/docs/0.3/apps/basic.fr.md b/docs/0.3/apps/basic.fr.md
index a1262814..aa8dd4a4 100644
--- a/docs/0.3/apps/basic.fr.md
+++ b/docs/0.3/apps/basic.fr.md
@@ -5,14 +5,12 @@ title: Basic Application
 
 # Basic Application
 
-Autres langages : [français](/../basic) | ...
-
+Autres langages: [Français](/../basic) | ...
 
 La basic application définit un appariement des urls à des mappings de classe. Dans l'exemple ci-dessous, les variables URL définissent un appariement d'une expression régulière à un nom de classe.
 
 Quand un utilisateur a accès à une ressource,  la liste des expressions régulières d'url est parcourue. Si une URL correspondant à la regex, la classe est instanciée, et la méthode 'GET' ou 'POST' est appelée selon la méthode http. Les données retournées depuis GET ou POST sont affichées dans le navigateur.
 
-
 Si l'URL demandée ne correspond à aucune des expressions régulières, une erreur 404 est renvoyée.
 
 ## Exemple
diff --git a/docs/0.3/apps/basic.md b/docs/0.3/apps/basic.md
index 9d4aaedc..cfe31fff 100644
--- a/docs/0.3/apps/basic.md
+++ b/docs/0.3/apps/basic.md
@@ -5,7 +5,7 @@ title: Basic Application
 
 # Basic Application
 
-Other languages : [français](/docs/0.3/apps/basic/fr) | ...
+Other languages: [Français](/docs/0.3/apps/basic/fr) | ...
 
 The basic application defines a pairing of urls to class mappings.  In the example below, the urls variable defines a pairing of a regular expression to a class name. 
 
@@ -13,7 +13,6 @@ When a user access a resource, runs through the list of url regular expressions.
 
 If the requested url doesn't match any regex, a 404 is returned.
 
-
 ## Example
 
     import web
diff --git a/docs/0.3/apps/index.md b/docs/0.3/apps/index.md
index 0f47b9c5..1f1aa122 100644
--- a/docs/0.3/apps/index.md
+++ b/docs/0.3/apps/index.md
@@ -5,7 +5,7 @@ title: webpy Applications
 
 # webpy Applications
 
-Other languages : [français](/docs/0.3/apps/fr) | ...
+Other languages: [Français](/docs/0.3/apps/fr) | ...
 
 webpy applications encompass the urls and handlers that map to them. They fall into several categories:
 
diff --git a/docs/0.3/apps/subdir.md b/docs/0.3/apps/subdir.md
index d02b5515..a8fe7977 100644
--- a/docs/0.3/apps/subdir.md
+++ b/docs/0.3/apps/subdir.md
@@ -7,10 +7,8 @@ title: Subdir application
 
 A subdir application lets you run various mount points on the same hostname, but switched based on directory mount point.
 
-
 This example assumes you have applications already working and called "app" defined in wiki.py, blog.py and auth.py. 
 
-
 ## Example code
 
     import wiki 
diff --git a/docs/0.3/form.fr.md b/docs/0.3/form.fr.md
index aea94507..5f48ee4c 100644
--- a/docs/0.3/form.fr.md
+++ b/docs/0.3/form.fr.md
@@ -9,14 +9,13 @@ Autres langues : [English](/form) | ...
 
 # Sommaire
 
-* <a href="#introduction">Introduction</a>
-* <a href="#carac">Caracteristiques des entrées formulaires</a>
-* <a href="#listes">Listes déroulantes</a>
-* <a href="#parti">Particularités des formulaires</a>
-* <a href="#exemple">Exemple</a>
+* [Introduction](#introduction)
+* [Caracteristiques des entrées formulaires](#carac)
+* [Listes déroulantes](#listes)
+* [Particularités des formulaires](#parti)
+* [Exemple](#exemple)
 
-<a name="introduction"></a>
-## Introduction
+<h2 id="introduction">Introduction</h2>
 
 Le module de formulaire de web.py permet de générer des formulaires HTML, de récuperer les entrées des utilisateurs, et les valider avant de les traiter ou les ajouter à une base de donnée.
 
@@ -26,7 +25,6 @@ Les formulaires sont instanciés avec une ou plusieurs entrées, et des validate
 
 La classe Input est sous-classée dans les entrées html suivantes (type HTML dans les parenthèses):
 
-
 * Textbox     - Champ de saisie de texte d'une ligne (input type="text")
 * Password   - Champ de saisie de texte d'une ligne qui cache ce qui est entré (input type="password")
 * Textarea   - Champ de saisie de texte multiligne (textarea)
@@ -64,11 +62,9 @@ Ce qui donnera:
     <tr><th><label for="Login"></label></th><td><button id="Login" name="Login">Login</button><div class="post" style="display: none;"></div></td></tr>
 </table>
 
-<a name="carac"></a>
-## Caracteristiques des entrées formulaires
+<h2 id="carac">Caracteristiques des entrées formulaires</h2>
 Les entrées formulaires offrent quelques attributs additionnels. Par exemple :
 
-
     form.textbox("firstname",
         form.notnull, # Place les validateurs en premier, suivi par des attributs facultatifs
         class_="textEntry", # Donne un nom de classe à la zone de texte - à noter le caractère de soulignement (underscore)
@@ -87,15 +83,13 @@ En plus des attributs ci-dessus, tous les attributs HTML peuvent être entré de
             maxlength="12"        )
     )
 
-<a name="listes"></a>
-##Listes déroulantes  (Dropdown) 
+<h2 id="listes">Listes déroulantes  (Dropdown) </h2>
 
 Les entrées des listes déroulantes permettent une description et une valeur uniques de chaque élément dans la liste déroulante. Pour ce faire, créez la liste déroulante avec les tuples comme ceci:
     
     form.Dropdown('mydrop', [('value1', 'description1'), ('value2', 'description2')])
 
-<a name="introduction"></a>
-## Particularités des formulaires
+<h2 id="introduction">Particularités des formulaires</h2>
 En plus des champs de saisie individuels, form.py permet une complète validation de formulaire qui autorise la comparaison des champs. Les validations sont passées sous forme de liste dans une variable 'validators'. Par exemple :
 
     signup = form.Form(
@@ -115,8 +109,7 @@ Une fois les données du formulaire postées, elles peuvent facilement être mis
         else:
             render.foo(f)
 
-<a name="exemple"></a>
-## Exemple
+<h2 id="exemple">Exemple</h2>
 
     import web
     from web import form
diff --git a/docs/0.3/index.md b/docs/0.3/index.md
index 68d4fe1e..ca37bff7 100644
--- a/docs/0.3/index.md
+++ b/docs/0.3/index.md
@@ -5,9 +5,10 @@ title: web.py 0.3 documentation
 
 # web.py 0.3 documentation
 
-Other languages : [français](/docs/0.3.fr) | ...
+Other languages: [Français](/docs/0.3.fr) | ...
 
 ## Install
+
 * [Install](/install). Install web.py, configure LightTPD, Apache, Nginx ...(CGI, FastCgi, ...)
 
 ## Tutorial
@@ -20,6 +21,7 @@ Other languages : [français](/docs/0.3.fr) | ...
 * [Code samples](https://github.com/webpy/webpy-examples/). Example code of how to write some basic applications.
 
 ## Component Documentation
+
 * [Applications](/docs/0.3/apps). How to map urls to python code paths.
     * [Basic app](/docs/0.3/apps/basic). Map regexes to classes.
     * [Auto app](/docs/0.3/apps/auto). Have webpy keep track of the urls based on class name.
@@ -36,7 +38,6 @@ Other languages : [français](/docs/0.3.fr) | ...
 
 * [Upgrade to 0.3 versions of web.py](/docs/0.3/upgrade)
 
-
 ## API Documentation
 
 * [API documentation](/docs/0.3/api)
diff --git a/docs/0.3/sessions.fr.md b/docs/0.3/sessions.fr.md
index 76709daf..fbe5398b 100644
--- a/docs/0.3/sessions.fr.md
+++ b/docs/0.3/sessions.fr.md
@@ -5,8 +5,7 @@ title: Les sessions web.py
 
 # Les sessions web.py
 
-Autres langages : [english](/../sessions) | ...
-
+Autres langages: [English](/../sessions) | ...
 
 Les sessions sont un moyen de stocker des informations entre les requêtes, faisant ainsi du http un protocole avec état. Elles fonctionnent en envoyant à l'utilisateur un cookie, qui mappe vers un objet de stockage de session sur le serveur. Lorsque l'utilisateur fait une requête vers une page, le client renvoie le cookie avec la requête, web.py charge la session basée sur sa clef, et le code peut demander et stocker des informations dedans.
 
@@ -20,17 +19,16 @@ Les sessions de web.py permettent différents procédés de stockage des donnée
 
 * DBStore: Les données sessions sont sérialisées et sotckées dans une base de donnée. Cela peut être très utile si vous souhaitez stocker les données sessions sur un système séparé. Pendant la création, DBStore prend deux arguments: une instance web.py de base de donnée, et le nom de la table (string). La table qui stocke la session doit avoir la structure suivante:
 
-
         session_id CHAR(128) UNIQUE NOT NULL,
         atime DATETIME NOT NULL default current_timestamp,
         data TEXT
 
 * ShelfStore: Les données sont stockées en utilisant le module [shelve](http://docs.python.org/library/shelve.html) de python.
 
-
 Les méthodes de stockage ont des performances variées et des ajustement d'installation, donc les options vous permettent de choisir ce qui convient le mieux pour votre appplication.
 
 ## Exemple
+
 Le code suivant montre comment utiliser une session de base DiskStore.
 
     import web
diff --git a/docs/0.3/sessions.md b/docs/0.3/sessions.md
index 685456eb..fb1f3453 100644
--- a/docs/0.3/sessions.md
+++ b/docs/0.3/sessions.md
@@ -5,13 +5,14 @@ title: web.py Sessions
 
 # web.py Sessions
 
-Other languages : [français](/sessions/fr) | ...
+Other languages: [Français](/sessions/fr) | ...
 
 Sessions are a way to store information between requests, thereby making http stateful.  They work by sending the user a cookie, which maps to a session storage object on the server.  When the user requests a page, the client sends the cookie back with the request, web.py loads the session based on the key, and code can request and store information in it.
 
 Sessions are convenient because they allow a programmer to store user state in native Python objects.
 
 ## Storage types
+
 web.py sessions allow for multiple ways to store the session data.  These methods include:
 
 * DiskStore. Session data is pickled in a designated directory. When instantiating, the first and only argument is the folder where the session information should be stored on disk.
@@ -25,8 +26,8 @@ web.py sessions allow for multiple ways to store the session data.  These method
 
 The storage methods have various performance and setup tradeoffs, so the options allow you to choose what's best for your application.
 
-
 ## Example
+
 The following code shows how to use a basic DiskStore session.
 
     import web
@@ -62,8 +63,8 @@ The following code shows how to use a basic DiskStore session.
     if __name__ == '__main__':
         app.run()
 
-
 ## Sessions and Reloading/Debug Mode
+
 Is your session data disappearing for seemingly no reason? This can happen when using the web.py app reloader (local debug mode), which will not persist the session object between reloads. Here's a nifty hack to get around this.
 
     # Hack to make session play nice with the reloader (in debug mode)
diff --git a/docs/0.3/templetor.fr.md b/docs/0.3/templetor.fr.md
index 48842731..b79fe470 100644
--- a/docs/0.3/templetor.fr.md
+++ b/docs/0.3/templetor.fr.md
@@ -9,33 +9,30 @@ Autre langues : [English](/docs/0.3/templetor) | ...
 
 ## Sommaire
 
-* <a href="#introduction">Introduction</a>
-* <a href="#using">Utiliser un modèle de gabarit</a>
-* <a href="#syntax">Syntaxe</a>
-	* <a href="#expressionsubstitution">Substitution d'expression</a>
-	* <a href="#attribut">Attribution</a>
-	* <a href="#filtrering">Filtrage</a>
-	* <a href="#newlinesuppression">Suppression d'un retour à la ligne</a>
-	* <a href="#escaping">Caractère d'échappement '$'</a>
-	* <a href="#comments">Commentaires</a>
-	* <a href="#controlstructure">Structures de contrôle</a>
-* <a href="#otherstatements">Autres déclarations</a>
-	* <a href="#def">$def : définir une nouvelle fonction de gabarit</a>
-	* <a href="#code">$code : écrire du code python dans le gabarit</a>
-	* <a href="#var">$var : définir des propriétés additionnelles dans les résultats du gabarit</a>
-* <a href="#builtins">Objets internes et variables globales</a>
-* <a href="#security">Sécurité</a>
-* <a href="#upgrading">Mise à jour depuis le gabarit web.py 0.2</a>
-
-
-<a name="introduction"></a>
-# Introduction
+* [Introduction](#introduction)
+* [Utiliser un modèle de gabarit](#using)
+* [Syntaxe](#syntax)
+	* [Substitution d'expression](#expressionsubstitution)
+	* [Attribution](#attribut)
+	* [Filtrage](#filtrering)
+	* [Suppression d'un retour à la ligne](#newlinesuppression)
+	* [Caractère d'échappement '$'](#escaping)
+	* [Commentaires](#comments)
+	* [Structures de contrôle](#controlstructure)
+* [Autres déclarations](#otherstatements)
+	* [$def : définir une nouvelle fonction de gabarit](#def)
+	* [$code : écrire du code python dans le gabarit](#code)
+	* [$var : définir des propriétés additionnelles dans les résultats du gabarit](#var)
+* [Objets internes et variables globales](#builtins)
+* [Sécurité](#security)
+* [Mise à jour depuis le gabarit web.py 0.2](#upgrading)
+
+<h1 id="introduction">Introduction</h1>
 
 Le langage de gabarit de web.py, appelé 'Templator', est conçu pour apporter la puissance de python aux modèles de gabarits.
 Au lieu d'inventer une nouvelle syntaxe pour les gabarits, il réutilise la syntaxe de python.
 Si vous connaissez le langage de programmation python, vous serez à l'aise. 
 
-
 Templator limite intentionnellement l'accès aux variables dans un gabarit. Un utilisateur a accès aux variables passées dans le modèle de gabarit ainsi qu'à certaines fonctions Python intégrées. Cela permet aux utilisateurs maladroits d'écrire des gabarits, sans vous soucier de causer des dommage au système en cours d'exécution. Vous pouvez, bien sûr, augmenter les variables globales disponibles, c'est ce que nous verrons plus tard.
 
 Voici un gabarit tout simple:
@@ -46,8 +43,7 @@ Voici un gabarit tout simple:
 La première ligne indique que le gabarit est défini avec un argument appelé 'name'.
 `$name` dans la seconde ligne sera remplacé par la valeur de name lorsque le template sera rendu.
 
-<a name="using"></a>
-# Utiliser un modèle de gabarit
+<h1 id="using">Utiliser un modèle de gabarit</h1>
 
 La façon la plus imple d'utiliser le rendu de gabarits est celle-ci :
 
@@ -56,7 +52,6 @@ La façon la plus imple d'utiliser le rendu de gabarits est celle-ci :
    
 La fonction 'render' prend comme argument le repertoire 'templates'. 'render.hello(..)' appelle le gabarit 'hello.html' avec les arguments donnés. En fait, il cherche les fichiers correspondants 'hello.*' dans le repertoire 'template' et sélectionne le premier fichier correspondant.
 
-
 Vous pouvez également créer des modèles à partir d'un fichier en utilisant 'frender'.
 
     hello = web.template.frender('templates/hello.html')
@@ -68,11 +63,9 @@ Ou encore à partir d'une chaîne de caractères:
     hello = web.template.Template(template)
     print hello('world')
 
-<a name="syntax"></a>
-# Syntaxe
+<h1 id="syntax">Syntaxe</h1>
 
-<a name="expressionsubstitution"></a>
-## Substitution d'expression
+<h2 id="expressionsubstitution">Substitution d'expression</h2>
 
 Le caractère spécial '$' est utilisé pour spécifier des expressions python. Les expressions peuvent être jointent dans '()' ou '{}' pour un regroupement explicite.
 
@@ -81,8 +74,7 @@ Le caractère spécial '$' est utilisé pour spécifier des expressions python.
     Gawk, a $dictionary[key].function('argument'). 
     Cool, a $(limit)ing.
 
-<a name="attribut"></a>
-## Attribution
+<h2 id="attribut">Attribution</h2>
 
 Vous aurez parfois besoin de définir de nouvelles variables et de réattribuer certaines d'entre elles.
     
@@ -94,8 +86,7 @@ Vous aurez parfois besoin de définir de nouvelles variables et de réattribuer
      
 Notez l'espace après '$' dans l'attribution. Il est requis pour différencier l'attribution à la substitution d'expression.
 
-<a name="filtrering"></a>
-## Filtrage 
+<h2 id="filtrering">Filtrage </h2>
 
 Par defaut, Templator utilise le filtre 'web.websafe' pour encoder le HTML.
 
@@ -107,8 +98,7 @@ Pour désactiver le filtre, utilisez ':' après '$'. Par exemple:
     Ce qui suit ne sera pas remplacé par une chaîne HTML ("&" par "&amp;" par exemple).
     $:form.render()
 
-<a name="newlinesuppression"></a>
-## Suppression d'un retour à la ligne
+<h2 id="newlinesuppression">Suppression d'un retour à la ligne</h2>
 
 Un retour à la ligne peut-être supprimé en ajoutant l'anti-slash '\' à la fin de la ligne.
 
@@ -117,23 +107,20 @@ Un retour à la ligne peut-être supprimé en ajoutant l'anti-slash '\' à la fi
     (comme ceci) \ 
     alors il n'y aura pas de retour à la ligne.
     
-<a name="escaping"></a>
-## Caractère d'échappement '$'
+<h2 id="escaping">Caractère d'échappement '$'</h2>
 
 Utilisez `$$` pour avoir `$` (signe dollars) à l'affichage.
 
     Can you lend me $$50?
     
-<a name="comments"></a>
-## Commentaires
+<h2 id="comments">Commentaires</h2>
 
 '$#' est utilisé comme indicateur de commentaires. Tout ce qui commence par '$#' jusqu'à la fin de la ligne sera ignoré.
 
     $# Ceci est un commentaire
     Hello $name.title()! $# Affiche le nom comme titre
 
-<a name="controlstructure"></a>
-## Structures de contrôles
+<h2 id="controlstructure">Structures de contrôles</h2>
 
 Le système de gabarit accepte les instructions `for`, `while`, `if`, `elif` et `else`.
 Tout comme en Python, le corps de la déclaration est indenté.
@@ -172,11 +159,9 @@ Parfois, celles-ci peuvent être très pratique.
         </tr>
     </table>
     
-<a name="otherstatements"></a>
-## Autres déclarations
+<h2 id="otherstatements">Autres déclarations</h2>
 
-<a name="def"></a>
-### $def
+<h3 id="def">$def</h3>
 
 Vous pouvez définir une nouvelle fonction de gabarit en utilisant `$def`. les arguments-clés sont aussi supportés.
 
@@ -203,8 +188,7 @@ Autre exemple
     $ data = [['a', 'b', 'c'], [1, 2, 3], [2, 4, 6], [3, 6, 9] ]
     $:table([tr(d) for d in data])
     
-<a name="code"></a>
-### $code
+<h3 id="code">$code</h3>
 
 Du code python arbitraire peut être écrit en utilisant le bloc '$code'.
 
@@ -224,8 +208,7 @@ Du code python arbitraire peut être écrit en utilisant le bloc '$code'.
     Les variables définies dans le bloc '$code' peuvent être utilisées ici.
     Par exemple, $limit(x)
   
-<a name="var"></a>  
-### $var
+<h3 id="var">$var</h3>
 
 Le bloc '$var' peut être utilisé pour définir des propriétés additionnelles dans les résultats du gabarit.
 
@@ -248,8 +231,7 @@ Les résultat du modèle ci-dessus peuvent être utilisés comme suit:
     >>> str(out)
     '\n\n<div>\nhello world\n</div>\n'
 
-<a name="builtins"></a>
-# Objets internes et variables globales
+<h1 id="builtins">Objets internes et variables globales</h1>
 
 Comme toutes fonctions python, le gabarit peut également accèder aux objets internes avec ses arguments et ses variables locales.
 Quelques fonctions internes communes telles que 'range', 'max', 'min', etc... et les valeurs booléennes 'True' et 'False' sont accessibles à tous les gabarits.
@@ -269,8 +251,7 @@ Les objets internes qui sont exposés dans les gabarits peuvent aussi être cont
     # disable all builtins
     render = web.template.render('templates', builtins={})
 
-<a name="security"></a>
-# Securité
+<h1 id="security">Securité</h1>
 
 L'un des objectifs de conception de Templetor est de permettre à des utilisateurs non épprouvés d'écrire des gabarits.
 
@@ -282,8 +263,7 @@ Pour rendre l'exécution du gabarit sûre, ce qui suit n'est pas autorisé dans
 
 `SecurityException` est déclenchée si votre modèle utilise l'une de celles-ci.
 
-<a name="upgrading"></a>
-# Mise à jour depuis le gabarit web.py 0.2
+<h1 id="upgrading">Mise à jour depuis le gabarit web.py 0.2</h1>
 
 La nouvelle implémentation est totalement compatible avec la mise en œuvre plus haut. Cependant, certains cas pourraient ne pas fonctionner pour les raisons suivantes:
 
diff --git a/docs/0.3/templetor.md b/docs/0.3/templetor.md
index aad1891c..686e5f2f 100644
--- a/docs/0.3/templetor.md
+++ b/docs/0.3/templetor.md
@@ -5,32 +5,30 @@ title: Templetor - The web.py templating system
 
 # Templetor: The web.py templating system
 
-Other languages : [français](/docs/0.3/templetor.fr) | ...
+Other languages: [Français](/docs/0.3/templetor.fr) | ...
 
 ## Summary
 
-* <a href="#introduction">Introduction</a>
-* <a href="#using">Using the template system</a>
-* <a href="#syntax">Syntax</a>
-    * <a href="#expressionsubstitution">Expression Substitution</a>
-    * <a href="#assignments">Assignments</a>
-    * <a href="#filtering">Filtering</a>
-    * <a href="#newlinesuppression">Newline suppression</a>
-    * <a href="#escaping">Escaping '$'</a>
-    * <a href="#comments">Comments</a>
-    * <a href="#controlstructure">Control Structures</a>
-* <a href="#otherstatements">Other Statements</a>
-    * <a href="#def">$def : define a new template function using $def</a>
-    * <a href="#code">$code : arbitrary python code can be written</a>
-    * <a href="#var">$var : can be used to define additional properties</a>
-* <a href="#builtins">Builtins and globals</a>
-* <a href="#security">Security</a>
-* <a href="#upgrading">Upgrading from web.py 0.2 templates</a>
-* <a href="#errors">Errors you may experience</a>
-
-
-<a name="introduction"></a>
-# Introduction
+* [Introduction](#introduction)
+* [Using the template system](#using)
+* [Syntax](#syntax)
+    * [Expression Substitution](#expressionsubstitution)
+    * [Assignments](#assignments)
+    * [Filtering](#filtering)
+    * [Newline suppression](#newlinesuppression)
+    * [Escaping '$'](#escaping)
+    * [Comments](#comments)
+    * [Control Structures](#controlstructure)
+* [Other Statements](#otherstatements)
+    * [$def : define a new template function using $def](#def)
+    * [$code : arbitrary python code can be written](#code)
+    * [$var : can be used to define additional properties](#var)
+* [Builtins and globals](#builtins)
+* [Security](#security)
+* [Upgrading from web.py 0.2 templates](#upgrading)
+* [Errors you may experience](#errors)
+
+<h1 id="introduction">Introduction</h1>
 
 The web.py template language, called `Templetor` is designed to bring the power of Python to templates.
 Instead of inventing new syntax for templates, it re-uses python syntax. 
@@ -46,9 +44,7 @@ Here is a simple template:
 The first line says that the template is defined with one argument called `name`.
 `$name` in the second line will be replaced with the value of name when the template is rendered.
 
-
-<a name="using"></a>
-# Using the template system
+<h1 id="using">Using the template system</h1>
 
 The most common way of rendering templates is this:
 
@@ -69,11 +65,9 @@ And if you have the template as a string:
     hello = web.template.Template(template)
     print hello('world')
 
-<a name="syntax"></a>
-# Syntax
+<h1 id="syntax">Syntax</h1>
 
-<a name="expressionsubstitution"></a>
-## Expression Substitution
+<h2 id="expressionsubstitution">Expression Substitution</h2>
 
 Special character `$` is used to specify python expressions. Expression can be enclosed in `()` or `{}` for explicit grouping.
 
@@ -82,8 +76,7 @@ Special character `$` is used to specify python expressions. Expression can be e
     Gawk, a $dictionary[key].function('argument'). 
     Cool, a $(limit)ing.
 
-<a name="assignments"></a>
-## Assignments
+<h2 id="assignments">Assignments</h2>
 
 Sometimes you may want to define new variables and re-assign some variables.
     
@@ -95,8 +88,7 @@ Sometimes you may want to define new variables and re-assign some variables.
 
 Notice the space after `$` in the assignment. It is required to differentiate assignment from expression substitution.
 
-<a name="filtering"></a>
-## Filtering 
+<h2 id="filtering">Filtering </h2>
 
 By default, Templetor uses `web.websafe` filter to do HTML-encoding.
 
@@ -108,8 +100,7 @@ To turnoff filter use `:` after `$`. For example:
     The following will not be html escaped.
     $:form.render()
 
-<a name="newlinesuppression"></a>   
-## Newline suppression
+<h2 id="newlinesuppression">Newline suppression</h2>
 
 Newline can be suppressed by adding `\` character at the end of line. 
 
@@ -118,23 +109,20 @@ Newline can be suppressed by adding `\` character at the end of line.
     (like these) \ 
     then there will be no newline.
     
-<a name="escaping"></a> 
-## Escaping $
+<h2 id="escaping">Escaping $</h2>
 
 Use `$$` to get `$` in the output.
 
     Can you lend me $$50?
     
-<a name="comments"></a> 
-## Comments
+<h2 id="comments">Comments</h2>
 
 `$#` is used as comment indicator. Anything starting with $# till end of the line is ignored.
 
     $# this is a comment
     Hello $name.title()! $# display the name in title case
 
-<a name="controlstructure"></a> 
-## Control Structures
+<h2 id="controlstructure">Control Structures</h2>
 
 The template system supports `for`, `while`, `if`, `elif` and `else`.
 Just like in python, body of the statement is indented.
@@ -173,11 +161,9 @@ Sometimes these can be very handy.
         </tr>
     </table>
     
-<a name="otherstatements"></a> 
-## Other Statements
+<h2 id="otherstatements">Other Statements</h2>
 
-<a name="def"></a>
-### def
+<h3 id="def">def</h3>
 
 You can define a new template function using `$def`. Keyword arguments are also supported.
 
@@ -204,8 +190,7 @@ Another example:
     $ data = [['a', 'b', 'c'], [1, 2, 3], [2, 4, 6], [3, 6, 9] ]
     $:table([tr(d) for d in data])
     
-<a name="code"></a>
-### code
+<h3 id="code">code</h3>
 
 Arbitrary python code can be written using the `code` block.
 
@@ -225,8 +210,7 @@ Arbitrary python code can be written using the `code` block.
     The variables defined in the code block can be used here.
     For example, $limit(x)
     
-<a name="var"></a>
-### var
+<h3 id="var">var</h3>
 
 The `var` block can be used to define additional properties in the template result.
 
@@ -249,8 +233,7 @@ The result of the above template can be used as follows:
     >>> str(out)
     '\n\n<div>\nhello world\n</div>\n'
 
-<a name="builtins"></a>
-# builtins and globals
+<h1 id="builtins">builtins and globals</h1>
 
 Just like any Python function, template can also access builtins along with its arguments and local variables.
 Some common builtin functions like `range`, `min`, `max` etc. and boolean values `True` and `False` are made available to all the templates.
@@ -269,8 +252,7 @@ Builtins that are exposed in the templates can be controlled too.
     # disable all builtins
     render = web.template.render('templates', builtins={})
 
-<a name="security"></a>
-# Security
+<h1 id="security">Security</h1>
 
 One of the design goals of Templetor is to allow untrusted users to write templates.
 
@@ -282,8 +264,7 @@ To make the template execution safe, the following are not allowed in the templa
 
 `SecurityException` is raised if your template uses any of these.
 
-<a name="upgrading"></a>
-# Upgrading from web.py 0.2 templates
+<h1 id="upgrading">Upgrading from web.py 0.2 templates</h1>
 
 The new implementation is mostly compatible with the earlier implementation. However some cases might not work because of the following reasons.
 
@@ -297,8 +278,7 @@ The following are still supported but not preferred.
 * Using `\$` for escaping dollar. Use `$$` instead.
 * Modifying `web.template.Template.globals`. pass globals to `web.template.render` as argument instead.
 
-<a name="errors"></a>
-# Errors you may experience
+<h1 id="errors">Errors you may experience</h1>
 
 If your error isn't mentioned here, feel free to report it by creating an
 issue with sample code used to reproduce it:
@@ -309,6 +289,7 @@ issue with sample code used to reproduce it:
 The `render` calls the template file with unexpected keyword argument `myvar`.
 
 Template file:
+
 ```
 $def with (var1, var2)
 
@@ -335,6 +316,7 @@ render.my_template_file(var1=..., var2=...)
 Template file doesn't have `$def with (...)` line (which indicates it doesn't use any variables), but 1 variable name is passed to the template while calling the `render` function.
 
 Template file:
+
 ```
 My sample content here without using any variable.
 ```
@@ -363,6 +345,7 @@ $:myvar
 ```
 
 Python code.
+
 ```
 # WRONG.
 render.my_template_file()
diff --git a/docs/0.3/templetor.zh-cn.md b/docs/0.3/templetor.zh-cn.md
index 2fe3a6ee..add77a50 100644
--- a/docs/0.3/templetor.zh-cn.md
+++ b/docs/0.3/templetor.zh-cn.md
@@ -5,8 +5,7 @@ title: Templetor web.py 模板系统
 
 # Templetor: web.py 模板系统
 
-<a name="introduction"></a>
-# Introduction
+<h1 id="introduction">Introduction</h1>
 
 <style>
 pre {
@@ -25,7 +24,6 @@ code {
 }
 </style>
 
-
 web.py 的模板语言叫做 `Templetor`，它能负责将 python 的强大功能传递给模板系统。
 在模板中没有重新设计语法，它是类 python 的。 
 如果你会 python，你可以顺手拈来。
@@ -39,11 +37,10 @@ web.py 的模板语言叫做 `Templetor`，它能负责将 python 的强大功
 第二行中的 `$name` 将会用 `name` 的值来替换。
 
 <div class="warning">
-如果是从 web.py 0.2 升级请看这里 <a href="#upgrading">升级</a> 部分。
+如果是从 web.py 0.2 升级请看这里 [升级](#upgrading) 部分。
 </div>
 
-<a name="using"></a>
-# 使用模板系统
+<h1 id="using">使用模板系统</h1>
 
 通用渲染模板的方法：
 
@@ -63,8 +60,7 @@ web.py 的模板语言叫做 `Templetor`，它能负责将 python 的强大功
     hello = web.template.Template(template)
     return hello('world')
 
-<a name="syntax"></a>
-# 语法
+<h1 id="syntax">语法</h1>
 
 ## 表达式用法
 
@@ -231,8 +227,7 @@ web.py 的模板语言叫做 `Templetor`，它能负责将 python 的强大功
     >>> str(out)
     '\n\n<div>\nhello world\n</div>\n'
 
-<a name="builtins"></a>
-# 内置 和 全局
+<h1 id="builtins">内置 和 全局</h1>
 
 像 python 的任何函数一样，模板系统同样可以使用内置以及局部参数。很多内置的公共方法像 `range`，`min`，`max`等，以及布尔值 `True` 和 `False`，在模板中都是可用的。部分内置和全局对象也可以使用在模板中。
 
@@ -249,8 +244,7 @@ web.py 的模板语言叫做 `Templetor`，它能负责将 python 的强大功
     # 禁用所有内置方法
     render = web.template.render('templates', builtins={})
 
-<a name="security"></a>
-# 安全
+<h1 id="security">安全</h1>
 
 模板的设计想法之一是允许非高级用户来写模板，如果要使模板更安全，可在模板中禁用以下方法：
 
@@ -260,8 +254,7 @@ web.py 的模板语言叫做 `Templetor`，它能负责将 python 的强大功
 
 如果模板中使用以上提及的会引发异常 `SecurityException`。
 
-<a name="upgrading"></a>
-# 从 web.py 0.2 升级
+<h1 id="upgrading">从 web.py 0.2 升级</h1>
 
 新版本大部分兼容早期版本，但仍有部分使用方法会无法运行，看看以下原因：
 
diff --git a/docs/0.3/todo.fr.md b/docs/0.3/todo.fr.md
index ae4df2dc..06d09097 100644
--- a/docs/0.3/todo.fr.md
+++ b/docs/0.3/todo.fr.md
@@ -5,7 +5,7 @@ title: TODO - A faire
 
 # TODO - A faire
 
-#Traduction française
+# Traduction française
 
 Ici sera réunie la liste des travaux à réaliser et ceux en cours de réalisation, conçernant la traduction française de web.py.
 
@@ -16,7 +16,7 @@ Ici sera réunie la liste des travaux à réaliser et ceux en cours de réalisat
 1. Les chemins des pages traduites devront ressembler à l'exemple ci-dessous et respecter la hierarchie du schéma anglais:
 	*cookbook/helloworld* --> *cookbook/helloworld/fr*
 
--------------------------------------------------
+---
 
 # En cours
 
@@ -26,7 +26,6 @@ Ici sera réunie la liste des travaux à réaliser et ceux en cours de réalisat
 
 ## Documentation de web.py 0.3
 
-
 ### Exemples de code
 * [Code samples](https://github.com/webpy/webpy-examples/). - traduction demandée
 
@@ -40,26 +39,25 @@ Ici sera réunie la liste des travaux à réaliser et ceux en cours de réalisat
 	### API Documentation
 * [API documentation](/docs/0.3/api) - traduction demandée
 
-
 ## Cookbook
 
-###Avancé
+### Avancé
 * [Comment utiliser web.background](/cookbook/background). - traduction demandée
 * [Run-time language switch](/cookbook/runtime-language-switch). - traduction demandée
 
-###Sessions et état des utilisateurs:
+### Sessions et état des utilisateurs:
 * [Utiliser session dans un gabarit](/cookbook/session_in_template). - traduction demandée
 * [Travailler avec les cookies](/cookbook/cookies). - traduction demandée
 * [Authentification des utilisateurs](/cookbook/userauth). - traduction demandée
 * [Authentification des utilisateurs avec base de données Postgresql](/cookbook/userauthpgsql). - traduction demandée
 * [Session avec des sous-apps](/cookbook/sessions_with_subapp). - traduction demandée 
 
-###Utils:
+### Utils:
 * [Envoi de Mail](/cookbook/sendmail). - traduction demandée
 * [Envoi de Mail en utilisant Gmail](/cookbook/sendmail_using_gmail).  - traduction demandée
 * [Webservice en utilisant soaplib + WSDL](/cookbook/webservice). - traduction demandée
 
-###Modèles de mise en forme, gabarits de mise en page:
+### Modèles de mise en forme, gabarits de mise en page:
 * [Utiliser des gabarits sur le site](/cookbook/layout_template). - traduction demandée
 * [Alterner un style](/cookbook/alternating_style). - traduction demandée
 * [Importer des fonctions dans les gabarits](/cookbook/template_import). - traduction demandée
@@ -69,11 +67,11 @@ Ici sera réunie la liste des travaux à réaliser et ceux en cours de réalisat
 * [Utiliser le moteur de gabarit  Jinja2 dans webpy](/cookbook/template_jinja). - traduction demandée
 * [Comment utiliser les gabarits sur Google App Engine](/cookbook/templates_on_gae). - traduction demandée
 
-###Essais:
+### Essais:
 * [Tester avec Paste et Nose](/cookbook/testing_with_paste_and_nose). - traduction demandée
 * [RESTful doctesting using an application's request method](/cookbook/restful_doctesting_using_request). - traduction demandée
 
-###Entrées utilisateurs:
+### Entrées utilisateurs:
 * [Uploader un fichier](/cookbook/fileupload). - traduction demandée
 * [Stocker un fichier uploadé](/cookbook/storeupload). - traduction demandée
 * [Comment limiter la taille des fichiers uploadés](/cookbook/limiting_upload_size). - traduction demandée
@@ -81,7 +79,7 @@ Ici sera réunie la liste des travaux à réaliser et ceux en cours de réalisat
 * [Comment utiliser les formulaires](/cookbook/forms). - traduction demandée
 * [Rendu individuel des champs de formulaires](/cookbook/form_fields). - traduction demandée
 
-###Base de données:
+### Base de données:
 * [Multiples bases de données](/cookbook/multidbs). - traduction demandée
 * [Select: Récupérer les entrées d'une base de données](/cookbook/select). - traduction demandée
 * [Update: Mettre à jour les entrées d'une base de données](/cookbook/update).  - traduction demandée
@@ -93,7 +91,7 @@ Ici sera réunie la liste des travaux à réaliser et ceux en cours de réalisat
 * [Intégrer SQLite UDF (user-defined-functions) à la couche de base de données webpy](/cookbook/sqlite-udf). - traduction demandée
 * [Utiliser un dictionnaire comme clause where](/cookbook/where_dict). - traduction demandée
 
-###Déploiement:
+### Déploiement:
 * [Déploiement Fastcgi au travers lighttpd](/cookbook/fastcgi-lighttpd). - traduction demandée
 * [Déploiement Fastcgi au travers Apache](/cookbook/fastcgi-apache).  - traduction demandée
 * [Déploiement CGI au travers Apache](/cookbook/cgi-apache). - traduction demandée
diff --git a/docs/0.3/tutorial.fr.md b/docs/0.3/tutorial.fr.md
index 350ef920..b1f2b906 100644
--- a/docs/0.3/tutorial.fr.md
+++ b/docs/0.3/tutorial.fr.md
@@ -5,29 +5,25 @@ title: web.py 0.3 tutorial
 
 # web.py 0.3 tutorial
 
-Autre langages : [english](./tutorial) | [chinese](./tutorial.zh-cn)
+Autre langages: [English](./tutorial) | [Chinese](./tutorial.zh-cn)
 
 # Sommaire
 
-
-* <a href="#introduction">Prérequis</a>
-* <a href="#manipurl">Manipuler les URLs</a>
-* <a href="#gereurl">Gérer les URLs</a>
-* <a href="#getpost">GET et POST : la différence</a>
-* <a href="#index">Page index - ma première classe</a>
-* <a href="#lance">Lancer le serveur</a>
-* <a href="#template">Modèles, gabarits</a>
-* <a href="#formulaires">Formulaires</a>
-* <a href="#bd">Base de données</a>
-* <a href="#affbd">Afficher le contenu d'une base de données</a>
-* <a href="#ecrbd">Ecrire dans une base de données</a>
-* <a href="#debug">Debugger</a>
-* <a href="#apres">Et Après ?</a>
-
-<a name="introduction"></a>
-# Prérequis
-
-
+* [Prérequis](#introduction)
+* [Manipuler les URLs](#manipurl)
+* [Gérer les URLs](#gereurl)
+* [GET et POST : la différence](#getpost)
+* [Page index - ma première classe](#index)
+* [Lancer le serveur](#lance)
+* [Modèles, gabarits](#template)
+* [Formulaires](#formulaires)
+* [Base de données](#bd)
+* [Afficher le contenu d'une base de données](#affbd)
+* [Ecrire dans une base de données](#ecrbd)
+* [Debugger](#debug)
+* [Et Après ?](#apres)
+
+<h1 id="introduction">Prérequis</h1>
 
 Vous connaissez Python et vous désirez construire un site web. Webpy vous permettra de le faire facilement.
 
@@ -35,12 +31,9 @@ Si vous décidez de suivre l'ensemble de ce tutorial, vous aurez besoin d'instal
 
 Si vous possédez déjà un projet web.py existant, jetez un oeil à la page de [mise à jour](http://webpy.org/docs/0.3/upgrade) pour plus d'informations sur la migration.
 
-
 # Commençons
 
-
-<a name="manipurl"></a>
-## Manipuler les URLs
+<h2 id="manipurl">Manipuler les URLs</h2>
 
 La partie la plus importante de n'importe quel site web est la structure des URLs. Les URLs ne sont pas que des liens que vos visiteurs voient et envoient par mails à leurs amis, elles fournissent aussi un modèle mental sur la façon avec laquel un site web fonctionne. Sur des sites populaires tels que del.icio.us, les URLs font partie même de l'interface utilisateur. Web.py rend la création d'URLs facile.
 
@@ -56,13 +49,12 @@ Maintenant, Nous devons donner à web.py notre structure URL. Commençons avec q
             '/', 'index'
             )
 
-La première partie est une expression régulière que l'on applique à une chaîne de caractère (l'URL), telle que /, /help/faq, /item/(\d+), etc.. (Note: \d+ n'admettra qu'une séquence de chiffre). Les parenthèses signifient qu'il faut capturer la séquence pour s'en servir plus tard. La seconde partie est le nom d'une Classe vers laquelle la requête sera envoyée, comme 'index', 'view', 'welcome.hello' (qui recherchera la Classe hello du module welcome.), ou get_\1.
+La première partie est une expression régulière que l'on applique à une chaîne de caractère (l'URL), telle que /, /help/faq, /item/(\d+), etc... (Note: \d+ n'admettra qu'une séquence de chiffre). Les parenthèses signifient qu'il faut capturer la séquence pour s'en servir plus tard. La seconde partie est le nom d'une Classe vers laquelle la requête sera envoyée, comme 'index', 'view', 'welcome.hello' (qui recherchera la Classe hello du module welcome.), ou get_\1.
 /1 est remplacé par la première capture de l'expression régulière; toutes les captures restantes seront passées à votre fonction. [Note traducteur : A préciser]
 
 Cette ligne signifie que nous souhaitons l'URL / (Note: la page d'accueil) qui doit être traitée par la classe nommée 'index'.
 
-<a name="gereurl"></a>
-## Gérer les URLs
+<h2 id="gereurl">Gérer les URLs</h2>
 
 Maintenant, nous avons besoin de créer une application spécifiant les URLs.
 
@@ -70,16 +62,13 @@ Maintenant, nous avons besoin de créer une application spécifiant les URLs.
 
 Cela explique à web.py qu'il faut créer une application avec les URLs qui sont listées ci-dessus, en appelant les Classes dans l'espace de noms global de ce fichier.
 
-<a name="getpost"></a>
-## GET et POST: la différence
+<h2 id="getpost">GET et POST: la différence</h2>
 
 Alors que la plupart des gens ne le remarquent pas en naviguant simplement, votre navigateur utilise un protocole connu appelé HTTP pour communiquer avec le World Wide Web. Les détails ne sont pas importants, mais l'idée de base est que les visiteurs de sites web demandent aux serveurs de sites web de remplir certaines fonctions (telles que GET ou POST) sur les URLs (comme / ou /foo?f=1).
 
 GET est celle que nous connaissons tous, celle qui sert à demander le texte d'une page web. Lorsque vous tapez 'harvard.edu' dans votre navigateur, cela demande littéralement au serveur web de Harvard de fournir /. La seconde fonction très célèbre, POST, est souvent utilisée lorsque vous utilisez certains types de formulaires, comme une demande d'achat d'un produit. Vous utilisez POST chaque fois que vous soumettez une demande (comme le débit de votre carte de crédit et le traitement d'une commande). Cela est essentiel, parce que GET URLs peut être transmis et indexé par les moteurs de recherche, que vous voulez certainement pour la plupart de vos pages, mais ne désirez certainement pas pour des choses comme le traitement des ordres (imaginez si Google essaye de tout acheter sur votre site!)
 
-
-<a name="index"></a>
-## Page index - ma première classe
+<h2 id="index">Page index - ma première classe</h2>
 
 Dans notre code web.py, nous faisons la distinction entre les deux clairement. Maintenant, il est nécessaire d'écrire la Classe 'index'.
 
@@ -97,8 +86,7 @@ Cela explique à web.py qu'il faut lancer l'application que nous avons créé ci
 
 Maintenant notez que, bien que j'ai beaucoup parlé ici, nous avons seulement cinq ou six lignes de code tout au plus. C'est tout ce dont nous avons besoin pour créer une application web.py complète. 
 
-<a name="lance"></a>
-## Lancer le serveur
+<h2 id="lance">Lancer le serveur</h2>
 
 Si vous allez dans votre terminal et que vous tapez les lignes de commande suivantes :
 
@@ -116,10 +104,7 @@ Note: Vous pouvez spécifier le numéro de port à utiliser dans la ligne de com
 
      $ python code.py 1234
 
-
-
-<a name="template"></a>
-# Modèles, gabarits
+<h1 id="template">Modèles, gabarits</h1>
 
 Ecrire du HTML à l'intérieur de python peut être lourd et pesant. C'est bien plus amusant d'écrire du Python à l'intérieur du HTML. Par bonheur, web.py le fait très facilement.
 
@@ -174,14 +159,12 @@ puis effaçez la ligne qui définit le nom. Maintenant, visitez /joe et il devra
 
 Si vous désirez en apprendre davantage sur les gabarits de web.py, visitez la page [Templetor](http://webpy.org/templetor)
 
-<a name="formulaires"></a>
-# Formulaires
+<h1 id="formulaires">Formulaires</h1>
 
 Le module de formulaire de web.py permet de générer des formulaires HTML, de récuperer les entrées des utilisateurs, et les valider avant de les traiter ou les ajouter à une base de donnée.
 Si vous souhaitez en apprendre plus sur l'utilisation du module de formulaires de web.py, consultez la [Documentation](http://webpy.org/docs/0.3.fr) ou la traduction française du module [Formulaires](http://webpy.org/docs/0.3/form.fr)
 
-<a name="bd"></a>
-# Base de données
+<h1 id="bd">Base de données</h1>
 
 Note: Avant de pouvoir utiliser une base de données, soyez certains d'avoir la librairie de la base de données appropriée déjà installée. Pour la base de donnée MySQL, utilisez MySQLdb et pour Postgres, utilisez psycopg2.
 
@@ -193,8 +176,7 @@ Premièrement, vous devez créer un objet database.
 
 C'est tout ce dont vous avez besoin -- web.py gèrera automatiquement la connexion et la déconnexion à la base de données.
 
-<a name="affbd"></a>
-## Afficher le contenu d'une base de données
+<h2 id="affbd">Afficher le contenu d'une base de données</h2>
 
 Utilisez votre interface d'administration de la base de données, et créez une simple table dans la base de données:
 
@@ -231,8 +213,7 @@ En visitant à nouveau votre site, vous devriez voir: "Learn web.py".
 
 Félicitations ! Vous venez de créer une application complète qui lit une base de données. 
 
-<a name="ecrbd"></a>
-## Ecrire dans une base données
+<h2 id="ecrbd">Ecrire dans une base données</h2>
 
 Maintenant, nous allons écrire dans la base de données.
 
@@ -271,15 +252,12 @@ Note: Afin d'accéder aux données à partir de plusieurs éléments identiqueme
 Quelques notes additionnelles: 
 
 `db.update` fonctionne comme `db.insert` excepté qu'au lieu de renvoyer l'ID, il doit recevoir en argument, après le nom de la table, soit l'ID soit une clause `WHERE` permettant d'identifier la ligne à modifier.
-
     
     db.update('todo', where="id = 10", title = "web.py pour les nuls")
 
-
 `web.input`, `db.query`, et d'autres fonctions dans web.py renvoient des Objets de Stockage (Storage objects), qui sont comme des dictionnaires mis à part que vous pouvez écrire `d.foo` en plus de `d['foo']`. Cela rend le code plus clair.
 
-<a name="debug"></a>
-# Debugger
+<h1 id="debug">Debugger</h1>
 
 web.py possède aussi des outils de debugging pour nous aider. Quand nous le faisons tourner avec le server web intégré, il commence l'application en mode debuggage. Dans ce mode, toutes les modifications du code et des gabarits sont automatiquement rechargées et les messages d'erreur contiennent de précieuses informations.
 
@@ -291,8 +269,7 @@ C'est la fin du tutorial maintenant. Jetez un oeil à la [Documentation](http://
 
 Vous pourrez trouver pleins de détails de tout ceci ainsi que de toutes les fonctions web.py dans la [Documentation](http://webpy.org/docs/0.3.fr).
 
-<a name="apres"></a>
-## Et après ?
+<h2 id="apres">Et après ?</h2>
 
 * [Plus de documentation](/docs/0.3.fr) 
 * [Formulaires](/docs/0.3/form.fr) 
diff --git a/docs/0.3/tutorial.id.md b/docs/0.3/tutorial.id.md
index 9b111867..c4365f3e 100644
--- a/docs/0.3/tutorial.id.md
+++ b/docs/0.3/tutorial.id.md
@@ -31,8 +31,7 @@ href="/install">install</a> untuk detilnya.
 
 Mari kita mulai.
 
-<a name="urlhandling"> </a>
-## Penanganan URL
+<h2 id="urlhandling">Penanganan URL</h2>
 
 Bagian paling penting dari setiap website adalah struktur URL yang 
 digunakan. URL yang Anda gunakan bukan saja merupakan sesuatu yang 
@@ -69,8 +68,7 @@ dilewatkan ke fungsi yang Anda buat.
 Baris ini menyatakan bahwa kita ingin agar URL `/` (contoh: halaman 
 depan sebuah website) akan ditangani oleh class dengan nama `index`. 
 
-<a name="getpost"> </a>
-## GET dan POST: perbedaannya
+<h2 id="getpost">GET dan POST: perbedaannya</h2>
 
 Sekarang kita ingin menulis class `index`. Walau sebagian besar 
 pengunjung tidak memperhatikan pada saat browsing, browser Anda 
@@ -134,8 +132,7 @@ Untuk lebih mudahnya, berikut adalah kode lengkapnya:
         app = web.application(urls, globals())
         app.run()
 
-<a name="start"> </a>
-## Memulai server
+<h2 id="start">Memulai server</h2>
 
 Apabila Anda ke command line dan mengetikkan:
 
@@ -155,9 +152,7 @@ nilai default:
 
     $ python code.py 1234
 
-
-<a name="templating"> </a>
-## Menggunakan template
+<h2 id="templating">Menggunakan template</h2>
 
 Menulis HTML di dalam Python bisa menjadi merepotkan; lebih nyaman 
 untuk menulis Python di dalam HTML. Untungnya, web.py membuatnya cukup 
@@ -229,10 +224,9 @@ Dan hapuslah baris yang mengatur name. Sekarang, kunjungilah `/Joe`
 dan harusnya, hello kepada Joe akan ditampilkan. 
 
 Apabila Anda ingin belajar lebih lanjut tentang template, kunjungilah 
-<a href="/docs/0.3/templetor">halaman templetor</a>.
+[halaman templetor](/docs/0.3/templetor).
 
-<a name="forms"> </a>
-## Form
+<h2 id="forms">Form</h2>
 
 Modul form dari web.py memungkinkan pembuatan form HTML, mendapatkan 
 input dari user, dan melakukan validasi sebelum input diproses atau 
@@ -240,8 +234,7 @@ ditambahkan ke dalam database. Apabila Anda ingin belajar lebih lanjut
 tentang modul form web.py, bacalah [Dokumentasi](/docs/0.3) or 
 kunjungilah link langsung ke [Pustaka Form](/form).
 
-<a name="databasing"> </a>
-## Menggunakan database
+<h2 id="databasing">Menggunakan database</h2>
 
 **Catatan:** Sebelum Anda dapat mulai menggunakan database, 
 pastikanlah pustaka untuk mengakses database telah terinstall. Untuk 
@@ -344,8 +337,7 @@ bersih.
 Untuk detil lebih lanjut, termasuk untuk semua fungsi web.py, bacalah 
 [dokumentasi](/docs/0.3).
 
-<a name="developing"> </a>
-## Selama pengembangan
+<h2 id="developing">Selama pengembangan</h2>
 
 web.py juga memiliki beberapa alat bantu untuk membantu kita melakukan 
 debugging. Pada saat berjalan dengan web server bawaan, web.py akan 
@@ -359,8 +351,7 @@ Anda dapat menambahkan kode berikut sebelum membuat aplikasi/template:
 
     web.config.debug = False
 
-<a name="whatnext"> </a>
-## Berikutnya?
+<h2 id="whatnext">Berikutnya?</h2>
 
 Sampai di sini dulu tutorial kita. Kunjungilah [buku resep](/cookbook/) 
 dan [contoh kode](https://github.com/webpy/webpy-examples/) untuk contoh-contoh keren yang dapat Anda 
diff --git a/docs/0.3/tutorial.md b/docs/0.3/tutorial.md
index 408188f7..5442106b 100644
--- a/docs/0.3/tutorial.md
+++ b/docs/0.3/tutorial.md
@@ -5,7 +5,7 @@ title: Tutorial
 
 # Tutorial
 
-Other languages : [chinese 简体中文 ](/docs/0.3/tutorial.zh-cn) | [français](/docs/0.3/tutorial.fr) | [Bahasa Indonesia](/docs/0.3/tutorial.id) | ...
+Other languages: [Chinese 简体中文 ](/docs/0.3/tutorial.zh-cn) | [Français](/docs/0.3/tutorial.fr) | [Bahasa Indonesia](/docs/0.3/tutorial.id) | ...
 
 ## Summary
 
@@ -23,12 +23,11 @@ Other languages : [chinese 简体中文 ](/docs/0.3/tutorial.zh-cn) | [français
 
 So you know Python and want to make a website. web.py provides the code to make that easy.
 
-If you want to do the whole tutorial, you'll need to have installed Python, web.py, flup, psycopg2, and Postgres (or equivalent database and Python driver). (See <a href="/install">install</a> for details.)
+If you want to do the whole tutorial, you'll need to have installed Python, web.py, flup, psycopg2, and Postgres (or equivalent database and Python driver). (See [install](/install) for details.)
 
 Let's get started.
 
-<a name="urlhandling"> </a>
-## URL Handling
+<h2 id="urlhandling">URL Handling</h2>
 
 The most important part of any website is its URL structure. Your URLs aren't just the thing that your visitors see and email to their friends, they also provide a mental model of how your website works. On popular sites like [del.icio.us](http://del.icio.us/), the URLs are even part of the user interface. web.py makes it easy to make great URLs.
 
@@ -48,8 +47,7 @@ The first part is a [regular expressions](http://osteele.com/tools/rework/) that
 
 This line says we want the URL `/` (i.e. the front page) to be handled by the class named `index`.
 
-<a name="getpost"> </a>
-## GET and POST: the difference
+<h2 id="getpost">GET and POST: the difference</h2>
 
 Now we need to write the `index` class. While most people don't notice it just browsing around, your browser uses a language known as HTTP for communicating with the World Wide Web. The details aren't important, but the basic idea is that Web visitors ask web servers to perform certain functions (like `GET` or `POST`) on URLs (like `/` or `/foo?f=1`).
 
@@ -92,8 +90,7 @@ if __name__ == "__main__":
     app.run()
 ```
 
-<a name="start"> </a>
-## Start the server
+<h2 id="start">Start the server</h2>
 
 If you go to your command line and type:
 
@@ -112,8 +109,7 @@ $ python code.py 1234
 http://0.0.0.0:1234/
 ```
 
-<a name="templating"> </a>
-## Templating
+<h2 id="templating">Templating</h2>
 
 Writing HTML from inside Python can get cumbersome; it's much more fun to write Python from inside HTML. Luckily, web.py makes that pretty easy.
 
@@ -165,16 +161,14 @@ and change the definition of the method `GET` to:
 
 and delete the line setting name. Now visit `/Joe` and it should say hello to Joe.
 
-If you wish to learn more about web.py templates, visit the <a href="/docs/0.3/templetor">templetor page</a>.
+If you wish to learn more about web.py templates, visit the [templetor page](/docs/0.3/templetor).
 
-<a name="forms"> </a>
-## Forms
+<h2 id="forms">Forms</h2>
 
 The form module of web.py allows the ability to generate html forms, get user input, and validate it before processing it or adding it to a database.
 If you want to learn more about using the module forms web.py, see the [Documentation](/docs/0.3) or direct link to [Form Library](/cookbook/forms)
 
-<a name="databasing"> </a>
-## Databasing
+<h2 id="databasing">Databasing</h2>
 
 **Note:** Before you can start using a database, make sure you have the appropriate database library installed.  For MySQL databases, use [MySQLdb](http://sourceforge.net/project/showfiles.php?group_id=22307) and for Postgres use [psycopg2](http://initd.org/pub/software/psycopg/).
 
@@ -269,8 +263,7 @@ Some quick additional notes: `db.update` works just like `db.insert` except inst
 
 You can find the full details on these and all the web.py functions in [the documentation](/docs/0.3).
 
-<a name="developing"> </a>
-## Developing
+<h2 id="developing">Developing</h2>
 
 web.py also has a few tools to help us with debugging. When running with the built-in webserver, it starts the application in debug mode. In debug mode any changes to code and templates are automatically reloaded and error messages will have more helpful information.
 
@@ -278,8 +271,7 @@ The debug is not enabled when the application is run in a real webserver. If you
 
     web.config.debug = False
 
-<a name="whatnext"> </a>
-## What Next ?
+<h2 id="whatnext">What Next ?</h2>
 
 This ends the tutorial for now. Take a look at the [cookbook](/cookbook/) and the [code examples](https://github.com/webpy/webpy-examples/)  for lots more cool stuff you can do with web.py.
 Also don't forget about the [api reference](/docs/0.3/api)
diff --git a/docs/0.3/tutorial.zh-cn.md b/docs/0.3/tutorial.zh-cn.md
index ee5f066a..40761d9a 100644
--- a/docs/0.3/tutorial.zh-cn.md
+++ b/docs/0.3/tutorial.zh-cn.md
@@ -25,8 +25,7 @@ title: web.py 0.3 新手指南
 
 准备开始。
 
-<a name="urlhandling"> </a>
-## URL 处理
+<h2 id="urlhandling">URL 处理</h2>
 
 任何网站最重要的部分就是它的URL结构。你的URL并不仅仅只是访问者所能看到并且能发给朋友的。它还规定了你网站运行的心智模型。在一些类似[del.icio.us](http://del.icio.us/)的流行网站 , URL甚至是UI的一部分。 web.py使这类强大的URL成为可能。
 
@@ -52,8 +51,7 @@ title: web.py 0.3 新手指南
 
 这会告诉web.py去创建一个基于我们刚提交的URL列表的application。这个application会在这个文件的全局命名空间中查找对应类。
 
-<a name="getpost"> </a>
-## GET和POST: 区别
+<h2 id="getpost">GET和POST: 区别</h2>
 
 现在我们需要来写`index`类。虽然大多数人只会看看，并不会注意你的浏览器在使用用于与万维网通信的HTTP语言。具体的细节并不重要，但是要理解web访问者请求web服务器去根据URL(像`/`、`/foo?f=1`)执行一个合适的函数（像`GET`、`POST`）的基本思想。
 
@@ -73,7 +71,6 @@ title: web.py 0.3 新手指南
 
 这会告诉web.py为我们启动上面我们写的应用。
 
-
 现在注意，即使我已经在这里说了很多，但我们真正有5行这些代码。这就是你需要编写的一个完整的web.py应用。
 为了更方便的使用，你的完整代码应该像下面这样:
 
@@ -91,8 +88,7 @@ title: web.py 0.3 新手指南
         app = web.application(urls, globals())
         app.run()
 
-<a name="start"> </a>
-## 启动服务
+<h2 id="start">启动服务</h2>
 
  如果你在命令行下面，请输入::
     $ python code.py
@@ -104,8 +100,7 @@ title: web.py 0.3 新手指南
 
     $ python code.py 1234
 
-<a name="templating"> </a>
-## 模板
+<h2 id="templating">模板</h2>
 
 在 Python 中写 HTML 不是聪明的选择，相反在 HTML 中写 Python 则有趣的多。幸运的是，`web.py` 让这件事情做得简单而又漂亮。
 
@@ -160,15 +155,12 @@ URL 的后面的 `?` 看起来不好看？修改下 URL 配置：
 
 如果学习更多关于 web.py 的模板处理，请访问 [web.py 模板](/docs/0.3/templetor).
 
-<a name="forms"> </a>
-## 表单
+<h2 id="forms">表单</h2>
 
 web.py的form模块能够帮助你生成HTML表单；获取用户的输入，并在处理或添加到数据库之前对其进行内容的验证。
 如果你要学习更多关于form模块的使用，请查看[帮助文档](/docs/0.3)或者[Form](/form)类库的链接
 
-
-<a name="databasing"> </a>
-## 数据库操作
+<h2 id="databasing">数据库操作</h2>
 
 **注意:** 在你开始使用数据库之前，确保你已经安装了合适的数据库访问库。比如对于MySQL数据库，使用 [MySQLdb](http://sourceforge.net/project/showfiles.php?group_id=22307) ，对于Postgres数据库使用[psycopg2](http://initd.org/pub/software/psycopg/)。
 
@@ -249,8 +241,7 @@ web.py的form模块能够帮助你生成HTML表单；获取用户的输入，并
 
 你可以在[the documentation](/docs/0.3)找到这方面具体的细节以及所有web.py的函数说明。
 
-<a name="developing"> </a>
-## 开发
+<h2 id="developing">开发</h2>
 
 web.py 还有一些帮助我们debug的工具。当它在内建的服务器中运行时，它会以debug模式启动程序。在debug模式中，任何代码、模板的修改，都会让服务器重新加载它们，然后还会输出有用的错误消息。
 
@@ -260,8 +251,7 @@ web.py 还有一些帮助我们debug的工具。当它在内建的服务器中
 
 我们的指南就到这里了。如果要做更多很酷的东西，你可以先查看一下文档。
 
-<a name="whatnext"> </a>
-## 下一步是什么?
+<h2 id="whatnext">下一步是什么?</h2>
 
 * [更多文档](/docs/0.3)
 * [Cookbook](/cookbook)
diff --git a/docs/0.3/upgrade.md b/docs/0.3/upgrade.md
index a948e708..2cf3d8a5 100644
--- a/docs/0.3/upgrade.md
+++ b/docs/0.3/upgrade.md
@@ -7,14 +7,13 @@ title: How to upgrade from earlier versions of web.py to 0.3
 
 Web.py 0.3 has some backward-incompatible changes. 
 
-* <a href="#return">prints are replaced by return statements</a>
-* <a href="#app">new application framework</a>
-* <a href="#db">new database system</a>
-* <a href="#exceptions">http errors are exceptions</a>
-* <a href="#others">other incompatible changes</a>
+* [prints are replaced by return statements](#return)
+* [new application framework](#app)
+* [new database system](#db)
+* [http errors are exceptions](#exceptions)
+* [other incompatible changes](#others)
 
-<a name="return"></a>
-## prints are replaced by return statements
+<h2 id="return">prints are replaced by return statements</h2>
 
 In earlier versions of web.py the GET and POST methods used to print the data to be send to the client. Now instead of printing the data, the data must be returned from that function. This makes post-processing of returned data possible.
 
@@ -59,8 +58,7 @@ It should become:
     if __name__ == "__main__":
         app.run()
 
-<a name="db"></a>
-## new database system
+<h2 id="db">new database system</h2>
 
 The database module of web.py has been improved to make it more modular.
 
@@ -101,8 +99,7 @@ If you are using python 2.5 or later, transactions can be used with `with` state
 		    db.insert('t1', name='foo')
 		    db.insert('t2', name='bar')
             
-<a name="exceptions"></a>
-## http errors are exceptions
+<h2 id="exceptions">http errors are exceptions</h2>
 
 In 0.3, all http errors have been changed to exceptions.
 
@@ -124,8 +121,7 @@ It should become:
         else:
 	    ....
 
-<a name="others"></a>
-## Other incompatible changes
+<h2 id="others">Other incompatible changes</h2>
 
 In web.py 0.3, `web.input()` returns values in unicode. This may create trouble sometimes.
 
diff --git a/docs/work.md b/docs/work.md
index 2bef6cbe..0e37b5f6 100644
--- a/docs/work.md
+++ b/docs/work.md
@@ -11,32 +11,35 @@ We need both reporters (tell us what's wrong!) and fixers (write code, make cont
 
 When adding work to be done, please place it in a section devoted to the page and/or parent page, and a link to that page. For example:
 
-***
-#Cookbook: [Cookbook](/cookbook)
+---
+
+# Cookbook: [Cookbook](/cookbook)
+
 * database select example code is incorrect
 
-***
+---
 
 When finishing working on something, delete it from the list. If a code block refers to old (version 0.2 for example) code, please add it to a separate url.  Also, add new content at new url (and delete old link when done) For instance:
 
 1. /foo is out of date with version 0.2 code
-1. move /foo to /foo/0.2
-1. put new code at /foo/0.3
-1. delete content at /foo, and update any urls that link to it
+2. move /foo to /foo/0.2
+3. put new code at /foo/0.3
+4. delete content at /foo, and update any urls that link to it
+
+---
 
+# Code samples: [Code samples](https://github.com/webpy/webpy-examples/)
 
-***
-#Code samples: [Code samples](https://github.com/webpy/webpy-examples/)
 * Move url to /samples
 
 ## Samples
+
 * simple-wiki: 0.2, external
 * simple-wiki num 2: 0.2, external
 * simple delicious: 0.2
 * alternate tutorial SQLite & SQLObject: 0.2
 * templating with genshi: should be part of larger 'templating' section
 
-
 ## tips & tricks
 
 * Possibly move entirely to cookbook?
@@ -51,9 +54,8 @@ vhost, metaclass and multiple apps should have separate section, but this setup
 * serving images: 0.2, should use mimetypes module?
 * multiple apps: not needed
 
-
 ## Real web apps
 
 * Leave them external, but annotate which version of webpy they use.
 
-***
+---
diff --git a/download.fr.md b/download.fr.md
index b6cca82c..5c329114 100644
--- a/download.fr.md
+++ b/download.fr.md
@@ -5,7 +5,7 @@ title: Téléchargement
 
 # Téléchargement
 
-Autre langages : [english](/download) | ...
+Autre langages: [English](/download) | ...
 
 ## Obtenir la dernière version stable
 
diff --git a/download.md b/download.md
index deba58a3..cd27e24f 100644
--- a/download.md
+++ b/download.md
@@ -5,7 +5,7 @@ title: Download
 
 # Download
 
-Other languages : [français](/download/fr) | ...
+Other languages: [Français](/download/fr) | ...
 ## Get the latest stable version
 
 The easiest way to install web.py is using [easy_install](http://peak.telecommunity.com/DevCenter/EasyInstall):
diff --git a/ideas.md b/ideas.md
index 926f3ec0..63fb31e7 100644
--- a/ideas.md
+++ b/ideas.md
@@ -9,30 +9,25 @@ Here are ideas for web.py projects to take on if you have some free time, say, t
 
 ## web.py infrastructure
 
-<a name="enhancing-templating"></a>
-### enhancing templating
+<h3 id="enhancing-templating">enhancing templating</h3>
 
 The current templating system, and even Alice Atlas's rewrite, doesn't perfectly conform to the spec. For example, it doesn't support arbitrary Python code execution within a template. This project would be to take the templating system the final mile and fix the remaining bugs and unimplemented features.
 
-<a name="engine-agnostic-templating"></a>
-### Engine-agnostic templating
+<h3 id="engine-agnostic-templating">Engine-agnostic templating</h3>
 
 Python has many templating engines, each emphasizing different features and approaches. Web.py currently supports Cheetah and Templator (its built-in engine). It would be nice to be able to be able to use the same model (a 'render' object which responds to template names, outputs the content-type, etc) with other engines (like Genshi, Clearsilver, Kid and others). Turbogears has some code doing similar stuff that can be canibalized.
 
-<a name="javascript-form-support"></a>
-### javascript form support
+<h3 id="javascript-form-support">javascript form support</h3>
 
 It's annoying to have to fill out a form.py form, only to get it back to find that it's been incorrectly filled out. This project would be to add metadata to web.py validators to allow them to be implemented in JavaScript (for `notnull` and `regexp`, this should be trivial) and then update the forms so that they work like [this qweb example][q] -- giving the user immediate feedback when they've failed a requirement.
 
   [q]: http://notabug.com/qweb/bbbbb
 
-<a name="user-accounts"></a>
-### user accounts
+<h3 id="user-accounts">user accounts</h3>
 
 web.py has long been lacking a user account system. The goal would be to build something simple and flexible enough that it could be plugged into all sorts of database backends and UI front ends, but still handle the details of HMACs and OpenID and stuff like that. If you're interested in this project, work with the mailing list to come up with a clear spec before you get started.
 
-<a name="built-in-session-middleware"></a>
-### Built-in session middleware
+<h3 id="built-in-session-middleware">Built-in session middleware</h3>
 
 Sessions are a useful abstraction for web applications. Flup comes with some simple session middleware, but it doesn't back to databases (which is very useful if your deployment scenario relies on multiple web servers using the same DB server). It would be nice if web.py would come with a built-in, file or DB -backed session facility.
 
@@ -42,50 +37,42 @@ Is there a set of functionality you find yourself implementing over and over tha
 
 ## web.py tools
 
-<a name="screen-scraping-data-processing"></a>
-### screen scraping / data processing
+<h3 id="screen-scraping-data-processing">screen scraping / data processing</h3>
 
 Lots of exciting web sites (e.g. [Chicago Crime][cc]) are built by scraping existing public data sources and reformulating them in a new way. This project would be to work on various public works screen scraping and data processing tasks to feed data to a new such public works site.
 
   [cc]: http://chicagocrime.org/
 
-<a name="collaborative-filtering"></a>
-### collaborative filtering
+<h3 id="collaborative-filtering">collaborative filtering</h3>
 
 Many database-backed web sites display various sorts of items -- news stories, users, photos -- and provide users with various techniques for finding them. Most of the traditional techniques (searching, filtering, following links) are pretty easy to implement in web.py. But one key one that's missing is support for collaborative filtering. This project would be to take existing collaborative filtering algorithms and implementations (e.g. [consensus][c]), possibly improving them or replacing them if necessary, and fitting them into a framework where they can be used on large-scale web.py sites. That means developing tools to move stuff from the database into the recommendation system, store the recommendations, update the recommendations regularly, etc.
 
   [c]: http://exogen.case.edu/projects/consensus/
 
-<a name="stats-package"></a>
-### stats package
+<h3 id="stats-package">stats package</h3>
 
 Every hit to the server contains within it a wealth of information -- user IP, cookies, browser information, referrers -- but for most people, all this data is largely thrown a way. For the most part, people still use the same log analysis tools developed in the early 1990s. What about a system that used the power of modern databases to let you explore this log information in a meaningful way? Click on a particular URL and see how its traffic has changed over time, how it compares with other URLs on the site, what referrers have linked to it and what those referrers say about it. Click on a particular IP and see its entire path through the site, watching where it came from and where it got stuck. And so on. I've got _lots_ of ideas for this if you're interested in building it.
 
 ## web apps
 
-<a name="startupideas-org"></a>
-### startupideas.org
+<h3 id="startupideas-org">startupideas.org</h3>
 
 A bunch of people come up with fairly good ideas for new web apps to build. A bunch of people are fairly good at building them. But, as far as I can tell, these groups aren't very good at talking to each other. This would be a simple web.py site where people could submit their new website ideas, other people could vote and comment on them, and developers could sign up to implement them. It's all about bringing people together. To build websites.
 
-<a name="teh-communicator"></a>
-### teh communicator
+<h3 id="teh-communicator">teh communicator</h3>
 
 IRC is nice for asking questions because you can get answers in real-time. But it's bad because it requires special client software, has pretty useless archives, and if no one answers your question in real-time then it doesn't get answered. "teh communicator" (just a code name) is a project to develop a new website that uses AJAX push to give you the realtime feel of IRC on a website (using web.py's `untwisted` module) but stores conversations in a database so that they're nicely archived, threaded, and you can keep track of which ones have already been answered.
 
-<a name="wiki-debate"></a>
-### WikiDebate
+<h3 id="wiki-debate">WikiDebate</h3>
 
 Wikipedia is great when you want to know the facts of a subject, but often you don't want the facts, you want the arguments. The goal of the WikiDebate project would be to develop a new site that was more of a cross between a threaded discussion and Wikipedia. Instead of simply having an edit war over which are the real facts, the site would capture the structure of real arguments on the subject, with the back-and-forth of claim and refutation. Ideally, pointless online arguments could be moved into this system and real progress could be made, instead of hashing the same points out over and over again.
 
-<a name="webpy-org"></a>
-### webpy.org
+<h3 id="webpy-org">webpy.org</h3>
 
 When people fish for a Python web framework, the first thing they encounter is the framework's website. They check how good (and easy to use) the documentation is, how easy it is to report bugs and interact with the developers, and those who aren't very technical just check how warm and fuzzy the website makes them feel. Web.py's website is not doing very well on the warm-and fuzzyness effort, it's distributed between a static page (decent design, but sparse), a wiki (on a commercial service, developed using web.py itself but looking pretty generic), a Trac site (which needs lots of love if it is to be at all useful) and a mailing list. The challenge is to both do a better job at marketing _and_ getting real value out of the effort (by making it easier for people collaborate of developing and supporting web.py).
 
 ## web.py community
 
-<a name="pyweek-for-webpy"></a>
-### PyWeek for web.py
+<h3 id="pyweek-for-webpy">PyWeek for web.py</h3>
 
 [PyWeek](http://www.pyweek.org/) is a contest challenging entrants to design, build, and complete a game starting from scratch in only one week.  Web.py could start with a similar model and rule set and invite interested parties to take a simple idea for a web app (possibly connected to startupideas.org?) and turn it into a functioning application in a specified amount of time.  Judgment and prizes aren't the point, we want to inspire folks with some free time to pick up the tools and just start using them.
diff --git a/index.es.md b/index.es.md
index 68f9a506..179f0cd6 100644
--- a/index.es.md
+++ b/index.es.md
@@ -3,7 +3,7 @@ layout: default
 title: ¡Bienvenido a web.py!
 ---
 
-Other langages : [Inglés](/index.html) | [Francés](/index.fr.html) | ...
+Other langages: [Inglés](/index.html) | [Francés](/index.fr.html) | ...
 
 ## Acerca de web.py
 
@@ -52,20 +52,20 @@ web.py fue publicado originalmente cuando Aaron Swartz trabajaba en [reddit.com]
 ### Algunos testimonios de usuarios:
 
 * "En el ecosistema de los frameworks web, alguno debe ocupar el nicho de 'pequeño, ligero y rápido': web.py hace eso."*  
-<span class="cite">&nbsp;&nbsp;&mdash;&nbsp; Lloyd Dalton, [colr.org](http://colr.org)</span>
+<span class="cite">&mdash; Lloyd Dalton, [colr.org](http://colr.org)</span>
 
 * "Hemos terminado de reescribir nuestro servidor en apenas unos días con la ayuda de web.py y tuvo todo lo que esperábamos."*  
-<span class="cite">&nbsp;&nbsp;&mdash;&nbsp; Sam Hsiung, [YouOS][25]</span>
+<span class="cite">&mdash; Sam Hsiung, [YouOS][25]</span>
 
    [25]: http://www.youos.com/
 
 * "[Web.py inspiró] el web framework que usamos en FriendFeed [y] el framework para aplicaciones web que se entrega con App Engine..."*  
-<span class="cite">&nbsp;&nbsp;&mdash;&nbsp; [Brett Taylor](http://backchannel.org/blog/google-app-engine), co-fundador de FriendFeed y líder técnico original en Google App Engine</span>
+<span class="cite">&mdash; Brett Taylor](http://backchannel.org/blog/google-app-engine), co-fundador de FriendFeed y líder técnico original en Google App Engine</span>
 
 * "Django te permite escribir aplicaciones web en Django. TurboGears te permite escribir aplicaciones web en TurboGears. Web.py te permite escribir aplicaciones web en Python."*  
-<span class="cite">&nbsp;&nbsp;&mdash;&nbsp; Alice Atlas</span>
+<span class="cite">&mdash; Alice Atlas</span>
 
 * "Guido* [van Rossum, creador de Python]*, probablemente encuentres que web.py es el que mejor se ajusta a tu estilo. ... Si no te gusta, no puedo imaginarme cual de la otra docena de frameworks existentes te __puede__ gustar."*   
-<span class="cite">&nbsp;&nbsp;&mdash;&nbsp; Phillip J. Eby, creador de Python Web Server Gateway Interface (WSGI) [#][30]</span>
+<span class="cite">&mdash; Phillip J. Eby, creador de Python Web Server Gateway Interface (WSGI) [#][30]</span>
 
    [30]: http://www.artima.com/forums/flat.jsp?forum=106&thread=146149&start=30&msRange=15
diff --git a/index.fr.md b/index.fr.md
index d61cfa74..ad4a1607 100644
--- a/index.fr.md
+++ b/index.fr.md
@@ -5,12 +5,11 @@ title: A propos de Web.py
 
 # A propos de Web.py
 
-Autre langages : [english](/) | [Español](/index.es.html) | ...
-
+Autre langages: [English](/) | [Español](/index.es.html) | ...
 
 **web.py** est un framework pour python qui est aussi simple qu'il est puissant. Web.py est dans le domaine publique; vous pouvez l'utiliser à toutes fins sans aucunes restrictions.
 
-##Une application complète web.py
+## Une application complète web.py
 
     import web
             
@@ -28,7 +27,6 @@ Autre langages : [english](/) | [Español](/index.es.html) | ...
     if __name__ == "__main__":
         app.run()
 
-
 ## Pour commençer
 
 web.py 0.51 a été réalisé le 2019-09-27: [web.py-0.51.tar.gz][16]
@@ -77,44 +75,44 @@ web.py a été publié alors que Aaron Swartz travaillait sur [reddit.com][20],
 
 ### Appréciations des
 
-"Dans l'écosystème des frameworks web, quelque chose doit occuper le créneau du "petit, léger et rapide". web.py est celui-là."  
-- Lloyd Dalton, [colr.org](http://colr.org)
+* "Dans l'écosystème des frameworks web, quelque chose doit occuper le créneau du "petit, léger et rapide". web.py est celui-là."  
+<span class="cite">&mdash; Lloyd Dalton, [colr.org](http://colr.org)</span>
 
-"Nous avons terminé la réécriture de notre serveur il y a quelques jours avec web.py et c'était tout ce que nous souhaitions."  
-- Sam Hsiung, [YouOS][25]
+* "Nous avons terminé la réécriture de notre serveur il y a quelques jours avec web.py et c'était tout ce que nous souhaitions."  
+<span class="cite">&mdash; Sam Hsiung, [YouOS][25]</span>
 
    [25]: http://www.youos.com/
 
-"Django vous permet d'écrire des applications web en Django. TurboGears vous permet d'écrire des applications web en TurboGears. Web.py vous permet d'écrire des applications web en Python."  
-- Alice Atlas
+* "Django vous permet d'écrire des applications web en Django. TurboGears vous permet d'écrire des applications web en TurboGears. Web.py vous permet d'écrire des applications web en Python."  
+<span class="cite">&mdash; Alice Atlas</span>
 
-"Très élégant et concis (sans oublier que c'est écrit par Aaron Swartz, dont les compétences en codage sont impressionnantes), et ça ne m'a pas fait perdre de temps."   
-- Jonas Galvez, Aupeo [#][26]
+* "Très élégant et concis (sans oublier que c'est écrit par Aaron Swartz, dont les compétences en codage sont impressionnantes), et ça ne m'a pas fait perdre de temps."   
+<span class="cite">&mdash; Jonas Galvez, Aupeo [#][26]</span>
 
    [26]: http://www.artima.com/forums/flat.jsp?forum=106&thread=146149
 
-"Le premier framework ... sur lequel je peux bidouiller du code et voir quelque chose fonctionner sans même être obligé de comprendre la logique de celui-ci. Un plaisir à intégrer."   
-- Delaunay Antoine built [a photo gallery][28] and [an agenda][34] with it
+* "Le premier framework ... sur lequel je peux bidouiller du code et voir quelque chose fonctionner sans même être obligé de comprendre la logique de celui-ci. Un plaisir à intégrer."   
+<span class="cite">&mdash; Delaunay Antoine built [a photo gallery][28] and [an agenda][34] with it</span>
 
    [28]: http://github.com/antoine/ibrouteur/
    [34]: http://metagenda.org
 
-"Guido [van Rossum, Créateur de Python], vous constaterez probablement que web.py convient le mieux à votre style. ...Si vous ne l'aimez pas, je ne peux imaginer lequel des autres douzaines d'autres framework sortis vous *pourriez* aimer."   
-- Phillip J. Eby, créateur du Python Web Server Gateway Interface (WSGI) [#lien][30]
+* "Guido [van Rossum, Créateur de Python], vous constaterez probablement que web.py convient le mieux à votre style. ...Si vous ne l'aimez pas, je ne peux imaginer lequel des autres douzaines d'autres framework sortis vous *pourriez* aimer."   
+<span class="cite">&mdash; Phillip J. Eby, créateur du Python Web Server Gateway Interface (WSGI) [#lien][30]</span>
 
    [30]: http://www.artima.com/forums/flat.jsp?forum=106&thread=146149&start=30&msRange=15
 
-"... l'exemple [Cheetah] que j'ai vu sur web.py à l'air "bon". (web.py itself OTOH gets an "F", for undocumented code with too much magic behavior. upvars(), bah.)"  [ Note traducteur : A préciser]
-- Guido van Rossum, Créateur de Python [#Lien][31]
+* "... l'exemple [Cheetah] que j'ai vu sur web.py à l'air "bon". (web.py itself OTOH gets an "F", for undocumented code with too much magic behavior. upvars(), bah.)"  [ Note traducteur : A préciser]
+<span class="cite">&mdash; Guido van Rossum, Créateur de Python [#Lien][31]</span>
 
    [31]: http://www.artima.com/weblogs/viewpost.jsp?thread=146503
 
-"il suffit de dire je crois, que Aaron se dirige dans la bonne direction."   
-- Harry Fuecks: [un simple wiki avec web.py][32]
+* "il suffit de dire je crois, que Aaron se dirige dans la bonne direction."   
+<span class="cite">&mdash; Harry Fuecks: [un simple wiki avec web.py][32]</span>
 
    [32]: http://www.sitepoint.com/blogs/2006/01/06/a-simple-wiki-with-webpy/
 
-"un moment très fascinant pour moi. Le même sentiment que j'ai eu lorsque j'ai écrit pour la première fois un script PHP. il est certain que ça me permettra d'apprendre python de façon amusante. Bon travail Aaron !"   
-- Kamal [Un simple blog en webpy, apprendre python de façon amusante][33]
+* "un moment très fascinant pour moi. Le même sentiment que j'ai eu lorsque j'ai écrit pour la première fois un script PHP. il est certain que ça me permettra d'apprendre python de façon amusante. Bon travail Aaron !"   
+<span class="cite">&mdash; Kamal [Un simple blog en webpy, apprendre python de façon amusante][33]</span>
 
    [33]: http://www.k4ml.com/node/165
diff --git a/index.md b/index.md
index d2cbb5be..c276313d 100644
--- a/index.md
+++ b/index.md
@@ -3,7 +3,7 @@ layout: default
 title: Welcome to web.py!
 ---
 
-Other langages : [French](/index.fr.html) | [Español](/index.es.html) | ...
+Other langages: [Français](/index.fr.html) | [Español](/index.es.html) | ...
 
 ## About web.py
 
@@ -59,16 +59,16 @@ web.py was originally published while Aaron Swartz worked at [reddit.com][20], w
 
 ### Some user testimonials:
 
-* "In the ecosystem of web frameworks, something must occupy the niche of 'small, light, and fast': web.py does this."*
-<span class="cite">&nbsp;&nbsp;&mdash;&nbsp; Lloyd Dalton, [colr.org](http://colr.org)</span>
+* "In the ecosystem of web frameworks, something must occupy the niche of 'small, light, and fast': web.py does this."*  
+<span class="cite">&mdash; Lloyd Dalton, [colr.org](http://colr.org)</span>
 
-* "[Web.py inspired the] web framework we use at FriendFeed [and] the webapp framework that ships with App Engine..."*
-<span class="cite">&nbsp;&nbsp;&mdash;&nbsp; [Brett Taylor](http://backchannel.org/blog/google-app-engine), co-founder of FriendFeed and original tech lead on Google App Engine</span>
+* "[Web.py inspired the] web framework we use at FriendFeed [and] the webapp framework that ships with App Engine..."*  
+<span class="cite">&mdash; [Brett Taylor](http://backchannel.org/blog/google-app-engine), co-founder of FriendFeed and original tech lead on Google App Engine</span>
 
-* "Django lets you write web apps in Django. TurboGears lets you write web apps in TurboGears. Web.py lets you write web apps in Python."*
-<span class="cite">&nbsp;&nbsp;&mdash;&nbsp; Alice Atlas</span>
+* "Django lets you write web apps in Django. TurboGears lets you write web apps in TurboGears. Web.py lets you write web apps in Python."*  
+<span class="cite">&mdash; Alice Atlas</span>
 
-* "Guido* [van Rossum, creator of Python]*, you'll probably find that web.py best suits your style. ... If you don't like it, I can't imagine which of the other dozens of frameworks out there you __would__ like."*
-<span class="cite">&nbsp;&nbsp;&mdash;&nbsp; Phillip J. Eby, creator of the Python Web Server Gateway Interface (WSGI) [#][30]</span>
+* "Guido* [van Rossum, creator of Python]*, you'll probably find that web.py best suits your style. ... If you don't like it, I can't imagine which of the other dozens of frameworks out there you __would__ like."*  
+<span class="cite">&mdash; Phillip J. Eby, creator of the Python Web Server Gateway Interface (WSGI) [#][30]</span>
 
    [30]: http://www.artima.com/forums/flat.jsp?forum=106&thread=146149&start=30&msRange=15
diff --git a/install.es.md b/install.es.md
index 2b0d3332..f99723af 100644
--- a/install.es.md
+++ b/install.es.md
@@ -5,27 +5,26 @@ title: Guía de instalación
 
 # Guía de instalación
 
-Otros idiomas : [english](/install) | [Japan 日本語 ](/install.ja) | [chinese 简体中文 ](/install.zh-cn) | [italiano](/install.it) | [français](/install.fr) | [Serbo-Croatian](http://science.webhostinggeeks.com/webpy-vodic-za-instalaciju)
+Otros idiomas : [English](/install) | [Japan 日本語 ](/install.ja) | [Chinese 简体中文 ](/install.zh-cn) | [Italiano](/install.it) | [Français](/install.fr) | [Serbo-Croatian](http://science.webhostinggeeks.com/webpy-vodic-za-instalaciju)
 
 ## Índice
 
-* <a href="#install">Instalación</a>
-* <a href="#dev">Desarrollo</a>
-* <a href="#prod">Producción</a>
-    * <a href="#nginx">Nginx</a>
-    * <a href="#lighttpd">LightTPD</a>
-        * <a href="#lighttpdfastcgi">.. con FastCGI</a>
-    * <a href="#apache">Apache</a>
-        * <a href="#apachecgi">.. con CGI</a>
-        * <a href="#apachecgihtaccess"> .. con CGI usando .htaccess</a>
-        * <a href="#apachefastcgi">.. con FastCGI</a>
-        * <a href="#apachescgi">.. con SCGI</a>
-        * <a href="#apachemodpython">.. con mod_python</a>
-        * <a href="#apachemodwsgi">.. con mod_wsgi</a>
-        * <a href="#apachemodrewrite">.. con mod_rewrite</a>
-
-<a name="install"></a>
-## Instalación
+* [Instalación](#install)
+* [Desarrollo](#dev)
+* [Producción](#prod)
+    * [Nginx](#nginx)
+    * [LightTPD](#lighttpd)
+        * [...con FastCGI](#lighttpdfastcgi)
+    * [Apache](#apache)
+        * [...con CGI](#apachecgi)
+        * [...con CGI usando .htaccess](#apachecgihtaccess)
+        * [...con FastCGI](#apachefastcgi)
+        * [...con SCGI](#apachescgi)
+        * [...con mod_python](#apachemodpython)
+        * [...con mod_wsgi](#apachemodwsgi)
+        * [...con mod_rewrite](#apachemodrewrite)
+
+<h2 id="install">Instalación</h2>
 
 Para instalar web.py para Python >= 3.5, descargue:
 
@@ -53,8 +52,7 @@ O [PIP](http://packages.python.org/distribute/)
 
     pip install web.py==0.61
 
-<a name="dev"></a>
-## Desarrollo
+<h2 id="dev">Desarrollo</h2>
 
 web.py trae incluido un servidor web. Puede aprender a escribir una aplicación siguiendo el [tutorial](http://webpy.org/tutorial). Cuando tenga su aplicación escrita, coloque su código en `code.py` e inicie el servidor así:
 
@@ -62,8 +60,7 @@ web.py trae incluido un servidor web. Puede aprender a escribir una aplicación
 
 Abra su navegador web y vaya a [http://localhost:8080/](http://localhost:8080/) para visualizar la página. Para especificar otro puerto, use `python code.py 1234`.
 
-<a name="prod"></a>
-## Producción
+<h2 id="prod">Producción</h2>
 
 El servidor web que se inicia cuando se corre un programa en web.py está bien,
 pero para sitios web populares necesitará algo un poco más serio. web.py
@@ -87,12 +84,9 @@ Y corra `chmod +x code.py` para hacerlo ejecutable.
 * [Despliegue de mod_wsgi mediante Nginx](http://webpy.org/cookbook/mod_wsgi-nginx)
 * [Despliegue de Fastcgi mediante Nginx](http://webpy.org/cookbook/fastcgi-nginx)
 
-<a name="lighttpd"></a>
-### Lighttpd
+<h3 id="lighttpd">Lighttpd</h3>
 
-<a name="lighttpdfastcgi"></a>
-
-#### .. con FastCGI
+<h4 id="lighttpdfastcgi">...con FastCGI</h4>
 
 FastCGI con lighttpd es la manera sugerida para usar web.py en producción. [reddit.com][3] maneja millones de hits con esta configuración.
 
@@ -133,20 +127,16 @@ A partir de la revisión 145, es necesario fijar una variable bin-environment en
     ))
     )
 
-<a name="apache"></a>
-### Apache
-
-<a name="apachecgi"></a>
-#### .. con CGI
+<h3 id="apache">Apache</h3>
 
+<h4 id="apachecgi">...con CGI</h4>
 
 Adicione lo siguiente en `httpd.conf` o `apache2.conf`.
 
     Alias /foo/static/ /camino/a/static
     ScriptAlias /foo/ /camino/a/code.py
 
-<a name="apachecgihtaccess"></a>
-#### .. con CGI usando .htaccess
+<h4 id="apachecgihtaccess">...con CGI usando .htaccess</h4>
 
 CGI es fácil de configurar, pero no es adecuado para sitios que requieren alto rendimiento.
 Adicione esto a su `.htaccess`:
@@ -173,9 +163,7 @@ Nota: Por la manera en que `web.py` está implementado, rompe el módulo `cgitb`
 
     web.internalerror = cgidebugerror
 
-
-<a name="apachefastcgi"></a>
-#### .. con FastCGI
+<h4 id="apachefastcgi">...con FastCGI</h4>
 
 FastCGI es sencillo de configurar y funciona tan bien como mod_python.
 
@@ -193,9 +181,7 @@ y apunte su navegador a `http://ejemplo.com/code.py/`. No olvide el slash del fi
 
 [Walter tiene consejos adicionales](http://lemurware.blogspot.com/2006/05/webpy-apache-configuration-and-you.html).
 
-
-<a name="apachescgi"></a>
-#### .. con SCGI
+<h4 id="apachescgi">...con SCGI</h4>
 https://www.mems-exchange.org/software/scgi/
 Descargue el código fuente de  `mod_scgi` aquí: http://www.mems-exchange.org/software/files/mod_scgi/
 Usuario de Apache en Windows:
@@ -211,9 +197,7 @@ reinicie apache y luego corra su code.py con el comando siguiente:
 abra su navegador, visite 127.0.0.1.
 Funciona!
 
-
-<a name="apachemodpython"></a>
-#### .. con mod_python
+<h4 id="apachemodpython">...con mod_python</h4>
 
 mod_python funciona tan bien como FastCGI, pero no es tan sencillo de configurar.
 
@@ -233,7 +217,6 @@ Para Python <2.5 haga lo siguiente:
     wget -O modpython_gateway.py http://svn.aminus.net/misc/modpython_gateway.py
     # u obtenga el fichero de esa dirección utilizando su navegador
 
-
 Renombre su `code.py` a algo así como `codep.py` y adicione:
 
     app = web.application(urls, globals())
@@ -249,8 +232,7 @@ Probablemente desee añadir una regla de reescritura (`RewriteRule`) apuntando `
 
 Asegúrese de visitar `/codep.py/` con el `/` al final. De otra forma, verá un mensaje de error como `A server error occurred. Please contact the administrator.`
 
-<a name="apachemodwsgi"></a>
-#### .. con mod_wsgi
+<h4 id="apachemodwsgi">...con mod_wsgi</h4>
 
 mod\_wsgi es un nuevo módulo de Apache que  [típicamente mejora el rendimiento respecto a mod_python](http://code.google.com/p/modwsgi/wiki/PerformanceEstimates) a la hora de alojar aplicaciones WSGI, y que además es muy fácil de configurar.</div>
 
@@ -278,8 +260,7 @@ También, puede que desee leer la sección "Directorio de trabajo de la aplicaci
 
 El sitio debe estar accesible en `http://ejemplo.com/code.py/` como es habitual.
 
-<a name="apachemodrewrite"></a>
-#### Reglas mod_rewrite para Apache
+<h4 id="apachemodrewrite">Reglas mod_rewrite para Apache</h4>
 
 Si desea que web.py sea accesible en 'http://ejemplo.com' en vez de en 'http://ejemplo.com/code.py/', adicione las reglas siguientes en su archivo .htaccess:
 
diff --git a/install.fr.md b/install.fr.md
index a410da03..82d0d682 100644
--- a/install.fr.md
+++ b/install.fr.md
@@ -5,27 +5,25 @@ title: Installation
 
 # Installation
 
-Autre langages : [español](/install/es) | [Japan](/install/ja) | [chinese](/install/zh-cn) | [italiano](/install/it) | [english](/install) 
+Autre langages: [Español](/install/es) | [Japan](/install/ja) | [Chinese](/install/zh-cn) | [Italiano](/install/it) | [English](/install) 
 
 ## Sommaire
 
-* <a href="#installation">Installation</a>
-* <a href="#dev">Développement</a>
-* <a href="#prod">Production</a>
-    * <a href="#lighttpd">LightTPD</a>
-        * <a href="#lighttpdfastcgi">...avec FastCGI</a>
-    * <a href="#apache">Apache</a>
-        * <a href="#apachecgi">...avec CGI</a>
-        * <a href="#apachecgihtaccess">.. avec CGI en utilisant .htaccess</a>
-        * <a href="#apachefastcgi">.. avec FastCGI</a>
-        * <a href="#apachescgi">.. avec SCGI</a>
-        * <a href="#apachemodpython">.. avec mod_python</a>
-        * <a href="#apachemodwsgi">.. avec mod_wsgi</a>
-        * <a href="#apachemodrewrite">.. avec mod_rewrite</a>
-
-
-<a name="installation"></a>
-## Installation
+* [Installation](#installation)
+* [Développement](#dev)
+* [Production](#prod)
+    * [LightTPD](#lighttpd)
+        * [...avec FastCGI](#lighttpdfastcgi)
+    * [Apache](#apache)
+        * [...avec CGI](#apachecgi)
+        * [...avec CGI en utilisant .htaccess](#apachecgihtaccess)
+        * [...avec FastCGI](#apachefastcgi)
+        * [...avec SCGI](#apachescgi)
+        * [...avec mod_python](#apachemodpython)
+        * [...avec mod_wsgi](#apachemodwsgi)
+        * [...avec mod_rewrite](#apachemodrewrite)
+
+<h2 id="installation">Installation</h2>
 Pour installer web.py, commencez par télécharger l'archive:
 
 [web.py-0.61.tar.gz](https://github.com/webpy/webpy/archive/0.61.tar.gz)
@@ -40,11 +38,9 @@ Note: sur certains systèmes Unix (ou Linux), il vous faudra vous connecter en t
 
 Une autre option est d'utiliser [Easy Install](http://peak.telecommunity.com/DevCenter/EasyInstall). Une fois Easy Install correctement paramétré, exécutez:
 
-
     easy_install web.py
 
-<a name="dev"></a>
-## Développement:
+<h2 id="dev">Développement:</h2>
 
 webpy intègre son propre serveur web.  Apprenez comment écrire une application en suivant le [tutoriel](./tutorial.fr).  Quand votre application est écrite, insérez votre code dans `code.py` et démarrez le serveur avec la commande:
 
@@ -52,8 +48,7 @@ webpy intègre son propre serveur web.  Apprenez comment écrire une application
 
 Ouvrez votre navigateur et allez à l'adresse [http://localhost:8080/](http://localhost:8080/) pour visualiser la page. Pour spécifier un port différent, utilisez simplement `python code.py 1234`.
 
-<a name="prod"></a>
-## Production
+<h2 id="prod">Production</h2>
 
 Le serveur web intégré à web.py est bien pratique en phase de développement, mais pour un site en production, il vaut mieux prévoir quelque chose de plus sérieux. web.py fonctionne avec n'importe quel serveur http compatible avec  [WSGI](http://www.python.org/dev/peps/pep-0333/). 
 
@@ -65,11 +60,9 @@ Pour utiliser une de ces variantes de CGI, ajoutez au début de votre `code.py`
 
 N'oubliez pas de le rendre exécutable: `chmod +x code.py`.
 
-<a name="lighttpd"></a>
-### LightTPD
+<h3 id="lighttpd">LightTPD</h3>
 
-<a name="lighttpdfastcgi"></a>
-#### .. avec FastCGI
+<h4 id="lighttpdfastcgi">...avec FastCGI</h4>
 
 FastCGI associé à lighttpd est la manière recommandée d'utiliser web.py en production. [reddit.com][3] gère des millions de visites de cette façon.
 
@@ -110,20 +103,16 @@ Depuis la revision 145, il est nécessaire de définir une variable  "bin-enviro
     ))
     )
     
-<a name="apache"></a>
-### Apache
-
-<a name="apachecgi"></a>
-#### .. avec CGI
+<h3 id="apache">Apache</h3>
 
+<h4 id="apachecgi">...avec CGI</h4>
 
 Ajoutez les lignes suivante à `httpd.conf` ou `apache2.conf`.
 
     Alias /foo/static/ /path/to/static
     ScriptAlias /foo/ /path/to/code.py
 
-<a name="apachecgihtaccess"></a>
-#### .. avec CGI en utilisant .htaccess
+<h4 id="apachecgihtaccess">...avec CGI en utilisant .htaccess</h4>
 
 CGI est facile à configurer mais ce n'est pas la meilleure des solutions pour les sites à très fort trafic.
 
@@ -152,8 +141,7 @@ Note: la manière dont `web.py` est implémenté provoque une erreur du module `
     
     web.internalerror = cgidebugerror
 
-<a name="apachefastcgi"></a>
-#### .. avec FastCGI
+<h4 id="apachefastcgi">...avec FastCGI</h4>
 
 FastCGI est facile à configurer et est aussi performant que 'mod_python'.
 
@@ -167,8 +155,7 @@ Malheureusement, et contrairement à lighttpd, Apache ne donne aucune indication
     
     web.wsgi.runwsgi = lambda func, addr=None: web.wsgi.runfcgi(func, addr)
     
-<a name="apachescgi"></a>
-#### .. avec SCGI
+<h4 id="apachescgi">...avec SCGI</h4>
 
 Téléchargez et installez le [module mod_scgi](http://www.mems-exchange.org/software/files/mod_scgi/)
 
@@ -184,8 +171,7 @@ redémarrez le serveur Apache et lancer votre 'code.py' avec la commande suivant
 lancez votre navigateur et visitez l'adresse suivante 127.0.0.1
 C'est aussi simple que ça...enfin, si ça marche du premier coup ;-) 
 
-<a name="apachemodpython"></a>
-#### .. avec mod_python
+<h4 id="apachemodpython">...avec mod_python</h4>
 
 mod_python est aussi performant que FastCGI, mais il n'est pas aussi évident à configurer. Suivez le guide:
 
@@ -205,7 +191,6 @@ Pour Python <2.5, procéder plutôt ceci:
     wget -O modpython_gateway.py http://projects.amor.org/misc/browser/modpython_gateway.py?format=raw
     # or fetch the file from that address using your browser  
 
-
 renommez votre script `code.py` en quelque chose comme `codep.py` et ajoutez le code suivant:
     
     main = web.wsgifunc(web.webpyfunc(urls, globals()))
@@ -220,8 +205,7 @@ Dans votre fichier `.htaccess`, ajoutez:
 
 Vous aurez surement aussi besoin d'ajouter une `RewriteRule` pour rediriger  `/` vers `/codep.py/`
 
-<a name="apachemodwsgi"></a>
-#### .. avec mod_wsgi
+<h4 id="apachemodwsgi">...avec mod_wsgi</h4>
 
 mod\_wsgi est un nouveau module Apache  [plus performant que mod_python](http://code.google.com/p/modwsgi/wiki/PerformanceEstimates) pour l'hébergement d'applications WSGI, et très facile à mettre en place.
 
@@ -248,8 +232,7 @@ Plus d'information dans la section "Application Working Directory"  sur [Common
 
 Encore une fois, votre application devrait-être accessible à l'URL suivante: `http://example.com/code.py/` (sans oublier le slash final!!!).
 
-<a name="apachemodrewrite"></a>
-#### mod_rewrite pour Apache
+<h4 id="apachemodrewrite">mod_rewrite pour Apache</h4>
 
 Si vous voulez que webpy soit accessible par l'URL 'http://example.com' au lieu de  'http://example.com/code.py/' ajoutez les directives suivantes dans votre fichier `.htaccess`:
 
diff --git a/install.it.md b/install.it.md
index 2a24620a..d8911148 100644
--- a/install.it.md
+++ b/install.it.md
@@ -23,7 +23,6 @@ guarda il [setup raccomandato](/recommended_setup) -in inglese-.
 
 Un'altra opzione è quella di usare[Easy Install](http://peak.telecommunity.com/DevCenter/EasyInstall). Una volta che [Easy Install](http://peak.telecommunity.com/DevCenter/EasyInstall) è stato settato correttamente, usare il seguente comando per installare automaticamente web.py:
 
-
     easy_install web.py
 
 ## Sviluppo
@@ -46,7 +45,7 @@ ed esegui `chmod +x code.py` per renderlo eseguibile.
 
 ### LightTPD
 
-#### ... con FastCGI
+#### ...con FastCGI
 
 FastCGI con lighttpd è la soluzione raccomandata di usare web.py in fase di produzione. [reddit.com][3] gestisce milioni di richieste con questa configurazione!
 
@@ -92,15 +91,14 @@ Questo comporta una variazione della tua configurazione del webserver ala voce f
     
 ### Apache
 
-#### .. con CGI
+#### ...con CGI
 
 Aggiungi le seguenti righe al tuo file `httpd.conf` o `apache2.conf`.
 
     Alias /foo/static/ /path/to/static
     ScriptAlias /foo/ /path/to/code.py
 
-
-#### .. con CGI usando il file .htaccess
+#### ...con CGI usando il file .htaccess
 
 CGI è facile da configurare, ma non è adeguato per i siti che richiedono elevate prestazioni.
 Per usare web.py con CGI aggiungi le seguenti righe al tuo `.htaccess`:
@@ -128,7 +126,7 @@ Nota: Il modo in cui `web.py` è implementato non lavora con il modulo `cgitb` p
     
     web.internalerror = cgidebugerror
 
-#### .. con FastCGI
+#### ...con FastCGI
 
 FastCGI è facile da configurare e agisce come mod_python.
 Aggiungi quanto segue al tuo `.htaccess`:
@@ -144,7 +142,8 @@ e indirizza il tuo browser a `http://example.com/code.py/`. Non dimenticare lo s
 
 [Walter ha altri consigli](http://lemurware.blogspot.com/2006/05/webpy-apache-configuration-and-you.html)[e](http://www.dofollownet.com/).
 
-#### .. con SCGI
+#### ...con SCGI
+
 https://www.mems-exchange.org/software/scgi/
 scarica i sorgenti di `mod_scgi` da qui: http://www.mems-exchange.org/software/files/mod_scgi/
 Per gli utenti apache su Windows: 
@@ -160,7 +159,7 @@ riavvia il webserver apache e poi avvia la tua applicazione code.py con il segue
 e apri il tuo browser, visita 127.0.0.1
 E' tutto a posto! 
 
-#### .. con mod_python
+#### ...con mod_python
 
 mod_python funziona come FastCGI, ma non è semplice da configurare.
 
@@ -180,7 +179,6 @@ Per python < 2.5 (precedente a 2.5) fai questo:
     wget -O modpython_gateway.py http://projects.amor.org/misc/browser/modpython_gateway.py?format=raw
     # o richiedi il file dal tuo browser 
 
-
 Rinomina il tuo `code.py` a qualcosa come `codep.py` e aggiungi:
     
     main = web.wsgifunc(web.webpyfunc(urls, globals()))
@@ -197,7 +195,7 @@ Probabilmente tu vorrai aggiungere una `RewriteRule` che punta `/` a `/codep.py/
 
 Sii sicuro di visitare `/codep.py/` con lo slash `/` extra alla fine. Altrimenti vedrai un messaggio di errore come `A server error occurred. Please contact the administrator.`
 
-#### .. con mod_wsgi
+#### ...con mod_wsgi
 
 mod\_wsgi è un nuovo modulo Apache che [tipicamente supera le peformance di mod_python](http://code.google.com/p/modwsgi/wiki/PerformanceEstimates)per hostare applicazioni WSGI, ed è veramente semplice da settare.
 
diff --git a/install.ja.md b/install.ja.md
index 88048c65..d193c58a 100644
--- a/install.ja.md
+++ b/install.ja.md
@@ -22,7 +22,6 @@ web.pyをダウンロードします。
 
 [Easy Install](http://peak.telecommunity.com/DevCenter/EasyInstall)を使えばワンステップでインストールすることが可能です。
 
-
     easy_install web.py
 
 ## 開発
@@ -53,7 +52,7 @@ CGI実行を行う場合はファイル`code.py`の先頭に以下を追記し
 
 ### LightTPD
 
-#### .. with FastCGI
+#### ...with FastCGI
 
 web.pyでは、lighttpd + FastCGI方式が推奨されています。[reddit.com][3] はこの方式で何百万ものアクセスに応答しています。
 
@@ -97,15 +96,14 @@ Since revision 145, it is necessary to set a bin-environment variable on the fas
 
 ### Apache
 
-#### .. with CGI
+#### ...with CGI
 
 `httpd.conf`もしくは`apache2.conf`に以下を追記してください。
 
     Alias /foo/static/ /path/to/static
     ScriptAlias /foo/ /path/to/code.py
 
-
-#### .. with CGI using .htaccess
+#### ...with CGI using .htaccess
 
 CGIは以下を`.htaccess`に追記するだけですので構築するのは簡単ですが、高性能なウェブサイトには向いていません。
 
@@ -132,7 +130,7 @@ Note: The way `web.py` is implemented breaks the `cgitb` module because it captu
     
     web.internalerror = cgidebugerror
 
-#### .. with FastCGI
+#### ...with FastCGI
 
 FastCGIを構築するのは簡単で、mod_pythonと同じ動作をします。
 
@@ -149,8 +147,8 @@ and point your browser to `http://example.com/code.py/`. Don't forget the traili
 
 [Walterからの追加のアドバイスはこちら](http://lemurware.blogspot.com/2006/05/webpy-apache-configuration-and-you.html).
 
+#### ...with SCGI
 
-#### .. with SCGI
 https://www.mems-exchange.org/software/scgi/
 download `mod_scgi` source here: http://www.mems-exchange.org/software/files/mod_scgi/
 windows apache user: 
@@ -165,7 +163,7 @@ apacheの再起動とcode.pyを以下のコマンドで起動してください
 
 起動後、ブラウザで 127.0.0.1を開いて確認してください。
 
-#### .. with mod_python
+#### ...with mod_python
 
 mod_pythonは、FastCGIと同様に動作しますが、構築するのは簡単ではありません。
 
@@ -185,7 +183,6 @@ Python 2.5以前のバージョンを使用している場合:
     wget -O modpython_gateway.py http://projects.amor.org/misc/browser/modpython_gateway.py?format=raw
     # or fetch the file from that address using your browser  
 
-
 `code.py`のファイル名を`codep.py`に変更してください。
     
     main = web.wsgifunc(web.webpyfunc(urls, globals()))
@@ -202,7 +199,7 @@ Python 2.5以前のバージョンを使用している場合:
 
 `/codep.py/` の末尾 `/`(スラッシュ)を忘れると、`エラー画面(Please contact the administrator.)`が表示されます。
 
-#### .. with mod_wsgi
+#### ...with mod_wsgi
 
 mod_wsgiは、特色として[mod_pythonより性能](http://code.google.com/p/modwsgi/wiki/PerformanceEstimates)が優れており、構築が非常に簡単な新しいApacheモジュールです。
 
diff --git a/install.md b/install.md
index 1bf8edc6..1584c348 100644
--- a/install.md
+++ b/install.md
@@ -5,27 +5,26 @@ title: Install guide
 
 # Install guide
 
-Other languages : [español](/install.es) | [Japan 日本語 ](/install.ja) | [chinese 简体中文 ](/install.zh-cn) | [italiano](/install.it) | [français](/install.fr) | [Serbo-Croatian](http://science.webhostinggeeks.com/webpy-vodic-za-instalaciju)
+Other languages: [Español](/install.es) | [Japan 日本語 ](/install.ja) | [Chinese 简体中文 ](/install.zh-cn) | [Italiano](/install.it) | [Français](/install.fr) | [Serbo-Croatian](http://science.webhostinggeeks.com/webpy-vodic-za-instalaciju)
 
 ## Summary
 
-* <a href="#install">Install</a>
-* <a href="#dev">Development</a>
-* <a href="#prod">Production</a>
-    * <a href="#nginx">Nginx</a>
-    * <a href="#lighttpd">LightTPD</a>
-        * <a href="#lighttpdfastcgi">.. with FastCGI</a>
-    * <a href="#apache">Apache</a>
-        * <a href="#apachecgi">.. with CGI</a>
-        * <a href="#apachecgihtaccess"> .. with CGI using .htaccess</a>
-        * <a href="#apachefastcgi">.. with FastCGI</a>
-        * <a href="#apachescgi">.. with SCGI</a>
-        * <a href="#apachemodpython">.. with mod_python</a>
-        * <a href="#apachemodwsgi">.. with mod_wsgi</a>
-        * <a href="#apachemodrewrite">.. with mod_rewrite</a>
-
-<a name="install"></a>
-## Install
+* [Install](#install)
+* [Development](#dev)
+* [Production](#prod)
+    * [Nginx](#nginx)
+    * [LightTPD](#lighttpd)
+        * [...with FastCGI](#lighttpdfastcgi)
+    * [Apache](#apache)
+        * [...with CGI](#apachecgi)
+        * [ ...with CGI using .htaccess](#apachecgihtaccess)
+        * [...with FastCGI](#apachefastcgi)
+        * [...with SCGI](#apachescgi)
+        * [...with mod_python](#apachemodpython)
+        * [...with mod_wsgi](#apachemodwsgi)
+        * [...with mod_rewrite](#apachemodrewrite)
+
+<h2 id="install">Install</h2>
 
 To install web.py for Python >= 3.5, download:
 
@@ -57,8 +56,7 @@ To install web.py for Python 2.7, please use the version `0.51`, the last suppor
 
     python2 -m pip install web.py==0.51
 
-<a name="dev"></a>
-## Development
+<h2 id="dev">Development</h2>
 
 web.py comes with a built-in webserver.  Learn how to write an application by following the [tutorial](http://webpy.org/tutorial).  When you have an application written, put your code into `code.py` and start the server like this:
 
@@ -66,8 +64,7 @@ web.py comes with a built-in webserver.  Learn how to write an application by fo
 
 Open your browser and go to [http://localhost:8080/](http://localhost:8080/) to view the page. To specify another port, use `python code.py 1234`.
 
-<a name="prod"></a>
-## Production
+<h2 id="prod">Production</h2>
 
 The web server that gets started when you run a web.py program is nice, but
 for popular sites you're going to want something a little more serious. web.py
@@ -91,12 +88,9 @@ And run `chmod +x code.py` to make it executable.
 * [mod_wsgi deployment through Nginx](http://webpy.org/cookbook/mod_wsgi-nginx)
 * [Fastcgi deployment through Nginx](http://webpy.org/cookbook/fastcgi-nginx)
 
-<a name="lighttpd"></a>
-### Lighttpd
+<h3 id="lighttpd">Lighttpd</h3>
 
-<a name="lighttpdfastcgi"></a>
-
-#### .. with FastCGI
+<h4 id="lighttpdfastcgi">...with FastCGI</h4>
 
 FastCGI with lighttpd is the recommended way of using web.py in production. [reddit.com][3] handles millions of hits this way.
 
@@ -137,20 +131,16 @@ Since revision 145, it is necessary to set a bin-environment variable on the fas
     ))
     )
 
-<a name="apache"></a>
-### Apache
-
-<a name="apachecgi"></a>
-#### .. with CGI
+<h3 id="apache">Apache</h3>
 
+<h4 id="apachecgi">...with CGI</h4>
 
 Add the following to `httpd.conf` or `apache2.conf`.
 
     Alias /foo/static/ /path/to/static
     ScriptAlias /foo/ /path/to/code.py
 
-<a name="apachecgihtaccess"></a>
-#### .. with CGI using .htaccess
+<h4 id="apachecgihtaccess">...with CGI using .htaccess</h4>
 
 CGI is easy to configure, but is not suitable for high-performance websites.
 Add this to your `.htaccess`:
@@ -177,9 +167,7 @@ Note: The way `web.py` is implemented breaks the `cgitb` module because it captu
 
     web.internalerror = cgidebugerror
 
-
-<a name="apachefastcgi"></a>
-#### .. with FastCGI
+<h4 id="apachefastcgi">...with FastCGI</h4>
 
 FastCGI is easy to configure and performs as well as mod_python.
 
@@ -197,9 +185,7 @@ and point your browser to `http://example.com/code.py/`. Don't forget the traili
 
 [Walter has some additional advice](http://lemurware.blogspot.com/2006/05/webpy-apache-configuration-and-you.html).
 
-
-<a name="apachescgi"></a>
-#### .. with SCGI
+<h4 id="apachescgi">...with SCGI</h4>
 https://www.mems-exchange.org/software/scgi/
 download `mod_scgi` source here: http://www.mems-exchange.org/software/files/mod_scgi/
 windows apache user:
@@ -215,9 +201,7 @@ restart apache and then start your code.py in the command below:
 and open you browser,visit 127.0.0.1
 It's ok!
 
-
-<a name="apachemodpython"></a>
-#### .. with mod_python
+<h4 id="apachemodpython">...with mod_python</h4>
 
 mod_python performs as well as FastCGI, but is not as straight-forward to configure.
 
@@ -237,7 +221,6 @@ For Python <2.5 do this:
     wget -O modpython_gateway.py http://svn.aminus.net/misc/modpython_gateway.py
     # or fetch the file from that address using your browser
 
-
 Rename your `code.py` to something like `codep.py` and add:
 
     app = web.application(urls, globals())
@@ -253,8 +236,7 @@ You also probably want to add a `RewriteRule` pointing `/` to `/codep.py/`
 
 Be sure to visit `/codep.py/` with the extra `/` on the end. Otherwise, you'll see an error message like `A server error occurred. Please contact the administrator.`
 
-<a name="apachemodwsgi"></a>
-#### .. with mod_wsgi
+<h4 id="apachemodwsgi">...with mod_wsgi</h4>
 
 mod\_wsgi is a new Apache module which [typically outperforms mod_python](http://code.google.com/p/modwsgi/wiki/PerformanceEstimates) for hosting WSGI applications, and is very easy to set up.</div>
 
@@ -282,10 +264,7 @@ Also, you might want to read the "Application Working Directory" section from [C
 
 It should then be accessible at `http://example.com/code.py/` as usual.
 
-
-
-<a name="apachemodrewrite"></a>
-#### mod_rewrite Rules for Apache
+<h4 id="apachemodrewrite">mod_rewrite Rules for Apache</h4>
 
 If you want web.py to be accessible at 'http://example.com' instead of 'http://example.com/code.py/' add the following rules to the `.htaccess` file:
 
diff --git a/install.zh-cn.md b/install.zh-cn.md
index 234e9a19..5964e575 100644
--- a/install.zh-cn.md
+++ b/install.zh-cn.md
@@ -7,22 +7,21 @@ title: 安装 web.py
 
 ## Summary
 
-* <a href="#install">安装</a>
-* <a href="#dev">开发</a>
-* <a href="#prod">产品</a>
-    * <a href="#lighttpd">LightTPD</a>
-        * <a href="#lighttpdfastcgi">.. 使用 FastCGI</a>
-    * <a href="#apache">Apache</a>
-        * <a href="#apachecgi">.. 使用 CGI</a>
-        * <a href="#apachecgihtaccess"> .. 使用 CGI using .htaccess</a>
-        * <a href="#apachefastcgi">.. 使用 FastCGI</a>
-        * <a href="#apachescgi">.. 使用 SCGI</a>
-        * <a href="#apachemodpython">.. 使用 mod_python</a>
-        * <a href="#apachemodwsgi">.. 使用 mod_wsgi</a>
-        * <a href="#apachemodrewrite">.. 使用 mod_rewrite</a>
-
-<a name="install"></a>
-## 安装
+* [安装](#install)
+* [开发](#dev)
+* [产品](#prod)
+    * [LightTPD](#lighttpd)
+        * [...使用 FastCGI](#lighttpdfastcgi)
+    * [Apache](#apache)
+        * [...使用 CGI](#apachecgi)
+        * [ ...使用 CGI using .htaccess](#apachecgihtaccess)
+        * [...使用 FastCGI](#apachefastcgi)
+        * [...使用 SCGI](#apachescgi)
+        * [...使用 mod_python](#apachemodpython)
+        * [...使用 mod_wsgi](#apachemodwsgi)
+        * [...使用 mod_rewrite](#apachemodrewrite)
+
+<h2 id="install">安装</h2>
 
 可以先下载源码包，再本地安装。下载：
     
@@ -54,8 +53,7 @@ title: 安装 web.py
 
     pip install web.py==0.61
 
-<a name="dev"></a>
-## 开发
+<h2 id="dev">开发</h2>
 
 web.py 内置了web服务器。可以按照 [tutorial](http://webpy.org/docs/0.3/tutorial)
 学习如何写一个 Web 应用。 写完后，将你的代码放到 `code.py` 并如下面的方法来启动服务器：
@@ -64,8 +62,7 @@ web.py 内置了web服务器。可以按照 [tutorial](http://webpy.org/docs/0.3
 
 打开你的浏览器输入 [http://localhost:8080/](http://localhost:8080/) 查看页面。 若要制定另外的端口，使用 `python code.py 1234`。
 
-<a name="prod"></a>
-## 产品
+<h2 id="prod">产品</h2>
 
 现在所运行 web.py 程序的web服务器是挺不错的， 但绝大多数网站还是需要更加专业一些的web服务器。web.py 实现了 [WSGI](http://www.python.org/dev/peps/pep-0333/) 并能在任何兼容它的服务器上运行。 WSGI 是一个web服务器与应用程序之间的通用API, 就如Java 的 Servlet 接口。 你需要安装 [flup](http://trac.saddi.com/flup) ([download here](http://www.saddi.com/software/flup/dist/)) 使web.py 支持with CGI， FastCGI 或 SCGI， flup提供了这些API的WSGI接口。
 
@@ -75,11 +72,9 @@ web.py 内置了web服务器。可以按照 [tutorial](http://webpy.org/docs/0.3
 
 并运行 `chmod +x code.py` 添加可执行属性。
 
-<a name="lighttpd"></a>
-### LightTPD
+<h3 id="lighttpd">LightTPD</h3>
 
-<a name="lighttpdfastcgi"></a>
-#### .. 使用 FastCGI
+<h4 id="lighttpdfastcgi">...使用 FastCGI</h4>
 
 在产品中通过FastCGI结合lighttpd是web.py使用的一种推荐方法。 [reddit.com][3] 通过该方法来处理百万次的点击。
 
@@ -121,21 +116,16 @@ lighttpd config设置参考如下：
     )
     
 
-<a name="apache"></a>
-### Apache
-
-<a name="apachecgi"></a>
-#### .. 使用 CGI
+<h3 id="apache">Apache</h3>
 
+<h4 id="apachecgi">...使用 CGI</h4>
 
 添加以下到 `httpd.conf` 或 `apache2.conf`。
 
     Alias /foo/static/ /path/to/static
     ScriptAlias /foo/ /path/to/code.py
 
-
-<a name="apachecgihtaccess"></a>
-#### .. 使用 CGI .htaccess
+<h4 id="apachecgihtaccess">...使用 CGI .htaccess</h4>
 
 CGI很容易配置， 但不适合高性能网站。
 添加以下到你的 `.htaccess`：
@@ -163,8 +153,7 @@ CGI很容易配置， 但不适合高性能网站。
     
     web.internalerror = cgidebugerror
 
-<a name="apachefastcgi"></a>
-#### .. 使用 FastCGI
+<h4 id="apachefastcgi">...使用 FastCGI</h4>
 
 FastCGI很容易配置，运行方式如同mod_python。
 
@@ -181,8 +170,7 @@ FastCGI很容易配置，运行方式如同mod_python。
 
 [Walter 还有一些额外建议](http://lemurware.blogspot.com/2006/05/webpy-apache-configuration-and-you.html).
 
-<a name="apachescgi"></a>
-#### .. 使用 SCGI
+<h4 id="apachescgi">...使用 SCGI</h4>
 https://www.mems-exchange.org/software/scgi/
 从 http://www.mems-exchange.org/software/files/mod_scgi/ 下载 `mod_scgi` 代码
 windows apache 用户： 
@@ -198,8 +186,7 @@ windows apache 用户：
 打开你的浏览器，访问127.0.0.1
 It's ok! 
 
-<a name="apachemodpython"></a>
-#### .. 使用 mod_python
+<h4 id="apachemodpython">...使用 mod_python</h4>
 
 mod_python 运行方式如同FastCGI， 但不是那么方便配置。
 
@@ -219,7 +206,6 @@ mod_python 运行方式如同FastCGI， 但不是那么方便配置。
     wget -O modpython_gateway.py http://projects.amor.org/misc/browser/modpython_gateway.py?format=raw
     # or fetch the file from that address using your browser  
 
-
 重命名 `code.py` 为 `codep.py` 或别的名字， 添加：
     
     app = web.application(urls, globals())
@@ -237,8 +223,7 @@ mod_python 运行方式如同FastCGI， 但不是那么方便配置。
 
 确保访问 `/codep.py/` 的时候有添加最后的 `/`。  否则，你将会看到一条错误信息，比如 `A server error occurred. Please contact the administrator.`
 
-<a name="apachemodwsgi"></a>
-#### .. 使用 mod_wsgi
+<h4 id="apachemodwsgi">...使用 mod_wsgi</h4>
 
 mod\_wsgi 是一个新的Apache模块 [通常优于mod_python](http://code.google.com/p/modwsgi/wiki/PerformanceEstimates) 用于架设WSGI应用，它非常容易配置。
 
@@ -266,8 +251,7 @@ mod\_wsgi 提供 [许多可行方法](http://code.google.com/p/modwsgi/wiki/Conf
 
 最终应该可以访问 `http://example.com/code.py/`。
 
-<a name="apachemodrewrite"></a>
-#### mod_rewrite 法则，Apache
+<h4 id="apachemodrewrite">mod_rewrite 法则，Apache</h4>
 
 如果希望 web.py 能够通过 'http://example.com' 访问，代替使用 'http://example.com/code.py/'， 添加以下法则到 `.htaccess` 文件：
 
diff --git a/philosophy.md b/philosophy.md
index 77324cb2..637985c8 100644
--- a/philosophy.md
+++ b/philosophy.md
@@ -7,7 +7,7 @@ title: Philosophy
 
 The web.py slogan is: "Think about the ideal way to write a web app. Write the code to make it happen."
 
-This is literally how I developed web.py. I wrote a web application in Python just imagining how I wanted the API to be. It started with <code>import web</code>, of course, and then had a place to define URLs, simple functions for GET and POST, a thing to deal with input variables and so on. Once the code looked right to me, I did whatever it took to make it execute _without changing the application code_ -- the result was web.py.
+This is literally how I developed web.py. I wrote a web application in Python just imagining how I wanted the API to be. It started with `import web`, of course, and then had a place to define URLs, simple functions for GET and POST, a thing to deal with input variables and so on. Once the code looked right to me, I did whatever it took to make it execute _without changing the application code_ -- the result was web.py.
 
 In response to someone complaining about web.py having "yet another template language", [I wrote a bit more about my philosophy](http://groups.google.com/group/webpy/msg/f266701d97e7ceb1):
 
diff --git a/recommended_setup.fr.md b/recommended_setup.fr.md
index 80144e1b..5cc927da 100644
--- a/recommended_setup.fr.md
+++ b/recommended_setup.fr.md
@@ -5,54 +5,47 @@ title: Configuration recommandée
 
 # Configuration recommandée
 
-Autre langages : [english](/recommended_setup) | ...
+Autre langages: [English](/recommended_setup) | ...
 
 ### Sommaire
 
-* <a href="#webserver">Serveurs web</a>
-* <a href="#database">Bases de données</a>
-* <a href="#pool">Pool de connexions</a>
-* <a href="#template">Modèles, gabarits</a>
-* <a href="#userinput">Entrées utilisateurs</a>
-
+* [Serveurs web](#webserver)
+* [Bases de données](#database)
+* [Pool de connexions](#pool)
+* [Modèles, gabarits](#template)
+* [Entrées utilisateurs](#userinput)
 
 Web.py recommande les logiciels suivants pour les serveurs de production:
 
-<a name="webserver"></a>
-##Serveurs web:
+<h2 id="webserver">Serveurs web:</h2>
 
 Webpy dispose d'un serveur web interne, mais il devrait être utilisé pour le développement seulement. Pour le déploiement, un serveur plus robuste est recommandé, comme l'un de ceux-ci:
 
-*  [lighttpd](http://www.lighttpd.net/download/) [BSD] [(doc)](http://trac.lighttpd.net/trac/wiki/#ReferenceDocumentation) via [flup's fastcgi](http://trac.saddi.com/flup) [BSD] ('easy_install flup')
-*  [Apache](http://www.apache.org/) [Apache] via [(mod_wsgi)](http://code.google.com/p/modwsgi/) [Apache]
+* [lighttpd](http://www.lighttpd.net/download/) [BSD] [(doc)](http://trac.lighttpd.net/trac/wiki/#ReferenceDocumentation) via [flup's fastcgi](http://trac.saddi.com/flup) [BSD] ('easy_install flup')
+* [Apache](http://www.apache.org/) [Apache] via [(mod_wsgi)](http://code.google.com/p/modwsgi/) [Apache]
 
-<a name="database"></a>
-##Bases de données:
+<h2 id="database">Bases de données:</h2>
 
 Webpy ne nécessite pas de base de données pour fonctionner. Il supporte néanmoins les bases suivantes:
 
+* [postgresql](http://www.postgresql.org/download/) [BSD] [(doc)](http://www.postgresql.org/docs/) avec [psycopg2](http://initd.org/pub/software/psycopg/) [BSD] [(doc)](http://www.initd.org/tracker/psycopg/wiki/PsycopgTwo) comme client python. ('easy_install psycopg2')
+* [mysql](http://dev.mysql.com/downloads/mysql/5.0.html) [GPL] [(doc)](http://www.mysql.org/doc/) avec [MySQLdb](http://sourceforge.net/project/showfiles.php?group_id=22307) [CNRI] [(doc)](http://mysql-python.sourceforge.net/MySQLdb.html) comme client python ('easy_install MySQL-python')
+* [sqlite](http://www.sqlite.org/) [Public domain] [(doc)](http://www.sqlite.org/docs.html) avec [pysqlite](http://code.google.com/p/pysqlite/) comme client python ('easy_install pysqlite').
 
-*  [postgresql](http://www.postgresql.org/download/) [BSD] [(doc)](http://www.postgresql.org/docs/) avec [psycopg2](http://initd.org/pub/software/psycopg/) [BSD] [(doc)](http://www.initd.org/tracker/psycopg/wiki/PsycopgTwo) comme client python. ('easy_install psycopg2')
-*  [mysql](http://dev.mysql.com/downloads/mysql/5.0.html) [GPL] [(doc)](http://www.mysql.org/doc/) avec [MySQLdb](http://sourceforge.net/project/showfiles.php?group_id=22307) [CNRI] [(doc)](http://mysql-python.sourceforge.net/MySQLdb.html) comme client python ('easy_install MySQL-python')
-*  [sqlite](http://www.sqlite.org/) [Public domain] [(doc)](http://www.sqlite.org/docs.html) avec [pysqlite](http://code.google.com/p/pysqlite/) comme client python ('easy_install pysqlite').
-
-<a name="pool"></a>
-##Pool de connexions:
+<h2 id="pool">Pool de connexions:</h2>
 
 Pour les sites à haut traffic, le pool de connexion autorise Webpy à conserver de multiples connexions aux bases de données ouvertes, afin d'accélérer l'accès aux bases. Cette option est facultative, mais disponible comme échelon tactique.
 
-*  [DBUtils](http://www.w4py.org/downloads/DBUtils/) [CNRI] [(doc)](http://www.webwareforpython.org/DBUtils/Docs/UsersGuide.html) ('easy_install DBUtils')
+* [DBUtils](http://www.w4py.org/downloads/DBUtils/) [CNRI] [(doc)](http://www.webwareforpython.org/DBUtils/Docs/UsersGuide.html) ('easy_install DBUtils')
 
-<a name="template"></a>
-##Modèles, gabarits:
+<h2 id="template">Modèles, gabarits:</h2>
 
 Webpy possède son propre système de gabarit qui permet aux utilisateurs d'autoriser l'écriture de gabarits aux utilisateurs moins épprouvés, et d'utiliser une syntaxe proche de celle du python dans les templates.
 
-*  template.py [built-in] [(doc)](/docs/0.3/templetor.fr)
+* template.py [built-in] [(doc)](/docs/0.3/templetor.fr)
 
-<a name="userinput"></a>
-##Entrées utilisateurs:
+<h2 id="userinput">Entrées utilisateurs:</h2>
 
 Markdown permet aux utilisateurs de Webpy d'écrire du texte qui est convertit en HTML dans la page. Ce n'est pas indispensable, mais c'est la meilleure façon de générer du HTML à partir des entrées utilisateur.
 
-*  [python-markdown](http://sourceforge.net/project/showfiles.php?group_id=153041) [BSD] [(doc)](http://www.freewisdom.org/projects/python-markdown/)
\ No newline at end of file
+* [python-markdown](http://sourceforge.net/project/showfiles.php?group_id=153041) [BSD] [(doc)](http://www.freewisdom.org/projects/python-markdown/)
\ No newline at end of file
diff --git a/recommended_setup.ja.md b/recommended_setup.ja.md
index 1e032f0f..eb096a19 100644
--- a/recommended_setup.ja.md
+++ b/recommended_setup.ja.md
@@ -8,21 +8,21 @@ title: 推奨環境
 web.pyは以下のソフトウェアを推奨しています。:
 
 ##ウェブサーバー:
-*  [lighttpd](http://www.lighttpd.net/download/) [BSD] [(doc)](http://trac.lighttpd.net/trac/wiki/#ReferenceDocumentation)
+* [lighttpd](http://www.lighttpd.net/download/) [BSD] [(doc)](http://trac.lighttpd.net/trac/wiki/#ReferenceDocumentation)
 
 ##データベース:
-*  [postgresql](http://www.postgresql.org/download/) [BSD] [(doc)](http://www.postgresql.org/docs/) with [psycopg2](http://initd.org/pub/software/psycopg/) [BSD] [(doc)](http://www.initd.org/tracker/psycopg/wiki/PsycopgTwo) as the python client. (`easy_install psycopg2`)
+* [postgresql](http://www.postgresql.org/download/) [BSD] [(doc)](http://www.postgresql.org/docs/) with [psycopg2](http://initd.org/pub/software/psycopg/) [BSD] [(doc)](http://www.initd.org/tracker/psycopg/wiki/PsycopgTwo) as the python client. (`easy_install psycopg2`)
   
-*  [mysql](http://dev.mysql.com/downloads/mysql/5.0.html) [GPL] [(doc)](http://www.mysql.org/doc/) with [MySQLdb](http://sourceforge.net/project/showfiles.php?group_id=22307) [CNRI] [(doc)](http://sourceforge.net/docman/?group_id=22307) as the python client (`easy_install MySQL-python`)
+* [mysql](http://dev.mysql.com/downloads/mysql/5.0.html) [GPL] [(doc)](http://www.mysql.org/doc/) with [MySQLdb](http://sourceforge.net/project/showfiles.php?group_id=22307) [CNRI] [(doc)](http://sourceforge.net/docman/?group_id=22307) as the python client (`easy_install MySQL-python`)
 
 ##CGI/FastCGI/SCGI:
-*  [flup](http://trac.saddi.com/flup) [BSD] (`easy_install flup`)
+* [flup](http://trac.saddi.com/flup) [BSD] (`easy_install flup`)
 
 ##コネクションプール:
-*  [DBUtils](http://www.w4py.org/downloads/DBUtils/) [CNRI] [(doc)](http://www.webwareforpython.org/DBUtils/Docs/UsersGuide.html) (`easy_install DBUtils`)
+* [DBUtils](http://www.w4py.org/downloads/DBUtils/) [CNRI] [(doc)](http://www.webwareforpython.org/DBUtils/Docs/UsersGuide.html) (`easy_install DBUtils`)
 
 ##テンプレートエンジン:
-*  template.py [built-in] [(doc)](templetor)
-*  [Cheetah](http://dl.sourceforge.net/cheetahtemplate/Cheetah-1.0.tar.gz) 1.0 [BSD] [(doc)](http://www.cheetahtemplate.org/learn.html)
+* template.py [built-in] [(doc)](templetor)
+* [Cheetah](http://dl.sourceforge.net/cheetahtemplate/Cheetah-1.0.tar.gz) 1.0 [BSD] [(doc)](http://www.cheetahtemplate.org/learn.html)
 ##User Input:
-*  [python-markdown](http://sourceforge.net/project/showfiles.php?group_id=153041) [BSD] [(doc)](http://www.freewisdom.org/projects/python-markdown/)
\ No newline at end of file
+* [python-markdown](http://sourceforge.net/project/showfiles.php?group_id=153041) [BSD] [(doc)](http://www.freewisdom.org/projects/python-markdown/)
\ No newline at end of file
diff --git a/recommended_setup.md b/recommended_setup.md
index a775a8de..af2f6baa 100644
--- a/recommended_setup.md
+++ b/recommended_setup.md
@@ -5,14 +5,14 @@ title: Recommended Setup
 
 # Recommended Setup
 
-Other languages : [français](/recommended_setup/fr) | ...
+Other languages: [Français](/recommended_setup/fr) | ...
 
 ### Summary
 
-* <a href="#web-servers">Web Server</a>
-* <a href="#databases">Databases</a>
-* <a href="#connection-pooling">Connection Pooling</a>
-* <a href="#templates">Templates</a>
+* [Web Server](#web-servers)
+* [Databases](#databases)
+* [Connection Pooling](#connection-pooling)
+* [Templates](#templates)
 
 web.py recommends the following software for production servers:
 
@@ -27,20 +27,20 @@ Webpy has an internal web server, but it should be used for development only. Fo
 
 Webpy does not require a database to run. It does, however, support using the following databases:
 
-*  [postgresql](http://www.postgresql.org/download/) [BSD] [(doc)](http://www.postgresql.org/docs/) with [psycopg2](http://initd.org/pub/software/psycopg/) [BSD] [(doc)](http://www.initd.org/tracker/psycopg/wiki/PsycopgTwo) as the python client. (`easy_install psycopg2`)
-*  [mysql](http://dev.mysql.com/downloads/mysql/5.0.html) [GPL] [(doc)](http://www.mysql.org/doc/) with [MySQLdb](http://sourceforge.net/project/showfiles.php?group_id=22307) [CNRI] [(doc)](http://mysql-python.sourceforge.net/MySQLdb.html) as the python client (`easy_install MySQL-python`)
-*  [sqlite](http://www.sqlite.org/) [Public domain] [(doc)](http://www.sqlite.org/docs.html) with [pysqlite](http://code.google.com/p/pysqlite/) as python client (`easy_install pysqlite`).
+* [postgresql](http://www.postgresql.org/download/) [BSD] [(doc)](http://www.postgresql.org/docs/) with [psycopg2](http://initd.org/pub/software/psycopg/) [BSD] [(doc)](http://www.initd.org/tracker/psycopg/wiki/PsycopgTwo) as the python client. (`easy_install psycopg2`)
+* [mysql](http://dev.mysql.com/downloads/mysql/5.0.html) [GPL] [(doc)](http://www.mysql.org/doc/) with [MySQLdb](http://sourceforge.net/project/showfiles.php?group_id=22307) [CNRI] [(doc)](http://mysql-python.sourceforge.net/MySQLdb.html) as the python client (`easy_install MySQL-python`)
+* [sqlite](http://www.sqlite.org/) [Public domain] [(doc)](http://www.sqlite.org/docs.html) with [pysqlite](http://code.google.com/p/pysqlite/) as python client (`easy_install pysqlite`).
 
 ## Connection Pooling
 
 For high traffic sites, connection pooling allows Webpy to keep multiple database connections open, typically allowing faster access from the database. This is optional, but available as a scaling tactic.
 
-*  [DBUtils](http://www.w4py.org/downloads/DBUtils/) [CNRI] [(doc)](http://www.webwareforpython.org/DBUtils/Docs/UsersGuide.html) (`easy_install DBUtils`)
+* [DBUtils](http://www.w4py.org/downloads/DBUtils/) [CNRI] [(doc)](http://www.webwareforpython.org/DBUtils/Docs/UsersGuide.html) (`easy_install DBUtils`)
 
 ## Templates
 
 Webpy has its own template system which allows users to let untrusted users write templates using this, and use python-like syntax within templates.
 
-*  template.py [built-in] [(doc)](/docs/0.3/templetor)
+* template.py [built-in] [(doc)](/docs/0.3/templetor)
 
 [Jinja2](https://jinja.palletsprojects.com/) is more popolar and feature rich, we strongly recommend Jinja2.
diff --git a/templetor.md b/templetor.md
index 81cb1347..e9cf5e72 100644
--- a/templetor.md
+++ b/templetor.md
@@ -185,6 +185,7 @@ Here's an example:
 The first line imports templetor. The second says that our templates are in the directory `templates/`. The third give all our templates access to the `len` function. The fourth grabs the template `message.html`, passes it the argument `'Hello, world!'`, passes the result of rendering it to [mcitp](http://www.buyitcert.com/mcitp.html) the template `base.html` and prints the result. (If your templates don't end in `.html` or `.xml`, templetor will still find them, but it won't do its automatic HTML-encoding.)
 
 ## Turning Off Filter
+
 By default `template.render` will use `web.websafe` filter to do HTML-encoding. To turn it off, put a : after the $ as in:
 
     $:form.render()
@@ -196,6 +197,7 @@ Output from form.render() will be displayed as is.
 Output from variable in template will be displayed as is.
 
 ## Including / nesting templates
+
 If you want to nest one template within another, you nest the `render()` calls, and then include the variable (unfiltered) in the page.
 In your handler: