દરેક પાસે એવો ફોલ્ડર હોય જ છે. જે અડધા અધૂરા ટ્યુટોરિયલ્સ, છોડી દેવાયેલા સાઇડ પ્રોજેક્ટ્સ અને README ફાઇલોથી ભરેલો હોય છે જે વાચ્યા કરતા વધુ વચન આપે છે. તે સારા ઈરાદાઓનો કબ્રસ્તાન છે, અને તેમાંથી બહાર નીકળવાનો એકમાત્ર રસ્તો કંઈક એવું લોન્ચ કરવું છે — કંઈ પણ — જે ખરેખર કામ કરતું હોય.

તે પૂર્ણ કરવાની તીવ્ર ઈચ્છા જ LIAR ના નિર્માણનું કારણ બની, જે એક એવી બ્રાઉઝર ગેમ છે જે એટલી નાની અને એટલી કઠોર છે કે તે માત્ર એક 28KB ની HTML ફાઇલમાં સમાઈ જાય છે. કોઈ ફ્રેમવર્ક નહીં. કોઈ ઈમેજ ફાઇલો નહીં. કોઈ સાઉન્ડ એસેટ્સ નહીં. ફક્ત કાચું HTML5 Canvas, Web Audio API, અને એક કડક સ્વભાવ.

એન્ટી-ટ્યુટોરિયલ

મોટાભાગના લર્નિંગ પ્રોજેક્ટ્સ એટલા માટે નિષ્ફળ જાય છે કારણ કે તેઓ ખૂબ જ જટિલ બની જાય છે. તમે કેનવાસ ટ્યુટોરિયલથી શરૂઆત કરો છો, પછી મૂવમેન્ટ સ્ક્રિપ્ટ ઉમેરો છો, પછી નક્કી કરો છો કે તમારે ટાઇલ એડિટરની જરૂર છે, પછી એન્ટિટી કમ્પોનન્ટ સિસ્ટમ, અને પછી Webpack કન્ફિગ જે કમ્પાઈલ થવામાં અગિયાર સેકન્ડ લે છે. છ અઠવાડિયા પછી તમારી પાસે બિલ્ડ પાઈપલાઈન તો હોય છે પણ ગેમ હોતી નથી.

LIAR તે જાળમાંથી બચવા માટે બનાવવામાં આવી છે. તે એક રિએક્શન ગેમ છે. એક બટન તમને TAP, HOLD, અથવા DON'T કરવાનું કહેશે. ટાઈમર પૂરો થાય તે પહેલાં તમારે કાર્ય કરવાનું છે. શરૂઆતના રાઉન્ડ્સ વિશ્વાસ કેળવે છે. લખાણ કહે છે TAP, તો તમે ટેપ કરો છો. લખાણ કહે છે HOLD, તો તમે તમારી આંગળી દબાવી રાખો છો. તે સરળ, લયબદ્ધ અને લગભગ ધ્યાન (meditative) જેવું છે.

પછી છઠ્ઠો રાઉન્ડ આવે છે.

વિશ્વાસઘાતની મિકેનિક્સ

છઠ્ઠા રાઉન્ડની આસપાસ, ગેમ જૂઠું બોલવાનું શરૂ કરે છે. સ્ક્રીન પર એક કમાન્ડ ફ્લેશ થાય છે — કદાચ એક આક્રમક, લાલ, ધ્રૂજતું TAP — અને વોર્મ-અપ દરમિયાન તમે જે રિફ્લેક્સ વિકસાવ્યા છે તે તમને બટન દબાવવા માટે મજબૂર કરે છે. જો તમે તે કરશો, તો તમે હારી જશો. લાલ ધ્રૂજતું લખાણ કોઈ ગ્લીચ નથી. તે એક સંકેત છે. એક પ્રમાણિક જૂઠું બોલનાર તમને સંકેત આપે છે, અને આ ગેમ તમને બરાબર તે જ આપે છે: છેતરપિંડીની એક વિઝ્યુઅલ ભાષા.

