[转]Game Engines

http://content.gpwiki.org/index.php/Game_Engines

 

A game engine is the core library functions used in a game, usually related to graphics, input, sound, networking and other systems.

Engines are separate from game-specific code, which enables different games to use the same engine. (Games of different genres even, in some cases.)

Engines have different features. When picking an engine, you have to pay attention to whether or not it satisfies the needs of your game.

 

Engine Overview

Game engines

Name clip_image001

Language clip_image001[1]

Platform clip_image001[2]

License clip_image001[3]

Graphics clip_image001[4]

Soundclip_image001[5]

Networkingclip_image001[6]

Scriptingclip_image001[7]

Other features clip_image001[8]

Plus clip_image001[9]

Minus clip_image001[10]

A6 Game Engine

C-script like language/C++/Delphi

clip_image003

Commercial

3D via DirectX

clip_image005

clip_image005[1]

clip_image005[2]clip_image006

Physics

Adventure Game Studio (AGS)

C++

clip_image003[1] clip_image008

Open source (Artistic License v2)

Allegro

clip_image005[3]

clip_image005[4]

clip_image005[5]clip_image006[1]

Supports user-made plugins and modules

AgateLib

.NET

clip_image003[2] clip_image006[2]

Free

2D via Direct3D or OpenGL

clip_image005[6]

clip_image010

clip_image010[1]

AGen

C++

clip_image003[3]

Indie/Commercial

Hardware accelerated 2D via Direct3D or OpenGL

clip_image005[7]

clip_image005[8]

clip_image005[9] clip_image006[3]

Physics

Scene management, high-level framework, automatic memory management

Not cross platform yet

Allegro

C

clip_image008[1] clip_image003[4] clip_image012 clip_image013

Free (Open Source)

2D and 3D

clip_image005[10]

clip_image010[2]

clip_image010[3]

APlay

C#, C# for Unity, Flash, Java (server), AWT

clip_image003[5] clip_image013[1] clip_image008[2]

Free and commercial

N/A

clip_image010[4]

clip_image005[11]

clip_image010[5]

Also includes persistence (database access). Check web page for more feature detail

Makes it possible to create online/multiplayer apps without caring about (or even knowing about) networking. Novel approach via graphical modelling

Asphyre

Delphi / Delphi .NET

clip_image003[6]

Free

2D/3D via DirectX

clip_image010[6]

clip_image005[12]

clip_image010[7]

GUI Editor

Versions later than v3.1 are only for BDS and Turbo Delphi

Axiom website

.NET

clip_image003[7] clip_image008[3] clip_image013[2]

LGPL

3D via OpenGL/DirectX/XNA

clip_image010[8]

clip_image010[9]

clip_image010[10]

Based on the very popular OGRE rendering engine.

Baja Engine

C++/Lua

clip_image003[8] clip_image013[3]

Free

3D via OpenGL

clip_image005[13]

clip_image005[14]

clip_image005[15]clip_image006[4]

Professional Results, Includes all tools

Shaders, Shipped a Commercial game, Easy to use, Flexible

As far as I can see, the site does not indicate source is included with the download (or for that matter, is available) Hard to use art pipeline, no community.

BigWorld Engine

C++/Python

clip_image003[9]clip_image006[5] clip_image008[4]clip_image006[6] clip_image013[4] clip_image015 clip_image017 clip_image019

Commercial & Indie

DirectX/9

clip_image005[16]

clip_image005[17]

clip_image005[18] clip_image006[7]

Professional Results, Includes all tools

Shaders, Shipped various Commercial games, Easy to use, proven

Also available with (source-less) Indie versions.

Blender Game Engine

Python

clip_image003[10] clip_image013[5] clip_image008[5] clip_image021

Free (Open Source)

3D via OpenGL

clip_image005[19]

clip_image005[20] clip_image006[8]

clip_image005[21] clip_image006[9]

Physics (including soft bodies) via Bullet, custom written shaders (via GLSL). Can use logic bricks to create basic games without programming experience, or Python for more complex games.

Included as part of Blender, a fully featured 3D package, so modeling, texturing, etc. all built in.

Occasionally spotty documentation.

Blitz3D

Basic

clip_image003[11]

Commercial

2d/3D via DirectX7

clip_image005[22]

clip_image005[23]

clip_image005[24] clip_image006[10]

Big community, a lot games

Easy to start, support BSP, 3DS, better for shareware games

No OOP, basic syntax

BlitzMax

Object Basic

clip_image003[12] clip_image008[6] clip_image013[6]

Commercial

2d via OpenGL

clip_image005[25]

clip_image005[26]

clip_image005[27] clip_image006[11]

Has many modules (GUI, 3D, Sound, Physics, etc ). Easy to start

Fast 2D engine, better for casual games(Arcanoids, Puzzles etc.), OOP, LUA Bind

Has no 3D module

BlurredEngine

C++

clip_image003[13]

Commercial

3D via DirectX

clip_image005[28]

clip_image005[29]

clip_image005[30]clip_image006[12]

incl. Leveleditor and 3D gui components

Brume Game Engine

