A cross-platform 2D game engine


Linux macOS Windows MinGW Emscripten CodeQL


nCine is a cross-platform 2D game engine.
It is released under the MIT License, Copyright (c) 2011-2021 Angelo Theodorou.
For additional information: https://ncine.github.io



  • GLEW
  • GLFW 3.x
  • SDL 2
  • libpng
  • libwebp
  • OpenAL-soft
  • libogg, libvorbis, libvorbisfile
  • Lua 5.4
  • Dear ImGui
  • Nuklear

Supported Platforms and Compilers

  • Windows (MSVC, MinGW-w64 on MSYS2)
  • macOS (Clang)
  • Linux (GCC, Clang)
  • Android (GCC, Clang)
  • Emscripten

Development Tools

  • git
  • CMake
  • Qt Creator
  • Doxygen with GraphViz
  • Valgrind
  • Cppcheck
  • clang-format
  • Google Test and Gcovr
  • Tracy frame profiler
  • Google Benchmark
  • RenderDoc graphics debugger



Coding Conventions

  • Indent with tabs (4 spaces) but use spaces for continuation line alignment
  • Allman brackets
    • No brackets around one line conditional statements
  • Padding space after parenthesis headers (if, do, while, for, switch)
  • Align pointer and reference operator to the variable or function name
  • inline keyword always before virtual and static
  • Mark an override method with the override specifier and remove virtual
  • Access specifiers order: public, protected, private
    • One half indent for access specifiers (2 spaces)
  • Declarations order: typedefs and enums, data members, constructors, destructors, methods
    • Friends defined in the private section of a class, after everything else
  • One space padding around operators
  • Use of the explicit keyword all the times it makes sense

Naming Conventions

  • Pascal case for classes, enumerations, typedefs and constants
  • Camel case for variables, functions and parameters
  • All upper case for enumerators in an enumeration