આ યુક્તિ કામ કરે છે કારણ કે તેનો પાયો પ્રમાણિક છે. શરૂઆતના રાઉન્ડ્સ તમને શીખવે છે કે રંગ અને ગતિનો અર્થ હોય છે. જ્યારે પેલેટ અચાનક બદલાય છે અને લખાણ ધ્રૂજે છે, ત્યારે ગેમ છેતરપિંડી નથી કરી રહી. તે સંકેત આપી રહી છે. તમારી પાસે માહિતી હતી. કાં તો તમે તે વાંચી કે નહીં.

જ્યારે તમે નિષ્ફળ જાઓ છો, ત્યારે ગેમ તમારો અનાદર કરે છે. તે અસહ્યતા જાણીજોઈને રાખવામાં આવી છે. કોઈ લીડરબોર્ડ કે સતત પ્રગતિ વગરની માઇક્રો-ગેમમાં, અપમાન એ ફરીથી રમવાની ઈચ્છા જગાડવાનું સાધન છે. તે ફીડબેક લૂપને પૂર્ણ કરે છે. તમે લેગને કારણે અથવા હિટબોક્સમાં ખામીને કારણે હારતા નથી. તમે હાર્યા કારણ કે તમે એક ધ્રૂજતા લાલ શબ્દ પર વિશ્વાસ કર્યો હતો, અને ગેમ એ સુનિશ્ચિત કરે છે કે તમે તે ભૂલનો અહેસાસ અનુભવો.

28KB નો વાસ્તવિક અર્થ શું છે

માત્ર એક 28KB ની HTML ફાઇલમાં બિલ્ડ કરવાનું પસંદ કરવું એ માત્ર કંઈક નવું કરવાનો પ્રયાસ નથી. તે એક ડિઝાઈન મર્યાદા છે જે તમને કઠિન નિર્ણયો લેવા માટે મજબૂર કરે છે. છુપાવવા માટે તમારી પાસે મેગાબાઇટ્સની સ્પ્રાઈટ શીટ્સ નથી. ટ્રિગર કરવા માટે કોઈ ઓડિયો ફાઇલો નથી. જે કંઈ પણ દેખાય છે તે HTML5 Canvas પર ફ્રેમ-બાય-ફ્રેમ દોરવામાં આવે છે. જે કંઈ પણ સંભળાય છે તે Web Audio ઓસિલેટર્સમાંથી આવે છે.

જો તમે સીધા Web Audio API સાથે કામ ન કર્યું હોય, તો તેનો અર્થ આ છે. પહેલેથી રેકોર્ડ કરેલ WAV અથવા MP3 લોડ કરવાને બદલે, કોડ એક AudioContext બનાવે છે, એક ઓસિલેટર નોડ જોડે છે, વેવફોર્મ પસંદ કરે છે — sine, square, sawtooth — અને ફ્રીક્વન્સી સેટ કરે છે. સાચા ઇનપુટ માટે એક ટૂંકી બીપ, અને નિષ્ફળતા માટે એક તીવ્ર બઝ. તે ટોન બ્રાઉઝર દ્વારા રીઅલ-ટાઇમમાં ગણવામાં આવે છે. તે ફાઇલ સાઈઝમાં કંઈ જ ખર્ચતા નથી અને કોઈ બાહ્ય નેટવર્ક રિક્વેસ્ટ ઉમેરતા નથી.

આ જ તર્ક વિઝ્યુઅલ્સ માટે પણ લાગુ પડે છે. Canvas તમને ઇમીડિયેટ-મોડ ડ્રોઈંગ સરફેસ આપે છે. તમે રેક્ટંગલ ક્લિયર કરો છો. તમે ટેક્સ્ટ ભરો છો. તમે શેક ઇફેક્ટ માટે ટ્રાન્સફોર્મ અથવા શેડો બ્લર સેટ કરો છો. ત્યાં કોઈ virtual DOM diffing નથી, કોઈ React reconciliation નથી, અને ડિબગ કરવા માટે કોઈ dependency array નથી. બ્રાઉઝર કોડ ચલાવે છે, અને પિક્સેલ્સ દેખાય છે. આટલી ફોકસ કરેલી ગેમ માટે, તે સીધી પ્રક્રિયા એક સુવિધા છે, મર્યાદા નથી.

