Dubhe is an open-source toolchain for developers who build decentralized applications on the Sui blockchain using the Move language. It is aimed at developers who want to go from a blank project to a deployed, queryable DApp without wiring together storage, indexing and client code by hand.
The project is positioned as an engine for building intent-centric applications. Its version 2.0.0 is described as running in production on Sui testnet and mainnet, and its latest code update is dated July 2, 2026, so the project is actively maintained. Because Dubhe is a developer framework rather than an end-user application, most of its value shows up in code and in the way it structures data, not in a graphical interface.
What Problem Does Dubhe Solve?
Building a decentralized application usually means solving the same problems again and again. You need a way to store global state, store per-user state, index events so the front end can read them quickly, and keep the client code in sync with the contracts. Each of these pieces is a project in itself.
Dubhe bundles these layers into one toolchain. The on-chain framework handles storage, the indexer handles querying, and the SDKs handle the client side. The goal is to shorten the path from an idea to something users can interact with.
The project's own description puts the timeline at hours rather than weeks, which is a claim worth testing against your own skill level and scope. A simple app with a few tables of data will move faster than a complex game with many interacting systems.
Who Is Dubhe For?
Dubhe is aimed at developers, not casual crypto users. You should be comfortable with a command line, a JavaScript or TypeScript project setup, and at least the basic ideas of smart contracts and blockchain transactions. Familiarity with React helps if you plan to use the included hooks.
Typical users are small teams building onchain games, marketplaces, social features or other interactive apps on Sui. Developers who want to explore the Move ecosystem more broadly may also look at the multi-chain client support, although the depth of support on each network is something to verify in the documentation.
If you only want to trade tokens or manage a wallet, Dubhe is not relevant to your needs. It is a build tool, not a consumer product.
How the Layers Fit Together
It helps to think of Dubhe as three cooperating parts. The first is the Move framework on chain, which defines how data is stored and who may change it. The second is the indexer, which watches the chain for events and writes them into PostgreSQL so they can be queried through GraphQL or gRPC. The third is the client side, made of TypeScript SDKs and React hooks, which reads from the indexer and sends transactions to the chain.
Because the schema lives in a single configuration file, a change to your data model can propagate to the typed client code. This is the main reason the framework emphasizes code generation: it keeps the on-chain model, the database and the front end from drifting apart.
For teams running their own infrastructure, the indexer and PostgreSQL database are a real operational responsibility. You will need to host them, monitor them and handle upgrades, so factor that into planning.
Why Session Keys Matter for Games and Apps
Every blockchain transaction normally requires the user to approve a signature in their wallet. For a turn-based game or a social app where users take many small actions, that approval step quickly becomes friction. Session keys address this by letting the user grant an application temporary, limited permission to sign on their behalf.
In practice, a user might approve a session once, and the app can then submit a series of actions silently within the limits the session allows. The design of those limits is important: a well-scoped session should only cover the actions the app really needs, and users should understand what they have approved.
Developers should treat session keys as a security-sensitive feature. Test how sessions expire and how they are revoked before using them in production.
Key features
Move-based, production-ready on Sui
Three-tier storage model
Session keys for delegated signing
Built-in marketplace and reactive writes
ECS world client and React hooks
Rust indexer with GraphQL and gRPC
Type-safe SDKs and code generation
Logic upgrades and data migration
Multi-Move ecosystem clients
Supported coins
Dubhe's documentation references Sui and Aptos as supported networks. Sui is the primary target, with version 2 described as running on its testnet and mainnet. Client support is also listed for Movement, Rooch and Initia, so check the documentation for the current state of each integration before building on one of them.
How to install Dubhe on Windows
- 1
Check your environment
Install Node.js and a package manager such as pnpm, since the project starter is created with pnpm. You will also need a working Rust toolchain if you plan to run or build the indexer, and PostgreSQL for the indexer's database. Confirm these are installed and accessible from your terminal before continuing.
- 2
Get the source or the starter
The official route is the project's documentation and its GitHub repository at github.com/0xobelisk/dubhe. Use the starter command shown in the documentation to scaffold a new project, or clone the repository if you want the full toolchain source. Only download from the official site or GitHub.
- 3
Install dependencies
Move into the project folder and install the JavaScript dependencies with pnpm. This pulls in the SDKs and build tools that the generated code depends on.
- 4
Build and run the components
Follow the documentation to build the Move packages, start the indexer against a local or test network, and launch the example front end. Running against a testnet first lets you confirm everything works before you spend real tokens on deployments.
-
Verify and keep up to date
Check checksums or release signatures when they are published, and watch the repository's release notes for updates, since version 2 introduced changes to the storage model and upgrade tooling.
How to use Dubhe
Dubhe is used from the developer's side, so the workflow is a project workflow rather than opening an application and clicking through menus. Once the starter project is set up, the typical loop looks like this.
- Define your data model in the dubhe.config.ts file, describing the tables and the storage tier each one belongs to.
- Generate the typed SDK code from that configuration so your front end and contracts share the same types.
- Write or adjust the Move logic that reads and changes the data, including any session-based or reactive behavior you need.
- Deploy the Move packages to a Sui testnet first and confirm transactions behave as expected.
- Start the indexer so events are written into PostgreSQL and become available through GraphQL and gRPC queries.
- Connect the React front end with the provided hooks, testing reads and writes against the indexed data.
- When the logic changes, use the upgrade and migration tooling so existing stored data is carried over correctly.
- Promote the same process to mainnet once the testnet behavior matches your expectations.
Pros & cons
- Covers the full stack: on-chain storage, indexing and client SDKs in one toolchain
- Version 2 is described as running in production on Sui
- Type-safe code generation reduces integration errors
- Session keys support smoother user experiences in interactive apps
- Includes tooling for logic upgrades and data migration
- Free and open source with the code publicly available on GitHub
- Aimed at developers, so it offers no value to end users without coding
- Requires knowledge of Move, Rust, TypeScript and PostgreSQL
- Running the indexer adds operational work for hosting and monitoring
- Multi-chain support varies in depth, so each network needs separate verification
- The claim of working apps in hours depends heavily on the project's complexity
Is Dubhe safe?
Dubhe is open-source code, so you can inspect it before use, which is an advantage. Download the source only from the official GitHub repository or the documentation site, and check release signatures or checksums when the maintainers publish them. Do not run starter scripts or dependencies pulled from unofficial mirrors or forks.
Be careful with keys. Anything that signs transactions can move funds if misconfigured, so keep deployment keys separate from test keys and never paste a seed phrase into a project file or a third-party website. Session keys in particular should be scoped narrowly and tested for expiry and revocation.
Because this is developer software, the main risks are supply-chain issues from dependencies and bugs in your own contract logic. Audit your Move code before deploying anything that holds user value, and use testnet extensively first.
- Official source only. Download from github.com/0xobelisk/dubhe. Ignore ads and lookalike domains.
- Check the SHA-256. Compare the installer hash with the value the developer publishes before running it.
- Never share your seed phrase. No developer, support agent or website — including CryptApps — will ever ask for it.
Alternatives
Dubhe sits in a different place from most tools in this catalog. Chainhook is a reorg-aware indexing engine for Stacks and Bitcoin, so it covers the indexing layer for a different chain family. Bitcoin Database Generator exports Bitcoin blockchain data into SQL Server, and BX is a command-line tool for Bitcoin. Cshtop is a terminal visualizer for Cosmos blocks, and Flowdepth is a desktop order-flow terminal for trading analysis.
The key distinction is scope. Dubhe is a full development toolchain for building Move applications on Sui, combining contract framework, indexer and SDKs. Several of the alternatives are single-purpose tools for reading or displaying chain data, which is useful if you just need to analyze a network without building an application on it.
If your goal is to build a DApp, Dubhe is the more complete option here. If you only need to explore or export blockchain data, a dedicated explorer or indexer may be simpler.
Specifications
- Price
- Free
- Type
- Open source
- License
- —
- Latest version
- v2.0.0
- Last update
- 2 Jul 2026
- Windows support
- Likely (builds for Windows; check releases)
- Source code
- github.com/0xobelisk/dubhe
Frequently asked questions
Yes, Dubhe is listed as free and open source. The code is available on GitHub, so you can use it without paying a license fee. Any costs you incur will come from network transactions when you deploy to Sui and from hosting your own indexer and database.
Windows support is listed as likely, since the project includes builds for Windows, but you should check the releases page for the current status. Many developers run such toolchains through WSL, which can make setup of Rust and PostgreSQL more predictable.
The main target is Sui, where version 2 is described as running on testnet and mainnet. The documentation also mentions Aptos, and client support is listed for Movement, Rooch and Initia. Check the documentation for how complete each of those integrations is.
Yes, the on-chain part of Dubhe is written in Move, so you need to understand Move to customize contract logic. You can use the TypeScript SDKs and React hooks without deep Move knowledge for simple reads and writes, but building real application logic requires learning the language.
The indexer watches chain events and stores them in PostgreSQL, then exposes them through GraphQL and gRPC. This lets your front end query data quickly without reading everything directly from the blockchain, which is important for responsive DApps.
It is open-source and developed in public, which makes it easier to review. Download only from the official GitHub repository or documentation site, verify checksums or signatures where available, and test thoroughly on testnet before deploying anything that handles real funds.
The project says a deployed, queryable DApp is possible in hours. That estimate suits a small app with a simple data model. A complex application with many interacting systems, custom logic and thorough testing will take considerably longer.
Yes, Dubhe includes tooling for logic upgrades and data migration. This is meant for applications that change over time, so that stored data can be carried forward when the contract code evolves.
Verdict
Dubhe suits developers who want a complete, typed toolchain for building Move applications on Sui. Its strengths are the combination of on-chain storage, a queryable indexer and generated SDKs, plus support for session keys and upgrades. It is not a consumer product, and it asks for real development skill. If you are building an interactive DApp and can commit time to learning the stack, it is worth evaluating against the documentation on testnet.