# go-ibax: a Go blockchain platform where you define contracts, tables and pages in one language

> IBAX-io/go-ibax is a Go node that bundles smart contracts, database tables and a web interface into a single simplified language. It is for teams that want to run their own network rather than deploy onto someone else's chain.

**IBAX-io/go-ibax** — An innovative Blockchain Protocol Platform, which everyone can deploy their own applications quickly and easily, such as Dapp, DeFi, DAO, Cross-Blockchain transactions, etc. 

- Repository: https://github.com/IBAX-io/go-ibax
- Website: https://ibax.io
- Stars: 7,850 · Forks: 6,367
- Language: Go
- License: Apache-2.0
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/ibax-io-go-ibax

## Who go-ibax is aimed at, and what it refuses to hide

Most blockchain frameworks ask you to pick a layer: a virtual machine for contracts, a separate store for state, a separate front end for users. go-ibax collapses those into one system. The README describes it as a platform "including smart contract, database table and interface", and the description extends the target to Dapp, DeFi, DAO and cross-blockchain transactions. The practical audience is a team that wants its own network with its own rules, not a team that wants to rent space on an existing public chain.

The repository layout supports that reading. cmd/ holds the command-line entry points, packages/ holds the node logic, tools/ holds auxiliary programs, and main.go plus build.sh produce a binary called go-ibax. There is no hosted control plane in the tree. If you adopt this, you operate the node. That is the trade: control over the rules in exchange for owning the operational work.

## The mechanism: one binary, a PostgreSQL-backed state, and a contract language

go-ibax compiles to a single command, go-ibax, that carries subcommands for configuration, key generation, genesis creation, database initialisation and running the node. The README's run sequence is short and sequential, which tells you the architecture is a conventional node plus a relational store rather than an embedded database.

The dependency list confirms the store. go.mod requires gorm.io/gorm and gorm.io/driver/postgres, so the node persists state through GORM into PostgreSQL. It also pulls github.com/syndtr/goleveldb, a LevelDB binding, so there is a second local store in play for data that does not belong in the relational tables. Networking and API surface come from gorilla/mux and gorilla/handlers, with github.com/gorilla/schema for request decoding and github.com/didip/tollbooth for rate limiting. Configuration is read through viper and cobra drives the CLI.

Cryptography is not homegrown: btcd, btcec/v2, btcutil and decred's secp256k1 are all in the require block, alongside tjfoc/gmsm for SM-series algorithms used in Chinese standards. That mix is a signal about intended deployment regions. The contract and interface layer is the part the README names but does not specify in detail; the repository does not include a language reference in the top-level files, so treat the contract language as something you learn from the project's documentation site rather than from the README.

## Building go-ibax from source on a machine you control

The README requires Go 1.17 or higher, while go.mod declares go 1.20. Building with a toolchain older than 1.20 will fail on the module directive, so use 1.20 or newer. The README also suggests adding Go's bin directories to PATH.

```bash
export PATH=$PATH:/usr/local/go/bin
export PATH=$PATH:$GOPATH/bin
```

The README's compile steps set a module proxy and tidy the module graph before building. Note that the README and the Makefile disagree on the proxy host: the README uses athens.azurefd.net, the Makefile exports goproxy.io. Either works if it is reachable from your network.

```bash
export GOPROXY=https://athens.azurefd.net
GO111MODULE=on go mod tidy -v
go build
```

After go build completes you should have a go-ibax executable in the working directory. The Makefile offers the same path through make build, which calls build.sh.

## A first real network: config, keys, genesis, database, start

The README's run section is the shortest honest tutorial in the repository. Five commands take you from an empty machine to a running node. First it creates the node configuration file.

```bash
go-ibax config
```

Then it generates the node's keys.

```bash
go-ibax generateKeys
```

Genesis creation is where the README is unusually blunt. It states that if you are creating your own blockchain network you must pass --test=true, otherwise you will not be able to create new accounts.

```bash
go-ibax generateFirstBlock --test=true
go-ibax initDatabase
go-ibax start
```