પેલોડને 28KB પર રાખવાનો અર્થ એ પણ છે કે ગેમ મોબાઈલ બ્રાઉઝર પર લગભગ તરત જ લોડ થઈ જાય છે, ભલે કનેક્શન નબળું હોય. તેને હોસ્ટ કરવામાં લગભગ કંઈ જ ખર્ચ થતો નથી. આખી એપ્લિકેશન મોટાભાગની વેબસાઇટના ફેવિકોન (favicon) કરતા પણ નાની છે. જો તમે શેર કરેલી લિંક દ્વારા અથવા ફોરમ પર એમ્બેડ કરીને વિતરિત કરી રહ્યા હોવ, તો આ બાબત મહત્વની છે. ઇન્સ્ટોલેશનમાં કોઈ અવરોધ નથી. તમે URL ની મુલાકાત લો છો, અને જૂઠું બોલવા માટે ગેમ તૈયાર છે.

ન્યાયી છેતરપિંડી

જૂઠું બોલવાની મિકેનિક્સ પર વાસ્તવિક સમય વિતાવવાથી ગેમ ડિઝાઈન વિશે એક સૂક્ષ્મ સત્ય બહાર આવે છે. અન્યાય ત્યારે જ મજાનો હોય છે જ્યારે તે સમજાય તેવો હોય. કોઈ ચેતવણી વગર ખેલાડીને મારી નાખતો રેન્ડમ ટ્રેપ ખરાબ ડિઝાઇન છે. એવો ટ્રેપ જે ધ્રૂજે છે, રંગ બદલે છે અને સ્થાપિત વિઝ્યુઅલ લયને તોડે છે, તે એમ્બુશ (અચાનક હુમલો) તરીકે સજાવેલું એક કોયડો છે.

લાલ ધ્રૂજતું લખાણ અનેક હેતુઓ પૂરા કરે છે. તે ખેલાડીઓએ રાઉન્ડ એક થી પાંચ દરમિયાન વિકસિત કરેલા ટેવ મુજબના પ્રતિભાવને બદલી નાખે છે. તે અગાઉ જે માત્ર રિફ્લેક્સ ટેસ્ટ હતો, તેમાં ભાવનાત્મક તબક્કા — શંકા, ખચકાટ, ગભરાટ — ઉમેરે છે. અને સૌથી મહત્વનું એ છે કે, તે નિષ્ફળતાની જવાબદારી તમારી પોતાની હોવાનો અહેસાસ કરાવે છે. જ્યારે તમે તે લાલ કમાન્ડ પર ટેપ કરો છો અને અપમાન દેખાય છે, ત્યારે તમે જાણો છો કે ભૂલ તમારી છે. ગેમે તમને સંકેત આપ્યો હતો. તમે તે વાંચવામાં નિષ્ફળ રહ્યા.

This is the difference between a cheap shot and a fair fight. LIAR wants to punch you in the face, but it puts its weight behind the swing first.

Shipping Over Polishing

The game is rough. The author will tell you that themselves. It is their first finished game, and simplicity was the price of completion. That honesty is refreshing in an ecosystem where developers often blog about systems that never see production. LIAR exists at a live URL. You can play it right now. You can view the source in a single file without untangling a monorepo.

The developer wants to know two things from anyone brave enough to try it. First, how long do you survive? Second, when the first lie hits in round six, does it feel fair, or does it feel cheap? Those are the right questions to ask. They treat the lie not as a bug, but as a mechanic that needs tuning.

If there is interest, they have offered to write a deeper guide covering the Canvas drawing loop, the logic behind the Web Audio oscillators, and exactly how the lying mechanic is structured in code. Given how rare it is to see a full game inside one HTML file, that guide would be genuinely useful to anyone stuck in tutorial purgatory.

The Real Takeaway

You do not need a game engine to build a game. You do not need a content delivery network for assets, or a design document twenty pages long, or permission from a framework maintainer. You need a boundary — here, 28KB and a single file — and a reason to finish. Constraints force clarity. A shaking red word is more memorable than a thousand imported sprites when the mechanic underneath is solid.

Play LIAR for yourself at https://playliar.netlify.app/.
You can read the original developer breakdown and source context at https://dev.to/shabbir_sesaifee_8fdc587/i-built-a-game-that-lies-to-you-in-a-single-28kb-html-file-no-framework-no-assets-4hnh.