Open Engine 2026.10.0-alpha.6

Open Engine 2026.10.0-alpha.6

A modern, high-performance, open-source game engine built for the community, by the community, with the goals of bringing power, scale, ease of use and true ownership to game developers.

It also builds for the web: the same engine runs in the browser on WebGPU, shipped as the @game-crafters-guild/openengine-web package with live examples. Its Web API is designed to bring the capabilities and performance of the engine into an HTML canvas anywhere: a few lines of JavaScript put a scene, its lighting and its models on any page.

Foundation

• Open source, MIT licensed.
• A modern C++20 code base.
• Hot-reloadable C# scripting on CoreCLR (.NET 10), and a build without .NET when scripting is off.
• Native C++ scripting.
• A modern renderer built on Vulkan, Metal and WebGPU.
• A cross-platform editor for Windows, macOS, Linux and the web. Yes, the editor runs in the browser.
• An ECS built on a true data-oriented design.
• UI driven by CSS layout and XML, in the editor and in games.
• Built for AI-assisted development: a bundled MCP server and CLI let AI agents drive the running editor, and an in-editor AI assistant ships as a preview.

New in this release

Pictures are on the changelog page for 19 October.

• A night sky full of stars. Fifty thousand stars with true brightness and color and a soft glow, in a star look contributed by Anjey. Auto exposure meters a night by its ground, not by its stars, and keeps it dark, and the scene is stored at the view's own exposure, so a night shows its faint stars and its detail instead of going black or turning into a hazy dusk. Auto exposure can meter either the picture or the light falling on the scene.
• Fog, computed on every surface. Each surface now computes the height fog in its own shader, at its own distance: terrain, grass, the ocean, glass and particles. Smoke in front of the horizon keeps its own color, edges against the sky keep their multisample anti-aliasing (MSAA), and open water fades into the haze at the horizon.
• Grass that takes the light. Blades lean, bend and twist one by one, and sunlight shines through them from behind. Meadow, Lawn and Steppe presets set up a whole field at once; better default values for them come in the next release.
• A generated C# layer, with physics and input. The engine's C# API is now generated: an engine developer marks a C++ function, record, enum or event in a header, and the build generates the native side and the C# from it, so a new call needs no hand-written glue. Physics and input are the first areas on it: C# scripts can ray cast, set a body's velocity, drive the character controller, react to contact and trigger events, and lock the pointer. This feature is not finished: the next release adds text and lists of results (render layers by name, Physics.RayCastAll and BoxOverlap), and audio, quitting the game, materials, the UI, the web's TypeScript side and components follow on the same layer.
• Named render layers. Name your render layers in Project Settings, pick them from a list in the inspector, and filter the Scene View by layer.
• Audio controls, contributed by Tim Aidley. Ogg Vorbis files play, and an Ogg Opus file is refused with a message to re-encode it. A playing sound's volume, pitch and pan can change, it can pause and resume where it stopped, and an Audio Emitter follows edits to its volume and pitch while it plays. Each 3D sound has its own distance falloff: none, inverse, linear or exponential, with a minimum and maximum distance and a rolloff. The controls are in C++; C# follows.
• Textures cook in seconds. A new BC7 encoder compresses a 4096² texture in about a quarter of a second on a 24-thread CPU, so the village sample is fully textured about 12 seconds after its first open instead of ten minutes.
• The web examples run on phones. The live examples now load and draw on Android phones (tested on a Pixel 6 in Chrome; about 10 frames a second in portrait).

Fixes and changes

