[opensourcedex]

engo is a free, open source gaming project written in Go and released under MIT. It has 1,822 GitHub stars, 132 forks and 54 open issues, and was last pushed 8 months ago. On this registry it ranks #71 of 87 tracked projects in Gaming, with 5 head-to-head comparisons available.

What is engo?

Engo is an MIT-licensed, cross-platform 2D game engine written in Go that follows an interpretation of the Entity Component System paradigm, intended for Go developers who want to build games with the language and toolchain they already use.

What it is

Engo is a game engine written in Go that provides the pieces a 2D game needs to start running: window creation, game startup, OpenGL context creation and input handling all live in the top-level github.com/EngoEngine/engo package. That package is designed to be used with Systems written to the specification of github.com/EngoEngine/ecs, and a second package, github.com/EngoEngine/engo/common, supplies the project's own ECS implementations of common game development Systems such as a RenderSystem and a CameraSystem. The repository is compilable for Mac OSX, Linux and Windows, with mobile added as a release target for Android and iOS following Go 1.4, and web support available through WebAssembly. Version 1.0 has been released.

The concrete problem it solves is the gap between the Go ecosystem and game development: rather than moving a project into an engine written in another language, a Go developer can pull Engo in as a library, keep the standard Go build workflow, and write gameplay as systems and components against a defined ECS interface instead of building window, OpenGL context and input plumbing from scratch. The split between the core engo package and the common systems means the reusable parts — rendering and camera handling in particular — arrive already implemented, while the architecture remains the ECS design the engine is built around.

Key capabilities

  • An Entity Component System architecture, reflected in the entity-component-system topic and in the engine's reliance on Systems built to the github.com/EngoEngine/ecs specification.
  • A two-package structure: github.com/EngoEngine/engo for windows, game startup, OpenGL context and input, and github.com/EngoEngine/engo/common for ECS implementations of common Systems.
  • Ready-made Systems in the common package, including a RenderSystem and a CameraSystem.
  • Cross-platform builds for Mac OSX, Linux and Windows, with Android and iOS as release targets and WebAssembly support for the web.
  • Platform-specific build tags for dependency resolution, such as go get -u -tags js ./... and go get -u -tags android ./....
  • A published tutorial series on the project website covering how to create a game, alongside conceptual explanations.
  • A demos folder in the repository holding runnable example projects.

Who uses it and how

  • Go developers building 2D games who want to remain inside the Go toolchain and add the engine with go get rather than adopting an external editor-centric stack.
  • Projects that want ECS structure without inventing it: developers implement Systems against the ecs specification and reuse RenderSystem and CameraSystem from the common package.
  • Teams targeting several platforms from one codebase, using the js and android build tags to pull the platform-specific dependencies for web and mobile builds alongside desktop targets.
  • Newcomers working through the website tutorial series, and contributors who gather in the project's Gitter chat to discuss bugs, feature requests and the projects they are building.

Getting started

Install the system dependencies first — on Debian or Ubuntu the README lists libasound2-dev, libglu1-mesa-dev, freeglut3-dev, mesa-common-dev, xorg-dev, libgl1-mesa-dev and git-all, while Windows requires a gcc such as Mingw on the PATH plus Git — and then fetch the engine with go get -u github.com/EngoEngine/engo. From there, the website tutorial series or the repository's demos folder provide the working starting points.

How it compares

No list of paid products or comparable engines is supplied with this entry, so Engo stands alone in this registry and no head-to-head contrast can be drawn from the available facts. The only positioning the facts support is Engo's own: an MIT-licensed, Go-native engine distributed as source through the Go toolchain rather than as a purchased product.

When to use it — and when not to

A self-hoster must first provision native build dependencies — OpenGL, GLU, freeglut, X11 and ALSA development packages on Linux, and a gcc toolchain on Windows — before go get will produce a working build, so the engine assumes a machine set up for CGo-linked graphics and audio work. It is a poor fit for anyone wanting a bundled editor, asset pipeline or 3D support, none of which the supplied facts describe. The README also flags that Engo is always undergoing optimizations and new features, which "sometimes means things break," and it keeps a list of breaking changes since v1.0 for that reason; that section is truncated in the available excerpt, and part of the getting-started material lives on the project website rather than in the repository.

project readme (upstream, from github) — read inline

Engo

