Name:Shri Hari (a.k.a TanPi)

I’m a game developer who loves making cool graphics and high-performance stuff. I build my own engines from scratch because I want full control and to really understand how everything works.

I work with everything from low-level assembly to modern rendering techniques. I focus on making things run fast and look good, no shortcuts.

When I’m not coding, I’m probably doing game jams or experimenting with new ideas. I like to learn, try new things, and push myself.

I like playing games and observing lots of details in them. That helps me understand what makes a game better so I can build games that actually feel good to play.

TV 3D-Model: Denys Hroshko

OverClocked is a fastpaced ThirdPerson Shooter Made for Boss Rush Jam 2025 (Jan 2025).

Media:

Tech:

• Unity (3D) - Game Engine
• C# - Programming language
• Blender - 3D Software

What i Did

Overclocked is the first full-on 3D game I made. I modeled a few things myself and mixed in some free licensed assets — but I didn’t just drop them in. I optimized them, tweaked their style in Blender, and made sure everything actually fit the game’s look and performance needs.

The vibe? Futuristic and rainy. I used screen space reflections, volumetric lighting, and fog to push that moody rainy-night-in-the-city feel. The shaders were all tuned to look slick without tanking FPS.

The theme for the jam was “Spin”, so I rolled with it — the boss has spin-based attacks, and the whole game kinda spirals around that mechanic.

I made Overclocked mainly to dive deep into 3D environments, shader tricks, and performance optimization — while still delivering a visual style and gameplay that hits hard.

Also, my friend joined as the music composer for this project — and he absolutely crushed it with a stunning soundtrack that brought the whole mood together.

Download & learn more on Itch.io

Escape-Vector is a retro-styled 2.5D roguelike shooter where 2D characters are running through a 3D world full of neon chaos. Made this for WhalePass Jam #2 and the theme was "Retro" — so I went full 80s neon shooter vibes.

Media:

Tech:

• Unity (3D) – Game Engine
• C# – Programming
• Blender – For 3D buildings and props

What I Did:

The main goal of the jam was to use the WhalePass API — so I integrated it to track XP, unlock achievements, and handle upgrades based on the player’s level. Basically, it's got online progression baked right in.

Now for the visuals — I went for that old-school CRT arcade look. I baked a bunch of lighting directly into textures using Unity, then removed the actual lights from the scene and swapped in emissive maps. That way I got fake-but-fresh lighting with ambient occlusion, while keeping the performance smooth.

To really push the retro style, I used Unity's custom render pipeline and made a post-processing shader that pixelates only specific objects — so the characters and bullets look crunchy, while the environment stays crisp.

Shoutout to one of the cool folks from the jam’s Discord — they helped with the soundtrack, and the music totally slaps with the retro action vibe.

This jam was a 7-day sprint, so it was hectic — but I learned a ton about shader tricks, API integration, and squeezing style into performance.

Web Play & learn more on Itch.io

Storms-Ahoy is a wave-based shooter where you blast sea monsters from your ship deck while surviving incoming chaos.

This game was made in a team of 6 for the Brackeys Game Jam 2024.2. The jam theme was "Calm befor Storm" — and we took that literally... and also with monsters.

Media:

Tech:

• Unity (2D) - Game Engine
• C# - Programming language
• GitHub - Version control & collaboration

What I did:

I handled most of the UI work, programmed the full upgrade system, and did a bunch of the secondary systems — like polish, game flow, and helpers that made the main game smoother.

It was my first proper team collab with 6 people, and it really helped me understand how to *actually* use GitHub in a proper team workflow. Not just push-and-pray — I learned the whole flow: branches, merges, pull requests, everything.

The project lasted 7 days, and we managed to finish and ship the game by working tightly as a team. It was fun, chaotic, and super educational.

You can play it and check it out on Itch.io.

SYSRA is a 2D platformer made for the GMTK Game Jam 2024. I made it solo in just 4 days — my shortest dev cycle ever for a full game — and it turned out to be my most successful project so far!

Media:

Tech:

