diff --git a/README.md b/README.md
index b04fbec..a60f1b7 100644
--- a/README.md
+++ b/README.md
@@ -25,132 +25,147 @@ Getting started
 
 Let's start with connecting to Redis using TCP:
 
-    password := ""  // no password set
-    db := int64(-1) // use default DB
-    client := redis.NewTCPClient("localhost:6379", password, db)
-    defer client.Close()
-
-    ping := client.Ping()
-    fmt.Println(ping.Err(), ping.Val())
-    // Output: <nil> PONG
+```go
+password := ""  // no password set
+db := int64(-1) // use default DB
+client := redis.NewTCPClient("localhost:6379", password, db)
+defer client.Close()
 
+ping := client.Ping()
+fmt.Println(ping.Err(), ping.Val())
+// Output: <nil> PONG
+```
 or using Unix socket:
 
-    client := redis.NewUnixClient("/tmp/redis.sock", "", -1)
-    defer client.Close()
-
-    ping := client.Ping()
-    fmt.Println(ping.Err(), ping.Val())
-    // Output: <nil> PONG
+```go
+client := redis.NewUnixClient("/tmp/redis.sock", "", -1)
+defer client.Close()
 
+ping := client.Ping()
+fmt.Println(ping.Err(), ping.Val())
+// Output: <nil> PONG
+```
 Then we can start sending commands:
 
-    set := client.Set("foo", "bar")
-    fmt.Println(set.Err(), set.Val())
+```go
+set := client.Set("foo", "bar")
+fmt.Println(set.Err(), set.Val())
 
-    get := client.Get("foo")
-    fmt.Println(get.Err(), get.Val())
+get := client.Get("foo")
+fmt.Println(get.Err(), get.Val())
 
-    // Output: <nil> OK
-    // <nil> bar
+// Output: <nil> OK
+// <nil> bar
+```
 
 We can also pipeline two commands together:
 
-    var set *redis.StatusReq
-    var get *redis.StringReq
-    reqs, err := client.Pipelined(func(c *redis.PipelineClient) {
-        set = c.Set("key1", "hello1")
-        get = c.Get("key2")
-    })
-    fmt.Println(err, reqs)
-    fmt.Println(set)
-    fmt.Println(get)
-    // Output: <nil> [SET key1 hello1: OK GET key2: (nil)]
-    // SET key1 hello1: OK
-    // GET key2: (nil)
-
+```go
+var set *redis.StatusReq
+var get *redis.StringReq
+reqs, err := client.Pipelined(func(c *redis.PipelineClient) {
+    set = c.Set("key1", "hello1")
+    get = c.Get("key2")
+})
+fmt.Println(err, reqs)
+fmt.Println(set)
+fmt.Println(get)
+// Output: <nil> [SET key1 hello1: OK GET key2: (nil)]
+// SET key1 hello1: OK
+// GET key2: (nil)
+```
 or:
 
-    var set *redis.StatusReq
-    var get *redis.StringReq
-    reqs, err := client.Pipelined(func(c *redis.PipelineClient) {
-        set = c.Set("key1", "hello1")
-        get = c.Get("key2")
-    })
-    fmt.Println(err, reqs)
-    fmt.Println(set)
-    fmt.Println(get)
-    // Output: <nil> [SET key1 hello1 GET key2]
-    // SET key1 hello1
-    // GET key2
+```go
+var set *redis.StatusReq
+var get *redis.StringReq
+reqs, err := client.Pipelined(func(c *redis.PipelineClient) {
+    set = c.Set("key1", "hello1")
+    get = c.Get("key2")
+})
+fmt.Println(err, reqs)
+fmt.Println(set)
+fmt.Println(get)
+// Output: <nil> [SET key1 hello1 GET key2]
+// SET key1 hello1
+// GET key2
+```
 
 We can also send several commands in transaction:
 
-    func transaction(multi *redis.MultiClient) ([]redis.Req, error) {
-        get := multi.Get("key")
-        if err := get.Err(); err != nil && err != redis.Nil {
-            return nil, err
-        }
-
-        val, _ := strconv.ParseInt(get.Val(), 10, 64)
-
-        reqs, err := multi.Exec(func() {
-            multi.Set("key", strconv.FormatInt(val+1, 10))
-        })
-        // Transaction failed. Repeat.
-        if err == redis.Nil {
-            return transaction(multi)
-        }
-        return reqs, err
+```go
+func transaction(multi *redis.MultiClient) ([]redis.Req, error) {
+    get := multi.Get("key")
+    if err := get.Err(); err != nil && err != redis.Nil {
+        return nil, err
     }
 
-    multi, err := client.MultiClient()
-    _ = err
-    defer multi.Close()
+    val, _ := strconv.ParseInt(get.Val(), 10, 64)
 
-    watch := multi.Watch("key")
-    _ = watch.Err()
+    reqs, err := multi.Exec(func() {
+        multi.Set("key", strconv.FormatInt(val+1, 10))
+    })
+    // Transaction failed. Repeat.
+    if err == redis.Nil {
+        return transaction(multi)
+    }
+    return reqs, err
+}
 
-    reqs, err := transaction(multi)
-    fmt.Println(err, reqs)
+multi, err := client.MultiClient()
+_ = err
+defer multi.Close()
 
-    // Output: <nil> [SET key 1: OK]
+watch := multi.Watch("key")
+_ = watch.Err()
+
+reqs, err := transaction(multi)
+fmt.Println(err, reqs)
+
+// Output: <nil> [SET key 1: OK]
+```
 
 To subscribe to the channel:
 
-    pubsub, err := client.PubSubClient()
-    defer pubsub.Close()
+```go
+pubsub, err := client.PubSubClient()
+defer pubsub.Close()
 
-    ch, err := pubsub.Subscribe("mychannel")
-    _ = err
+ch, err := pubsub.Subscribe("mychannel")
+_ = err
 
-    subscribeMsg := <-ch
-    fmt.Println(subscribeMsg.Err, subscribeMsg.Name)
+subscribeMsg := <-ch
+fmt.Println(subscribeMsg.Err, subscribeMsg.Name)
 
-    pub := client.Publish("mychannel", "hello")
-    _ = pub.Err()
+pub := client.Publish("mychannel", "hello")
+_ = pub.Err()
 
-    msg := <-ch
-    fmt.Println(msg.Err, msg.Message)
+msg := <-ch
+fmt.Println(msg.Err, msg.Message)
 
-    // Output: <nil> subscribe
-    // <nil> hello
+// Output: <nil> subscribe
+// <nil> hello
+```
 
 You can also write custom commands:
 
-    func Get(client *redis.Client, key string) *redis.StringReq {
-        req := redis.NewStringReq("GET", key)
-        client.Process(req)
-        return req
-    }
+```go
+func Get(client *redis.Client, key string) *redis.StringReq {
+    req := redis.NewStringReq("GET", key)
+    client.Process(req)
+    return req
+}
 
-    get := Get(client, "key_does_not_exist")
-    fmt.Println(get.Err(), get.Val())
-    // Output: (nil)
+get := Get(client, "key_does_not_exist")
+fmt.Println(get.Err(), get.Val())
+// Output: (nil)
+```
 
 Client uses connection pool to send commands. You can change maximum number of connections with:
 
-    client.ConnPool.(*redis.MultiConnPool).MaxCap = 1
+```go
+client.ConnPool.(*redis.MultiConnPool).MaxCap = 1
+```
 
 Look and feel
 -------------