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

Im a self-taught game developer who loves making cool Projects/Graphics and high-performance stuff. I have build my own engines from scratch to learn 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.

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

Mask/Off is a couch co-op puzzle game created during Global Game Jam 2026 (Coimbatore). Built in just 48 hours, this was my first in-person game jam and one of the most memorable development experiences I’ve had.

The event was filled with passionate developers, welcoming community members, and industry professionals who were incredibly generous with their knowledge and time.

Media:

Tech:

• Unity – Game Engine
• C# – Programming Language

What I Did

• Designed and implemented the multi-controller input system for local multiplayer
• Developed the player movement system
• Created the throwable ability mechanic
• Designed and implemented one of the mask abilities
• Worked on shader effects to enhance visual feedback

This jam pushed me to collaborate closely under intense time pressure, rapidly prototype gameplay systems, and design mechanics that worked well in a shared-screen multiplayer setting.

Play the game: Game Link
View the jam team: GGJ Team Page

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

Super Pixel is my first ever published game that too made on scratch.

Scratch is where i started by game development and i have made several other projects but non is public(even i have lost the project files lol).

Since then i found my spark inside me for game development and i have kept walking with it, Youtube and lots of channels/online resource have held me a lot (a big THANKS to them).

i wish i met my kid version of myself and thank him for not giving up!!

I love to thank everyone even for smalled thing in my life(butterfly effect mate!!)

PiGL.js is a custom WebGL rendering engine and editor built from scratch — vanilla JS and GLSL, no heavy frameworks. Modular architecture, multipass rendering, deferred lighting, post-processing effects. More of a graphics playground than a game engine, and that's exactly the point.

Tech:

• Vanilla JavaScript (ES6+) – core engine logic, OOP architecture, async asset loading
• WebGL 1.0 / GLSL – raw graphics, lighting, and screen-space effects
• Vite – build tooling, shader hot-reloading
• lil-gui – in-editor UI for real-time inspection and material tweaking

What I Did

• Engineered a modular rendering pipeline from scratch — Lighting, Outlines, Skybox, Pixel Art passes
• Built a deferred-like workflow using MRTs to decouple lighting from scene complexity
• Created an in-browser editor: Window Manager, Hierarchy view, real-time Inspector
• Implemented a full math library — custom Matrix4, Vector3, Quaternion-style logic
• Built an OBJ + texture asset loader with placeholder and GPU upload state management
• Designed a real-time profiler for FPS, frame times, and per-pass draw call counts

What I Learned

• Low-level WebGL state management — framebuffers, vertex/fragment shaders, the whole pipeline
• Designing extensible engine architecture where adding a new visual pass doesn't break everything else
• Spatial math for camera systems, projection matrices, and light-space transforms
• Optimizing render loops through resource reuse and minimizing state changes

Powers stylized pixel-art environments and water simulations. Source and docs on GitHub.

Sim-Cade Car Physics is a private learning project in Flax Engine — one week, core vehicle systems built from scratch. Tyre grip, suspension response, engine torque, transmission behavior. The goal was to understand how car physics actually work before ever trusting a pre-built vehicle system again.

Tech:

• Flax Engine – simulation and rendering
• C# – physics logic, input handling, vehicle control
• Maths & Physics – forces, torque, suspension, tyre behavior from first principles

What I Did

• Implemented tyre grip, suspension response, engine torque, and transmission from scratch
• Built end-to-end vehicle mechanics in Flax for fast experimentation and tuning
• Developed a playable prototype to test behavior under different scenarios

What I Learned

• Tyre physics, suspension modeling, and torque distribution in a simplified simulation
• Rapid prototyping and iteration inside Flax Engine
• Balancing realism and playability in sim-cade vehicle mechanics
• Applying physics principles directly to game programming problems

Portfolio — you're already inside it. Built entirely from scratch. Three.js for 3D rendering, GSAP for animations, Vite for build. The whole thing is designed to feel like an interactive experience, not a static page.

Tech:

• Three.js – custom 3D nodes, interactive transitions, WebGL visuals
• GSAP – fluid animations, scene flips, hover interactions
• Vite – rapid dev and optimized builds
• JavaScript / HTML / CSS – logic, styling, layout

What I Did

• Designed a node-based layout — modular, interactively expandable, feels like a game UI
• Used Three.js for a lightweight custom 3D renderer
• Built GSAP timelines for all major animations — entrances, node expansions, hover states
• Embedded a fully playable DOSBox version of SYSRA directly in the site — visit and play without leaving

What I Learned

• Designing interactive UI that feels like a product, not just a showcase
• Three.js scene management and camera control for UI-driven 3D
• GSAP timeline orchestration for complex multi-element animations
• Embedding emulated content (DOSBox) inside a live web experience

Live at itstanpi.github.io

