SilenceEngine - A 2D/3D Game Engine

A 2D/3D Game Engine written on top of LWJGL3

[h1]What is SilenceEngine?[/h1]
SilenceEngine is a 2D/3D game engine that takes care of low level aspects of game development like graphics, input handling, asset loading and collision detection for you, meaning you only need to make your game. It lets you focus on the game play and game design, by doing most of the hard work for you.

The main feature of SilenceEngine is it’s simplicity, and it greatly reduces the amount of code you need to write by taking care of almost everything automatically for you. Though it is meant to take care of everything automatically, it is also completely customizable. Here are a list of features of it.

  • State Based Games:

SilenceEngine supports separating the game logic into different states, like intro state, story state, play state, high score state, game over state, and any other state that you are going to create. This allows you to keep stuff separate and your code base clean and easy to read.

  • Module Based Engine:

SilenceEngine is based on different modules, it is a collection of modules called as engines. There are core engine, audio engine, graphics engine, input engine, and collision engine, and all these engines make up the SilenceEngine. It is up to you on how you use it, you can use all these as a whole, or you could use each of them separately. Either way, they work.

  • Completely Customizable:

SilenceEngine is designed to be completely customizable. You can change everything from the ResourceLoader to the Game Loop, and you can also change the entity parameters. It is totally flexible and also easy to use. It is finally up to you whether you want to extend the components, or to re-implement them in your way.

  • Automatic Collision Detection:

SilenceEngine features with automatic collision detection. All you need to do is give your entities a collision shape, and register the classes in the collider, and the collisions, along with collision response is done for you, in both 2D and 3D. The CollisionEngine uses SAT (Separating Axis Theorem) to determine collisions, and hence you get your collision response with good accuracy.

  • Object Oriented Wrappers for OpenGL and OpenAL:

If you think that all the above features are not useful for you, and you want more performance and you love going low level, SilenceEngine provides object oriented wrapper classes for OpenGL and OpenAL. It is up to you how to use them, and other parts of the SilenceEngine cooperates with you.

The above list is only half what SilenceEngine offers to you. It is currently in heavy development, and more features are yet to arrive. In the meanwhile, take a look at the source code, and the example games to get an idea of how to use this engine.

[h1]Is it only for games?[/h1]
Perhaps not, you can create any form of OpenGL application using SilenceEngine. It provides you with OpenGL classes in the package, which cleanly wraps the OpenGL functions into Java classes, making them more easy to use. All you have to take care of is that you must call the dispose() on those objects when you no longer need them.

It is also easier to use in development mode as we will check for OpenGL errors after every call to the OpenGL functions and report you the errors, if any exist, in the form of GLException allowing you to get rid of the errors quickly and easily. By the way, everything in SilenceEngine is modern, and there is no deprecated stuff. I’m proud to say that this engine only uses OpenGL 3.3 (no deprecated OpenGL).


[]This is licenced under MIT licence, which you can find here.
]This game engine uses JOrbis library from JCraft which are licenced under LGPL.
[]This game engine uses J-Ogg library from on a free permissive licence.
]This game engine is written on top of LWJGL 3. You can find it’s licence here.


[]SilenceEngine website (
]SilenceEngine forum (
[]SilenceEngine JavaDocs (Less updated) (
]ScorpionHunter (SilenceEngine 2D Demo Game) (
[]Blox (Incomplete, SilenceEngine 3D Demo Game) (
]GitHub Repository (

Is it really a game engine or a game library/framework?

More importantly at this point, does anyone care?




If there is no license, it doesn’t mean that it’s open source, it’s under copyright by default. Please choose a license:

Please mention the license of the third party libraries you use too (I already do so).

I’ve looked at the native loader. Do you plan to support ARM? I remind you that some laptops use ARM CPUs. There is probably a better way of writing FileUtils.readLinesToStringArray by using NIO2.

Is there a demo of your engine? What does it bring compared to LibGDX?

Game Engines: Unity, Udk, Cryengine, Jmonkeyengine, etc
Librarys/Frameworks: Libgdx, Slick2d, etc

Btw, I really like the logo ;D

Its quite a big difference :stuck_out_tongue:

LibGDX uses several sets of low level bindings, it shouldn’t be put into the same category than the APIs on which it relies for its hardware accelerated graphics and JMonkeyEngine is rather a 3D engine than a game engine.

@SHC Your math classes are quite poor for the moment and you mainly just wrap GLFW and its “friend”. Is it reasonable to set MAX_VERTICES_IN_BATCH once for all?

[quote]LibGDX uses several sets of low level bindings, it shouldn’t be put into the same category than the APIs
Desktop/Android/BlackBerry/iOS/HTML5 Java game development framework

Straight from the libgdx homepage.

Really? Wow! I didn’t know that! I meant given how many we’ve seen recently does it really matter any more?



No, it really doesn’t matter, but it may confuse a few people who expect it to be something like unity.

And what does LibGDX use in desktop environment? The “library” that you just put into the same category:

Please explain.

It maybe currently a framework, but I also have plans to add scenegraph, level loaders (tmx) and also simple world physics, which would make it an engine. At this point, nobody may care, but I thought to post here, to know the feedback (constructive of course), so that I can improve it a lot.

And guys, please don’t compare mine with LibGDX, that would be comparing an ant with an elephant, I just wanted to document the progress, and also notify you at the same time, so I made a post here.

I don’t believe that having no licence means it’s not opensource, I meant by opensource, the source code is open to all, and I put no restrictions on how you guys use the code, I don’t want to do so, hence I selected no licence. However, if you do insist that software should have a licence, please suggest me one, that would allow the user to do anything he wants with the engine.

[quote]but I also have plans to add scenegraph, level loaders (tmx) and also simple world physics, which would make it an engine.
Woo Hoo!!! ;D

Yep, I agree that they are really poor, atm, mainly since the age of this is just two days. As per the MAX_VERTICES_IN_BATCH, I heard that some cards have limits on the size of the VBO datastore, and that too, the least thing is they only allow 4MB of data. So I set the max vertices to 4096, so 4096 * 4 * 4, i.e., 4096 vertices with 4 components each of 4 bytes would be sufficient in that memory. Should I increase that limit?

I don’t want to annoy you but it was mainly a legal reminder and it might refrain some developers to use your stuff. You can choose a permissive license like ASF or BSD 3-Clause if you want as few restrictions as possible or even Public Domain Dedication Creative Commons 0 but not sure it is suitable for the code. Look at Unlicense too.

You should separate the program and the shaders. I’m still reading your source code.

Yes, it depends on your target. I remember that there are some OpenGL constants that you can use but sometimes they return crazy values.

[quote]mainly since the age of this is just two days.
So you wrote all that code in 2 days? congrats :wink:

I decided to go with MIT licence guys, added the LICENCE file to the repository.

It is possible to write your own shaders. Just create a Shader object with your sources and use it. The shader that is by default, is a simple pass-away shader that doesn’t do anything other than just passing the values as they are.

I don’t get what you mean, it supports every platform that LWJGL3 has natives for, my NativesLoader just extracts them to a temp directory, and assigns the org.lwjgl.librarypath variable so that natives can be found.

Your native loader uses no cache. The libraries are deleted on exit. As a consequence, each time you run an application based on your engine, you have to extract the libraries. It increases a bit the startup time. Maybe you should add a flag to enable/disable this feature.

It’s possible to cross-compile the library that you use but according to its platform-dependent Ant script used to build the native libraries, you’re right, it doesn’t support ARM :frowning:

I’ve seen that you have added a license into your project :wink: