Dora SSR (多萝珍奇引擎)

Web IDE · Coding Agent Target-device live game engine

Dora SSR is a cross-platform game engine that lives on the device your game runs on — a phone, a handheld, or a desktop. Its built-in Web IDE opens in any browser on the same network, so you code, inspect, and iterate against the real runtime instead of a detached preview, with an AI coding agent built in. The engine runs natively on Android, iOS, Windows, macOS, Linux, and HarmonyOS.

_{The Web IDE in a browser, editing code that runs on the device in real time.}

• Develop against the real runtime. The engine runs on the target device and the browser is just a window onto it. What you edit is what runs — no emulator, no export step, no detached preview.
• A complete toolchain in the browser. The Web IDE covers project files, typed editing, completion, diagnostics, and jump-to-definition, plus built-in editors for animation, particles, physics, story scripts, Git, and more.
• An AI agent built into the engine. The Coding Agent brings LLM-assisted development into the Web IDE — with project skills, persistent memory, API lookup, safe edits, build checks, runtime validation, and sub-agent delegation.

_{The engine on the device, the IDE wherever you are.}

Ask it to analyze a project, look up APIs, make safe edits, and validate the result at runtime. The agent works inside the engine, with persistent memory, project skills, and sub-agent delegation.

Common game-production tasks stay inside the Web IDE:

Animation editor — skeletal animation timelines	Particle editor — effects with live preview
Physics editor — shaping bodies and fixtures	Yarn editor — story scripts and node graphs
Visual script editor — logic as connected nodes	Spine preview — inspecting skeletal animation data
Git client — history, remotes, and changes	Profiler — runtime performance and debugging

Also built in: a TIC-80 editor, tile-map support, an Excel-to-database workflow, and Blockly for Scratch-style visual scripting.

• Scenes & 3D — tree-based 2D and 3D scenes, an approachable ECS module, cameras, materials, lighting, models, animation, and 3D physics.
• 2D production — Spine2D, DragonBones, built-in skeletal animation, PlayRho physics, tile maps, particles, and retro TIC-80 content.
• Graphics & media — asynchronous asset loading, Ogg/Theora video, multi-format spatial audio, runtime shader compilation, Effekseer, NanoVG, ImGui, and TrueType rendering.
• UI & narrative — CSS Flex layout, responsive TSX interfaces, and Yarn Spinner story scripting.
• Data — asynchronous SQLite access plus Excel-to-database workflows.
• Game patterns — reusable logic and AI support for 2D platformers, and a machine-learning gameplay framework.

Write game code in the language your team already knows — they all drive the same engine APIs:

Prefer blocks over text? Blockly provides Scratch-style visual scripting for teaching and prototyping.

A taste of TSX — declarative scenes with React-style APIs, compiled with TSTL:

import { React, toNode } from 'DoraX';
import { Ease } from 'Dora';

toNode(
  <sprite file='Image/logo.png'>
    <sequence>
      <event name="Count" param="3"/>
      <delay time={1}/>
      <event name="Count" param="2"/>
      <delay time={1}/>
      <event name="Count" param="1"/>
      <delay time={1}/>
      <scale time={0.1} start={1} stop={0.5}/>
      <scale time={0.5} start={0.5} stop={1} easing={Ease.OutBack}/>
    </sequence>
  </sprite>
)?.slot("Count", (_, param) => print(param));

_{TSX code and the responsive UI it renders, live in the runtime.}

local _ENV = Dora

local sprite = Sprite("Image/logo.png")
sprite:once(function()
  for i = 3, 1, -1 do
    print(i)
    sleep(1)
  end
  print("Hello World")
  sprite:perform(Sequence(
    Scale(0.1, 1, 0.5),
    Scale(0.5, 0.5, 1, Ease.OutBack)
  ))
end)

local sleep <const> = require("sleep")
local Ease <const> = require("Ease")
local Scale <const> = require("Scale")
local Sequence <const> = require("Sequence")
local Sprite <const> = require("Sprite")

local sprite = Sprite("Image/logo.png")
if not sprite is nil then
  sprite:once(function()
    for i = 3, 1, -1 do
      print(i)
      sleep(1)
    end
    print("Hello World")
    sprite:perform(Sequence(
      Scale(0.1, 1, 0.5),
      Scale(0.5, 0.5, 1, Ease.OutBack)
    ))
  end)
end

_ENV = Dora

with Sprite "Image/logo.png"
   \once ->
     for i = 3, 1, -1
       print i
       sleep 1
     print "Hello World!"
     \perform Sequence(
       Scale 0.1, 1, 0.5
       Scale 0.5, 0.5, 1, Ease.OutBack
     )

import { Sprite, Ease, Scale, Sequence, sleep } from 'Dora';

const sprite = Sprite("Image/logo.png");
if (sprite) {
  sprite.once(() => {
    for (let i of $range(3, 1, -1)) {
      print(i);
      sleep(1);
    }
    print("Hello World");
    sprite.perform(Sequence(
      Scale(0.1, 1, 0.5),
      Scale(0.5, 0.5, 1, Ease.OutBack)
    ))
  });
}

import { React, createRoot, signal } from 'DoraX';
import { Director } from 'Dora';

const count = signal(0);
const root = createRoot(Director.entry);

root.render(() => (
  <label fontName="sarasa-mono-sc-regular" fontSize={30}>
    Count: {count.value}
  </label>
));

count.value += 1;

import "dora"

func init {
  sprite := dora.NewSpriteWithFile("Image/logo.png")
  sprite.RunActionDef(
    dora.ActionDefSequence(&[]dora.ActionDef{
      dora.ActionDefEvent("Count", "3"),
      dora.ActionDefDelay(1),
      dora.ActionDefEvent("Count", "2"),
      dora.ActionDefDelay(1),
      dora.ActionDefEvent("Count", "1"),
      dora.ActionDefDelay(1),
      dora.ActionDefScale(0.1, 1, 0.5, dora.EaseLinear),
      dora.ActionDefScale(0.5, 0.5, 1, dora.EaseOutBack),
    }),
    false,
  )
  sprite.Slot("Count", func(stack: dora.CallStack) {
    stack.Pop()
    param, _ := stack.PopStr()
    dora.Println(param)
  })
}

use dora_ssr::*;

fn main () {
  let mut sprite = match Sprite::with_file("Image/logo.png") {
    Some(sprite) => sprite,
    None => return,
  };
  let mut sprite_clone = sprite.clone();
  sprite.schedule(once(move |mut co| async move {
    for i in (1..=3).rev() {
      p!("{}", i);
      sleep!(co, 1.0);
    }
    p!("Hello World");
    sprite_clone.perform_def(ActionDef::sequence(&vec![
      ActionDef::scale(0.1, 1.0, 0.5, EaseType::Linear),
      ActionDef::scale(0.5, 0.5, 1.0, EaseType::OutBack),
    ]));
  }));
}

Loli War	Zombie Escape
Dismantlism	Luv Sense Digital

• Learn individual APIs and engine features with Dora-Example.
• See how real projects organize assets, scripts, and gameplay with Dora-Demo.

1. Install the APK on the target device.
2. Launch the app — it displays an address to open from a browser on any device on the same network.
3. Open the address in a browser, and the Web IDE is ready.

Download and extract the release, launch the app, and open the displayed address in a browser.

Download and extract the release, or install with Homebrew:

brew install --cask ippclub/tap/dora-ssr

Launch the app and open the displayed address in a browser.

Ubuntu Jammy

sudo add-apt-repository ppa:ippclub/dora-ssr
sudo apt update
sudo apt install dora-ssr

Debian Bookworm

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 9C7705BF
sudo add-apt-repository -S "deb https://ppa.launchpadcontent.net/ippclub/dora-ssr/ubuntu jammy main"
sudo apt update
sudo apt install dora-ssr

Launch the app and open the displayed address in a browser.

See the official guide.

1. In the Web IDE, right-click Workspace in the left panel and create a new folder for your project.
2. Add an entry file named init — Lua, YueScript, Teal, TypeScript, or TSX (see Languages).
3. Press Ctrl + R, or click the 🎮 icon in the lower-right corner and choose Run — the game runs on the device.
4. Right-click the project folder and choose Download to export the packaged project.

• Learn — Quick Start · API Reference · Ask DeepWiki
• Community — Discord · QQ Group 512620381
• Examples — Dora-Example · Dora-Demo

Dora SSR is developed by IppClub — come build with us!

Issues and pull requests are welcome! Please read the Contributing Guidelines first.

Dora SSR is a donation and incubation project of the Open Atom Foundation, a non-profit foundation supporting open-source technologies. We are committed to building a more open and collaborative game-development environment.

Dora SSR is released under the MIT License.