Simple 2D platformer engine • Charity-first creation

Eliah Engine.
Simple 2D Platformer Creation.

“Eliah Engine is game engine for 5 to 99 years old to make a simple game,its idea to build something for everybody,but main goal and idea is charity function that was at beggining of this story engine”— Eliah M
Original statement by Eliah M • Presentation copy: made by ChatGPT
0Lighting checks passed
0Turret families
0Export paths
ELIAH ENGINE / VIDEO SHOWCASEYOUTUBE READY
VideoLevel EditorTest GameEXEHTML5
ANYTERRAINPAINT PROPROTECTED LIGHTINGMODULAR TURRETSDEVELOPER EXPORTCONNECTED LEVELSLAN MULTIPLAYERCHARITY VISION
01 / Engine systems

Every major tool becomes a visible, animated system.

This showcase is rebuilt from the uploaded Phase 6 engine package. Every original animation can be replaced from WordPress, and new multilingual system categories can be added without editing code.

01Runtime connected

AnyTerrain World System

Free shapes, slopes, curves, loops, moving and rotating platforms, conveyors, environment zones, destructible terrain, runtime deformation, chunking, repair, profiling and deterministic replay.

  • Shared Editor → Test → Export runtime
  • Connected strokes and terrain groups
  • Large-world partition and performance tools
02Professional painting
BRUSH
32CONNECTEDSQUARE

Paint Pro System

Industrial grid painting with adjustable tile and brush sizes, connected grouping, shapes, materials, drag painting, Shift-to-erase and one-transaction undo/redo.

  • Paint terrain, hazards and gameplay volumes
  • Edit a complete painted group as one object
  • Incremental preview while dragging
03Protected post stack
BLOOM
FOG
LUT
TONE

AAA Lighting & Post-Processing

Normal-mapped lighting, SDF shadows, material response, multi-pass bloom, height and distance fog, local fog zones, color grading, CUBE LUT sampling and multiple tone mappers.

  • Depth-aware background response
  • Independent pass failover
  • Live Editor → Test Game publishing
045 effect families
ICEGUMGASACIDFIRE

Modular Turret Studio

Cryo Ice, Elastic Gum, Neuro Gas, Corrosive Acid and Fluid Flame modules with aim tracking, charge telegraphs, recoil, projectile trails, impacts and bounded effect pools.

  • Fixed direction or player tracking
  • Terrain-aware line of sight
  • Editor preview and export parity
05Release + Developer
project.snapshot()iwatch.scan_all_levels()preflight.validate_assets()runtime.publish_shared_world()developer.enable_tools()
PROJECTIWATCHBUILD
RELEASEDEVELOPER
F1GRIDCOLLISIONINSPECTORFRAME STEP
PREPARINGSCANNINGPACKAGINGREADY

Export System + Developer Runtime

Windows game export, clean HTML5 Release export and editable HTML5 Developer export share the canonical connected world. The Developer build keeps the playable game and adds diagnostics, overlays, object inspection, frame stepping and a verified full-code package.

  • Double iWatch staging scan
  • Transactional folder and ZIP publishing
  • Fixed-step browser simulation
  • No required paid CDN or API
06Movement runtime
RUNJUMPWALLDASH

AnyTerrain Player

A shared player runtime designed for slopes, walls, moving terrain and export parity, with room for advanced movement, abilities, combat modifiers and deterministic replay diagnostics.

  • Terrain-aware collision movement
  • Stable runtime contract
  • Editor and export integration
07Connected world
01
02
03

Level Join & Connected Camera

Levels form one connected world with a persistent camera, transition preloading, mixed platformer/top-down routing and project-local level packages.

  • Camera continuity between levels
  • Visible transition space
  • JSON and Eliah package workflows
08Project-local assets
PNGGIFMP3WAV

Image, Sprite & Sound Pipeline

Import project images, GIFs and sound assets, preserve transforms, connect material events and prepare normal/height data for the lighting path.

  • Asset package and async loading path
  • Material-linked sound hooks
  • Export staging verification
09Adaptive performance
NATIVE CORE60FPS TARGET
RENDERPHYSICSSCRIPTSASSETS
RUSTPYTHON

Adaptive Performance Architecture

Frame pacing, render budgets, culling, texture streaming, async assets, persistent GPU resources, native acceleration and Python fallback are organized to preserve a playable world when hardware limits are reached.

  • Per-system frame budgets
  • Hardware-aware quality adaptation
  • Native DLL path with fallback
  • Diagnostics instead of silent failure
10LAN ready • VPS path
HOST
P2
P3
VPS

LAN Multiplayer & VPS Path

