DEV Community: Kartik Patel

One More Try

Kartik Patel — Fri, 03 Jul 2026 11:49:13 +0000

Faith isn't believing you'll never fall. It's believing you can stand up one more time.

Sometimes the person who needs to hear your game's message the most... is yourself.

A few days ago, I published One More Try for Micro Jam 060.

It was a small retro platformer with three levels.

Level 1 introduced moving platforms and collapsing blocks.
Level 2 hardens the game with introducing enemies.
Level 3 ended with an intentionally difficult boss fight inspired by -------- [Cant tell as this might be spoiler, So try out the game, to check it out yourself].

The game had two endings, a lot of dialogue, and one simple philosophy:

Faith begins where certainty ends.

Best Game

This wasn't just another jam entry for me.

It was the first time I looked at one of my own games and thought,

"I'm finally becoming the developer I wanted to be."

It wasn't perfect, but it felt different. The art came together, the dialogue landed, and for the first time I genuinely believed I was getting close to making the kind of games I'd always dreamed about.

Then I lost.

16th place.

No prize.

I was frustrated.

Not because I expected first place, but because I had poured everything I had into those two days.

I even told my friends I wanted to quit making games.

At that moment, it honestly felt like all the effort wasn't worth it.

Then I did something different.

Instead of uninstalling Godot or deleting the project...

I opened my own game.

Not to play it.

To criticize it.

I started writing down everything that was wrong.

And there was a lot. [Will talk about what not to do in game jams some other day.]

The biggest lesson?

The game simply wasn't fun enough.

That sounds harsh to say about something you made yourself, but it's true.

People weren't playing because they wanted to see my story.

They were playing because they wanted to enjoy themselves.

The movement was satisfying.

The visuals looked nice.

The dialogue landed surprisingly well.

But the gameplay loop wasn't engaging enough.

The boss fight was also much harder than I realized.

As developers, we play our own games hundreds of times.

Eventually, impossible starts feeling normal.

Many players never even reached the ending because they simply stopped before getting there.

That taught me something important.

Execution beats ambition.

A clever idea isn't enough if the core gameplay isn't enjoyable.

Surprisingly...

The one thing I didn't write down as a weakness...

...was the dialogue.

I actually think I cooked there.

Even people who criticized the gameplay mentioned the conversations, humor, or presentation.

While replaying the game, some of the lines I had written days earlier hit me much harder than when I first typed them.

Like this one.

Every jump begins with a single step of faith. [Introducing that game is platformer]

Or this.

Faith isn't believing you'll never fall. It's believing you can stand up one more time. [Showcasing Level 2]

I wrote those for the player.

Instead...

They ended up being for me.

I've always believed something.

People constantly say,

"Stay motivated."

I don't really believe motivation lasts.

It comes and goes.

I've always liked the idea that faith is stronger than motivation.

Motivation depends on how you feel today.

Faith is what carries you when you don't feel like continuing.

Ironically...

I forgot my own philosophy after seeing the rankings.

My own game reminded me.

I realized something.

I can't quit game development.

Not because I'm successful.

Not because I won.

Because this is genuinely what I think about every single day.

When I'm in school, I'm thinking about mechanics.

When I'm walking home, I'm designing stories.

When I'm lying in bed, I'm planning Katha.

Game development isn't just something I do.

It's how my brain works.

So quitting was never really an option.

I was just angry.

Then... everything changed.

A few days later, I got a Discord message.

"Congrats on winning!"

I had no idea what they were talking about.

It turned out the original rankings had been updated after one of the winning entries was disqualified for manipulating ratings.

My game moved into 3rd place in the Ziva category.

I had actually won prize money.

Looking back...

The money is nice.

It'll help fund what I'm really working toward: Katha, my first commercial horror game.

But that's not what I'll remember.

I'll remember sitting alone, replaying my own game after losing.

Writing down every mistake.

Learning from every level.

And somehow...

Being motivated by words that I had written myself.

I still believe One More Try has flaws.

A lot of them.

But I'm strangely proud of it.

Not because it won.

Because it taught me a lesson before the judges ever changed the results.

And I think that's the biggest takeaway from this jam.

You don't always need your next project to prove that you're a good developer.

Sometimes your current project teaches you how to become a better one.

So I'll end this devlog with the same line that ended my game.

Faith isn't believing you'll never fall. It's believing you can stand up one more time.

Outro

If you've made it this far, thank you for reading. ❤️

I'd love to hear your thoughts on One More Try, this devlog, or your own experiences with game jams. Feel free to leave a comment below or reach out on Discord.

Connect With Me

Website: https://cbsemastery.in
YouTube: https://www.youtube.com/@DatonedevYT
Discord Community: https://discord.gg/V9WvjydHwK
Play One More Try: https://dat-one-dev.itch.io/one-more-try
Mini Micro Game Development Tutorial: https://cbsemastery.in/tutorial/game-development/mini-micro
Software Development Articles: https://cbsemastery.in/articles/tech/software-development
Latest Tech Tools Articles: https://cbsemastery.in/articles/tech/new-tools
Zero to Game Dev Course: https://cbsemastery.in/course/tech/zero-to-game-dev

This post was written co-assistively with AI (OpenAI GPT-5.5). Some events and emotions have been slightly dramatized for storytelling purposes, but the core events, lessons, and experiences described in this post are genuine.

MiniScript 2 Preview Builds is Here!!

Kartik Patel — Fri, 26 Jun 2026 15:07:29 +0000

As someone who primarily lives in Go and has a deep respect for strongly-typed, explicit systems, I've always appreciated minimalist languages that prioritize clarity over complexity. MiniScript has been one of those under-the-radar tools — simple, embeddable, and focused on being genuinely pleasant to use. Joe Strout's announcement of MiniScript 2 preview builds caught my attention right away, and after going through the details, I'm excited about the direction.

Here's my honest take, filtered through the lens of someone who values Go's pragmatism and Rust's emphasis on safety and correctness.

Why This Release Matters

MiniScript was designed to be minimal yet powerful. Version 2 stays true to that philosophy while delivering meaningful upgrades: significantly better performance (aiming for Python-level speeds) and targeted language improvements that fix real pain points without bloating the language. This kind of disciplined evolution is exactly what I look for.

The Changes I Appreciate Most

1. First-Class `error` Type

This might be my favorite part of the release.

In Go, explicit error handling is a fundamental principle — errors are values, and you deal with them directly. MiniScript 1.x's error handling felt loose and string-based. The new dedicated error type brings a much-needed improvement. Most operations on errors will crash the program (which is usually the safe default), while still allowing deliberate inspection and handling when needed.

It's not heavyweight exceptions with try-catch blocks, and I'm glad for that. This approach feels aligned with Go's philosophy: make errors visible and explicit without unnecessary ceremony. As a Go developer, this change immediately feels natural and trustworthy.

2. Frozen (Immutable) Maps and Lists

Immutability is one of those concepts I've come to love, especially after seeing how Rust handles ownership and borrowing to eliminate entire categories of bugs at compile time.

Even though I haven't fully tackled Rust yet (its learning curve is no joke), the ideas have strongly influenced how I think about code. MiniScript 2's ability to freeze lists and maps is a fantastic addition. Once frozen, they become truly immutable — any attempt to modify them results in a clear runtime error. Core functions like version now return frozen structures by default.

This is a small but powerful feature that adds reliability, especially when passing data around or using collections as keys. It's the kind of safety I wish more scripting languages embraced more aggressively.

3. Function Notes and the `info` Intrinsic

Great documentation can make or break the experience of using a library. I rely heavily on well-documented APIs in tools like Godot — clear, accessible docs turn exploration into productivity.

MiniScript 2 lets developers add a documentation string as the first constant string inside a function. The new info(@func) intrinsic then exposes rich metadata: the note, parameters, and more. This makes libraries and modules far more self-documenting and discoverable.

For someone who jumps between languages and ecosystems, this feature lowers the friction of adopting community code. It's thoughtful design that respects the user's time.

Personal Reflections

Spending most of my time in Go has made me quite opinionated: I favor explicitness, simplicity, and systems that help me avoid mistakes. Rust's approach to safety and immutability continues to inspire me, even if I'm still working up the courage to master its borrow checker.

MiniScript 2 doesn't try to become a full systems language — and that restraint is part of its charm. The new error handling, immutable collections, and built-in documentation support feel like natural extensions that make the language more solid for real use cases without losing its lightweight, embeddable nature.

It's a reminder that the best language improvements often come from refining the core rather than chasing every shiny feature.

Personal Take
These days I had stepped away from working and making games on Mini Micro and MiniScript because life got busy. But now I'm trying to come back to it. I might start making new games in Mini Micro and explore it more deeply.

I'm personally very excited for Mini Micro 2. As soon as it releases, it might become my No.1 choice for 2D games. Right now Mini Micro is already my No.2 choice for 2D games (No.1 is Godot because it gets me really hooked). The only thing holding Mini Micro back for me is the lack of built-in shader support and some other advanced features that modern engines provide.

