Distributed server for social and realtime games and apps.

Overview

Nakama

GitHub release Forum License

Distributed server for social and realtime games and apps.

Features

  • Users - Register/login new users via social networks, email, or device ID.
  • Storage - Store user records, settings, and other objects in collections.
  • Social - Users can connect with friends, and join groups. Builtin social graph to see how users can be connected.
  • Chat - 1-on-1, group, and global chat between users. Persist messages for chat history.
  • Multiplayer - Realtime, or turn-based active and passive multiplayer.
  • Leaderboards - Dynamic, seasonal, get top members, or members around a user. Have as many as you need.
  • Tournaments - Invite players to compete together over prizes. Link many together to create leagues.
  • Parties - Add team play to a game. Users can form a party and communicate with party members.
  • Runtime code - Extend the server with custom logic written in Lua, TypeScript/JavaScript, or native Go code.
  • Matchmaker, dashboard, metrics, and more.

Build scalable games and apps with a production ready server used by ambitious game studios and app developers all around the world. Have a look at the documentation and join the developer community for more info.

Getting Started

The server is simple to setup and run for local development and can be deployed to any cloud provider. See the deployment notes for recommendations on how to deploy the project for production. Nakama server requires CockroachDB or another Postgres wire-compatible server as it's database.

Docker

The fastest way to run the server and the database is with Docker. Setup Docker and start the daemon.

  1. Set up a docker-compose file and place it in a folder for your project.

  2. Run docker-compose -f ./docker-compose.yml up to download container images and run the servers.

For more detailed instructions have a look at our Docker quickstart guide.

Nakama Docker images are maintained on Docker Hub and prerelease images are occasionally published for cutting edge features of the server.

Binaries

You can run the servers with native binaries for your platform.

  1. Download the server from our releases page and the database.

  2. Follow the database instructions to start it.

  3. Run a migration which will setup or upgrade the database schema:

    nakama migrate up --database.address "[email protected]:26257"
  4. Start Nakama and connect to the database:

    nakama --database.address "[email protected]:26257"

When connected you'll see server output which describes all settings the server uses for configuration.

{"level":"info","ts":"2018-04-29T10:14:41.249+0100","msg":"Node","name":"nakama","version":"2.0.0+7e18b09","runtime":"go1.10.1","cpu":4}
{"level":"info","ts":"2018-04-29T10:14:41.249+0100","msg":"Database connections","dsns":["[email protected]:26257"]}
...

Usage

Nakama supports a variety of protocols optimized for various gameplay or app use cases. For request/response it can use GRPC or the HTTP1.1+JSON fallback (REST). For realtime communication you can use WebSockets or rUDP.

For example with the REST API to authenticate a user account with a device identifier.

curl "127.0.0.1:7350/v2/account/authenticate/device?create=true" \
  --user "defaultkey:" \
  --data '{"id": "someuniqueidentifier"}'

Response:

{
"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1MjQ5OTU2NDksInVpZCI6Ijk5Y2Q1YzUyLWE5ODgtNGI2NC04YThhLTVmMTM5YTg4MTgxMiIsInVzbiI6InhBb1RxTUVSdFgifQ.-3_rXNYx3Q4jKuS7RkxeMWBzMNAm0vl93QxzRI8p_IY"
}

There's a number of official client libraries available on GitHub with documentation. The current platform/language support includes: .NET (in C#), Unity engine, JavaScript, Java (with Android), Unreal engine, Godot, Defold, and Swift (with iOS). If you'd like to contribute a client or request one let us know.

Nakama Console

The server provides a web UI which teams can use to inspect various data stored through the server APIs, view lightweight service metrics, manage player data, update storage objects, restrict access to production with permission profiles, and gain visibility into realtime features like active multiplayer matches. There is no separate installation required as it is embedded as part of the single server binary.

You can navigate to it on your browser on http://127.0.0.1:7351.

Deployment

Nakama can be deployed to any cloud provider such as Google Cloud, Azure, AWS, Digital Ocean, Heroku, or your own private cloud. You should setup and provision separate nodes for Nakama and CockroachDB.

The recommended minimum production infrastructure for CockroachDB is outlined in these docs and Nakama can be run on instance types as small as "g1-small" on Google Cloud although we recommend a minimum of "n1-standard-1" in production. The specific hardware requirements will depend on what features of the server are used. Reach out to us for help and advice on what servers to run.

Heroic Cloud

You can support development, new features, and maintainance of the server by using the Heroic Labs' Heroic Cloud for deployment. This service handles the uptime, replication, backups, logs, data upgrades, and all other tasks involved with production server environments.

Have a look at our Heroic Cloud service for more details.

Contribute

The development roadmap is managed as GitHub issues and pull requests are welcome. If you're interested to add a feature which is not mentioned on the issue tracker please open one to create a discussion or drop in and discuss it in the community forum.

Simple Builds

All dependencies required for a build are vendored as part of the Go project. We recommend a modern release of the Go toolchain and do not store the codebase in the old GOPATH.

  1. Download the source tree.

    git clone "https://github.com/heroiclabs/nakama" nakama
    cd nakama
  2. Build the project from source.

    go build -trimpath -mod=vendor
    ./nakama --version

Full Source Builds

The codebase uses Protocol Buffers, GRPC, GRPC-Gateway, and the OpenAPI spec as part of the project. These dependencies are generated as sources and committed to the repository to simplify builds for contributors.

To build the codebase and generate all sources follow these steps.

  1. Install the toolchain.

    go install \
        "google.golang.org/protobuf/cmd/protoc-gen-go" \
        "google.golang.org/grpc/cmd/protoc-gen-go-grpc" \
        "github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-grpc-gateway" \
        "github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2"
  2. If you've made changes to the embedded Console.

    cd console/ui
    ng serve
  3. Re-generate the protocol buffers, gateway code and console UI.

    env PATH="$HOME/go/bin:$PATH" go generate -x ./...
  4. Build the codebase.

    go build -trimpath -mod=vendor

License

This project is licensed under the Apache-2 License.