Pi‑Engine is a custom 2D game engine built in Java — rendering pipeline, entity-component system, scene management, real-time input, GUI overlays, all structured for flexibility and performance. Built it to actually understand what an engine is under the hood, not just how to use one.

Tech:

• Java 11+ – core engine logic, entity management, event handling
• LWJGL / OpenGL – rendering textured sprites, tilemaps, GUI overlays
• Component-System (CS) – modular architecture, reusable components
• Scene Graph – hierarchical structure with update/render separation
• ImGui-Java – debug overlays for live scene inspection and profiling

What I Did

• Designed a Component-System architecture — rendering, physics, input, and UI fully decoupled
• Built a rendering pipeline in LWJGL/OpenGL with sprite batching, z-order, and camera transforms
• Implemented JSON-based scene loading for entities, components, and prefab data
• Integrated ImGui for live entity hierarchy inspection, component values, and profiler stats
• Created hot-reloadable systems for live asset and logic tweaking at runtime

What I Learned

• Component-System workflows and managing component lifecycle across varied systems
• Building efficient rendering loops and batching strategies
• Dynamic scene and prefab loading from JSON definitions
• Using ImGui to build developer tools that actually improve workflow
• Structuring a modular engine that can support gameplay or simulation projects

Source, engine tools, and example scenes on GitHub.

SYSRA.asm is SYSRA — but in 8086 Assembly, running on DOS. Custom sprite rendering, collision detection, direct screen-buffer management. No libraries, no engine. Just registers, interrupts, and a deep understanding of how old games actually worked.

Tech:

• NASM / 8086 real-mode Assembly – full CPU instruction control
• BIOS & DOS interrupts – video mode (0x13h), keyboard input, timing
• Direct video memory writes – real-time sprite and tile rendering
• Fixed-point arithmetic (8.8 format) – subpixel movement and smooth collision
• Double buffering in segment:offset – flickering eliminated
• Custom tile & sprite system – collision map baked into binary format

What I Did

• Real-mode memory segmentation and segment:offset pointers for tile maps
• Manual update-render loop toggling between backbuffer and frontbuffer
• Fixed-point system for smooth horizontal and vertical movement
• Collision detection via sprite footprint checked against a binary collision mask
• Keyboard polling via BIOS INT 16h for immediate player input
• Inner loop unrolling and REGISTER-level sprite blit optimizations

What I Learned

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

Foundation for a retro-style platformer engine. Planning to extend with PC speaker sound, level loading, and rudimentary physics. Full source on GitHub.

AI‑Racing‑Sim is a 2D car racing simulator in Python that uses reinforcement learning (PPO) to train autonomous racing agents. Custom simulation environment, RL training pipeline, telemetry logging, real-time policy visualization.

Tech:

• Python 3.x – simulation and training logic
• Custom Gym-style environment – state-reset, step(), render() abstractions
• PPO via Stable Baselines3 – actor-critic RL algorithm
• NumPy – physics and vector math for 2D dynamics
• Matplotlib / Pygame – telemetry plotting and real-time render
• Tensorboard integration – training metrics, loss curves, reward progression

What I Did

• Built a full 2D top-down track simulator — vehicle kinematics, collision, lap detection
• Defined observation and continuous action spaces (steering, acceleration)
• Integrated Gym-compatible interface for PPO training via Stable Baselines3
• Tuned PPO hyperparameters — batch size, learning rate, clipping epsilon
• Visualized agent performance with real-time render and saved telemetry plots

What I Learned

• RL training fundamentals — policy gradient stability, reward shaping, exploration vs exploitation
• 2D physics modeling — translating thrust and friction into real acceleration dynamics
• Gym environment mechanics — episode termination, state normalization, reproducibility
• RL debugging strategies — diagnosing divergence, hyperparameter impact, reward clarity

Full source, training scripts, and demo on GitHub.

2DURP‑GodRays is a post-processing shader for Unity URP that generates dynamic god ray (crepuscular ray) effects in 2D scenes. Fully tunable — Density, Decay, Exposure, Blur, Samples. Demo on itch.io.

Tech:

• Unity URP – lightweight scriptable rendering
• HLSL – custom full-screen post-processing shader
• ScriptableRendererFeature + ScriptableRenderPass – injected after depth/opaque pass
• Depth-based radial blur – samples along vector from light source with decay
• RTHandles – transient render texture management
• Dynamic sample scaling and viewport downscaling for performance modes

What I Did

• Architected the URP renderer feature and render pass for light scattering
• Developed the radial blur kernel in HLSL with multi-iteration decay sampling
• Managed RTHandles and temporary render textures to isolate and blur light source masks
• Exposed all shader parameters for runtime tweaking by artists and devs
• Built a demo scene with UI toggles and keybinds for live testing