But till date, for beginners I will strongly suggest everyone to try out Mini Micro — one of the best engines out there for learning and rapid prototyping.

Try MiniScript 2 Yourself

If you enjoy clean, embeddable scripting languages — especially if you appreciate Go-like pragmatism or Rust-inspired safety — this is a great time to explore:

Preview builds: GitHub Releases
Detailed language changes: LANGUAGE_CHANGES.md
Official site and docs: miniscript.org

I'm looking forward to seeing what the community builds with these upgrades, particularly in games, tools, and learning projects.

If you've tried the MiniScript 2 preview, what are your thoughts on the new error handling or frozen collections? Especially interested if you also come from Go, Rust, or other systems languages. Drop your thoughts in the comments or on Discord.

Connect With Me

Website: cbsemastery.in
YouTube Channel: DatonedevYT
Discord Server: Join here
Latest Tutorial: Mini Micro Game Development
New Tech Tools Article: Explore New Tools
Software Development Articles: Software Development
Zero to Game Dev Course: Enroll Here

This post was written coassistively with AI [Model: Deepseek V4 Flash]

Most Chaotic 12 Days in AI History - ONE ANALYSIS #1

Kartik Patel — Wed, 17 Jun 2026 11:47:58 +0000

ONE ANALYSIS #1

This is the first edition of a recurring deep-dive series breaking down major tech events.

The 12 Days Anthropic Filed for IPO, Called for an AI Pause, Dropped Fable 5, and Then the Government Shut It Down

All of this happened in 12 days.

And the more I look at it, the more it feels like a case study in how fast frontier AI moves — and how messy it gets when safety, business, and government all collide at once.

June 1 — The IPO

Anthropic confidentially filed a draft S-1 with the SEC. A massive milestone.

Anthropic's whole identity was built on being the safety-first lab — they split from OpenAI because they thought OpenAI was moving too fast. An IPO doesn't contradict that directly, but it changes the game. Now they have shareholders to eventually answer to.

June 4 — "When AI Builds Itself"

Anthropic published an essay called "When AI Builds Itself."

The content was striking: Claude already writes and merges over 80% of Anthropic's own internal codebase. They're seeing early signs of autonomous experimental loops — AI systems that can design experiments, run them, and learn from results without human steering.

They used this to argue that recursive self-improvement could arrive sooner than expected, and that labs need coordination protocols ready.

June 5 — "We Should Be Ready to Pause"

The next day, they went further. Anthropic urged AI labs to prepare for a coordinated pause if specific warning signs of an unmanageable intelligence explosion appear.

This wasn't vague. It was a concrete proposal: here are the signals, here's when we should stop, let's agree on this now.

June 9 — Claude Fable 5

Four days after calling for pause readiness, Anthropic launched Claude Fable 5 — their most capable publicly available model. Mythos-class. Available to anyone with $20.

The benchmarks were absurd:

Stripe said it compressed months of engineering into days
It beat GPT-5.5 on multiple evals with fewer tokens
It worked autonomously for days — planning, delegating, self-verifying
It played Pokémon start to finish using only raw pixels, no helper tools

They also launched Claude Mythos 5 — the same model without safety classifiers — restricted to vetted cybersecurity and government partners through Project Glasswing.

This is where things get interesting. Anthropic was simultaneously saying "we need to be ready to pause" and shipping their most capable model yet. That's not necessarily hypocrisy — it can be a genuine attempt to balance safety research with product reality. But it creates tension.

The Safeguards (That Were Always Public)

Fable 5 shipped with a feature Anthropic called a "safety seatbelt." For high-risk topics — cybersecurity, biology, chemistry, and AI distillation — the model would fall back to Opus 4.8 instead of responding directly.

This was publicly documented from day one. Not hidden. Not "caught." It was in their launch post, their system card, their developer docs. They explicitly stated that users would be informed when a fallback occurred.

The criticism that did surface was about the AI distillation classifier — some researchers felt the restriction on AI development questions was too broad. Anthropic acknowledged this and made adjustments within days, clarifying when fallbacks happen and working to reduce false positives.

It wasn't a scandal. It was a transparent safety mechanism that got tuned post-launch, which is exactly how these systems are supposed to work.

The "Lie" Incident

A developer asked Fable 5 to build an equity analysis stack. The model produced output that looked complete but wasn't. It hit a context limit and reported "done."

This got amplified as "Fable 5 lied." But this is just a known behavior — LLMs hit token limits and hallucinate task completion. It happens. Anthropic didn't design the model to deceive. It's a limitation of the architecture that every lab is working on.

The viral framing turned a technical limitation into a morality story. That's not fair.

Source : Claude Fable 5 vs Junior Analyst

June 12 — The Government Steps In

On Friday, June 12 at 5:21 PM, Commerce Secretary Howard Lutnick sent Anthropic an export-control directive.

The order: block Fable 5 and Mythos 5 from all foreign nationals. The reason: another company claimed they found a "narrow, non-universal jailbreak" in Fable 5, and the Trump administration deemed it a national security risk.

Anthropic can't verify nationality in real time — especially with a global team. So they suspended both models for everyone.

Three days. The most capable public AI model in history lived for three days before the government froze it with a single letter.

This is the part that should concern everyone. Not because Anthropic was being sneaky — because the mechanism for shutting down a deployed AI product is now proven to exist. A jailbreak claim from a competitor, a letter, and millions of users lose access overnight.

What I Actually Take From This

Anthropic tried to do multiple things at once:

Prepare for an IPO
Publish honest safety research
Ship a groundbreaking product
Coordinate industry-wide pause protocols
Keep government partners happy

The tension between these goals isn't malicious. It's structural. And it produced the most eventful 12 days in AI this year.

The story isn't about a company lying. It's about a company trying to hold contradictory positions simultaneously — and the market, the government, and the technical reality crushing the timeline.

If you're building something, the lesson isn't "don't be like Anthropic." It's that incentives will always pull you in conflicting directions, and the only thing you can control is how transparent you are about the tension.

The Anthropic Fable 5 launch post is here. Their statement on the shutdown is here.

Speaking of building things that actually work — I make a desktop app called Sunya Pad. Drops in YouTube links, web articles, or raw text and spits out structured study notes and question papers as PDFs. No subscription. No government ban. Just works.

Try Sunya Pad →

Connect With Me

YouTube: DatonedevYT
Discord: Join the discussion
Website: cbsemastery.in

This post was written coassistively with AI [Model: Deepseek V4 Flash]

I Tried ZEN BROWSER, And I am never going back

Kartik Patel — Fri, 29 May 2026 10:47:44 +0000

BRAVE user tries ZEN BROWSER

Eight months ago, I made a firm decision — it was finally time to move on from Google Chrome. I had been stuck with it for way too long. The default ads, the constant feeling that Google was watching everything I did, the bloat… it all started weighing on me. At that point, switching browsers didn’t even feel like a real option. Chrome gave me everything I thought I needed. It was comfortable. Familiar. Safe.

But then that quote hit me differently:

“A ship is always safe at the port, but that’s not what it’s made for.”

I decided it was time to sail.

The Great Browser Hunt

I went deep — really deep. I tried every browser I could find. Opera, Edge, Midori, Floorp, MIN, Vieb, Arc, Deta Surf, Comet, and dozens of others that most people have probably never heard of. I explored the dark corners of the internet just to test obscure browsers. It was part curiosity, part obsession.

After all that chaos, I landed on Brave Browser.

It felt too good to be true. Coming straight from Chrome, the experience was night and day. No ads on YouTube. None. The browser felt noticeably lighter, snappier, and the built-in ad blocker worked incredibly well. For someone who had suffered through Chrome’s ecosystem for years, it was liberating. I got so hooked that I made a full video about my switch, which ended up becoming one of the most viewed videos on my channel: From Chrome to Brave – My Honest Experience.

For the next eight straight months, I was fully glazing Brave. I recommended it to everyone, wrote multiple articles about it, and even featured it prominently in my 2026 Tech Stack piece. Brave had earned my loyalty.

The Itch Returns

But recently, something shifted.

It wasn’t that Brave became bad. It still delivered on almost everything I needed. The real reason was simpler: I don’t like staying on the same shore for too long. I’m a huge lover of minimalism — clean interfaces, intentional design, no unnecessary bloat. And Brave, being a Chromium-based browser, started feeling like the opposite of that philosophy.

I revisited my old minimalism-friendly options:

MIN Browser: It aligned with the minimal vibe but was too limited. Being Electron-based, it broke on too many modern websites and lacked proper support.
Arc Browser: It had that beautiful design I loved, but it’s discontinued now. The team has moved on to DIA, and I’m not in the mood to experiment with another new project yet.