• Unity (2D) – Game Engine
• C# – Programming Language

What I Did

The theme for the jam was “Scale,” so I built level mechanics around resizing objects to navigate puzzles and progress through tight platforming challenges.

SYSRA was a crash course in time/resource management. With just 4 days, I had to cut every corner that didn’t hurt gameplay — and still make sure it all looked and felt polished.

It taught me how to laser-focus under pressure and deliver results — no fluff, just gameplay that works and feels fun.

Web Play & learn more on Itch.io

Paper-War is an endless side-scrolling platformer brawler made in just 7 days for the Brackeys Game Jam 2024.1.

Media:

Tech:

• Unity 2D - Game Engine
• C# - Programming language

What I Did

The main playable character in Paper War is a soft-body fighter — building and tuning that took a lot of time, but it taught me a ton about Unity's 2D physics system, bone rigging, and texture mapping.

The game features multiple melee weapons like swords, spades, and hammers — each with their own unique properties. You collect these on the go by exploring, opening doors, and defeating enemies.

This was only my second game jam, and I had an absolute blast. Despite the tight timeline, I managed to polish it well and ship everything within the 7-day deadline.

Download & learn more on Itch.io

RealmShift is a top-down boss-rush shooter made in 30 days for the Boss Rush Game Jam. It was my very first game jam and marked my return to Unity after a long break.

Media:

Tech:

• Unity 2D - Game Engine
• C# - Programming language

What I Did

With some prior Unity experience, I joined the jam to dive back into game dev — and it paid off big time. I learned a ton about Unity's workflow, game design, and engine architecture.

This was the jam where I first explored using shaders, and it opened up a whole new world of creativity for me. I handled everything from design to polish, making sure the game felt solid and complete.

Special shoutout to a Discord friend who contributed an amazing soundtrack that players really loved!

Try it out on Itch.io

Portfolio is my personal interactive web portfolio built entirely from scratch. It serves as both a showcase of my projects and a live demonstration of my skills in frontend graphics, animation, and creative presentation. The entire UI is rendered with WebGL using Three.js and animated using GSAP, giving it a dynamic, game-like feel.

Tech:

• Three.js – for rendering custom 3D nodes, interactive transitions, and smooth WebGL-powered visuals.
• GSAP (GreenSock) – driving fluid animations between scenes, flips, and hover interactions.
• Vite – modern build toolchain for rapid development and optimized builds.
• JavaScript / HTML / CSS – for logic, styling, and layout structure.

What I Did

• Designed a node-based layout system resembling Unity’s Inspector, where each section (Games, Projects, About) is modular and interactively expandable.
• Used Three.js to create a lightweight custom renderer for 3D.
• Implemented GSAP timelines for all major UI animations, including entrance transitions, node expansions, and hover states.
• Embedded a fully playable DOSBox-powered version of SYSRA within the site using a dynamic iframe system — allowing visitors to play the game directly inside the portfolio.
• Built the system with Vite for blazing-fast hot module reload and clean build outputs.

What Makes It Unique

• The portfolio itself is a living project — not just a static list, but an interactive playground demonstrating WebGL, UI/UX, and real-time animation skills.
• Playable content like SYSRA adds an extra layer of engagement and allows visitors to directly experience my work without navigating away.
• Highly optimized: lightweight assets, lazy loading of nodes, and smooth animations even on mid-tier devices.

Visit the live site at itstanpi.github.io and explore projects the way I intended them to be experienced — interactively, playfully, and with a touch of 3D flair.

Pi‑Engine is a custom 2D game engine built in Java, crafted to support modular game development. It features a rendering pipeline, entity-component system, scene management, real-time input handling, and GUI overlays—with everything structured for flexibility and performance.

Tech:

• Java 11+ – core engine logic, entity-management, and event handling.
• LWJGL / OpenGL – rendering textured sprites, tilemaps, and GUI overlays.
• Component-System (CS) – modular architecture with reusable components and systems.
• Scene Graph – hierarchical scene structure with update/render separation.
• Input Handling – keyboard and mouse events with customizable bindings.
• Resource Management – efficient loading and caching of textures, fonts, and SVG-like assets.
• ImGui-Java integration – debug overlays for real-time scene inspection and profiling.

