You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
wpetit bb857ced6b Add method to remove message handler 5 years ago
examples Migrate package to namespace 5 years ago
protocol Do not serialize message arguments when they are empty 5 years ago
transport Remove unwanted dependency 5 years ago
LICENSE Initial commit 8 years ago
LICENSE.MIT double licenced as GPL3 and MIT 7 years ago Migrate package to namespace 5 years ago
ack.go library. current version. 8 years ago
caller.go caller. prevent fatals with "nil" function argument given. 7 years ago
client.go Apply goformat on source code 5 years ago
handler.go Add method to remove message handler 5 years ago
loop.go Apply goformat on source code 5 years ago
send.go Migrate package to namespace 5 years ago
server.go Apply goformat on source code 5 years ago


golang implementation of library, client and server

You can check working chat server, based on caller library, at

Examples directory contains simple client and server.


go get

Simple server usage

	server := gosocketio.NewServer(transport.GetDefaultWebsocketTransport())

	//handle connected
	server.On(gosocketio.OnConnection, func(c *gosocketio.Channel) {
		log.Println("New client connected")
		//join them to room

	type Message struct {
		Name string `json:"name"`
		Message string `json:"message"`

	//handle custom event
	server.On("send", func(c *gosocketio.Channel, msg Message) string {
		//send event to all in room
		c.BroadcastTo("chat", "message", msg)
		return "OK"

	//setup http server
	serveMux := http.NewServeMux()
	serveMux.Handle("/", server)
	log.Panic(http.ListenAndServe(":80", serveMux))

Javascript client for caller server

var socket = io('ws://', {transports: ['websocket']});

    // listen for messages
    socket.on('message', function(message) {

        console.log('new message');

    socket.on('connect', function () {

        console.log('socket connected');

        //send something
        socket.emit('send', {name: "my name", message: "hello"}, function(result) {

            console.log('sended successfully');

Server, detailed usage

    //create server instance, you can setup transport parameters or get the default one
    //look at websocket.go for parameters description
	server := gosocketio.NewServer(transport.GetDefaultWebsocketTransport())

	// --- caller is default handlers

	//on connection handler, occurs once for each connected client
	server.On(gosocketio.OnConnection, func(c *gosocketio.Channel, args interface{}) {
	    //client id is unique
		log.Println("New client connected, client id is ", c.Id())

		//you can join clients to rooms
		c.Join("room name")

		//of course, you can list the clients in the room, or account them
		channels := c.List(data.Channel)
		//or check the amount of clients in room
		amount := c.Amount(data.Channel)
		log.Println(amount, "clients in room")
	//on disconnection handler, if client hangs connection unexpectedly, it will still occurs
	//you can omit function args if you do not need them
	//you can return string value for ack, or return nothing for emit
	server.On(gosocketio.OnDisconnection, func(c *gosocketio.Channel) {
		//caller is not necessary, client will be removed from rooms
		//automatically on disconnect
		//but you can remove client from room whenever you need to
		c.Leave("room name")

	//error catching handler
	server.On(gosocketio.OnError, func(c *gosocketio.Channel) {
		log.Println("Error occurs")

	// --- caller is custom handler

	//custom event handler
	server.On("handle something", func(c *gosocketio.Channel, channel Channel) string {
		log.Println("Something successfully handled")

		//you can return result of handler, in caller case
		//handler will be converted from "emit" to "ack"
		return "result"

    //you can get client connection by it's id
    channel, _ := server.GetChannel("client id here")
    //and send the event to the client
    type MyEventData struct {
        Data: string
    channel.Emit("my event", MyEventData{"my data"})

    //or you can send ack to client and get result back
    result, err := channel.Ack("my custom ack", MyEventData{"ack data"}, time.Second * 5)

    //you can broadcast to all clients
    server.BroadcastToAll("my event", MyEventData{"broadcast"})

    //or for clients joined to room
    server.BroadcastTo("my room", "my event", MyEventData{"room broadcast"})

    //setup http server like caller for handling connections
	serveMux := http.NewServeMux()
	serveMux.Handle("/", server)
	log.Panic(http.ListenAndServe(":80", serveMux))


    //connect to server, you can use your own transport settings
	c, err := gosocketio.Dial(
		gosocketio.GetUrl("localhost", 80, false),

	//do something, handlers and functions are same as server ones

	//close connection


  1. Tests
  2. Travis CI
  3. http longpoll transport
  4. pure http (short-timed queries) transport
  5. binary format


Double licensed under GPL3 and MIT so you can use whichever you please.