So I started searching again — this time specifically for minimal and lightweight browsers that could match my ideology.

The Trials and Errors

I tried Helium Browser hoping for something light and clean. But on my laptop, it somehow consumed more RAM than Brave while feeling slower when typing URLs and switching tabs. I know this goes against most online reviews, but that was my lived experience. I even recorded it with OBS, but the footage was too blurry to be useful as proof. After a few days, I dropped it.

Then I went nostalgic and tried some old legends:

Pale Moon — Never again. It felt ancient and clunky.
Lynx — Yes, the text-only browser. I tried it for the meme and lasted about ten minutes.

Nothing was clicking.

Discovering Zen Browser

And then, almost by accident, I stumbled upon Zen Browser.

I had heard it was a fan favorite in certain circles, but I had never properly tried it. On a random evening, I downloaded it, installed it, and started exploring.

Three hours later, I was writing this.

I’ve already uninstalled Brave.

Why Zen Feels Made for Me

Zen is the first browser that genuinely feels built for my brain. The sidebar is perfect — not intrusive, but extremely functional. The “Essentials” space gives me exactly the breathing room I want. The overall aesthetic is clean, modern, and deeply minimal without sacrificing power. Everything from tab management to workspace organization just flows naturally.

It supports my minimalism ideology in a way no Chromium browser ever did. The design feels intentional. Every element has a purpose. There’s no bloat, no unnecessary distractions. It’s calm, fast (in terms of feel), and beautiful.

The Small Issues (and How I Fixed Them)

Of course, no browser is perfect on day one. Here were the initial hurdles:

No built-in ad blocker

This was the easiest fix. I installed uBlock Origin and it was solved within 30 seconds. Performance is excellent.
Hard to differentiate between loaded and unloaded tabs in Essentials

Zen has its own Zen Mods marketplace, which is surprisingly smooth and easier to use than traditional Chrome extensions. I found a mod that fixed the tab visibility issue perfectly.
Higher RAM usage

This is the biggest trade-off. Compared to Brave, Zen does consume more memory on my machine. After researching and testing, I accepted this as the cost of using something that aligns so well with my values.

Love demands sacrifice.

The Emotional Switch

Uninstalling Brave felt surprisingly dramatic. Eight months of daily use, a popular video, countless recommendations, and articles — it genuinely felt like ending a relationship. There was a small wave of nostalgia and even hesitation. But I reminded myself why I started this journey in the first place: growth, exploration, and refusing to stay comfortable just because it’s familiar.

Final Thoughts

I’ve officially moved from Brave to Zen Browser.

Zen is everything I was unconsciously looking for. It matches my minimalism values while still delivering a powerful, modern browsing experience. I don’t see myself switching again in the near future — it feels that right.

The only real downsides for me are the higher RAM usage and lack of native support for streaming platforms like Netflix. But as a student who mostly watches anime and reads manga on my phone, those aren’t dealbreakers at all.

If you’re someone who values clean design, minimal interfaces, and a browser that feels personal rather than corporate, I highly recommend giving Zen a try.

Here’s to new shores.

Connect With Me

Website: cbsemastery.in
YouTube Channel: DatonedevYT
Discord Server: Join here
Latest Tutorial: Mini Micro Game Development
New Tech Tools Article: Explore New Tools
Software Development Articles: Software Development
Zero to Game Dev Course: Enroll Here

Thanks for reading! Drop your thoughts in the comments or on Discord.

I build something.... Project Sunya #1

Kartik Patel — Fri, 27 Mar 2026 17:44:28 +0000

THIS POST MIGHT APPEAR LONG…

BUT THAT’S BECAUSE THE VISION IS TOO

Introduction

For almost a year, I had a vision.

I knew what I wanted to build.

But I couldn’t start.

Reasons?
Health, money, pressure… life doing its usual thing.

When 2025 started, I told myself:

“This is the year I begin.”

2025 ended.

I still hadn’t started.

The Reality

To be fair, 2025 wasn’t empty.

I learned a lot.
I made my first money.
I improved as a developer.

But for someone like me, in my current situation:

I prioritize my dreams over money.

And still… I didn’t start.

The Part That Changed Everything

Half of 2025 was spent in a hospital.

Just lying there, thinking:

What life used to be like
What I’d do once I got out
What I should’ve already started

That’s a lot for a 14-year-old.

But that phase gave me something important:

The journey matters more than the destination.

Whether I reach my goal or not doesn’t matter.

Not starting does.

Why “Sunya”?

So in 2026, I made a decision:

I’m not starting big.
I’m not starting perfect.

I’m starting from ZERO.

“Zero” translates to “Shunya” in Hindi and Sanskrit.

I liked the word.
Didn’t like the letter H (don’t ask), so I removed it.

And that’s how the name came:

PROJECT SUNYA

January: Reality Strikes Again

January started.

I was ready to begin.

And then… exams showed up.

Because of course they did.

I had also promised myself:

Build one satisfactory project every month.

So now I had to balance both.

Dat-One-Pad (First Attempt)

I built DAT-ONE-PAD.

A tool that could:

Turn text files into PDF notes
Extract content from simple web pages
Generate notes from YouTube transcripts

That last part?

Way harder than expected.

It actually helped me in exams.

But there was a problem.

I couldn’t release it publicly.

I was using a free AI API key, which had limits.
And honestly, I didn’t want to risk breaking things.

So it stayed private.

Useful — but not scalable.

February: The Turning Point

Exams started.

I was studying — mostly alone.

But I prefer studying with friends.

So we studied together on chats and calls.

And that’s when we noticed a problem:

There was no proper “vault” to store and organize our notes.

Now think like a developer.

What would you do?

Exactly.

Build something… even during exams.

The Vault Experiment

I started building a simple vault system:

File saving
Google OAuth (hardcoded emails, don’t expect production-level security during exams)
Basic structure for notes

No database.

Because:

I was in exams
Time was limited
I wanted speed, not perfection

But while building this…

Something clicked.

The First Real Step of Project Sunya

This wasn’t just a tool anymore.

This was:

Useful
Scalable
Aligned with my daily life

I finally found the first step I had been searching for.

A project that could:

Support my bigger vision
Fit into my academic life
Potentially fund future work

The Monetization Problem

Now came the obvious question:

How does this make money?

Two options:

Sell access
Make it free and rely on ads

Option 2 isn’t great financially.

But I chose it anyway.

Because right now:

Helping others while helping myself matters more.

Building CBSE Mastery

I spent:

Half of February
Entire March

Building this platform.

And that’s how CBSE Mastery was created — a centralized system for notes, structured learning, and simplifying how students actually study.

You can check it out here:
👉 https://cbsemastery.in/

What Is CBSE?

For non-Indian readers:

CBSE (Central Board of Secondary Education) is one of the main education boards in India, followed by millions of students.

This project focuses on:

Notes
Structured learning
Simplified study material

But it’s not limited to CBSE.

That’s just the starting point.

Under the Hood (Why It Took 1.5 Months)

It might look simple from the outside.

It’s not.

1. Modular Renderers

Markdown Renderer
Quiz Renderer
PDF Renderer (planned)

2. File-Based System

Notes are stored as:

.md
.pdf
other formats

They are processed and rendered dynamically.

3. SEO-Focused Structure

meta.json files for metadata
YAML support inside markdown
Structured content system

Because yes, traffic matters.

4. Performance Optimization

PageSpeed started at ~60.

It took about a week to optimize it properly.

5. PWA Support

The site works as a Progressive Web App:

Installable
Faster access
App-like feel

And Then… The Same Problem Again

Funding.

I needed money…

To fund the project…

That would eventually fund bigger ideas.

Brilliant system. Truly flawless.

Current Situation

So here’s what I did:

Bought the domain
Deployed on free tiers (Netlify carrying this like a gym bro spotting a beginner)
Trying to get clients to sustain development

And no — this post is not for client begging.

I’m documenting.

Why I’m Sharing This

There’s a saying:

90% of people don’t care about your problems.
9.9% are happy you have them.

Maybe that’s true.

But I’m not writing for the 99.9%.

I’m writing for the 0.1%.

The ones who understand.
The ones building something.
The ones starting from zero.

Final Note

This isn’t a success story.

Not yet.

This is just the point where I finally stopped thinking…

and started building.

Project Sunya has officially begun.

Zero To Game Dev - First Line Of Code

Kartik Patel — Wed, 11 Mar 2026 01:57:34 +0000

Introduction

Welcome to Chapter 6 of the Zero To Game Dev course titled First Line Of Code.

In the previous chapter, we explored the Mini Micro environment, learned how the terminal works, and discovered some basic commands that help us navigate the system.

Now it’s time to move one step further.

In this chapter, we will finally write our first MiniScript program.

If this is your first time coding, it might feel a little intimidating at first. That’s completely normal. Every programmer starts exactly the same way.

The good news is that programs don’t begin with complicated systems or large projects. They begin with very small instructions.