The LAN runtime provides discovery, host election, TCP connection, migration, validated snapshots and interpolation while the game keeps its local simulation. The same architecture communicates the future online server path.

  • No paid network library required
  • Reconnect and host migration
  • Validated bounded messages
  • Shared runtime protocol
02 / Five modular turret families

Every turret has its own gameplay rule and its own animation.

The R10 package keeps the turret system modular: each family owns its projectile behavior, editor fields, impact response and player or terrain effect.

01 / CRYO ICE

Cryo Ice Turret

Charged frost bolts remember recent hits. The first hit chills and slows the player; the second hit freezes the player, while reinforced hits deepen the ice shell.

  • Editable chill, freeze and stack-memory durations
  • Frost projectile trail and terrain crystal impact
  • Best for timing challenges and movement control
02 / ELASTIC GUM

Elastic Gum Turret

An elastic lower-body shot stretches and wobbles in flight. On impact it slows the player and pulls movement back toward a sticky anchor for a configurable duration.

  • Editable duration, speed factor and pull force
  • Wavy projectile motion and sticky terrain splat
  • Creates pressure without fully removing control
03 / NEURO GAS

Neuro Gas Turret

A slow projectile grows into a layered neuro cloud. Every hit extends the effect and the player controls are reshuffled at deterministic intervals.

  • Editable effect duration, switch interval and cloud growth
  • Expanding smoke layers with bounded visual effects
  • Designed for confusion zones and puzzle encounters
Corrosive Acid Turret editor and HTML5 demonstration
04 / CORROSIVE ACID

Corrosive Acid Turret

An AAA acid burst damages the player and eats compatible AnyTerrain and Paint Pro platforms cell by cell. It updates collision and leaves a spreading corrosive pool.

  • Editable acid duration, cells-per-second and pixel-cell size
  • Terrain erosion, collision refresh and damageable-platform support
  • Creates permanent route changes and environmental hazards
05 / FLUID FLAME

Fluid Flame Tower

A charged flame tower produces a terrain-blocked layered stream approximately ten pixels thick, combining heat, sparks, smoke, burn damage and optional terrain damage.

  • Editable stream duration, burn duration and terrain damage
  • Terrain-aware flame blocking and layered particles
  • Useful for area denial, timed passages and moving fire walls
03 / Simple 2D platformer engine

Start building a platformer without starting from an empty code file.

Eliah Engine brings level editing, player movement, terrain, lighting, sound, gameplay systems and export tools into one visual workflow for beginners, learners and indie creators.

Build speedrun and platformer games

Create connected 2D levels, slopes, moving platforms, hazards, turrets, checkpoints and movement challenges for classic platformers or speedrun-focused games.

Use visual tools before programming

Drag, click, paint terrain, configure systems and test the game directly. Developer exports remain available when deeper code access is needed.

Export for desktop and web

Prepare Windows EXE, HTML5 Release and HTML5 Developer packages with shared project data, validation and diagnostic workflows.

¿Qué es Eliah Engine?

Eliah Engine es un motor sencillo de plataformas 2D y un editor visual de niveles diseñado para ayudar a principiantes a crear juegos con herramientas de clic, sistemas reutilizables y flujos guiados.

¿Necesito ser programador para usar Eliah Engine?

No. El proyecto se basa en controles visuales, edición mediante arrastrar y soltar, sistemas de juego preparados y botones sencillos, a la vez que ofrece exportaciones Developer y código editable para usuarios avanzados.

¿Qué juegos puedo crear con Eliah Engine?

El motor se centra en plataformas 2D, plataformas de speedrun y experiencias de niveles conectados, con terreno, movimiento, iluminación, materiales, torretas, audio, multijugador y sistemas de exportación para muchas ideas.

¿Cómo se puede exportar un juego de Eliah Engine?

Los proyectos pueden prepararse para Windows EXE, HTML5 Release y HTML5 Developer. Las exportaciones Developer añaden diagnósticos, overlays, herramientas de inspección y paquetes de código editables.

¿Por qué Eliah Engine incluye una visión benéfica?

El proyecto se creó con el objetivo a largo plazo de hacer accesible la creación de juegos, dirigir una parte significativa del éxito futuro a la caridad y utilizar el resto para sostener el desarrollo y los costes operativos.

04 / Current uploaded build
R10 • INDUSTRIAL RUST BUILD FIX 2 • ABI 1.9

Nine protected native lighting modules with measurable performance and visual certification.