Issues
  • Would be awesome to have Defold (LUA) client sdk

    Would be awesome to have Defold (LUA) client sdk

    Me and some my friend wants to use Nakame server for their games using Defold. Would be great to have Defold (Lua) client sdk.

    Conversation on Defold forum :
    https://forum.defold.com/t/firebase-or-other-backend-service-support/13270/2?u=agulev

    opened by AGulev 21
  • Missing error logs in Windows under docker-toolbox

    Missing error logs in Windows under docker-toolbox

    Description

    If Lua code has runtime error in some function - the Nakama server stops running this function without any logs in console

    Example

    There are the error because we can't concatenate " state " .. state

    function M.match_loop(context, dispatcher, tick, state, messages)
      print ("first step")
      print (">> match_loop " .. " nkTime " .. nk.time() .. " state " .. state)
      print ("second step")
    

    Last logs from console: nakama | {"level":"debug","ts":"2019-01-04T10:24:36.412Z","msg":"Processing presence event","joins":1,"leaves":0} nakama | >>> match_join nakama | {"level":"debug","ts":"2019-01-04T10:24:36.413Z","msg":"Sending *rtapi.Envelope_Match message","uid":"235800a4-e25f-4587-8808-d28aa434a58f","sid":"03affa98-683c-4959-bdc3-e754f622e32b","envelope":"cid:"4" match:<match_id:"7e43e33f-0ad0-4f87-a8e1-60b48e71d918.nakama1" authoritative:true label:<> self:<user_id:"235800a4-e25f-4587-8808-d28aa434a58f" session_id:"03affa98-683c-4959-bdc3-e754f622e32b" username:"RRendeRR" > > "} nakama | first step

    Expected Result

    Logs with stack trace in console

    Actual Result

    No any logs in console

    Context

    C++ client

    Your Environment

    • Nakama: 2.3.0
    • Cockroach: 2.1.1
    • Windows 10
    opened by rrenderr 12
  • Dashboard redesign

    Dashboard redesign

    The dashboard which comes with Nakama server was re-enabled in the 1.0.2 release ahead of a redesign. This issue tracks design requirements and requests from the community for what they'd like to see in the reworked dashboard.

    opened by novabyte 12
  • Improve connectivity when enabling SSL in Nakama for development

    Improve connectivity when enabling SSL in Nakama for development

    Hello everyone, I try to connect from Unity Editor to nakama using SSL and what I get as a response from the server is the following: message: ApiResponseException(StatusCode=503, Message='all SubConns are in TransientFailure, latest connection error: connection error: desc = "transport: authentication handshake failed: x509: cannot validate certificate for 127.0.0.1 because it doesn't contain any IP SANs"', GrpcStatusCode=14)

    SSL is created using Lets Encrypt.

    Client configuration: client = new Client("https",_ipAddress, 443, serverKey, UnityWebRequestAdapter.Instance) {

    The Ip Address I used is the domain of my server. I already tried running Nakama without SSL and it worked fine.' Nakama Version: 2.5.1+8216d5cc Cockroach version: v2.1.6

    Any ideas?

    opened by nerdakos 11
  • [ SQL ] Misleading error message on email update

    [ SQL ] Misleading error message on email update

    When trying to update the email field in the users table via a RPC function, one gets the duplicate key constraint error in the docker logs.

    The problem here is the error is not correct nor the docs. In order to update the email field on the users table one needs to add the update_time = now() to the update query, after which the query executes correctly.

    It should be added in the docs and the error message from SQL should be more specific.

    Description

    Example: When updating a user's email address, the RPC call fails 500 error

    Steps to Reproduce

    Create a simple RPC function and call it from the front end to update the email for the current user.

    Expected Result

    The email should be updated

    Actual Result

    The server responds with 500 error

    Context

    • Browser / Chrome

    Your Environment

    • Nakama: 2.7.0
    opened by danieltamas 10
  • Store handle for each user in the presence map

    Store handle for each user in the presence map

    This was asked about on Gitter so that presence join and leave events can include the handle of the user who's state changed in the realtime chat or match.

    enhancement wishlist 
    opened by novabyte 10
  • Fatal concurrency error while starting Nakama (with lua runtimes) under heavy load

    Fatal concurrency error while starting Nakama (with lua runtimes) under heavy load

    Description

    While a Nakama instance was restarting under heavy load, we encountered this fatal error:

    fatal error: concurrent map writes
    fatal error: concurrent map writes
    
    goroutine 65087 [running]:
    runtime.throw({0x1a541bc, 0xaaaaaaaaaaaaaa})
            runtime/panic.go:1198 +0x71 fp=0xc04e09f1c8 sp=0xc04e09f198 pc=0x992e91
    runtime.mapassign_faststr(0x188e960, 0xc0004d4d20, {0xc000a940a0, 0x1e})
            runtime/map_faststr.go:294 +0x38b fp=0xc04e09f230 sp=0xc04e09f1c8 pc=0x97040b
    github.com/heroiclabs/nakama/v3/server.newRuntimeLuaVM.func1(0xc000a940a0, {0xc000a940a0, 0x16}, 0xc04e26edc0)
            github.com/heroiclabs/nakama/v3/server/runtime_lua.go:2077 +0xf2 fp=0xc04e09f260 sp=0xc04e09f230 pc=0x16b4c92
    github.com/heroiclabs/nakama/v3/server.(*RuntimeLuaNakamaModule).registerRPC(0xc0001e1320, 0x30)
            github.com/heroiclabs/nakama/v3/server/runtime_lua_nakama.go:297 +0x84 fp=0xc04e09f2b0 sp=0xc04e09f260 pc=0x16d02e4
    github.com/heroiclabs/nakama/v3/server.(*RuntimeLuaNakamaModule).registerRPC-fm(0xc004446240)
            github.com/heroiclabs/nakama/v3/server/runtime_lua_nakama.go:285 +0x2c fp=0xc04e09f2d0 sp=0xc04e09f2b0 pc=0x17571ec
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.callGFunction(0xc004400370, 0x0)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/vm.go:202 +0x37 fp=0xc04e09f338 sp=0xc04e09f2d0 pc=0x1416037
    
    Full trace:
    fatal error: concurrent map writes
    fatal error: concurrent map writes
    
    goroutine 65087 [running]:
    runtime.throw({0x1a541bc, 0xaaaaaaaaaaaaaa})
            runtime/panic.go:1198 +0x71 fp=0xc04e09f1c8 sp=0xc04e09f198 pc=0x992e91
    runtime.mapassign_faststr(0x188e960, 0xc0004d4d20, {0xc000a940a0, 0x1e})
            runtime/map_faststr.go:294 +0x38b fp=0xc04e09f230 sp=0xc04e09f1c8 pc=0x97040b
    github.com/heroiclabs/nakama/v3/server.newRuntimeLuaVM.func1(0xc000a940a0, {0xc000a940a0, 0x16}, 0xc04e26edc0)
            github.com/heroiclabs/nakama/v3/server/runtime_lua.go:2077 +0xf2 fp=0xc04e09f260 sp=0xc04e09f230 pc=0x16b4c92
    github.com/heroiclabs/nakama/v3/server.(*RuntimeLuaNakamaModule).registerRPC(0xc0001e1320, 0x30)
            github.com/heroiclabs/nakama/v3/server/runtime_lua_nakama.go:297 +0x84 fp=0xc04e09f2b0 sp=0xc04e09f260 pc=0x16d02e4
    github.com/heroiclabs/nakama/v3/server.(*RuntimeLuaNakamaModule).registerRPC-fm(0xc004446240)
            github.com/heroiclabs/nakama/v3/server/runtime_lua_nakama.go:285 +0x2c fp=0xc04e09f2d0 sp=0xc04e09f2b0 pc=0x17571ec
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.callGFunction(0xc004400370, 0x0)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/vm.go:202 +0x37 fp=0xc04e09f338 sp=0xc04e09f2d0 pc=0x1416037
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.init.3.func26(0xc004400370, 0x9bab40, 0xc0044231e0)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/vm.go:821 +0x35f fp=0xc04e09f4a8 sp=0xc04e09f338 pc=0x141b05f
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.mainLoopWithContext(0xc004400370, 0xc000aa24c0)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/vm.go:60 +0x113 fp=0xc04e09f500 sp=0xc04e09f4a8 pc=0x1415d73
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.(*LState).callR(0xc004400370, 0x1, 0x1, 0xc000484900)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/state.go:1211 +0x1b4 fp=0xc04e09f5f8 sp=0xc04e09f500 pc=0x1403bf4
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.(*LState).Call(...)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/state.go:1971
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.loRequire(0xc004400370)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/baselib.go:559 +0x6b5 fp=0xc04e09f728 sp=0xc04e09f5f8 pc=0x13deed5
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.callGFunction(0xc004400370, 0x0)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/vm.go:202 +0x37 fp=0xc04e09f790 sp=0xc04e09f728 pc=0x1416037
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.init.3.func26(0xc004400370, 0xb5cff0, 0xc004423140)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/vm.go:821 +0x35f fp=0xc04e09f900 sp=0xc04e09f790 pc=0x141b05f
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.mainLoopWithContext(0xc004400370, 0xc000bc25c0)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/vm.go:60 +0x113 fp=0xc04e09f958 sp=0xc04e09f900 pc=0x1415d73
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.(*LState).callR(0xc004400370, 0x1, 0x1, 0xc0000bcf90)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/state.go:1211 +0x1b4 fp=0xc04e09fa50 sp=0xc04e09f958 pc=0x1403bf4
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.(*LState).Call(...)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/state.go:1971
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.loRequire(0xc004400370)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/baselib.go:559 +0x6b5 fp=0xc04e09fb80 sp=0xc04e09fa50 pc=0x13deed5
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.callGFunction(0xc004400370, 0x0)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/vm.go:202 +0x37 fp=0xc04e09fbe8 sp=0xc04e09fb80 pc=0x1416037
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.init.3.func26(0xc004400370, 0xa51e00, 0xc0044230a0)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/vm.go:821 +0x35f fp=0xc04e09fd58 sp=0xc04e09fbe8 pc=0x141b05f
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.mainLoopWithContext(0xc004400370, 0xc00080bb00)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/vm.go:60 +0x113 fp=0xc04e09fdb0 sp=0xc04e09fd58 pc=0x1415d73
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.(*LState).callR(0xc004400370, 0x1, 0x1, 0xc0001afcb0)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/state.go:1211 +0x1b4 fp=0xc04e09fea8 sp=0xc04e09fdb0 pc=0x1403bf4
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.(*LState).Call(...)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/state.go:1971
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.loRequire(0xc004400370)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/baselib.go:559 +0x6b5 fp=0xc04e09ffd8 sp=0xc04e09fea8 pc=0x13deed5
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.callGFunction(0xc004400370, 0x0)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/vm.go:202 +0x37 fp=0xc04e0a0040 sp=0xc04e09ffd8 pc=0x1416037
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.init.3.func26(0xc004400370, 0x9bb860, 0xc004423000)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/vm.go:821 +0x35f fp=0xc04e0a01b0 sp=0xc04e0a0040 pc=0x141b05f
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.mainLoopWithContext(0xc004400370, 0xc01d2cf140)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/vm.go:60 +0x113 fp=0xc04e0a0208 sp=0xc04e0a01b0 pc=0x1415d73
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.(*LState).callR(0xc004400370, 0x2, 0xffffffffffffffff, 0xc04e0a0398)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/state.go:1211 +0x1b4 fp=0xc04e0a0300 sp=0xc04e0a0208 pc=0x1403bf4
    github.com/heroiclabs/nakama/v3/internal/gopher-lua.(*LState).Call(...)
            github.com/heroiclabs/nakama/v3/internal/gopher-lua/state.go:1971
    

    We are going to try setting min runtimes = max runtimes to avoid this error.

    Steps to Reproduce

    1. Configure Nakama with min Lua runtimes = 64, max = 256
    2. Start a lot of test clients trying to authenticate repeatedly
    3. Start Nakama

    Expected Result

    No error. Lua runtimes spin up with no issue.

    Actual Result

    Fatal error. See above.

    Context

    Godot client

    Your Environment

    Nakama 3.10 (forked from https://github.com/heroiclabs/nakama/commit/1d0527e00cdcb5106249e48baa40b03d37bf8b4f) Postgres Docker

    opened by brianwinterpixel 9
  • "error":"json: cannot unmarshal object into Go value of type []*server.importStorageObject"

    Before you submit an issue we recommend you drop into the Gitter community and ask any questions you have or mention any problems you've had getting started with the server.

    Please provide as much information as you can with this issue report. If you believe it may be an issue with one of the client libraries please report it on their own trackers.

    Description

    Getting 'Failed to upload the file' error when uploading json file to Storage in admin panel. Logs: {"level":"warn","ts":"2019-05-21T11:03:22.819-0700","msg":"Could not parse JSON file.","error":"json: cannot unmarshal object into Go value of type []*server.importStorageObject"}

    $ ./nakama --version 2.5.1+8216d5cc

    Json I am trying to upload: { "items": [ { "desc": null, "id": "3423", "name": null, "parameters": null, "quantity": 0, "tags": null, "type": 0 } ], "version": "1" }

    Steps to Reproduce

    1. Login as admin to
    2. Go to Storage
    3. Select Import Json file
    4. drag and drop json file.
    5. Error appears: Failed to upload the file.

    Expected Result

    No error is thrown and json file uploaded

    Actual Result

    The error appears: Failed to upload the file. Terminal logs: {"level":"warn","ts":"2019-05-21T11:03:22.819-0700","msg":"Could not parse JSON file.","error":"json: cannot unmarshal object into Go value of type []*server.importStorageObject"}

    Context

    • [ ] Unity
    • [ ] Unreal
    • [x] Other(web)

    Your Environment

    • Nakama: 2.5.1+8216d5cc
    • Cockroach: v2.1.6
    • Environment name and version:
    • Operating System and version: OSX 10.14.4
    opened by AlexeyIS 9
  • A rejoin sent to a match the player is already part of does not return the match label

    A rejoin sent to a match the player is already part of does not return the match label

    Description Re-joining the match without leaving it doesn't trigger match handler's match_join_attempt and match_join on server side and unity client doesn't throw any exception on the call

    • var match = await NakamaSessionManager.Instance._Socket.JoinMatchAsync(matchId);

    And getting an empty label i.e. match.Label is empty.

    Steps to Reproduce

    1. Join a match and store it's match_id and print the match label which is not an empty string.
    2. Re-join the same match with the stored match_id

    Expected Result

    • On server side : match_join_attempt and match_join should have been invoked.
    • On client side : match label should not have been empty.

    Actual Result

    • No logs printed in the match_join_attempt and match_join
    • Match label is an empty string.

    Context Client used unity

    Environment

    • Nakama: v2.0.3+98493c9
    • Cockroach: v2.0.5
    • Unity Client - v2.1.0
    • Operating System and version: Windows 10
    opened by hk0129 9
  • Server to server functions input is accepted in an unexpected way

    Server to server functions input is accepted in an unexpected way

    Description

    Server to server functions have some issues while handling the payload body.

    Steps to Reproduce

    As your docs describe, I just created something exactly as the example:

    local nk = require("nakama")
    
    local function http_handler(context, payload)
      local message = nk.json_encode(payload)
      nk.logger_info(("Message: %q"):format(message))
      return {["context"] = context}
    end
    
    nk.register_rpc(http_handler, "http_handler_path")
    

    And try to call it:

    curl -X POST "http://127.0.0.1:7350/v2/rpc/http_handler_path?http_key=defaultkey" \
         -d '{"some": "data"}' \
         -H 'Content-Type: application/json' \
         -H 'Accept: application/json'
    

    Actual Result

    But I got:

    {"error":"json: cannot unmarshal object into Go value of type string","code":3}
    

    Deeper Information

    Actually I found that you treat the whole body as payload, and it should be passed as a JSON string, like:

    curl -X POST "http://127.0.0.1:7350/v2/rpc/http_handler_path?http_key=somekey" \
         -d '"{\"some\": \"data\"}"' \
         -H 'Content-Type: application/json' \
         -H 'Accept: application/json'
    

    Please look at this line: -d '"{\\"some\\": \\"data\\"}"'. It's a JSON string, which contains a JSON Object serialized as string. What the ...

    And what i got in the logger in this case:

    {"level":"info","ts":"2018-05-15T10:51:30.868+0800","msg":"Message: \"\\\"{\\\\\\\"some\\\\\\\": \\\\\\\"data\\\\\\\"}\\\"\""}
    

    What a mess.

    Expected Result

    I hope that the whole body is treat as payload, unserialize it, and pass it as table to the Lua context.

    Like this:

    local nk = require('nakama')
    nk.register_rpc(function (context, payload)
      nk.logger_info(payload['some']) -- get "data", no json_decode needed
    end, 'func_name')
    

    Environment

    $ ./nakama --version
    2.0.0+dev
    

    This version is built from commit ea2bfb78e4f37659cd7f39fee54624e03c8d52de .

    opened by oott123 9
  • Plugin Architecture

    Plugin Architecture

    Implement a collection of plugin hooks which are executed at various stages in the socket pipeline which can be used to trigger behaviour in custom plugins. These plugins must be written in Go and will be loaded at server start with their configurations. This can be used to reduce the number of SDKs required in game clients for analytics, Ads, dynamic IAP prices, etc.

    enhancement help wanted planned rfc 
    opened by novabyte 9
  • Expose Nakama server version to our runtime

    Expose Nakama server version to our runtime

    Example use case: QA wants to know server version that app is using, and thus devs want to print it on the client. User could write an RPC that sends down the server version.

    enhancement 
    opened by lugehorsam 0
  • Typescript: SQL 'value' output is unreadable

    Typescript: SQL 'value' output is unreadable

    We're executing a sql query to get all storage objects of a certain collection. We're using the sql query to bypass the arbitrary hardcoded limit where nakama returns an error if requesting a list of more than 100. I think this should be removed, it's frankly the source of many of our issues and it should be up to the developer to decide what list size is too big. I know we can use a cursor and grab everything but doesn't that amount to many queries? My understanding is that one big query is cheaper than many small ones... but I digress.

    We're getting a bizzare output for "value" which is unreadable. The rest seems fine: rows = nk.sqlQuery(query, parameters); return JSON.stringify({ success: true, servers: rows }); { "user_id": "00000000-0000-0000-0000-000000000000", "write": 0, "update_time": "2022-06-09T19:52:30.476506Z", "collection": "servers", "key": "whatever", "value": [ 123, 34, 71, 97, 109, 101, 77, 111, 100, 101, 34, 58, 32, 49, 44, 32, 34, 83, 101, 114, 118, 101, 114, 78, 97, 109, 101, 34, 58, 32, 34, 66, 114, 101, 110, 100, 101, 110, 34, 125 ], "version": "745f2988787925a473d1589c25934d14", "read": 1, "create_time": "2022-06-09T19:52:30.476506Z"

    When I look up the storage item in nakama it reads like this:
    {
      "GameMode": 1,
      "ServerName": "Brenden"
    }
    

    Any idea why the sql query is returning gibberish? Are you guys doing anything fancy here? I looked at source and didn't spot anything. The database schema also showed that 'value' is stored as JSONB so I would have expected to get the exact parseable JSON here unless there's a bug going on.

    Thanks, Brenden

    opened by brendenfrank 1
  • Concurrent read/write panic when modifying Lua tables defined at file-scope

    Concurrent read/write panic when modifying Lua tables defined at file-scope

    Description

    We added a caching mechanism in Lua to reduce time wasted on marshalling data between Go and Lua for a large chunk of data we use very frequently. This was a noticeable performance improvement.

    However, this caching mechanism is causing concurrency issues between Lua runtimes.

    Steps to Reproduce

    This code should be able to reproduce the issue:

    
    local nk = require("nakama")
    
    local _cached_config = {}
    local _cached_config_timestamp = 0
    local _cache_duration = tonumber(nk.get_context().env.config_cache_duration) or 0
    
    local function _actually_query_config()
    	nk.logger_info("[config] _actually_query_config()")
    	local storage_read = nk.storage_read({{
    		collection = "winterpixel",
    		key = "config"
    	}})
    	if storage_read[1] then
    		return storage_read[1]["value"], storage_read[1]["version"]
    	end
    	nk.logger_error("[config] failed to query config")
    	error("failed to query config")
    	return nil, "*"
    end
    
    -- This function is used in other Lua modules very frequently.
    -- Except for in the RPC below, the config returned here is never modified by other Lua modules.
    local function query_config()
    	if _cache_duration == nil or _cache_duration <= 0 then
    		local value, version = _actually_query_config()
    		return value
    	end
    	
    	local current_time = math.floor(nk.time() / 1000) -- milliseconds to seconds
    	if current_time - _cached_config_timestamp > _cache_duration then
    		local value, version = _actually_query_config()
    		_cached_config_timestamp = current_time
    
    		-- NOTE: Reassigning _cached_config does not seem to cause any concurrency issues.
    		_cached_config = value
    	else
    		nk.logger_info("[config] returning _cached_config()")
    	end
    
    	return _cached_config
    end
    
    -- ----------------------------
    
    -- This RPC is called by clients to get the config.
    -- We modify the config to send dynamic data to the client.
    local function rpc_winterpixel_get_config(context, payload)
    	local config = query_config()
    	-- NOTE: If we do a shallow copy of this config table before modifying, we no longer encounter concurrency issues.
    	-- Disabling lua_read_only_globals also resolves the issue.
    
    	config["server_time"] = math.floor(nk.time() / 1000)
    	-- [write other dynamic stuff to config file]
    
    	return nk.json_encode(config)
    end
    
    nk.register_rpc(rpc_winterpixel_get_config, "winterpixel_get_config")
    
    

    Call the above RPC frequently to trigger a concurrency panic.

    Expected Result

    We expected the file-scope local _cached_config to be a local variable managed per Lua runtime. However, after debugging this issue my understanding is that file-scope variables are actually globals shared between Lua runtimes, set as read-only to avoid concurrency issues.

    With this understanding, I expect that the code above should have triggered a panic for trying to modify a read-only global table. We encountered errors for trying to write to read-only globals while writing this code, but we didn't understand what it meant or why it was being triggered - all of our vars are local. It would have been helpful to have documentation on this subject.

    Actual Result

    On occasion, a panic is triggered. Every case we've encountered involves a concurrency issue with modifying LTable strdict.

    Context

    Godot

    Your Environment

    Nakama 3.10 (forked from https://github.com/heroiclabs/nakama/commit/1d0527e00cdcb5106249e48baa40b03d37bf8b4f) The only changes in our fork are: "add rest interface with default raw json content type" https://github.com/heroiclabs/nakama/pull/775 "Switch order of http_key and Authorization header auth methods" https://github.com/heroiclabs/nakama/pull/772

    Postgres

    Docker

    opened by brianwinterpixel 2
  • Cursor Pagination is always returning the same cursor when limit is <100

    Cursor Pagination is always returning the same cursor when limit is <100

    Description

    When calling the nkRuntime storageList using a cursor to return paginated data, if a limit is specified below the default value (100), then the cursor is always the same and I can't proceed beyond the 2nd page of data.

    If the limit is null or >=100, then data is returned as expected.

    Steps to Reproduce

    Method Call: nk.storageList("00000000-0000-0000-0000-000000000000", collection, limit, cursor);

    1. Pass limit value of 20 with null cursor.
    2. First page of 20 records are returned along with the first cursor.
    3. Pass limit of 20 with the first cursor.
    4. Second page of 20 records are returned, new cursor is same as first.

    Expected Result

    The second an subsequent cursors should be different and allow data to be returned in sets of 20 until last set of <=20, which should include a null cursor.

    Actual Result

    Cursor is always the same after first page, so cannot proceed beyond the second page.

    If the limit is null or >=100, then data is returned as expected.

    Context

    • [ ] Other

    Your Environment

    • Nakama: 3.10.0
    • Database: postgres:12.2-alpine
    • Environment name and version: Elasticbeanstalk
    opened by JMCNAM-SN 6
Releases(v3.12.0)
  • v3.12.0(May 22, 2022)

    Notable changes

    For the full release notes have a look at our release notes documentation.

    Added

    • Add "FriendsBlock" function to all runtimes.
    • Add "ChannelMessagesList" function to all runtimes.

    Changed

    • Ensure storage write ops return acks in the same order as inputs.
    • Update console path for delete all data operation.
    • Check HTTP key before Authorization header in RPC function invocations.
    • Expose error message from Apple authentication JWT verification failures.
    • Improve user online status lookups.
    • Build with Go 1.18.2 release.
    • Update naming of delete notifications before/after hook registration functions.
    • Improve clarity of Nakama Console status view graph headers.
    • Improve log messages from failed social provider requests.
    • Improve concurrency with Lua runtime function registrations.
    • Ensure authoritative match loggers correctly include only their own match identifier.
    • Improve handling of large tournament max size values.
    • Improve handling of channel removal on group leave/kick/ban.
    • Small UI adjustments to the group membership view in the Nakama Console.

    Fixed

    • Fix data returned by "StreamUserList" in JavaScript runtime.
    • Allow passing lists of presences as match init parameters to Go runtime matches.
    • Fix Nakama Console object counts when database statistics are not available.
    • Must generate username field in the token generator if not specified when called by the server runtimes.
    • Improve JavaScript runtime authoritative match filtered broadcasts to large sets of users.
    • Align optional parameters in JavaScript runtime bindings.
    • Fix JavaScript registered match handlers not being available within the "InitModule" function.
    • Use unique notification ID handling for persistent notifications sent to all users.
    • Ensure concurrent leaderboard creation requests are handled idempotently.
    • Fix regression with matchmaker optimization used when only two opponents are matched.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.23.0 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-3.12.0-darwin-amd64.tar.gz(12.46 MB)
    nakama-3.12.0-linux-amd64.tar.gz(13.35 MB)
    nakama-3.12.0-linux-arm64.tar.gz(12.04 MB)
    nakama-3.12.0-windows-amd64.tar.gz(10.72 MB)
  • v3.11.0(Mar 21, 2022)

    Notable changes

    Added

    • Add "GroupUsersBan" function to all runtimes.
    • Add "LeaderboardRecordsHaystack" to all runtimes.
    • Add Groups page and API endpoints to the developer console.
    • Add "NotificationSendAll" function to the runtimes, for sending a notification to all users.
    • Log a warning when client IP address cannot be resolved.
    • Add matchmaker option to enforce a multiple of resulting matched count.
    • Add tagged Prometheus stats containing RPC function identifiers.

    Changed

    • Improve Stackdriver log format timestamp and message field formats.
    • Use crypto random to seed global random instance if possible.
    • Allow migrate subcommand to use database names that contain dashes.
    • Add senderID param to "channelIdBuild" function.
    • Improve leaderboard rank cache population at startup.
    • JavaScript global variables are made immutable by default after the "InitModule" function is invoked.
    • Return system user UUID string in "StorageWrite" acks for all runtimes.
    • Realtime after hooks now include both the outgoing and incoming payload.
    • Realtime after hooks do not run when the operation fails.
    • Build with Go 1.18.0 release.

    Fixed

    • Fix the registered function name for "nk.channelIdBuild" in the JavaScript runtime.
    • Better input validation for Steam link operations.
    • Fix incorrect link device behaviour in JavaScript runtime.
    • Fix JavaScript runtime multi-update execution consistency when part of the operation fails.
    • Fix handling of wallet ledger lookups with no limit during account exports.
    • Ensure maximum count is accounted for in matchmaker mutual match checks.
    • Ensure the matchmaker always correctly prefers matches closer to the maximum count.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.22.0 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-3.11.0-darwin-amd64.tar.gz(11.98 MB)
    nakama-3.11.0-linux-amd64.tar.gz(12.80 MB)
    nakama-3.11.0-linux-arm64.tar.gz(11.54 MB)
    nakama-3.11.0-windows-amd64.tar.gz(10.67 MB)
  • v3.10.0(Dec 17, 2021)

    Notable changes

    Added

    • Add ctx field to access http request headers in the runtimes.
    • New JS runtime stringToBinary and binaryToString functions.
    • New configuration option for frequency of database DNS change scans.

    Changed

    • Set JavaScript runtime custom error message as the returned payload message in RPC requests.
    • JavaScript runtime match data changed to use Uint8Array type.
    • Update Tally, and transitive dependencies to resolve dynamic linker error in xxhash package.
    • Build with Go 1.17.5 release.

    Fixed

    • Gracefully close Lua matches when call queue fills up.
    • Better handling for Lua runtime wallet update operation errors.
    • Fix handling of leaderboard record writes that do not need to update the database.
    • Fix parsing edge case in TypeScript/JavaScript runtime storage delete operations.
    • Better handling of leaderboard and tournament score submissions that result in no score change.
    • Named match creation now returns existing presences if the name mapped to an existing match.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.21.0 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-3.10.0-darwin-amd64.tar.gz(11.69 MB)
    nakama-3.10.0-linux-amd64.tar.gz(12.42 MB)
    nakama-3.10.0-linux-arm64.tar.gz(11.26 MB)
    nakama-3.10.0-windows-amd64.tar.gz(10.40 MB)
  • v3.9.0(Oct 29, 2021)

    Notable changes

    Added

    • Allow creation of relayed matches with a name. Names will be mapped to match identifiers.
    • Expose Nakama errors to the server runtime.
    • The wallet ledger view in the Nakama Console now supports pagination.

    Changed

    • Periodically check database hostname for underlying address changes more frequently.
    • Upgrade GRPC, GRPC-Gateway, Protobuf, PGX, and other dependencies.

    Fixed

    • Fix optimistic email imports when linking social profiles.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.20.0 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-3.9.0-darwin-amd64.tar.gz(11.67 MB)
    nakama-3.9.0-linux-amd64.tar.gz(12.40 MB)
    nakama-3.9.0-linux-arm64.tar.gz(11.23 MB)
    nakama-3.9.0-windows-amd64.tar.gz(10.38 MB)
  • v3.8.0(Oct 15, 2021)

    Notable changes

    Added

    • Add final notification sent to sockets closed via single socket option.
    • Add match signal function to server framework.
    • Add node status icons to the console dashboard.

    Changed

    • Build with Go 1.17.2 release.

    • Match handlers are now required to implement a signal handler function.

      Match signals allow the match handler to be sent a reservation signal to mark a user ID or session ID into the match state ahead of their join attempt and eventual join flow. This is useful to apply reservations to a matchmaking system with Nakama's matchmaker or match listings APIs.

    • Log status follow missing users at debug instead of warn level.

    Fixed

    • Fix input validation edge case in group listing operations.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.19.0 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/runtim[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-3.8.0-darwin-amd64.tar.gz(12.12 MB)
    nakama-3.8.0-linux-amd64.tar.gz(12.86 MB)
    nakama-3.8.0-linux-arm64.tar.gz(11.68 MB)
    nakama-3.8.0-windows-amd64.tar.gz(10.77 MB)
  • v3.7.0(Sep 28, 2021)

    Notable changes

    Added

    • New config options to enforce a single socket per user, and a single match per socket.

    Changed

    • Build with Go 1.17.1 release.
    • Allow tournament creation operations to set the authoritative flag.
    • Update to nakama-common 1.18.0 release.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.18.0 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-3.7.0-darwin-amd64.tar.gz(12.07 MB)
    nakama-3.7.0-linux-amd64.tar.gz(12.83 MB)
    nakama-3.7.0-linux-arm64.tar.gz(11.64 MB)
    nakama-3.7.0-windows-amd64.tar.gz(10.74 MB)
  • v3.6.0(Sep 9, 2021)

    Notable changes

    Added

    • More informational logging when groups are created, updated, or deleted.
    • Add "ChannelMessageUpdate" function to server framework.
    • New config option to toggle Lua runtime error stacktraces returned to clients.

    Changed

    • Use the Facebook Graph API v11.0 version.
    • Defer Facebook email import execution to after account creation.
    • Improve encode/decode check in authoritative match creation parameters.
    • Warn when using deprecated config parameters.
    • Improve email import semantics when linking social accounts.
    • Log IAP provider API response payload when non 200 status code is returned.
    • Better handling of storage operations where OCC is not required.
    • Default ledger updates to false in "walletsUpdate" function in the JavaScript/Lua runtimes. Same as how Go usage works.
    • Build with Go 1.17.0 release.
    • Purchase validation functions now return a flag indicating if valid purchases are new or resubmitted.
    • Adjust Lua runtime pool allocation startup logs.

    Fixed

    • Fix log level in Lua runtime log calls which use structured logger fields.
    • Register purchase validation before/after hooks in JavaScript/Lua runtimes.
    • Register "DemoteGroupUsers" before/after hooks in the JavaScript runtime.
    • Add missing "environment" to JavaScript ValidatedPurchases type.
    • Fix typos in error messages which mention empty input values.
    • Fix resolution of exported time and latency metrics.
    • Optimize tournament lookup operations.
    • Fix "groupUpdate" function incorrect parsing of "open" argument in the Lua runtime.
    • List JavaScript modules if loaded from the default entrypoint in the Console.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.17.0 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-3.6.0-darwin-amd64.tar.gz(12.07 MB)
    nakama-3.6.0-linux-amd64.tar.gz(12.82 MB)
    nakama-3.6.0-linux-arm64.tar.gz(11.64 MB)
    nakama-3.6.0-windows-amd64.tar.gz(10.73 MB)
  • v3.5.0(Aug 10, 2021)

    Notable changes

    Added

    • Handle thrown JS runtime custom exceptions containing a message and a grpc code to be returned in the server response.
    • Add function to retrieve a random set of users to server framework.
    • Add ChannelMessageSend function to server framework.
    • Add BuildChannelId function to server framework.

    Changed

    • Apple Sign-In is now supported across both Web and mobile tokens.
    • Status messages can now be up to 2048 characters (increased from 128 characters).
    • Improved SQL used in unfiltered group listings queries.
    • Throw error instead of panic when attempting to create a group with the system user.
    • Add userId field for permission check in JavaScript/Lua runtimes groupUpdate functions.
    • Allow standard space characters in usernames for direct compatibility with Steam display names.
    • Build with Go 1.16.7 release.
    • Allow batch-only leaderboard and tournament score lookups from the server framework.
    • Return a better error message when single input wallet updates are performed for a user which does not exist.
    • Update to newer Apple guidelines on Game Center root certificate validation in authentication.

    Fixed

    • Fix creator id being read from the wrong argument in JavaScript runtime groupUpdate function.
    • Fix max count being incorrectly validated in groupUpdate JavaScript runtime function.
    • Fix error handling when attempting to write records to a tournament that does not exist.
    • Fix JavaScript runtime missing fields from leaderboards/tournaments get, list, and write functions.
    • Fix JavaScript runtime ownerId field bad parsing in leaderboard/tournament records list functions.
    • Fix parameter usage in leaderboard score set operator.
    • Fix JavaScript runtime storageList not returning a cursor.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.16.0 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-3.5.0-darwin-amd64.tar.gz(12.69 MB)
    nakama-3.5.0-linux-amd64.tar.gz(13.46 MB)
    nakama-3.5.0-linux-arm64.tar.gz(12.05 MB)
    nakama-3.5.0-windows-amd64.tar.gz(11.24 MB)
  • v3.4.0(Jul 8, 2021)

    Notable changes

    Added

    • Add new groupsList runtime function.
    • Add runtime leaderboardList and leaderboardsGetId functions.
    • Add leaderboard/tournament prev_reset field.
    • Add custom metrics runtime functions for counters, gauges, and timers.
    • Add optional override for runtime Apple IAP validation function.
    • Add socket lang parameter to Go runtime contexts.

    Changed

    • Include ticket in party matchmaker add operation responses.
    • Build with Go 1.16.5 release.
    • Replace Bleve gtreap in-memory store implementation with a more compact version.
    • Users kicked from parties now receive a party close event.
    • Log recovered panics in HTTP handler functions at error level rather than info.
    • Add new langTag, members and open filters to the group listing API.
    • Upgrade pgx to v4 for improved SQL performance.
    • Update RegisterLeaderboardReset runtime function signature.
    • Cancel runtime context when graceful shutdown completes.
    • Add button to Nakama Console UI to allow device IDs to be copied.

    Fixed

    • Ensure all members are correctly listed in party info when there are multiple concurrent successful joins.
    • Correctly set party ID in matchmaker matched callback input.
    • Send Party close messages only where appropriate.
    • Fix TypeScript/JavaScript match dispatcher presence list validation.
    • Fix JavaScript/Lua friendsList incorrect returned values.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.15.0 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-3.4.0-darwin-amd64.tar.gz(12.69 MB)
    nakama-3.4.0-linux-amd64.tar.gz(13.46 MB)
    nakama-3.4.0-linux-arm64.tar.gz(12.05 MB)
    nakama-3.4.0-windows-amd64.tar.gz(11.24 MB)
  • v3.3.0(May 17, 2021)

    Notable changes

    Added

    • Tournaments and leaderboards now allow operator scoring to be passed in on updates.
    • Tournaments and leaderboards now support decrement score operator.
    • Add "rpc_id" and "api_id" to the structured logger output in API calls.

    Changed

    • Store email, avatar URL, and display name provided by Apple, Facebook, and Google login providers if empty.
    • Change runtime group add/kick/promote/demote APIs to include optional callerID parameter for permission checking. If the caller ID is an empty string it defaults to the system user.
    • Default to use SSL mode "prefer" in database connections.

    Fixed

    • Fix reading Lua authoritative match states that contain functions.
    • Fix reading JS/TS authoritative match states that contain functions.
    • Use UNIX path representation for embedded migrations and console files on Windows systems.
    • Update Lua VM implementation to resolve nil reference caused after a VM registry resize.
    • Pointerize slice and map types when passed into the JS VM so that they're mutated by reference.
    • Fix off by one error in leaderboard records returned by "around owner" queries.
    • Return null from within JS VM GetMatch function if match does not exist.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.14.0 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-3.3.0-darwin-amd64.tar.gz(12.46 MB)
    nakama-3.3.0-linux-amd64.tar.gz(13.21 MB)
    nakama-3.3.0-linux-arm64.tar.gz(11.84 MB)
    nakama-3.3.0-windows-amd64.tar.gz(11.24 MB)
  • v3.2.1(Apr 18, 2021)

    Notable changes

    Changed

    • A user's online indicator now observes the status mode rather than just socket connectivity.
    • Update sql-migrate library to a32ed26.
    • Rework some migrations for better compatibility with different database engines.
    • Update to Protobuf v1.5.2, GRPC v1.37.0, and GRPC-Gateway v2.3.0 releases.
    • Update to Bleve v2.0.3 release.
    • Various other dependency updates.

    Fixed

    • Fix user scoping in Nakama Console purchase listing view.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.13.1 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-3.2.1-darwin-amd64.tar.gz(12.46 MB)
    nakama-3.2.1-linux-amd64.tar.gz(13.22 MB)
    nakama-3.2.1-linux-arm64.tar.gz(11.86 MB)
    nakama-3.2.1-windows-amd64.tar.gz(11.24 MB)
  • v3.2.0(Apr 14, 2021)

    Added

    • New API to logout and intercept logouts with session and refresh tokens.
    • Add a leave reason to presence events to handle transient disconnects more easily.
    • New API for IAP validation with Apple App Store, Google Play Store, and Huawei AppGallery.

    Changed

    • Improve struct field alignment on types in the social package.
    • Improve memory re-use within the matchmaker and match registry structures.
    • Support Facebook Limited Login tokens received into the standard Facebook login/link/unlink functions.
    • Update JS VM to newer version. This resolves an issue with resizing some JS arrays.
    • Build with Go 1.16.3 release.

    Fixed

    • Matchmaker entries which were only partially matched together could not combine with larger player counts.
    • Fix bad inputs parsed in some before/after hook executions made from the API Explorer in the Console.
    • Correctly return Unix timestamps in JS runtime functions returning users/accounts data.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.13.0 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
  • v3.1.2(Mar 4, 2021)

    Notable changes

    Changed

    • Sort match listings to show newer created matches first by default.
    • Loosen status follow input validation and constraints to ignore unrecognised user IDs and usernames.
    • Build with Go 1.16.0 release.
    • Do not import Steam friends by default on Steam authentication.
    • Do not import Facebook friends by default on Facebook authentication.
    • Improve match label update batching semantics.
    • Account object returned by some JS runtime functions are not flattened with user values anymore.

    Fixed

    • Fix an issue in the JS runtime that would prevent the matchmaker matched callback to function correctly.
    • Allow the console API to return large responses based on the configured max message size.
    • Allow JS runtime initializer functions to be invoked inside a try/catch block.
    • Fix Tournament Reset function hook schedules calcuated on first write if the end active time must be computed with no reset schedule.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.12.1 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
  • v3.1.1(Feb 15, 2021)

    Notable changes

    Changed

    • Go runtime logger now identifies the file/line in the runtime as the caller rather than the logger.
    • Build with Go 1.15.8 release.
    • Use a newer CA certificates package within the Docker containers.

    Fixed

    • Fix an issue that prevented the JavaScript runtime hooks to be invoked correctly.
    • Fix the delete button not working in the console leaderboard listing.
    • GetUsers can fetch user accounts by Facebook ID the same as in the client API.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.12.1 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-3.1.1-darwin-amd64.tar.gz(12.41 MB)
    nakama-3.1.1-linux-amd64.tar.gz(13.31 MB)
    nakama-3.1.1-linux-arm64.tar.gz(11.96 MB)
    nakama-3.1.1-windows-amd64.tar.gz(11.19 MB)
  • v3.1.0(Feb 4, 2021)

    Notable changes

    Added

    • New APIs to import Steam friends into the social graph.

    Changed

    • Improve output of "nakama migrate status" command when database contains unknown migrations.
    • The socket status flag is now parsed as case-insensitive.
    • Build with Go 1.15.7 release.

    Fixed

    • Fix an issue with the JS runtime multiUpdate function.
    • Fix an issue where the JS runtime would call the InitModule function twice.
    • Fix how the JS runtime invokes matchmakerMatched and leaderboard/tournament related hooks.
    • Fix JS VM not being put back into the pool after an RPC call.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.12.0 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-3.1.0-darwin-amd64.tar.gz(12.36 MB)
    nakama-3.1.0-linux-amd64.tar.gz(13.27 MB)
    nakama-3.1.0-linux-arm64.tar.gz(11.92 MB)
    nakama-3.1.0-windows-amd64.tar.gz(11.15 MB)
  • v3.0.0(Jan 16, 2021)

    Notable changes

    This is a major release of the server but is fully backwards compatible with the 2.x releases. Have a look at the release announcement for more details: https://heroiclabs.com/blog/announcements/nakama-3-0/

    Added

    • New JavaScript runtime to write server code.
    • Introduce refresh tokens that can be used to refresh sessions.
    • New Realtime Parties for users to create teamplay in games. Users can form a party and communicate with party members.
    • Add party matching support to the Matchmaker.
    • Add options to the Matchmaker to control how long tickets wait for their preferred match.
    • Add Console UI permissions API.
    • New "ReadFile" runtime function to read files within the "--runtime.path" folder.

    Changed

    • Rebuild Console UI with Angular framework. Manage user data, update objects, restrict access to production with permission profiles, and gain greater visibility into realtime features like active matches.
    • Matchmaker improvements to the process for matching and the handling of player count ranges.
    • Authoritative match handlers can now tick at 60 per second.
    • Support CockroachDB 20.2 release.
    • Build with Go 1.15.6 release.

    Fixed

    • Return rank field in Lua API for leaderboard record writes.
    • Return social fields for users in friend listings.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.11.0 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-3.0.0-darwin-amd64.tar.gz(12.35 MB)
    nakama-3.0.0-linux-amd64.tar.gz(13.24 MB)
    nakama-3.0.0-linux-arm64.tar.gz(11.90 MB)
    nakama-3.0.0-windows-amd64.tar.gz(11.14 MB)
  • v2.15.0(Nov 28, 2020)

    Notable changes

    Added

    • Add cacheable cursor to channel message listings.
    • Add group management functions to the server runtime. Thanks @4726.

    Changed

    • Make metrics prefix configurable and set a default value.
    • Pin the GRPC Go plugin for the protoc compiler with a tool dependency.
    • Build with Go 1.15.5 release.
    • Use the Facebook Graph API v9.0 version.
    • Facebook authentication no longer requires access to gender, locale, and timezone data.
    • Update to Bleve v1.0.13 release.
    • Update to nakama-common 1.10.0 release.
    • Skip logging Lua errors raised by explicit runtime calls to the error({ msg, code }) function.

    Fixed

    • Better handling of SSL negotiation in development with certs provided to the server.
    • Use correct error message and response code when RPC functions receive a request payload larger than allowed.
    • Expose missing 'group_users_kick' function to the Lua runtime.
    • Fix an issue that would cause an error when trying to update a tournament record with invalid data.
    • Fix some issues around listing tournaments.
    • Fix an issue that would prevent the insertion of a record in a tournament with no scheduled reset and end time.
    • Ensure the devconsole applies user password updates even if no other fields change.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.10.0 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-2.15.0-darwin-amd64.tar.gz(10.78 MB)
    nakama-2.15.0-linux-amd64.tar.gz(11.52 MB)
    nakama-2.15.0-linux-arm64.tar.gz(10.42 MB)
    nakama-2.15.0-windows-amd64.tar.gz(9.71 MB)
  • v2.14.1(Nov 2, 2020)

    Notable changes

    Added

    • Event contexts now contain user information for external events.
    • Expose more metrics for socket activity.
    • New Docker release of the server with debug symbols enabled.
    • Add "TournamentRecordsList" and "ListFriends" functions to the Go server runtime.
    • Add "friends_list" and "tournament_records_list" functions to the Lua server runtime.

    Changed

    • Build with Go 1.15.3 release.
    • Update to Protobuf v1.4.3, GRPC v1.33.1, and GRPC-Gateway v2.0.1 releases.
    • Update protocol definitions for OpenAPIv2 code generator.

    Fixed

    • Fix score comparisons on leaderboard record ranks in cache. Thanks @4726.
    • Put "rank" field into results from "tournament_records_haystack" calls in Lua server runtime.
    • Add missing cursor return values from "GroupUsersList" and "UsersGroupList" functions in the Go server runtime.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.9.0 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-2.14.1-darwin-amd64.tar.gz(10.50 MB)
    nakama-2.14.1-linux-amd64.tar.gz(11.22 MB)
    nakama-2.14.1-linux-arm64.tar.gz(10.16 MB)
    nakama-2.14.1-windows-amd64.tar.gz(9.45 MB)
  • v2.14.0(Oct 3, 2020)

    Notable changes

    Added

    • Publish new metric for presences count.
    • Use a "tool dependency" to specify the protoc-gen-go, protoc-gen-grpc-gateway, and protoc-gen-openapiv2 required versions. See here.

    Changed

    • Build with Go 1.15.2 release.
    • Update to Protobuf 1.4.2, GRPC 1.32.0, and GRPC-Gateway 2.0.0-beta.5. This enables us to take advantage of the new Protobuf runtime. See here.
    • Replace shell script with Go generate commands to run protoc toolchain.
    • Update protocol definitions to remove warnings from stricter Go package import paths. See here.
    • Move some Go packages to be internal.
    • Improved rank caching strategy.
    • Separate authentication error response code and message for banned accounts.
    • Pin to an older certs store in the Docker container to work around an issue with GeoTrust certificates.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.8.0 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/nakama-common/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-2.14.0-darwin-amd64.tar.gz(10.50 MB)
    nakama-2.14.0-linux-amd64.tar.gz(11.21 MB)
    nakama-2.14.0-linux-arm64.tar.gz(10.16 MB)
    nakama-2.14.0-windows-amd64.tar.gz(9.45 MB)
  • v2.13.0(Aug 31, 2020)

    Notable changes

    Added

    • Add Sign in with Apple authentication, link, and unlink.
    • Wallet operations now return the previous and updated state of the wallet.
    • New multi-update runtime function to handle batched storage, wallet, and account updates in a single transaction.
    • Groups now have a demote API for convenience.

    Changed

    • Build with Go 1.15.0 release.
    • Sanitize metric names and properties fields.
    • Wallet updates now use int64 values to ensure precision in all numeric operations.
    • Update to nakama-common 1.7.3 release.
    • Optimize how session IDs are stored in presence structs.
    • Friend listings now allow a page size of up to 1000 objects.

    Fixed

    • Prevent bad presence list input to dispatcher message broadcasts from causing unexpected errors.
    • Extra HTTP headers in RPC responses are set before the response is written to the buffer.
    • Fix an issue in the Lua runtime nk module's "jwt_generate" function that would prevent it from accepting a key in RS256 format.
    • Fix an issue in the Lua runtime nk module's "rsaSHA256Hash" function that would prevent it from parsing the input private key.
    • Unmatched routes in the Nakama Console server now return a 404 rather than a 401 response.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.7.3 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-2.13.0-darwin-amd64.tar.gz(10.03 MB)
    nakama-2.13.0-linux-amd64.tar.gz(10.69 MB)
    nakama-2.13.0-linux-arm64.tar.gz(9.70 MB)
    nakama-2.13.0-windows-amd64.tar.gz(9.02 MB)
  • v2.12.0(May 25, 2020)

    Notable changes

    Added

    • Print a log message when all authoritative messages have stopped during graceful shutdown.
    • New option in Lua runtime for read-only globals to reduce memory footprint. This is enabled by default.
    • Separate server config flags for socket read and write buffer sizes.
    • Add user session scoped fields to authoritative match join attempt contexts.
    • Add group ID to content of in-app notifications sent with user changes in groups.
    • New runtime function to get a single match by ID.
    • New runtime functions for link and unlink operations.
    • New Lua runtime function to print a log message at debug level.
    • Add disable time to account get operations in the server runtime.
    • Expose last user relationship update time when listing friends.
    • Expose caller information in logger messages.
    • Expose node name in all runtime contexts.

    Changed

    • Rebuild metrics implementation.
    • Validate GOB encoded authoritative match create parameters.
    • Eliminate user account writes to database if fields have not changed.
    • The gauges in the Developer console status view more accurately reflect current server metrics.
    • Disconnect match participants when a Lua runtime authoritative match ends due to an error.
    • Sort wallet ledger listings by creation time from newest to oldest.
    • Do not update leaderboard and tournament record timestamps when scores have not changed.
    • Build with Go 1.14.3 release.
    • Update to nakama-common 1.5.1 release.

    Fixed

    • Fetch account in Lua runtime function now includes Facebook Instant Game IDs.
    • Don't duplicate runtime environment values in the devconsole configuration view.
    • All low-level channel presence events now populate room, group, and direct message fields.
    • Developer console status graphs correctly show a fixed time window of metrics.
    • Fix friend deletion in developer console user detail view.
    • Fix group membership deletion in developer console user detail view.
    • A user's password is no longer expected when unlinking emails.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.5.1 must be used with this release.

    env GO111MODULE=on go get "github.com/heroiclabs/[email protected]"
    
    Source code(tar.gz)
    Source code(zip)
    nakama-2.12.0-darwin-amd64.tar.gz(10.95 MB)
    nakama-2.12.0-linux-amd64.tar.gz(11.66 MB)
    nakama-2.12.0-linux-arm64.tar.gz(10.68 MB)
    nakama-2.12.0-windows-amd64.tar.gz(9.84 MB)
  • v2.11.1(Mar 29, 2020)

  • v2.11.0(Feb 27, 2020)

    Notable changes

    Added

    • Return tournament end time in listing operations if one exists.
    • Add Facebook Instant Game Authentication.

    Changed

    • Build with Go 1.14.0 release.
    • Update most server dependencies (particularly GRPC, GRPC Gateway, and Protobuf).
    • Upgrade to use nakama-common 1.4.0 release.

    NOTE: For developers who use the Go server runtime support. The nakama-common package at v1.4.0 must be used with this release.

    Source code(tar.gz)
    Source code(zip)
    nakama-2.11.0-darwin-amd64.tar.gz(12.23 MB)
    nakama-2.11.0-linux-amd64.tar.gz(13.08 MB)
    nakama-2.11.0-linux-arm64.tar.gz(11.97 MB)
    nakama-2.11.0-windows-amd64.tar.gz(10.91 MB)
  • v2.10.0(Feb 13, 2020)

    Notable changes

    Added

    • New metric for number of authoritative matches currently running.
    • New metric for total number of events dropped by the events processor pool.

    Changed

    • Build with Go 1.13.7 release.
    • Update username on leaderboard and tournament records when processing a score update.
    • Automatically stop empty authoritative matches after a configurable amount of time.

    Fixed

    • Fix calculation for 'can enter' field for newly created tournaments.
    • Ensure tournament reset callbacks carry the correct ID.
    • Ensure tournament end callbacks carry the correct end and reset times.
    • Expose match stopped state to the Lua runtime match dispatcher.
    • Fix calculation of tournament start active time for schedules with variable active durations.
    Source code(tar.gz)
    Source code(zip)
    nakama-2.10.0-darwin-amd64.tar.gz(12.40 MB)
    nakama-2.10.0-linux-amd64.tar.gz(13.29 MB)
    nakama-2.10.0-linux-arm64.tar.gz(12.14 MB)
    nakama-2.10.0-windows-amd64.tar.gz(11.03 MB)
  • v2.9.1(Jan 14, 2020)

  • v2.9.0(Dec 23, 2019)

    Notable changes

    Added

    • New runtime functions to retrieve tournaments by ID.
    • Allow tournament duration to exceed reset window and cap the duration if it does.
    • Ban group users which prevents them from rejoining or requesting to rejoin.
    • New config parameter for max request message size separate from socket message size limit.

    Changed

    • Do not use absolute path for tini executable in default container entry point.
    • Faster validation of JSON object input payloads.
    • Update IAP validation example for Android Publisher v3 API.
    • Relayed multiplayer matches allow echoing messages back to sender if they're in the filter list.
    • Upgrade Facebook authentication to use version 5.0 of the Facebook Graph API.
    • Upgrade devconsole serialize-javascript (2.1.1) dependency.
    • Ensure authoritative match dispatcher is no longer usable after match stops.
    • Deferred message broadcasts now process just before match ends if match handler functions return an error.

    Fixed

    • Correctly read pagination cursor in notification listings.
    • Group user add no longer sends another channel message when an add operation is repeated.
    • Importing Facebook friends when there are no friends and reset is true now works as expected.

    NOTE For developers who use the Go server runtime support. The nakama-common package at v1.3.0 must be used with this release.

    Source code(tar.gz)
    Source code(zip)
    nakama-2.9.0-darwin-amd64.tar.gz(12.38 MB)
    nakama-2.9.0-linux-amd64.tar.gz(13.25 MB)
    nakama-2.9.0-linux-arm64.tar.gz(12.13 MB)
    nakama-2.9.0-windows-amd64.tar.gz(11.01 MB)
  • v2.8.0(Nov 12, 2019)

    Notable changes

    Added

    • New API for client and runtime events known as event signals.
    • Allow user account password updates from the developer console.

    Changed

    • Default runtime HTTP key value is no longer the same as the default server key value.
    • A group create operation now returns a GRPC Code 6 (HTTP 409 Conflict) when the group name is already in use.
    • Allow Console API requests to return results above default size limit.
    • The presence count is no longer added together across nodes in the status view of the Developer Console.
    • Create tournament operations always returns the existing tournament after repeated calls with the same ID.
    • Upgrade to Go 1.13.4 and use Debian buster-slim for base docker images.
    • Rate limit the maximum number of concurrent leaderboard/tournament callback executions.
    • Allow Go runtime match listing operations min/max count to be optional.

    Fixed

    • Handle (OCC) errors when concurrently writing new storage objects.
    • Fix optimistic concurrency controls (OCC) on individual storage objects under high write contention.
    • Time spent metrics are now correctly reported in milliseconds.
    • Password minimum length error message now correctly reflects the constraint.
    • Set specific response Content-Type header in successful HTTP RPC responses.

    NOTE For developers who use the Go server runtime support. The nakama-common package at v1.2.0 must be used with this release.

    Source code(tar.gz)
    Source code(zip)
    nakama-2.8.0-darwin-amd64.tar.gz(12.36 MB)
    nakama-2.8.0-linux-amd64.tar.gz(13.23 MB)
    nakama-2.8.0-linux-arm64.tar.gz(12.11 MB)
    nakama-2.8.0-windows-amd64.tar.gz(10.99 MB)
  • v2.7.0(Sep 12, 2019)

    Notables changes

    Added

    • Enable RPC functions to receive and return raw JSON data.
    • Status follow operations now also accept usernames to follow.
    • Pagination support for friends listing operations.
    • Filtering by friend state in friends listing operations.
    • Pagination support for group users listing operations.
    • Filtering by user state in group users listing operations.
    • Pagination support for user groups listing operations.
    • Filtering by group state in user groups listing operations.
    • Allow max count to be set when creating groups from client calls.
    • Log better startup error message when database schema is not set up at all.
    • New "check" command to validate runtime modules without starting the server.
    • Add discrete channel identifier fields in all messages and message history listings.
    • Session tokens now allow storage of arbitrary string key-value pairs.
    • New runtime function for programmatic GDPR account data exports.

    Changed

    • Use Go 1.13.0 on Alpine 3.10 as base Docker container image and native builds.
    • Update devconsole lodash (4.17.13), lodash.template (4.5.0), eslint-utils (1.4.1), set-value (2.0.1), and mixin-deep (1.3.2) dependencies.
    • Errors from runtime before hooks no longer close the session.
    • Switch prometheus metrics to use labels instead of a prefix.
    • Add flag on realtime socket messages that will support optional reliability.
    • Friends listing pages are now limited to max 100 results each.
    • Group users listing pages are now limited to max 100 results each.
    • User groups listing pages are now limited to max 100 results each.
    • Group users listing now includes disabled (banned) users.
    • User groups listing now includes disabled groups.
    • Remove hard cap on maximum number of users per group.
    • Return deterministic ordering for edge relationship listings.
    • Return deterministic ordering for storage listing operations.
    • Return deterministic ordering for leaderboard scores where both score and subscore are identical.
    • Consistent default database address between migration command and main server startup.
    • Return deterministic ordering for group listings without filters.

    Fixed

    • Handle updates during leaderboard schedule reset window.
    • Ensure the matchmaker cannot match together tickets from the same session.
    • Handle leaderboard deletes shortly before a scheduled reset.
    • Listing user groups no longer returns an error when the user is a member of zero groups.
    • Go runtime group creation now correctly validates max count.
    • Consistent expiry calculation in leaderboard records haystack queries.
    • Convert custom SQL query and exec parameters to integers when necessary in Lua runtime.
    • Correctly validate users before adding them to groups.
    • Add missing group chat channel message when a user joins the group.
    • Add missing group chat channel message when a user leaves the group.
    • Add missing group chat channel message when a user is added to the group.
    • Add missing group chat channel message when a user is kicked from the group.
    • Add missing group chat channel message when a user is promoted in the group.
    • Handle TIMESTAMPTZ return types in Lua runtime custom SQL queries.
    • Use consistent upper bound for authoritative match label size.

    NOTE: The Go 1.13 release has changed how we build the the server so it can accommodate Go modules for dependency resolution with the builtin Go server runtime. We recommend Go modules be used to manage dependencies on projects which use the Go runtime moving forwards.

    Source code(tar.gz)
    Source code(zip)
    nakama-2.7.0-darwin-amd64.tar.gz(12.35 MB)
    nakama-2.7.0-linux-amd64.tar.gz(13.24 MB)
    nakama-2.7.0-linux-arm64.tar.gz(12.10 MB)
    nakama-2.7.0-windows-amd64.tar.gz(10.97 MB)
  • v2.6.0(Jul 1, 2019)

    Notable changes

    Added

    • Explicitly set cache control header in all API responses.
    • Add support for CockroachDB 19.1.
    • Add tournament start active timestamp to the API response.
    • Add overridable expiry time when listing leaderboard/tournaments records.

    Changed

    • Tournament start time can be set to past time.
    • Update GRPC (1.21.1), GRPC-Gateway (1.9.2), Protobuf (1.3.1), Mux (1.7.2), and OpenCensus (0.22.0) dependencies.
    • Use Go 1.12.6 as base Docker container image and native builds.
    • Move from dep to Go modules for dependency management.
    • Switch database driver from pq to pgx.
    • Update devconsole handlebars (4.1.2) and js-yaml (3.13.1) dependencies.
    • Update community link in console sidebar.

    Fixed

    • Fix delayed first time invocation of tournament and leaderboard callbacks.
    • Expired tournaments will no longer be listed nor any records will be returned.
    • Unlink device identifiers on console user account details page.
    • Add missing index drop on migrate down.
    • Handle query and parameter resets on wallet update retries.
    • Reset list of friend IDs in Facebook import when retrying the operation.
    • Reset notifications in friend add when retrying the operation.
    • Do not return storage list cursor unless there are further objects.
    • Attempt fast user and storage count on partitioned tables in console API.
    Source code(tar.gz)
    Source code(zip)
    nakama-2.6.0-darwin-amd64.tar.gz(12.33 MB)
    nakama-2.6.0-linux-amd64.tar.gz(13.12 MB)
    nakama-2.6.0-linux-arm64.tar.gz(12.00 MB)
    nakama-2.6.0-windows-amd64.tar.gz(10.98 MB)
  • v2.5.1(May 3, 2019)

    Notable changes

    Changed

    • Storage object get operations now also return the user ID if the owner is the root user.
    • Status view on console no longer refreshes if server is not reachable.
    • Adjust default socket ping and pong heartbeat frequency.

    Fixed

    • Display updated counters on console status page.
    • Render friend names on console user details page.
    • Render group names on console user details page.
    • Do not attempt to navigate to groups from console user details page.
    • Render changed wallet value after update on console user details page.
    • Display custom ID, email, and verification time on console user details page.
    • Add missing placeholder text to fields on console user details page.
    • Re-render the console storage view when deleting records.
    Source code(tar.gz)
    Source code(zip)
    nakama-2.5.1-darwin-amd64.tar.gz(11.48 MB)
    nakama-2.5.1-linux-amd64.tar.gz(12.19 MB)
    nakama-2.5.1-linux-arm64.tar.gz(11.17 MB)
    nakama-2.5.1-windows-amd64.tar.gz(10.24 MB)
Owner
Heroic Labs
Social infrastructure for games and apps.
Heroic Labs
This is a list of different open-source video games and commercial video games open-source remakes.

This is a list of different open-source video games and commercial video games open-source remakes.

Ivan Bobev 79 Jun 27, 2022
Realtime strategy game for Gameboy Advance

Skyland Overview A Gameboy Advance game created, frantically, for a game jam, in about twenty days. A simple realtime strategy game where you build fl

Evan Bowman 27 May 20, 2022
Dedicated Game Server Hosting and Scaling for Multiplayer Games on Kubernetes

Agones is a library for hosting, running and scaling dedicated game servers on Kubernetes. Agones, is derived from the Greek word agōn which roughly t

GoogleForGames 4.6k Jun 28, 2022
HEX LINK - A Distributed Somatosensory Interaction Device

HEX LINK - A Distributed Somatosensory Interaction Device 介绍 HEX LINK: Higher-order EXcess LINK 这是一套可适用于PC端游戏的体感操作设备。 项目演示视频链接: 【开源·自制】真正的体感"只狼"_哔哩哔哩_

JingYang 216 Jun 25, 2022
OGRE is a scene-oriented, flexible 3D engine written in C++ designed to make it easier and more intuitive for developers to produce games and demos utilising 3D hardware.

OGRE (Object-Oriented Graphics Rendering Engine) is a scene-oriented, flexible 3D engine written in C++ designed to make it easier and more intuitive for developers to produce games and demos utilising 3D hardware. The class library abstracts all the details of using the underlying system libraries like Direct3D and OpenGL and provides an interface based on world objects and other intuitive classes.

null 2.8k Jun 29, 2022
A multi core friendly rigid body physics and collision detection library suitable for games and VR applications.

Jolt Physics Library A multi core friendly rigid body physics and collision detection library suitable for games and VR applications. A YouTube video

null 1.8k Jun 27, 2022
3D games console based on RP2040 and iCE40 UP5k

PicoStation 3D This is an unfinished, untested project to develop a 3D games console based on an RP2040 microcontroller and an iCE40 UP5k FPGA. Quick

Luke Wren 35 Jun 5, 2022
A set of libraries and tools to make MSX games using the C programming language.

ubox MSX lib This is a set of libraries and tools to make MSX games using the C programming language. There are three main components: ubox: thin wrap

Juan J. Martínez 42 May 30, 2022
TIC-80 is a fantasy computer for making, playing and sharing tiny games.

TIC-80 is a fantasy computer for making, playing and sharing tiny games.

Vadim Grigoruk 3.5k Jun 27, 2022
Enfusion Artifical Intelligence for DayZ and future Bohemia Interactive games.

Enfusion AI Project (eAI) This mod adds headless player units under the control of a script on the server. Although the script is very rudimentary now

William Bowers 55 Jun 13, 2022
Game engine behind Sea Dogs, Pirates of the Caribbean and Age of Pirates games.

Game engine behind Sea Dogs, Pirates of the Caribbean and Age of Pirates games.

Storm Devs 633 Jun 27, 2022
Project DELTA - An open-source trainer built on the Void Engine for Toby Fox's games and their spin-offs.

Project DELTA v3 Project DELTA - An open-source, modular mod menu for Toby Fox's games and their spin-offs. Important note to Grossley: Yes, it is out

Archie 7 Apr 20, 2022
Graphical improvements mod for Hyperdimension Neptunia Re;Birth1, Re;Birth2 and Re;Birth3 games.

Neptastic Mod Graphical improvements mod for Hyperdimension Neptunia Re;Birth1, Re;Birth2 and Re;Birth3 games. Features: Resolution upscaling and down

tlaik 28 May 23, 2022
Dragon's Dice Roller aims to be a lightweight, simple, reliable and easy-to-use dice roller for RPG games.

Dragon's Dice Roller is the first and (so far the only) open source RPG dice roller written in C available on GitHub. It aims to be a lightweight, simple, reliable and easy-to-use dice roller for any kind of role-playing game.

Michael Kolesidis 10 Apr 22, 2022
YYToolkit is a tool for creating mods and altering GameMaker games.

YYToolkit is a tool for creating mods and altering GameMaker games.

Archie 29 Jun 10, 2022
GRawInput is a modification for games "Gothic" and "Gothic 2"

GRawInput GRawInput is a modification for games "Gothic" and "Gothic 2" that change old deprecated DirectX7 Direct Input Keyboard and Mouse interface

Jakub 2 Jan 24, 2022
A CTRPF plugin for the Nintendo 3DS Pokémon games in which, supports both the 6th and 7th generations.

Multi-Pokémon Framework Multi-Pokémon Framework is a Pokémon plugin developed by Jared0714 that is based off of Nanquitas' CTRPluginFramework. This pl

null 21 Jun 6, 2022
An Unreal Engine 4 silent aim method, not usable on all games. Tested on Fortnite, Rogue Company, Bloodhunt, and Splitgate.

UE4-Silent-Aim An Unreal Engine 4 silent aim method, not usable on all games. Only tested on Fortnite, Rogue Company, Bloodhunt, and Splitgate. Done t

null 35 Jun 26, 2022
This is netvars, interfaces and class ids dump from Valve's Source2 Engine games

About this This is netvars, interfaces and class ids dump from Valve's Source2 Engine games: Artifact Classic Artifact Foundry Dota 2 Dota Underlords

Dmitry 9 May 24, 2022