What I Did

• Designed an Component-System architecture with decoupled logic for rendering, physics, input, and UI systems.
• Built a rendering pipeline using LWJGL and OpenGL, handling sprite batching, z-order, and camera transforms.
• Implemented scene loading from JSON definitions for entities, components, and prefab data.
• Integrated immediate-mode GUI via ImGui-Java to inspect entity hierarchies, component values, and live profiler stats.
• Created hot-reloadable systems enabling live tweaking of assets and logic at runtime.

What I Learned

• Designing robust Component-System workflows and managing component lifecycle across varied systems.
• Building efficient rendering loops.
• Loading and parsing scene definitions, assets, and entity prefabs dynamically.
• Using ImGui to create developer tools that enhance workflow and debugging visibility.
• Structuring a game engine with modular, extensible systems—capable of supporting gameplay or simulation projects.

This engine underlies several demo projects—including a basic platformer and physics sandbox—and serves as a starting point for more complex games. You can explore the architecture, engine tools, and example scenes on GitHub.

SYSRA.asm is an 8086 Assembly-language platformer prototype I developed to explore low-level game development on DOS. It demonstrates custom sprite rendering, collision detection, and direct screen-buffer management—all handcrafted without any external libraries.

Tech:

• NASM / 8086 real-mode Assembly – full control over CPU instructions.
• BIOS & DOS interrupts – setting video mode (0x13h), keyboard input, timing.
• Direct video memory writes – drawing sprites and tiles in real-time.
• Fixed-point arithmetic – subpixel movement and smooth collision handling.
• Double buffering in segment:offset schema – to reduce flickering.
• Custom tile & sprite system – collision map integrated into binary formats.

What I Did

I built this from scratch to understand how classic DOS games managed graphics and input. I implemented:

• Real-mode memory segmentation and segment:offset pointers for tile maps.
• An update-render loop that manually toggles between backbuffer and frontbuffer.
• A fixed-point system (8.8 format) for smooth horizontal and vertical movement.
• Collision detection by checking sprite footprint against a binary collision mask.
• Keyboard polling via BIOS INT 16h to get immediate player input.
• Optimizations like unrolling inner loops and using REGISTER-level sprite blit routines.

Through this project, I gained deep insights into:

• CPU pipeline and instruction latency on 8086.
• Memory layout constraints in limited segment offsets.
• Manual collision system design at the byte-level.
• Graphics mode 0x13h (320×200, 256‑color) rendering challenges.

Though not a full game yet, it forms the foundation for a retro-style platformer engine. I intend to extend it with sound support (via PC speaker), level loading from data files, and rudimentary physics.

Check out the full source and demos on GitHub

AI‑Racing‑Sim is a 2D car racing simulator built in Python that uses reinforcement learning (PPO) to train autonomous agents for optimal racing behavior. The project includes a custom simulation environment, RL training pipeline, telemetry logging, and real-time policy rollout visualization.

Tech:

• Python 3.x – core simulation and training logic.
• Gym-style custom environment – state-reset, step(), render() abstractions.
• PPO (Proximal Policy Optimization) via Stable Baselines3 – actor‑critic RL algorithm.
• NumPy – physics and vector math for 2D dynamics computations.
• Matplotlib or Pygame – telemetry plotting or real-time render loops.
• Checkpointing & tensorboard integration – tracking training metrics, loss curves, reward progression.

What I Did

• Designed and programmed a 2D top-down track simulator including: vehicle kinematics (steer, throttle, brake), collision handling, and lap detection.
• Defined observation space (e.g., heading, speed, distance-to-track-edge) and continuous action space (steering angle, acceleration).
• Integrated Gym-compatible interface, enabling PPO training using Stable Baselines3.
• Tuned PPO hyperparameters — batch size, learning rate, clipping epsilon — to stabilize training and avoid policy collapse.
• Visualized agent performance with real-time render and saved telemetry plots (reward vs. timestep, lap time histograms).