Documenting Conventions

  • Put Doxygen brief descriptions in header files and additional documentation in implementation ones
  • Use Qt style for Doxygen detailed descriptions (/*! */) and end them with a period
  • nCine onboarding for Windows feedback

    nCine onboarding for Windows feedback

    Hi! Thanks for all the great work up to providing an onboarding document for newcomers.

    I've just followed https://ncine.github.io/build-windows/ using CMake v3.21.3 for VS2019 on x64 architecture and stumbled a few times (bottom line, I've went for BFU approach to see if it could stand it).

    Performing the step "Build the dependency libraries" -- when generated nCine-libraries solution, it did not build project_glew out of the box with the following CMake error CUSTOMBUILD : CMake error : No platform specified for -a -- my workaround: I've edit nCine-libraries/cmake/gewl.cmake and slipped in the line set(CMAKE_GENERATOR_PLATFORM x64) after line 3 -- then it built ok (for me, since I've fixed the platform)

    Performing the step "Build the nCine library" -- nCine requires "nCine-data" directory, but when you're downloading things from github master, the folder is named "nCine-data-master" -- I would recommend to explicitelly show the required directory layout when starting building nCine at the beginning of the walkthrough -- also, default CMAKE_INSTALL_PREFIX is pointing to Program files, which is protected by default, I would recommend explicitelly tell the user to change this value in CMake to points outside Program files -- walkthrough is not mentioning installing the nCine, i.e., after I open generated nCine.sln and build it, I need to manually invoke the build of INSTALL project in order to gen "nCine directory"

    Performing the step "Build example ncPong" -- here CMake configuration expects NCINE_DIR environment variable to exist and point to nCine build; this is not mentioned by the walkthrough at all -- then again, it expects "ncPong-data" directory but user downloads "ncPong-data-master" from GitHub

    After above patches, it built ok and run flawlessly, which is good job done at your side!

    opened by kefik 4
  • Build nCine with the OpenGL ES support (on Linux).

    Build nCine with the OpenGL ES support (on Linux).


    • Hardware: rpi-logoRaspberry Pi 4B
    • Platform: GNU/Linux
    • Architecture: aarch64
    • nCine release: master commit 1b7de7d


    Currently building the nCine with the test app forces the use of the OpenGL 3.3, even if the device doesn't fully support it, but it works with OpenGL ES 3.0. The built itself will finish successfully, but the test application won't work, when trying it on the device supporting OpenGL >3.3 or doesn't supporting it at all, which is the case for most ARM devices.


    The test apps will run using the GLES 3.0 backend on the ARM devices working under Linux distributions.


    - HH:MM:SS  [L6] - void ncine::SdlGfxDevice::initDevice() -> SDL_GL_CreateContext failed: Could not create GL context: GLXBadFBConfig

    (anonymised time)

    Currently known workarounds:

    • Use MESA_GL_VERSION_OVERRIDE=3.3 to force the use of the OpenGL 3.3, even if it isn't supported by hardware (may fail if hardware/software supports GLES API only).
      • NOTE: This workaround works fine with the Raspberry Pi 4B device.
    opened by SpacingBat3 2
  • What about a package manager?

    What about a package manager?

    If I weren't a game creator, it would take me time to find all the packages. But what if you try to add a package manager for faster build, for example, conan?

    opened by Trimsku 1
  • Resource reloading and fault tolerance

    Resource reloading and fault tolerance

    I'm working on some changes in resource loading in order to support a typical GUI tool workflow, think of an editor. :wink:

    You should be able to load a resource, say a texture, from a file, then assign it to a bunch of sprites and then change the texture by loading a second file and have all your sprites automatically update.

    Recently I have committed some changes to enhance the fault tolerance of loading a resource by providing an optional class that wraps the data being loaded and that can be queried to see if the process has been successful.

    I'm thinking about changing the approach, delete the data classes and unify the reload and the fault tolerance API.

    This way you will be able to create an empty texture and load it with data at a later time. You will be able to load data from texels in memory (making it possible to have CPU procedural generated textures), or from a file. You will be able to load a new file to the same texture and if the loading process fails the texture will be left unchanged.

    I should also create a new apptest_loading that shows how to load resources (from file, from a memory file, from a memory buffer) and how to reload them.

    The feature branch

    • new_loading -> The branch has been merged to master

    As a starting point I suggest you have a look at the new apptest_loading.


    • [x] Add an empty Texture::Texture() constructor that only creates the OpenGL texture name (glGenTextures)
    • [x] Add an empty Font::Font() constructor and check AudioBuffer::AudioBuffer()
    • [x] In apptest_loading test changing a texture and an audio buffer format by assigning a new object
    • [X] In apptest_loading add a section to load sounds and fonts from memory and file
    • [x] In apptest_loading check the fault tolerance by trying loading non existing files or files and memory buffers with random data
    • [x] Check how feasible is to reload in the case of AudioStream (and add AudioStream::AudioStream())
    • [x] Study how to integrate OpenAL AL_*_OFFSET source properties for sound buffer or stream seeking
    • [x] Update apptest_audio to use the new ncine-data/sounds files (and add the display of audio offsets)
    • [x] Remove any FATAL_ASSERT while loading or creating resources
    • [X] Rewrite the Texture/Audio/FontData commit to split some changes from the new_loading one
    • [x] Before merging or rebasing run clang-format, write the master branch changelog and add apptest_loading to the web-tests
    opened by encelo 1
  • CMake generate android-libraries-build does not generate nCine-android-external

    CMake generate android-libraries-build does not generate nCine-android-external

    I follow the Build for Android, after building the dependency libraries, I try to build the nCine library , and I got error: image

    image I thought maybe I need to build the solution just like generating nCine-external. I open Visual Studio 2019 and build the solution, but I got error:

    Performing configure step for 'project_ogg'
    . \configure' is not recognized as an internal or external command

    I am very interesing at this game engine. Did I misunderstand something or doing something wrong?

    opened by Soft-me 1
  • Multiple viewports and cameras

    Multiple viewports and cameras

    The main rationale behind supporting viewports is the possibility of having off-screen render targets, a feature that can be used together with custom shaders (#2) to allow for post-processing effects like bloom, depth of field or normal mapping illumination.

    An off-screen render target might also be used to scale the game output to a custom resolution that is different than the screen one (it could be a workaround for Android fixed resolution, for example).

    The viewport will also allow the use of a dedicated camera class that should alleviate the need for a dummy node to simulate camera transformations like in the current version of apptest_camera. The camera class will use uniform variables to send data to nodes: projection and view matrices will be multiplied inside the vertex shader.

    By also adding a "dirty flag" for scene node transformations it will be possible to move nodes with the camera without recalculating their scenegraph transformations, thus saving a lot of precious CPU time. Screen culling code should also be updated to work with viewports and cameras.


    • [x] Move clear color and OpenGL viewport methods of the IGfxDevice class in the Viewport one
      • [x] Fix compilation of external projects (ncParticleEditor, ncJugiMapGuiDemo, etc...)
      • [x] Use the new camera in the ncTiledViewer project
    • [x] Have viewports with a camera but no texture, in order to add more transformation flexibility
      • [x] Add the option to use a texture-less viewport with a camera class in apptest_camera
    • [x] Fix screen culling within a viewport (maybe with some form of spatial hashing?)
    • [x] Add dirty flags to avoid unneeded scene node transformations and AABB box recalculations
    • [x] Replicate the new class and methods in the Lua API





    opened by encelo 0
  • Continuous Integration issues

    Continuous Integration issues

    • [x] macOS: The dynamic linker cannot find the dependency libraries when those are built by the C.I. This issue has been fixed on 28/01/2022 with an update to nCine-libraries.
    • [x] Windows: DevDist workflows fail because Doxygen cannot run dot to create graphs
      • CUSTOMBUILD : error : Problems running dot: exit code=1, command='dot'
    • [x] Linux and MinGW: some tests from gtest_list_movable fail, only on GCC in Release. The issue disappears when compiling List.h with #pragma GCC optimize ("O2") instead of O3. On 29/01/2022 the problematic tests have been disabled when compiling on GCC in Release.
    • [x] MinGW: C:\msys64\mingw64\bin/llvm-strip.exe: error: 'D:/a/nCine/nCine-build-DevDist/libncine.dll': unexpected associative section index, only with Clang. This issue still occurs but on 27/01/2022 I disabled stripping of binaries on MinGW with Clang to avoid it. I have also opened an issue to report it.
    opened by encelo 0
  • Reloading and fault tolerance for Lua scripts

    Reloading and fault tolerance for Lua scripts

    There is another important change in resource loading to order to support a GUI tool workflow: the ability to load a Lua script and being able to run it safely even if it has errors.

    • [x] Modify LuaDebug::assert so that it doesn't cause any assert
    • [x] Provide a way in the API to retrieve the errors in a Lua script
    • [x] In apptest_loading add a section for Lua scripts and check their fault tolerance

    LÖVE 2D style distribution

    • [x] Add a LuaDist options preset, tested by the C.I. and uploaded in the artifacts
    • [x] It should disable things like ImGui, Nuklear, threads, documentation, etc...
    • [x] It should not build tests, but only apptest_lua and install it under a different name (maybe luancine)
    • [x] apptest_lua should load a script.lua script and show errors with a TextNode
    • [x] It should use argc and argv to be able to specify a script name on the command line

    Leftovers tasks from #3

    • [x] Consider making the ITextureSaver interface public for users to save textures to files
    • [x] ~~Consider creating a IAudioBufferSaver interface to save audio samples~~
    • [x] Consider allowing the creation of a Sprite without a Texture or a TextNode without a Font just like you can now create an AudioBufferPlayer without an AudioBuffer
      • It might be useful when object pools are needed, you would then create an array of sprites and assign textures later
    opened by encelo 0
  • Move template scripts inside the engine

    Move template scripts inside the engine

    This is another task I have had for some time. The objective is easy: minimize the effort I have to put into updating the CMake scripts in every project and make them fetch what they need from the engine directory.

    Many times a change in the engine will require a change in project scripts. With this new way of handling the scripts a project will use whatever version the engine provides for building. I would still like to retain the option to easily copy the files in a project directory to be able to customize them.

    • [x] Projects should just use a single CMakeList.txt file containing what is currently in the package_info.cmake script plus some additional code to find the engine and the rest of the scripts
    • [x] Simplify ncTemplate and all other projects to refer to nCine for updated setup and compile scripts
    • [x] Check if there is still any need for the devdist cmake scripts
    • [x] Consider renaming every PACKAGE_ variable prefix and every package_ file name prefix to PROJECT_ and project_
      • [x] Update ncline with new variables
      • [x] Update build instructions on the site
      • [x] Update README.md of ncTemplate
      • [x] Rename PACKAGE_ and package_ variables in GitHub workflow scripts
      • [x] Rename variables in Arch Linux PKGBUILD scripts
      • [x] Open a Pull Request to rename PACKAGE_DEFAULT_DATA_DIR in JugiMap projects
    • [x] Make a more flexible support for data and icons in arbitrary directories and don't fail if icons are not available, fallback to nCine icons in nCine-data if those are available
    • [X] ~~Provide a .gitignore file so that copied template files can be automatically ignored in the game repository~~


    • The old project scripts were able to automatically pick nCine location when it was installed system-wide on Windows and Linux.
    opened by encelo 0
  • Minor bugs and improvements

    Minor bugs and improvements

    Those are some small bugs I have discovered recently:

    • [x] Font::Font(const char *fntFilename) will not load the corresponding font bitmap texture on Android if using assets
    • [X] The package_copy_targets.cmake scripts on Windows does not copy DLLs
      • Should it be changed to copy the DLLs to more places? Not only the build directory but also in the Release and Debug directories
    • [X] Add a check for the Java package name to warn the user if the underscore is used
    • [x] Provide meaningful defaults for the data path configuration
    • [x] Use AllocConsole on Windows to open a console in Debug mode even when using WinMain
    • [X] Investigate the use of CMake's MAP_IMPORTED_CONFIG_CONFIG so that, for example, a project built in Release mode can correctly link to ncine_d.lib and ncine_main_d.lib
    • [x] Use ncline code to add colored logging output on all platforms
    bug enhancement 
    opened by encelo 0
  • Custom Shaders

    Custom Shaders

    It has been a long time now since I first thought about the possibility to provide a way for users to override the default shaders.

    The task has been delayed for a long time because I had other priorities and because I thought I needed to refactor (yes, again) the rendering system before trying to add this interesting but possibly complex feature.

    As both Jugilus and the team behind the deadfish game recently asked for this I decided to shuffle it higher in my priority list. :wink:

    Don't hesitate to comment on this issue or on our Discord server! :speech_balloon:


    • [x] Create a class abstracting the shader state of a DrawableNode
    • [x] Shader reloading and recompilation should be fault tolerant (like other resources in #3)
    • [x] Should the Shader class derive from Object?
      • What are the implications of this choice? :thinking:
    • [x] Provide a way for the user to decide how matrices are passed
      • Like the name of the model view matrix uniform and if it is in a named block or not
    • [x] Provide a way for the user to link the semantics to an attribute name
      • "aPosition contains vertex positions"
    • [x] Proper handling of shader loading and compilation errors
      • Should the application exit? Can the shader be reloaded? :thinking:
    • [x] Find a way not to sacrifice batching for nodes with custom shaders
    • [x] Should there be always available uniforms and attributes with default names or all data driven?
    • [x] Proper testing with all drawable node types
    • [x] Test on Android and Emscripten, test glapptest_fbo_cube
    • [x] When loading custom shaders it should be possible to use default for certain stages
      • For example use the default Sprite vertex shader and only provide a custom fragment one
    • [x] Add a corresponding Lua API for custom shaders
    • [x] Before merging or rebasing: run clang-format and check compilation of all commits, write the master branch changelog, update the features section, and add apptest_shaders to the web-tests, then delete the remote branch.
    • [x] Check if the rest of the projects compile with the changes from this branch (for example ncTiledViewer does not)


    opened by encelo 0
  • Add support for the EFX OpenAL extension

    Add support for the EFX OpenAL extension

    • [ ] Add support for EFX effects
    • [ ] Add support for HRTF for headphones?
    • [ ] Add support for opening (and maybe reopening) the OpenAL audio device with a set of parameters specified in the AppConfiguration
    • [ ] Add support for switching to headphones on Windows?
    • [x] Unregister a player from an audio device on destruction
    • [ ] Query or request a value for MaxSources
    • [ ] Log OpenAL extensions and properties like for OpenGL in GfxCapabilities
    • [ ] Complete the AudioEffect, AudioEffectSlot, and AudioFilter classes
    • [ ] Add Doxygen documentation to the new methods
    • [ ] Add the new classes and methods to the Lua API
    • [ ] Test on all platforms (including Android and Emscripten)
    • [ ] Add support for effects and filters in the new ImGui interface of apptest_audio
    • [ ] Stop the debug text in apptest_audio from flickering due to alignment
    • [ ] Before pushing check code with clang-format and update the changelog on the site (download-master.md)


    opened by encelo 0
  • 2020.05(May 19, 2020)

    This is the third nCine release.



    Breaking Changes

    • Removed flipX() and flipY() sprite methods
      • They have been superseded by setFlippedX() and setFlippedY()
    • Removed setOpaqueTexture() sprite method
      • You can achieve the same result with the general setBlendingEnabled(false)
    • The Matrix4x4<T>::scale() static method has been renamed to Matrix4x4<T>::scaling()
    • The dataPath() and savePath() methods of IFile have been moved to the new FileSystem class
      • The access() method of IFile have been superseded by the more powerful query methods of the FileSystem class
      • The nc.application.datapath() Lua function is now nc.fs.get_datapath()
    • The children() method of a SceneNode now returns a nctl::Array

    New Features

    • Scene nodes support anchor points and non-uniform scaling
      • There is a new apptest_anchor application that shows all new node features
    • Drawable nodes support custom alpha blending factors
    • Nuklear integration for fully skinnable user interfaces
    • You can now embed the whole engine inside a Qt5 widget by choosing the Qt5 desktop backend
      • If the Qt Gamepad library is available it will be used for gamepad input events
    • Touch events are supported on desktop through the SDL2 and Qt5 backends
      • They now also provide information about touch pressure
    • The FileSystem class has been added to help you query and manipulate paths, files, and directories
      • It comes with a new apptest_filebrowser application that shows an ImGui based file browser
    • ImGui and Nuklear integrations support custom fonts loading
    • Added a new unclamped three channels ColorHdr class
    • The IAppEventHandler class now receives onSuspend() and onResume() events


    • The logging system is initialized earlier and can be used inside onPreInit()
    • The Android asset manager is initialized earlier and can be used inside onPreInit()
    • Handling of windows resizing events has been fixed
    • Emscripten applications react to window resizing and fullscreen events
    • Emscripten applications can now load and save local files
    • Sprite flipping methods now take a status flag
    • The version of the integrated Tracy has gone from v0.5 to v0.6.3
    • The version of the integrated ImGui has gone from v1.73 to v1.76
    • Deletion of children scene nodes upon parent destruction has been made optional
    • The Matrix4x4<T> can now translate, rotate and scale in place, avoiding a full matrix multiplication
      • It can now also be multiplied on the right side of a vector
    • Automatic sprite batching is now available on Emscripten
      • You can choose the fixed batch size with a variable in the AppConfiguration class
    • Added support for Google ANGLE libraries on Windows
    • Sorting of render commands is now stable
      • If two commands have the same material sorting key then a secondary key based on node creation time is used
    • All kind of hashmap and hashset containers can now correctly use const char * as key type
    • Added two low-level classes to save textures as Png or WebP images
    • It is now possible to set the swap interval on all desktop backends with IGfxDevice::setSwapInterval()
    • The new String::append(const char *) overload will prevent allocating a string object when appending
    • Visiting the scenegraph should be faster as children are now stored in an array instead of a list
    • The new unordered remove methods of arrays will remove elements faster when preserving order is not required
    • The debug overlay interface has now a node inspector to query and modify nodes in the scene
    • Android Gradle Plugin, Build Tools, compileSDKVersion and targetSDKVersion have all been updated to newer versions


    • The Emscripten port compiles with upstream LLVM WebAssembly backend
    • Some minor fixes in the color classes code
    • Culling of drawable nodes works with negative scaling factors
    • Scene nodes are now correctly transformed before children thus eliminating any update delay with nodes chains
    • Caching of TextNode boundaries does not introduce a one frame delay on update
    • The Lua stack is now cleaned after a failure in calling a function
      • Previously the stack would easily overflow if some callbacks were not defined
    • String lenght is now updated if a string is truncated when using a formatting method
    • Fixed OpenGL FBO wrapper class when dealing with reading and drawing buffers


    This release is packaged together with:

    The Android libraries have been compiled with NDK r21b for armeabi-v7a, arm64-v8a and x86_64.

    Source code(tar.gz)
    Source code(zip)
    nCine-2020.05-Darwin.dmg(12.60 MB)
    nCine-2020.05-Win64-VS2017.exe(7.24 MB)
    nCine-2020.05-Win64-VS2017.zip(13.64 MB)
    nCine-2020.05-Win64-VS2019.exe(7.19 MB)
    nCine-2020.05-Win64-VS2019.zip(13.61 MB)
  • 2019.10(Oct 20, 2019)

    This is the second nCine release.


    • nCine-2019.10-Win64-VS2019.exe (md5: 8e505ffe0ec256688e85e00dbbe7ec17)
    • nCine-2019.10-Win64-VS2019.zip (md5: 63d93c1cdba532c002fd59b0094e1dd2)
    • nCine-2019.10-Win64-VS2017.exe (md5: 99d9fc5b22a51286fe76bf8634316390)
    • nCine-2019.10-Win64-VS2017.zip (md5: 1cff45df92503c773ca2dc1d2f31dc78)
    • nCine-2019.10-Darwin.dmg (md5: 1554b5a3d906d7c3bd62f50c53eb2f85)


    Breaking Changes

    • The Font constructor has now inverted parameters: fntFilename as first and texFilename as second
      • The reason for that is the new single parameter constructor
    • SceneNode::parentNode() getter has been renamed to just parent(), to be consistent with the new setParent() setter
    • The xResolution and yResolution fields of the AppConfiguration class have been replaced by a single 2D resolution vector
      • The setResolution() helper method has been removed as it is now possible to call resolution.set()
      • In Lua x_res and y_res have been replaced by the resolution 2D vector
    • The old non ImGui debug overlay has been deleted. If you need the debug overlay you also need to enable the ImGui integration
      • As part of this change the fontTexFilename and fontFntFilename strings in the AppConfiguration class have been deleted
    • The withProfilerGraphs and withInfoText flags in the AppConfiguration class has been unified into a single withDebugOverlay flag
      • You have to explicitely set the new flag to true to enable the debug overlay even when your application is compiled in debug mode
    • Many nctl::String::copy() methods have been turned into assign() methods in order to be more consistent with STL
    • The Timer::now() method has been removed, refer to the new TimeStamp class

    New Features

    • Emscripten is now supported as a target platform, meaning you can now use the nCine for web games! :spider_web:
    • The user can now query the available fullscreen video modes on PC and choose one
      • The IGfxDevice interface has been enriched with methods to query the current video mode, the list of available ones and to set a new mode
    • A new deferShaderQueries flag has been added to the AppConfiguration classes
      • When it is set to true all the shader error checks and introspection queries are deferred upon the first use of the shader, if it is ever used.
      • The option allows for decreased starting time at the expense of possible stutters when the shader is first used in a frame
    • New methods have been added to the audio classes to query their state
      • They were used in the new Audio Players section of the ImGui debug overlay interface
    • If you use the nCine compiled as a static library you have now access to more functionalities in the OpenGL classes
      • You can now create PBOs and TBOs.
      • You can now use GL_SAMPLER_1D and GL_SAMPLER_3D types in shaders
      • A new GLCullFace class has been added to track OpenGL face culling state
    • The Font class now relies on FntParser class to extract all the data from a FNT file
      • More checks are now performed to ensure the text can be properly rendered
      • More glyph channel configurations are now supported and rendered correctly
      • The Font class can be constructed with a single parameter: the FNT file. The texture will be loaded according to the file specified in the first page tag.
    • When you compile the engine you can now choose to disable the support for various dependency libraries and features
      • You can disable threads support, Lua bindings, Png or WebP image loading, Ogg Vorbis sound loading or audio altogether


    • The version of the integrated Tracy has gone from v0.4.1 to v0.5
      • It is now easier to use Tracy in custom nCine projects, including on Android
      • Threads can be named so that they can be tracked in the Tracy profiler
      • You can now also retrieve current thread priority or set a new one
      • All log entries are written out as coloured Tracy messages
      • Threads id are invalidated on join and cancel so that they can be reused
    • The version of the integrated ImGui has gone from v1.70 to v1.73
    • The GameController mapping database has been updated from the one included in SDL 2.0.9 to the one in SDL 2.0.10
    • The SceneNode classes has seen the addition of long awaited helper methods in the shape of setParent(), alpha() and absAlpha()
      • The first one makes it easy and intuitive to set a node parent without going the opposite way by calling parent->addChildNode(this)
      • The alpha related methods should make it easier to query for a node alpha value
      • There are also new Lua methods for scene nodes: set_parent(), get_alpha() and set_alpha()
    • The new TimeStamp class can be used to collect timestamps at the full precision of the internal clock
      • The Time class has been enhanced with stop() and totalTime() methods to aggregate multiple time spans
      • Most methods of the TimeStamp class are also accessible through the Lua API
    • It is now possible to assign() a certain numbers of characters from a C string to an nctl::String object
    • You can now enable the ImGui debug overlay even when the scenegraph is disabled
      • In this case be sure to track OpenGL states using GLBlending, GLDepthTest and the new GLCullFace class
    • The Font class has a new query method, numKernings(), to retrieve the number of kerning pairs in a font (it is called num_kernings() in Lua)
    • You can access the array of animations in an AnimatedSprite and the array of rectangles in a RectAnimation
    • On Windows the executables use the Windows subsystem instead of the console one
      • They will also expose version properties thanks to the VERSIONINFO file
    • The Android Gradle plugin version has been updated from 3.4.0 to 3.4.1 and Android build tools from 28.0.3 to 29.0.2
      • The changes have been reflected in the template project as well


    • Compiler warnings related with nctl::UniquePtr wrapping forward declared classes have been fixed. They could have sometimes led to incorrect object deletions and possible leaks. :fearful:
    • The OpenAL implementation has been rewritten and many bugs that were lurking in the code should have been squashed :bug:
    • Some changes dictated by the layout of the new ncTemplate project
      • The CMake scripts now expect a nCine-data/icons/icon.ico file instead of the old nCine.ico
      • Installers are now built with the CPACK_PACKAGE_VENDOR and CPACK_PACKAGE_HOMEPAGE_URL variables correctly set
    • The returned value for GL_MAX_UNIFORM_BLOCK_SIZE is now clamped to 64kB because some OpenGL drivers might return very big numbers


    This release is packaged together with:

    The Android libraries have been compiled with NDK r20 for armeabi-v7a, arm64-v8a and x86_64.

    Source code(tar.gz)
    Source code(zip)
    nCine-2019.10-Darwin.dmg(12.58 MB)
    nCine-2019.10-Win64-VS2017.exe(6.94 MB)
    nCine-2019.10-Win64-VS2017.zip(12.66 MB)
    nCine-2019.10-Win64-VS2019.exe(6.90 MB)
    nCine-2019.10-Win64-VS2019.zip(12.61 MB)
  • 2019.05(Aug 12, 2019)

    nCine 2019.05

    This is the first release of the project and it is based on the source code initially published at the end of May 2019.


    • nCine-2019.05-VS2019.exe (md5: e080f1573e0796e7c46932aca12f3164)
    • nCine-2019.05-VS2019.zip (md5: bfec0f3d9915d251c3615bd94cdb1cf2)
    • nCine-2019.05-VS2017.exe (md5: 3d27b7eca1ea9fa831c66e470f614baa)
    • nCine-2019.05-VS2017.zip (md5: ced631b0d69e11f3190c0026871ecbea)
    • nCine-2019.05-Darwin.dmg (md5: 58abb3a9bffc619b789363aa0c123c8b)


    This release is packaged together with:

    The Android libraries have been compiled with NDK r20 for armeabi-v7a, arm64-v8a and x86_64.

    Source code(tar.gz)
    Source code(zip)
    nCine-2019.05-Darwin.dmg(11.93 MB)
    nCine-2019.05-VS2017.exe(6.50 MB)
    nCine-2019.05-VS2017.zip(12.06 MB)
    nCine-2019.05-VS2019.exe(6.46 MB)
    nCine-2019.05-VS2019.zip(12.00 MB)
A cross-platform 2D game engine
Open-source, cross-platform, C++ game engine for creating 2D/3D games.

GamePlay v3.0.0 GamePlay is an open-source, cross-platform, C++ game framework/engine for creating 2D/3D mobile and desktop games. Website Wiki API De

gameplay3d 3.8k Oct 2, 2022
KlayGE is a cross-platform open source game engine with plugin-based architecture.

KlayGE KlayGE is a cross-platform open source game engine with plugin-based architecture. It's started since 2003. The explicit goal of KlayGE is: to

Minmin Gong 1.8k Oct 2, 2022
A cross-platform 2D game engine

nCine nCine is a cross-platform 2D game engine. It is released under the MIT License, Copyright (c) 2011-2021 Angelo Theodorou. For additional informa

nCine 749 Sep 25, 2022
Powerful, mature open-source cross-platform game engine for Python and C++, developed by Disney and CMU

Panda3D Panda3D is a game engine, a framework for 3D rendering and game development for Python and C++ programs. Panda3D is open-source and free for a

Panda3D 3.5k Sep 27, 2022
A powerful free cross-platform RTS game engine

Spring RTS game engine README Spring (formerly TASpring) is an Open Source Real Time Strategy game engine. Visit our project homepage for help, sugges

Spring RTS 2.8k Sep 28, 2022
CSEngine is a cross-platform 3D game engine.

CSEngine - Cross Platform C++ Game Engine CSEngine is a cross-platform 3D game engine. ?? As it is under development, it is not yet suitable for pract

ounols 51 Sep 25, 2022
Intrinsic is a Vulkan based cross-platform game and rendering engine

Intrinsic is a Vulkan based cross-platform game and rendering engine

Benjamin Wrensch 1k Sep 20, 2022
Free, cross-platform 2D game engine powered by Haxe and OpenFL

flixel | addons | ui | demos | tools | templates | docs | haxeflixel.com Links Here are the most important links to get you started with HaxeFlixel: G

HaxeFlixel 1.6k Sep 24, 2022
Godot Engine – Multi-platform 2D and 3D game engine

Godot Engine 2D and 3D cross-platform game engine Godot Engine is a feature-packed, cross-platform game engine to create 2D and 3D games from a unifie

Godot Engine 53.9k Oct 4, 2022
Flax Engine – multi-platform 3D game engine

Flax Engine – multi-platform 3D game engine

Flax Engine 3.6k Sep 30, 2022
The Atomic Game Engine is a multi-platform 2D and 3D engine with a consistent API in C++, C#, JavaScript, and TypeScript

The Atomic Game Engine is a multi-platform 2D and 3D engine with a consistent API in C++, C#, JavaScript, and TypeScript

null 2.8k Oct 2, 2022
CLUSEK-RT is a complex game engine written in C++ and the successor of the CLUSEK game engine

CLUSEK-RT is a complex game engine written in C++ and the successor of the CLUSEK game engine. This engine has been designed with a cross-platform design in mind. Thanks to Vulkan API it delivers a next-gen experience with ray tracing to both Linux and Windows platforms

Jakub Biliński 36 Sep 28, 2022
Ground Engine is an easy to use Game Engine for 3D Game Development written in C++

Ground Engine is an easy to use Game Engine Framework for 3D Game Development written in C++. It's currently under development and its creation will b

 PardCode 56 Aug 15, 2022
TrenchBroom is a modern cross-platform level editor for Quake-engine based games.

TrenchBroom is a modern cross-platform level editor for Quake-engine based games.

TrenchBroom 1.2k Sep 26, 2022
Rogy-Engine- - My 3D game engine source code.

Rogy-Engine Development My 3D game engine. (NOT THE FINAL VERSION- Windows only) Features: PBR shading and reflection probes with parallax correction.

AlaX 95 Sep 30, 2022
Hyperion Engine is a 3D game engine written in C++

Hyperion Engine About Hyperion Engine is a 3D game engine written in C++. We aim to make Hyperion be easy to understand and use, while still enabling

null 219 Oct 1, 2022
Minetest is an open source voxel game engine with easy modding and game creation

Minetest is an open source voxel game engine with easy modding and game creation

Minetest 8k Oct 5, 2022
Stealthy way to hijack the existing game process handle within the game launcher (currently supports Steam and Battle.net). Achieve external game process read/write with minimum footprint.

Launcher Abuser Stealthy way to hijack the existing game process handle within the game launcher (currently supports Steam and Battle.net). Achieve ex

Ricardo Nacif 77 Sep 25, 2022
Game Boy, Game Boy Color, and Game Boy Advanced Emulator

SkyEmu SkyEmu is low level cycle accurate GameBoy, GameBoy Color and Game Boy Advance emulator that I have been developing in my spare time. Its prima

Sky 211 Sep 29, 2022