Is EDITOR of cocos creator open source?


Hm, wouldn’t you agree the main page at is a little confusing when it says that

Cocos2d-x is a suite of open-source, cross-platform, game-development tools used by thousands of developers all over the world.

then? Do you plan on open sourcing the Cocos Creator editor? It’d really help us work through issues like today’s undocumented behaviors with build scripts, as code is self-documenting. Thanks.


I’d even be willing to roll up my sleeves a bit and submit PRs with fixes.


Well cocos2d-x and Creator are different. Cocos2d-x is open-source. Creator is not.


I see, I thought it was a parent-child relationship.


Nope. But I understand your main points.


There are other open editors in development: SpriteBuilderX for one (search the forum for it)

Forks of the old open-source version of the editor that Creator is based on: (history view of all forks) (most up-to-date, afaict) (most stars/etc) (original clone, it’s now in a private “closed” repo) (core classes) (demo fireball game)

  • everything I could find today *


Those are even more in the “you’re on your own” territory though.


Yes, I was going off the assumption you wanted something open-source.
Lot of other tools out there as well as code solutions :smiley:


Hm, do you have any personal experience with any of them? If so, which would you recommend? I’m assuming fireball means that it is compatible with Cocos Creator scenes?


Yes Fireball is probably now incompatible with Creator, since it’s been a year or two since they forked it (privately) and worked on it as closed-source project.

Here’s a statement from walzer (founder of Chukong, I believe, not of cocos2d-x) basically saying it won’t be opened. You could PM him or @ liink him here if you want to ask for him to reconsider. I’m not sure how they make money on it? Maybe they sell services to fix bugs or add features based on those willing to pay? Maybe they sell add-on plugins?

CocosBuilder worked just fine 5 years ago (it still works if you have the right version).
SpriteBuilderX is trying to improve upon it today and should be used unless you had old .ccb files.

Creator, honestly doesn’t give you a whole lot more than what this “older” editor had, except that you can edit javascript, “play” from within editor, and it’s now “components”. Most of that, while great for first-time users, gives you almost nothing beyond visual layout and visual keyframe animations if you’ve already created your own hot-loading, own script bindings, own custom in-game editing tools, own quake-style console command system (that hooks into CCConsole stuff from cocos2d-x), etc.

We also use Tiled, Spine, and non-open: TexturePacker, LevelHelper, Physics Designer, Photoshop, etc.

We also use in-game editor tools to manipulate our game as well.

We’ve also added our own custom code for “real” hot-loading, not the fake “hot-restarting” that Creator has, even while using c++, such that we can see immediately the results of editing any of our assets: Textures, Shaders, CocosBuilder scenes, JSON/PLIST/misc text formatted files we’ve written by hand or from other tools.