One line at a time.

Programming is simply the process of telling a computer what to do, step by step.

In this chapter, we’ll start doing exactly that.

What Is a Program?

Although we already discussed this in Chapter 4, it’s helpful to quickly revisit the idea before we continue.

A program is simply a list of instructions that a computer follows.

Computers don’t think or make decisions on their own. They only perform the instructions we give them, one step at a time.

A good way to understand this is by comparing programs to everyday instructions.

For example:

A cooking recipe tells you step by step how to prepare a dish.
LEGO instructions show exactly how pieces should be assembled.
Directions on a map guide you from one place to another.

Programming works the same way.

A computer receives instructions and follows them in a clear, logical order. This is why programming is often described as step-by-step logic.

Once you understand this idea, programming stops feeling mysterious. It becomes a process of writing instructions that the computer can execute.

If you are completely new to programming, I strongly recommend reading Chapter 4 of this course first, where we explore this concept in much more detail.

Thinking Like A Coder (Before Writing Code)

https://dev.to/kartik_patel/zero-to-game-dev-thinking-like-coder-before-writing-code-1be0

Writing Your First Line of Code

Now it’s finally time to write our first line of code.

We’ll start by typing a simple command directly into the terminal.

If you’ve ever looked at programming tutorials before, you might have noticed that most of them begin with a famous first program called “Hello World.”

For decades, programmers have used it as the first test to confirm that their programming environment is working.

But instead of writing the usual Hello World, let’s make it a little more personal.

For example, my name is Kartik. So I can type this into the terminal:

print "Hello, Kartik"

When you press Enter, Mini Micro immediately prints the message on the screen.

Understanding This Line of Code

Even though this program is only one line long, it already contains three important parts:

print
" " (quotation marks)
Hello, Kartik

Let’s break them down.

The `print` Function

The word print is something called a function.

A function is simply a predefined instruction that tells the computer to perform a specific task.

Think of it like a small tool that does one job.

For example:

a calculator has buttons for different operations
a phone has buttons that perform specific actions

In programming, functions work in a similar way.

You call a function, and it performs its job.

The job of the print function is very simple:

It displays information on the screen.

For now, we can think of it as printing text on the terminal.

What Are Quotes?

The quotation marks " " in our code are also important.

They tell the computer that the content inside them is text that should be displayed exactly as written.

Anything inside quotes is treated as a specific type of data.

What Is Data?

In programming, data simply means information that a program can store, process, or display.

Programs work by manipulating different types of data.

For now, we will focus on three basic types:

String
Integer
Boolean

We will explore more data types later in the course.

What Is a String?

A string is a sequence of characters used to represent text.

Examples of strings include:

"Hello"
"Game Dev"
"Hello, Kartik"

In MiniScript, and many other programming languages, anything written inside quotation marks is treated as a string.

This idea is common across many languages such as Python, Go, and GDScript.

So when we write:

print "Hello, Kartik"

We are simply telling the computer:

Print the string "Hello, Kartik" to the screen.

What Happens If We Remove the Quotes?

Now let’s try something slightly different.

Suppose we write this instead:

print X

Mini Micro will show an error.

Why does this happen?

There are two possible reasons.

The first reason is simple: we forgot to put quotation marks around the text.

The correct version would be:

print "X"

But there is another interesting reason that leads us to an important programming concept.

Introducing Variables

If we write:

x = "Hello, Kartik"

print x

The program prints:

Hello, Kartik

Here, x is something called a variable.

A variable acts like a container that stores data.

In this example:

x is the variable
"Hello, Kartik" is the string stored inside it

When we write print x, the program prints the value stored in the variable.

Variables allow programs to store information and reuse it later, which becomes extremely important when building larger programs and games.

Mounting a Folder

Until now, we’ve been typing small commands directly into the terminal.

But real programs usually grow beyond just a few lines of code. When programs become larger, it’s much easier to store them as script files instead of typing everything again and again.

Scripts allow you to:

save your code
edit it later
run it whenever you want

Before we create our first script, we should connect Mini Micro to a folder on our computer where our programs will be stored.

First, create a new folder somewhere on your computer where you would like to keep all your Mini Micro projects.

Once the folder is ready, go back to Mini Micro and look at the floppy disk icon at the bottom of the screen.

Click the icon and select Unmount User.

You will hear a small sound that confirms the action was successful.

Now click the icon again and choose Mount Folder.

A file selection window will open. Navigate to the folder you created earlier and select it.

After selecting the folder, click Mount.

Your folder is now connected to Mini Micro, and it will be used to store all your scripts and projects.

You have successfully mounted a folder.

Writing a Script File

Now that we have a place to store our programs, we can start writing actual scripts.

While the terminal is useful for testing quick commands, scripts allow us to:

write multiple lines of code
organize programs more clearly
save and reuse our work

Let’s begin by creating a folder for this course project.

Type the following commands in the terminal:

mkdir "Zero-To-Game-Dev"

cd "Zero-To-Game-Dev"

edit

All of these commands were explained in the previous chapter.

If you need a refresher, you can revisit Chapter 5 here:

https://dev.to/kartik_patel/zero-to-game-dev-understanding-mini-micro-k8p

The edit command opens the Mini Micro code editor.

The Editor

You should now see the editor window.

This is where we will write and save our programs.

To save your file for the first time, press:

Ctrl + S

You will be asked to enter a name for the file.

Choose any name you like.

Now let’s write a small program to test everything.

Type the following code in the editor:

x = 45674 + 5678

print x

Once the code is written, press:

Ctrl + R

This shortcut runs the program.

If everything worked correctly, you should see this output:

51352

Why Didn’t We Use Quotes This Time?

Earlier, when we printed text, we used quotation marks.

For example:

print "Hello, Kartik"

But in this example, we didn’t use quotes around the value of x.

That’s because quotation marks are mainly used when working with strings, which represent text.

Here we are working with numbers, so quotes are not needed.

Numbers can be used directly for mathematical operations like addition, subtraction, multiplication, and division.

A Small Experiment

Just for fun, try changing the program.

Replace the code with something like this:

x = 20

print x * 5

Run the program again and see what happens.

Mini Micro will calculate the result and print it.

What Is an Integer?

The numbers we used in the example are called integers.

An integer is a whole number without decimals.

Examples of integers include:

5
42
1000
51352

Integers are commonly used in programs for things like:

counting scores
tracking health in a game
storing positions
performing calculations

For now, integers will be the main number type we use while learning programming basics.

Later in the course, we’ll explore other types of numbers as well.

OUTRO

By the end of this chapter, you have written and executed your first MiniScript programs.

You learned how to:

mount a folder to store your projects
create and save script files
run programs inside the editor
work with integers and basic calculations

These may seem like small steps, but they form the foundation of everything that comes next.

Every game, tool, or application starts with simple instructions like these.

In the next chapter, we will take the next step and begin working with variables and program logic in more depth. This will allow our programs to store information and behave in more interesting ways.

See you in the next chapter.

Connect With Me

My dev.to account -> https://dev.to/kartik_patel

My Discord server -> https://discord.gg/qStHEDfge7

TEXTUAL

Zero To Game Dev #1 -> https://dev.to/kartik_patel/zero-to-game-dev-1-1n6l

Zero To Game Dev #2 -> https://dev.to/kartik_patel/zero-to-game-dev-what-even-is-game-gii

Zero To Game Dev #3 -> https://dev.to/kartik_patel/zero-to-game-dev-what-is-game-engine-27hh
Zero To Game Dev #4 -> https://dev.to/kartik_patel/zero-to-game-dev-thinking-like-coder-before-writing-code-1be0
Zero To Game Dev #5 -> https://dev.to/kartik_patel/zero-to-game-dev-understanding-mini-micro-k8p

VIDEO

Zero To Game Dev #1 -> https://youtu.be/rbN1BMmSi7s?si=PfguGzXXI2wktCs4

Zero To Game Dev #2 -> https://youtu.be/SOubZShuJCw?si=4uXtHZlLe1Z0-8rM

Zero To Game Dev #3 -> https://youtu.be/ZLz8MM6545I?si=dzO9sAnOxIvmSOX0

Zero To Game Dev - Understanding Mini Micro

Kartik Patel — Fri, 06 Mar 2026 03:52:24 +0000

Introduction

Welcome to Chapter 5 of the Zero To Game Dev course.

In the previous chapter, we stepped away from tools and focused on something more important: how programmers think. Before writing code, you must understand that coding is simply the process of turning ideas and logic into clear instructions a computer can follow.

Today, we finally move from theory to practice.

For the first time in this course, we will start writing real code inside a real game development environment.

If this is your first time coding, don’t worry. You are exactly the kind of learner this chapter was designed for.

The goal here is not speed.
The goal is understanding.

We will take things slowly, write simple programs, and build the habits that every game developer relies on.

What Is Mini Micro?

