diff --git a/README.md b/README.md
index a4bc4e76..9a97ec54 100644
--- a/README.md
+++ b/README.md
@@ -657,6 +657,7 @@ import (
 	"gopkg.in/go-playground/validator.v8"
 )
 
+// Booking contains binded and validated data.
 type Booking struct {
 	CheckIn  time.Time `form:"check_in" binding:"required,bookabledate" time_format:"2006-01-02"`
 	CheckOut time.Time `form:"check_out" binding:"required,gtfield=CheckIn" time_format:"2006-01-02"`
diff --git a/examples/basic/main.go b/examples/basic/main.go
index 48fa7bba..1c9e0ac4 100644
--- a/examples/basic/main.go
+++ b/examples/basic/main.go
@@ -6,7 +6,7 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-var DB = make(map[string]string)
+var db = make(map[string]string)
 
 func setupRouter() *gin.Engine {
 	// Disable Console Color
@@ -21,7 +21,7 @@ func setupRouter() *gin.Engine {
 	// Get user value
 	r.GET("/user/:name", func(c *gin.Context) {
 		user := c.Params.ByName("name")
-		value, ok := DB[user]
+		value, ok := db[user]
 		if ok {
 			c.JSON(http.StatusOK, gin.H{"user": user, "value": value})
 		} else {
@@ -50,7 +50,7 @@ func setupRouter() *gin.Engine {
 		}
 
 		if c.Bind(&json) == nil {
-			DB[user] = json.Value
+			db[user] = json.Value
 			c.JSON(http.StatusOK, gin.H{"status": "ok"})
 		}
 	})
diff --git a/examples/custom-validation/server.go b/examples/custom-validation/server.go
index dea0c302..9238200b 100644
--- a/examples/custom-validation/server.go
+++ b/examples/custom-validation/server.go
@@ -10,6 +10,7 @@ import (
 	"gopkg.in/go-playground/validator.v8"
 )
 
+// Booking contains binded and validated data.
 type Booking struct {
 	CheckIn  time.Time `form:"check_in" binding:"required,bookabledate" time_format:"2006-01-02"`
 	CheckOut time.Time `form:"check_out" binding:"required,gtfield=CheckIn" time_format:"2006-01-02"`
diff --git a/examples/realtime-advanced/main.go b/examples/realtime-advanced/main.go
index 1f3c8585..a16c58b0 100644
--- a/examples/realtime-advanced/main.go
+++ b/examples/realtime-advanced/main.go
@@ -13,16 +13,19 @@ func main() {
 	StartGin()
 }
 
+// ConfigRuntime sets the number of operating system threads.
 func ConfigRuntime() {
 	nuCPU := runtime.NumCPU()
 	runtime.GOMAXPROCS(nuCPU)
 	fmt.Printf("Running with %d CPUs\n", nuCPU)
 }
 
+// StartWrokers start starsWorker by goroutine.
 func StartWorkers() {
 	go statsWorker()
 }
 
+// StartGin starts gin web server with setting router.
 func StartGin() {
 	gin.SetMode(gin.ReleaseMode)
 
diff --git a/examples/realtime-advanced/stats.go b/examples/realtime-advanced/stats.go
index 4afedcb5..a6488035 100644
--- a/examples/realtime-advanced/stats.go
+++ b/examples/realtime-advanced/stats.go
@@ -50,6 +50,7 @@ func connectedUsers() uint64 {
 	return uint64(connected)
 }
 
+// Stats returns savedStats data.
 func Stats() map[string]uint64 {
 	mutexStats.RLock()
 	defer mutexStats.RUnlock()
diff --git a/ginS/gins.go b/ginS/gins.go
index a7686f23..04cf131c 100644
--- a/ginS/gins.go
+++ b/ginS/gins.go
@@ -22,14 +22,17 @@ func engine() *gin.Engine {
 	return internalEngine
 }
 
+// LoadHTMLGlob is a wrapper for Engine.LoadHTMLGlob.
 func LoadHTMLGlob(pattern string) {
 	engine().LoadHTMLGlob(pattern)
 }
 
+// LoadHTMLFiles is a wrapper for Engine.LoadHTMLFiles.
 func LoadHTMLFiles(files ...string) {
 	engine().LoadHTMLFiles(files...)
 }
 
+// SetHTMLTemplate is a wrapper for Engine.SetHTMLTemplate.
 func SetHTMLTemplate(templ *template.Template) {
 	engine().SetHTMLTemplate(templ)
 }
@@ -39,7 +42,7 @@ func NoRoute(handlers ...gin.HandlerFunc) {
 	engine().NoRoute(handlers...)
 }
 
-// NoMethod sets the handlers called when... TODO
+// NoMethod is a wrapper for Engine.NoMethod.
 func NoMethod(handlers ...gin.HandlerFunc) {
 	engine().NoMethod(handlers...)
 }
@@ -50,6 +53,7 @@ func Group(relativePath string, handlers ...gin.HandlerFunc) *gin.RouterGroup {
 	return engine().Group(relativePath, handlers...)
 }
 
+// Handle is a wrapper for Engine.Handle.
 func Handle(httpMethod, relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
 	return engine().Handle(httpMethod, relativePath, handlers...)
 }
@@ -89,10 +93,12 @@ func HEAD(relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
 	return engine().HEAD(relativePath, handlers...)
 }
 
+// Any is a wrapper for Engine.Any.
 func Any(relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
 	return engine().Any(relativePath, handlers...)
 }
 
+// StaticFile is a wrapper for Engine.StaticFile.
 func StaticFile(relativePath, filepath string) gin.IRoutes {
 	return engine().StaticFile(relativePath, filepath)
 }
@@ -107,6 +113,7 @@ func Static(relativePath, root string) gin.IRoutes {
 	return engine().Static(relativePath, root)
 }
 
+// StaticFS is a wrapper for Engine.StaticFS.
 func StaticFS(relativePath string, fs http.FileSystem) gin.IRoutes {
 	return engine().StaticFS(relativePath, fs)
 }
diff --git a/internal/json/json.go b/internal/json/json.go
index 4f643c56..419d35f2 100644
--- a/internal/json/json.go
+++ b/internal/json/json.go
@@ -9,8 +9,12 @@ package json
 import "encoding/json"
 
 var (
-	Marshal       = json.Marshal
+	// Marshal is exported by gin/json package.
+	Marshal = json.Marshal
+	// MarshalIndent is exported by gin/json package.
 	MarshalIndent = json.MarshalIndent
-	NewDecoder    = json.NewDecoder
-	NewEncoder    = json.NewEncoder
+	// NewDecoder is exported by gin/json package.
+	NewDecoder = json.NewDecoder
+	// NewEncoder is exported by gin/json package.
+	NewEncoder = json.NewEncoder
 )
diff --git a/internal/json/jsoniter.go b/internal/json/jsoniter.go
index f1ed5bea..2021c53c 100644
--- a/internal/json/jsoniter.go
+++ b/internal/json/jsoniter.go
@@ -9,9 +9,13 @@ package json
 import "github.com/json-iterator/go"
 
 var (
-	json          = jsoniter.ConfigCompatibleWithStandardLibrary
-	Marshal       = json.Marshal
+	json = jsoniter.ConfigCompatibleWithStandardLibrary
+	// Marshal is exported by gin/json package.
+	Marshal = json.Marshal
+	// MarshalIndent is exported by gin/json package.
 	MarshalIndent = json.MarshalIndent
-	NewDecoder    = json.NewDecoder
-	NewEncoder    = json.NewEncoder
+	// NewDecoder is exported by gin/json package.
+	NewDecoder = json.NewDecoder
+	// NewEncoder is exported by gin/json package.
+	NewEncoder = json.NewEncoder
 )
diff --git a/render/data.go b/render/data.go
index 33194913..6ba657ba 100644
--- a/render/data.go
+++ b/render/data.go
@@ -6,6 +6,7 @@ package render
 
 import "net/http"
 
+// Data contains ContentType and bytes data.
 type Data struct {
 	ContentType string
 	Data        []byte
@@ -18,6 +19,7 @@ func (r Data) Render(w http.ResponseWriter) (err error) {
 	return
 }
 
+// WriteContentType (Data) writes custom ContentType.
 func (r Data) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, []string{r.ContentType})
 }
diff --git a/render/html.go b/render/html.go
index 1e3be65b..4d3d5812 100644
--- a/render/html.go
+++ b/render/html.go
@@ -9,20 +9,27 @@ import (
 	"net/http"
 )
 
+// Delims represents a set of Left and Right delimiters for HTML template rendering.
 type Delims struct {
-	Left  string
+	// Left delimiter, defaults to {{.
+	Left string
+	// Right delimiter, defaults to }}.
 	Right string
 }
 
+// HTMLRender interface is to be implemented by HTMLProduction and HTMLDebug.
 type HTMLRender interface {
+	// Instance returns an HTML instance.
 	Instance(string, interface{}) Render
 }
 
+// HTMLProduction contains template reference and its delims.
 type HTMLProduction struct {
 	Template *template.Template
 	Delims   Delims
 }
 
+// HTMLDebug contains template delims and pattern and function with file list.
 type HTMLDebug struct {
 	Files   []string
 	Glob    string
@@ -30,6 +37,7 @@ type HTMLDebug struct {
 	FuncMap template.FuncMap
 }
 
+// HTML contains template reference and its name with given interface object.
 type HTML struct {
 	Template *template.Template
 	Name     string
@@ -38,6 +46,7 @@ type HTML struct {
 
 var htmlContentType = []string{"text/html; charset=utf-8"}
 
+// Instance (HTMLProduction) returns an HTML instance which it realizes Render interface..
 func (r HTMLProduction) Instance(name string, data interface{}) Render {
 	return HTML{
 		Template: r.Template,
@@ -46,6 +55,7 @@ func (r HTMLProduction) Instance(name string, data interface{}) Render {
 	}
 }
 
+// Instance (HTMLDebug) returns an HTML instance which it realizes Render interface..
 func (r HTMLDebug) Instance(name string, data interface{}) Render {
 	return HTML{
 		Template: r.loadTemplate(),
@@ -66,6 +76,7 @@ func (r HTMLDebug) loadTemplate() *template.Template {
 	panic("the HTML debug render was created without files or glob pattern")
 }
 
+// Render (HTML) executes template and writes its result with custom ContentType for response.
 func (r HTML) Render(w http.ResponseWriter) error {
 	r.WriteContentType(w)
 
@@ -75,6 +86,7 @@ func (r HTML) Render(w http.ResponseWriter) error {
 	return r.Template.ExecuteTemplate(w, r.Name, r.Data)
 }
 
+// WriteContentType (HTML) writes HTML ContentType.
 func (r HTML) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, htmlContentType)
 }
diff --git a/render/json.go b/render/json.go
index f6b7878e..32d0fc42 100644
--- a/render/json.go
+++ b/render/json.go
@@ -13,34 +13,41 @@ import (
 	"github.com/gin-gonic/gin/internal/json"
 )
 
+// JSON contains the given interface object.
 type JSON struct {
 	Data interface{}
 }
 
+// IndentedJSON contains the given interface object.
 type IndentedJSON struct {
 	Data interface{}
 }
 
+// SecureJSON contains the given interface object and its prefix.
 type SecureJSON struct {
 	Prefix string
 	Data   interface{}
 }
 
+// JsonpJSON contains the given interface object its callback.
 type JsonpJSON struct {
 	Callback string
 	Data     interface{}
 }
 
+// AsciiJSON contains the given interface object.
 type AsciiJSON struct {
 	Data interface{}
 }
 
+// SecureJSONPrefix is a string which represents SecureJSON prefix.
 type SecureJSONPrefix string
 
 var jsonContentType = []string{"application/json; charset=utf-8"}
 var jsonpContentType = []string{"application/javascript; charset=utf-8"}
 var jsonAsciiContentType = []string{"application/json"}
 
+// Render (JSON) writes data with custom ContentType.
 func (r JSON) Render(w http.ResponseWriter) (err error) {
 	if err = WriteJSON(w, r.Data); err != nil {
 		panic(err)
@@ -48,10 +55,12 @@ func (r JSON) Render(w http.ResponseWriter) (err error) {
 	return
 }
 
+// WriteContentType (JSON) writes JSON ContentType.
 func (r JSON) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, jsonContentType)
 }
 
+// WriteJSON marshals the given interface object and writes it with custom ContentType.
 func WriteJSON(w http.ResponseWriter, obj interface{}) error {
 	writeContentType(w, jsonContentType)
 	jsonBytes, err := json.Marshal(obj)
@@ -62,6 +71,7 @@ func WriteJSON(w http.ResponseWriter, obj interface{}) error {
 	return nil
 }
 
+// Render (IndentedJSON) marshals the given interface object and writes it with custom ContentType.
 func (r IndentedJSON) Render(w http.ResponseWriter) error {
 	r.WriteContentType(w)
 	jsonBytes, err := json.MarshalIndent(r.Data, "", "    ")
@@ -72,10 +82,12 @@ func (r IndentedJSON) Render(w http.ResponseWriter) error {
 	return nil
 }
 
+// WriteContentType (IndentedJSON) writes JSON ContentType.
 func (r IndentedJSON) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, jsonContentType)
 }
 
+// Render (SecureJSON) marshals the given interface object and writes it with custom ContentType.
 func (r SecureJSON) Render(w http.ResponseWriter) error {
 	r.WriteContentType(w)
 	jsonBytes, err := json.Marshal(r.Data)
@@ -90,10 +102,12 @@ func (r SecureJSON) Render(w http.ResponseWriter) error {
 	return nil
 }
 
+// WriteContentType (SecureJSON) writes JSON ContentType.
 func (r SecureJSON) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, jsonContentType)
 }
 
+// Render (JsonpJSON) marshals the given interface object and writes it and its callback with custom ContentType.
 func (r JsonpJSON) Render(w http.ResponseWriter) (err error) {
 	r.WriteContentType(w)
 	ret, err := json.Marshal(r.Data)
@@ -115,10 +129,12 @@ func (r JsonpJSON) Render(w http.ResponseWriter) (err error) {
 	return nil
 }
 
+// WriteContentType (JsonpJSON) writes Javascript ContentType.
 func (r JsonpJSON) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, jsonpContentType)
 }
 
+// Render (AsciiJSON) marshals the given interface object and writes it with custom ContentType.
 func (r AsciiJSON) Render(w http.ResponseWriter) (err error) {
 	r.WriteContentType(w)
 	ret, err := json.Marshal(r.Data)
@@ -139,6 +155,7 @@ func (r AsciiJSON) Render(w http.ResponseWriter) (err error) {
 	return nil
 }
 
+// WriteContentType (AsciiJSON) writes JSON ContentType.
 func (r AsciiJSON) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, jsonAsciiContentType)
 }
diff --git a/render/json_17.go b/render/json_17.go
index 75f7f374..208193c7 100644
--- a/render/json_17.go
+++ b/render/json_17.go
@@ -12,10 +12,12 @@ import (
 	"github.com/gin-gonic/gin/internal/json"
 )
 
+// PureJSON contains the given interface object.
 type PureJSON struct {
 	Data interface{}
 }
 
+// Render (PureJSON) writes custom ContentType and encodes the given interface object.
 func (r PureJSON) Render(w http.ResponseWriter) error {
 	r.WriteContentType(w)
 	encoder := json.NewEncoder(w)
@@ -23,6 +25,7 @@ func (r PureJSON) Render(w http.ResponseWriter) error {
 	return encoder.Encode(r.Data)
 }
 
+// WriteContentType (PureJSON) writes custom ContentType.
 func (r PureJSON) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, jsonContentType)
 }
diff --git a/render/msgpack.go b/render/msgpack.go
index b6b8aa0f..dc681fcf 100644
--- a/render/msgpack.go
+++ b/render/msgpack.go
@@ -10,20 +10,24 @@ import (
 	"github.com/ugorji/go/codec"
 )
 
+// MsgPack contains the given interface object.
 type MsgPack struct {
 	Data interface{}
 }
 
 var msgpackContentType = []string{"application/msgpack; charset=utf-8"}
 
+// WriteContentType (MsgPack) writes MsgPack ContentType.
 func (r MsgPack) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, msgpackContentType)
 }
 
+// Render (MsgPack) encodes the given interface object and writes data with custom ContentType.
 func (r MsgPack) Render(w http.ResponseWriter) error {
 	return WriteMsgPack(w, r.Data)
 }
 
+// WriteMsgPack writes MsgPack ContentType and encodes the given interface object.
 func WriteMsgPack(w http.ResponseWriter, obj interface{}) error {
 	writeContentType(w, msgpackContentType)
 	var mh codec.MsgpackHandle
diff --git a/render/protobuf.go b/render/protobuf.go
index 34f1e9b5..47895072 100644
--- a/render/protobuf.go
+++ b/render/protobuf.go
@@ -10,12 +10,14 @@ import (
 	"github.com/golang/protobuf/proto"
 )
 
+// ProtoBuf contains the given interface object.
 type ProtoBuf struct {
 	Data interface{}
 }
 
 var protobufContentType = []string{"application/x-protobuf"}
 
+// Render (ProtoBuf) marshals the given interface object and writes data with custom ContentType.
 func (r ProtoBuf) Render(w http.ResponseWriter) error {
 	r.WriteContentType(w)
 
@@ -28,6 +30,7 @@ func (r ProtoBuf) Render(w http.ResponseWriter) error {
 	return nil
 }
 
+// WriteContentType (ProtoBuf) writes ProtoBuf ContentType.
 func (r ProtoBuf) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, protobufContentType)
 }
diff --git a/render/reader.go b/render/reader.go
index 7a06cce4..ab60e53a 100644
--- a/render/reader.go
+++ b/render/reader.go
@@ -10,6 +10,7 @@ import (
 	"strconv"
 )
 
+// Reader contains the IO reader and its length, and custom ContentType and other headers.
 type Reader struct {
 	ContentType   string
 	ContentLength int64
@@ -26,10 +27,12 @@ func (r Reader) Render(w http.ResponseWriter) (err error) {
 	return
 }
 
+// WriteContentType (Reader) writes custom ContentType.
 func (r Reader) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, []string{r.ContentType})
 }
 
+// writeHeaders writes custom Header.
 func (r Reader) writeHeaders(w http.ResponseWriter, headers map[string]string) {
 	header := w.Header()
 	for k, v := range headers {
diff --git a/render/redirect.go b/render/redirect.go
index a0634f5a..9c145fe2 100644
--- a/render/redirect.go
+++ b/render/redirect.go
@@ -9,12 +9,14 @@ import (
 	"net/http"
 )
 
+// Redirect contains the http request reference and redirects status code and location.
 type Redirect struct {
 	Code     int
 	Request  *http.Request
 	Location string
 }
 
+// Render (Redirect) redirects the http request to new location and writes redirect response.
 func (r Redirect) Render(w http.ResponseWriter) error {
 	// todo(thinkerou): go1.6 not support StatusPermanentRedirect(308)
 	// when we upgrade go version we can use http.StatusPermanentRedirect
@@ -25,4 +27,5 @@ func (r Redirect) Render(w http.ResponseWriter) error {
 	return nil
 }
 
+// WriteContentType (Redirect) don't write any ContentType.
 func (r Redirect) WriteContentType(http.ResponseWriter) {}
diff --git a/render/render.go b/render/render.go
index df0d1d7c..abfc79fc 100644
--- a/render/render.go
+++ b/render/render.go
@@ -6,8 +6,11 @@ package render
 
 import "net/http"
 
+// Render interface is to be implemented by JSON, XML, HTML, YAML and so on.
 type Render interface {
+	// Render writes data with custom ContentType.
 	Render(http.ResponseWriter) error
+	// WriteContentType writes custom ContentType.
 	WriteContentType(w http.ResponseWriter)
 }
 
diff --git a/render/text.go b/render/text.go
index 7a6acc44..2ea7343c 100644
--- a/render/text.go
+++ b/render/text.go
@@ -10,6 +10,7 @@ import (
 	"net/http"
 )
 
+// String contains the given interface object slice and its format.
 type String struct {
 	Format string
 	Data   []interface{}
@@ -17,15 +18,18 @@ type String struct {
 
 var plainContentType = []string{"text/plain; charset=utf-8"}
 
+// Render (String) writes data with custom ContentType.
 func (r String) Render(w http.ResponseWriter) error {
 	WriteString(w, r.Format, r.Data)
 	return nil
 }
 
+// WriteContentType (String) writes Plain ContentType.
 func (r String) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, plainContentType)
 }
 
+// WriteString writes data according to its format and write custom ContentType.
 func WriteString(w http.ResponseWriter, format string, data []interface{}) {
 	writeContentType(w, plainContentType)
 	if len(data) > 0 {
diff --git a/render/xml.go b/render/xml.go
index cff1ac3e..cc5390a2 100644
--- a/render/xml.go
+++ b/render/xml.go
@@ -9,17 +9,20 @@ import (
 	"net/http"
 )
 
+// XML contains the given interface object.
 type XML struct {
 	Data interface{}
 }
 
 var xmlContentType = []string{"application/xml; charset=utf-8"}
 
+// Render (XML) encodes the given interface object and writes data with custom ContentType.
 func (r XML) Render(w http.ResponseWriter) error {
 	r.WriteContentType(w)
 	return xml.NewEncoder(w).Encode(r.Data)
 }
 
+// WriteContentType (XML) writes XML ContentType for response.
 func (r XML) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, xmlContentType)
 }
diff --git a/render/yaml.go b/render/yaml.go
index 25d0ebd4..33bc3254 100644
--- a/render/yaml.go
+++ b/render/yaml.go
@@ -10,12 +10,14 @@ import (
 	"gopkg.in/yaml.v2"
 )
 
+// YAML contains the given interface object.
 type YAML struct {
 	Data interface{}
 }
 
 var yamlContentType = []string{"application/x-yaml; charset=utf-8"}
 
+// Render (YAML) marshals the given interface object and writes data with custom ContentType.
 func (r YAML) Render(w http.ResponseWriter) error {
 	r.WriteContentType(w)
 
@@ -28,6 +30,7 @@ func (r YAML) Render(w http.ResponseWriter) error {
 	return nil
 }
 
+// WriteContentType (YAML) writes YAML ContentType for response.
 func (r YAML) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, yamlContentType)
 }
diff --git a/utils.go b/utils.go
index bf32c775..f4532d56 100644
--- a/utils.go
+++ b/utils.go
@@ -14,8 +14,10 @@ import (
 	"strings"
 )
 
+// BindKey indicates a default bind key.
 const BindKey = "_gin-gonic/gin/bindkey"
 
+// Bind is a helper function for given interface object and returns a Gin middleware.
 func Bind(val interface{}) HandlerFunc {
 	value := reflect.ValueOf(val)
 	if value.Kind() == reflect.Ptr {
@@ -33,16 +35,14 @@ func Bind(val interface{}) HandlerFunc {
 	}
 }
 
-// WrapF is a helper function for wrapping http.HandlerFunc
-// Returns a Gin middleware
+// WrapF is a helper function for wrapping http.HandlerFunc and returns a Gin middleware.
 func WrapF(f http.HandlerFunc) HandlerFunc {
 	return func(c *Context) {
 		f(c.Writer, c.Request)
 	}
 }
 
-// WrapH is a helper function for wrapping http.Handler
-// Returns a Gin middleware
+// WrapH is a helper function for wrapping http.Handler and returns a Gin middleware.
 func WrapH(h http.Handler) HandlerFunc {
 	return func(c *Context) {
 		h.ServeHTTP(c.Writer, c.Request)