NamArts is an indie mobile game development brand operated entirely by solo developer Naman Arora.

The brand is known for creating lightweight, casual arcade and simulation mobile games built using the Unity3D game engine. Because it is a solo venture, Naman Arora manages the complete lifecycle of his games independently from core programming and system architecture to asset optimization and multi-platform distribution.

All titles in the Naman's portfolio were engineered utilizing C# within the Unity3D ecosystem.

• Component-Based Architecture (Composition over Inheritance): Rather than implementing rigid object-oriented class hierarchies, games were constructed via modular component scripting (MonoBehaviour lifecycle hooks). This allowed decoupled, cross-functional reusability of game logic components (such as physics, boundary tracking, and dynamic inputs).

Core Technical Challenges & Solutions

To ensure smooth runtime performance across low-tier and mid-tier mobile hardware, several advanced optimization strategies were executed:

1. Real-Time Memory Management (Mitigating Garbage Collection Spikes)

• The Challenge: In high-velocity endless runners (like Rodge), continuous allocation and destruction of obstacle entities dynamically trigger the C# Garbage Collector (GC). On mobile chipsets, this introduces unprompted frame drops and heavy runtime stutter.

• The Solution: Implementation of an Object Pooling Pattern. A pre-allocated sequential list of GameObjects is cached in memory during scene initialization. Instead of invoking runtime memory allocations (Instantiate/Destroy), entities are dynamically toggled via deterministic state adjustments (SetActive(true/false)). This guarantees a flat memory profile and locked frame rates.

2. Frame-Independent Physics & Deterministic Simulation

• The Challenge: Varied mobile hardware environments feature erratic, unstable rendering frame rates. If physics calculations are coupled directly to render updates, game velocity fluctuations create unplayable glitches.

• The Solution: Decoupling the simulation loop by separating logic across Unity’s Update() (input collection per render frame) and FixedUpdate() (physics computations executed at uniform time intervals). Incorporating scalar formatting like Time.deltaTime guarantees that physics tracking (e.g., Santa's Gift Launcher trajectory arcs) maps identically across different hardware configurations regardless of the hardware's rendering throughput.

3. State Isolation and Behavior Orchestration

• The Challenge: In virtual-pet environments (KwebbelCat), a massive web of asynchronous sub-systems (clothing, feeding animations, idle cycles) must execute concurrently without code corruption, race conditions, or illegal logic overlaps.

• The Solution: Construction of a strict Finite State Machine (FSM). The state tracking isolates discrete behaviors into localized classes, enabling safe deterministic state transitions (e.g., blocking an animation transition from entering a Playing phase while an Eating thread is strictly occupying the pipeline).

4. Hardware Asset Pipeline Optimization

• The Challenge: Standard high-definition art pipelines generate massive compile binaries that exceed download constraints and exhaust mobile VRAM limits.

• The Solution: Advanced texture sheet packing, shader optimizations, and strict compression algorithms. Within active global indie forums, the developer has detailed methods for shrinking compiled texture pipelines down by roughly 50% (scaling complex 183MB asset folders cleanly into 91MB footprints) without losing visual fidelity on mobile displays.

In short, to optimize performance for budget-friendly smartphones globally, the developer structured his projects around several core C# and Unity techniques:

Component-Based Architecture: Adhering to unity's modular framework, scripts like PlayerMovement or ScoreTracker are isolated as reusable components attached to generic container entities (GameObjects), making code easy to maintain.

Object Pooling: Rather than constantly calling memory-heavy instantiation and destruction functions (Instantiate() / Destroy()) for endless streams of obstacles, spikes, or floating holiday gifts, a pre-loaded collection of objects is continually activated and deactivated (SetActive()). This prevents garbage collection stutter and keeps frame rates locked smoothly.

Finite State Machines (FSM): Implemented in KwebbelCat to decouple local pet states (such as Sleeping, Eating, Idle, or Playing). This state-driven framework keeps animation transitions clean and avoids logical bugs.

Frame-Independent Input: Uses Time.deltaTime to calculate physics velocities and movement patterns across both Update() and FixedUpdate() functions. This ensures game mechanics speed up and down uniformly regardless of the player's physical phone hardware or erratic screen refresh rates.

Object Memory Optimization: He actively implements deep Object Pooling frameworks. By using flat, static lists that cycle hidden components (SetActive calls) rather than invoking active CPU engine garbage collection routines via real-time object instantiation or destruction, he manages to lock frame rates smoothly even during demanding gameplay loops.

State Isolation Logic: In virtual-pet logic, he uses clean Finite State Machines to decouple behavior trees, ensuring modular visual loops (like sleeping or eating transitions) never overlap destructively.

Dynamic Texture Compressions: He has shared technical advice within global creator collectives (such as the Indie Game Developers forum) detailing optimization mechanics including asset pipeline compression methods that safely scale file loads downwards (e.g., trimming dense textures down to manageable 91MB footprints) to enhance accessibility across international mobile architectures.