.NET 2.0/3.5 (C#)

clip_image003[14]

Free

3D via DirectX 9/DirectX 10

clip_image005[31]

clip_image010[11]

clip_image010[12]

Have more modules (GUI, Sound, Physics, Collisions, Animations, Effects (Hardware Shaders), Terrains, etc ). Easy to start

Easy to use, object oriented, animation system, integrated physics

C4 Engine

C++

clip_image003[15] clip_image013[7] clip_image017[1]

Commercial

3D

clip_image005[32]

clip_image005[33]

clip_image005[34]clip_image006[13]

Voxel terrain, shader editor, more

Active development, good support, clean architecture

Chingu

Ruby

clip_image003[16] clip_image013[8] clip_image008[7]

Free

2D via OpenGL

clip_image005[35]

clip_image005[36]

clip_image010[13]

Game states, plugginable game logic.. game engine features

Available on github, 28+ bundled examples.

Cipher Game Engine

C/C++

clip_image003[17]

Commercial

3D

clip_image005[37]

clip_image005[38]

clip_image010[14]

Collision Detection, AI

ClanLib

C++

clip_image003[18] clip_image008[8] clip_image013[9]

Free (Open Source)

Accelerated 2D

clip_image005[39]

clip_image005[40]

clip_image010[15]

Open Source. Excellent lightweight networking

Cobra (programming language from Squeaky Duck)

Pascal/Delphi derivative

clip_image003[19]

Indie/Commercial

2D/3D via OpenGL, with an optional separate non-hardware-accelerated 2D mode for compatibility.

clip_image005[41]

clip_image005[42]

clip_image010[16]clip_image006[14]

Various community supplied extensions (GUIs, Parsers, Virtual Machines)

Fast 2D graphics

Somewhat buggy 3D, not-cross platform, somewhat slow bug-fix cycle.

Cocos2d-x

C++, Lua

clip_image023 clip_image025 clip_image015[1] clip_image008[9] clip_image013[10] clip_image003[20]

Free Open Source (MIT)

2D via OpenGL

clip_image005[43]

clip_image005[44]

clip_image005[45]clip_image006[15]

Various community supplied extensions, derived from cocos2d for iPhone to make it multi-platform.

2D graphics, many commercial games produced using this library.

Mainly for mobile platforms, other platforms are for development.

CRM32Pro

C++

clip_image003[21] clip_image008[10]

Closed Source; LGPL announced on site

2D via SDL/glSDL and optimized MMX blitters

clip_image005[46]

clip_image005[47]

clip_image010[17]

XML parser, Log, propietary file system to package your resources with full protection and useful EditorDPF to manage them, graphics primitives, cursors, tiles, sprites, fonts, several FX effects, GUI system, accurate timer, MPEG-I video, full support of OGG,modules,WAV and VOC, useful network API andmore...

Full documentation (english and spanish). Cross-platform. Heavily optimized for each current CPU (MMX and SSE). Available as a DLL or static library(only Win32). EditorDPF, a resources manager. SetupProyect, a customizable config system. Everything is free!

Crystal Space

C/C++

clip_image008[11] clip_image003[22] clip_image013[11]

Free (LGPL)

3D via OpenGL

clip_image005[48]

clip_image010[18]

clip_image005[49]clip_image006[16]

DaBooda Turbo Engine v1.5.4

VB(COM)/FreeBASIC(VTable)

clip_image003[23]

Free (GPL)

2D(and old school style 3D) via DirectX8

clip_image005[50]

clip_image005[51]

clip_image005[52]

complete 2D game development environment. Supports VB,VB .Net, FreeBASIC

AutoMove(ala Zelda1),Sprites,Overlays,Maps,Audio,Network,Counters,

Key,Joy, FreeBASIC supported through IDispatch, DBFE, or Vtable Documentation in chm, plenty of tutorials and examples..

Final Build, FreeBASIC build in transition, see DBOS, DBHGE at our site

Daimonin

C (server), C++ (client), java (editor)

clip_image008[12] clip_image003[24] clip_image013[12]

GPL

2d/3d via SDL and OGRE3D

clip_image005[53]

clip_image005[54]

clip_image005[55]clip_image006[17]

complete MMORPG engine

Delta3D

C++

clip_image008[13] clip_image003[25] clip_image013[13]

Free(LGPL)

3D via OpenSceneGraph (OpenGL)

clip_image005[56]

clip_image005[57]

clip_image005[58]clip_image006[18]

ODE Physics, STAGE Game Editor, Much More

A well-supported open source project. Built upon other open source projects (OSG, ODE, OpenAL, etc.). Great for games, simulations, or other graphical applications. Supports massive terrains. Used by many large scale companies (e.g., Boeing, Lockheed Martin, etc.), educational institutions, and small developers.

D'Enfent Engine

C++

clip_image008[14] clip_image003[26]

GPL

2D / 3D via OpenGL

clip_image010[19]

clip_image010[20]

clip_image010[21]

Lessons and samples for easy start. Shaders are supported.

DarkbasicPro

Basic

clip_image003[27]

Shareware

2d/3D via DirectX9

clip_image005[59]

clip_image005[60]

clip_image005[61]clip_image006[19]

Big community, a lot games

Easy to start, support BSP, 3DS, better for shareware games

clip_image010[22] OOP, basic syntax

DizzyAGE

C++

clip_image003[28]

Free

2D via DirectX

clip_image005[62]

clip_image010[23]

clip_image005[63] clip_image006[20]

Tool used to create Dizzy games, in the classic adventure style

DXGame Engine

VB6

clip_image003[29]

Free

2D+ via Direct3D

clip_image005[64]

clip_image010[24]

clip_image010[25]

Automated Sprites, 2D Tile Map (Unlimited Layers), Collision Checking, Explosions, Basic Particle Engine, High Level

DxIce

VB6.0 and VB.NET

clip_image003[30]

Free (closed source)

Mostly 2D and some 3D DX9

clip_image005[65]

clip_image010[26]

clip_image010[27]

Various functions/methods to aid in RAD

Great for 2D, many helpers for common game routines

Limited 3D support

dx_lib32 2.0

VB 6.0 (also VB.NET)

clip_image003[31]

Free

2D hardware via DirectGraphics (D3D8)

clip_image005[66]

clip_image010[28]

clip_image010[29]

Draw 2D textures with isometric or caballera perspective in one call, support movie playback (include DivX formats), easy imput handling class, PAK File format support (Quake/Half-Life format), basic Timers counters, support for Timers Events for multithreaing routines (like Timer control of VB but without control interface and instance of this) and more...

Single light DLL (VB6 Runtime and DirectX API only dependency), simple interface, easy to start, several layers of abstraction, automatic resources management, full documentation of all functions

clip_image010[30] full OOP interface, ActiveX DLL (need register in the system), all documentation and web site are in spanish (this a problem? maybe... if you aren't

spanish ;-) )

DX Studio

.NET

clip_image003[32]

Commercial

3D via DirectX9

clip_image005[67]

clip_image005[68]

clip_image005[69] clip_image006[21]