• CSS transform and transform-origin work in the editor and in game UI, and clicks land where the element is drawn (#15, contributed by Tim Aidley).
• New scenes and the Blank template start on a clear day with horizon haze over a grid ground.
• C# scripts load when the project opens (#26).
• The editor keeps your panel layout between sessions (#28).
• The rotate gizmo turns the way you drag (#29).
• A speaker button next to Play mutes the editor's audio.
• A .cube color grade has a preview strip with skin tones in the inspector.
• Exported games ship one copy of each texture, about three quarters smaller.
• An exported game builds its shaders in parallel the first time it runs.
• The AI Assistant takes dictation on macOS and has a text size slider.
• Editor icons and SVG images in UI stay sharp at any size.
• A scene line the engine cannot read is listed in the load report, with the fix, instead of being ignored silently.
• Damaged model, animation, stylesheet and material files are refused with a message instead of crashing the editor, the Player or the web page.
• A Navigation Source component chooses which meshes a navigation bake uses.
• Paths keep clear of thin walls and the agent's radius.
• Ray casts honor their layer filter, and RayCastAll returns every hit.
• Create Empty Parent groups the whole selection in one undo step.
• Mark-ups keep their notes through undo.
• Objects no longer go missing from reflection probes.
• Long editor sessions no longer start drawing wrong on some GPUs.
• The editor no longer crashes on exit while shaders are building, or freezes when a package rebuilds.
• A clean checkout configures again: the NVTX download's checksum matches the archive GitHub serves (#34, contributed by Amelia Mesdag).
• Linux builds use patchelf 0.19.2 (#3, contributed by Tim Aidley).

If you are updating a project

• Render layers in scenes are lists: MeshRenderer.renderLayerMask = 1 becomes MeshRenderer.renderLayers = [0] (also on Terrain), Camera.cullingMask = 4294967295 becomes Camera.visibleLayers = all, Camera.postProcessMask = 4294967295 becomes Camera.volumeLayers = all, and HLOD (the merged distant meshes) needs a new bake (render layers).
• A custom render pipeline: delete the HeightFog pass and point the passes that read its output at the color it read. Then copy HeightFogParamsUpload, the fog inputs and the Tonemap node's "serviceTextures": ["uLut3d", "uLut1d"] from Engine/Assets/RenderPipelines/ForwardPlus.rendergraph. The editor names the pass it refuses (height fog).
• C# input calls are generated: Input.IsKeyDown(KeyCode.W, out bool down) becomes bool down = Input.IsKeyDown(Key.W), InputIds.HashInput(name) becomes StringId.Of(name), Input.Bind(ctx, action, Input.DeviceType.Keyboard, code: KeyCode.Space) becomes Input.BindKey(ctx, action, Key.Space), and RegisterAction(ctx, action, isAxis: false) takes ActionKind.Button. GameEngine.Physics.ABI is removed: use Physics.RayCast and entity.Physics (physics from scripts).
• C++ game UI: GameUI::FindElementByIdAny(id) becomes GameUI::FindElementById(id), and the per-document FindElementById(entityId, id) becomes GameUI::FindDocumentRoot(entityId)->FindById(id).
• Grass: TerrainGrass.bladeWidth is now the whole leaf's width, so double the value. Grass colors are read as sRGB: to keep an old look, each channel becomes round(255 × sRGB-encode(old / 255)), for example 128 becomes 188. Translucency now runs from 0 to 1 and 1 is a thin leaf; a scene that set a lower value for the old look shows thicker blades, so try 1 (terrain grass).
• A camera that stores Camera.autoExposureMinEv = 4 keeps a black night: delete the line (the default is now -7). SkyEnvironment.MoonPhase01 is gone: put its value in MoonArcPosition. Night views get a night tint by default; PostProcessVolume.nightTintStrength = 0 turns it off.
• A .cube asset picks its color encoding from the file. If an old grade looks brighter, set Input Encoding to Linear on the asset.
• Every texture recooks once.

In this release

• The source, built from a clean checkout with the steps in README.md and BUILD.md; the documentation at https://openengine.dev/docs/.
• An experimental Windows x64 build of the Editor, OpenEngine-Editor-2026.10.0-alpha.6-win-x64.zip (201 MB, SHA-256 688cfe0f07edf12e402e345356af7d03addb9af4bcab12cac97629d57dc13afb), to try the editor without building it, with the gameenginecli command-line tool and the MCP server. Requirements and limitations are in its README.txt: a Vulkan 1.3 driver, the .NET 10 SDK, the Visual C++ 2015-2022 x64 redistributable, and Visual Studio 2026 with the C++ workload for game export and C++ scripting; the Claude Code command-line tool for the AI Assistant.
• An experimental macOS Apple silicon build of the Editor, OpenEngine-Editor-2026.10.0-alpha.6-macos-arm64.zip (248 MB, SHA-256 3f7ce29322dc7f78fea8cd9577601414e00fa0b141602f1c2770890b4c56d44d), with the gameenginecli command-line tool and the MCP server. It needs macOS 15 or later and the .NET 10 SDK; the Xcode Command Line Tools, CMake and Ninja only for C++ scripting. It is signed ad hoc, not notarized: extract it with Finder and clear the download mark once (xattr -dr com.apple.quarantine <folder>), as its README.txt describes.
• An experimental Linux x64 build of the Editor, OpenEngine-Editor-2026.10.0-alpha.6-linux-x64.zip (298 MB, SHA-256 128c26d677db06eddd2ffef2bb287742b5bfa1272c5b9a9cb166f5e64c991372), with the gameenginecli command-line tool and the MCP server. It needs glibc 2.39 or newer (Ubuntu 24.04, Debian 13, Fedora 40 or newer), a Vulkan 1.3 driver and the .NET 10 SDK; a C++ compiler, CMake and Ninja only for game export and C++ scripting. It was built and tested in Linux containers without a GPU, as its README.txt describes.
• The Windows zip's README.txt says that macOS and Linux users build from source; the macOS and Linux Editor downloads above replace that.
• The web package @game-crafters-guild/openengine-web 2026.10.0-alpha.6 on npm under the alpha tag (npm install @game-crafters-guild/openengine-web@alpha), with the live examples at https://game-crafters-guild.github.io/opengine-web/.

An early release

This is an alpha: APIs and file formats may change between releases. The engine is yours as much as ours: open issues, send pull requests, and help shape it. Thank you to Tim Aidley for the audio, fog, CSS transform and Linux build changes in this release, to Amelia Mesdag for the NVTX checksum fix, to Anjey for the star look, and to Theformand for the reports behind the script loading, panel layout and rotate gizmo fixes.

Join us on Discord: https://discord.gg/c8JASm4q8

Known issues

• The first time an exported game runs, its first few seconds show a flat gray ground until its shaders are built.
• The height fog thickens with distance but does not thin with altitude, so aircraft and objects high in the sky turn gray.
• Particles, such as fire and smoke, do not show in reflections on wet or shiny floors.
• The moon is drawn as a flat white disc with a hard, stair-stepped edge.
• The four-point star with its faint halo is the Classic star look in the Sky Environment; it becomes the default in the next release.
• After you change the meshes under a baked navigation surface, it keeps the old paths: bake it again.
• Hiding or showing objects while the Hierarchy panel is open can pause a frame for about 70 ms (#32).
• C# has no calls yet for audio (#25), materials (#17), quitting the game (#21), the Markdown text control (#24), setting a UI element's transform (#33) or finding a render layer by name; C# scripts set layers by number.
• With tests turned on (-DBUILD_TESTING=ON), MaterialLitCubeTests and WebGpuDeviceSmokeTests do not compile: build the targets you need, not the whole tree.
• The headless Player (Player --headless) has been run on Windows and in a Linux container only.
• The sample's ShadowStress scene renders almost white in the Game View and in an exported game, on every platform: its sun has no light intensity unit. To fix it in your copy, give the sun the Lux unit (Light.intensityUnit = Lux), as the next release does.
• The macOS build needs macOS 15 or later. It is not notarized: macOS refuses the apps until the download mark is cleared, and a zip extracted with the command-line unzip loses part of the apps' signatures (use Finder or ditto -x -k).
• On macOS the Movie Recorder does not find the Player.
• On macOS, six of the engine's own tests fail on a clean checkout (the terrain bake cache, one render pipeline rebuild, one editor command-line cancellation and one texture upload), and one texture cook test assumes a Mac has no BC7 encoder; the editor and exported games are not affected.
• The Linux build has been tested only in containers with software rendering (Mesa llvmpipe) under X11, on Ubuntu 24.04 and Fedora 43: the editor opens the sample project and renders its scenes, a game export builds and the exported game runs. It has not been run on a Linux desktop with a GPU or under Wayland. It needs glibc 2.39 or newer; older distributions (Ubuntu 22.04, Debian 12) cannot start it.
• On ARM64 Linux, build with video turned off.