2025-10-04 Testing

Rendering Base

Began experimenting with OpenGL 3.0

Geometry + Texture loading + 2D Camera + Shaders

2025-10-21 UPDATE

Rendering

Moved to OpenGL 4.6 for modern functionality:

Direct State Access (DSA) + Persistent buffer mapping + Program pipelines + Synchronization objects.

2025-12-07 Testing

Text

First basic monochrome ASCII text was rendered on the screen.

2025-12-11 Testing

Window

Introduced basic window management and input handling using GLFW, providing the first interactive application environment.

2026-02-02 ALPHA 0.1

Project Restructure

Restructured the project from an initially unorganized codebase into a more structured library architecture.

Core and rendering layers began to emerge, establishing clearer boundaries between shared library functionality, rendering, and platform-specific operations.

2026-02-26 ALPHA 0.1.1

Rendering Optimization

Introduced the first major rendering performance improvements, including texture caching, batching, and texture atlases.

Rendering resources could now be reused and grouped across elements, reducing redundant texture operations and draw calls.

2026-03-01 ALPHA 0.1.2

Platform Support & Logging

Introduced a platform layer to isolate operating-system-specific functionality and provide a foundation for future cross-platform work. A new logging system was also introduced to improve debugging and output clarity, alongside core functionality such as file I/O.

2026-04-08 ALPHA 0.1.3

Build Speed

Significantly improved build times by optimizing the project's build process, evidently leading to faster production. Build scrips for debug and release were also separated to reduce unnecessary complexity and bloat.

2026-06-14 ALPHA 0.1.4

Button

Began development of the first interactive UI component, establishing the foundation for reusable UI controls.

2026-06-20 ALPHA 0.1.5

Core utility

Introduced Rect and Color structures with common operations, reducing the reliance on OpenGL Mathematics (GLM).

An input system was also introduced to provide a common interface for handling keyboard and mouse input independently of the underlying platform.

2026-07-14 ALPHA 0.1.6

Rendering Text

Monochrome Unicode text rendering was extended to support arbitrary glyph combinations from loaded fonts, enabling text in languages and scripts supported by the selected font.

Development surrounding text behavior such as alignment and line wrapping started.

2026-07-15 ALPHA 0.1.6.1

Label

Introduced a reusable label component to provide a higher-level interface for text rendering.

2026-07-22 ALPHA 0.1.6.2

Rendering Optimization & Features

Introduced basic text wrapping and alignment functionality.

New rendering improvements to per-frame storage using a scratch arena. Frame-temporary rendering data will now be allocated from the scratch arena and reused each frame without performing new allocations for each frame.

Also reworked glyph atlases to improve lookup time using a hashmap.

2026-07-24 ALPHA 0.1.6.3

Rendering Features

Introduced an alternative rendering path for drawing repeated geometry more efficiently. The renderer expanded from only supporting VertexBase to also supporting instanced rendering.

Instanced rendering became the primary path for drawing UI elements, allowing appropriate per-element data to be supplied as instance data while sharing the underlying geometry.

2026-07-28 ALPHA 0.1.7

Application

An application layer emerged within the core to encapsulate window boiler plate, component initialization, and application lifecycle management.

This allowed applications built using NGUI to follow a common initialization path and execution structure rather than managing these responsibilities independently.

This was also the first major leap made towards adopting a framework architecture.

2026-08-29 ALPHA 0.1.8

COLR Rasterizer

First successfull COLR rasterizer implementation, capable of rendering certain color emoji, depending on the paint structures encountered.

2026-09-01 ALPHA 0.2

UI Layer

First major effort to structure the UI system around reusable elements. Element creation and common behavior across UI components were generalized to establish a consistent foundation for building UI components. Rendering depth was also naturally derived from the ordering of elements within the UI tree containing every UIElement.

This marked another major step towards adopting a framework architecture, moving beyond a library that simply provided UI functionality.

2026-09-15 ALPHA 0.2.1

UI Layer Improvements

Expanded the UI layer with hierarchical bounds and clipping propagation. Child elements could now inherit restrictions from their parent elements and establish more restrictive clipping regions of their own.

This provided the foundation for rendering UI elements correctly within nested containers and established a more robust UI hierarchy.

Also redesigned the UI tree to utilize a persistent arena allocator as well as some improvements to the UI tree structure leading to traversal optimizations.

2026-09-16 ALPHA 0.2.1.1

UI Utility

Small bounds utility (Insets) for padding elements integrated with the bounds propagation workflow.

2026-09-18 ALPHA 0.2.2

Text Layout

Text got its own layout system calculating line wrapping based on language and font rules set by the UNICODE standard and HarfBuzz shaping utility.

2026-09-26 ALPHA 0.2.3

Internal Debugging

Memory allocation metadata tracking to identify leaks and lifetime issues in debug builds, while collecting metrics surrounding allocation counts and memory usage.

Redirected debug output from external libraries such as OpenGL, HarfBuzz, and ICU to its own debug output category to reduce noise.

2026-09-30 ALPHA 0.2.4

UI Events

Introduced an event system for the UI, allowing elements to receive and respond to user input such as mouse and keyboard events.

Event propagation was introduced alongside the system, allowing events to travel through the UI hierarchy and be handled by the appropriate elements. With this approach, event data became packed using unions to reduce memory overhead of dispatched events.

Hit testing was moved from specific components to being generalized in the UI.

2026-10-01 ALPHA 0.2.4.1

New UI primitive

New UIText primitive introduced to bring text rendering into the UI layer as a first-class UI element.

This established a direct connection between the UI hierarchy and the existing text rendering system, allowing text to participate in layout, bounds, clipping, and rendering like other UI elements.

2026-10-03 ALPHA 0.2.4.2

Fallback Fonts

Introduced font fallback support for glyphs not available in the selected font.

When a glyph is missing, the font system searches the configured fallback fonts in order and selects the first font containing the required glyph.

Currently lacks a missing-glyph representation when no configured font contains the required glyph.

Also added a dedicated rasterizer path for color glyphs, sharing the existing glyph rasterization pipeline while using color-specific handling.

2026-10-04 ALPHA 0.2.5

Rasterizer + Text Field

Migration from custom COLR rasterizer to HarfBuzz's experimental COLR rasterizer.

Began development of an editable text input component, extending the UI system with text interaction and keyboard input.

2026-10-09 ALPHA 0.3

Platform Layer

The Platform layer can now handle enough window features to justify leaving GLFW for explicit platform window creation.

Moved UTF utilities into core layer to remove its dependency on the platform layer.

Transferred Input ownership from Application to Window, removing application's role as an input adapter.

2026-10-10 IN PROGRESS

Platform Emoji Picker & More...

Working on a platform-specific solution for emoji picker functionality not exposed through GLFW. The solution is aimed to integrate with the underlying platform while keeping the functionality accessible through the UI layer.

Looking to improve debugging further by introducing core assertion functionality, potentially with platform-specific implementations.

Also considering if a core Point utility would be benifical enough to justify a codebase refactor.