Open Source and Game Development


Game makers compete to make the best games. However, we don’t compete to make the best tools, whether they are content creation tools, pipeline tools, analysis tools, or testing tools.

We’d all reduce our development costs and make better games if we could share the cost of developing great tools. In turn, better games should attract more gamers and more gamer money, which would benefit all of us. We all lose when bad tools lead games to crash, stutter, or otherwise leave gamers disappointed.

Unreal, Unity, and others have excellent tool sets, but they can’t solve all our problems. If they did, we wouldn’t need to hire programmers.

What opportunities do we see for open source collaboration in the game industry?

To start, I know we all need to make tools. Professional tools can have a daunting list of features:

  • Cut, copy, paste
  • Undo, redo
  • Search and replace
  • Source Code Management (SCM) integration
  • Bug tracking integration
  • Ability to push updates
  • Crash reporting
  • Skinable
  • Keyboard shortcuts
  • Testable and Scriptable (say using Python)
  • Syntax highlighting
  • Spell checking
  • IntelliSense
  • XML import and export
  • Docking and window management
  • Standard UI controls
  • Session recording and playback
  • Multi-document editing
  • Support localization

Media or Game specific tools would add even more features:

  • Timeline controls (A lot of media has a time component)
  • Statecharts (like Visio) (A lot of media has states)
  • A variety of 2D, 3D or audio controls, meters and widgets (think Maya or Sound Forge)
  • High performance 2D and 3D viewing
  • Audio and video capture and playback. Variable rate playback.
  • Metadata extraction (All media has useful metadata)
  • Control via multi-touch (A single slider may not be ideal for media manipulation)
  • Layers (to allow multiple content specialists to work on the same ‘objects’ at the same time)
  • Separation of target and host (when you develop on PCs and target consoles or less capable devices, or multiple devices with varying formats)

Unlike throw-away tools, professional tools are hard to write (from scratch). Luckily, most of these professional features are common from tool to tool. Users want common, or better, identical functionality across their tools. They hate relearning variant UIs for each tool. Programmers adding new features to old tools also don’t want to have to learn a unique code base before they can be productive. The solution to making professional tools quickly and inexpensively is a high quality, modern tools framework.

Bill Budge came to Sony Worldwide studios nine years ago to create a tool to make tools, especially game tools. We called this effort ATF, for Authoring Tools Framework. We open sourced ATF on GitHub at GDC 2014. Although ATF offers most of the features listed above, this post isn’t a review or description of ATF. (For information on ATF: Also, see ATF’s extensive wiki at

We open sourced ATF, not only to do something nice for the game development community, but in the hope that ATF might be the start of something bigger. We want ATF to be a foundation for a long-term, open source effort enabling many game (and game platform) makers to work together on valuable (but non-proprietary) technology.

We aren’t the first company to open source tools or game technology. But game developers lack a place where open source contributions are vetted by a community of top developers. As Linux or LLVM have taught us, it’s not enough to upload some old tools or modules to GitHub and claim you are supporting open source.

Your contributions must be useful to many game developers. They need to pass code review, so they need to be well architected, documented, and include robust automated testing (so it’s easy for others to continue development). They should be modular, flexible, and efficient. They must pass all build or continuous integration tests. They should leverage common frameworks. Breaking changes should be minimized (and work arounds documented). New components must work with existing components and be non-duplicative. Like any ongoing software project, refactoring will be needed on occasion.

We believe game companies can collaborate if we focus on non-proprietary pieces, the stuff your top programmers don’t want to do, the boring stuff, if you’d prefer. Stuff like:

  • Automated testing
  • Performance Analysis
  • Common content editing tools (level editor, script editor, state machine editor, etc.)
  • Common networking components
  • Common social components
  • Common business components
  • Common pipeline components
  • Common asset management, asset workflow, and asset analysis
  • Analytics and Metrics

We want ATF to be an enabler for this long-term effort. If you’re interested, we hope you join our community,, and start contributing!