Welcome to Axe Game Engine

Axe is aimed at being a multi-lingual and multi-platform 2d and 3d game engine. The current version of the engine was developed in Java and utilizes LWJGL for graphics. Axe was built for efficiency and is very feature rich:

  • Animation Framework
  • Artificial Intelligence
  • Networking
  • Particle Effects
  • Dynamic User Interface
  • Physics Engine
  • Audio Engine
  • Tools


Axe is a work in progress. It has been under active development since August 2011 and has been incrementally designed since 2006. Axe is a result of many years of trial and error game engine development. Axe was originally in VB.NET/DirectX, ported to C#/XNA, then to Java/JOGL, and finally to its current development platform Java/LWJGL. C++/SDL/OpenGL and C#/XNA engines are in the works, but currently have a subset of functionality.



The Animation framework is based on something I call an Attribute. An attribute is something that can have basic operations done on it, for example: addition of another attribute of the same type, scale by some value, interpolate a value between a start and an end, etc. Examples of Attributes are colors, vectors, floats, ints, matrices, cameras, rectangles, bounds, sprites, pretty much anything that implement the Attribute interface. With these basic operations several generic animation classes can be created:

  • Path
  • Spring
  • Event
  • Schedule
  • Animation
  • Animator


A path has a single function: Set an attribute to some value given a delta between 0.0 and 1.0. Here are examples of Path implementations available:

  • PointPath: Sets the input to a single value
  • Tween: Interpolates the input between a start and end value
  • JumpPath: Sets the input to the closest point in a set of points, without interpolation
  • IntegralPath: Sets the input by evenly interpolating between a set of points based on the delta
  • TimedPath: Given an array of points and an array of times, the input will be interpolated between the points based on the delta
  • LinearPath: A TimedPath where the time is calculated based on the distances between the array of points
  • QuadraticPath: A curve between 3 points (one control point)
  • CubicPath: A curve between 4 points (two control points)
  • BezierPath: A curve between n points (n - 2 control points)
  • ComboPath: A set of paths and an array of times, the input will be interpolated between the paths based on the delta
  • CompiledPath: A JumpPath where an input path is given and the set of points is precalculated
  • UniformPath: A TimedPath where the points are evenly separated (based on distance)


A Spring animates an attribute to some resting value. Examples of Spring implementations available:

  • LinearSpring: Given spring stiffness and damping, the attribute will be animated to a resting value
  • DistanceSpring: Given spring stiffness and damping, the attribute will be animated to a resting value within a given distance
  • BoxSpring: Similar to a LinearSpring, behaves differently


An event animates some attribute over a path. An event can have a delay, can loop any number of times, can delay between execution, and can have an Easing for the attributes motion on the Path.


Manages a list of events and provides utility methdods for animating and queueing attributes


A path of frames that are animated in some duration with some easing. An animation can have an animation to play next once its complete.


Controls an attribute by playing, stopping, pausing, queueing, and transitioning between a set of animations.

Artificial Intelligence


Steering Behaviors

Game Solving

Given the state of a game, and all possible moves in its current state, a solver can find the first or all end game states and the path of moves it took to get there.

Finite State Machine

Distribution and Probability