The latest uploaded package adds eliah_light_validation.dll and hardens the complete Rust build. It measures frame percentiles, true 1% low FPS, hitches, budget overruns, quality oscillation, luminance flicker, SDF shadow stability and deterministic parity fingerprints.

  • 35 of 35 R10 source, ABI, deployment and integration checks passed
  • Industrial source preflight passed 35 of 35 additional build-fix checks
  • R1–R8 compatibility, R9 export compatibility and 332 Python files passed
  • Four-scene deterministic Python fallback suite passed
Native Windows certification

The package contains all Rust sources and the protected build script. Run BUILD_LIGHT_R10_WINDOWS.bat on Windows to cargo-check, compile, install, load, hash-verify and certify all nine real DLLs.

R10 PERFORMANCE + VISUAL CERTIFICATION35 / 35
P50CAPTURE
P95CAPTURE
P99CAPTURE
1% LOWREPORT
COREPERFSDFMATPOSTENVPARALLAXEXPORTVALIDATION

HITCH AUDITPASS

QUALITY OSCILLATIONSTABLE

VISUAL FLICKERPASS

SHADOW STABILITYPASS

STACK FINGERPRINTDETERMINISTIC

05 / What’s New

New updates are added above the original history.

Open Appearance → Eliah Engine Updates and upload one or more compact JSON files. A JSON package can add several releases at once; the same unique ID replaces only that update, while the permanent history remains below it.

CPP STEP26 NEW BUILD
2026-08-16CPP STEP26

Industrial multithreaded C++ job runtime

STEP26 adds a persistent native worker pool with priorities, work stealing, JobFence synchronization and parallel range dispatch. It connects per-category CPU timing to STEP23 profiling and validates 100,000 concurrent jobs plus a 1,000,000-item dispatch.

  • High, Normal and Background lanes schedule World, Physics, Collision, Terrain, Particles, Culling, Streaming and Draw Submission work.
  • Nested worker-assisted waits avoid dispatch deadlocks, failed jobs are isolated, and the build uses short isolated intermediates for long-path-safe MSBuild/FileTracker operation.
R11N.4 NEW BUILD
2026-08-10R11N.4

Canonical FPSC C++ runtime + final Level Editor performance pass

R11N.4 moves FPSC to one canonical fpsc/fps runtime, adds ABI 1300 safety, VS2022 one-click build/self-test and EXE deployment. Level Editor 12/12 is complete, startup black-screen/flicker paths are repaired and F1 profiling is lighter.

  • FPSC uses CPU capability detection, AVX2 runtime dispatch and a safe Python fallback when the DLL is missing or incompatible.
  • Level Editor final integration passed 75/75 checks; Test Game Phase 5 passed 31/31 with earlier 60 FPS optimization phases preserved.
R11M.4 CURRENT BUILD
Latest verified engine upgradeNATIVE LIGHTING + FULL RUNTIME PARITY

R11M.4 — Native HDR lighting, deterministic exports and complete turret parity

This release combines the complete R11A–R11L native lighting line with the R11M.4 runtime repair. The engine now uses one protected rendering and gameplay contract across Level Editor, Test Game, Windows EXE, EXE Developer, HTML5 and HTML5 Developer. The goal is not only better graphics: it is to make the same project behave, look and simulate the same way in every place where the creator tests or publishes it.

1. What the native lighting pipeline actually does

  • Twenty-one compiled Windows x64 lighting DLLs split the renderer into focused modules: GPU capability checks, G-buffer creation, scene submission, HDR light accumulation, tiled culling, PBR materials, SDF shadows, temporal stabilization, bloom, color grading, volumetric fog and performance diagnostics. This modular design keeps heavy native work outside the Python frame loop while preserving protected Python/OpenGL fallback paths.
  • The renderer works in linear HDR space, so lights can carry energy above 1.0 before tone mapping. Materials respond through physically based rules instead of a simple brightness overlay, while shadows and post-processing are cached, budgeted and allowed to fall back independently if one optional pass fails.

2. Runtime parity and turret behavior

  • R11M.4 moves all five turret families onto a deterministic HTML scheduler. Ice can chill and then freeze; Gum reduces speed, jump and dash freedom while applying a tether pull; Gas stacks duration and changes controls on a fixed schedule; Fire creates a terrain-aware stream with burn and heat; Corrosive Acid fires a three-shot burst and progressively cuts small cells from damageable terrain.
  • Acid erosion is no longer only a visual effect. The runtime maintains a polygon-aware terrain mask, rebuilds collision after material is removed, stores the erosion mask for later frames and spreads acid pools along reachable surfaces. This makes the same acid hole exist in gameplay, collision and rendering instead of appearing only on screen.
  • The HTML presentation was also cleaned: the unintended center health bar, browser-only grid/vignette/letterbox glow and duplicate WebGL post-processing were removed. Camera shake is off unless a project explicitly enables it, and the shake offset is calculated once per frame so jumping does not create a different browser-only view.