What I Learned

• Fundamentals of RL training — policy gradient stability, reward shaping, handling exploration vs. exploitation.
• 2D physics modeling — translating wheel thrust and friction constraints into acceleration & steering dynamics.
• Gym environment mechanics — ensuring correct episode termination, state normalization, and reproducibility.
• Debug strategies for RL — diagnosing divergence, hyperparameter sweep impact, and reward signal clarity.
• Visualization pipelines — integrating training logs, tensorboard metrics, and simulation playback.

This prototype serves as a foundation for more advanced work, such as:

• Extending to 3D physics or integrating with a real-time simulator like Gym‑Duckietown or ROS-based frameworks.
• Adding multi-agent racing scenarios or curriculum learning for complex track layout generalization.
• Transitioning to perception-based agents using raw pixel inputs and convolutional policies.

Explore the full source code, training scripts, and demo session on GitHub.

2DURP‑GodRays is a post-processing shader crafted for Unity’s URP that generates dynamic, high‑quality god ray (crepuscular rays) effects in 2D scenes. It supports customizable settings like density, decay, exposure, and blur, enabling both aesthetic and optimized performance integration. A demo is available on itch.io.

Tech:

• Unity Universal Render Pipeline (URP) – for lightweight scriptable rendering.
• HLSL-based custom full-screen post-processing shader.
• Render Features & Render Pass – injecting god‑ray pass after depth/opaque.
• Depth-based radial blur – sample along vector from light source, combine decay.
• Shader properties: Density, Decay, Exposure, Samples, BlurRadius.
• Support for both 2D Sprite & 2D Lights pipelines via URP layering.
• Efficient performance modes: adjustable sample count and resolution via downsampling.

What I Did

• Architected a URP ScriptableRendererFeature and ScriptableRenderPass for light scattering.
• Worked with RTHandles and temporary render textures to isolate and blur light source masks.
• Developed radial blur kernel in HLSL with decay control and multi-iteration sampling.
• Exposed shader tuning parameters, enabling artists/devs to tweak visuals at runtime.
• Handled performance via dynamic sample count scaling and viewport downscaling.
• Created demonstration scene (sprites, parallax background) with UI toggles and keybindings: U, A/D/Arrows, Space, LMB/RMB, F :contentReference[oaicite:3]{index=3}.

What I Learned

• Deep understanding of URP’s render lifecycle and passes.
• Techniques for efficient radial blur and light-scattering shader design.
• Memory management using RTHandles and transient RenderTextures.
• Balancing visual quality and performance through sampling strategies.
• Shader‑centered UI configuration for rapid iteration and testing.

This shader pack is a foundation for visual polish in 2D URP games. Future improvements include:

• Dynamic light occlusion via depth masks or stencil overlays.
• Auto light positioning from scene light sources (e.g., 2D Light and Shadow Caster).
• Integration with volumetric particle overlays for atmosphere enhancement.
• Support for HDR and bloom integration via post-processing stack.

Try the demo or grab the source on itch.io or GitHub!

Physics‑Engine is a custom 2D physics simulation framework written in C++ with OpenGL rendering. It demonstrates core physics techniques like Verlet integration, constraint-based springs and distance joints, and simple collision detection/rendering—all built from the ground up.

Tech:

• C++11 – core architecture and physics logic.
• GLFW + GLEW – cross-platform OpenGL context creation and function loading.
• OpenGL – real-time rendering using point and line primitives for particles and joints.
• Verlet Integration – stable time-stepping for particle position updates.
• Constraint Solvers – spring/distance constraints implemented via positional corrections.
• Basic collision detection – AABB/circle or point collision responses.
• User input – interactive control via keyboard (Space for jump, Up arrow to move).
• FPS locking and loop timing – fixed at 144 Hz for deterministic updates.

What I Did

