# Lumicraft Dynamic global illumination for Unreal Engine without Lumen. Every dynamic light bounces (directional, point, spot, rect), emissive materials light the scene, and the sky bounces off the ground. Objects get contact shadows in the bounce, and the sun's bounce follows the volumetric clouds' shadow. Works with Substrate, in split screen, in stereo for VR (tested with emulated instanced stereo, not on a headset), on landscapes, with DirectX 11, DirectX 12 and Vulkan, and on UE 5.6, 5.7 and 5.8. GPU cost at 1080p on an RTX 2070 Super, test courtyard (sun and sky / one point light), averaged over frames: | | Sun and sky | Point light | |---|---|---| | Lumicraft, Low | 0.3 ms | 0.35 ms | | Lumicraft, Medium | 0.9 ms | 0.7 ms | | Lumicraft, Epic (default) | 1.0 ms | 1.0 ms | | Lumicraft, Cinematic (4 grids, 384 m) | 2.0 ms | 2.0 ms | | Lumen Medium (Lumen Lite, 5.8) | 1.0 ms | not measured | | Lumen High | 4.2 ms | 4.1 ms | ## Setup 1. Enable the plugin. 2. Project Settings > Rendering > Global Illumination > **Dynamic Global Illumination Method: Plugin**. 3. Project Settings > Rendering > Software Ray Tracing > **Generate Mesh Distance Fields: on** (it is on in new projects). 4. Restart the editor. If steps 2 and 3 are missing, the editor says so when it opens and **Fix project settings** does them (and offers the restart). **Don't ask again** turns it off for the project, for one that switches between Lumen and Lumicraft on purpose. Lumicraft asks the engine for the global distance field by itself when the method is Plugin. If the log says "Lumicraft is off", the engine built no distance field: check that Generate Mesh Distance Fields is on. On UE 5.6 and 5.7 the Global Illumination scalability also has to be Medium or higher (Low turns distance fields off there, and Lumicraft with them, like Lumen); on 5.8 Low keeps Lumicraft on with one grid. Low also turns off the engine's distance field AO, so a movable sky light is no longer shadowed and lights rooms from inside; that is the engine's Low, the same with Lumen. The method can also be set to Plugin in a Post Process Volume only; Lumicraft then asks for the distance field on its first frame. ## How it works Light is spread through a grid of cells around the camera (a light propagation volume). Each frame: 1. Cells just in front of a surface, found with the global distance field, are lit by every dynamic light, with soft shadows traced through the distance field. 2. The light each surface reflects, tinted by its color, spreads one cell per step. Geometry blocks it, and a surface absorbs what reaches it (it comes back as the next bounce). 3. The light arriving in front of each surface is added to the scene as indirect diffuse light, where Lumen's would be. There are two nested grids by default: 48 cells of 1 m and 48 cells of 2 m, so 96 m of reach. ## How bright, compared with ground truth A light propagation volume on its own keeps too much light out in the open and loses light in closed rooms. Lumicraft scales each surface's bounce by how much sky it sees, calibrated against Unreal's path tracer in the test scenes (an open courtyard lit by the sun and by a point light, three rooms, a street). The bounce Lumicraft adds lands between 0.4 and 1.7 times the path traced one, about 1.3 times off on average; without the calibration it went from 0.3 to 3.5 times. Lumen High measured 0.7 to 1.1 times in the same scenes, so it is closer. Use `r.Lumicraft.Intensity` or a Post Process Volume's Indirect Lighting Intensity to match your art direction. ## Settings **Project Settings > Plugins > Lumicraft** has every setting that changes the look: intensity, cell size, bounces, sky, sky occlusion, final gather, emissive, contact distance, fog and translucency, rough reflections, baked GI, the stylized bounce, and the calibration values under Advanced. They apply right away and are saved in `DefaultEngine.ini`. Blueprint can change all of them at runtime (see Blueprint). What costs GPU time follows the engine's **Global Illumination scalability** (`sg.GlobalIlluminationQuality`), like Lumen, so a game's graphics menu drives it: | Level | Grids | Steps | Contact occlusion | Grid updates | Final gather rays | |---|---|---|---|---|---| | Low | 1 | 6 | off | every 2 frames | 4 | | Medium | 2 | 8 | on, a quarter resolution | fine every frame, coarse every 2 | 4 | | High, Epic | 2 | 8 | on | fine every frame, coarse every 2 | 8 | | Cinematic | 4 | 8 | on | every frame | 8 | The final gather is off unless you turn it on (LP_Interior does). With it on, Medium costs 1.7 ms in the test courtyard against 2.2 ms on Epic: half the rays take 0.43 ms off the gather, for a little more flicker and the shade about 7% brighter. All of them are console variables, so they can also go in `DefaultEngine.ini` under `[SystemSettings]` or change at runtime. A value set there or in the console wins over the scalability level. | Variable | Default | What it does | |---|---|---| | `r.Lumicraft.Enable` | 1 | On or off. | | `r.Lumicraft.Intensity` | 1 | Scale on the bounce light. | | `r.Lumicraft.Cascades` | 2 | Nested grids, 1 to 4 (48, 96, 192 or 384 m of reach). Each one more costs about 0.25 ms when updated every other frame. | | `r.Lumicraft.CellSize` | 100 | Size of the finest cell, in cm. Tuned at 100. Smaller cells reach less (each grid is 48 cells across, so raise `GridSize` with it) and lose more light over distance, because light loses a little at every cell it crosses: with 50 cm cells a wall 9 m from the light got a fifth of the bounce. Larger cells blur it (200: about 0.8). Check `r.Lumicraft.Intensity` after changing it. | | `r.Lumicraft.GridSize` | 48 | Cells per side. The cost grows with the cube of it. | | `r.Lumicraft.Iterations` | 8 | Propagation steps per frame. | | `r.Lumicraft.FineUpdateInterval` | 1 | The finest grid updates once every this many frames. 2 halves the cost (about 0.75 ms instead of 1.05 in the test courtyard) with a slower response to moving lights; Low uses it. | | `r.Lumicraft.Freeze` | 0 | 1 = the GI stops updating and keeps the light it has: about 0.35 ms, only the final apply. For static scenes, menus and cutscenes. A grid still moves when the camera gets a quarter of it away. | | `r.Lumicraft.CoarseUpdateInterval` | 2 | The coarser cascades update once every this many frames and reuse their light in between. 2 cuts the average cost by about 20%. 1 = every frame. | | `r.Lumicraft.TemporalPropagation` | 1 | Each frame continues the last one's propagation, so light travels further for the same cost. When a light turns off, 6% of its bounce is left after 3 frames and under 1% after 10 in the fine grid; the coarse grid, updated every other frame, takes about twice as long. 0 = every frame starts from zero. | | `r.Lumicraft.MultiBounce` | 0.75 | Light bounces more than once (one more bounce per frame). Higher fills closed rooms more but lingers longer when a light turns off. 0 = single bounce. | | `r.Lumicraft.EnclosedBounce` | 2.8 | Scale on the first bounce of a surface that sees no sky. | | `r.Lumicraft.OpenBounce` | 0.3 | Scale on the first bounce of a surface that sees half the sky or more. | | `r.Lumicraft.MultiBounceOpenSky` | 0.25 | Share of the further bounces kept by a surface that sees the sky. | | `r.Lumicraft.SkyBounce` | 1 | Sky light bounced off surfaces. 0 saves about 0.15 ms. | | `r.Lumicraft.Emissive` | 1 | Scale on the light emissive materials cast. | | `r.Lumicraft.EmissiveFade` | 0.98 | How long emissive light the camera stopped seeing is remembered (per frame). 1 = until seen again. | | `r.Lumicraft.StationaryLights` | 0 | 0 = when the project allows static lighting, stationary lights do not bounce (their bounce is baked). 1 = they always bounce. | | `r.Lumicraft.SelfDamping` | 0.75 | Keeps a surface from lighting itself. | | `r.Lumicraft.PropagationWeight` | 1 | Scale on what each propagation step carries. 1 keeps the energy; below 1 the bounce fades faster with distance. | | `r.Lumicraft.DefaultAlbedo` | 0.4 | Color (grey) used for surfaces the camera has not seen yet. | | `r.Lumicraft.SampleOffset` | 0.5 | How far in front of a surface the grids are read, in cells. Further leaks less through walls but loses contact. | | `r.Lumicraft.ContactOcclusion` | 1 | Darkens the bounce under and next to objects (a box on the floor, a corner), traced in the distance field at half resolution. About 0.13 ms. 0 = off. | | `r.Lumicraft.ContactOcclusionDistance` | 100 | How far the contact occlusion looks, in cm (10 to 300). | | `r.Lumicraft.EngineVolume` | 1 | Fills the engine's translucency GI volume, so volumetric fog, lit translucent materials and heterogeneous volumes take the bounce. About 0.02 ms. 0 = off. | | `r.Lumicraft.HalfResApply` | 1 | Reads the grids for one pixel in four and fills in the rest by depth (the bounce is smooth). Saves about 0.08 ms at 1080p. 0 = every pixel. The final gather always runs at half resolution, so with it on this setting has no effect. | | `r.Lumicraft.ContactResolution` | 2 | Contact occlusion traced for every pixel (1), one in 2x2 (2) or one in 4x4 (4); Medium scalability uses 4, about a third of the cost. | | `r.Lumicraft.ContactBlur` | 1 | Blurs the contact occlusion along each surface, two passes of 9 samples, about 0.03 ms. 0 = raw: blotchy where the distance field is rough (log walls, rocks), mostly hidden by TSR. | | `r.Lumicraft.CharacterOcclusion` | 1 | Characters darken the bounce around them with their shadow capsules (see Characters below). Runs in the contact occlusion pass, about 0.02 ms per character. 0 = off. | | `r.Lumicraft.UseBakedGI` | 1 | A Lumicraft Baked GI Volume in the level lights it with its asset (see Baked GI). 0 = live GI, to compare. | | `r.Lumicraft.SkyOcclusion` | 0 | Lumicraft shades the sky light, its diffuse light and its reflections, with the sky its grids see times the contact occlusion. It replaces the engine's distance field AO and SSAO in the views Lumicraft renders, view by view: no console variable changes, so the game's graphics menu keeps them, and they are back as soon as Lumicraft is off or Lumen takes over. It works with live grids (not with baked GI) and a movable sky light; anything else keeps the engine's own AO. No dark smudges at the foot of rough walls, and less sky inside rooms. It follows the sky light's Occlusion Exponent and Min Occlusion, as the engine does for its distance field AO. Same cost. Movable sky light only. LP_Interior turns it on. | | `r.Lumicraft.FinalGather` | 0 | Each pixel gathers the bounce from the surfaces around it with short rays through the distance field, the way Lumen does, instead of reading the grid in front of it. Colors bleed from one surface onto the next: in the village cabin the red floor warms the walls as it does with Lumen, where the grid alone left them grey. About 1 ms more. LP_Interior turns it on. | | `r.Lumicraft.Style` | 0 | Stylized bounce, for stylized games (a realistic scene barely shows it): 1 = painted (more of the color it picked up, cooler where weak, warmer where strong; `r.Lumicraft.StyleSaturation`, 1.8), 2 = bands (steps of `r.Lumicraft.StyleBandStops` stops, 1, for toon shaded materials), 3 = voxel (one light per grid cell, in blocks). | | `r.Lumicraft.FinalGatherRays` | 8 | Rays per traced pixel (one pixel in four is traced, then blurred along each surface). The GI scalability sets 4 on Low and Medium; a preset leaves it to the scalability unless Override Quality is ticked. | | `r.Lumicraft.FinalGatherDistance` | 400 | How far the rays go, in cm; past it they take the grid's light. | | `r.Lumicraft.RoughSpecular` | 0 | Rough reflections from the grids, faded in from roughness 0.35 to 0.7, on top of the engine's. About 0.1 ms at 1080p. | | `r.Lumicraft.SunSampling` | 1 | The sun's shadow ray starts at another of 16 spots over each cell's surface every update and the result is averaged, so a sun patch smaller than a cell (through a window) lights its share of it. Same cost as one ray. 0 = one ray from the middle: rooms light in blotches, one side bright and the other dark. | | `r.Lumicraft.Debug` | 0 | 1 = position in the cell, 2 = bounce light on white, 3 = normal, 4 = cascade, 5 = stored emissive, 6 = stored albedo, 7 = contact occlusion, 8 = where the grid thinks the sun reaches (yellow lit, blue shadowed), 9 = sky visibility (what `r.Lumicraft.SkyOcclusion` hands the engine, white = open). Debug views read the grids at full resolution without the final gather, and leave the sky light unshadowed. | For lights that switch instantly with no trace at all, set `r.Lumicraft.TemporalPropagation 0` and `r.Lumicraft.MultiBounce 0`. Bounce light will then reach less far. ## Fog, translucent materials and particles **Volumetric fog and lit translucent materials take the bounce on their own.** Each frame Lumicraft fills the engine's translucency GI volume, the one Lumen fills, with its bounce plus the sky light. The engine's volumetric fog, lit translucent materials (glass, water, lit particles) and heterogeneous volumes read it, so the fog around a street lamp glows with the bounce and a window pane picks up the color of the room. Nothing to set up; every view gets its own, split screen included. It costs about 0.02 ms and can be turned off with `r.Lumicraft.EngineVolume 0`. The volume reaches 80 m from the camera, like Lumen's; past that, fog and translucents get the sky only. **Unlit translucent materials and unlit particles** do not read that volume. For them, Lumicraft also copies its grids into a texture the material function **MF_LumicraftTranslucentGI** (Lumicraft content, Translucency folder) reads: 1. Add the function to the unlit translucent material. 2. Plug its **Emissive** output into the material's Emissive Color (add it to whatever is there). 3. Leave **Normal** empty for surfaces; give it zero for smoke and particles, lit the same from every side. Do not add the function to a lit translucent material as well: it would get the bounce twice. The function reads the finest grid first and the coarser ones past it (up to 384 m with four grids); that texture takes 4 MB, costs about 0.01 ms per grid and follows the first player in split screen. `M_LumicraftGlassExample` is a plain lit translucent material that gets the bounce from the engine's volume. ## Baked GI For a level whose lighting never changes, or for weaker hardware: save the grids once and use them with no update cost. The bounce, the fog and the translucents look the same; the GPU only applies it. 1. Stand the camera in the middle of the area to cover (in the editor viewport or in Play), with the GI looking the way you want. 2. Open the console and type `Lumicraft.Bake` (or `Lumicraft.Bake /Game/Maps/MyLevel_GI` to pick where the asset goes). In the editor, keep the viewport's Realtime on: the grids are read from what it renders. A path that already holds another asset is refused. 3. A second later the asset is saved and a **Lumicraft Baked GI Volume** in the level points at it (one is placed if the level has none). Save the level to keep it. Baked from Play, the asset stays but the volume lasts only for that session: drop a Lumicraft Baked GI Volume in the level and pick the asset. Measured in the example village at 1080p, Epic: 0.77 ms live, 0.21 ms baked, same picture. The grids reach as far as they did when baked: 48 m around the camera with one grid, 96 m with two (Epic), 384 m with four (Cinematic); set the scalability before baking. Past that there is no bounce. Each grid takes 1.8 MB on disk and in video memory. The bake keeps what was lit at that moment: a door that opens, a lamp switched on or a sun that moves is not seen. Turn **Use Baked GI** off on the volume (Blueprint too) to go back to live GI, and `r.Lumicraft.UseBakedGI 0` compares the two. Characters still darken it around them through their capsules. Baking again over the same asset updates every volume using it. ## Lumicraft GI Light A light that only feeds the GI (`ALumicraftGILight`, or the `Lumicraft GI Light` component on any actor). It lights the bounce, never the surfaces directly, and keeps working off screen. Put one in a neon sign, a screen or a lava pool, so their glow keeps lighting the room when the camera looks away (emissive materials only count while the camera sees them), or use it as a fill light that only exists in the bounce. Color, intensity in candelas, radius; soft shadows from the distance field. ## Lumicraft Paint Volume Paints the bounce by hand, where Lumen leaves no say (`ALumicraftPaintVolume`, or the `Lumicraft Paint Volume` component). Scale the box to size it; Shape makes it a box or the ellipsoid inside it, and Edge Softness fades it in from the edge. Two modes: - **Light**: the surfaces inside get a fill light of that color (Intensity in lux; the demo's sun is 10), and bounce it on like any other light. It reaches past the volume through the grids and stops at walls: a warm fill in a dark corner, green light rising off a swamp, a cold glow in a cave. - **Bounce**: the color the surfaces inside bounce with is multiplied by Color times Intensity, up to white (a surface never sends out more than it gets). A red carpet that warms the room more, a floor that bounces less, a wall that bounces green. Dark surfaces gain the most: in the village cabin, the red floor at 3.5 times brought the back wall from 52 to 92 (linear, x1000). In the demo, P paints the cabin: a warm fill, a cold corner and a floor that bounces 3.5 times and warmer. Up to 32 per view (the nearest to the camera when there are more), moved and edited live (Blueprint too). Neither is drawn nor collides. The cost is a few reads per surface cell and per pixel. With baked GI the grids are not recomputed: Light still lights the surfaces inside but no longer spreads, and Bounce does nothing. ## Lumicraft Light Sensor A component that reads how much bounce light reaches the point where it sits: `IndirectLight` (color), `IndirectLuminance` (one number) and `bHasReading`. For a stealth game that knows when the player is in the dark, an AI that sees better in lit rooms, a light meter. Updated every frame, two or three frames late (read back from the GPU). Indirect light only; add the direct lights you care about yourself. Up to 64 per world. `bHasReading` turns false when the GI is off or Lumen takes over. ## Blueprint Everything is reachable from Blueprint (category **Lumicraft**): - **Get Lumicraft Settings** / **Set Lumicraft Settings**: every setting in one struct (Lumicraft GI Settings). Get it, change a few fields, set it back; only the fields that changed are written. - Two presets come with the plugin (Lumicraft content, Presets folder): **LP_Interior** (cells of 50 cm, intensity 0.55, the sky occlusion and the final gather on, for houses and small rooms: a 4 m room is 8 cells across instead of 4 and its walls and ceiling get the light Lumen gives them, with half the reach; about 2.5 ms at 1080p on an RTX 2070 Super on Epic, 1.1 ms of it the final gather, and about half a millisecond less on Medium) and **LP_WeakHardware** (one grid every other frame, no contact occlusion, about 0.3 ms). The demo applies LP_Interior inside the cabin and resets outside, the way a game would at a door. - **Lumicraft Preset** assets (Content Browser > Miscellaneous > Data Asset > Lumicraft Preset) and **Apply Lumicraft Preset**: make your own besides the two above, a night one, one per biome. A preset leaves the Quality fields to the game's graphics menu unless **Override Quality** is ticked. For a preset per area, apply it from a trigger box's overlap events; for brightness and tint per area, a Post Process Volume's Indirect Lighting Intensity and Color already do it. - **Reset Lumicraft Settings**: takes back everything set from Blueprint, so Project Settings and the scalability decide again. - **Set Lumicraft Quality** (Low to Cinematic): Lumicraft's part of a scalability level without touching the rest of the engine. - **Bake Lumicraft GI**: the bake as an async node, with On Baked (the asset) and On Failed. The level's Lumicraft Baked GI Volume points at the result; its **Baked GI** and **Use Baked GI** can be set from Blueprint to swap bakes (a day and a night one) or go back to live GI. From Python or editor scripting, which do not see async nodes, use **Bake Lumicraft GI (Scripting)**, bind On Baked and On Failed on the object it returns, then call **Start**. - **Set Lumicraft Debug View**, **Is Lumicraft Active** (for a graphics menu), and the shortcuts **Set Lumicraft Frozen**, **Set Lumicraft Enabled**, **Set Lumicraft Intensity**, **Set Lumicraft Update Interval**. - The **Lumicraft GI Light**, **Lumicraft Paint Volume** and **Lumicraft Light Sensor** components expose their properties and readings to Blueprint. Blueprint sets the console variables above the Project Settings and the scalability, so it applies to every view. ## Example map `Lumicraft Content/Examples/LumicraftExample`: a courtyard with colored walls in the sun, a closed room lit only by an emissive strip and a GI Light, and a glass panel reading the GI. Its post process volume turns Lumicraft on in that map whatever the project uses. ## Limits - Windows is tested (DirectX 11, DirectX 12, Vulkan). Linux builds, but it has not been run on Linux yet; tell us if you do. - Deferred renderer only. With Forward Shading on, the engine never calls a GI plugin (Lumicraft says so in the log). - Emissive materials cast light once the camera has seen them, and fade out shortly after it stops seeing them. Only opaque ones count (translucent emissive never reaches the GBuffer). - With a stationary sky light, or with baked lighting in the level, emissive capture is off: the engine has already added that light to the colors Lumicraft would read. Use a movable sky light and no lightmaps for emissive bounce. - The Post Process Volume's Indirect Lighting Intensity and Indirect Lighting Color scale and tint the bounce, like they do for Lumen. A volume around a cave or a room is how to adjust one area. - Scene captures and reflection captures that do not render every frame start fresh each time: they take four times the steps instead, with a single bounce. - Rooms only a few cells across lose bounce on the way to the ceiling: with 1 m cells the village cabin (4 m) got half of Lumen's light on its ceiling. LP_Interior (50 cm cells) brings it level. - The engine lights interiors with the sky light too, shaded only by its distance field AO, which is coarse: through windows the sky leaks in and greys the walls, and the AO leaves darker, greenish smudges at the foot of rough walls (log walls, rocks), with or without Lumicraft (Lumen replaces that light, so neither shows there). `r.Lumicraft.SkyOcclusion 1` (on in LP_Interior) shades the sky light with Lumicraft's grids instead: in the village cabin the smudges are gone and the walls come out level with Lumen. It needs a movable sky light and takes the engine's distance field AO and SSAO off the views it renders (the contact occlusion takes SSAO's place). With ray traced AO on, the engine writes its own AO after Lumicraft and keeps it. Without it, raise the Sky Light's **Occlusion Exponent** (2.5 in the demo) to shade the inside without changing the open ground. The sky also shows in the reflections inside (a grey sheen on floors and walls): a reflection capture in the room fixes that, as without Lumen in any project; the demo's cabin has one. - Low resolution by nature: bounce light is soft. Walls and roofs 20 cm thick or more keep the light out of a closed room (measured: same as with the GI off). The engine's global distance field has voxels of about 40 cm and blurs a 10 cm wall, so Lumicraft checks which side of a surface each shadow ray is on as it passes it. A closed room with 10 cm walls in full sun lets in a seventh of what got through without the check. Rays that pass close to a window frame or a door jamb are told apart by the shape of the distance field there, so windows keep their light (measured the same as without the check). Debug view 8 shows where the grid thinks the sun reaches. - No sharp reflections of its own. Keep Screen Space Reflections and place reflection captures indoors (they capture Lumicraft's bounce). With a movable sky light, keep its distance field AO on, or turn on `r.Lumicraft.SkyOcclusion`, so the sky does not shine in reflections inside rooms. `r.Lumicraft.RoughSpecular 1` adds rough reflections from the grids (rough metal and plastic pick up the color of the room); it is off by default because it adds to the engine's reflections instead of replacing them, and costs about 0.1 ms. - Characters (skeletal meshes) are not in the engine's distance field, which is what Lumicraft traces. They receive the bounce, and darken it around them through their shadow capsules, the same ones the engine uses for Capsule Indirect Shadow: set a **Shadow Physics Asset** on the skeletal mesh and turn on **Capsule Indirect Shadow** on its component. That covers the floor around the feet and the body itself (an arm against the chest). It needs the contact occlusion pass (High scalability and up). Characters still do not block the light travelling across a room or tint a wall with their color. - Static lights are skipped, and stationary ones too when the project allows static lighting (see `r.Lumicraft.StationaryLights`); their bounce is in the lightmaps. - Up to 64 lights feed the bounce in each view, Lumicraft GI Lights included. Past that the directional lights go first, then the local lights brightest at the middle of the grids. A local light only costs anything in the cells its attenuation radius reaches. - Up to 64 shadow capsules darken the bounce in each view, the nearest characters first. A character usually has 10 to 15, so four to six characters close to the camera get them. ## Engine hotfixes Lumicraft plugs into the engine's GI hook, which works on the renderer's own types, and a hotfix can change them. A plugin compiled for one hotfix (say 5.7.1) and run on another (5.7.4) may crash at startup or when the GI turns on. The log says when the two differ ("Lumicraft was compiled for..."). To rebuild it for your hotfix: 1. Move the Lumicraft folder from the engine's `Plugins/Marketplace` folder into your project's `Plugins` folder. 2. Delete its `Binaries` and `Intermediate` folders. 3. In a C++ project, right click the `.uproject` > Generate Visual Studio project files, then build. A Blueprint-only project needs one C++ class first (Tools > New C++ Class, any parent). Or from a command line: `RunUAT.bat BuildPlugin -Plugin=<path>/Lumicraft.uplugin -Package=<output folder>`. ## Support Email contato@tessaroapps.com. Say which engine version and graphics card you use, and attach the log (`Saved/Logs`); a screenshot with `r.Lumicraft.Debug` on helps too. Free Windows demo: https://github.com/filipetessaro/lumicraft-demo