3. Codebase scale and verification

  • The package contains 392 Python files with 84,021 physical lines and 26 Rust source files with 6,989 physical lines. The main source languages together contain 97,382 physical lines. DLLs are compiled binaries, so they are reported as 21 deployment lighting modules plus the separate performance core rather than as “lines of DLL code.”
  • Verification covers both source structure and runtime behavior: R11M.4 turret parity passed 34/34 checks, the active-level repair passed 9/9, the R11L pipeline passed its native build and compatibility suites, and headless Chromium completed the HTML runtime without JavaScript or startup errors. These checks confirm the shipped logic, while long-duration testing on a broad real-hardware matrix remains a roadmap task.
Publicación
August 2, 2026COMPLETED

Exportación Release y Developer

Las versiones EXE, HTML5 Release y HTML5 Developer comparten el snapshot canónico del proyecto y el preflight de iWatch.

Versión Developer totalmente jugableDiagnósticos F1 y overlays del editorPaquete de código editable verificadoCarpetas transaccionales y salida ZIP
Sistemas de juego
August 2, 2026COMPLETED

Cinco familias modulares de torretas

Cryo Ice, Elastic Gum, Neuro Gas, Corrosive Acid y Fluid Flame usan módulos, avisos, proyectiles y efectos de estado independientes.

Acumulación de frío y congelaciónRalentización elástica y retrocesoGas expansivo y redistribución de controlesErosión de terreno y llama fluida
Herramientas del mundo
August 2, 2026COMPLETED

AnyTerrain + Paint Pro

La creación de terreno y la pintura industrial comparten un contrato de runtime agrupado, editable y exportable.

Formas libres, pendientes, curvas y buclesPlataformas móviles, giratorias y splineGrupos de pincel conectados con deshacer/rehacerDeformación, reparación y perfilado en runtime
Sistemas nativos R4–R8
August 2, 2026COMPLETED

Sombras, materiales, Post FX, entorno y paralaje

Las sombras SDF avanzadas, la respuesta de materiales, el postprocesado, la simulación ambiental y el paralaje consciente de la profundidad se organizan como módulos nativos aislados.

Atlas avanzado de sombras SDFRutas DLL de Material y Post FXMódulos de entorno y paralajeFallbacks protegidos independientes
Capa de exportación R9
August 2, 2026COMPLETED

Despliegue transaccional de iluminación nativa

El Editor, Test Game y EXE comparten un manifiesto lightdll verificado, comprobaciones SHA-256, rechazo de pilas parciales y despliegue transaccional.

Contrato de despliegue R9 de ocho módulosVerificación hash en runtimeFallback seguro de Python cuando no existe una pila DLLMismo contrato de carga en Editor, Test Game y EXE
R10 versión actual
August 2, 2026COMPLETED

Industrial Rust Build Fix 2 + validación completa

La pila de iluminación nativa de nueve módulos incorpora comprobaciones ABI compartidas más sólidas, un preflight completo del espacio Cargo y un módulo dedicado a validar el rendimiento y el resultado visual.

ABI 1.9 y nueve módulos DLL protegidosP50/P95/P99, 1% low real y detección de tironesSuite determinista de validación con cuatro escenas35/35 comprobaciones R10 de código e integración superadas
06 / Animated Road Goals

The original roadmap stays. New goals are inserted first.

Roadmap updates use the same JSON center. Progress, status, target and translated descriptions are stored as structured data, so the file stays small and the theme creates the animated card safely.

PlannedNative frame scheduling integration

Connect the job runtime to the live frame pipeline

Next work will move real frame-critical systems onto STEP26 jobs: culling, particles, terrain, physics and draw preparation. The target is persistent task scheduling, dependency-safe execution, profiler-guided worker scaling and real-hardware regression tests.

  • Keep renderer/API ownership on the main thread while independent CPU workloads execute safely in workers.
  • Add dependency-aware frame tasks, hardware worker-count tuning and build-to-build performance certification before enabling wider automatic parallelism.
25%
PlannedFPSC Phase 2–7

Move more frame-critical work into persistent native C++

Next phases add persistent C++ scene buffers, native culling/transform and collision, multi-core jobs, particle/projectile pools and zero-copy render buffers. Final hardware auto-tuning will choose safe backends and reject regressions measured on real Windows/Kivy hardware.

  • Keep Kivy/OpenGL ownership on the main thread while independent CPU work moves to native worker jobs.
  • Add build-to-build regression certification and real-hardware FPS measurements before enabling automatic tuning.
