ThinkGo is a lightweight MVC framework written in Go (Golang).


The only requirement is the Go Programming Language

go get -u

Quick start

package main

import (

func main() {
	app := thinkgo.BootStrap()
	app.RegisterRoute(func(route *route.Route) {

		route.Get("/", func(req *context.Request) thinkgo.Response {
			return thinkgo.Text("Hello ThinkGo !")

		route.Get("/ping", func(req *context.Request) thinkgo.Response {
			return thinkgo.Json(map[string]string{
				"message": "pong",

		// Dependency injection
		route.Get("/user/{name}", func(req *context.Request, name string) thinkgo.Response {
			return thinkgo.Text(fmt.Sprintf("Hello %s !", name))
	// listen and serve on


Basic Routing

The most basic routes accept a URI and a Closure, providing a very simple and expressive method of defining routes:

app.RegisterRoute(func(route *route.Route) {
    route.Get("/foo", func(req *context.Request) thinkgo.Response {
        return thinkgo.Text("Hello ThinkGo !")

Available Router Methods

The router allows you to register routes that respond to any HTTP verb:

route.Get("/someGet", getting)
route.Post("/somePost", posting)
route.Put("/somePut", putting)
route.Delete("/someDelete", deleting)
route.Patch("/somePatch", patching)
route.Options("/someOptions", options)

Sometimes you may need to register a route that responds to multiple HTTP verbs. You may even register a route that responds to all HTTP verbs using the Any method:

route.Any("/someAny", any)

Parameters in path

Of course, sometimes you will need to capture segments of the URI within your route. For example, you may need to capture a user's ID from the URL. You may do so by defining route parameters:

route.Get("/user/{id}", func(req *context.Request, id string) thinkgo.Response {
	return thinkgo.Text(fmt.Sprintf("User %s", id))

You may define as many route parameters as required by your route:

route.Get("/posts/{post}/comments/{comment}", func(req *context.Request, postId, commentId string) thinkgo.Response {


Basic Controller

Below is an example of a basic controller class.

package controller

import (

func Index(req *context.Request) thinkgo.Response {
	return thinkgo.Text("Hello ThinkGo !")

You can define a route to this controller like so:

route.Get("/", controller.Index)

Resource Controller

This feature will be supported in a future release.

HTTP Request

Accessing The Request

To obtain an instance of the current HTTP request via dependency injection

func Handler(req *context.Request) thinkgo.Response {
	name := req.Input("name")

Dependency Injection & Route Parameters

If your controller method is also expecting input from a route parameter you should list your route parameters after the request dependencies. For example, you can access your route parameter name like so:

route.Put("/user/{name}", func(req *context.Request, name string) thinkgo.Response {

Request Path & Method

The path method returns the request's path information. So, if the incoming request is targeted at, the path method will return foo/bar:

uri := req.GetPath()

The method method will return the HTTP verb for the request.

method := req.GetMethod();

Retrieving Cookies From Requests

name, _ := request.Cookie("name")

HTTP Response

an HTTP Response Must implement the thinkgo.Response interface

Creating Responses

a simple strings or json Response:

thinkgo.Text("Hello ThinkGo !")

				"message": "pong",

Attaching Cookies To Responses

response.Cookie("name", "alice")


views are stored in the views directory, A simple view might look something like this:

views/layout.html like this:

{{ define "layout" }}
<!DOCTYPE html>
<html lang="en">
    <meta charset="UTF-8">
    <title>{{ .Title }}</title>
    {{ template "content" .}}
{{ end }}

views/tpl.html like this:

{{ define "content" }}
<h2>{{ .Message }}</h2>
{{ end }}
{{ template "layout" . }}

we may return it using the Render function like so:

route.Get("/tpl", func(request *context.Request) thinkgo.Response {
	data := map[string]interface{}{"Title": "ThinkGo", "Message": "Hello ThinkGo !"}
	return thinkgo.Render("tpl.html", data)

HTTP Session

retrieving Data like this:


storing Data like this:

request.Session().Set("user", "alice")