Getting Started with Dubhe

Your journey to building fully on-chain applications starts here

🚀 Getting Started with Dubhe

Transform your ideas into fully on-chain applications - from zero to deployed in under 30 minutes

🌟 What is Dubhe Engine?

Dubhe Engine is the ultimate open-source framework for building lightning-fast, fully on-chain Move applications. It revolutionizes blockchain development with its innovative Entity Component System (ECS) architecture and schema-driven development approach.

ECS Architecture

Scalable Design: Build complex applications with modular, composable components

Schema-Driven

Type Safety: Define once, generate everywhere - from contracts to frontend

Multi-Chain

Universal: Deploy to Sui, Aptos, Rooch, and Initia with the same codebase

🎯 Choose Your Learning Path

🎓 New to Blockchain

Perfect for beginners • Start with blockchain fundamentals and Move language basics

⚡ Experienced Developer

Jump right in • Fast-track to building with Dubhe Engine

🎮 Game Developer

Learn by building • Create a complete on-chain RPG game

📚 Reference Docs

Quick lookup • Complete API reference and technical documentation

🚀 Quick Setup (5 Minutes)

1. Install Prerequisites

   # Install Node.js 18+ and pnpm
   curl -fsSL https://get.pnpm.io/install.sh | sh -
   
   # Install Sui CLI (for Sui development)
   cargo install --locked --git https://github.com/MystenLabs/sui.git --branch mainnet sui
   
2. Create Your First Project

   pnpm create dubhe my-first-dapp
   cd my-first-dapp
   
3. Start Development

   # Start local blockchain
   pnpm run dev:node
   
   # In another terminal, deploy contracts
   pnpm run deploy:local
   
   # Start frontend
   pnpm run dev
   

📚 Essential Concepts

Entity Component System (ECS)

What is ECS?

ECS is a software architecture pattern that separates data (Components) from logic (Systems) and uses Entities as unique identifiers. This pattern is widely used in game development for its performance and flexibility.

In Dubhe:

• Entities: Unique IDs representing objects in your application
• Components: Data structures attached to entities (health, position, inventory)
• Systems: Functions that process components and implement game logic

Schema-Driven Development

What are Schemas?

Schemas define the structure of your on-chain data. Dubhe uses these definitions to automatically generate:

• Move smart contracts
• TypeScript interfaces
• Client SDK methods
• Database indexes

This ensures type safety from your smart contracts all the way to your frontend.

Fully On-Chain Architecture

What does “Fully On-Chain” mean?

In a fully on-chain application:

• All game logic executes on the blockchain
• All state is stored on-chain
• Every action is verifiable and permanent
• No centralized servers required

This provides true ownership, composability, and persistence for your applications.

🛠️ Development Tools

CLI

# Project management
dubhe new <project-name>      # Create new project
dubhe build                    # Build contracts
dubhe deploy                   # Deploy to network
dubhe migrate                  # Run migrations

# Schema management
dubhe schema generate          # Generate code from schemas
dubhe schema validate          # Validate schema definitions

# Development
dubhe dev                      # Start dev environment
dubhe test                     # Run tests
dubhe console                  # Interactive console

SDK

import { DubheClient } from '@0xobelisk/dubhe-client';

// Initialize client
const client = new DubheClient({
  network: 'testnet',
  packageId: 'YOUR_PACKAGE_ID'
});

// Read component data
const player = await client.getComponent('PlayerComponent', entityId);

// Execute system function
await client.tx.playerSystem.move({
  direction: 'north',
  distance: 10
});

// Subscribe to events
client.on('PlayerMoved', (event) => {
  console.log('Player moved:', event);
});

Testing

import { TestClient } from '@0xobelisk/dubhe-test';

describe('Game Logic', () => {
  let client: TestClient;
  
  beforeEach(async () => {
    client = await TestClient.setup();
  });
  
  it('should damage player', async () => {
    const player = await client.createEntity('Player');
    await client.tx.combatSystem.damage({
      target: player,
      amount: 10
    });
    
    const health = await client.getComponent('HealthComponent', player);
    expect(health.value).toBe(90);
  });
});

🎓 Learning Resources

Video Tutorials

Step-by-step video guides for visual learners

Example Projects

Full source code for reference applications

Community Forum

Get help and share your projects

🤝 Get Help

Need assistance? We’re here to help!

• 💬 Discord Community - Get real-time help
• 📖 GitHub Discussions - Ask questions
• 🐛 Report Issues - Found a bug?
• 📧 Email Support - Direct support

🚦 Next Steps

1. Complete the Quickstart

   Follow our comprehensive quickstart guide to understand core concepts

2. Build Your First DApp

   Create a simple counter application to learn the basics

3. Explore Advanced Features

   Dive into advanced tutorials for complex applications

4. Join the Community

   Connect with other developers and share your creations