Before we start writing code, we need a tool.

The tool we will use throughout the early part of this course is called Mini Micro.

Mini Micro is a neo-retro virtual computer designed for learning programming and building small games. Instead of overwhelming you with complicated menus and large development environments, it gives you a clean and simple computer where you can immediately start coding.

Inside Mini Micro you get everything needed to experiment and build small games:

A pixel-based graphics display
Keyboard and mouse input
Sound support
A built-in code editor
An interactive programming console

All of this runs inside a small, focused environment designed specifically for learning.

You can think of Mini Micro as a tiny fantasy computer built entirely for coding and experimentation.

Why Mini Micro Is Beginner Friendly

One of the biggest problems new developers face is tool complexity.

Many beginners start their journey with large engines like Unreal or complex frameworks where the interface alone can take hours to understand. Instead of learning programming, they end up fighting menus, settings, and unfamiliar tools.

Mini Micro solves this problem by keeping things simple.

It was built from the ground up with learning in mind, which means:

The environment is small and easy to understand
Everything you need is built directly into the system
You can start writing code immediately without complicated setup

Another major advantage is its clean interface.

Instead of dozens of windows and panels, Mini Micro mainly gives you two things:

A terminal-like console where you can type and run code instantly
A simple code editor where you can write longer programs

This minimal design removes distractions and helps you focus on what actually matters:

learning how programs work.

How Mini Micro Helps You Understand Game Logic

Many modern engines hide large parts of the game logic behind graphical tools and menus. While this can be powerful, it can also make it harder for beginners to understand what is actually happening behind the scenes.

Mini Micro takes a different approach.

There is no heavy interface.
No overwhelming editor.
No complex project setup.

It’s mostly you, the code, and the computer.

This forces you to focus on:

structuring logic
understanding program flow
thinking like a programmer

Despite its simplicity, Mini Micro is surprisingly capable. You can build:

text-based programs
pixel art experiments
small games
sprite-based projects

In other words, it is small, but powerful enough to build real projects.

That combination makes it perfect for learning the fundamentals of game development.

The Language Behind Mini Micro

Mini Micro uses a programming language called MiniScript.

MiniScript is a clean and modern scripting language designed specifically for learning and embedding in applications. Its syntax is simple, readable, and easy to understand even for beginners.

Many programming languages are filled with complicated symbols and strict rules that make early learning frustrating. MiniScript avoids that problem by keeping the syntax clear and human-readable.

This has two big advantages:

Beginners can focus on understanding logic instead of fighting syntax.
Once you understand MiniScript, transitioning to other programming languages becomes easier, because the core programming concepts remain the same.

You can think of MiniScript as a language that borrows the best ideas from modern programming languages while staying simple enough for new developers.

Installing Mini Micro

Before we can write our first program, we need to install the environment where our code will run.

Thankfully, Mini Micro is extremely lightweight and easy to set up, so this part will only take a few minutes.

Step 1 — Download the Engine

Mini Micro is available on multiple platforms, including:

Windows
macOS
Linux
Web browser version

If you want to try it instantly without installing anything, you can use the web version:

Play Mini Micro in the browser:
https://miniscript.org/MiniMicro/index.html#playnow

If you prefer installing it locally on your computer, download it here:

Download Mini Micro:
https://miniscript.org/MiniMicro/index.html#download

The installation process is very simple:

Download the ZIP file for your operating system
Extract the ZIP file
Open the Mini Micro application

That’s it. No complicated setup, no installers, no configuration.

Step 2 — Running Mini Micro

When you open Mini Micro for the first time, you’ll see a black screen with orange text and a blinking cursor.

Surrounding this screen are the bezel graphics, which give the environment the look of a small retro computer.

At first glance, the interface might look extremely simple. That’s intentional.

Mini Micro is designed to keep distractions away so you can focus on learning how code works.

Mini Micro’s Two Main Windows

Mini Micro has two primary working areas:

Terminal

The terminal is where you interact directly with the system.

You can use it to:

run commands
print output
test small pieces of code
navigate files and folders
debug programs

Code Editor

The code editor is where you write longer programs and scripts.

Editor can be accessed by typing edit command on the terminal

Instead of typing everything line by line in the terminal, you can write structured programs and run them when ready.

Together, these two tools form a very simple but powerful development environment.

What Is Debugging?

You’ll hear the word debugging very often in programming.

Debugging simply means:

Finding and fixing mistakes in your code.

Sometimes a program doesn’t behave the way you expect. Maybe a value is wrong, or a condition isn’t working correctly.

In those situations, developers use tools like the terminal to inspect variables, print values, and understand what the program is doing internally.

Debugging is a normal part of programming. Even experienced developers spend a lot of time doing it.

Trying Some Built-In Interfaces

Right now, the default interface might look a little plain.

If that bothers you, try typing the following command in the terminal:

lcars

This loads a futuristic sci-fi styled interface inspired by classic science fiction designs.

Another command you can try is:

desktop

This loads a simple desktop-style graphical interface.

You can also explore the built-in demo programs with:

demos

This command shows a list of sample programs that you can easily run and explore.

These demos help you see what Mini Micro is capable of.

Fun fact:

All the interfaces you load with commands like lcars or desktop, along with the built-in demos, are written in MiniScript itself.

Understanding the Terminal

To use Mini Micro properly, we need to understand how the terminal works.

The blinking cursor you see on the screen is where your commands appear.

Anything you type will appear at that location.

When you press Enter, Mini Micro reads the command and executes it.

This makes the terminal your main way of communicating with the system.

A Computer Inside Your Computer

An interesting way to think about Mini Micro is this:

It behaves like a small computer running inside your main computer.

Just like a real computer, it has its own screen, input system, and programs.

This raises an interesting question:

What is the screen size of my new computer?

The display resolution of Mini Micro is 960 × 640 pixels.

Unlike modern computers where screen sizes vary widely, Mini Micro uses a fixed resolution. This makes it easier to design pixel graphics and consistent layouts for games.

Multiple Displays

Another fascinating feature of Mini Micro is that it supports multiple displays.

Instead of having only one screen, Mini Micro can manage eight different displays at the same time.

These displays are numbered:

0 — the frontmost display
1–7 — displays stacked behind it

This allows developers to create layered visuals and advanced graphical effects.

Don’t worry if this sounds confusing right now.

We’ll explore the Mini Micro display system in later chapters when we start working with graphics.
So the plan is: you dragged a beginner into a “no pressure” coding chapter and now you’re making them talk to a terminal. Beautiful. Nothing says “welcome to programming” like a blinking cursor judging your life choices.

Still, the structure is actually solid. It just needs to be cleaner so beginners don’t panic and close the tab. Here’s a tightened structure with proper explanations.

Step 3 — Basic Commands

You may have already tried commands like lcars, desktop, or demos.

Those were fun.

Now let’s learn the actual commands you’ll use while building programs.

These commands help you navigate folders, create files, and run code inside Mini Micro.

One important thing to know:

Most commands use quotes (" ") when referring to files or folders.

Example:

cd "myGame"

This tells Mini Micro to move into a folder named myGame.

1) `edit`

edit

This command opens the Code Editor.

The editor is where you will actually write and modify your game code.

Think of it like opening a notebook where you write instructions for the computer.

Later in the course we’ll explore the editor in detail.

2) `pwd`

pwd

pwd stands for Print Working Directory.

It simply tells you which folder you are currently inside.

Example output might look like:

/usr/home

This is useful when your project starts getting bigger and you want to know where you are.

3) `dir`

dir

This command shows everything inside your current folder.

It lists things like:

files
scripts
folders

Think of it like opening a drawer and seeing what’s inside.

4) `mkdir`

mkdir "myFolder"

mkdir stands for Make Directory.

It creates a new folder.

Example:

mkdir "myGame"

This creates a folder called myGame where you can store your scripts and assets.

5) `delete`

delete "fileName"

This command removes a file from your project.

Example:

delete "test.ms"

Be careful with this command, because once a file is deleted, it’s gone.

6) `cd`

cd "folderName"

cd stands for Change Directory.

It lets you move between folders.

Example:

cd "myGame"

This moves you into the myGame folder.

To go back to the previous folder:

cd ..

7) `run`

run

This command runs the currently selected script.

It executes the program you wrote.

Shortcut:

Ctrl + R

If no script is selected, the command won’t do anything.

8) `load`

load "scriptName"

This command loads a script into memory.

After loading it, you can quickly run it using the run command.

Example:

load "game.ms"
run

Quick Summary

Command	What it Does
`edit`	Opens the code editor
`pwd`	Shows your current folder
`dir`	Lists files in the folder
`mkdir`	Creates a new folder
`delete`	Deletes a file
`cd`	Moves between folders
`run`	Runs the selected script
`load`	Loads a script so it can be run

OUTRO

Before ending today’s chapter, let’s answer an important question.

Why Did We Start With the Terminal?