initDatabase is the step that expects PostgreSQL to be reachable and configured; the README does not spell out the connection settings here, so read the generated configuration file before running it. The Makefile packages a shortcut for the same flow under a try target, which runs go build, then generateFirstBlock --test=true, then initDatabase, then start. That target is the fastest way to see whether the whole chain of steps works on your machine, but it is a development convenience, not a deployment procedure.

## The --test=true flag is a real constraint, not a footnote

The README's warning that account creation depends on --test=true is the single most consequential sentence in the document. It means the genesis path documented for self-hosted networks is the test path. A team that generates a first block without that flag, expecting a production network, is told by the README that it will not be able to create new accounts. Whether a separate production genesis procedure exists is not stated in the README, and the top-level files do not document one.

There is a second gap: the README documents no rollback, no backup procedure and no upgrade path for an existing chain. The Makefile has an init target that calls initDatabase, which suggests re-initialisation is a normal operation during development, but nothing in the repository describes what happens to existing state when you run it against a populated database. Treat database lifecycle as your responsibility and test it on disposable data first.

A third limitation is environmental. The node needs PostgreSQL and a Go build toolchain, and the README's build instructions assume you are comfortable exporting proxy variables and running go mod tidy. If your team has no Go engineers, the maintenance cost is not the chain, it is the build.

## How go-ibax differs from a general-purpose smart contract chain

The obvious comparison is a Go-based contract platform such as Hyperledger Fabric, or a general-purpose chain with an EVM. The difference is where the application boundary sits. On an EVM chain you write contracts in Solidity, store state in the contract's own storage, and build the user interface somewhere else entirely. go-ibax's README describes contracts, database tables and interface as one package delivered through a simplified language, so the platform expects to own more of the stack.

Fabric is the closer analogue in deployment terms: both are Go projects, both expect you to run nodes yourself, and both are aimed at networks where the operator sets the rules. The divergence is the data model. Fabric's ledger is a key-value world state behind chaincode; go-ibax routes state through GORM into PostgreSQL, which means the people who already know SQL can inspect and query the node's tables directly. That is convenient for operations and awkward for anyone who expects the ledger to be the only source of truth.

If your requirement is to reach users on a large public network with existing wallets and tooling, none of these self-hosted options is the right shape. go-ibax is for a network you define.

## Conclusion

Adopt go-ibax if you need a permissioned or application-specific chain and you are willing to run the node yourself from source; the README's own sequence (generateKeys, generateFirstBlock --test=true, initDatabase, start) is the whole path to a working network. Do not adopt it if you want a managed endpoint or a large public developer ecosystem, because the repository ships a node binary and a build script, not a hosted service. Verify first that you can compile with the Go version your toolchain provides, that PostgreSQL is reachable for initDatabase, and that the --test=true flag is acceptable for the network you intend to create, since the README ties account creation to that flag.

## FAQ

### What Go version does go-ibax need to build?

The README states the build requires Go 1.17 or higher, but go.mod declares go 1.20, so a toolchain at 1.20 or newer is the safe choice. Building with an older toolchain will fail on the module directive.

### Why does go-ibax say I must use --test=true when generating the first block?

The README states that if you are creating your own blockchain network you must use the --test=true option, otherwise you will not be able to create new accounts. It does not document a separate production genesis procedure.

### Which database does go-ibax store its state in?

go.mod requires gorm.io/gorm and gorm.io/driver/postgres, so the node persists state through GORM into PostgreSQL, and it also depends on goleveldb for a local store. The README's initDatabase step is the one that initialises the database.

### How do I go from a fresh clone to a running go-ibax node?

The README's sequence is go-ibax config, then go-ibax generateKeys, then go-ibax generateFirstBlock --test=true, then go-ibax initDatabase, then go-ibax start. The Makefile packages the same flow under a try target.

## Sources

- [IBAX-io/go-ibax on GitHub](https://github.com/IBAX-io/go-ibax)
- [License: Apache-2.0](https://github.com/IBAX-io/go-ibax/blob/main/LICENSE)
- [Project website](https://ibax.io)
- [README](https://github.com/IBAX-io/go-ibax/blob/main/README.md)
- [Releases](https://github.com/IBAX-io/go-ibax/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ibax-io-go-ibax