// ENGINE · FINGERENGINE

FingerEngine Game Engine

A lightweight mini-game engine layered deeply on Cocos Creator 3.8.8, distilling years of R&D into a clean, testable, AI-friendly foundation. One codebase covering WeChat, Douyin, Kuaishou, App, and Web.

// OVERVIEW

Why We Built Our Own Engine

The pain of mini-game development isn't "can't write the gameplay" — it's reinventing the wheel on every project: platform differences, asset pipelines, hot updates, multiplayer sync, UI binding… each one is enough to bog a team down.

FingerEngine folds Cocos Creator's capabilities into a reusable architecture, letting designers, engineers, and artists work in parallel on a stable foundation and leave their energy for the gameplay itself.

▍Entity-Component-System (ECS) composable architecture, decoupling logic from presentation
▍MVVM-driven UI layer with data binding out of the box
▍Hot updates and a remote asset pipeline — iterate without waiting for review
▍Both lockstep and state-sync multiplayer modes, ready for competitive games
▍Complete JSDoc for an AI-friendly, type-safe development experience

bootstrap.ts — Boot the engine

import { FingerEngine } from 'finger-engine';

// One build, every platform · Cocos Creator 3.8.8
const app = new FingerEngine(
  platforms: ['wechat', 'douyin', 'web'],
  scene:     'MainMenu',
  hotUpdate: true,,
});

app.launch(() => {
  ui.open('views/LoginView');
  res.load('main_atlas');
  net.connect('ws://game.joyfinger.cn');
});▍

// ARCHITECTURE

A Clear Layered Architecture

From the pure TypeScript core to the Cocos runtime, every layer has a single responsibility and is independently testable.

Core Layer · Pure TS

ECS, network protocols, behavior trees, event bus, deterministic random, and timer systems — all engine-agnostic and unit-testable in Node.

Cocos Adapter Layer

Wraps Cocos Creator 3.8.8 capabilities behind stable interfaces: scene management, component lifecycle, @ccclass serialization and loading.

MVVM UI Layer

Data-driven views with automatic two-way binding between view models and views; dialogs, notifications, and view stacks managed uniformly.

Asset & Hot-Update Pipeline

Loading, caching, compression, and remote hot updates built on the Asset Manager — ship new versions without release waiting.

Networking & Sync Layer

WebSocket / HTTP wrappers with both lockstep and state sync, plus built-in reconnection and protocol compression.

Tools & Performance Layer

Profiling, leveled logging, object pools, and batched render scheduling — smooth even on low-end devices.

// FEATURES

Core Features in Depth

Every capability here was earned through real projects — ready on day one.

One-Click Multi-Platform Builds

One codebase builds for WeChat, Douyin, Kuaishou, App, and Web simultaneously. Platform differences, subpackage strategies, platform login, and payment SDK integrations are handled automatically — building means publishing, with no per-platform manual adaptation.

Composable ECS Architecture

A three-way decoupling of entities, components, and systems: systems own the logic, components carry the data, entities compose capabilities freely. With object pools and command buffers, even thousand-entity scenes stay clear and performant.

Hot Updates & Asset Pipeline

Reinforced asset loading, atlas batching, and remote hot updates on top of the Cocos Asset Manager. Version iterations and event launches no longer wait for platform review; staged rollouts and rollbacks flow seamlessly.

High-Performance Rendering

Adapted to WebGL / WebGPU render pipelines with deeply optimized 2D batching and effects. Particles, combat effects, and open-world scenes stay silky even on low-end devices.

Networking & Multiplayer Sync

WebSocket / HTTP protocol layer with both lockstep and state-sync modes built in. Reconnection, weak-network compensation, and protocol compression come standard — competitive and casual games work out of the box.

Toolchain & Debugging

Built-in profiling, leveled logging, and strict type checks. Complete JSDoc covers every public interface, so AI can readily understand and generate compliant code.

// CODE

A Delightful Out-of-the-Box Experience

Express the clearest logic with the least boilerplate.

movement.ts — ECS component

import { Comp, Entity, System } from 'finger-engine';

class MoveData extends Comp {
  speed: number = 120;
}

class MoveSystem extends System {
  update(dt: number) {
    this.allOf(MoveData).forEach(e => {
      const pos = e.get(PosData);
      pos.x += e.get(MoveData).speed * dt;
    });
  }
}

hud.ts — MVVM binding

import { viewModel, Bindable } from 'finger-engine';

@viewModel
class HUDModel {
  @Bindable score = 0;
  @Bindable combo = 0;
}

// Views update automatically — no manual set
hud.data.score += 100;
hud.data.combo = 3;

TECH STACK

The Foundation

Cocos Creator 3.8.8TypeScriptWebGL / WebGPUAsset ManagerFully Documented JSDocMIT License

// GET STARTED

Start Your Project with FingerEngine

Whether it's licensing the engine or having us build custom gameplay — we'd love to hear from you.

services@joyfinger.cn Contact Us →