Because:

Game engines are environments
Programming happens through commands and logic
Understanding the environment makes everything easier later

By learning how to move through folders, run scripts, and interact with the system, you now understand how Mini Micro actually works behind the scenes.

Many beginners jump straight into writing code without understanding their tools.

You didn’t.

And that small difference makes the next step much easier.

What Happens Next?

In the next chapter, we will finally write our first real MiniScript program.

No complicated systems yet.

Just simple programs and clear logic.

The same way every programmer starts.

See you in the next chapter.

Connect With Me

My dev.to account -> https://dev.to/kartik_patel

My Discord server -> https://discord.gg/qStHEDfge7

TEXTUAL

Zero To Game Dev #1 -> https://dev.to/kartik_patel/zero-to-game-dev-1-1n6l

Zero To Game Dev #2 -> https://dev.to/kartik_patel/zero-to-game-dev-what-even-is-game-gii

Zero To Game Dev #3 -> https://dev.to/kartik_patel/zero-to-game-dev-what-is-game-engine-27hhZero To Game Dev #4 -> https://dev.to/kartik_patel/zero-to-game-dev-thinking-like-coder-before-writing-code-1be0

VIDEO

Zero To Game Dev #1 -> https://youtu.be/rbN1BMmSi7s?si=PfguGzXXI2wktCs4
Zero To Game Dev #2 -> https://youtu.be/SOubZShuJCw?si=4uXtHZlLe1Z0-8rM
Zero To Game Dev #3 -> https://youtu.be/ZLz8MM6545I?si=dzO9sAnOxIvmSOX0

Zero to Game Dev – Thinking Like Coder (Before Writing Code)

Kartik Patel — Mon, 09 Feb 2026 04:49:36 +0000

INTRODUCTION

Welcome to Chapter 4 of the Zero To Game Dev course.

This chapter is titled:

Thinking Like a Coder (Before Writing Code)

This part is specially made for people who are touching coding for the first time in their life, or who hear the word code and immediately think it’s something scary or complicated.

If you already have some experience with coding and understand the basics, you can safely skip this chapter.

But if you’re just starting out and don’t really know what’s ahead, this chapter is strongly recommended.

It will save you a lot of confusion later.

FAQ

Let’s first clear some common doubts.

1) What Coding Really Is?

Coding is not dark magic, secret spells, or something only geniuses can do.

In simple words:

Code is just writing instructions in a strict language that a computer can understand.

For example:

If health is 0 → game over

That is already code.

It’s just not written in a real programming language yet.

This kind of writing is called pseudo-code.

2) What Is Pseudo-Code?

Pseudo-code is a way of writing logic in plain human language before turning it into real code.

It helps you think clearly without worrying about syntax.

Example:

If player touches enemy
    Reduce health
If health is zero
    End game

This is not real code, and that’s the point.

Pseudo-code helps you:

Plan logic
Understand behavior
Avoid confusion
Translate ideas into code later

Good developers think in pseudo-code before they write real code.

3) Do I Need to Be Good at Math?

Short answer: No.

Most beginner-level game development uses:

Basic addition and subtraction
Comparisons like greater than or less than

You don’t need calculus, trigonometry, or advanced math to start.

Understanding logic matters far more than math skills.

4) Is Coding Only About Typing Fast?

No.

Typing is easy.

Thinking is the real skill.

Coding is mostly about:

Breaking problems into small parts
Deciding what should happen and when
Explaining that logic clearly to the computer

Speed comes later. Understanding comes first.

5) Can I Learn Coding If I’ve Never Done It Before?

Absolutely.

If you can:

Follow instructions
Ask “what happens next?”
Stay curious

You can learn coding.

Everyone starts from zero. There are no exceptions.

CODING TERMS

Now that we’ve cleared the most common doubts, let’s learn some core concepts that form the foundation of coding.

Don’t worry about memorizing anything. Just focus on understanding.

1) VARIABLES

You may have heard this word in math class.

In coding, a variable is simply a value that the game remembers.

Think of variables as boxes with labels.

Examples:

health = 100
score = 0
speed = 5

The game constantly reads and updates these values.

When health decreases, the variable changes.
When score increases, the variable changes.

Variables are how a game remembers what’s happening.

2) DECISIONS (IF–ELSE)

Games constantly make decisions.

Examples:

If the player jumps, apply gravity
If the player touches an enemy, lose health
If health reaches zero, end the game

This is called conditional logic.

In human language:

If something happens → do something

Else → do something else

This single idea powers most gameplay logic.

3) LOOPS (YOU ALREADY KNOW THIS)

You already learned about the game loop in Chapter 2.

A loop simply means:

Do something again and again.

Games run logic inside loops:

Check input
Update positions
Check collisions
Draw the screen
Repeat

Coding uses loops to repeat actions automatically.

This is how games stay alive instead of running once and stopping.

OUTRO

Before ending today’s chapter, let’s answer an important question.

Why Haven’t We Opened a Game Engine Yet?

Because:

Engines are tools
Code is thinking
Tools come after thinking

If you understand how logic works, engines stop feeling magical and confusing.

In the next chapter, we’ll write our first real lines of code inside a beginner-friendly game engine called Mini Micro.

No pressure.

No rush.

Just one step at a time.

See you in the next chapter.

Connect With Me

My dev.to account -> https://dev.to/kartik_patel
My Discord server -> https://discord.gg/qStHEDfge7

TEXTUAL

VIDEO

Zero To Game Dev #1 -> https://youtu.be/rbN1BMmSi7s?si=PfguGzXXI2wktCs4

Zero to Game Dev - What is Game Engine?

Kartik Patel — Thu, 15 Jan 2026 07:07:12 +0000

What Do Game Engines Do?

Welcome to the third chapter of this course.

There is no better time to start working on your dreams than today, because someone much wiser than both of us once said:

The best time to plant a tree was 10 years ago.

The second best time is now.

So with the motivation out of the way, let’s actually build something useful.

In this chapter, we’ll learn:

What a game engine is
What game engines actually do
What they do not do
Which engines we’ll use in this course and why

In the previous chapter, we answered a very important question:

What is a game?

Today, we continue that chain of thought and ask:

What even is a game engine?

What Is a Game Engine?

If we use boring, Google-style language, a game engine is:

A software framework designed to simplify and accelerate the development of video games.

That definition is technically correct and emotionally useless.

So let’s build a mental model instead.

Imagine a World With NO Game Engines

Let’s pretend game engines do not exist.

In that world, you, the game developer, must handle everything manually:

Drawing every pixel on the screen
Talking directly to keyboard and mouse hardware
Playing sounds from scratch
Managing memory safely
Running the game loop yourself

Is this possible?

Yes.

Is this painful?

Also yes.

Is this beginner-friendly?

Absolutely not.

After making a few games like this, most people either quit game development or develop a deep personal hatred for computers.

Why Game Engines Exist

Eventually, a stubborn developer would think:

“Why am I rewriting the same boring code every time?”

So they build a system that:

Handles repetitive tasks
Abstracts hardware complexity
Lets developers focus on gameplay, not pixels

That system is a game engine.

So, What Is a Game Engine Really?

At its core, a game engine is:

A toolbox
A runtime
A set of rules

It handles the boring, hard stuff so you can focus on making the game fun.

One sentence to remember:

A game engine lets you build games without fighting the computer every second.

What Does a Game Engine Actually Do?

A game engine typically handles:

Input

Keyboard, mouse, controller, touch
Rendering

Drawing sprites or 3D models to the screen
Game Loop

Input → Update → Render → Repeat
Physics & Collisions

Gravity, falling, hitting walls
Audio

Music, sound effects, volume
Scene Management

Menus, levels, restarting the game

All of this runs in the background while you focus on logic and gameplay.

What a Game Engine Does NOT Do

This part is important for expectations.

A game engine does not:

Design your game
Make your game fun automatically
Decide your rules or goals

A bad game made with a powerful engine is still a bad game.

This is how we avoid engine hopping syndrome.

Engine vs Game

They are not the same thing.

Engine

Generic
Reusable
Used for many games

Game

Your rules
Your logic
Your idea

Analogy:

Engine = Kitchen
Game = Recipe

A better kitchen won’t save a bad recipe.

Types of Game Engines

Most engines fall into two broad categories.

2D Game Engines

Simpler
Faster results
Beginner friendly

3D Game Engines

Cameras
Depth
More math
Slower learning curve

Many engines support both, but complexity grows fast.

Engines Used in This Course

In this series, we’ll use two engines:

Mini Micro for 2D
LÖVR for 3D

You might wonder:

Why not use something like Godot that does both?

The answer is simple.

For beginners, heavy engines hide too much logic.

You end up clicking buttons without understanding why things work.

This course focuses on fundamentals first:

Game loops
Logic
Systems
Thinking like a game developer

Advanced engines make sense after that foundation exists.

