This project is to step up and continue development of the Aether game engine and toolset. Aether is an engine designed for rapid cross-platform development, handling all common tasks and compatabiity internally, leaving development time entirely for the GAME and not the technology.
My hopes are that with a free and easy to use API and toolset, and no additional work required to run on every major platform, I can help independent developers get their dream games completed faster and cheaper while simultaniously supporting my own goal of seeing more independent games support the mac and linux platforms.
Why did I start this project?
Development on Aether origionally started almost two years ago when I was first looking at starting Android development. After a lot of research the few cross platform solutions I could find all had major flaws.
Very few higher level engines supported mobile platforms or non x86 platforms at all, those that did were either closed source and expensive, or required their own IDE which in general ran on windows only. Inspecting lower level engines, a lot of them have huge portability problems, requiring a lot of code re-writing for each specific platform, and had very little automation of common tasks. On top of that, most are either woefully out of date or extraordinarly complicated to work with.
Right now due to this a there's only a few options available to people. Most choose to simply pick one platform and write specificly for it, or buy one of the larger commercial engines (which in general suffer from the same issues mentioned earlier, development can only be done from windows, prohibitively expensive for newer developers, and the inability to use the vast amount of existing libraries with them). Aether aims to fill a gap here, a game engine high level enough that developers don't need to worry about any simple tasks, yet low level enough that the developer can use any tools or IDE's that they like. Plus the api is accessable through C or C++ style calls, meaning the engine and library can be accessed from nearly any language.
In reality this project sits somewhere between "Engine" and being just an API. It's not really a "true" game engine as it's not really made for any specific game type or format, and it's not really just a simple API as there is a high level of automation it handles within your game once it's initialized. Whatever you call it though it's purpose is to inspect what tasks a game developer might want to do in their game outside of the game logic, and create an API that handles it for them leaving them free from the implementation details.
What's the funding for?
This funding will pay for the continued development of the engine, up until now I've paid for all my hosting, development resources, and time from my own pocket, but I've passed the point where I can continue to afford to do this. For each $1000 I can raise that's an additional 2-3 months of development paid for, plus covers server fees and other associated maintenence costs. I also need to get an older mac, preferrably used and cheap so I can reliably build and test the engine and tools properly for mac.
Please keep in mind the $1000 goal is just for initial funding to complete the basic 2d functionality and scenegraph system, and at least partially implement the scripting engine (it was already in a previous engine version but requires substantial re-write). My hopes are that once the project hits a certain level of users I will be able to pull in enough funding to continue development beyond the initial release, though the more that is raised in this campaign the more time can be spent working on the engine and not worring about further fundraising.
The engine is already in a working state, and is in use in a few released games of my own, and has been my toolkit in the past two ludum dare 48 hour game development competitions. You can download and try out the current version of the engine at the link below, but please keep in mind it is very much still in development and is developed on linux and android first, so the windows build has only been tested under WINE for the time being.
- "listener" model for key/joystick/mouse/touchscreen/etc.. input
- keyboard binding system for key remapping
- console system to pass commands to components
- internal message pump for communication between game elements, somewhat similar to what many operating systems use
- fully featured logging system, with tagging and dumping to console, files, and android logcat.
- automated state management system for simplifying game loops and UI layers
- abstracted rendering interface allowing for later upgrades to new renderers without changing the existing API
- automatic scaling and virtual screenmodes, simplifying desktop and phone development especially for pixel art games
- automated texture handling, including proper backgrounding, context re-creation and texture re-loading on all platforms
- simple api for primitive drawing and batching quads
- accelerated ttf drawing system, with C style string formatting
- automated sound system for simple music and SFX handling and volume control
- abstracted file handling for saving and loading data, without having to worry about paths, seperators, and knowing where you can safely save to on different operating systems.
- serializers for safely and simply handling local configuration files and online high score lists
The api also contains JNI bindings and an already built Android layer with support for admob and callbacks to do tasks like file management, open the android market, and use the onscreen keyboard. A few of these android features are only in the newest version of this game engine, which the only one of my game's I've ported to it yet is here
All the other applications on my google play page are with older revisions of the engine as well, last ludum dare I also used the older, currently public version of the engine to make a small isometric RPG within the 48 hour timespan for my entry, which is viewable here
The art in these are also made using the first tool in the toolset designed to integrate tightly with this engine, the current public version you can download here http://www.midnightfragfest.com/sprite-editor/
Each stage of development is laid out here, with what it will take in funding and time to get that far and the major features I intend to complete within each period.
First stage of development: 1-2 months ($1000)
- improve android support and speed, plus better integration with the java api, and improved admob support
- improve mac support
- improve the speed of 2d primitive drawing and memory handling
- include an "effects" api for the 2d portion of the engine, to simplify things such as particle emitters and weather effects
- create a fully automated scenegraph and entity system api, the old one was removed pending rewrite, this is the area that will take most of the time in this phase of the project.
- complete the materials and batching system
- re-write and re-add tiled2d loader support and potentially support for other 2d tilemap formats
- revamp animations format in the sprite editor to reflect recent engine changes
Second stage of development: ~3-4 months ($2000)
- re-write and re-add the Angelscript support
- re-create the Angelscript shell application allowing full games written in Angelscript and no compiling (other than to angelscript bytecode) for cross-platform. This was a feature removed in the current version as the new engine was too different from the previous one.
- re-write bindings for box2d
- add animated tileset support to the sprite and animations editor
- begin construction on the 2d world editor to edit physics based scenes/worlds
Third stage of development: ~5-7 months($3000-$4000)
- add bone based 2d animation to the animations editor and engine
- build an initial version of the networking API to simplify making cross-platform multiplayer games
Fourth stage of development: ~8-12 months($5000+)
- bring the 3d rendering api into the stable release
- complete model loading system for common formats
- create importers and exporters for other common formats
- begin construction on the 3d world editor
The intended license is lgpl or similar upon each
release, I intend to leave it a little open for discussion first before
choosing however. It will be an open source license though, and must
allow commercial use and binary linking without sharing source, so lgpl
seems the obvious choice.
Risks and challenges
No matter how good the technology, the tools, and the ease of use no project of this type can truly succeed without developer support. Even once fully featured and fully stable, all tools integrated, it will be a long uphill battle to get people to switch over to using it instead of their old favorites. This will require constant releases, communication, and advertising on my part and the part of other dedicated community members to bring more people in.
Time is another factor, while I believe my estimates are close to the total time it will take to complete each one of the planned features, in a large project like this you simply can't accurately project that far in the future. There is always the chance looming that features may need to be left out due to lack of funding and time. And of course, being human myself, there is always chance of an emergency causing delays.
Hopefully it will not happen but should the funding run dry before completion of the planned phases development will still continue just at a much slower pace, as I no longer have the resources to have that much downtime outside of work.
The only concern I have in fulfilling the rewards is if the funding only hits the initial requirements yet the engine still becomes used by those supporters I could very well be committed to hosting a decent number of large files for a decently long period without any long term funds to offset the bandwidth and storage costs. Worst comes to worst I may have to cap download speeds or start running advertisements if this scenario were to happen, though I see it as fairly unlikely.
Learn about accountability on Kickstarter