Filament is a real-time physically based rendering engine for Android, iOS, Windows, Linux, macOS, and WebGL2



Android Build Status iOS Build Status Linux Build Status macOS Build Status Windows Build Status Web Build Status

Filament is a real-time physically based rendering engine for Android, iOS, Linux, macOS, Windows, and WebGL. It is designed to be as small as possible and as efficient as possible on Android.


Download Filament releases to access stable builds. Filament release archives contains host-side tools that are required to generate assets.

Make sure you always use tools from the same release as the runtime library. This is particularly important for matc (material compiler).

If you'd rather build Filament yourself, please refer to our build manual.


Android projects can simply declare Filament libraries as Maven dependencies:

repositories {
    // ...

dependencies {
    implementation ''

Here are all the libraries available in the group

Artifact Description
filament-android The Filament rendering engine itself.
gltfio-android A glTF 2.0 loader for Filament, depends on filament-android.
gltfio-android-lite Trimmed version of gltfio that does not support some glTF extensions.
filament-utils-android KTX loading, Kotlin math, and camera utilities, depends on gltfio-android.
filament-utils-android-lite Trimmed version of filament-utils that does not support some glTF features.
filamat-android A runtime material builder/compiler. This library is large but contains a full shader compiler/validator/optimizer and supports both OpenGL and Vulkan.
filamat-android-lite A much smaller alternative to filamat-android that can only generate OpenGL shaders. It does not provide validation or optimizations.


iOS projects can use CocoaPods to install the latest release:

pod 'Filament', '~> 1.15.1'


If you prefer to live on the edge, you can download a continuous build by following the following steps:

  1. Find the commit you're interested in.
  2. Click the green check mark under the commit message.
  3. Click on the Details link for the platform you're interested in.
  4. On the top right, click on the Artifacts dropdown and choose an artifact.


  • Filament, an in-depth explanation of real-time physically based rendering, the graphics capabilities and implementation of Filament. This document explains the math and reasoning behind most of our decisions. This document is a good introduction to PBR for graphics programmers.
  • Materials, the full reference documentation for our material system. This document explains our different material models, how to use the material compiler matc and how to write custom materials.
  • Material Properties, a reference sheet for the standard material model.


Night scene Night scene Materials Materials Helmet Screen-space refraction



  • Native C++ API for Android, iOS, Linux, macOS and Windows
  • Java/JNI API for Android
  • JavaScript API


  • OpenGL 4.1+ for Linux, macOS and Windows
  • OpenGL ES 3.0+ for Android and iOS
  • Metal for macOS and iOS
  • Vulkan 1.0 for Android, Linux, macOS, and Windows
  • WebGL 2.0 for all platforms


  • Clustered forward renderer
  • Cook-Torrance microfacet specular BRDF
  • Lambertian diffuse BRDF
  • Custom lighting/surface shading
  • HDR/linear lighting
  • Metallic workflow
  • Clear coat
  • Anisotropic lighting
  • Approximated translucent (subsurface) materials
  • Cloth/fabric/sheen shading
  • Normal mapping & ambient occlusion mapping
  • Image-based lighting
  • Physically-based camera (shutter speed, sensitivity and aperture)
  • Physical light units
  • Point lights, spot lights and directional light
  • Specular anti-aliasing
  • Spot and directional light shadows
  • Cascaded shadows
  • EVSM, PCSS, DPCF, or PCF shadows
  • Transparent shadows
  • Contact shadows
  • Screen-space ambient occlusion
  • Screen-space refraction
  • Global fog
  • Dynamic resolution (with support for AMD FidelityFX FSR)

Post processing

  • HDR bloom
  • Depth of field bokeh
  • Multiple tone mappers: generic (customizable), ACES, filmic, etc.
  • Color and tone management: luminance scaling, gamut mapping
  • Color grading: exposure, night adaptation, white balance, channel mixer, shadows/mid-tones/highlights, ASC CDL, contrast, saturation, etc.
  • Screen-space lens flares

glTF 2.0

  • Encodings

    • Embeded
    • Binary
  • Primitive Types

    • Points
    • Lines
    • Line Loop
    • Line Strip
    • Triangles
    • Triangle Strip
    • Triangle Fan
  • Animation

    • Transform animation
    • Linear interpolation
    • Morph animation
      • Sparse accessor
    • Skin animation
    • Joint animation
  • Extensions

    • KHR_draco_mesh_compression
    • KHR_lights_punctual
    • KHR_materials_clearcoat
    • KHR_materials_ior
    • KHR_materials_pbrSpecularGlossiness
    • KHR_materials_sheen
    • KHR_materials_transmission
    • KHR_materials_unlit
    • KHR_materials_volume
    • KHR_mesh_quantization
    • KHR_texture_transform

Rendering with Filament

Native Linux, macOS and Windows

You must create an Engine, a Renderer and a SwapChain. The SwapChain is created from a native window pointer (an NSView on macOS or a HWND on Windows for instance):

Engine* engine = Engine::create();
SwapChain* swapChain = engine->createSwapChain(nativeWindow);
Renderer* renderer = engine->createRenderer();

To render a frame you must then create a View, a Scene and a Camera:

Camera* camera = engine->createCamera(EntityManager::get().create());
View* view = engine->createView();
Scene* scene = engine->createScene();


Renderables are added to the scene:

Entity renderable = EntityManager::get().create();
// build a quad
        .boundingBox({{ -1, -1, -1 }, { 1, 1, 1 }})
        .material(0, materialInstance)
        .geometry(0, RenderableManager::PrimitiveType::TRIANGLES, vertexBuffer, indexBuffer, 0, 6)
        .build(*engine, renderable);

The material instance is obtained from a material, itself loaded from a binary blob generated by matc:

Material* material = Material::Builder()
        .package((void*) BAKED_MATERIAL_PACKAGE, sizeof(BAKED_MATERIAL_PACKAGE))
MaterialInstance* materialInstance = material->createInstance();

To learn more about materials and matc, please refer to the materials documentation.

To render, simply pass the View to the Renderer:

// beginFrame() returns false if we need to skip a frame
if (renderer->beginFrame(swapChain)) {
    // for each View

For complete examples of Linux, macOS and Windows Filament applications, look at the source files in the samples/ directory. These samples are all based on libs/filamentapp/ which contains the code that creates a native window with SDL2 and initializes the Filament engine, renderer and views.

For more information on how to prepare environment maps for image-based lighting please refer to


See android/samples for examples of how to use Filament on Android.

You must always first initialize Filament by calling Filament.init().

Rendering with Filament on Android is similar to rendering from native code (the APIs are largely the same across languages). You can render into a Surface by passing a Surface to the createSwapChain method. This allows you to render to a SurfaceTexture, a TextureView or a SurfaceView. To make things easier we provide an Android specific API called UiHelper in the package All you need to do is set a render callback on the helper and attach your SurfaceView or TextureView to it. You are still responsible for creating the swap chain in the onNativeWindowChanged() callback.


Filament is supported on iOS 11.0 and above. See ios/samples for examples of using Filament on iOS.

Filament on iOS is largely the same as native rendering with C++. A CAEAGLLayer or CAMetalLayer is passed to the createSwapChain method. Filament for iOS supports both Metal (preferred) and OpenGL ES.


To get started you can use the textures and environment maps found respectively in third_party/textures and third_party/environments. These assets are under CC0 license. Please refer to their respective URL.txt files to know more about the original authors.

Environments must be pre-processed using cmgen or using the libiblprefilter library.

How to make contributions

Please read and follow the steps in Make sure you are familiar with the code style.

Directory structure

This repository not only contains the core Filament engine, but also its supporting libraries and tools.

  • android: Android libraries and projects
    • filamat-android: Filament material generation library (AAR) for Android
    • filament-android: Filament library (AAR) for Android
    • filament-utils-android: Extra utilities (KTX loader, math types, etc.)
    • gltfio-android: Filament glTF loading library (AAR) for Android
    • samples: Android-specific Filament samples
  • art: Source for various artworks (logos, PDF manuals, etc.)
  • assets: 3D assets to use with sample applications
  • build: CMake build scripts
  • docs: Documentation
    • math: Mathematica notebooks used to explore BRDFs, equations, etc.
  • filament: Filament rendering engine (minimal dependencies)
    • backend: Rendering backends/drivers (Vulkan, Metal, OpenGL/ES)
  • ide: Configuration files for IDEs (CLion, etc.)
  • ios: Sample projects for iOS
  • libs: Libraries
    • bluegl: OpenGL bindings for macOS, Linux and Windows
    • bluevk: Vulkan bindings for macOS, Linux, Windows and Android
    • camutils: Camera manipulation utilities
    • filabridge: Library shared by the Filament engine and host tools
    • filaflat: Serialization/deserialization library used for materials
    • filagui: Helper library for Dear ImGui
    • filamat: Material generation library
    • filamentapp: SDL2 skeleton to build sample apps
    • filameshio: Tiny filamesh parsing library (see also tools/filamesh)
    • geometry: Mesh-related utilities
    • gltfio: Loader for glTF 2.0
    • ibl: IBL generation tools
    • image: Image filtering and simple transforms
    • imageio: Image file reading / writing, only intended for internal use
    • matdbg: DebugServer for inspecting shaders at run-time (debug builds only)
    • math: Math library
    • mathio: Math types support for output streams
    • utils: Utility library (threads, memory, data structures, etc.)
    • viewer: glTF viewer library (requires gltfio)
  • samples: Sample desktop applications
  • shaders: Shaders used by filamat and matc
  • third_party: External libraries and assets
    • environments: Environment maps under CC0 license that can be used with cmgen
    • models: Models under permissive licenses
    • textures: Textures under CC0 license
  • tools: Host tools
    • cmgen: Image-based lighting asset generator
    • filamesh: Mesh converter
    • glslminifier: Minifies GLSL source code
    • matc: Material compiler
    • matinfo Displays information about materials compiled with matc
    • mipgen Generates a series of miplevels from a source image
    • normal-blending: Tool to blend normal maps
    • resgen Aggregates binary blobs into embeddable resources
    • roughness-prefilter: Pre-filters a roughness map from a normal map to reduce aliasing
    • specular-color: Computes the specular color of conductors based on spectral data
  • web: JavaScript bindings, documentation, and samples


Please see LICENSE.


This is not an officially supported Google product.

  • Building using native Visual Studio

    Building using native Visual Studio

    Describe the bug Not a bug. I am just wondering what prevents building filament using the native Microsoft compiler in Visual Studio? Is it just a matter of C++ code not building? I saw a reference about assembly code in another issue. Is this still a problem or is there equivalent c code?

    enhancement windows 
    opened by gpyalt 37
  • Initial draft of C FFI wrapper for filament

    Initial draft of C FFI wrapper for filament

    This is an initial draft of a C wrapper for #139.

    This will likely require major rework before it is merged, but I wanted to get the discussion going nevertheless.

    Current the idea of API.h / cfilament.h is that the same symbol name is used in the C header, but is directly aliased to the C++ class if the header is included from the cpp file.

    I am also not sure whether duplication of documentation makes sense here. The interface is most likely going to be used by writers of FFI wrappers for other languages that do not use the header directly. Actual users of C will likely have access to an actual C++ compiler and can link against the static library directly without use of this wrapper.

    opened by shartte 37
  • Occlusion Material

    Occlusion Material

    Describe the bug I use filament via the SceneForm SDK. But I suspect it is a filament bug. When I put this material on an object then on some devices (I have not yet been able to determine which ones are 100% functional and which are not.) the objects behind it are displayed in black.

    This effect only affects GLTF and OBJ objects. FBX models are correctly occluded.

    The question now is whether it is a filament bug or rather an ArCore bug.

    This is my occluder material:

    material {
        name : "Occlusion material",
        shadingModel : unlit,
        colorWrite : false,
        depthWrite : true
    fragment {
        void material(inout MaterialInputs material) {
            material.baseColor = vec4(0.0);

    To Reproduce Simply place a model with this material in front of a GLTF object. That is the result. 68686583-2135c400-056c-11ea-8a0b-c2b1ce06e7b6

    Expected behavior It would be correct if the object behind it were not visible. Like this: 68686464-f8adca00-056b-11ea-9dd5-9203d7a497fe

    Screenshots See "ToReproduce" and "Expected behavior" sections

    Smartphone (please complete the following information):

    • Device: [Not Working: Pixel 3a / OnePlus 5T] [Working: for example Samsung S7]
    • OS: [All Android Versions]

    Additional context The render order of the objects was set as follows: Camera -> Occlusion -> Others

    If this is not a filament error I apologize. But I have the feeling that the people in the SceneForm Repo are being let down.

    Maybe someone from this team can help. What surprises me is that it only does not work with GLTF and OBJ objects.

    opened by bobekos 36
  • readPixels on iOS/Metal returns buffer with only zeros

    readPixels on iOS/Metal returns buffer with only zeros

    I am using readPixels with a callback on iOS/Metal. The PixelBuffer uses PixelDataFormat::RGBA and PixelDataType::UBYTE. I am reserving an uint8_t array of size width * height * 4 for the storage, and call renderer->readPixels(0, 0, width, height, std::move(pb)).

    The swapchain has SwapChain::CONFIG_TRANSPARENT | SwapChain::CONFIG_READABLE as parameters, and I have metalLayer.opaque = NO to match that.

    Unfortunately, when the callback fires, the buffer is all zeros. Any ideas?

    (will try on other backends tomorrow).

    bug metal 
    opened by kpeeters 35
  • How to show only gltf model not the background part

    How to show only gltf model not the background part

    I want to render the gltf model with a transparent background in android-

    the code is

      ` surfaceView = SurfaceView(this);
        choreographer = Choreographer.getInstance()
        modelViewer = ModelViewer(surfaceView)
    private fun loadEnvironment(ibl: String) {
        // Create the indirect light source and add it to the scene.
        var buffer = readAsset("envs/$ibl/${ibl}_ibl.ktx")
        KtxLoader.createIndirectLight(modelViewer.engine, buffer).apply {
            intensity = 100_000f
            modelViewer.scene.indirectLight = this
        // Create the sky box and add it to the scene.
        buffer = readAsset("envs/$ibl/${ibl}_skybox.ktx")
        KtxLoader.createSkybox(modelViewer.engine, buffer).apply {
            modelViewer.scene.skybox= Skybox.Builder().intensity(0f).color(0.0f, 0.0f, 0.0f, 0.0f).build(modelViewer.engine)
    private fun loadGltf(name: String) {
        val buffer = readAsset("models/${name}.gltf")
        modelViewer.loadModelGltf(buffer) { uri -> readAsset("models/$uri") }
    private fun readAsset(assetName: String): ByteBuffer {
        val input =
        val bytes = ByteArray(input.available())
        return ByteBuffer.wrap(bytes)

    I'm getting the black background when I'm using this code in skybox modelViewer.scene.skybox= Skybox.Builder().intensity(0f).color(0.0f, 0.0f, 0.0f, 0.0f).build(modelViewer.engine)

    and twhen I'm using this code in skybox. modelViewer.view.blendMode=View.BlendMode.TRANSLUCENT modelViewer.scene.skybox=null

    I'm getting like this Screenshot_2020-10-21-11-18-24-514_com google android filament gltf (1)

    Please tell me how can I show the model without any background?

    enhancement gltf 
    opened by shivammaindola 35
  • "gltfviewer -s" results in no lighting

    Describe the bug in windows, command "gltf_viewer my.gltf", that point lighting effect is visible; however, command "gltf_viewer -s my.gltf",that point lighting effect is gone. However, we do not want to scale the scene.

    Expected behavior how could be modify the code to control this?

    opened by JackKaiXing 34
  • crash on Android 8.1.0

    crash on Android 8.1.0

    Describe the bug some devices are works, but some not.

    crash info bugreport files

    crash detail info refer to file tombstone_00

    device info

    Android 8.1.0

    bug opengl gpu specific 
    opened by August1996 33
  • 1.16 may have broken skinmeshes lighting

    1.16 may have broken skinmeshes lighting

    Describe the bug I updated from 1.15.2 to 1.16.1 and the lighting of my skin meshes completely broke. It looks as if the normals aren't computed properly, I'm not even sure the light is coming from the correct direction. No problem on static geometries.

    • I already rebuilt the materials.
    • I don't think I have any kind of scales in my hierarchy

    To Reproduce Steps to reproduce the behavior: I don't have repro steps and can't provide screenshots yet, this will take me a while to provide (or is there a way to provide screenshots privately?)

    I'm opening the ticket as a heads-up and welcoming suggestions if this problem could be on my side. In the meanwhile I've temporarily reverted to 1.15.2.

    Desktop (please complete the following information):

    • OS: Windows
    • GPU: NVIDIA GTX 1080
    • Backend: OpenGL
    opened by teub 33
  • How to render into a transparent RenderTarget/Texture?

    How to render into a transparent RenderTarget/Texture?

    I create a View and set a RenderTarget which contains a color and depth attachment.

    The texture for the color attachment is created like:

    fila_texture = filament::Texture::Builder()
          .usage(filament::Texture::Usage::COLOR_ATTACHMENT | filament::Texture::Usage::SAMPLEABLE)

    I've set the clear color using ClearOptions of the Renderer to an arbitary color with an alpha of 0.

    Is this the correct way of rendering into a transparent buffer?

    I'm asking because the result I get seems to have an alpha of 1.0.

    opened by roxlu 33
  • GLTF's UV scaling functionality not implemented?

    GLTF's UV scaling functionality not implemented?

    Bug description We suspect that the Filament 1.4.5 version, present in last Sceneform version (1.16.0), does not deal (properly) with UV Scaling in GLTF/GLB files.

    To Reproduce This kind of transform is carried-out by means of the GLTF 2.0 extension KHR_texture_transform. Said this, when this kind of UV Scaling is used in a GLTF file under ARCore, in order to obtain a repeatable large texture, these are the wrong results obtained: image Please note the wrong repetition problem in the platform and the rail.

    Expected behavior Of course, the texture is shown in a correct way when we visualize the GLTF by means of a WebGL viewer (e.g. VSCodium GLTF Extension with BJS rendering): image

    Smartphone (please complete the following information):

    • Device: Motorola MotoG6 and Samsung Tab S4
    • OS: Android 9.0
    bug gltf 
    opened by vortice3D 29
  • opengl32.lib duplicate defines error

    opengl32.lib duplicate defines error

    I am trying to build the filament libs into my own project, but my project already includes opengl for other libs and I am getting the following errors:

    Do you guys have some sort of workaround for this just like the unwindows.h file?

    opened by Tenebralus 27
  • Refactor VulkanContext/Driver initialization

    Refactor VulkanContext/Driver initialization

    Move the initialization of VulkanContext fields to the class itself. This will clean up how the various extension support flags are deteremined.

    Also disable debugUtils extension for Mesa driver (#6192).

    opened by poweifeng 1
  • Model loads without skin texture in the initial phase

    Model loads without skin texture in the initial phase

    Describe the bug When we try to load a GLB model frequently, After 3-4 iterations, it renders a skeleton or a skin-less model for some microseconds. We are unable to eliminate it. I've attached a video and a photo of the same

    To Reproduce Steps to reproduce the behavior:

    1. Load a GLB model
    2. Again load the GLB model
    3. It'll cause flickering ( skin-less,texture-less model to render)

    Expected behavior It was expected that the Model will load with texture properly every time.


    Smartphone (please complete the following information):

    • Device: [Realme 9 pro, Poco x3 pro, many devices]
    • OS: [ Android 12.0, 13]

    Additional Details Glb Size: 8-10MB

    @romainguy and team

    opened by ritik619 0
  • Memory leaked with Skybox and IndirectLight on Android

    Memory leaked with Skybox and IndirectLight on Android


    As the picture showing, Creating Skybox or IndirectLight by KTXLoader.createXXX will create cubemap Texture. Normally, we may use Engine.destroy to release the Skybox or IndirectLight, but the cubemap Texture will not be destroyed unless the engine is destroyed or destroying the cubemap Texture explicitly(it is very oddly because nobody can realize it).

    opened by August1996 0
  • Android crash in v1.28.1

    Android crash in v1.28.1

    version: 1.28.1 platform: Android crash info:

    Build fingerprint: OPPO/PFVM10/OP522D:12/SP1A.210812.016/R.202211071000:user/release-keys
    Revision: 0
    ABI: arm64
    time: 2022-12-26 11:54:47
    pid: 6127, tid: 6127, name: main  >>> <<<
    signal: 11 (SIGSEGV), code: 2 (SEGV_ACCERR) fault addr: 0x7637e0200c
    si_errno:0, si_errnoMsg:Success, sending pid:0, sending uid:0
        r0: 0xb40000774abfe000  r1: 0x00000000000000ba  r2: 0xb4000077b21fa000
        r3: 0x0000000000000073  r4: 0x0000000000000000  r5: 0xb4000077b2586740
        r6: 0xb4000077b2585d0c  r7: 0x0000000000000000  r8: 0x0000000000002cc0
        r9: 0x0000007637e01040  r10: 0x0000007637e0201c  r11: 0xb4000077b21fafe0
        r12: 0x0000000000008000  r13: 0x0000000000000002  r14: 0x0000000000000000
        r15: 0x0000000000003c00  r16: 0x0000000000008001  r17: 0x0000007637ed2300
        r18: 0x6adacb2a790c2a3a  r19: 0xb4000077b2520e80  r20: 0x00000000000000b3
        r21: 0xb4000077b2558000  r22: 0x00000000000000b3  r23: 0xb40000785c8115b0
        r24: 0xb4000077b251c860  r25: 0xb4000077b654f108  r26: 0x0000007798853f98
        r27: 0x0000007fc22f95f0  r28: 0x0000007fc22f9570  r29: 0x0000007fc22f95b0
        r30: 0x00000077989b989c  sp: 0x0000007fc22f9440  pc: 0x0000007637f07744
        pstate: 0x0000000020001000
    #00 pc 0000000000104744 filament::FSkinningBuffer::setBones(filament::FEngine&, filament::backend::Handle<filament::backend::HwBufferObject>, filament::math::details::TMat44<float> const*, unsigned long, unsigned long) + 180 [arm64-v8a]
    #01 pc 00000000001a6898 updateBoneMatrices (/Users/re/work/other/filament/libs/gltfio/src/Animator.cpp:562) [arm64-v8a]
    java: updateBoneMatrices()($FrameCallback.void doFrame(long)(
    opened by zkwlx 2
  • Applying rotation to projection matrix changes spotlight

    Applying rotation to projection matrix changes spotlight

    I am trying to rotate the final rendered image by pi/2 or -pi/2 by adjusting the projection matrix. That works fine, except that light produced by spotlights changes. This is what I do:

    math::mat4 rot;
    double angle = 3.1415/2;
    rot[0][0]= std::cos(angle);
    rot[1][0]= std::sin(angle);
    rot[1][1]= std::cos(angle);
    auto projmat = camera->getProjectionMatrix();
    camera->setCustomProjection(rot * projmat, camera_near, camera_far);

    Directional lights behave fine (i.e. their effect looks the same with or without the rotation), it's just the spots that change.

    Am I doing this wrong?

    opened by kpeeters 7
Google ❤️ Open Source
An easy to build CO2 Monitor/Meter with Android and iOS App for real time visualization and charting of air data, data logger, a variety of communication options (BLE, WIFI, MQTT, ESP-Now) and many supported sensors.

CO2-Gadget An easy to build CO2 Monitor/Meter with cell phone App for real time visualization and charting of air data, datalogger, a variety of commu

Mariete 30 Dec 17, 2022
Oxygine is C++ engine and framework for 2D games on iOS, Android, Windows, Linux and Mac

BUILD AND RUN See oxygine-framework/readme/ folder. It has instructions on how to build and run oxygine on different platforms. Wiki available at http

Oxygine 735 Dec 23, 2022
An efficient, small mobile key-value storage framework developed by WeChat. Works on Android, iOS, macOS, Windows, and POSIX.

中文版本请参看这里 MMKV is an efficient, small, easy-to-use mobile key-value storage framework used in the WeChat application. It's currently available on Andr

Tencent 15.4k Jan 8, 2023
A cross-platform (Android/iOS/Windows/macOS) cronet plugin for Flutter via `dart:ffi`

cronet_flutter A cross-platform (Android/iOS/Windows/macOS) cronet plugin for Flutter via dart:ffi

null 25 Dec 11, 2022
Sega Master System / Game Gear / SG-1000 emulator for iOS, macOS, Raspberry Pi, Windows, Linux, BSD and RetroArch.

Gearsystem is a very accurate, cross-platform Sega Master System / Game Gear / SG-1000 emulator written in C++ that runs on Windows, macOS, Linux, BSD, iOS, Raspberry Pi and RetroArch.

Ignacio Sanchez Gines 181 Dec 18, 2022
Firmware, mechanical and electrical design files for the Inline Filament Diameter Estimator, Lowcost (InFiDEL).

Inline Filament Diameter Estimator, Lowcost (InFiDEL) Originally created by Thomas Sanladerer A cheap, yet precise filament diameter sensor, intended

Daniel Smullen 113 Dec 29, 2022
Signed - a 3D modeling and construction language based on Lua and SDFs. Signed will be available for macOS and iOS and is heavily optimized for Metal.

Signed - A 3D modeling language Abstract Signed is a Lua based 3D modeling language, it provides a unique way to create high quality 3D content for yo

Markus Moenig 90 Nov 21, 2022
MTEngineSDL is a SDL2+ImGui engine for macOS, Linux and MS Windows.

Hello and welcome to the MTEngineSDL! This is an application host framework for starting custom apps created using SDL2, ImGui and OpenGL. How to comp

null 3 Jan 10, 2022
Real-Time Rendering with Lighting Grid Hierarchy I3D 2019 Demo

Real-Time Rendering with Lighting Grid Hierarchy I3D 2019 Demo Daqi Lin This demo is for the I3D 2019 paper Real-Time Rendering with Lighting Grid Hie

Lin Daqi 110 Sep 20, 2022
An implementation of physically based shading & image based lighting in D3D11, D3D12, Vulkan, and OpenGL 4.

Physically Based Rendering (c) 2017 - 2018 Michał Siejak (@Nadrin) An implementation of physically based shading model & image based lighting in vario

Michał Siejak 1.1k Jan 4, 2023
Improved version of real-time physics engine that couples FEM-based deformables and rigid body dynamics

Enhanced version of coupled FEM and constrained rigid body simulation Description This little playground aimed to test our Conjugate Gradients based M

Andrey Voroshilov 25 Apr 11, 2022
Macos-arm64-emulation - A guide for emulating macOS arm64e on an x86-based host.

macos-arm64-emulation Use the following guide to download and configure all of the necessary tools and files for emulating the macOS arm64e kernel. Th

Cylance 233 Jan 7, 2023
Utility to install kexts, Frameworks and PrivateFrameworks in the System of macOS. For macOS Monterey 12 and Big Sur 11

Command-Line-SnapShot-Mounter Credit: chris1111 Apple This utility uses the macOS terminal Command Line SnapShot Mounter is an utility that allows you

chris1111 23 Jan 8, 2023
Light probe generation and BRDF authoring for physically based shading.

IBLBaker About IBLBaker is provided under the MIT License(MIT) Copyright(c) 2015 Matt Davidson. Please see the LICENSE file for full details. Feel fre

MattD 660 Dec 28, 2022
Physically-based GPU and CPU ray-tracer emerging on a surface

etx-tracer Physically-based GPU and CPU ray-tracer emerging on a surface. Features Vertex Connection and Merging algorithm (CPU and GPU); Full-spectra

Serhii Rieznik 233 Dec 14, 2022
Updates the Wii's current system time with the real world time.

Fix Wii System Time This is a homebrew tool I made for the Wii a while ago. It updates the current system time with the real world time via worldtimea

Puzzle 2 Nov 9, 2022
🗺️ OMAPS.APP — Offline OpenStreetMap maps for iOS and Android. A community-driven fork of MAPS.ME.

OMaps is an open source cross-platform offline maps application, built on top of crowd-sourced OpenStreetMap data. It was publicly released for iOS and Android.

OMaps 4.4k Jan 7, 2023
A beginner friendly desktop UI for Tasmota flashed devices for Windows, macOS and Linux.

TasmoManager A beginner friendly desktop UI for Tasmota flashed devices for Windows, macOS and Linux. Features Native Tasmota device discovery (via ta

Tom Butcher 52 Dec 10, 2022