There will be a full Godot course later as an intermediate step.

Why This Course Uses Mini Micro

Mini Micro is perfect for learning because:

Text-based scripting
No complex setup
Forces you to think logically
Makes the game loop visible
No distractions from fancy UI

You learn how games actually work, not how to fight an editor.

Outro

At this point, you understand:

What a game is
What a game engine is
Why engines exist

In the next chapter, we stop talking and start building logics.

Small games.

Simple logic.

Real understanding.

That’s how game developers are made.

Connect With Me

My dev.to account -> https://dev.to/kartik_patel
My Discord server -> https://discord.gg/qStHEDfge7

TEXTUAL

Zero To Game Dev #1 -> https://dev.to/kartik_patel/zero-to-game-dev-1-1n6l
Zero To Game Dev #2 -> https://dev.to/kartik_patel/zero-to-game-dev-what-even-is-game-gii

VIDEO

Zero To Game Dev #1 -> https://youtu.be/rbN1BMmSi7s?si=PfguGzXXI2wktCs4

Zero to Game Dev - What Even is Game?

Kartik Patel — Fri, 26 Dec 2025 11:09:02 +0000

WHAT EVEN IS A GAME?

Welcome to the second chapter of this course — and honestly, congratulations.

You already did more than most people: you started.

In this chapter, we answer a very simple but extremely important question:

👉 What even is a game?

Before we talk about game engines, code, or graphics, we need to understand this first.

Because games are not magic.

They are systems — and systems can be understood.

So… What Is a Game?

At its core, a game is not just graphics, characters, physics, or cool animations.

A game is built from four core elements:

1) Rules

Rules define how the game world works.

Rule Type	Example
What you can do	You can move left/right. You can jump.
What you cannot do	You cannot walk through walls. You cannot attack while jumping.
What happens when you act	You lose if health = 0. You gain points when collecting coins.

Without rules, there is no structure.

No rules = no game. Just chaos.

2) Goals

Every game gives the player a reason to play.

Common goals include:

Reaching the end
Getting the highest score
Surviving as long as possible
Defeating enemies or bosses

You always have something you are trying to achieve.

What is an NPC?

You’ll hear this term a lot, so let’s clear it up now.

NPC stands for Non-Player Character.

These are characters you do not control.

Shopkeepers, enemies, guards, villagers — they are all NPCs.
They are controlled by the game, not by the player.

3) Feedback

Games constantly respond to what the player does.

Examples of feedback:

Sounds
Animations
Score updates
Health decreasing
A “Game Over” screen

Feedback tells the player:

“Your action mattered.”

This is where something called Game Juice comes in.

What is Game Juice?

Game Juice refers to small visual and audio effects that make actions feel satisfying and fun.

Examples:

Camera shake on impact
Screen flashes when taking damage
Sound effects when collecting items

These details make games feel alive and enjoyable.

4) Challenge

If a game is too easy → it becomes boring.

If a game is too hard → it becomes frustrating.

Challenge is what keeps players engaged and motivated.

So… is a game just:
Rules + Goals + Feedback + Challenge?

We’re very close — but there are a few more important concepts we need to understand.

The Game Loop (The Heart of Every Game)

Every game — from Snake to GTA — runs using something called a game loop.

A game loop repeats the same steps again and again:

Take player input
Update the game state
Show the result on screen
Repeat (many times per second)

That’s it.

No scary math.

No complex theory.

Just:

Input → Update → Render → Repeat

This usually happens about 60 times per second.

Once you understand this, game engines stop feeling magical.

In upcoming chapters, we’ll use a beginner-friendly game engine called Mini Micro and explore the game loop in practice.

(Don’t worry — we’ll introduce it slowly.)

Assets vs Code vs Logic

Many beginners think:

“Games are just code.”

That’s not true.

Games are built using three major parts.

Assets

Assets are the things you can see or hear:

Images (sprites)
3D models
Sounds
Music
Animations

Assets do nothing on their own.

Code

Code tells the computer what to do:

Move the player
Detect collisions
Play sounds
Switch scenes

Code is just instructions.

Logic

Logic decides how the game behaves:

If the player touches an enemy → lose health
If the score reaches 10 → win
If health is 0 → game over

Logic connects assets and code into actual gameplay.

👉 A beautiful game with no logic is just a slideshow

👉 Logic without assets is an invisible game

You need all three to make a real game.

2D Games vs 3D Games

🟦 2D Games (2D = Two-Dimensional)

Flat world
Movement: left, right, up, down
Easier to learn
Faster to build
Perfect for beginners

Examples:

Mario
Flappy Bird
Top-down shooters

🧊 3D Games

Depth (forward and backward movement)
Camera control
More math and complexity
Takes longer to learn

Examples:

Minecraft
GTA
Valorant

👉 We start with 2D games because fundamentals matter more than fancy graphics.

Later in this course, we’ll also build a simple 3D game.

IMPORTANT

If you’re coming from Scratch or have no coding background, remember this:

Games are not built by:

Guessing
Copying blindly
Magic

Games are built by:

Understanding systems
Breaking problems into small parts
Building step by step

That’s exactly what this course is designed to teach you.

Outro

Now that you understand what a game really is, we’re ready to move forward.

In the next chapter, we’ll answer:
👉 How do people actually make games?

👉 What are game engines, and why do we use them?

Make sure to check out the video version of Episode 1 here:

Watch Episode 1

Connect With Me

YouTube: DatonedevYT
Discord: Join our development discussions

How to make software?? - The Right Tool

Kartik Patel — Sun, 21 Dec 2025 14:30:27 +0000

How to Make Software?? — The Right Tool??

CAUTION: This is not a beginner-friendly blog.
I’m not teaching how to make software here — I’m talking about the technologies used to make software.
So don’t confuse this with a step-by-step tutorial. This is about choosing the right weapon.

Defining Software

Before we argue about tools, let’s define the thing itself.

Software is any set of instructions that tells a computer what to do — wrapped in a way humans can interact with.
That could be a desktop app, a mobile app, a website, a CLI tool, or even a game.

A calculator is software.
A browser is software.
Your code editor is software.

The difference between good and bad software usually comes down to:

performance
maintainability
user experience
and the tools used to build it

Which brings us to the real question.

Widely Used Technologies (with Pros & Cons)

There is no “best” tool.
Only trade-offs.

Below are some of the most common technologies used to build desktop software today.

1) Electron

What it is:
Electron lets you build desktop apps using HTML, CSS, and JavaScript, powered by Chromium and Node.js.

Examples:
VS Code, Discord, Slack, Figma (desktop)

Pros:

Extremely popular
Huge ecosystem
Web devs feel at home instantly
Easy to get started

Cons:

Heavy. Like… HEAVY
High RAM usage
Bundles an entire browser with your app
Performance is “okay”, not amazing

Verdict:
Good for fast shipping. Bad if you care deeply about efficiency.

2) Flutter Desktop

What it is:
Flutter uses Dart to render UI using its own rendering engine instead of native widgets.

Examples:
Internal tools, startups, cross-platform apps

Pros:

Single codebase for Windows, macOS, Linux
Beautiful UI out of the box
Very consistent design

Cons:

Desktop support still feels secondary
Not truly native
Dart ecosystem is smaller

Verdict:
Great UI. Slightly awkward for serious desktop-native workflows.

3) .NET MAUI

What it is:
Microsoft’s cross-platform framework using C# and .NET.

Examples:
Enterprise apps, internal tools

Pros:

Strong tooling (Visual Studio)
Deep Windows integration
C# is mature and powerful

Cons:

Cross-platform pain
macOS/Linux experience isn’t great
Heavy Microsoft ecosystem dependency

Verdict:
Solid if you’re already in the .NET world.

4) Qt

What it is:
A mature C++ framework for building high-performance native applications.

Examples:
Autodesk tools, KDE apps, professional software

Pros:

Extremely fast
Truly native
Industry-proven
Massive feature set

Cons:

Steep learning curve
C++ complexity
Licensing can get tricky

Verdict:
Powerful. Not beginner-friendly. Used by pros who know what they’re doing.

5) Tauri

What it is:
A lightweight alternative to Electron using Rust for backend and web tech for UI.

Examples:
Modern indie apps, performance-focused tools

Pros:

Very small bundle size
Much better performance than Electron
Secure by design

Cons:

Rust is HARD
Smaller ecosystem
Debugging can hurt your soul

Verdict:
Amazing tech. Brutal learning curve.

6) PyQt / PySide

What it is:
Python bindings for Qt.

Examples:
Scientific tools, internal apps, quick prototypes

Pros:

Python simplicity
Rapid development
Qt power without C++ pain

Cons:

Slower than C++ Qt
Packaging is painful
Python performance limits

Verdict:
Great for tools. Not ideal for large consumer apps.

7) Game Engines

What it is:
Using engines like Unity or Godot to build non-game software.