/rant :smiley: - sorry - I’m also sad that they’ve “wasted” so much time, though it’s their time and their choice, on multiple failed editors and projects instead of refactoring the core engine :-[

p.s. the irony that we keep our custom code internal to ourselves is not lost on me, heh


I believe we bought Fireball, not just a fork.

Walzer is the founder of Cocos2d-x, not Chukong.


Thanks for clarifying!

However, cocos2d-x is still and always will be an open source project to me. Until the copyright holders fork and change the license, I don’t consider the project to have much of an actual owner (though I’d declare Ricardo as the rightful founder, hehe).

Also, cocos2d-x is copyrighted by Chukong which is the technical owner.

I only used founder for Walzer because I mistakenly thought he was the one on the forums from Chukong and also because it’s in his forum bio line.

Someone bought Fireball and forked it. Fireball was open source with an MIT license. That version before they bought it still exists as open source, in the same way cocos2d-x currently (like as of this minute) open source with an MIT license and thus has no real owner, in terms of usage.

While someone might “own” the copyright, the license effectively invalidates that ownership since I can fork any MIT licensed project and close it, claim it as my own, or whatever the heck I want :smiley:

I mean no disrespect, if it was taken as such.


Yes Ricardo created Cocos2d-python and cocos2d-iPhone. Bonus points if you can tell me why he called it Cocos2d!!!

Then Walzer made Cocos2d-x

Sometime after that Walzer and Chukong partnered up.

Then Ricardo joined the Cocos2d-x team.


The fragmentation here is brutal.


Ah, Walzer started the cpp fork before Ricardo joined, I didn’t realize that.
@TheChuckster yep, it is indeed.


Probably something to do with coconut based on the logo :smiley:



Names after Los Cocos, Argentina.

Cocos + 2d game engine == Cocos2d


Ah, nice. School project originally? or just local group there? or were the original contributors (looks like 3-6 of them in the copyright header of python project) from around the world? I should prob just PM ricardo, eh, haha.


You mentioned hot-loading, do you mean hot-loading c++ code, or resources?
It sound very interesting, and the quake-style console command :smiley:

I’m an entry level dev, could you please share some thoughts or resources on those features for me to research?


Well hot-loading is sort of not an entry level thing, per se, but it’s not difficult, just probably not what I’d start with - go make a few fun silly small games first :smiley:

Also, if you are using Creator then Javascript mitigates some of this since the entire game is scripted and doesn’t need to be recompiled. I do wish, however, that they added more update at run-time capabilities (maybe the latest version has improved in this area).

Hot-reloading that I’ve used personally is resources/data only, not c/c++ recompiling on the fly (though that is also possible). So either the game code watches for file change notifications, or polls files for changes, or has UI to force reload of object(s).

The data is reloaded from file (“”) into the entity type’s “template” of sorts (for those created in future) and applied across all current entity instances in the scene of that type. Various resources are referenced in this template: sounds, animation frames, textures, etc.

So at a high-level the texture is swapped, base property values are updated (each instance can apply modifier values to these), some other properties are updated in whole (overwritten), new animation frame sets are swapped with old, etc.

I’ve added videos from handmade hero and j.blow’s Jai development for some current examples.

(sorry the rest is quite long, I should probably move this onto my blog and link)


If I started a new game (medium to larger, year+ long project) I’d want to start with some of these things right up front.

  • Hot reloading of data (maps, entity, localization, etc)
  • Heavily data-driven (again while scripting makes things easier initially, just making all data/properties modifiable without re-compiling gets you 80-90% of what scripting provides in most cases I’ve worked with where Lua/JS was used)
  • In-Game UI to modify data/properties/scene as well that allows save/load (and versioning)
  • Quake-style console either hooked up to CCConsole commands, or written from scratch (or open source code)


Handmade Hero Hot-Recompile in C99 (but c++ compiler for a few extra features)

For a look at how one can in fact do hot-reload of actual code while debugging (or technically in released build on platforms where executing data is allowed) you can check out handmade hero’s videos:

I think if you look at week 5 on this link those videos may also have some notes.

Note: I really don’t recommend this for anyone using cocos2d-x. If you really wanted this with c++ go use Unreal instead.

However, in general I do believe people think scripting languages are some golden ticket when in fact they really just wanted data files and an in-game editor with hot-reloading of these assets. An external editor can be used, but if you use an in-game editor with save/load then you don’t need the actual live reloading, for the most part.


Coincidentally Jonathan Blow just did some streams on this exact very subject (see below). He doesn’t go into the platform layer file notification, but you can use libfswatch ( to hook up the capability. He also develops the console using immediate mode GUI ideas. You could use imGUI to use similar code, but otherwise you’d have to figure out how to best apply the state onto the cocos::ui::Widgets if you use them for the quake console.

One key aspect I’ve found makes this easier with cocos2d-x is that we have game entity state separated from the Node* derived rendering instances. We update the Node* (et al) properties (position, sprite frame, etc) from the state. This means we only use Actions for menus and effects (particles, etc), but we do use the internal tween:: functions.

Cocos2d-x has a highly coupled data design, especially if you use Actions and such for manipulating state. We manually update spriteFrames for our animations by keeping frame index and anything else we need to set current sprite frame, for example. This allows us to hot-reload the prefix/frame-index-list and have a character on screen change to use the new animation texture/frames associated with the current running state (e.g. “walking”).

Quake Console
Cocos2d-x does have a limited console-like experience that can be used by telnetting into the game remotely. You can see the implementation in CCConsole.cpp

Archived Twitch Stream Videos
Disclaimer Notes:

  • These are long and unedited archives of him live streaming on Twitch
  • I wouldn’t watch straight through unless you were very interested in his new language
  • He’s mostly streaming to show his progress on his new programming language JAI
  • He does a little C++ here and there when he’s debugging his JAI compiler

Hot-Reload Global State - variables, in his terms, you can extrapolate this out to loading data into a game entity .

Initial Quake Console UI (6 parts - mostly again I’d expect it to be uninteresting for you) .

Adding simple Commands .

Playlist where these exist (some others) .