OpenSceneGraph alternatives and similar libraries
Based on the "Graphics" category.
Alternatively, view OpenSceneGraph alternatives based on common mentions on social networks and blogs.
GLFW9.5 9.1 L2 OpenSceneGraph VS GLFWA multi-platform library for OpenGL, OpenGL ES, Vulkan, window and input
bgfx9.4 9.2 L1 OpenSceneGraph VS bgfxCross-platform, graphics API agnostic, "Bring Your Own Engine/Framework" style rendering library.
Skia9.0 10.0 L1 OpenSceneGraph VS SkiaSkia is a complete 2D graphic library for drawing Text, Geometries, and Images.
urho3d8.3 9.8 L1 OpenSceneGraph VS urho3dGame engine
magnum8.1 9.8 L2 OpenSceneGraph VS magnumLightweight and modular C++11 graphics middleware for games and data visualization
Ogre 3D8.0 9.8 OpenSceneGraph VS Ogre 3Dscene-oriented, flexible 3D engine (C++, Python, C#, Java)
OpenSubdiv7.8 0.0 L1 OpenSceneGraph VS OpenSubdivAn Open-Source subdivision surface library.
DirectXTK7.4 7.1 OpenSceneGraph VS DirectXTKThe DirectX Tool Kit (aka DirectXTK) is a collection of helper classes for writing DirectX 11.x code in C++
OpenVDB7.3 8.5 L1 OpenSceneGraph VS OpenVDBOpenVDB - Sparse volume data structure and tools
Open-Source Vulkan C++ API7.3 9.4 L1 OpenSceneGraph VS Open-Source Vulkan C++ APIOpen-Source Vulkan C++ API
Horde3D6.5 3.4 L1 OpenSceneGraph VS Horde3DHorde3D is a small 3D rendering and animation engine. It is written in an effort to create an engine being as lightweight and conceptually clean as possible.
herebedragons6.1 1.9 OpenSceneGraph VS herebedragonsA basic 3D scene implemented with various engines, frameworks or APIs.
Ion6.0 2.0 OpenSceneGraph VS IonIon
glbinding4.9 4.1 OpenSceneGraph VS glbindingA C++ binding for the OpenGL API, generated using the gl.xml specification.
Irrlicht4.5 0.0 L1 OpenSceneGraph VS IrrlichtAn automatically updated mirror of the Irrlicht SVN repository on sourceforge
Partio4.4 0.0 OpenSceneGraph VS PartioC++ (with python bindings) library for easily reading/writing/manipulating common animation particle formats such as PDB, BGEO, PTC. See the discussion group @ http://groups.google.com/group/partio-discuss
Visualization Library3.8 0.0 L1 OpenSceneGraph VS Visualization LibraryVisualization Library is a C++ middleware for high-performance 2D and 3D graphics applications based on OpenGL 1.x-4.x supporting Windows, Linux and Mac OS X.
IrrlichtBAW2.8 0.0 OpenSceneGraph VS IrrlichtBAWBuild A World fork of Irrlicht
OpenMesh, 7.01.6 0.0 L1 OpenSceneGraph VS OpenMesh, 7.0Clone of the official OpenMesh repository
CairoA 2D graphics library with support for multiple output devices. [LGPL2 or Mozilla MPL]
Write Clean C++ Code. Always.
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of OpenSceneGraph or a related project?
Welcome to the OpenSceneGraph (OSG).
For up-to-date information on the project, in-depth details on how to compile and run libraries and examples, see the documentation on the OpenSceneGraph website:
For support subscribe to our public mailing list or forum, details at:
For the impatient, we've included quick build instructions below, these are are broken down is three parts:
1) General notes on building the OpenSceneGraph 2) macOS release notes 3) iOS release notes
If details below are not sufficient then head over to the openscenegraph.org to the Documentation/GettingStarted and Documentation/PlatformSpecifics sections for more indepth instructions.
Robert Osfield. Project Lead. 26th April 2018.
Section 1. How to build OpenSceneGraph
If you are using the vcpkg dependency manager you can download and install OpenSceneGraph from source with CMake integration using a single command:
vcpkg install osg
The OpenSceneGraph uses the CMake build system to generate a platform-specific build environment. CMake reads the
CMakeLists.txt files that you'll find throughout the OpenSceneGraph directories, checks for installed dependencies and then generates files for the selected build system.
If you don't already have CMake installed on your system you can grab it from http://www.cmake.org, use version 2.8.0 or later. Details on the OpenSceneGraph's CMake build can be found at:
Under Unix-like systems (i.e. Linux, IRIX, Solaris, Free-BSD, HP-UX, AIX, macOS) use the
ccmake command-line utils. Note that
cmake . defaults to building Release to ensure that you get the best performance from your final libraries/applications.
cd OpenSceneGraph cmake . make sudo make install
Alternatively, you can create an out-of-source build directory and run cmake or ccmake from there. The advantage to this approach is that the temporary files created by CMake won't clutter the OpenSceneGraph source directory, and also makes it possible to have multiple independent build targets by creating multiple build directories. In a directory alongside the OpenSceneGraph use:
mkdir build cd build cmake ../OpenSceneGraph make sudo make install
Under Windows use the GUI tool CMakeSetup to build your VisualStudio files. The following page on our wiki dedicated to the CMake build system should help guide you through the process:
Under macOS you can either use the CMake build system above, or use the Xcode projects that you will find in the OpenSceneGraph/Xcode directory. See release notes on macOS CMake build below.
For further details on compilation, installation and platform-specific information read "Getting Started" guide:
Section 2. Release notes on macOS build, by Eric Sokolowski et al.
There are two ways to compile OpenSceneGraph under macOS. The recommended way is to use CMake to generate Xcode project files and then use Xcode to build the library. The default project will be able to build Debug or Release libraries, examples, and sample applications.
The alternative is to build OpenSceneGraph from the command line using
ninja using the instructions for Unix-like systems above.
Here are some key settings to consider when using CMake:
- BUILD_OSG_EXAMPLES - By default this is turned off. Turn this setting on to compile many great example programs.
- CMAKE_OSX_ARCHITECTURES - Xcode can create applications, executables, libraries, and frameworks that can be run on more than one architecture. Use this setting to indicate the architectures on which to build OSG. x86_64 is the only supported value for OS versions > 10.7.
- OSG_BUILD_APPLICATION_BUNDLES - Normally only executable binaries are created for the examples and sample applications. Turn this option on if you want to create real macOS .app bundles. There are caveats to creating
.appbundles, see below.
- OSG_DEFAULT_IMAGE_PLUGIN_FOR_OSX - By default macOS uses the
imageioplugin instead of the plugins for the individual file types (e.g.
gif, etc.) to load image file types. The
imageioplugin can handle all popular file formats through the ImageIO framework.
- OSG_WINDOWING_SYSTEM - You have the choice to use Cocoa, Carbon, or X11 when building applications on macOS. Cocoa is the default for OS versions >= 10.5. Carbon and X11 are no longer actively supported, either by Apple or the OSG community.
APPLICATION BUNDLES (.app bundles)
The example programs when built as application bundles only contain the executable file. They do not contain the dependent libraries as would a normal bundle, so they are not generally portable to other machines. They also do not know where to find plugins. An environmental variable OSG_LIBRARY_PATH may be set to point to the location where the plugin .so files are located. OSG_FILE_PATH may be set to point to the location where data files are located. Setting OSG_FILE_PATH to the OpenSceneGraph-Data directory is very useful when testing OSG by running the example programs.
Many of the example programs use command-line arguments. When double-clicking on an application (or using the equivalent "open" command on the command line) only those examples and applications that do not require command-line arguments will successfully run. The executable file within the .app bundle can be run from the command-line if command-line arguments are needed.
Section 3. Release notes on iOS build, by Thomas Hogarth
With CMake 3.11, XCode 9.4 and the iOS sdk 11.4 installed you can generate an iOS XCode project using the following command line:
export THIRDPARTY_PATH=/path/to/3rdParty cmake ./ -G Xcode -DOSG_BUILD_PLATFORM_IPHONE:BOOL=ON \ -DIPHONE_SDKVER="11.4" \ -DIPHONE_VERSION_MIN="10.0" \ -DOPENGL_PROFILE:STRING=GLES3 \ -DOSG_CPP_EXCEPTIONS_AVAILABLE:BOOL=ON \ -DBUILD_OSG_APPLICATIONS:BOOL=OFF \ -DBUILD_OSG_EXAMPLES:BOOL=ON \ -DOSG_WINDOWING_SYSTEM:STRING=IOS \ -DOSG_DEFAULT_IMAGE_PLUGIN_FOR_OSX="imageio" \ -DDYNAMIC_OPENSCENEGRAPH:BOOL=OFF \ -DDYNAMIC_OPENTHREADS:BOOL=OFF \ -DCURL_INCLUDE_DIR:PATH="$THIRDPARTY_PATH/curl-ios-device/include" \ -DCURL_LIBRARY:PATH="$THIRDPARTY_PATH/curl-ios-device/lib/libcurl.a" \ -DFREETYPE_INCLUDE_DIR_freetype2:PATH="$THIRDPARTY_PATH/freetype-ios-universal/include/freetype" \ -DFREETYPE_INCLUDE_DIR_ft2build:PATH="$THIRDPARTY_PATH/freetype-ios-universal/include" \ -DFREETYPE_LIBRARY:PATH="$THIRDPARTY_PATH/freetype-ios-universal/lib/libFreetype2.a" \ -DTIFF_INCLUDE_DIR:PATH="$THIRDPARTY_PATH/tiff-ios-device/include" \ -DTIFF_LIBRARY:PATH="$THIRDPARTY_PATH/tiff-ios-device/lib/libtiff.a" \ -DGDAL_INCLUDE_DIR:PATH="$THIRDPARTY_PATH/gdal-ios-device/include" \ -DGDAL_LIBRARY:PATH="$THIRDPARTY_PATH/gdal-ios-device/lib/libgdal.a"
Be sure to set the THIRDPARTY_PATH to the path containing your thirdparty dependencies. Set IPHONE_SDKVER to the version of the iOS sdk you have installed, in this instance 11.4. IPHONE_VERSION_MIN controls the deployment sdk used by xcode, and lastly set OPENGL_PROFILE to the version of GLES you want to use.
Once this completes an XCode project will have been generated in the osg root folder. Open the generated Xcode project, select the example_osgViewerIPhone target. In 'General' tab set a development team.
Once this is done you should be able to build and deploy the
example_osgViewerIPhone target on your device.