Repository navigation
Revises engine foundations and adds modular consumer facilities - #10
Merged
Merged
Conversation
Rename projects/tools to projects/dependency-checks to reflect the standalone Backward external-library verification executable. Update root CMake selection and layout/planning documentation with the new owner path and purpose. Preserve both moved file contents, the backward-cpp target and its existing test-option selection. Static path, byte-preservation and whitespace checks pass; no builds or tests were run.
Sequence Engine-only, native and full OpenGL acceptance with reusable Release outputs, standalone bootstrap/target reuse and a separate Debug Engine-linked crash consumer. Preserve CLion profiles, limit any later authorized builds to one low-priority job and avoid repeating passed checks without a concrete reason. Record the owner selection of preparation and static checks only for this pass. Configuration, compilation and executable acceptance remain pending an explicit request.
Add a consumer that references no Engine entry point and receives its crash bootstrap solely through Cheryl::Engine. Keep it outside the default build unless acceptance runners are selected and outside automatic CTest execution. Provide a manual POSIX driver for Debug and NDEBUG consumers with isolated working directories, bounded subprocesses and disabled core files. Require Backward-specific trace output in Debug and ordinary signal termination without that output in NDEBUG builds. Document the target, execution scope and pending G5 evidence. Static review passed: Python AST syntax, exact production manifests, preservation of all original named tests, unchanged owner memory source, neutral Engine include boundaries, local documentation links and staged whitespace. No configuration, compilation or test execution was performed, per the owner-selected static-only scope.
Record the static preparation checkpoint and keep executable isolation acceptance open in the groundwork and U9 plans. Account for the 52/6/11 production manifests, preserved named cases, owner consumer probes, module include boundaries and standalone helper paths. Prepare a Release sequence that adds Native GLFW and OpenGL while reusing neutral outputs, a minimal Debug signal check, exact target/driver selections and an enclosing-host supplied-target example. Require PRE_TEST discovery and host-root CTest enablement, preserve CLion profiles, and distinguish native display limits and installed-package scope from source-target validation. Reviewed source paths, public quoted includes, consumer header inventories, dependency selectors and plan links without configuring, compiling or executing tests. Keep all executable outcomes and cost measurements pending under the owner-selected static-only scope.
…mposition Record the owner-reported extracted aggregate result of 393 passes and 17 ignored/skipped cases without inferring configuration or native coverage. Plan complete Engine, Native GLFW and OpenGL runners with reusable suite case objects and a single runner entry point. Move combined all-tests ownership and its diagnostics driver to projects/tests while preserving focused runners, selections, dependencies and source bytes. Keep implementation verification static until explicitly authorized to build or run tests.
Add engine-all-tests, platform-module_native-glfw-all-tests and graphics-module_opengl-all-tests under their implementing owners. Define combined all-tests in projects/tests after owner registration and move the cross-project diagnostics driver there without changing its bytes or executable expectations. Compile each focused suite into one reusable object target with private include hooks and definitions. Separate test support from the runner entry point, link cases directly into focused, owner and combined runners, and propagate conditional native X11 dependencies through the acceptance case target. Preserve focused/manual runners, selection options, native/font opt-ins and output locations. Record the owner-reported pre-change aggregate result of 393 passes and 17 ignored/skipped cases. Static review accounts for 333 Engine, 4 Native GLFW and 73 OpenGL cases, preserves every original suite source/helper manifest and all 310 recorded source/header/fixture/driver bytes, and verifies documentation paths and CMake source structure. No configuration, compilation or executable tests were run for this follow-up.
Replace completed planning journals with concise contract references, remaining requirements, discovery gates and scoped Git recovery pointers. Preserve UI probe and adapter prerequisites, module isolation acceptance, ownership constraints and unfinished public documentation work. Track G5 and U9 progress in one checklist per macro task, retaining checked subtasks until the whole task completes. Add documentation discipline that preserves useful context and reusable procedures while preventing routine execution-report accumulation. Keep existing Git rules and Cheryl conventions intact.
Use concise focused and acceptance runner names, with engine-all, native-glfw-all and opengl-all for owner aggregates. Keep all-tests as the selected assembly aggregate. Update aggregate assignments, the Engine acceptance link option, the logging driver and current documentation. Preserve case-object reuse, ownership, discovery, acceptance selection, build options and dependencies; unrelated verification executables retain their names. Verify exact target-name substitutions and unchanged shared composition helpers through static inspection. Repository searches find no old target names; Python syntax and diff whitespace checks pass. No configuration, compilation or test execution performed. Original task base: 2d1786e
Enables CTest in each selected module directory before adding its test owners. The previous helper enabled it inside a function, losing the CMAKE_TESTING_ENABLED definition on return and preventing standalone top-level registration. Checks fresh Engine-only and standalone Native configurations for isolated source/target graphs and the generated top-level CTest file. Updates the active G5 checklist to reuse owner-reported current all-tests and demo evidence, combine isolated and standalone selections, reuse compiler results and reserve execution for missing composition/bootstrap coverage.
Close G5 after fresh neutral Engine, standalone Native GLFW and whole OpenGL selections, supplied-target reuse, owner consumers and CTest registration, isolated logging/diagnostics, and automatic Debug/Release signal delivery. Reuse the owner's current combined all-tests and demo evidence rather than rebuilding those assemblies. Execute missing native OpenGL opt-ins, including publication backpressure and shutdown cases. Use serial low-priority builds and a task-local compiler cache; the Debug signal check reuses the existing neutral archive. Replace accumulated execution journals with reusable validation procedures and coverage limits. Remove the completed one-purpose checklist and repair roadmap links. Preserve sandbox migration, reverse teardown, future UI/input/Steam prerequisites, and separate installed-package and wider platform acceptance. Clarify that signal installation follows the compiled bootstrap object's NDEBUG scope. Validation: independent consumers passed; 126 Engine, four Native GLFW and 73 OpenGL cases passed without skips in the selected runs. Native GL includes 14 display checks. Standalone and supplied-target CTest registration match. Manual logging, diagnostics and bounded POSIX crash drivers passed; documentation links and whitespace checked.
Define copied top-left logical clip regions, finite/ordered validation, nested intersection, viewport clamping and outward framebuffer rounding. Draw styles resolve clips into immutable packets; empty regions suppress native draws. Add a separate position/UV/float-RGBA layout and transient provider upload without changing Vertex2D storage. Unsupported providers reject colored uploads explicitly. Keep VAO storage, shader attribute mapping and scissor implementation inside the whole OpenGL owner; validate before native state changes and reset scissor for unclipped draws and full clears. Add neutral mapping/retention/layout checks, OpenGL recording checks and an opt-in pixel check of color, alpha, scaled top-left clips and scissor reset. Document contracts and the ordered U9 probe units. Static validation: affected CMake paths exist, Engine headers remain native/graphics-free, whitespace checked. Executable U9 acceptance is pending explicit authorization; source completion does not close that gate.
Extend the existing Engine-owned portable graph with copied colored geometry and image/atlas storage. Record overlapping translucent panels, nested scroll clipping, an image and synthetic ASCII data through the real STBFont layout/submission contract. Exercise exclusive committed-text focus alongside controller gameplay State in both runtime modes. Submit image replacement to the platform owner, adopt its completed future during simulation and retain earlier packet resources through replacement and teardown. Bound the session and inspect ordering, thread affinity, focus epochs and final ownership without introducing widget APIs or another engine target. Require an explicit framebuffer extent for clipped direct OpenGL pipeline draws, preserving the original unclipped overload. Document the reusable probe procedure and the next adapter's pipeline/atlas bootstrap decision. Static validation: whitespace, documentation paths, test-name uniqueness and neutral Engine SDK boundaries checked. No U9 compilation or executable tests run; focused acceptance remains open while source work proceeds under the owner's conditional build/test instruction.
Read records for the focused field and its lease epoch through the existing TickInput API. Extract TextEvent values safely so routed button and editing-control records do not cause variant access failures. Validation: recompiled only the affected Release translation unit with one low-priority job. No full rebuild or test suite was run.
Add backend-neutral keyboard and mouse button codes alongside existing opaque State and native/scancode tokens. Populate them in the native GLFW adapter and retain callback-time pointer positions on button and scroll records. Add native mapping and Engine capture-to-tick preservation checks, including a click followed by movement and unmapped State keys. Select TGUI 1.13.0 custom-backend requirements, application-owned materials, immutable atlas snapshots and platform upload ownership before adapter implementation. Static mapping coverage, documentation links and whitespace checks pass. Added executable checks remain pending; no build or test suite was run.
Introduce Cheryl::UI::TGUI as an opt-in owner with module-local tests, an aggregate and an independent consumer/header probe. Reuse supplied TGUI targets or an explicit 1.13.0 source/package, require custom FreeType-only features and avoid dependency downloads or host backend rewrites. Translate portable key, committed-text and observation-time pointer records without native SDK calls or destructive consumption. Preserve repeats and fractional vertical scrolling, reject invalid coordinates/text and leave unsupported controls and key releases in the original stream. Suppress UI selection in Engine/module consumer bootstrap, document the current input-only scope and leave retained rendering, uploads and toolkit-session lifecycle in the owning U9 checklist. Static source/dependency/include/CMake/link checks pass; builds and executable acceptance remain pending.
Register extern/tgui at the reviewed v1.13.0 release and select the optional UI owner in the root assembly. Reuse supplied toolkit targets, explicit sources or package locations before the bundled source, without fetching during CMake configuration. Keep Engine-only and independent module bootstrap free of toolkit discovery. Document FreeType requirements and cached CLion selection, and refine the remaining resource/render bridge work before its implementation. Static diff and dependency revision checks only; no configure, compilation or tests were run.
Copy toolkit RGBA generations and expand indexed, transformed colored triangles into owned logical recordings. Preserve draw order, view mapping, image UV orientation and nested clips, with explicit configured texture limits and a smoothed-only provider policy. Upload complete recordings on the original provider/platform owner through owned dispatcher submissions. Reuse live image generations through a weak cache, resolve application-supplied materials into retained neutral packets, and adopt ready scenes without waiting or replacing the current scene on failure or cancellation. Add owner-local texture, recording, resource, retention and adoption checks plus independent consumer/header coverage. Reconcile current contracts and the remaining U9 session/widget work. Static checks only; configuration, compilation and executable acceptance remain pending.
Use Manu343726/ctti as the external dependency upstream and synchronize the initialized submodule remote. Preserve the existing pinned CTTI revision; no dependency update, build or test is performed.
Point extern/ctti at RexarX/ctti and synchronize its initialized local remote. Keep the pinned dependency revision unchanged and preserve the previous commit series.
Point extern/gainput at jochumdev/gainput and synchronize its initialized local remote. Preserve the pinned Gainput revision and leave the pre-existing CTTI working-tree change untouched.
Select and reuse gainput::gainput, gainputstatic or gainput instead of assuming the legacy static target. Apply warning options only to an owned concrete library and inherit exported public headers, repairing usage requirements only for legacy source builds. Suppress upstream samples and tests in a local dependency scope while preserving host cache choices and HID configuration. Document composition and record the separately discovered CTTI name-API migration required before compilation. The supplied CLion configure command succeeds with the existing default cache. No project targets were built and no tests were run. Preserve the existing user-selected submodule revisions as uncommitted work.
Use ctti/name.hpp and name_of for fully qualified singleton diagnostics and the unevaluated type-name macros. Replace the removed type_id factories with type_id_of in the macros and dependency acceptance cases. Extend the existing CTTI cases to cover namespace qualification, reference preservation, value-ID decay and expression non-evaluation. Document the CTTI 1.1 requirement and the remaining tracked submodule revision alignment. Preserve the user's pending CTTI and Gainput revision changes outside this commit. Static inspection finds no removed CTTI API references in Cheryl sources and all referenced CTTI headers exist in the selected checkout. No builds or tests were run.
Initialize the selected Gainput manager explicitly on the first window attachment before device creation. Validate window ownership first, pass the native HWND on Windows, and initialize the non-Windows HID backend without a window instance. Pair initialization with Exit at adapter destruction while preserving devices across window detachment and reattachment. Pass elapsed steady-clock seconds to Update instead of its zero default, resetting the interval on attachment to exclude detached time. Add an opt-in native composition case for the first poll, repeated attachment, clock advancement, retained device IDs and context destruction. Document the lifecycle and callback contracts alongside the remaining tracked dependency revision alignment and process-global HID/Windows notification ownership limits. Static whitespace and affected formatting checks pass; no project builds or tests were run. Exclude the pending mapper declaration/definition changes and user-selected dependency revisions from this commit.
Copy logical window dimensions beside framebuffer dimensions on the platform owner in sequential and concurrent execution. Transfer the pair under the existing concurrent handoff lock and append the logical dimensions to TickContext so existing aggregate initialization remains valid. Extend the controlled-window scenario with distinct logical/pixel dimensions, platform-thread accessor checks and a focused concurrent case. Document the copied snapshot contract and order the remaining U9 session/demo work around it. The new checks are source-complete; no builds or tests were run.
Own the custom toolkit backend, recording GUI and guarded FreeType font factory in one session. Use copied logical/pixel dimensions and explicit simulation time; preserve focus epochs, modifier releases and input capture lifetimes. Report unavailable clipboard/cursor/IME services and reject destructive clipboard shortcuts before widgets edit a selection. Keep the backend alive through GUI/global-resource destruction and allow final serial teardown after the simulation owner stops. Extend the independent consumer and module-local source checks for real text widgets, view mapping, atlas generations and teardown. Executable acceptance remains pending; no builds or tests were run for this unit.
Give every discovered GoogleTest case its own CTest working directory, shared by suite and aggregate registration. Separate directories by runner, configuration, and a hash of the complete test name so concurrent cases retain independent default log files. Reproduces the Windows reflection_output failure with MSVC 19.51 under Wine while another process holds rendering.log open. The isolated configuration passes that case and 28 logging checks in parallel, with the existing cross-drive config_reopen skip. Native parallel verification passes 655 checks with two fixture-dependent skips; multi-config discovery confirms distinct directories across runner prefixes and Debug/Release configurations.
Passes the repository root to the standalone SDK consumer in CMake path form. Windows backslashes previously entered the RmlUi font macro unchanged and became C++ escape sequences, corrupting the path to assets/fonts/DejaVuSans.ttf. Reproduces the original path corruption with MSVC under Wine and verifies that the actual RmlUi consumer loads the font and exits successfully with the normalized path.
Retires TR15 and TR17 after reported acceptance and preserves their reusable Engine-only graph and Linux terminal procedures in the owning guides. Narrows TR20 to the first main-push SDK collection, replaces the obsolete manual dispatch with run inspection and artifact checksum checks, and removes the resolved manifest fixture blocker. Repairs roadmap, status and guide references while retaining hosted Windows CFF and logging temporary-drive coverage limits, desktop QA and dedicated startup/UI follow-up.
Adds a namespace-and-local-name overload alongside the existing qualified ID lookup. Exposes an owned namespace snapshot keyed by local sprite names, with deterministic iteration and retained handles copied under the cache read lock. Keeps collection lookup independent of manifest loading and frame selection so games can use renamed manifest groups directly.
Assembles singleton error messages with string append instead of std::format in both Singleton_CTS and Singleton_CTU. Covers get() and initialize() so callers avoid the format argument instantiation reported by clangd consumers. Preserves exception types, diagnostic text, and singleton construction and publication behavior.
cppcooper
force-pushed
the
engine-foundations-and-consumer-facilities
branch
from
October 13, 2026 22:33
5643339 to
23c7761
Compare
Uses the supplied schema v2 configuration with Ubuntu 24.04 and Python 3.13. Points Sphinx at docs/conf.py and reserves the requirements installation for the documentation toolchain pilot.
Prefers installed documentation tools when minimum versions, Python requirements, dependency constraints and imports are usable. Provisions a hash-locked Python toolchain and pinned Doxygen into a shared user cache only when needed, with process locks and readiness checks across CMake configurations. Adds optional root and standalone documentation targets without configure-time installation, plus a Doxygen/Breathe/Exhale/Sphinx pilot and revision-specific repository links. Covers cache reuse, recovery, dependency selection, archives and concurrent setup with stdlib tests. Validates standalone Ninja configuration, 38 bootstrap cases and initial Linux tool provisioning; rendered pilot acceptance follows separately.
Preserves callable lookup and template parameters by documenting inherited interfaces on their declaring bases. Resolves unambiguous namespace and inherited alias references, excludes private friend and storage details, and uses standard Sphinx navigation with valid local anchors. Clears owned XML output before extraction, captures strict Sphinx warnings, and avoids source footers for generated or built-in pages.
Demonstrates public OpenGL startup, platform-owned bindings and resource loading, retained sprite injection, selected system fonts with embedded fallback, tick-based movement and cell selection, and immutable sprite and text frame submission. Adds an opt-in root target plus source and installed-SDK consumer entry points. Checks in self-authored two-cell artwork, indexes, materials and shaders so the example does not depend on optional or unfinished game assets.
Publishes purpose, arguments, results, retained and borrowed lifetimes, owner-thread requirements and failure behavior in Doxygen comments for startup, game hooks, bindings, loading, resource lookup, font selection, text preparation and frame submission. Preserves the established contracts and all noncomment C++ tokens; no declarations or runtime behavior change.
Includes maintained source excerpts for startup, lifecycle, assets, fonts, simulation, rendering and cleanup, with explicit Ninja root/source/SDK setup commands and links to detailed contracts. Documents compatible system tools, shared pinned fallback caches, independent docs-only CMake generation, and the versioned Read the Docs publishing and account setup contract. Updates entry points and build option references.
Accepts a validated Doxygen path or executable name before fallback selection, preserving system-first defaults and newer-version testing. Rejects explicit native overrides with forced pinned tooling and propagates pinning state to child generators. Covers override validation, missing and unusable tools, installer avoidance, pinning conflicts and child environment propagation with isolated tooling checks.
Discovers Cheryl-owned engine, support and module headers across ten public roots. Preserves exact declaring owners, aliases, concepts and template constraints, adds qualifier notes, and gives namespaces case-safe identities without changing engine declarations. Normalizes private compound and friendship visibility from Doxygen metadata and the explicit implementation namespace policy. Validates extraction scope, local navigation/assets/fragments, source Git objects and clean publication identity; publishes sanitized revision/tool metadata and source links.
…ishing Uses one pinned generator and validator for Read the Docs and read-only Actions checks, caches shared tools by interpreter and lock identity, and retains revision-identified HTML and diagnostics. Adds the maintained first game to existing Linux and Windows module compilation. Prepares a disabled-by-default main-to-stable mirror with separate write permissions, canonical-event and successful-check gates, stale-main detection and non-forced updates. Covers publication decisions, API failures and response ownership with mocked requests only.
Reconciles the maintainer guide with the implemented full-reference checks, declaration notes, artifact workflow, and pinned Read the Docs build. Describes the disabled stable mirror and first-publication prerequisites, including the main-push trigger and deferred historical-version coverage. Repairs the first-game CMake excerpt boundary and makes controls, OpenGL requirements, and desktop acceptance limits explicit.
Collects header locations by exact Doxygen declaration ID and resolves generated owner pages through Exhale document filenames, including the separately generated concept pages. Adds revision-pinned declaring-source links alongside the existing build provenance footer.
Targets the exact RenderedText resolve_text signature used by the maintained example, so the reader reaches that overload instead of the separate legacy Font and string_view path.
Includes the declared vector return type in the resolve_text cross-reference target required by the Sphinx C++ domain. An isolated render against both Doxygen overloads confirms that the link selects uploaded Unicode text submission.
Replaces globbed page-title navigation with ordered, concise subject labels and separate Assets, Rendering, Resources, Runtime, Reference, Development, and Validation groups. Retains all existing guide destinations and descriptive article titles, and labels the generated API hierarchy as Symbols. Adds section headings to memory, input, events, worker, audio, timing, failure, and diagnostics guides so their distinct topics can be discovered through the existing expandable navigation without changing the documented contracts.
Groups asset values and their supporting declarations into focused families, separates portable rendering contracts from OpenGL implementations, and scopes input protocols by purpose. Moves reusable workers, runtime services, application composition, platform adapters, memory, state, time, file and logging utilities into their owning namespaces. Migrates engine modules, examples, consumers, fixtures, friendships and standard specializations without changing asset schemas or runtime behavior. Keeps include paths and CMake targets stable, removes exported catch-all aliases, and restores DeltaTime documentation extraction by removing its duplicate pragma. Builds the engine, all optional Linux backends and worker providers, examples, SDK, public-header consumers and existing test/acceptance executables with Ninja using 16 jobs. Defers GoogleTest discovery and does not execute tests.
Reconciles the walkthroughs, examples and subject contracts with the new API owners and contextual names. Explains asset families, CPU recipes and retained rendering resources, neutral input protocols, reusable workers and runtime ownership. Adds namespace and migration guidance while preserving short navigation labels. Draws vertical ancestry and branch guides in the semantic API file tree without changing its links or adding JavaScript. Updates private namespace exclusions and clock-reference handling for the reorganized reference. Preserves public named declarations and overload counts in the regenerated XML inventory.
Resolves repeated namespace identifiers through the declaring lexical scope, preserves leading global qualifiers for standard-clock member exclusions, and normalizes Doxygen virtual return-type metadata before rendering. Selects the Unicode text overload using its exact generated declaration spelling and corrects runtime lifecycle references and StartupResult context terminology. Verifies the overload link through an isolated Sphinx rendering.
Builds one lookup from public Sphinx declarations and namespace pages, then resolves ordinary inline names, calls, template types and member assignments. Preserves displayed code and existing links, excludes examples and signatures, and leaves ambiguous or unresolved references unchanged. Reuses extraction metadata to validate generic template owners, refreshes cached pages when the API inventory changes, and reports linking overhead in the documentation build log. Documents the authoring and overload-resolution behavior.
Adds generated documentation and reorganizes the engine API
Exclude docs/api/generated and Python __pycache__ directories so local generated pages and bytecode do not appear as untracked files. Keep authored documentation and project sources visible.
Generate API sources under docs/generated/api and keep documentation bytecode under docs/generated/pycache by default. Set cache routing before local imports, preserve explicit Python prefixes, and propagate the selected prefix to child processes. Update API navigation, declaring-owner lookup, source links, and inline references for the new document paths. Ignore the generated tree and exclude legacy API output from Sphinx discovery to prevent duplicate pages after switching branches.
Move Sphinx configuration, extensions, theme inputs, dependency manifests, generation scripts, the docs-only CMake project and existing tooling tests into one nested area. Keep authored Markdown pages in the documentation root and load configuration through Sphinx -c. Default local, CMake and CI rendering to docs/generation/generated, route API pages and bytecode there, and serialize profiles with its shared generation lock. Exclude tooling and auxiliary outputs from source discovery while retaining the generated API pages, and protect authored sources and reserved API/cache directories from output overrides. Update API references, navigation, hosted build entry points, CI cache and artifact paths, and the documentation generation guide for the new layout.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Summary
This PR substantially advances Cheryl Engine toward its v4.0.0 architectural baseline, building on the runtime, rendering, and resource-management foundations previously merged into
develop.The primary objective is to transform those foundations into a cohesive, extensible game engine with independently selectable platform, graphics, UI, and audio implementations, supported by consumer-facing APIs, reproducible builds, and verifiable integration contracts.
The branch also introduces significant new functionality across asset management, text rendering, execution scheduling, diagnostics, and development tooling.
Major changes
Engine architecture and modularity
Cheryl::Enginelibrary with optional integration modules and explicit dependency boundaries.Runtime, execution, and input
Rendering, graphics, and assets
Text and user interfaces
Audio
Testing, diagnostics, and documentation
Validation and remaining acceptance
Selected Linux builds, integration suites, native observations, and consumer checks have been completed throughout development. The latest manifest fixture update also records a successful focused five-case asset-manifest run.
However, implementation and acceptance remain separate. Outstanding verification includes independent Engine-only linkage inspection, Linux terminal configuration and desktop acceptance, indexed-material demo QA, and hosted Linux/Windows CI and SDK verification.
Successful local Linux validation does not establish comprehensive Windows, macOS, Wayland, or mobile compatibility.
Scope under continued review
This PR remains an active integration branch as the v4.0.0 checkpoint approaches. Additional changes may be incorporated before merging into
develop, particularly where they complete existing architectural contracts or resolve integration gaps.Current follow-up discussions include:
These are evolving development priorities, not assertions that every item must be implemented before this PR merges. Completed changes will be incorporated into this description as appropriate; remaining work will continue through the project roadmap.
v4.0.0 checkpoint
This PR is intended to establish a coherent, usable foundation for Cheryl Engine 4.0.0—not to declare the engine feature-complete.
The checkpoint emphasizes stable architectural boundaries, reliable resource and execution ownership, functional platform/graphics/UI/audio integration, and credible consumer-facing build and development facilities.
Future capabilities can be delivered incrementally without requiring every anticipated subsystem or platform integration to be part of the initial v4.0.0 baseline.