top of page
NiteLiteLogo_Wallpaper.png

NiteLite Engine

NiteLite was a custom 3D game engine developed in C++ by the engineering team behind KnightLight. I joined the project as a Technical Designer to stress-test the engine's pre-alpha tools and validate its proprietary C# scripting API. My work focused on providing critical, actionable feedback through a formal QA reporting pipeline, and developing a 3D physics-based game prototype to demonstrate the engine's gameplay capabilities in a live environment.

Project Details

Type: Custom Engine

Engine: Custom C++ Engine

Duration: 4 months (8 total)

Team Size: 9

Platform: PC

Year: 2025

Key Contributions

  • C# API Validation: Stress-tested the engine's proprietary C# scripting implementation by building technical demos to identify limitations in the API's logic and performance.

  • Technical QA & Bug Reporting: Acted as a primary tester for the engine and its dedicated launcher, identifying critical stability issues and documentating them through a formal GitHub reporting system.

  • Tool Request & Feedback: Collaborated directly with the engineering team to pitch and request specific engine features, providing feedback on editor usability to ensure the toolset met the practical needs of both programmers and designers.

  • Rapid Prototyping: Engineered a playable 3D Suika physics clone from scratch to validate the engine's collision detection, physics-based merging, and game-loop stability.

  • Visual Identity & Branding: Designed the official NiteLite logo used in the engine's launcher; the design emphasizes the engine's technical and programming-centric nature.

Team: EC&WW
EC&WW_Logo.jpg

​NiteLite was developed by a highly technical 10-person team composed primarily of programmers, many of whom were original contributors to the original KnightLight custom engine. Working as Technical Designers and QA Consultants, Taylor and I integrated with the engineering team to validate their systems in a live production environment.

Technical QA: Breaking the Engine

Because NiteLite was in active development, my primary responsibility was to be the "first user" who found the breaking points before the engine was considered stable enough for commercial use. Rather than working directly in the repository's main branch, I tested versioned releases. Whenever the programming team pushed a new build, I updated my editor directly through the NiteLite launcher and treated the new environment as a sandbox for Quality Assurance, systematically testing features like physics colliders, script parsing, and object rendering.

NiteLite Launcher

NiteLite Launcher Update

I utilized GitHub to manage a professional reporting pipeline, filing detailed bug reports that included step-by-step reproduction methods and suggested fixed. To ensure the engineering team could quickly identify how their C++ systems we misbehaving under a designer's workflow, I actively recorded and attached video documentation of the bugs in action. For example, by capturing video of a severe culling bug, where scaled geometry would incorrectly disappear from the scene at specific camera angles, I provided the rendering programmers with the exact visual evidence they needed to correct their visibility logic.

Bugs_All.png

GitHub Reporting Pipeline

Video documentation attached to a bug report

Prototyping: The Minigame Showcase

To demonstrate the engine's versatility and stability ahead of our final milestone, we shifted our production focus toward building a diverse collection of minigames. The team developed several distinct prototypes, including Minesweeper, Flappy Bird, and a tower defense clone, all connected through a central, interactive Lobby scene by the other designer. This structure allowed us to effectively stress-test different aspects of the engine's rendering, logic, and physics simultaneously.

Lobby_A.png

Minigame Showcase Lobby scene

Various prototype scenes built within the engine

For my contribution to the showcase, I engineered a 3D Suika (Watermelon Game) clone entirely within NiteLite's proprietary C# API. Because the engine's scripting environment was completely custom and still being documented, I had to build the core game loop from the ground up, successfully scripting the physics-based merging mechanics, fixed camera rotation, and dynamic score tracking.

​

Beyond the backend logic, I also tackled the UX challenges of translating a 2D puzzle into a 3D environment. To help players better gauge depth and facing direction, I deliberately designed the arena with brightly colored walls and placed dancing character models in the background to serve as vibrant visual reference points and work around the lack of a lighting system. Furthermore, I arranged a physical hierarchy of the mergeable spheres around the perimeter of the play table. This acted as a diegetic legend, intuitively teaching players the merge order and letting them know exactly which ball was next without relying on text menus. Ultimately, developing this playable prototype served as a comprehensive validation for the engine's collision detection, rendering, and API reliability.

In-engine Suika screenshots

Suika gameplay

Visual Identity: The Launcher

To give the NiteLite engine a professional, unified feel, I volunteered to design its official branding. Because this was a custom tool built by and for developers, I wanted the visual identity to immediately reflect its technical roots. I designed the logo around a box motif inspired by a blinking text cursor, a direct nod to the engine's programming-centric nature and the C# API at its core.

​

My design process started with initial concept sketches to nail down the silhouette. Once I locked in the core idea, I moved into digital drafting, carefully measuring the lengths, heights, and spatial distances of the typography in my first iteration. This strict attention to geometric balance and proportion ensure the design remained crisp and legible at any scale.

NiteLite_Logo_Sketch.png

Early logo sketches and iterations

NiteLite_Logo_Measures.png

Precise geometric measurements used to balance the typography

The final NiteLite logo

Because the design scaled down so cleanly, it was fully adopted by the team for multiple uses across the engine. It was integrated as the primary branding for the engine's boot-up launcher, and it also served as the default placeholder icon for files within the engine's content browser. Seeing my logo populate the asset explorer gave the editor UI a much more polished, cohesive look.

Post-Mortem: Pipelines, Blueprints, and Collaboration

Being the "first user" of a custom game engine is a unique challenge. NiteLite taught me that in a highly volatile technical environment, flexibility is just as important as technical skill.​

​

  • Scope Management & Pivoting: Initially, my co-designer and I spent months conceptualizing a large-scale adventure game named Moralia to build within NiteLite. However, we soon realized the custom engine's early feature set and stability couldn't support that scope within our deadline. We strategically pivoted from a sprawling game to a collection of focused minigames. This pivor was a hard lesson in scope managemenet, but it ultimately allowed us to deliver a polished showcase that perfectly served the engine's testing needs.

Scrapped evel section ideas for Moralia

  • ​Practical Problem-Solving: While scripting the 3D Suika prototype, I spent hours trying to engineer a complex, dynamic way to pass an array of string references between two C# scripts. After struggling to debug the connections, I asked a more experienced programmer for advice. They pointed out a much simpler solution: since the array was static, I could just copy it directly into both scripts. This eye-opening moment taught me to prioritize practical, functional solutions over overengineered, "perfect" code.

PostMortem.png

String array being utilized in two different scripts

bottom of page