GoDoc Join the chat at https://gitter.im/EngoEngine/engo License Build Status Build status Go Report Card Coverage Status

A cross-platform game engine written in Go following an interpretation of the Entity Component System paradigm. Engo is currently compilable for Mac OSX, Linux and Windows. With the release of Go 1.4, supporting Android and the inception of iOS compatibility, mobile has been be added as a release target. Web support (wasm) is also available.

v1.0 is now available! To celebrate, there will be a game jam coming soon to celebrate the release, start actually building things and hopefully find any issues. Updates for this will come soon.

Getting in touch / Contributing

We have a gitter chat for people to join who want to further discuss engo. We are happy to discuss bugs, feature requests and would love to hear about the projects you are building!

Getting Started

Theory: common vs engo

There are currently two major important packages within this repository: github.com/EngoEngine/engo and github.com/EngoEngine/engo/common.

The top level engo package contains the functionality of creating windows, starting the game, creating an OpenGL context and handling input. It is designed to be used with Systems designed as per github.com/EngoEngine/ecs specifications. The common package contains our ECS implementations of common game development Systems like a RenderSystem or CameraSystem.

Practice: Getting it to Run

  1. First, you have to install some dependencies:
  2. If you're running on Debian/Ubuntu: sudo apt-get install libasound2-dev libglu1-mesa-dev freeglut3-dev mesa-common-dev xorg-dev libgl1-mesa-dev git-all
  3. If you're running on Windows you'll need a gcc compiler that the go tool can use and have gcc.exe in your PATH environmental variable. We recommend Mingw since it has been tested. You'll also need git installed, we recommend getting it from The official Git site
  4. If you're on OSX, you will also need Git. You can find instructions here. You can also use homebrew to install git as well. Open an issue if you have any issues
  5. Then, you can go get it: go get -u github.com/EngoEngine/engo
  6. You may also want to get the dependencies of platform specific builds, so that build tools like godef can use them: go get -u -tags js ./... go get -u -tags android ./...
  7. Now, you have two choices:
  8. Visit our website, which hosts a full-blown tutorial series on how to create your own game, and on top of that, has some conceptual explanations;
  9. Check out some demos in our demos folder.
  10. Finally, if you run into problems, if you've encountered a bug, or want to request a feature, feel free to shoot us a DM or create an issue.

Breaking Changes Since v1.0

Engo is always undergoing a lot of optimizations and constantly gets new features. However, this sometimes means things break. In order to make transitioning easier for you, we have a list of those changes, with the most recent being at the top. If you run into any problems, please contact us at gitter.

  • TMXObject Width and Height is in pixels, and can be fractional. This has changed from an int to a float64.
  • TMXTileset now uses a Spritesheet instead of a Texture. This helps keep track of the guid better and allows the gid to not start at zero and have skips in it, as well as for borders and spacing in the tile sheet.
  • TMX Level's objects have all been rolled into Object rather than have separate things like "PolyLineObject". This is to be consistent with the TMX format.
  • The Shader interface now has a SetCamera(*CameraSystem) method. This method allows shaders to automatically update the camera system as it changes, such as between scenes or when the camera system is added.
  • The domain engo.io has expired. Now use github.com/EngoEngine/engo as the import path, and the site can be located at engoengine.github.io

Roadmap to v1.1

A list of issues for v1.1 can be found here. There's always room for improvement! Feel free to submit proposals, open issues, and let us know how we can improve!

History

Engo, originally known as Engi was written by ajhager as a general purpose Go game engine. With a desire to build it into an "ECS" game engine, it was forked to github.com/paked/engi. After passing through several iterations, it was decided that the project would be rebranded and rereleased as Engo on its own GitHub organization.

Credits

Thank you to everyone who has worked on, or with Engo. None of this would be possible without you, and your help has been truly amazing.

These are 3rd party projects that have made engo possible.

  • The original engi game engine which engo was based off of (BSD license)
  • Oto, a low-level cross-platform library to play sound. The AudioSystem uses this and is based on the audio package used in Ebiten.

Frequently asked questions

Is engo free to use?

engo is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does engo do?

Engo is an open-source 2D game engine written in Go.

What is engo written in?

engo is primarily written in Go. Its source is publicly available at https://github.com/EngoEngine/engo, and it has 1,822 GitHub stars.