Big Update EdenSpark 1.0

Open Source AI-assisted platform for making games on PC and consoles

A platform that creates opportunities

One-click publishing, and the game remains yours.

  • Submit from the launcher, and your game is in the catalog: likes, comments, counters, and invite links.
  • You retain the rights to your game. We make no claims to it and don't lock it into the platform.
  • Don't want the catalog? The Export feature provides a self-contained standalone build: .exe, assets, and libraries.

Three game jams, more than 50 games in the catalog

This isn't an engine that’s “coming soon”. Nearly fifty games have already been built with it.

  • 3 game jams, more than 50 games in the catalog. Open and play them right now.
  • A couple of weeks per game. Participants arrived with no prior experience in EdenSpark or Daslang, yet they managed to create a huge number of high-quality games.

The Editor

If you’ve worked with Unity, Unreal, or Godot, you already know how to use it.

  • Familiar layout and actions: scene hierarchy, component inspector, asset importer, file browser, console, code editor, gizmos, and prefab mode.
  • All the essentials for traditional development are included: Play/Pause/Step, universal undo, drag-and-drop between panels, and hotkeys.
  • Extensive debugging info, including visual tools: frame statistics, an in-editor profiler, physics and navmesh rendering, and logs with clear stack traces.

Daslang: fast, strongly typed language with hot reload

Compiled-language speed, Python-like syntax, and on-the-fly reloading.

  • Faster than typical scripting languages: static typing and zero-cost interop with C++, no data marshaling on every call.
  • Simple, readable syntax similar to Python, making it easy to get started.
  • Large projects can be AOT-compiled (to C++), allowing you to achieve production speeds without rewriting gameplay logic in C++.
  • In-place debugging: VS Code debugger, function profiler, and memory profiler.
  • Plus hot-reloading: Ctrl+Shift+R reloads scripts without losing game state.
  • The language has its own website, documentation, a playground, and open source code — daslang.io 9 platforms, including PS5 and Switch.

Out-of-the-box MCP: the agent interacts with the engine directly, no guesswork

Connect tools like Claude Code, Codex, Cursor, Copilot, or Gemini and get to work immediately.

  • The MCP server runs inside the active game: the agent reads the scene, presses buttons, plays, and takes screenshots, all with undo support.
  • Dedicated MCP for Daslang: the agent writes code based on the actual API and documentation, not just what it "remembers". Fewer hallucinations and made-up functions.
  • Works offline, no API keys or accounts are required.

Out-of-the-box asset generation

Generate images and 3D models right inside the editor. No extra purchases needed.

  • Text-to-image generation, image editing, and 3D model generation, all built into the editor.
  • Eden Image Mini — an image generation model that runs locally on your PC: once installed, no internet connection or queues required.
  • Texture inpainting— paint over an area on a generated 3D model's preview, specify what should be there, and regenerate only that specific section.
  • This is a priority area for us: we are continuing to develop it and will integrate more powerful models as the community grows.

From 2D and low-poly to full PBR HD

A single engine for everything from pixel-art arcade games to high-fidelity visuals.

  • Two renderers: Standard: fast, multi-camera, supporting orthographic views and 2D; HD: full PBR with global illumination, volumetric clouds, realistic water, and TAA.
  • Both support: meshes, materials, particle systems, emission, sprites, Tiled format support for 2D, and custom shaders created via Shader Graph or Daslang code.
  • The renderer is built on Dagor Engine technology, which powers Gaijin’s flagship titles: War Thunder, Enlisted, Cuisine Royale, and others.
Standard Render
HD Render

Cutting-edge rendering technologies

Everything you’d expect from a major engine — it’s all here.

  • Dynamic GI with off-screen emission: lighting is recalculated in real-time, and emissive surfaces act as true light sources even when off-camera.
  • Translucency: light passes through thin surfaces like foliage, fabric, and curtains.
  • Vector fonts: text remains crisp at any size or zoom level.
  • Particle systems, bloom, volumetric clouds, and realistic water in HD.
without offscreen-emission
with offscreen-emission
without Translucency
with Translucency
without Bloom
with bloom

Custom shaders

.shader files; properties automatically become sliders in the Inspector; hot-reloading support.

  • Materials, 2D, and full-screen post-effects all use the same language. Dozens of ready-made shaders included: dissolve, hologram, cel-shading, force field, night vision, CRT, Mandelbrot.
  • User-defined shaders also work on consoles, where HLSL runtime compilation is unavailable and requires specific handling
  • Don't like writing code? There's Shader Graph.
