Engine5 development timeline (as of 16-06-2026)

[Cooler2]

• 2026-02-08 - the large Engine5 refactoring began: the old base library started to be split into clear modules such as Apus.Core, Apus.Conv, and Apus.Strings. This set the main direction for the branch: not a cosmetic cleanup, but a rebuild of the engine foundation.
• 2026-02-08 - a shared test framework was added together with the first new modules. For a project of this age, this was an important milestone: changes could now be checked with repeatable tests, not only by launching demos.
• 2026-02-09 - Apus.HashMaps was added, and platform primitives such as timing, sleeping, and thread identifiers were moved into the new base layer. This started the separation of the modern foundation from the old Apus.Common.
• 2026-02-15 - Apus.Threads was added, giving the engine a dedicated module for threads, locks, and synchronization. It became a necessary base for future multithreaded rendering, resource loading, and window management.
• 2026-02-15 - error diagnostics were improved: stack traces, exception handling, and memory checks were strengthened. At this stage Engine5 began to gain tools not only for writing code, but also for understanding complex failures.
• 2026-02-16 - Apus.Files, Apus.Utils, and Apus.Lib were extracted. The base library started turning from a historically grown set of functions into a system of focused modules.
• 2026-02-16 - EventMan was migrated onto the new foundation built from Core, Strings, Threads, and Log. Since the event system is important for UI, scenes, and commands, this was one of the key internal migrations.
• 2026-02-17 - Apus.Classes and the old container layer were moved onto the new foundation. This closed one of the major dependency knots that had been blocking further Base cleanup.
• 2026-02-17 - time handling was unified and UTF8.Format was added. These changes made the base layer less dependent on old platform and string workarounds.
• 2026-02-18 - Apus.Common in Base was almost completely replaced by Apus.Core and the related new modules. This was one of the main turning points: the old central dependency stopped being the foundation of the library.
• 2026-02-18 - controlled floating-point formatting was added through Conv.ToStr(double). For the engine this matters not only as convenience, but also as a way to get consistent output in logs, tests, and data across different systems.
• 2026-02-22 - the text and font path began moving toward a stricter string model. Search operations were improved and groundwork was laid for safe UTF-8 handling and future UCS-4 support.
• 2026-02-26 - the key and input modifier system was redesigned. Instead of relying on old virtual-key bindings, the engine began forming its own input layer.
• 2026-02-27 - the font layer was moved to String32, removing old 16-bit limitations in Unicode text handling.
• 2026-03-01 - mass migration of engine modules to the new Base API began. From this point on, the refactoring was no longer only internal library work; it started reshaping the engine itself.
• 2026-03-05 - rendering track R-01 began: OpenGL context creation was updated, modern diagnostics were enabled, and core-profile mode was prepared. This moved Engine5 closer to a modern OpenGL model.
• 2026-03-05 - rendering was moved toward more modern buffer and shader usage. Old client-pointer and compatibility paths began giving way to a GPU-oriented pipeline.
• 2026-03-06 - Robot API was added: the engine gained a file-based protocol for external inspection of windows, FPS, scenes, UI, resources, and pixels. This is important for automated demo checks and runtime diagnostics.
• 2026-03-08 - the large R-02 windowing and platform track began. SDL and Windows paths started moving toward a shared model suitable for future multi-window support.
• 2026-03-09 - responsibility for scenes, sizes, FPS, and render state began moving out of the global TGame object and into individual windows. This brought the architecture closer to a real multi-window engine.
• 2026-03-10 - multi-window support gained a working foundation: separate state for each window, synchronization, and scene lifecycle handling. This was an important step away from the old "one main window" model.
• 2026-03-11 - Apus.Spatial was added and a new spatial-geometry line began. The engine gained a base for rays, frustums, bounding volumes, and future 3D code.
• 2026-03-12 - the large geometry track R-07 began. Geom2D and Geom3D started moving to unified type names, methods instead of scattered free functions, and a clearer API model.
• 2026-03-12 - old geometry compatibility was gradually removed. This made the API less confusing for new users and reduced the amount of historical duplication.
• 2026-03-18 - containers were fully extracted into Apus.Containers, and the hash-table policy was fixed. Base became better structured and clearer in its areas of responsibility.
• 2026-03-22 - high-precision monotonic clocks Time.TicksUs and Time.TicksSec were added. This matters for smooth animation, profiling, input, and stable frame measurements.
• 2026-03-23 - deterministic test-time clock override was added and animation tests were expanded. Time-dependent code became testable without random delays or instability from real timers.
• 2026-03-24 - rounding and other basic operations were aligned across compilers and platforms. These details matter in rendering, where a small difference can become visible.
• 2026-03-24 - UI track R-05 continued: element styling started to be centralized through TStyleBlock and the style catalog. This was a step toward a more modern and controllable UI layer.
• 2026-05-29 - after a pause, a major Linux/FPC stabilization pass was done: platform differences were fixed, smoke checks were updated, and systematic demo verification under Linux began.
• 2026-05-30 - the SDL path on Linux was brought to practical usability: keyboard handling, mouse coordinates, window closing, and multithreaded demo startup were fixed. Cross-platform support became something verified by real checks, not only an intention.
• 2026-06-03 - console modernization track R-16 began: command output and logs were separated from the old console module, while ConsoleScene gained its own buffer, filters, and display controls.
• 2026-06-05 - render performance diagnostics track R-09 began. Counters for draw calls, shaders, textures, vertices, and a dedicated debug overlay panel were added.
• 2026-06-09 - a normal-mapping prototype was added and the standard 3D shader was updated. This was the first visible step toward more expressive modern 3D rendering.
• 2026-06-09 - the color API was moved to a Color record with methods. This made graphics code easier to read and reduced the number of scattered global functions.
• 2026-06-09 - typed access helpers for texture rows and pixels were added. Working with locked textures became safer and easier to understand.
• 2026-06-12 - R-19 began: a new TMesh/TGpuMesh path was added for storing, loading, and sending geometry to the GPU. This started the replacement of the old 3D pipeline with a clearer model.
• 2026-06-12 - MeshLab was added as a technical demo for validating the new mesh path, sections, large grids, and GPU rendering. It became a workbench for the new 3D architecture.
• 2026-06-13 - R-20 began: generators for basic 3D shapes such as boxes, cylinders, planes, and spheres were added. This made it easier to create test scenes without external assets.
• 2026-06-14 - world and camera coordinate conventions were fixed. For a 3D engine this is essential: without such rules, models, cameras, lights, and imported formats quickly start contradicting each other.
• 2026-06-15 - MeshLab, Simple3D, and ShadowMap began moving onto the new 3D path. Engine5 started showing not only internal infrastructure, but real visible 3D scenarios.
• 2026-06-15 - Apus.Engine.DebugDraw was added as a visual layer for 3D debugging. It helps show axes, lines, shapes, and other service geometry directly in the scene.
• 2026-06-16 - the old OBJ path started being replaced by the OBJMesh and TGpuMesh combination, while obsolete loaders were removed. This brought the 3D side closer to a unified Engine5 architecture.