• Implemented a particle-based physics system using Verlet integration to simulate stable motion.
• Built constraint structures: springs and fixed-distance joints connecting particles.
• Developed simple collision detection and response to prevent particles/joints from passing through static obstacles.
• Rendered simulation elements (particles and joints) using OpenGL’s line and point drawings.
• Integrated real-time input handling: players can apply impulses (e.g. jump) via Space and steer using arrow keys.
• Ensured smooth physics with 144 Hz loop, locking FPS for consistent behavior across runs.

What I Learned

• Low-level physics integration methods and their stability at high update rates.
• Constraint resolution techniques using positional corrections instead of force solvers.
• Real-time rendering with OpenGL primitives and handling graphics context with GLFW/GLEW.
• Loop timing and deterministic simulation by decoupling physics updates from frame rendering.
• Interactive input mapping to physics actions for user-controlled simulation scenarios.

This project is a foundation for advanced physics-based systems. Future extensions could include:

• Rigid-body dynamics with orientation/quaternion handling.
• More advanced collision detection (SAT, GJK) and continuous collision response.
• Soft-body structures like cloth or mesh deformation.
• Adding textures, shaders for visualization, and performance profiling tools.

See the full demo (video linked in README) and source code on GitHub.

Wiki-Interactive is a dynamic and engaging webpage designed to educate and entertain users about our solar system. It features a playful, cartoon-style design aimed at kids and curious minds, combining interactive visuals with real physics simulation using Matter.js.

Tech:

• Frontend: HTML5, CSS3, JavaScript
• Physics Engine: Matter.js

What I Did

• Designed a cartoon-style solar system to create a fun and approachable learning experience.
• Integrated the Matter.js physics engine to simulate realistic gravitational effects and motion.
• Implemented parallax scrolling for depth perception and game-like presentation.
• Optimized rendering of multiple interactive objects for smooth browser performance.
• Used web technologies to build a fully interactive and responsive experience playable in any modern browser.

Features

• Interactive Solar System: Users can explore planets and elements with real-time motion and response.
• Kid-Friendly Design: Cartoon visuals and animations make learning space science fun and engaging.
• Physics Simulation: Motion and interactions driven by Matter.js for realism and immersion.
• Game-Inspired Elements: Includes parallax, dynamic object rendering, and playful motion logic.

Built with love for both learning and games, Wiki-Interactive is an example of how web technologies and game dev tricks can be used to create educational fun.

Check out the demo at Wiki-Interactive Live or view the source on GitHub.

Vending Machine Simulation is a full-stack web application that simulates a smart vending machine experience. It features user-facing interactions via mobile, secure wallet and PIN systems, and an admin dashboard for managing inventory, sales, and pricing.

Tech:

• Frontend: HTML, CSS, JavaScript, jQuery, Chart.js, Matter.js, Bootstrap
• Backend: PHP, MySQL, PHP QR Code Library
• APIs: Twilio (for OTP-based PIN recovery)
• Communication: AJAX (for real-time updates between machine and phone)

What I Did

• Built a mobile-first user interface for signing in, managing wallet balance, and buying products using QR codes.
• Implemented a secure wallet system where users authenticate via phone number and PIN, with OTP recovery support via Twilio.
• Created the backend logic in PHP for managing user accounts, transaction records, and PIN resets.
• Designed and developed an admin dashboard to visualize sales data (using Chart.js), restock items, and update product prices.
• Integrated QR code generation using the PHP QR Code library for each vending machine instance.

Features

• User Experience: QR login, wallet recharge, product selection, and transaction history.
• Security: 4-digit PIN login with OTP-based reset via SMS.
• Admin Tools: Sales filtering by branch/date/product, bar graph analytics, product restocking, and live inventory control.
• Responsive Design: Optimized for both mobile and desktop access via Bootstrap and AJAX-powered updates.

Assets courtesy of Freepik. Built to simulate how modern vending machines can integrate mobile-first UX with real-time inventory and secure digital payments.

Explore the code and try the simulation on GitHub.

@Tan-Pi

@Tan-Pi

@ItsTanPI

@ItsTanPI

@shriharishanmugam

@itstanPI