What I Learned

• URP's render lifecycle and the full ScriptableRenderPass workflow
• Radial blur and light-scattering shader design techniques
• RTHandle memory management and transient render texture best practices
• Balancing visual quality vs performance through sampling strategies

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

Physics‑Engine is a custom 2D physics simulation in C++ with OpenGL rendering. Verlet integration, constraint-based springs and distance joints, basic collision — all from scratch. Built it because I wanted to understand constraint solvers before trusting any engine's physics black box.

Tech:

• C++11 – core architecture and physics logic
• GLFW + GLEW – cross-platform OpenGL context and function loading
• OpenGL – real-time rendering with point and line primitives
• Verlet Integration – stable time-stepping for particle position updates
• Constraint Solvers – spring/distance constraints via positional corrections
• 144 Hz fixed loop – deterministic physics updates

What I Did

• Particle-based physics system using Verlet integration for stable motion
• Spring and fixed-distance joint constraints connecting particles
• Basic collision detection and response for static obstacles
• Real-time OpenGL rendering of particles and joints via line/point primitives
• Interactive input — Space for impulse/jump, arrow keys to steer

What I Learned

• Physics integration methods and their stability characteristics at high update rates
• Constraint resolution via positional corrections instead of force-based solvers
• Real-time rendering with OpenGL primitives and GLFW/GLEW context management
• Decoupling physics updates from frame rendering for deterministic simulation

Full source and demo on GitHub.

Vending Machine Simulation is a full-stack web app simulating a smart vending machine — QR-based mobile UX, secure wallet and PIN system, admin dashboard for inventory, pricing, and sales analytics.

Tech:

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

What I Did

• Mobile-first UI — QR login, wallet top-up, product selection, transaction history
• Secure wallet system — phone number + PIN auth with OTP recovery via Twilio
• PHP backend — user accounts, transaction records, PIN reset flows
• Admin dashboard — sales analytics via Chart.js, restocking, live price management
• QR code generation per vending machine instance via PHP QR Code library

What I Learned

• Full-stack architecture — designing a system from mobile UI to database layer
• Real-time AJAX communication between client and server
• Third-party API integration (Twilio SMS) for production-style auth flows
• Building admin tooling — data visualization, inventory control, access management

Explore the code on GitHub.

Wiki-Interactive is an interactive solar system webpage — cartoon-style, kid-friendly, real physics simulation via Matter.js. Game dev tricks applied to education. Parallax scrolling, dynamic object rendering, motion-driven interactivity, all in the browser.

Tech:

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

What I Did

• Designed a cartoon-style solar system for an approachable learning experience
• Integrated Matter.js for real gravitational effects and object motion
• Implemented parallax scrolling for depth and game-like feel
• Optimized rendering of multiple interactive objects for smooth browser performance

What I Learned

• Applying game dev rendering and interaction patterns to web-based educational content
• Matter.js physics integration and tuning for visual appeal over strict realism
• Performance optimization for multi-object browser rendering

Live demo at Wiki-Interactive Live — source on GitHub.

1st Place – IMMERSIVEX '26
Sri Ramakrishna Engineering College (SREC)

Secured 1st place among 50+ participants in a competitive game jam. Built a complete and polished game under strict time constraints.

The project was judged by industry professionals and was recognized mainly for visual quality, technical execution, and overall feel.

Won a ₹10,000 prize. More than that, this was my first proper on-stage win after years of grinding.

Participant – Global Game Jam

Took part in Global Game Jam, where developers from all over the world build games within a very short time frame.

It’s a good test of how fast you can think, adapt ideas, and actually finish something under pressure.

These jams are where I experiment a lot and push my limits, especially with visuals and execution.

ATOM Community

I actively help people who are getting into game development, engine development, and graphics programming.

Most of the time it’s answering doubts, explaining concepts, or helping them debug stuff they are stuck on.

I try to make things simpler for others because I know how confusing this space can get when you start.

Game Development Basics Workshop
FOSS Club, CIT

I led a full hands-on workshop for 100+ students where I taught the fundamentals of game development from scratch. I didn’t just explain theory, I made sure everyone actually built something.

By the end of the session, every participant had a working game. That was the main focus — not just listening, but doing.

This also helped me get better at breaking down complex systems into simple ideas that beginners can understand.

Pi-Engine Showcase
FOSS Conference, CIT

I presented my custom-built Pi-Engine to 100+ attendees, explaining how the engine is structured and how different systems work together.

Covered things like rendering pipeline, component system, and overall workflow — basically how I think when building an engine.

I also showcased multiple projects built using the engine to prove it’s actually usable and not just an experiment.

@Tan-Pi

@Tan-Pi

@ItsTanPI

@ItsTanPI

@shriharishanmugam

@itstanPI