var {
    @color rimColor = float3(0.0, 0.5, 1.0)
    speed = 4.0
}

[pixel_shader]
def fresnel_pulse(inp : PbrInput) {
    let rim = fresnel(3.0, inp.worldNormal, inp.viewDir) * rimColor
    let pulse = remap(sin(g_Time * speed), float2(-1, 1), float2(0, 1))
    return PbrOutput(emission = rim, emissionStrength = length(rim) * pulse * 5.0,
                     metalness = 0.0, roughness = 0.0)
}

Asset pipeline: fast and without a conversion step

Drop a file into the project, and it's immediately in the game. Modify the file, and the game updates.

  • No separate export to an engine-specific format: just place the source file, and the build happens automatically in the background.
  • Asset hot-reloading: swap a texture, model, or material, and the change is visible instantly without restarting.
  • Wide range of supported formats out of the box:
  • models: FBX, glTF/GLB, OBJ, DAE;
  • textures: PNG, JPG, BMP, PSD, TGA, SVG;
  • audio: WAV, OGG, MP3, FLAC; fonts: TTF, OTF; data: JSON, XML, TXT, binary .data.
  • Assets optimized for runtime and memory: vertex cache optimizer (up to 30x in benchmarks), mesh simplification, and one-click texture compression.
without optimization— 90.6 MB on GPU
Same textures with optimization— 15.9 MB on GPU

Prefabs

Assemble once, use everywhere, edit in one place.

  • Nesting and inheritance, drag-and-drop instancing, initial scene prefab.

Physics

Powered by Jolt. Tens of thousands of bodies in the simulation.

  • RigidBody, compound Collider's, CharacterController, joints (spring, hinge, 6DOF), raycast and ray picking, CollisionListener.
  • The engine handles tens of thousands of bodies simultaneously.
  • Includes vehicle physics: engine, transmission, wheels.

NavMesh

Agents find their own path. Plus, the NavMesh can be rebuilt on the fly.

  • NavMesh component: bake from scene colliders at the push of a button.
  • It builds so fast that it can be done at runtime, there is an API for baking directly from code. Procedural level generation and destructible environments are supported.
  • Single-line path requests; NavCorridor handles pursuit and dynamic path adjustments.

Audio

3D sound, reverb, effects and music composed via code.

  • Positional audio and reverb; long sounds are streamed, while short ones are automatically decoded into memory.
  • Strudel: rhythm and melody defined by patterns in just a few lines, SF2 soundfont support, and binaural HRTF.

Animation

A low-level API offering full control, plus helpers to avoid repetitive coding.

  • Full low-level control over blending and masks: animate for any specific task, rather than being limited to what the engine pre-defines.
  • Playback helpers for simple cases: one line of code starts the animation.
  • Built-in inertial blending: transitions feel natural without the need for cumbersome animation graphs or dedicated transition clips.

Multiplayer and Networking

Write a single-player game. Add [replicated]. Now two people can play.

  • Built-in multiplayer and network support: a server-side component instance appears on all clients complete with transform, parent, mesh, and collision data.
  • Integrated lobby and invite systems; the host runs within the player's process, there is no need to deploy a separate server.
  • Physics replication and synchronization are handled by the engine: networked objects move smoothly and collide with the world. Prediction for player-controlled objects and correction smoothing are implemented in game code, tailored to the specific genre rather than forced into a single, rigid model.
[replicated]
class Health : Component {
    hp : float = 100.0

    def override on_update {
        if (hasRemoteAuthority) {   
            return
        }
        hp = min(hp + 5.0 * get_delta_time(), 100.0)
    }
}

Download the launcher, then choose your path:

 

  • Download/Play any published game if you just want to play.
  • Create/Try — launch and explore any of the dozens of samples without creating a project.
  • Create/Clone — build your own game based on a sample.

edenspark.io | games.edenspark.io | docs.edenspark.io | Discord | Telegram

Download!
Previous
Next

EdenSpark Game Jam #3 Winners: The Elements Hand Out the Prizes

The judges picked the top three and the community chose their favorite. Meet the authors of the best entries of the third jam!

EdenSpark Update 1.0

Multiplayer without servers, offscreen GI, input configuration for different devices, and more!