> ## Documentation Index
> Fetch the complete documentation index at: https://dubhe.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Dubhe Engine Quick Start - Build Your First On-Chain App in Minutes
> Get started with Dubhe Engine in under 10 minutes. Learn to build scalable, fully on-chain applications using ECS architecture and Move smart contracts.
🚀 Developer Guide
Master the art of building fully on-chain applications with Dubhe Engine
**Prerequisites:** Basic knowledge of blockchain concepts and TypeScript/JavaScript programming
## What is Dubhe Engine?
Community-driven development with full transparency and collaboration
Optimized for real-time applications with minimal latency
Built specifically for the Move ecosystem and its unique capabilities
Battle-tested in production with enterprise-grade reliability
## 🏗️ Core Architecture
Dubhe uses the **Entity Component System (ECS)** pattern - the same architecture powering AAA game engines like Unity DOTS and Unreal Engine
**Unique identifiers** for objects in your application world
**Data containers** that store entity attributes and state
**Logic processors** that transform component data
ECS provides several advantages for on-chain applications:
* **Performance**: Data-oriented design optimizes for cache efficiency
* **Flexibility**: Mix and match components to create complex behaviors
* **Modularity**: Systems are independent and composable
* **Scalability**: Easily handle thousands of entities
## 💻 Development Workflow
```javascript theme={null}
// dubhe.config.js
export default {
schemas: {
components: [
{
name: "PlayerComponent",
fields: {
health: "u64",
level: "u8",
experience: "u64",
name: "string"
}
},
{
name: "InventoryComponent",
fields: {
items: "vector",
capacity: "u32"
}
}
]
}
}
```
```move theme={null}
module game::player_component {
struct PlayerComponent has store, drop {
health: u64,
level: u8,
experience: u64,
name: String
}
public fun new(...): PlayerComponent { ... }
public fun get_health(...): u64 { ... }
public fun set_health(...) { ... }
}
```
```typescript theme={null}
interface PlayerComponent {
health: bigint;
level: number;
experience: bigint;
name: string;
}
const player = await client.getComponent(
'PlayerComponent',
entityId
);
```
Use the CLI to generate type-safe Move code:
```bash theme={null}
dubhe generate
```
Write game logic in Move:
```move theme={null}
public entry fun level_up(player: &mut PlayerComponent) {
assert!(player.experience >= required_exp(player.level), EInsufficientExp);
player.level = player.level + 1;
player.experience = 0;
}
```
Connect your UI with the TypeScript client:
```typescript theme={null}
const playerData = await client.getComponent({
entity: playerId,
component: 'PlayerComponent'
});
await client.tx.player_system.level_up({ player: playerId });
```
## Key Features
Define your application's data structure with schemas that automatically generate Move contracts and TypeScript types.
Built-in subscriptions keep your frontend synchronized with on-chain state changes in real-time.
Entity Component System design enables scalable, maintainable game logic that can handle complex interactions.
All game state and logic runs on-chain, ensuring transparency, composability, and true ownership.
## Getting Started
Choose your path based on your experience:
New to Dubhe? Start here with a simple example project.
Learn to build Move contracts step-by-step.
Integrate Dubhe with your frontend application.
Explore the blockchain operating system.
## Community and Support
Join our developer community
Contribute to the project
See example applications
**Ready to build?** Follow our [Quick Start guide](/dubhe/sui/quick-start) to create your first Dubhe application in minutes.