20%
In progressProduction certification

Real-Hardware Matrix, Long-Session Stability and Final WASM / Cross-Export Release Lock

R11L and R11M.4 establish the compiled 21-DLL native stack and deterministic runtime contract. The next production milestone is not another cosmetic effect: it is a repeatable certification matrix proving that the same active level, camera, physics, turrets, lighting, shadows, bloom, volumetrics and post-processing remain stable on target hardware and in every shipping runtime.

  • Target hardware certification — Run the full R11L suite on representative Intel, AMD and NVIDIA GPUs. Record real GPU timers, sustained 60 FPS, P95/P99, 1% low, VRAM use, resize/device-loss behavior and quality transitions for low, balanced, high and cinematic profiles.
  • Long-session resource stability — Certify repeated Test Game starts, connected-level transitions, editor resizing, scene reloads and export launches over long sessions. The pass criteria are no growing render-target pool, no shader/resource leak, no unbounded temporal history and no recurring stutter from certification work.
  • WASM and browser matrix — Build and certify the R11M WASM physics path and WebGL2 compositor in current Chromium, Firefox and WebKit-family browsers. Verify sharp full-resolution output, Canvas2D/JavaScript fallback, mobile controls, all turret families, acid holes, screen-shake opt-in and zero browser/runtime errors.
  • Cross-export golden release lock — Automate one release matrix that opens the same project in Editor, Test Game, EXE, EXE Developer, HTML5 and HTML5 Developer, then compares contract signatures, active level/spawn, camera, deterministic physics snapshots, object counts, turret schedules, terrain erosion masks and render diagnostics before publishing.
  • Future native backend expansion — Keep ABI 1.9 additive while preparing SSBO/compute scheduling, indirect submission, frame capture, telemetry streaming and optional Vulkan/D3D12 backends without removing OpenGL, Python or Canvas fallbacks.
85%
ResearchObjetivo comunitario

Beta para creadores y documentación

Preparar introducción, tutoriales, informes de compatibilidad y un flujo sencillo para creadores de 5 a 99 años.

8%
In progressEjecutar BUILD_LIGHT_R10_WINDOWS.bat

Certificación nativa R10 para Windows

Compilar, instalar, cargar, verificar por hash y certificar las nueve DLL Rust reales en Windows mediante el pipeline protegido de 25 etapas.

82%
In progressDiagnósticos para creadores

Informes de validación en vivo de 600 fotogramas

Mostrar P50, P95, P99, 1% low, tirones, parpadeo visual y estabilidad de sombras en un informe claro para creadores.

70%
PlannedFlujo de juego

Autoría de torretas y biblioteca de presets

Ampliar las cinco familias de torretas con presets reutilizables, vistas previas de animación, perfiles de equilibrio y presupuestos de efectos seguros para exportar.

38%
PlannedPresentación pública

Cinco juegos de demostración pulidos

Demostrar terreno, iluminación, movimiento, torretas, multijugador y exportación mediante ejemplos jugables completos.

12%
07 / Original theme + safe updater

One JSON package. Three permanent update channels.

For every new engine ZIP, one compact JSON package can update What’s New, Roadmap and the animated Code Metrics category. WordPress validates plain text and numbers, rejects executable content and preserves the permanent website. Legacy HTML upload remains available only for older update files.

NEW ENGINE ZIPCOMPARE BUILDCOMPACT JSON3 CHANNELSVALIDATE DATAWEBSITE UPDATED
08 / Protection architecture

Performance without sacrificing the whole render stack.

Newer systems are designed as protected passes. A failed effect should degrade one subsystem instead of removing the entire scene.

STABLE RENDERERALWAYS AVAILABLE
LightingBloomLUTFog
ShadowsSDFAssetsWorkers

ComposerPASS

Post stackPASS

AnyTerrainPASS

Native workerFALLBACK READY

Export preflightPASS

09 / The reason behind the engine

A game engine can create more than games.

The project vision is to keep game creation approachable for children, adults and older learners, while directing a meaningful share of future engine income toward charity and using the remaining share to sustain development, support and operating costs.

01Accessible creationSimple tools before unnecessary complexity.
02Learning through playBuild, test, understand and improve.
03Give while growingSuccess should help people beyond the software.
0% charity vision
Charity vision50%
Development + costs50%
This is a project vision statement and can be edited in the WordPress Customizer.
10 / Community road goal

Build toward 10,000 creators.

A long-term community goal for people who want to learn, experiment, publish small games and support a charity-first development story.

0creator goal