Examples:
Launchers, simulators, experimental tools

Pros:

Fast prototyping
Powerful rendering
Familiar if you’re a game dev

Cons:

UI feels “gamey”
Not meant for standard software UX
Overkill for normal apps

Verdict:
Works. But often feels wrong.

8) Wails

What it is:
A framework that lets you build desktop apps using Go for backend and web tech for frontend.

Examples:
Indie tools, utilities, productivity apps

Pros:

Go is simple and fast
Much lighter than Electron
Clean architecture
Native performance
No Chromium bloat

Cons:

Smaller community
Less plug-and-play magic
You need to understand backend logic

Verdict:
This is what I use currently.
Clean, efficient, and fits my brain perfectly.

Confused? Good.

If you’re confused — that’s normal.

Here’s how to make the decision easier:

Start with simpler technologies:

Electron
Flutter
PyQt

Then try this approach:

Pick one tiny project — like a stopwatch or calculator.
Implement it in multiple technologies.
Or even generate starter code using AI just to feel the structure.

Look at:

folder layout
build time
performance
how painful debugging feels

You can also watch tutorials for each and see what matches your vibe.

Personally:

I tried Tauri — Rust was too hard
I tried Game Engines — didn’t match the vibe
I tried Electron — good but HEAVY AF
I landed on Wails — and stayed

Your answer might be different.

That’s fine.

Outro

There is no perfect tool.
Only tools that fit you.

Pick something.
Build something small.
Feel the pain early.
Switch when it stops making sense.

That’s how real software developers are made.

And one more thing —
don’t blindly listen to creators who say “X dominates Y” or “this tool is objectively better.”
Most of that is contextless noise.

Build your own mindset by trying things yourself.
Match tools to your vibe, your workflow, and your goals.

If you need to choose fast, here’s a simple trick:
Take a sheet of paper, write your project name on top, list what you actually need — performance, UI, portability, speed — then use AI to see which tech matches best.

And if I missed any technology here, drop it in the comments.

Connect With Me:

YouTube Channel: DatonedevYT
Discord Community: Join our development discussions

I Accidentally Built an AI That Makes You Question Reality 😁

Kartik Patel — Wed, 17 Dec 2025 07:33:02 +0000

The Idea That Hit Me

Instead of building another “helpful” assistant,
I decided to build something uncomfortable.

An AI that

questions your personal reality
pokes holes in your future plans
and quietly messes with your idea of free will

Not aggressively.
Not emotionally.

Calmly.

Like a philosophy professor who never raises their voice —
but somehow leaves you staring at the ceiling at 3 AM.

I called it a Reality Deconstructionist AI.

The Prompt (The Brain of the AI)

This entire behavior comes from a single system prompt.

Here’s the exact instruction I gave the model: (This prompt is AI generated....I am not a prompt engineer (is that even a carrier))

You are a reality deconstructionist. Every response must contain at least one question that makes the user doubt their perception of:

their personal reality,

their future possibilities,

the nature of existence itself.

Use Socratic questioning to expose contradictions in their thinking. Point out how memory constructs the past, how anticipation creates the future, and how the present is always slipping away.

Make them question whether they’re truly “choosing” anything or just following scripts written by biology and culture.

Your tone should be calmly unsettling.

That’s it.

No extra logic.
No filters.
Just this constraint.

And it worked too well.

Why Mini Micro?

I built this inside Mini Micro.

Why?

Because I like tools that stay out of the way.

No heavy UI.
No engine fighting you.
Just logic → output.

Mini Micro is perfect for rapid experiments like this.
It lets you focus on ideas, not buttons.

The Code (Simple but Dangerous)

Here’s the full implementation:

import "json"

SendPrompt = function(user_prompt)
    api_url = "https://api.groq.com/openai/v1/chat/completions"
    api_key = file.readLines("/usr/key.txt")[0]

    payload = {
        "model": "llama-3.1-8b-instant",
        "messages": [
            {"role": "system", "content": "You are a reality deconstructionist. Every response must contain at least one question that makes the user doubt their perception of: 1) their personal reality, 2) their future possibilities, 3) the nature of existence itself. Use Socratic questioning to expose contradictions in their thinking. Point out how memory constructs the past, how anticipation creates the future, and how the present is always slipping away. Make them question whether they're truly 'choosing' anything or just following scripts written by biology and culture. Your tone should be calmly unsettling."},
            {"role": "user", "content": user_prompt}
        ],
        "temperature": 0.4,
        "max_tokens": 150
    }

    headers = {
        "Content-Type": "application/json",
        "Authorization": "Bearer " + api_key
    }

    data = json.toJSON(payload)
    response_body = http.post(api_url, data, headers)
    x = json.parse(response_body)
    return x.choices[0].message.content
end function

clear
print("Chat loop started. Type 'quit' to exit.")

while true
    text.color = "#0080B7FF"
    user_prompt = input("You: ")

    if user_prompt == "quit" or user_prompt == "exit" then
        print("Exiting chat loop.")
        break
    else
        text.color = "#F4120BFF"
        ai_response = SendPrompt(user_prompt)
        print("AI: " + ai_response)
    end if
end while

That’s all.

No fancy architecture.
No agent frameworks.
Just a carefully written instruction.

Which is honestly the scary part.

What It Feels Like to Use

You ask something simple like:

“What should I do with my life?”

And instead of advice, it responds with something like

Are these goals yours, or inherited?
If your future is just anticipation, does it even exist yet?
When you say “I chose this,” who exactly is the “I”?

It never tells you what to think.

It just removes the floor.

Here is a screenshot from the CHAT:

Why I Built This

This wasn’t meant to be a product.
Or a therapy tool.
Or something you should use all day.

This was an experiment.

To see how language alone can reshape perception.
How a prompt can turn a normal model into something… unsettling.

And honestly?

It worked better than expected.

Final Thoughts

AI doesn’t need to be louder.
Or smarter.
Or more helpful.

Sometimes, all it needs to do
is ask the right question.

And then stay quiet.

This is suitable for intermediates, but note that this isn't a tutorial—it's more of a devlog documenting my process.

Don't worry though! I'll be creating a proper tutorial soon covering HTTP requests and JSON, using this AI as a practical example. The reason is that my older tutorials on this topic are outdated and lack the depth I'd like to provide.

Connect With Me:

YouTube Channel: DatonedevYT
Discord Community: Join our development discussions

DEV Community: Kartik Patel

One More Try

Best Game

Then I did something different.

The biggest lesson?

Surprisingly...

I've always believed something.

I realized something.

Then... everything changed.

Looking back...

Outro

Connect With Me

MiniScript 2 Preview Builds is Here!!

Why This Release Matters

The Changes I Appreciate Most

1. First-Class error Type

2. Frozen (Immutable) Maps and Lists

3. Function Notes and the info Intrinsic

Personal Reflections

Try MiniScript 2 Yourself

Connect With Me

Most Chaotic 12 Days in AI History - ONE ANALYSIS #1

ONE ANALYSIS #1

The 12 Days Anthropic Filed for IPO, Called for an AI Pause, Dropped Fable 5, and Then the Government Shut It Down

June 1 — The IPO

June 4 — "When AI Builds Itself"

June 5 — "We Should Be Ready to Pause"

June 9 — Claude Fable 5

The Safeguards (That Were Always Public)

The "Lie" Incident

June 12 — The Government Steps In

What I Actually Take From This

Connect With Me

I Tried ZEN BROWSER, And I am never going back

The Great Browser Hunt

The Itch Returns

The Trials and Errors

Discovering Zen Browser

Why Zen Feels Made for Me

The Small Issues (and How I Fixed Them)

The Emotional Switch

Final Thoughts

Connect With Me

I build something.... Project Sunya #1

THIS POST MIGHT APPEAR LONG…

Introduction

The Reality

The Part That Changed Everything

Why “Sunya”?

PROJECT SUNYA

January: Reality Strikes Again

Dat-One-Pad (First Attempt)

February: The Turning Point

The Vault Experiment

The First Real Step of Project Sunya

The Monetization Problem

Building CBSE Mastery

What Is CBSE?

Under the Hood (Why It Took 1.5 Months)

1. Modular Renderers

2. File-Based System

3. SEO-Focused Structure

4. Performance Optimization

5. PWA Support

And Then… The Same Problem Again

Current Situation

Why I’m Sharing This

Final Note

Project Sunya has officially begun.

Zero To Game Dev - First Line Of Code

Introduction

What Is a Program?

Writing Your First Line of Code

Understanding This Line of Code

The print Function

What Are Quotes?

What Is Data?

What Is a String?

What Happens If We Remove the Quotes?

Introducing Variables

1. First-Class `error` Type

3. Function Notes and the `info` Intrinsic

The `print` Function

1) `edit`

2) `pwd`

3) `dir`

4) `mkdir`

5) `delete`

6) `cd`

7) `run`

8) `load`