From 680949c373fa752988ce65318e07dde7b2b33c6f Mon Sep 17 00:00:00 2001 From: Danylo Yenikeiev Date: Tue, 28 Jul 2026 15:41:29 +0700 Subject: [PATCH 01/11] Add Kova preview link --- _tabs/projects.md | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/_tabs/projects.md b/_tabs/projects.md index 4300510..01a4d02 100644 --- a/_tabs/projects.md +++ b/_tabs/projects.md @@ -5,19 +5,17 @@ order: 4 A compact overview of what I'm building and the public work that best represents my current engineering focus. -## Modular Rust game engine +## Kova Engine -My main project is a **modular, general-purpose game engine built from scratch in Rust**. +**[Open the Kova Engine technical preview](/projects/kova/)** -It includes custom runtime and ECS architecture, rendering, assets and content, input, scenes, physics, plugins, task systems, voxel capabilities, tooling, testing, and backend-neutral public APIs. +Kova is my modular, general-purpose Rust game engine foundation. The technical preview documents the current public-style Camera Orbit, Basic 3D, and Basic 2D examples, engine-user API shape, architecture boundaries, validation approach, capability status, and explicit pre-alpha limitations. -The architecture is deliberately layered: high-level engine and gameplay code should not depend directly on backend-specific graphics or windowing handles, and extension points are designed to work for first-party and third-party plugins through the same public interfaces. - -The repository is currently private while the engine is being prepared for public release. +The repository is currently private while the engine is being prepared for a public-source pre-alpha release. ## Freven -**Freven** is a voxel game built on top of my engine and used as a real downstream validation project. +**Freven** is a voxel game built on top of Kova and used as a real downstream validation project. Current work exercises voxel world and chunk management, rendering and collision updates, interaction, world streaming, diagnostics, frame-time performance, and the boundary between reusable engine capabilities and game-specific behavior. From 98f9c6920022e4fb619e9488dd63bbf518d8166d Mon Sep 17 00:00:00 2001 From: Danylo Yenikeiev Date: Tue, 28 Jul 2026 15:42:55 +0700 Subject: [PATCH 02/11] Add native Kova technical preview page --- projects/kova.md | 469 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 469 insertions(+) create mode 100644 projects/kova.md diff --git a/projects/kova.md b/projects/kova.md new file mode 100644 index 0000000..f31d4ad --- /dev/null +++ b/projects/kova.md @@ -0,0 +1,469 @@ +--- +layout: page +title: Kova Engine +description: A technical preview of Kova, a modular general-purpose Rust game engine foundation with public 2D and 3D authoring APIs, explicit backend boundaries, and runnable validation examples. +permalink: /projects/kova/ +toc: true +image: + path: /assets/img/kova/kova-social-preview.svg + alt: Kova Engine technical preview +--- + +> **Rust** | **Private development repository** | **Preparing for public-source pre-alpha** +{: .prompt-info } + +## A modular, general-purpose game engine foundation written in Rust + +Kova explores a library-first engine architecture with public 2D and 3D authoring APIs, explicit plugin and backend boundaries, and validation through real runnable examples. + +The engine is under active private development. Its current milestone proves the core public application, scene, rendering, input, and transform paths without requiring game code to manage WGPU, winit, or the renderer lifecycle directly. + +[Explore the demos](#camera-orbit) | [View the architecture](#architecture) | [Discuss engine or tooling work](#contact) + +![Illustrated placeholder for the Kova Camera Orbit example](/assets/img/kova/kova-camera-orbit-placeholder.svg) +_Illustrated placeholder. Replace this image with the real Camera Orbit video poster and use the WebM/MP4 recording in the same position._ + +## At a glance + +| | | +|---|---| +| **Runnable 2D and 3D paths** | Public engine APIs are exercised through real desktop examples rather than architecture documents alone. | +| **Backend-hidden user API** | Ordinary example code does not manage WGPU resources, winit events, or manual render lifecycle stages. | +| **Validation-driven development** | Visual examples are paired with deterministic or backend-free smoke paths where practical. | +| **Public release preparation** | The private repository is being prepared for an explicitly unstable public-source pre-alpha release. | + +## What Kova is + +Kova is a general-purpose engine foundation rather than a game-specific framework or renderer experiment. + +Its public surface is being designed so that an external project can construct an application, compose plugins, author scenes, create assets, respond to input, and run through a normal desktop path without reaching into backend implementation details. + +The current codebase includes engine foundation, ECS and application layers, public scene and transform authoring, 2D and 3D rendering paths, input and camera APIs, assets, materials, meshes, diagnostics, desktop runtime composition, and optional voxel extension work. + +Kova remains pre-alpha. The current examples prove selected vertical paths; they do not yet claim that the engine can ship a complete production game. + +### Current status + +- M2 public API validation milestone completed +- Runnable Camera Orbit, Basic 3D, and Basic 2D examples +- Public-source pre-alpha release gate in progress +- Editor pre-alpha remains future work +- APIs may change before public release + +## Demos + +### Camera Orbit + +A small interactive 3D example built entirely through public Kova app, desktop, input, scene, mesh, material, light, camera, and transform APIs. + +Mouse input updates the camera's local transform while Kova's normal transform propagation derives the global state before extraction and rendering. + +![Illustrated placeholder for the Camera Orbit demo](/assets/img/kova/kova-camera-orbit-placeholder.svg) +_Camera orbit driven through Kova's public app, input, camera, and transform APIs. Replace this placeholder with the final recording._ + +#### Controls + +- Move the mouse to orbit around the scene +- Press `Escape` to release the cursor +- Click the left mouse button to capture it again +- Vertical rotation is clamped to prevent inversion + +#### What it proves + +- public `KovaApp` construction +- public desktop plugin composition +- ordinary `Startup` and `Update` systems +- keyboard, mouse button, and mouse motion resources +- camera authoring through public components +- local and global transform propagation +- lit materials and point lighting +- cursor capture through a public window-facing contract +- no direct WGPU, winit, or manual renderer lifecycle usage + +#### Application and system composition + +```rust +use kova_desktop::prelude::*; + +let mut app = KovaApp::new(); + +app.add_plugins( + KovaDesktopPlugins::new() + .with_window_title(WindowTitle::new("Kova Camera Orbit")) + .with_window_size(WindowSize::new(960, 540)), +)?; + +app.world_mut() + .insert_resource(CameraOrbitSettings::default()); + +app.world_mut() + .insert_resource(CameraOrbitState::from_settings( + CameraOrbitSettings::default(), + )); + +app.add_systems(Startup, setup_camera_orbit_scene); +app.add_systems(Update, update_camera_orbit); + +app.run()?; +``` + +_Representative excerpt from the current private example. Error handling and cursor-state setup are shortened here for readability._ + +#### Public scene, mesh, material, and light authoring + +```rust +let mut scene = SceneList::new(); + +let cube_mesh = scene.asset(asset_value( + MeshAsset::position_normal_from_cuboid( + MeshId::new("example.mesh.cube"), + MeshLabel::new("Cube"), + Cuboid::new(1.0, 1.0, 1.0), + )?, +)); + +let cube_material = scene.asset(asset_value( + MaterialDescriptor::standard( + MaterialId::new("example.material.cube"), + MaterialLabel::new("Blue cube"), + StandardMaterial::lit( + Color::srgb_rgb(124.0 / 255.0, 144.0 / 255.0, 1.0), + ) + .with_roughness(0.55), + ), +)); + +scene.spawn(( + PointLight3d::new(LightColor::WHITE, 1_000_000.0, 20.0) + .with_radius(0.25), + Transform3d::from_xyz(4.0, 8.0, 4.0), + GlobalTransform3d::IDENTITY, +)); + +scene.mesh_draw_3d_local_at( + cube_mesh, + cube_material, + Transform3d::from_xyz(0.0, 0.51, 0.0), +); + +scene.apply(world)?; +``` + +The public example creates its scene without obtaining GPU buffers, render passes, swapchain objects, or backend resource handles. + +#### Camera transform from public input state + +```rust +fn camera_transform( + yaw: AngleRadians, + pitch: AngleRadians, + target: Vec3, + distance: f32, +) -> Transform3d { + let orientation = Transform3d::from_euler( + EulerRot::YXZ, + yaw, + pitch, + AngleRadians::ZERO, + ); + + let position = target - orientation.forward() * distance; + + Transform3d::from_translation(position) + .looking_at(target, Vec3::Y) +} +``` + +The full example validates finite input, wraps yaw, clamps pitch, handles cursor capture, and updates exactly one marked camera. + +> **Current ergonomics note:** The current typed system adapter does not yet combine every resource and mutable query shape required by this example. Camera Orbit therefore uses Kova's public raw `World` system form for the update system. It still does not access backend or renderer internals. +{: .prompt-warning } + +### Basic 3D + +The Basic 3D example is a minimal static desktop scene authored through the same public APIs intended for external engine users. + +It creates generated meshes, lit standard materials, ambient lighting, a photometric point light, a perspective camera, and local transforms before running through Kova's public desktop path. + +![Illustrated placeholder for the Kova Basic 3D example](/assets/img/kova/kova-basic-3d-placeholder.svg) +_A blue cube on a white circular base rendered by the Kova Basic 3D example. Replace with `kova-basic-3d.webp`._ + +```rust +let mut app = KovaApp::new(); + +app.add_plugins( + KovaDesktopPlugins::new() + .with_window_title(WindowTitle::new("Kova Basic 3D")) + .with_window_size(WindowSize::new(960, 540)), +)?; + +app.add_systems(Startup, setup_basic_3d_scene); +app.run()?; +``` + +```rust +let camera_transform = + Transform3d::from_xyz(-2.5, 4.5, 9.0) + .looking_at(Vec3::ZERO, Vec3::Y); + +scene.camera_3d_local(camera, camera_transform); +``` + +#### What this proves + +- one normal public desktop runner path +- generated meshes with position and normal data +- public lit material descriptors +- public camera authoring +- local transform placement +- normal local-to-global propagation +- a lit forward rendering path +- no manual prepare, queue, render, or present calls + +> **Current limitation:** This example does not claim a production renderer. Point-light shadows are disabled in this path, and automatic exposure and tonemapping are not yet part of the example's fixed SDR calibration. +{: .prompt-info } + +### Basic 2D + +The Basic 2D example validates a separate 2D authoring path rather than presenting 2D objects as dummy 3D geometry. + +A translated and rotated root owns two child draws. Explicit `DrawOrder2d` values prove that visible ordering is independent of entity creation order. + +![Illustrated placeholder for the Kova Basic 2D example](/assets/img/kova/kova-basic-2d-placeholder.svg) +_A coral rectangle and blue hexagon rendered through Kova's public 2D APIs. Replace with `kova-basic-2d.webp`._ + +```rust +world.spawn(KovaDesktopScene2d::default_camera())?; + +let root = world.spawn(( + Transform2d::from_translation_xy(-0.65, -0.20) + .with_rotation(AngleRadians::new(0.12)), + GlobalTransform2d::IDENTITY, +))?; + +let front = world.spawn(( + Mesh2d::new(front_mesh), + MeshMaterial2d::new(front_material), + DrawOrder2d::new(10), + Transform2d::from_translation_xy(0.75, 0.15) + .with_rotation(AngleRadians::new(-0.22)), + GlobalTransform2d::IDENTITY, +))?; + +world.insert_component(front, Parent::new(root))?; +``` + +#### What this proves + +- an orthographic public 2D camera +- generated rectangle and regular-polygon meshes +- typed sRGB colors +- unlit material descriptors +- explicit 2D draw ordering +- parent-child transform propagation +- same-frame world transform resolution +- a dedicated 2D path without transform-Z ordering hacks + +> **Current limitation:** The example does not yet claim sprites, textures, tilemaps, text, runtime UI, animation, physics, batching, alpha blending, or a complete 2D game workflow. +{: .prompt-info } + +## Architecture + +Kova is divided by ownership and dependency boundaries rather than by arbitrary feature folders. + +User-facing domain APIs remain separate from WGPU, winit, and platform-specific resource ownership. Runtime and backend crates may use those dependencies, but gameplay-facing code should not need to understand them. + +![Kova architecture layers from external project to backend integrations](/assets/img/kova/kova-architecture.svg) + +### Backend-hidden gameplay APIs + +Gameplay-facing and domain APIs should not expose WGPU objects, winit events, backend resource handles, or manual rendering lifecycle operations. + +### Public extension symmetry + +First-party plugins should use the same public extension mechanisms intended for future third-party plugins. Kova should not rely on privileged internal plugin paths. + +### Product-neutral engine core + +Kova remains independent from the Freven game, platform, content, and publishing policy. Freven acts as a downstream pressure test rather than defining the engine's public identity. + +### Library-first, editor-aware + +The runtime should remain usable without an editor. Editor architecture is being planned early, but it is not allowed to become a hidden requirement for building or running a project. + +## What engine-user code should look like + +Kova's high-level examples are intentionally written to resemble external user code. + +A project should be able to: + +1. construct a `KovaApp` +2. compose public plugins +3. register startup and update systems +4. author assets and scene entities +5. respond to public input resources +6. run through a public desktop path + +It should not need to: + +- allocate GPU buffers manually +- own a surface or swapchain +- call render extraction stages +- invoke prepare, queue, or present functions +- process raw winit events +- import product-specific Freven types + +```rust +let mut app = KovaApp::new(); + +app.add_plugins(KovaDesktopPlugins::new())?; +app.add_systems(Startup, setup_scene); +app.add_systems(Update, update_gameplay); + +app.run()?; +``` + +_The exact public API remains pre-alpha and may change, but the architectural boundary is deliberate._ + +## Current capability status + +| Area | Current evidence | Status | +|---|---|---| +| Application and plugin composition | `KovaApp`, schedules, and desktop plugin groups used by runnable examples | **Working foundation** | +| ECS and resource model | Public world, components, resources, systems, and hierarchy paths | **Working foundation** | +| Desktop runner | Real WGPU/winit desktop path behind public composition APIs | **Working foundation** | +| 3D scene authoring | Basic 3D and Camera Orbit examples | **Validated example** | +| 2D scene authoring | Basic 2D example with hierarchy and draw ordering | **Validated example** | +| Input and camera control | Mouse, keyboard, cursor capture, and orbit camera | **Validated example** | +| Meshes, materials, and lighting | Generated geometry, lit/unlit materials, ambient and point light | **Working vertical path** | +| Transform hierarchy | Public local/global 2D and 3D propagation | **Validated example** | +| Asset identity and catalog work | Logical identities, production catalog, and deterministic variant resolution | **Active development** | +| External project use | Clean external-consumer validation path | **Active validation** | +| Editor | Architecture and authoring tools planned | **Not yet a release claim** | +| Public source release | Licensing, security, CI, docs, and release audit gate | **In preparation** | + +## Built through validation, not diagrams alone + +Kova's architecture is pressure-tested with small external-style applications and focused validation packages. + +The visual examples are kept outside engine crates and consume public interfaces. When an example discovers missing reusable functionality, that gap is fixed or tracked in the owning engine layer rather than hidden inside example-specific code. + +Where practical, the same authored paths are paired with backend-free or bounded smoke validation so CI can check application, scene, and frame behavior without requiring an interactive desktop. + +```console +cargo +stable run --locked -p kova_example_camera_orbit +cargo +stable run --locked -p kova_example_basic_3d +cargo +stable run --locked -p kova_example_basic_2d +``` + +> The repository is still private. These commands document the current internal examples and will become usable from a clean public checkout after the public-source release gate is completed. +{: .prompt-info } + +### Validation principles + +- examples use intended public facades +- engine crates do not depend on example packages +- backend-free validation is preferred when a visible window is unnecessary +- backend-specific types are checked at layer boundaries +- API friction discovered by examples is documented rather than concealed +- clean external-consumer behavior is treated as a release gate + +## Current work + +With the M2 public API validation milestone complete, current work is split between public-source release preparation, ordinary engine ergonomics, and the production content path. + +Recent work focuses on explicit logical asset identity, immutable production catalogs, deterministic asset variant resolution, and reproducible external-consumer validation. + +### Production content architecture + +Establishing stable logical asset identity, catalog ownership, and deterministic resolution before expanding the authoring and import workflow. + +### External consumer path + +Ensuring that a project outside the engine workspace can use documented public interfaces without relying on private repository structure or internal hooks. + +### Public-source pre-alpha gate + +Preparing licensing and provenance, security reporting, public CI, documentation, contribution workflows, distribution rules, launch examples, and a final release audit. + +## Pre-alpha means explicit limitations + +### Current limitations + +- The repository remains private. +- Public APIs are unstable and may change. +- Kova does not yet claim that an external developer can ship a complete game. +- The editor is not production-ready and should not be presented as an existing finished product. +- Current examples prove selected vertical paths rather than complete 2D or 3D production workflows. +- Some system-parameter ergonomics still require lower-level public `World` access. +- The current Basic 3D path does not prove production shadows, HDR, automatic exposure, or tonemapping. +- Packaging and distribution remain part of later readiness work. + +### Active directions + +- production content loading and external project workflows +- ordinary engine-user API ergonomics +- editor pre-alpha architecture and tools +- broader renderer and material readiness +- audio, animation, runtime UI, and gameplay-support systems +- networking and server-authoritative architecture +- scripting, modding, and data-driven authoring +- optional voxel extensions as an extensibility pressure test +- structured interfaces for future tooling and automation + +> Structured, inspectable engine operations may later support external tools and coding agents, but agent-facing integration is currently a research direction rather than a released feature. +{: .prompt-info } + +## Engine foundation and downstream pressure test + +Kova and Freven are deliberately separated. + +Kova owns the reusable engine, public APIs, runtime composition, renderer boundaries, examples, and validation infrastructure. + +Freven is a downstream game and product that can pressure-test Kova through the same public interfaces intended for other projects. Game-specific content, account systems, launcher behavior, publishing, moderation, and product policy remain outside the Kova engine repository. + +This separation helps prevent one game's requirements from becoming accidental engine architecture. + +## Related engineering work + +### RodinBridge / Godot compatibility and lifecycle work + +A private compatibility and reliability update for a public Godot integration, including plugin lifecycle, subprocess cleanup, WebSocket buffering and malformed-input handling, reconnect and shutdown behavior, local authorization boundaries, and reproducible A/B validation. + +### Backend and integration work + +Commercial and independent work involving APIs, webhooks, tracking systems, backend services, Docker/Linux, and multi-system debugging. + +## Built by Danylo Yenikeiev + +I am a software engineer based in Poland, working across Rust, Python, TypeScript, backend systems, networking, Linux, Docker, and developer tooling. + +Kova is my long-term engine architecture project. Building it requires work across public API design, ECS and application lifecycle, rendering boundaries, scene and transform systems, assets, input, validation infrastructure, and downstream project compatibility. + +I am open to contract and long-term work involving: + +- game-engine and runtime development +- editor and developer tooling +- engine, DCC, and SDK integrations +- plugins and extension infrastructure +- networking and local services +- lifecycle and reliability work +- automation and agent-accessible tooling +- difficult cross-system debugging + +## Contact + +I am interested in technically demanding contract and long-term work around engines, editor tooling, plugins, SDKs, runtime infrastructure, and developer automation. + +The Kova repository remains private during active development, but I can provide a focused private code walkthrough or discuss the architecture for a relevant technical opportunity. + +- **Email:** [ogyrec.404@proton.me](mailto:ogyrec.404@proton.me) +- **GitHub:** [@ogyrec-o](https://github.com/ogyrec-o) +- **LinkedIn:** [Danylo Yenikeiev](https://www.linkedin.com/in/danylo-yenikeiev/) +- **About:** [About me](/about/) + +Based in Poland. Europe/Warsaw. Available for remote contract work. + +--- + +Kova is an active technical codename and a private pre-alpha project. Features, APIs, naming, and release plans may change. From b4b434330b0b801c54f6ee5e53e65d90f90b7d73 Mon Sep 17 00:00:00 2001 From: Danylo Yenikeiev Date: Tue, 28 Jul 2026 15:43:10 +0700 Subject: [PATCH 03/11] Add Camera Orbit placeholder --- assets/img/kova/kova-camera-orbit-placeholder.svg | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 assets/img/kova/kova-camera-orbit-placeholder.svg diff --git a/assets/img/kova/kova-camera-orbit-placeholder.svg b/assets/img/kova/kova-camera-orbit-placeholder.svg new file mode 100644 index 0000000..5bcf361 --- /dev/null +++ b/assets/img/kova/kova-camera-orbit-placeholder.svg @@ -0,0 +1,13 @@ + + Kova Camera Orbit placeholder + A minimal illustrated placeholder showing a blue cube on a white circular base. + + + + + + + + Kova Camera Orbit + Illustrated placeholder for the real engine capture + From 96d22f0174f75b7317b6f62b62c8dec8da352575 Mon Sep 17 00:00:00 2001 From: Danylo Yenikeiev Date: Tue, 28 Jul 2026 15:43:21 +0700 Subject: [PATCH 04/11] Add Basic 3D placeholder --- assets/img/kova/kova-basic-3d-placeholder.svg | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 assets/img/kova/kova-basic-3d-placeholder.svg diff --git a/assets/img/kova/kova-basic-3d-placeholder.svg b/assets/img/kova/kova-basic-3d-placeholder.svg new file mode 100644 index 0000000..9e79c3f --- /dev/null +++ b/assets/img/kova/kova-basic-3d-placeholder.svg @@ -0,0 +1,11 @@ + + Kova Basic 3D placeholder + A minimal illustrated placeholder showing a blue cube on a white circular base. + + + + + + Kova Basic 3D + Illustrated placeholder for the real engine screenshot + From 44496c08ecb022fa710f97b89c7b094428ce760a Mon Sep 17 00:00:00 2001 From: Danylo Yenikeiev Date: Tue, 28 Jul 2026 15:43:35 +0700 Subject: [PATCH 05/11] Add Basic 2D placeholder --- assets/img/kova/kova-basic-2d-placeholder.svg | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 assets/img/kova/kova-basic-2d-placeholder.svg diff --git a/assets/img/kova/kova-basic-2d-placeholder.svg b/assets/img/kova/kova-basic-2d-placeholder.svg new file mode 100644 index 0000000..ef8716e --- /dev/null +++ b/assets/img/kova/kova-basic-2d-placeholder.svg @@ -0,0 +1,11 @@ + + Kova Basic 2D placeholder + A minimal illustrated placeholder showing a coral rectangle overlapped by a blue hexagon. + + + + + + Kova Basic 2D + Illustrated placeholder for the real engine screenshot + From cf25bc220393d7e18c3749b9ebbe3b33896a4689 Mon Sep 17 00:00:00 2001 From: Danylo Yenikeiev Date: Tue, 28 Jul 2026 15:44:00 +0700 Subject: [PATCH 06/11] Add Kova architecture diagram --- assets/img/kova/kova-architecture.svg | 42 +++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 assets/img/kova/kova-architecture.svg diff --git a/assets/img/kova/kova-architecture.svg b/assets/img/kova/kova-architecture.svg new file mode 100644 index 0000000..1d3949e --- /dev/null +++ b/assets/img/kova/kova-architecture.svg @@ -0,0 +1,42 @@ + + Kova architecture layers + A vertical diagram from an external project through public APIs, foundation, domains, plugins, runtime, and backends. + + + + + + + + External game or validation project + + + Public facade and desktop composition + kova_desktop, KovaApp, plugin groups + + + Foundation + core, ECS, app, math, tasks, fs + + + Backend-neutral domains + assets, scene, transform, input, camera + mesh, material, physics, diagnostics + + + Plugins and render pipeline boundaries + public contracts, extraction, planning + + + Runtime and runners + desktop composition, window/render loop + + + WGPU, winit, platform integration + From be1718795df319f5f044b2011fecdca08253fce8 Mon Sep 17 00:00:00 2001 From: Danylo Yenikeiev Date: Tue, 28 Jul 2026 15:44:13 +0700 Subject: [PATCH 07/11] Add Kova social preview --- assets/img/kova/kova-social-preview.svg | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 assets/img/kova/kova-social-preview.svg diff --git a/assets/img/kova/kova-social-preview.svg b/assets/img/kova/kova-social-preview.svg new file mode 100644 index 0000000..ef7a118 --- /dev/null +++ b/assets/img/kova/kova-social-preview.svg @@ -0,0 +1,13 @@ + + Kova Engine technical preview + Kova title with a minimal cube illustration and modular Rust game engine foundation subtitle. + + + + + + + Kova + Modular Rust game engine foundation + Technical preview + From c44cf3c32d381d3c716023464ba709b9c1973af7 Mon Sep 17 00:00:00 2001 From: Danylo Yenikeiev Date: Tue, 28 Jul 2026 16:10:37 +0700 Subject: [PATCH 08/11] Refine Kova page structure and architecture section --- projects/kova.md | 151 ++++++++++++++++++++++++----------------------- 1 file changed, 76 insertions(+), 75 deletions(-) diff --git a/projects/kova.md b/projects/kova.md index f31d4ad..e2b247e 100644 --- a/projects/kova.md +++ b/projects/kova.md @@ -9,57 +9,44 @@ image: alt: Kova Engine technical preview --- -> **Rust** | **Private development repository** | **Preparing for public-source pre-alpha** -{: .prompt-info } +Kova is a modular, general-purpose game engine foundation written in Rust. It is being built as a reusable library rather than a game-specific framework or a renderer demo. -## A modular, general-purpose game engine foundation written in Rust +The repository is private while I prepare it for a public-source pre-alpha release. The current milestone validates the public application, plugin, scene, input, transform, 2D, and 3D paths through runnable desktop examples. -Kova explores a library-first engine architecture with public 2D and 3D authoring APIs, explicit plugin and backend boundaries, and validation through real runnable examples. +![Illustrated preview of the Kova Camera Orbit example](/assets/img/kova/kova-camera-orbit-placeholder.svg) +_Camera Orbit example. Temporary illustration until the recorded engine capture is added._ -The engine is under active private development. Its current milestone proves the core public application, scene, rendering, input, and transform paths without requiring game code to manage WGPU, winit, or the renderer lifecycle directly. +## Overview -[Explore the demos](#camera-orbit) | [View the architecture](#architecture) | [Discuss engine or tooling work](#contact) +Kova's public surface is designed so that an external project can construct an application, compose plugins, author scenes, create assets, respond to input, and run through a normal desktop path without reaching into backend implementation details. -![Illustrated placeholder for the Kova Camera Orbit example](/assets/img/kova/kova-camera-orbit-placeholder.svg) -_Illustrated placeholder. Replace this image with the real Camera Orbit video poster and use the WebM/MP4 recording in the same position._ +The current codebase includes the engine foundation, ECS and application layers, public scene and transform authoring, 2D and 3D rendering paths, input and camera APIs, assets, materials, meshes, diagnostics, desktop runtime composition, and optional voxel extension work. -## At a glance +### What the current milestone proves -| | | -|---|---| -| **Runnable 2D and 3D paths** | Public engine APIs are exercised through real desktop examples rather than architecture documents alone. | -| **Backend-hidden user API** | Ordinary example code does not manage WGPU resources, winit events, or manual render lifecycle stages. | -| **Validation-driven development** | Visual examples are paired with deterministic or backend-free smoke paths where practical. | -| **Public release preparation** | The private repository is being prepared for an explicitly unstable public-source pre-alpha release. | +- Camera Orbit, Basic 3D, and Basic 2D run through the public desktop path +- ordinary engine-user code does not manage WGPU resources or winit events +- examples live outside engine crates and consume public interfaces +- local and global transforms work across both 2D and 3D paths +- input, camera, meshes, materials, lighting, and scene authoring form usable vertical slices +- the architecture can be validated without treating Freven as part of the engine core -## What Kova is +### Release status -Kova is a general-purpose engine foundation rather than a game-specific framework or renderer experiment. +Kova remains pre-alpha. The M2 public API validation milestone is complete, but APIs may still change before public release. Current work focuses on the production content path, external-consumer validation, release documentation, licensing, security, CI, and distribution rules. -Its public surface is being designed so that an external project can construct an application, compose plugins, author scenes, create assets, respond to input, and run through a normal desktop path without reaching into backend implementation details. - -The current codebase includes engine foundation, ECS and application layers, public scene and transform authoring, 2D and 3D rendering paths, input and camera APIs, assets, materials, meshes, diagnostics, desktop runtime composition, and optional voxel extension work. - -Kova remains pre-alpha. The current examples prove selected vertical paths; they do not yet claim that the engine can ship a complete production game. - -### Current status - -- M2 public API validation milestone completed -- Runnable Camera Orbit, Basic 3D, and Basic 2D examples -- Public-source pre-alpha release gate in progress -- Editor pre-alpha remains future work -- APIs may change before public release +The editor is not yet a release claim, and the current examples prove selected vertical paths rather than a complete production game workflow. ## Demos ### Camera Orbit -A small interactive 3D example built entirely through public Kova app, desktop, input, scene, mesh, material, light, camera, and transform APIs. +Camera Orbit is a small interactive 3D example built entirely through public Kova app, desktop, input, scene, mesh, material, light, camera, and transform APIs. Mouse input updates the camera's local transform while Kova's normal transform propagation derives the global state before extraction and rendering. -![Illustrated placeholder for the Camera Orbit demo](/assets/img/kova/kova-camera-orbit-placeholder.svg) -_Camera orbit driven through Kova's public app, input, camera, and transform APIs. Replace this placeholder with the final recording._ +![Illustrated preview of the Camera Orbit demo](/assets/img/kova/kova-camera-orbit-placeholder.svg) +_Camera orbit driven through Kova's public app, input, camera, and transform APIs._ #### Controls @@ -107,7 +94,7 @@ app.add_systems(Update, update_camera_orbit); app.run()?; ``` -_Representative excerpt from the current private example. Error handling and cursor-state setup are shortened here for readability._ +_Representative excerpt from the current private example. Error handling and cursor-state setup are shortened for readability._ #### Public scene, mesh, material, and light authoring @@ -176,17 +163,16 @@ fn camera_transform( The full example validates finite input, wraps yaw, clamps pitch, handles cursor capture, and updates exactly one marked camera. -> **Current ergonomics note:** The current typed system adapter does not yet combine every resource and mutable query shape required by this example. Camera Orbit therefore uses Kova's public raw `World` system form for the update system. It still does not access backend or renderer internals. -{: .prompt-warning } +**Implementation note.** The current typed system adapter does not yet combine every resource and mutable query shape required by this example. Camera Orbit therefore uses Kova's public raw `World` system form for the update system. It still does not access backend or renderer internals. ### Basic 3D -The Basic 3D example is a minimal static desktop scene authored through the same public APIs intended for external engine users. +Basic 3D is a minimal static desktop scene authored through the same public APIs intended for external engine users. It creates generated meshes, lit standard materials, ambient lighting, a photometric point light, a perspective camera, and local transforms before running through Kova's public desktop path. -![Illustrated placeholder for the Kova Basic 3D example](/assets/img/kova/kova-basic-3d-placeholder.svg) -_A blue cube on a white circular base rendered by the Kova Basic 3D example. Replace with `kova-basic-3d.webp`._ +![Illustrated preview of the Kova Basic 3D example](/assets/img/kova/kova-basic-3d-placeholder.svg) +_A blue cube on a white circular base rendered by the Kova Basic 3D example._ ```rust let mut app = KovaApp::new(); @@ -209,7 +195,7 @@ let camera_transform = scene.camera_3d_local(camera, camera_transform); ``` -#### What this proves +#### What it proves - one normal public desktop runner path - generated meshes with position and normal data @@ -220,17 +206,16 @@ scene.camera_3d_local(camera, camera_transform); - a lit forward rendering path - no manual prepare, queue, render, or present calls -> **Current limitation:** This example does not claim a production renderer. Point-light shadows are disabled in this path, and automatic exposure and tonemapping are not yet part of the example's fixed SDR calibration. -{: .prompt-info } +**Scope note.** This example does not claim a production renderer. Point-light shadows are disabled in this path, and automatic exposure and tonemapping are not yet part of the example's fixed SDR calibration. ### Basic 2D -The Basic 2D example validates a separate 2D authoring path rather than presenting 2D objects as dummy 3D geometry. +Basic 2D validates a separate 2D authoring path rather than presenting 2D objects as dummy 3D geometry. A translated and rotated root owns two child draws. Explicit `DrawOrder2d` values prove that visible ordering is independent of entity creation order. -![Illustrated placeholder for the Kova Basic 2D example](/assets/img/kova/kova-basic-2d-placeholder.svg) -_A coral rectangle and blue hexagon rendered through Kova's public 2D APIs. Replace with `kova-basic-2d.webp`._ +![Illustrated preview of the Kova Basic 2D example](/assets/img/kova/kova-basic-2d-placeholder.svg) +_A coral rectangle and blue hexagon rendered through Kova's public 2D APIs._ ```rust world.spawn(KovaDesktopScene2d::default_camera())?; @@ -253,7 +238,7 @@ let front = world.spawn(( world.insert_component(front, Parent::new(root))?; ``` -#### What this proves +#### What it proves - an orthographic public 2D camera - generated rectangle and regular-polygon meshes @@ -264,34 +249,52 @@ world.insert_component(front, Parent::new(root))?; - same-frame world transform resolution - a dedicated 2D path without transform-Z ordering hacks -> **Current limitation:** The example does not yet claim sprites, textures, tilemaps, text, runtime UI, animation, physics, batching, alpha blending, or a complete 2D game workflow. -{: .prompt-info } +**Scope note.** The example does not yet claim sprites, textures, tilemaps, text, runtime UI, animation, physics, batching, alpha blending, or a complete 2D game workflow. ## Architecture -Kova is divided by ownership and dependency boundaries rather than by arbitrary feature folders. +Kova is organized around ownership and dependency boundaries rather than arbitrary feature folders. User-facing domains stay separate from WGPU, winit, and platform-specific resource ownership. -User-facing domain APIs remain separate from WGPU, winit, and platform-specific resource ownership. Runtime and backend crates may use those dependencies, but gameplay-facing code should not need to understand them. +```text +External project + -> public composition + KovaApp, kova_desktop, plugin groups -![Kova architecture layers from external project to backend integrations](/assets/img/kova/kova-architecture.svg) + -> foundation + core, ECS, app, math, tasks, filesystem -### Backend-hidden gameplay APIs + -> backend-neutral domains + assets, scene, transform, input, camera + mesh, material, physics, diagnostics -Gameplay-facing and domain APIs should not expose WGPU objects, winit events, backend resource handles, or manual rendering lifecycle operations. + -> plugin and render boundaries + public contracts, extraction, render planning -### Public extension symmetry + -> runtime and runners + desktop composition, window and render loop -First-party plugins should use the same public extension mechanisms intended for future third-party plugins. Kova should not rely on privileged internal plugin paths. + -> backend integrations + WGPU, winit, platform-specific code +``` -### Product-neutral engine core +The dependency direction is intentional: backend integrations may depend on public engine domains, but gameplay-facing code should not need backend types in order to create scenes or run an application. -Kova remains independent from the Freven game, platform, content, and publishing policy. Freven acts as a downstream pressure test rather than defining the engine's public identity. +| Boundary | Owns | Must stay hidden from the layer above | +|---|---|---| +| Public composition | Application setup, plugin groups, normal desktop entry points | Backend startup order and renderer lifecycle | +| Foundation | ECS, schedules, math, tasks, filesystem contracts | Product-specific game policy | +| Engine domains | Assets, scenes, transforms, input, cameras, meshes, materials | WGPU and winit handles | +| Runtime and runners | Window loop, extraction, render preparation, presentation | Manual lifecycle calls in gameplay code | +| Backend integrations | WGPU, winit, platform-specific ownership | Direct access from external projects | -### Library-first, editor-aware +### Design rules -The runtime should remain usable without an editor. Editor architecture is being planned early, but it is not allowed to become a hidden requirement for building or running a project. +1. **Backend-hidden gameplay APIs.** Domain APIs should not expose WGPU objects, winit events, backend resource handles, or manual rendering lifecycle operations. +2. **Public extension symmetry.** First-party plugins should use the same public extension mechanisms intended for future third-party plugins. +3. **Product-neutral engine core.** Freven is a downstream validation project, not part of Kova's public identity or dependency graph. +4. **Library-first, editor-aware.** The runtime must remain usable without an editor, even while editor architecture is planned early. -## What engine-user code should look like +## Engine-user code Kova's high-level examples are intentionally written to resemble external user code. @@ -323,9 +326,9 @@ app.add_systems(Update, update_gameplay); app.run()?; ``` -_The exact public API remains pre-alpha and may change, but the architectural boundary is deliberate._ +The exact public API remains pre-alpha and may change, but the boundary itself is deliberate. -## Current capability status +## Capability status | Area | Current evidence | Status | |---|---|---| @@ -342,9 +345,9 @@ _The exact public API remains pre-alpha and may change, but the architectural bo | Editor | Architecture and authoring tools planned | **Not yet a release claim** | | Public source release | Licensing, security, CI, docs, and release audit gate | **In preparation** | -## Built through validation, not diagrams alone +## Validation approach -Kova's architecture is pressure-tested with small external-style applications and focused validation packages. +Kova is pressure-tested with small external-style applications and focused validation packages. The visual examples are kept outside engine crates and consume public interfaces. When an example discovers missing reusable functionality, that gap is fixed or tracked in the owning engine layer rather than hidden inside example-specific code. @@ -356,8 +359,7 @@ cargo +stable run --locked -p kova_example_basic_3d cargo +stable run --locked -p kova_example_basic_2d ``` -> The repository is still private. These commands document the current internal examples and will become usable from a clean public checkout after the public-source release gate is completed. -{: .prompt-info } +The repository is still private. These commands document the current internal examples and will become usable from a clean public checkout after the public-source release gate is completed. ### Validation principles @@ -386,7 +388,7 @@ Ensuring that a project outside the engine workspace can use documented public i Preparing licensing and provenance, security reporting, public CI, documentation, contribution workflows, distribution rules, launch examples, and a final release audit. -## Pre-alpha means explicit limitations +## Limitations and release status ### Current limitations @@ -411,16 +413,15 @@ Preparing licensing and provenance, security reporting, public CI, documentation - optional voxel extensions as an extensibility pressure test - structured interfaces for future tooling and automation -> Structured, inspectable engine operations may later support external tools and coding agents, but agent-facing integration is currently a research direction rather than a released feature. -{: .prompt-info } +Structured, inspectable engine operations may later support external tools and coding agents. Agent-facing integration is currently a research direction rather than a released feature. -## Engine foundation and downstream pressure test +## Kova and Freven Kova and Freven are deliberately separated. Kova owns the reusable engine, public APIs, runtime composition, renderer boundaries, examples, and validation infrastructure. -Freven is a downstream game and product that can pressure-test Kova through the same public interfaces intended for other projects. Game-specific content, account systems, launcher behavior, publishing, moderation, and product policy remain outside the Kova engine repository. +Freven is a downstream game and product that pressure-tests Kova through the same public interfaces intended for other projects. Game-specific content, account systems, launcher behavior, publishing, moderation, and product policy remain outside the Kova engine repository. This separation helps prevent one game's requirements from becoming accidental engine architecture. @@ -434,9 +435,9 @@ A private compatibility and reliability update for a public Godot integration, i Commercial and independent work involving APIs, webhooks, tracking systems, backend services, Docker/Linux, and multi-system debugging. -## Built by Danylo Yenikeiev +## About the developer -I am a software engineer based in Poland, working across Rust, Python, TypeScript, backend systems, networking, Linux, Docker, and developer tooling. +I am Danylo Yenikeiev, a software engineer based in Poland, working across Rust, Python, TypeScript, backend systems, networking, Linux, Docker, and developer tooling. Kova is my long-term engine architecture project. Building it requires work across public API design, ECS and application lifecycle, rendering boundaries, scene and transform systems, assets, input, validation infrastructure, and downstream project compatibility. @@ -462,8 +463,8 @@ The Kova repository remains private during active development, but I can provide - **LinkedIn:** [Danylo Yenikeiev](https://www.linkedin.com/in/danylo-yenikeiev/) - **About:** [About me](/about/) -Based in Poland. Europe/Warsaw. Available for remote contract work. +Based in Poland (Europe/Warsaw) and available for remote contract work. --- -Kova is an active technical codename and a private pre-alpha project. Features, APIs, naming, and release plans may change. +_Kova is an active technical codename and a private pre-alpha project. Features, APIs, naming, and release plans may change._ From aefd59127ef3a999e9df9ffd5cd5d53e1882ed7c Mon Sep 17 00:00:00 2001 From: Danylo Yenikeiev Date: Tue, 28 Jul 2026 16:10:52 +0700 Subject: [PATCH 09/11] Remove custom architecture illustration --- assets/img/kova/kova-architecture.svg | 42 --------------------------- 1 file changed, 42 deletions(-) delete mode 100644 assets/img/kova/kova-architecture.svg diff --git a/assets/img/kova/kova-architecture.svg b/assets/img/kova/kova-architecture.svg deleted file mode 100644 index 1d3949e..0000000 --- a/assets/img/kova/kova-architecture.svg +++ /dev/null @@ -1,42 +0,0 @@ - - Kova architecture layers - A vertical diagram from an external project through public APIs, foundation, domains, plugins, runtime, and backends. - - - - - - - - External game or validation project - - - Public facade and desktop composition - kova_desktop, KovaApp, plugin groups - - - Foundation - core, ECS, app, math, tasks, fs - - - Backend-neutral domains - assets, scene, transform, input, camera - mesh, material, physics, diagnostics - - - Plugins and render pipeline boundaries - public contracts, extraction, planning - - - Runtime and runners - desktop composition, window/render loop - - - WGPU, winit, platform integration - From 157dd588fb965c10dfdc6803adc9b6aa1f5a6582 Mon Sep 17 00:00:00 2001 From: Danylo Yenikeiev Date: Tue, 28 Jul 2026 16:12:40 +0700 Subject: [PATCH 10/11] Keep Kova page revision current From fe1aa8a80f9f5f61f0cddc78a4e88f66b8763c02 Mon Sep 17 00:00:00 2001 From: Danylo Yenikeiev Date: Tue, 28 Jul 2026 16:13:03 +0700 Subject: [PATCH 11/11] Keep Projects tab current