Ageia PhysX, HLSL Shaders, GUI Editor.

Object-Oriented, Active Development, High-Level Scripting.

EasyWay Game Engine

Java

clip_image003[33] clip_image008[15] clip_image013[14]

opensource GPL

2D/3D via OpenGL

clip_image005[70]

clip_image010[31]

clip_image010[32]

Easily extendible, perfect pixel collision, PathFinding, special effects, automatic engine that don't draw what you don't see, engine anti bug

very simple: you can write a game in very few lines of code; You can extend simply the game engine with your function

the API documentation isn't completed yet

Epee Engine

C++

clip_image003[34] clip_image008[16] clip_image013[15]

zlib/libpng

2D SDL but 3D planned using OpenGL

clip_image005[71]

clip_image010[33]

clip_image010[34]

see web site

Very easy to use and fast rendering

Engine is still in the early stages

Entanglar

Any .Net (VB/C#/C++)

clip_image003[35]

Unannounced

clip_image010[35]

clip_image010[36]

clip_image005[72]

clip_image010[37]

2D Physics. Stable fixed timeslice timer. Entity management.

Completely transparent, decoration of properties/methods with attributes makes them automatically synchronised. Remote simulation error prediction. Flexibility to choose any graphics/sound/scripting.

Alpha build only. No 3D physics yet. Light documentation.

Entropia Engine

VB6/C

clip_image003[36]

LGPL

2D using DirectX 8.1

clip_image005[73]

clip_image010[38]

clip_image010[39]

See Web Site (or the SDK)

Very easy to use, fast, lots of utilities for a rapid game development, particle engine, sprite engine, map engine and dynamic lights engine (in development but works, see SDK), tiler, console, PAK file format (Quake PAK's), compression , MD5, and much more!

Web site in Spanish (engine 95 % in English, will fix this soon)

Esenthel Engine

C++

clip_image003[37] clip_image013[16] clip_image015[2]

Free and Commercial

3D, DirectX 9/10/11, OpenGL, OpenGL ES

clip_image005[74]

clip_image005[75]

clip_image005[76]

Many

Next-Gen Graphics. MMO Capable. Physics. Rich Toolset. Lot of Tutorials. Stable.

Espresso3D

Java

clip_image003[38] clip_image008[17] clip_image013[17]

Free and Commercial

3D via LWJGL

clip_image005[77]

clip_image010[40]

clip_image010[41]

Many

Ethanon

AngelScript (made with C++)

clip_image003[39]

Free (LGPL)

Advanced 2D with hardware acceleration

clip_image005[78]

clip_image005[79]

clip_image005[80]

Many

Fenix Project (beta)

language hibrid between Pascal and C

clip_image003[40] clip_image008[18] clip_image013[18] clip_image021[1] clip_image012[1]

Open Source

2D via SDL

clip_image005[81]

clip_image005[82]

clip_image010[42]

Perfect Pixel collision, path finding routine, music modules and Ogg Vorbis Support, cross plataform, very similitudes with Div Game Studio: compatibility with more of file formats (FPG, MAP, PAL, etc...) and a few compatibility with the syntax and other functions of the Div language

Very easy syntax, documentation and web site in english and spanish, a complete game of functions, easy for newbies, the evolution of Div Game Studio!

clip_image010[43] oficial IDE (but existsalternatives), 2D via software, no OPP language, few bugs

FIFE - the Flexible Isometric Free Engine

C++, Python

clip_image003[41] clip_image008[19] clip_image013[19] clip_image027

Free of charge / open source (LGPL 2.1)

2D software renderer via SDL, hw-accelerated mode via OpenGL

clip_image005[83]

clip_image010[44]

clip_image005[84] clip_image006[22]

Ingame console, GUI framework pychan based on guichan, custom XML-based file formats

One of the few open source 2D isometric game engines available

Not feature complete at this point but ready to create game with it nevertheless

FlatRedBall 2.5D

.NET

clip_image003[42]

Free

3D via DirectX

clip_image005[85]

clip_image010[45]

clip_image010[46]

Template, Collision Detection, Physics, Skeletons

G3D

C++

clip_image008[20] clip_image003[43] clip_image013[20]

Free (BSD)

3D via OpenGL

clip_image010[47]

clip_image010[48]

clip_image010[49]

G3DRuby

Ruby

clip_image003[44] clip_image008[21]

Free

3D via OpenGL

clip_image010[50]

clip_image010[51]

clip_image010[52]

GameCore

C++

clip_image003[45] clip_image013[21]

Commercial, Free trial

3D

clip_image005[86]

clip_image005[87]

clip_image005[88] clip_image006[23]

WYSIWYG World Editor provides Terrain editor, FX design, Physics editor, Pathfinding editor, Procedural geometry

Active development, good support, knowledgeable community

Game Maker

Delphi

clip_image003[46]

Free and Commercial

2D/3D

clip_image005[89]

clip_image005[90]

clip_image005[91] clip_image006[24]

Terrific for making quick 2d tile-based games with easy scripting interface, slow 3D support(via DirectX)

GameSalad

No Programming

clip_image013[22] clip_image015[3]

Free and Commercial

2D

clip_image005[92]

clip_image010[53]

clip_image005[93] clip_image006[25]

Physics, Particles

Visual system allows for rapid development.

Mac OS X on Intel only.

GameStart

C++

clip_image003[47] clip_image029

Commercial, Free trial

2D/3D

clip_image005[94]

clip_image005[95]

clip_image005[96] clip_image006[26]

Physics, Particles, Terrain, Character animation

Comprehensive and fully visual IDE, tailored for developers, designers and artists. Production proofed workflow.

Genesis3D

C++

clip_image003[48]

Free/Commercial

3D via DirectX

GhostEngine

C++

clip_image003[49]

Engine code is Zlib/libPNG-licensed

3D via OpenGL/DirectX, with DirectX support in the works

clip_image010[54]

clip_image005[97]

clip_image005[98] clip_image006[27]

As of 5-28-2008, the project has been marked as no longer under development.

GLBasic

BASIC

clip_image003[50] clip_image008[22] clip_image013[23] and other platforms

Commercial

2D/3D via OpenGL

clip_image005[99]

clip_image005[100]

clip_image010[55]

IDE is Windows only, but can compile for other devices included Palm, Android, Windows CE. Simple classes can be used. No chance of source code is usually needed to run on any platform.

Easy to start, use and can publish programs for AppStore, Palm Catalogue and Android Marketplace

None

Glint 3d Engine

100% lua scriptable, C++ source

clip_image003[51] clip_image013[24]

Donation-based licensing. Free version available. Closed source.

2D/3D via OpenGL/DirectX

clip_image005[101]

clip_image005[102]

clip_image005[103]

Includes 2D/3D Irrlicht graphics, Bullet physics, 3d OpenAL sound, cryptography, threading, world management, gui controls, gui skins, event management, key-mapping, special fx, dynamic lighting, animation, multi-language support. GUI Editors, Programmer's Reference and more...

100% scriptable - No install required! No compilers required! Completely extensible and flexible. For apps, sims and games.

Golden T Game Engine

Java

clip_image003[52] clip_image008[23] clip_image013[25]

Free

2D via OpenGL

clip_image005[104]

Gosu

C++, Ruby

clip_image003[53] clip_image013[26] clip_image015[4] clip_image008[24]

Free (MIT licensed itself, but relies on FMOD or SDL_mixer)

2D via OpenGL

clip_image005[105]

clip_image005[106]

clip_image010[56]

Integration with many Ruby libraries

Modern C++, rather minimalistic

Grail Adventure Game Engine

C++, Lua

clip_image003[54] clip_image008[25] clip_image013[27]

GPL

2D via SDL

clip_image005[107]

clip_image010[57]

clip_image005[108]

clip_image010[58]

Open & Flexible, write Games in Lua or direct in C++

Currently still in Development (rewriting from former D-Version known as "indiana")

HGE (Haaf's Game Engine)HGE at SourceForgeHGE

C++

clip_image003[55]

Open Source (Zlib/libpng license)

2D via DirectX

clip_image005[109]

clip_image010[59]

clip_image010[60]

Authoring tools, lightweight

Easy to start, good engine structure

No multiplatform

Horde3D

C++, C DLL interface

clip_image003[56]

Free (LGPL)

3D via OpenGL

clip_image010[61]

clip_image010[62]

clip_image005[110]

Shader based design, skeletal animation, animation blending, morph targets, post processing effects like HDR or DOF, COLLADA support

Lightweight next-generation engine with clean design

id Tech 1

C

clip_image003[57] clip_image008[26]

Free (GPL)

2.5D, fan-made enhancements: 3D

clip_image005[111]

clip_image005[112]

clip_image010[63]

C++ support in some fan-made versions.

Used to make Doom WAD's, Ports and Mods. Large active community

Official version technically outdated/limited, fan-made versions still maintained and updated

id Tech 2

C

clip_image003[58] clip_image008[27]

Free (GPL) or Commercial without GPL limits

3D

clip_image005[113]

clip_image005[114]

clip_image010[64]

C++ support in some fan-made versions.

Allows designing of Quake II Mods (with Quake IISource)

Technically outdated, may not work on later Windows + Linux machines.

id Tech 3

C

clip_image003[59] clip_image008[28]

Free (GPL) or Commercial without GPL limits

3D

clip_image005[115]

clip_image005[116]

clip_image010[65]

C++ support in some fan-made versions. Last C-based id Engine that works on all Windows and Linux machines.

Still used today

Relatively weak graphics compared to new Engines

id Tech 4

C++

clip_image003[60] clip_image008[29]

Free (GPL), previously commercial

3D

clip_image005[117]

clip_image005[118]

clip_image010[66]

First intended C++ id Engine

Full realtime shadows, XBOX Support (With XBOX License)

Graphics based on outdated stencil shadows (compared to modern next-gen games)

Ignifuga

Python/Cython

clip_image003[61] clip_image008[30] clip_image013[28] clip_image023[1] clip_image015[5]

Open Source (modified BSD) / Commercial license req'd for splash screen removal

2D via OpenGL or Direct3D 9 via SDL

clip_image010[67]

clip_image010[68]

clip_image005[119] clip_image006[28]

Component based, data driven, sprites, fonts, parallax scrolling

Dynamic development and fully static binary only deployment to targets. No hassle building and packaging for all targets using the Schafer tool.

Currently in alpha stage of development, though actively developed.

ika

C++

clip_image003[62] clip_image008[31]

Free (GPL)

2D via OpenGL

clip_image005[120]

clip_image010[69]

clip_image005[121] clip_image006[29]

very low overhead...

Irmo

C

clip_image008[32]

Free

clip_image005[122]

clip_image005[123] clip_image006[30]

Only a networking engine.

Irrlicht

C++/.NET

clip_image003[63] clip_image008[33] clip_image013[29]

Free (zlib/pnglib)

3D via DirectX(8,9), OpenGL or various software renderers

clip_image010[70]

clip_image010[71]

clip_image005[124] clip_image006[31]

Collision Detection, HDR, PARALLAX

Big Community, a lot examples and tutorials

Active development - Stable

IwGame Engine

C++

clip_image003[64] clip_image013[30] clip_image015[6] clip_image023[2] clip_image006[32]

Free

2D

clip_image005[125]

clip_image005[126]

clip_image010[72]

Built on top of the Marmalade SDK. Accelerometer, compass, multi-touch, http resource loading, unified ad API, auto screen size and aspect management.

Unified animating Ad API supporting 12 different ad providers for free game developers that want to maximise their games revenue potential. Fully documented and regularly updated.

Jad Engine - C# + MDX Game Engine

C#

clip_image003[65]

LGPL

3D via Managed DirectX

clip_image005[127]

clip_image010[73]

clip_image010[74]

Focused to graphics cards that support shaders 2.0 or better, It uses Newton Physics Engine to generate realistic movements and responses, HDR support (the graphic card must support floating point blending), FirstPerson and SelfDriven (exported from 3D Studio Max) cameras support, Animation Skeletal animation using channels, Imports directly MD5 files..., Postproduction system integrated in the engine, AI Engine: Genetic Programming Framework

Very more easy and intuitive interface, documentation and support are in english, a simple DLL

clip_image010[75] full documentation

Jamagic 1.2

Jamascript

clip_image003[66]

Commercial(Withdrawn from sale)

3D

clip_image005[128]

clip_image005[129]

clip_image005[130]

Inbuilt editors

Easy to Learn, online games like flash

No longer supported

JawsJS 2D Engine

Javascript

Browsers

LGPL

2D

clip_image005[131]

clip_image010[76]

clip_image010[77]

Supports both Canvas and HTML-based sprites

easy to get started, lots of examples

Needs a fairly new browser

JEngine SSE

C++

clip_image003[67] clip_image008[34]

Free (GPL)

2D via OpenGL

clip_image005[132]

clip_image005[133]

clip_image005[134]clip_image006[33]

Collision detection,Cg&GLS effects,GUI,etc. Contains full 2D open source framework with editor.

Jet3D

C/C++

clip_image003[68]

Free

3D via DirectX

clip_image005[135]

JGame

Java

clip_image003[69] clip_image008[35] clip_image013[31]

Free (BSD)

2D

clip_image005[136]

clip_image010[78]

clip_image010[79]

jMonkey Engine

Java

clip_image003[70] clip_image008[36] clip_image013[32]

Free (BSD)

3D via LWJGL

clip_image005[137]

clip_image005[138]

clip_image005[139] clip_image006[34]

A Java scene graph based 3D game engine. See the latest release notes

Joge

Java

clip_image003[71] clip_image008[37] clip_image013[33]

Free (Creative Commons License)

2D via LWJGL

clip_image005[140]

clip_image010[80]

clip_image010[81]

JOGRE Engine

Java

clip_image003[72] clip_image008[38] clip_image013[34]

Free (BSD)

2D

?

clip_image010[82]

clip_image010[83]

Java Online Gaming Real-time Engine.

Lavgine

Engine in C++, Games in Lua

clip_image003[73]

Free (non-commercial), Commercial (15% from profits), Closed Source

Hardware accelerated 2D

clip_image005[141]

clip_image005[142]

clip_image005[143] clip_image006[35]

LiveData Manager to swap data on change, Box2D-based physics, 3D Sound based on XACT (Content-driven API), Game Programming in LuaScript (optional: encrypted scripts), Achievement System, Networking, Unicode support for bitmap fonts, Profile system for saving in-game variables

Still evolving. Last update: 2011-07, developed by ONE person (consequence, integrity, the same API and quality of code :P)

Alpha phase (2011-07), lack of tools (in plans), developed by ONE person

Leadwerks 3d engine

C++/C#/Delphi/BlitzMax

clip_image003[74]

Commercial

3D via OpenGL

clip_image005[144]

clip_image005[145]

clip_image005[146] clip_image006[36]

Lightfeather 3d engine

C++

clip_image003[75] clip_image008[39] clip_image013[35]

Free (zlib/libpng)

3D via OpenGL

clip_image010[84]

clip_image005[147]

clip_image010[85]

GLSL and Cg shaders, HDR rendering, MRT , Portals, occlusion culling, PVS, Skeletal and Morphing Animation, Exporter for Blender to lfm format, Post-Processing Framework, Paging terrain with splatting (includes editor + generator), Built-in GUI, Particle system editor|more..

LÖVE

Lua

clip_image003[76] clip_image013[36] clip_image008[40]

zlib/libpng

2D via OpenGL

clip_image005[148]

clip_image005[149]

clip_image005[150]

Box2D wrapper library included out-of-box.

Maker3D

Custom

clip_image003[77] clip_image008[41]

Commercial

3D

clip_image005[151]

clip_image010[86]

clip_image005[152] clip_image006[37]

WYSIWYG editor, Crossplatform

RPG (role playing game) designer, character generation, battle system, easy to Learn, team management

Moai

C++ for the engine, Luafor the games

clip_image003[78] clip_image013[37] clip_image015[7] clip_image023[3]Google Native Client

Open Source (CPAL)

2D via OpenGL (WIP 3D)

clip_image005[153]

clip_image005[154]

clip_image005[155] clip_image006[38]

Physics (Box2D or Chipmunk), animation, analytics, monetization.

Good performance. Developed by a professional team. Cloud services.

MonoGame

C#

clip_image003[79] clip_image008[42] clip_image013[38] clip_image015[8] clip_image023[4]

Free (Open Source)

2D (3D is planned in 2012)

clip_image005[156]

clip_image005[157]

clip_image010[87]

Based on Mono

Open source XNA implementation

Multimedia Fusion 2

Custom - none scripting

clip_image003[80]

Commercial

2D

clip_image005[158]

clip_image005[159]

clip_image005[160] clip_image006[39]

ActiveX, Dll, many plug-ins, movement extensions

Easy to Learn, a favourite with younger developers, online games like flash

neabEngine

PHP

clip_image003[81] clip_image008[43]

Free / Commercial

2D (AJAX)

clip_image010[88]

clip_image005[161]

clip_image005[162]

Comes with the full source code, allows to add/edit modules.

NeL (alt:OpenNel)

C/C++

clip_image003[82] clip_image008[44]

Free/Commercial

3D via DirectX or OpenGL

clip_image005[163]

clip_image005[164]

CEGUI Integration

NemoX 3D Engine

VB/Delphi/.NET

clip_image003[83]

Free

3D via DirectX

clip_image005[165]

clip_image005[166]

clip_image005[167]

NeoAxis Game Engine

API: C#/.NET, Internally: C++

clip_image003[84] clip_image013[39] clip_image008[45]

Free/Commercial

3D via DirectX or OpenGL

clip_image005[168]

clip_image005[169]

clip_image005[170]

Game Demo, GUI Editor, Map Editor, Resource Editor (Mesh, Particles, etc...), ODE and PhysX by AGEA Support, and Documentation

You can purchase the source code of the engine.

NeoEngine

C++

clip_image003[85] clip_image008[46]

Free (MPL)

3D via DirectX or OpenGL

clip_image005[171]

clip_image005[172]

clip_image005[173] clip_image006[40]

NetGore

C#

clip_image003[86] clip_image008[47] clip_image013[40]

Free (Open Source)

2D (top-down and platformer) via SFML (OpenGL)

clip_image005[174]

clip_image005[175]

clip_image005[176]

Open source, multiplayer (MMORPG) support, very active development

Novashell Game Creation

Lua

clip_image003[87] clip_image008[48] clip_image013[41]

zlib/libpng

ClanLib (OpenGL)

clip_image005[177] clip_image006[41]

clip_image010[89]

clip_image005[178] clip_image006[42]

Fast Game Creation with Lua

sector based partitioning, easy editing files, level editor

Beta

OGE - Open Game Engine

C++

clip_image003[88] clip_image008[49]

Free (LGPL) / Commercial

3D (OGRE hence DX + OpenGL)

clip_image005[179] clip_image006[43]

clip_image010[90]

clip_image005[180] clip_image006[44]

Multithread and pluggable design, MyGUI, Physics (Bullet), Unicode, OGEd - Game Editor

Multithread, Plugin-based, Clean OO, Early stage of development

Early stage of development

OGRE

C++

clip_image003[89] clip_image008[50] clip_image013[42]

Free (LGPL) / Commercial

3D via DirectX or OpenGL

clip_image010[91]

clip_image010[92]

clip_image010[93]

Super 3D Engine, Support All HighEnd 3D Technologies, Plugin structure

Big Community, A lot examples and tutorials, made severals big games (like as air simulation, 3d adventure, 3d action), Open Source

too big source code

ORE

VB6

clip_image003[90]

Free

2d via DirectX7 / DirectX8

clip_image005[181]

clip_image005[182]

clip_image005[183]

Orx: Portable Game Engine

C/C++

clip_image003[91] clip_image008[51] clip_image013[43] clip_image015[9]

Free (zlib)

2.5D, hardware accelerated

clip_image005[184] clip_image006[45]

clip_image010[94]

clip_image010[95]

Data driven. Lightweight. Portable. Very easy to use.

Extended unique features (animation graph, hierarchical config files, independent clocks, hierarchical objects, differential scrolling, ...).

Ovorp Engine

.NET

clip_image003[92]

Free

2D via DirectX

clip_image005[185]

Panda3D

C++, Python

clip_image003[93] clip_image008[52] clip_image013[44] clip_image015[10]

Free

3D via OpenGL, DirectX or TinyGL

clip_image005[186] clip_image006[46]

clip_image005[187]

clip_image005[188] clip_image006[47]

Free models, documentation, simple installation

Used by Disney to make ToonTown, easy learning, very stable

PixelLight

C++

clip_image003[94] clip_image008[53] clip_image023[5]

LGPL

3D via OpenGL (+ experimental 3D via DirectX9)

clip_image005[189] clip_image006[48]

clip_image005[190]

clip_image005[191] clip_image006[49]

See official feature list

PLib

C++

clip_image008[54] clip_image003[95] clip_image013[45]

Free (LGPL)

2D and 3D via OpenGL

clip_image005[192]

clip_image005[193]

clip_image005[194]

Playground SDK

C++, Lua

clip_image003[96] clip_image013[46]

Free

2d/3d via DirectX/OpenGL on Windows/Mac

clip_image005[195]

clip_image010[96]

clip_image005[196] clip_image006[50]

Animation editor; dialog editor; particle editor; ultra-flexible particle system; 2d sprite system; dynamic texture atlas support; flat file support; background file reading support; small footprint.

Used by PlayFirst and many other developers to write over 100 published causal games. Best-in-class i18n. Excellent documentation and support in the forums.

No game editor (yet; one is planned).

PVLE game engine

C++

clip_image003[97] clip_image008[55] clip_image013[47]

GPL / Proprietary (Commercial)

2D/3D via OpenSceneGraph (OpenGL)

clip_image010[97]

clip_image010[98]

clip_image010[99]

Physics via ODE, object oriented

Small and easy game engine. Uses the most existing code possible.

Very young and still alpha

Popcap Framework

C++

clip_image003[98]

Free

2D

clip_image005[197]

clip_image010[100]

clip_image010[101]

Super Game Engine for developing super games like as Zuma

have great game ZUMA

Not 3D

PowerRender

C++

clip_image003[99] clip_image019[1]

Commercial

3D via DirectX

clip_image005[198]

clip_image010[102]

clip_image005[199] clip_image006[51]

Physics, Collision Detection, HDR

Easy to start, flexible engine

Bad working with shadowing

PTK Engine

C++

clip_image003[100] clip_image013[48]

Free and Commercial

2D

clip_image005[200]

clip_image010[103]

clip_image010[104]

Font, TTF, Spline, Tar files

Lightweight and Crossplatform

PureBasic

Basic

clip_image013[49] clip_image008[56] clip_image003[101]

Commercial

PySoy

Python

clip_image008[57] clip_image013[50] clip_image003[102]

Free (GPLv3)

3D via OpenGL

clip_image005[201] clip_image006[52]

clip_image005[202]

clip_image005[203]

Integrated Physics

No proprietary dependencies

Still in Beta (lacks features)

Quake Engine

C

clip_image003[103] clip_image008[58] clip_image013[51]

GPL, Commercial

Software, OpenGL

clip_image005[204]

clip_image005[205]

clip_image005[206] clip_image006[53]

Quake II Engine

C

clip_image003[104] clip_image008[59] clip_image013[52]

GPL, Commercial

OpenGL

clip_image005[207]

clip_image005[208]

Quake III Arena Engine

C

clip_image003[105] clip_image008[60] clip_image013[53]

GPL, Commercial

OpenGL

clip_image005[209]

clip_image005[210]

Raydium 3D

C

clip_image003[106] clip_image008[61]

Free (GPL)

3D via OpenGL

clip_image005[211] clip_image006[54]

clip_image005[212]

clip_image005[213] clip_image006[55]

Physics via ODE

Ray Game Designer 2

None needed

clip_image003[107]

Free

3D via OpenGL or Direct3D

clip_image005[214]

clip_image010[105]

clip_image005[215]

Collision Detection, Translucency, Lighting

Requires no programming, very easy to use, includes most needed tools

Very limited gameplay options, outdated graphics engine, very small community

Reality Factory

None needed

clip_image003[108]

3D viaGenesis3D(DirectX)

clip_image005[216]

clip_image005[217]

clip_image005[218]

RealmForge Game Engine

C# (.NET)

3D via Axiom(OpenGL)

clip_image005[219]

clip_image005[220]

clip_image005[221]

RetinaX

Completelty .NET 2.0 (C#). No wrapped C++ Libraries.

Free (BSD)

3D via Managed DirectX

clip_image005[222]

clip_image010[106]

clip_image010[107]

User Interface

Easy to start programming DirectX. Framework is well structured and you can modify it to your liking.

RPG Maker 2003

C/Delphi

clip_image003[109]

Shareware

2D

clip_image005[223] clip_image006[56]

clip_image005[224]

clip_image005[225] clip_image006[57]

Level Editor

Easy to use

Not open source

RPG Maker XP

C/Delphi

clip_image003[110]

Shareware

2D

clip_image005[226] clip_image006[58]

clip_image005[227]

clip_image005[228] clip_image006[59]

Level Editor

Easy to use

clip_image010[108]t open source

Saq2D

C#

clip_image003[111]

Free

2D engine via XNA

clip_image010[109]

clip_image010[110]

clip_image010[111]

scge

C++ / Python

clip_image003[112] clip_image013[54] clip_image008[62]

Free (Public Domain)

2D and 3D via OpenGL

clip_image005[229] clip_image006[60]

clip_image005[230] clip_image006[61]

clip_image005[231] clip_image006[62]

Gerneral Purpose Engine

Easy to use and versatile

Slot Constructor

Lua, C

clip_image003[113] clip_image008[63]

Commercial

2D and 3D via OpenGL

clip_image005[232]

clip_image005[233] clip_image006[63]

clip_image005[234] clip_image006[64]

Specially designed for casino and amusement game machines. Deploy to gaming boards and PC.

Extremely easy to use, has own IDE and other GUI tools.

3D is very limited.

SLUDGE

C++

clip_image003[114] clip_image013[55] clip_image008[64]

Free (LGPL)

2D via OpenGL

clip_image005[235] clip_image006[65]

clip_image010[112]

clip_image005[236] clip_image006[66]

Engine for graphic adventures

Easy to use

Spring RTS Engine

C++/Lua

clip_image008[65] clip_image003[115] clip_image013[56]

GPL2

3D via OpenGL

clip_image005[237] clip_image006[67]

clip_image005[238]

clip_image005[239] clip_image006[68]

Large User Community

SoftPixel Engine

C++

clip_image003[116]

Free (zlib/libpng)

3D via OpenGL 2.0

clip_image005[240] clip_image006[69]

clip_image005[241] clip_image006[70]

clip_image005[242] clip_image006[71]

Collision Detection, Shader (GLSL), very simple

Very easy like BASIC languages but powerfull like C++ & OpenGL

Active development. Some unfinished parts

Source Engine

C++

clip_image003[117] clip_image008[66]clip_image006[72]

Commercial/Free

Direct3D

clip_image005[243]

clip_image005[244]

clip_image005[245] clip_image006[73]

Havok Physics, Valve Faceposer Technology, VGUI, HDR, Steam Community,SDk

Sphere RPG Engine

Javascript

clip_image003[118] clip_image008[67] clip_image013[57]

GPL

2D via software or hardware (OpenGL or DirectX) rendering

clip_image005[246]

clip_image005[247]

clip_image005[248] clip_image006[74]

Map editor, tile editor, image editor, imports RPG Maker resources

Very good map/tile engine, cross-platform, imports many resources, and fully featured to make your own SNES/Genesis style game.

The Nebula Device 2

C++

clip_image003[119]

Free

3D via DirectX

clip_image005[249]

clip_image005[250]

clip_image005[251]

Thousand ParsecFramework

Python, C++, others

clip_image003[120] clip_image008[68] clip_image013[58]

Free (GPL)

2D/3D

clip_image010[113]

clip_image005[252]

clip_image005[253]

Framework for online turn based space strategy games

TNT Basic

Basic

clip_image013[59]

Free (GPL)

2D

clip_image005[254]

clip_image010[114]

clip_image010[115]

Torque

C++

clip_image003[121] clip_image008[69] clip_image013[60]

Commercial

3D via OpenGL

clip_image005[255] clip_image006[75]

clip_image005[256]

clip_image005[257] clip_image006[76]

Mission Editor, Terrain Editor, Mac and Linux Support, WYSIWYG GUI Editor, Particle Engine, Theora Video, Multiple Language Support

Source Code Included, Large Community, Many 3D modeling exporters

Buggy, slow, outdated

Torque2D

C++

clip_image003[122] clip_image008[70] clip_image013[61]

Commercial

2D

clip_image005[258] clip_image006[77]

clip_image005[259]

clip_image005[260] clip_image006[78]

Truevision3D

VB/Delphi/C++/.NET

clip_image003[123]

Free for learning/Commercial

3D via DirectX

clip_image005[261] clip_image006[79]

clip_image005[262]

clip_image005[263] clip_image006[80]

Physics, Plugins for popular modeling packages, Active user base, Normal Mapping, Relief Mapping, and complex shaders

UnrealEngine2 / 2X / 3

C++

clip_image003[124] clip_image008[71] clip_image013[62] clip_image017[2] clip_image019[2]

Commercial

3D

clip_image005[264]

clip_image005[265]

clip_image005[266] clip_image006[81]

Physics, HDR (UE3)

high cost

UnrealEngine2 Runtime

C++

clip_image003[125] clip_image008[72] clip_image013[63] clip_image017[3],clip_image019[3]

Non-Commercial / Educational

3D

clip_image005[267]

clip_image005[268]

clip_image005[269] clip_image006[82]

Need to be a 'serious developer'. Still pricey. No source code.

Unigine

C++

clip_image003[126] clip_image008[73] clip_image013[64] clip_image017[4] clip_image023[6] clip_image015[11]

Commercial

3D

clip_image005[270]

clip_image005[271]

clip_image005[272] clip_image006[83]

DX9/DX10/DX11/OpenGL/OpenGL ES render, shaders 5.0, hardware tessellation, stereo 3D, physics, pathfinding, sound, GUI

Great 3D Engine, image quality like as CryEngine and Unreal, small cost, more tools

Unity

C++

clip_image003[127] clip_image029[1], Browsers

Free/Commercial

3D via DirectX or OpenGL

clip_image005[273]

clip_image005[274]

clip_image005[275] clip_image006[84]

Ageia PhysX, terrain engine, extensible shaders, JIT compiled scripts, collaboration tools, friendly community, most file formats supported

Smooth workflows, lots of powerful tools, complete documentation

Advanced features cost more, source code is separate license

Verge

Lua or VergeC

clip_image003[128] clip_image013[65] clip_image008[74]

Free (BSD license)

Software 2D

clip_image005[276]

clip_image005[277]

clip_image005[278]

Friendly community, tile-based map editor tool, fully scriptable game

Extremely easy to rapidly prototype something, simple-to-use software graphics.

Requires some knowledge of scripting. Does not have hardware accelerated graphics.

vbGORE

VB6

clip_image003[129]

Free (Open Source)

2D via 3D

clip_image005[279]

clip_image005[280]

clip_image010[116]

Designed towards ORPG and MMORPG design

[Valve]

Python

clip_image003[130] clip_image008[75]

commercial

2D/3D via DirectX and OpenGL

clip_image005[281]

clip_image010[117]

clip_image005[282] clip_image006[85]

Many

Vision Game Engine

C++

clip_image003[131] clip_image019[4] clip_image017[5] clip_image029[2]

Commercial

DirectX 9-11

clip_image005[283]

clip_image005[284]

clip_image005[285] clip_image006[86]

Supports XBLA, PSN and WiiWare. Includes FMOD and RakNet free-of-charge. Includes 20+ integrations to other 3rd party middleware (physics, AI, weather, vegetation, audio, asset management and more)

Optimized for many platforms. Highly flexible workflow. Modular architecture. Flexible pricing. Excellent support.

Not as well known. Community is small, but growing.

Visual3D Game Engine

C# (.NET)

clip_image003[132] clip_image019[5]

Commercial, Free for Open Source and Educational Use

3D via XNA

clip_image005[286]

clip_image005[287]

clip_image005[288] clip_image006[87]

All-in-one Game Development Toolset, HDR, Per-pixel, Parallax, Dynamic Soft Shadows, God Rays, SSAO*), Entity/Model/Material Editor, Particle Editor (Explosions, Volumetrics) , Advanced Physics (Rag Dolls, Vehicles), Terrain Editor (Procedural Generation, Massive Full-Globe Terrain, Land Cover Painting, Geodata), AI and Pathfinding, Multiplayer Networking, Cinematics/Path/Road Editors, Real-time In-Game Scene/Mission Editing, Script/Conversation Editor, 3D Audio, Day-Night Cycle, Free Starter Kits/Asset Libraries, C# Shaders, UI Editor, Web Deployment*, Collaborative Editing* (* coming soon)

tIDE map editor / xTile engine

C# / XNA

clip_image003[133] clip_image019[6]

Free

2D Tile Map Editor and Engine

clip_image010[118]

clip_image010[119]

clip_image010[120]

WYSIWYG parallax layer editing, animated tiles, custom properties,

plugin support, XNA-ready content pipeline extensions

YAKE Engine

C++

clip_image003[134] clip_image008[76]

Free

3D via OGRE(OpenGL), Direct3D9

clip_image005[289]:clip_image006[88]

clip_image005[290]

clip_image005[291] clip_image006[89]

GUI via CEGUI, physics viaODE

Yage

D

clip_image003[135] clip_image008[77]

Free (LGPL)

3D via OpenGL

clip_image005[292] clip_image006[90]

clip_image010[121]

clip_image010[122]

YVision

.NET(C#)

clip_image003[136] clip_image013[66], Silverlight 5, Windows Phone 7

Commercial (Free)

Axiom

clip_image005[293]

clip_image010[123]

clip_image005[294] clip_image006[91]

Integrated physics(BulletXNA), image processing(OpenCV), augmented-reality(SLARToolkit)), multi-threading, steering behaviors.

Zak Engine

C++

clip_image003[137]

Free

2D via DirectX 8.1 and 9.0

clip_image005[295]

clip_image005[296]

clip_image005[297] clip_image006[92]

Tiles Maps (AnaConda Map Editor), Sprites, Particle Systems, Bitmap Fonts

Very stable, easy to use, fast games development

ZFX Community Engine

C++

clip_image003[138] clip_image008[78] clip_image027[1]

Free (LGPL)

3D via DirectX and OpenGL

clip_image005[298]

clip_image005[299]

clip_image005[300] clip_image006[93]

Edge2d Engine

C++

clip_image003[139] clip_image008[79]

Open Source

Library independent(both DirectX and OpenGL etc

clip_image005[301]

clip_image010[124]

clip_image010[125]

very object-oriented and plugin-based, you can create your own graphics plugin without modified base library

Phoenix Engine

C#

clip_image003[140]

Beta

SDL.NET

clip_image005[302]

clip_image005[303]

clip_image010[126]

IronPython

Map Editor, Sprite, Plugin system, e.t.c

Weaver

C

clip_image008[80]

Free (GPL)

2D

clip_image005[304]

clip_image010[127]

clip_image010[128]

Ogg Vorbis support, complete framework, collision detection

Easy to start, learn and use. Fast 2D engine. Self-contained system.

 

External Links

§ 3D Engines List

§ DevMaster.Net 3D Engine Database

§ Jeux Infinis Engine Database (french)

posted @ 2012-04-20 15:06  Pulaski  阅读(1228)  评论(0编辑  收藏  举报