Forem: Kartik Patel

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

DAT ONE RECAP: 2025

Kartik Patel — Sun, 14 Dec 2025 15:42:49 +0000

This year was insane for me.

Honestly, if I ranked every year I’ve lived so far, 2025 would still end up at the top. And yeah, I know my life is short, I’m still a kid — but the character development I went through this year is something I never imagined. This was the year where I faced life and death almost at the same time.

So this is the ultimate Dat One recap of 2025.

Let’s start from the beginning — from the first real video on my channel.

The video was titled “3D Version of Lua”.

It wasn’t actually my first YouTube video ever. I had uploaded stuff before, but this was my first English video. I’m from India, and the kind of content I make is already very niche. Making it in Hindi would’ve made it even more niche. So I decided to switch to English.

That switch was hard.

Tongue twisters, broken grammar, sentences that barely made sense — and honestly, some still don’t. But I’ve improved a lot since then, and I’m proud of that.

After that video, I uploaded two more videos on Lua and Love2D. At that time, I was completely new to game development. I was searching for an engine that gave me full control without an overcomplicated UI. Engines like GameMaker felt overwhelming. Love2D felt perfect — simple, minimal, code-first.

Then I made a tutorial on Godot.

And that became the first major checkpoint of my channel.

That Godot video became the most viewed video on my channel that year. I knew Godot was what the audience wanted. But even then, I didn’t want to turn my channel into a Godot-only channel.

The reason was Mini Micro.

I was searching for a simple, minimal, down-to-earth game engine — and Mini Micro was exactly that. That’s why most of my content this year revolved around Mini Micro and MiniScript.

Somewhere in this timeline, I also posted a video on the Fyrox Engine. That happened because I really liked the content style of the YouTuber GameFromScratch, and I tried to copy that style.

I quickly realized something important: making content like someone else isn’t fun. You have to find your own voice.

After that realization, I posted more Mini Micro and MiniScript videos, and one more Godot video — which ended up being my last Godot video of the year.

Then I disappeared for two months.

After those two months, I uploaded a video titled “2025 was the worst year of my life”.

In that video, I sounded unserious. I was laughing and smirking. The reason is simple: whenever I feel extreme emotional pain, I don’t cry immediately — I laugh. After recording that video, I cried a lot.

Because the reality was heavy.

Starting from November 2024, I had been suffering from multiple diseases. Due to heavy pollution in my state, I started having severe breathing issues. It felt like someone was choking me. I was rushed to a nearby hospital, and from there referred to AIIMS Delhi.

I was treated there for 24 hours on heavy medication and discharged with inhalers. After that incident, my physical condition went downhill. I lost around 12 kg of weight.

In January, I got jaundice.
In February, it disappeared.
In March, I got a UTI.
That recovered.
Then jaundice came back.
Then it came back again in April, with my bilirubin levels reaching around 22.

I was admitted to another respected hospital, where I was declared to have Wilson’s Disease — a rare genetic disorder that basically sounded like a life sentence.

I broke down.

I cried a lot. That’s when I made the video about 2025 being the worst year of my life.

At that point, I genuinely thought I had very little time left. I decided I had to work fast. I wanted to earn money — not because I’m greedy or materialistic, but because I wanted to make my family smile.

Even while writing this, I’m smiling and crying at the same time.

I decided to stop copying other creators and started producing content in my own style. You can clearly see the shift in my thumbnails and video quality after that point.

Then I decided to learn a serious, market-worthy programming language. That’s when I found Go.

I started a Go 101 blog series on my dev.to account. It was supposed to last 30 days. It didn’t even last a week. But during that time, I built a small tier list program in Go and made a video ranking programming languages.

Then came April.

I was still taking medicines for Wilson’s Disease when a relative who worked at the same hospital suggested we go to another hospital — one we had never even heard of. We went there for a second opinion.

I got admitted immediately.

That moment broke me.

I cried like a baby in the hospital. I had anemia, heavy jaundice, extremely low blood pressure. My life started feeling like a burden to myself. I genuinely felt like I should just die.

Every night, I cried. Other patients even complained about it.

Before November 2024, I had been studying hard for an entrance exam that could get me into a better government school for free. Now that effort felt meaningless. The exam was approaching, and I was lying in a hospital bed, fighting for my life.

I had my laptop with me, but due to network jammers, internet only worked after 4 PM.

That hospital felt more like an institute than a hospital — even its name had “Institute” in it.

They ran test after test. Around 52 tests in total.

Finally, they declared I had no Wilson’s Disease.
No asthma.
Nothing genetic.

What I actually had was multiple autoimmune disorders, hepatitis, typhoid, and several other conditions — around seven diseases at once.

The date was May 19.
My birthday was May 21.
The entrance exam was on May 26.

And then something unbelievable happened.

Without any jaundice medicine, my body started recovering on its own. Doctors discharged me on May 20. On May 21, I was home.

That birthday wasn’t happy. Life still felt ruined. I had lost around 15 kg and then gained back even more. My current weight is actually higher than before I got sick.

About the entrance exam — another miracle happened.

I had typhoid and needed injections for five days. The last injection was on May 25. That meant I could sit for the exam on May 26.

I gave the exam.

June passed in trauma.
Half of July passed in trauma.
I made a few videos in between.

Then, on July 18, the results came.

I had secured 3rd rank in the exam.

I got admitted.

That’s where the death phase of 2025 ended.

My body had mostly recovered by then, though I still take daily medication. I decided to make a heavy comeback. I upgraded my content quality again. I started participating in game jams regularly and ended up winning 3–4 of them.

I uploaded another Godot video — this time about the asset store — and my content quality reached a level comparable to bigger creators.

Subscriber growth was still slow.
But I never gave up.

At my lowest point, I had decided to earn — and I kept my word. I worked harder than ever. I earned through game jams, technical writing, and other small opportunities.

I still wanted a solid, long-term skill.

So I returned to Go.

And in November 2025, I fully committed to it.

Today, I’m happy to say that I’ve officially transitioned from being only a game developer to becoming a software developer.

This doesn’t mean I’ll stop making games. I’ll still participate in game jams regularly.

But it does mean that in 2026, you’re going to see some serious software products from me.

Some of them will be paid — a small one-time price, probably under $25 — and the reason for that should be clear by now. I’ll also release free products.

Finally, thank you to everyone who supported me during this time.

Special thanks to ds slower (His YT), @joestrout , and AnimeAbhi (A YouTube Subscriber) — for supporting me when I was at my lowest.

This was 2025.

And I’m still standing.

Connect With Me:

YouTube Channel: DatonedevYT
Discord Community: Join our development discussions

Zero to Game Dev - Introduction

Kartik Patel — Mon, 01 Dec 2025 13:54:49 +0000

INTRODUCTION TO THE COURSE

Welcome to the first chapter of this course — and honestly, to the start of your game dev journey.
Before we jump into the technical stuff, let’s set the mood.

I’m Kartik (also known as Dat_One_Dev), the person guiding you through this entire experience. I’m here because I’ve walked through the same confusion, the same “where do I even begin,” and the same endless Googling. So this course is built to be friendly, understandable, and beginner-proof.

What This Course Offers

This is your first real step into the world of game development.
Not the scary, complex version people show online — the approachable version where things finally make sense.

Who This Course Is For

Anyone who wants to start and has enough determination to stay till the end.

Whether you’re someone who likes messing around in Scratch, someone who survived school projects in Excel, someone who has never coded a line in their life, or someone who only plays games and wonders, “How do people even make these?”

This course is for all of you.

The core message is simple: You don’t need experience. Just curiosity and determination.

What You Will Learn

We start from zero.

Then we build up to creating an actual working game. Step by step, no overwhelm.

You’ll learn:

• What games are made of
• How game engines help you build them
• The components behind the game
• Basic game logic and scripting concepts
• How scenes, objects, assets, and physics come together
• And finally, how to build a simple, fully playable game from scratch

Everything is explained clearly, slowly, and in a way anyone can follow.

Requirements

Here’s what you don’t need:

• No advanced maths
• No coding background
• No expensive laptop
• No paid software

What you do need is simple:

• Curious enough to question things
• A way to take notes (optional but super helpful)
• A normal PC — Windows, Linux, Mac, anything works
• Determination to stick with the lessons

If you show up consistently, you will learn. That’s a promise.

How This Course Works

We learn and we build.

This isn’t theory-only.
This isn’t “copy the code and hope it works.”
You’re going to understand what you’re doing and why it works.

Every lesson builds your intuition — the “game dev brain” that’ll stay with you no matter what engine or language you learn later.

What You’ll Be Capable of at the End

Let’s be honest: you won’t walk out of this making GTA VI (before 2026😁).
But you will walk out with something far more important — the foundation to build your own big dream one day.

By the end of this course, you will:

• Build a real, playable game
• Understand the fundamentals clearly
• Know how game engines actually work
• Be ready to move into advanced tools, engines, and techniques
• And most importantly, believe that you can do this

This course is about giving you confidence and skills equally.

Final Message: Let’s Begin Game Dev

By the end of this course, you will have built a game with your own hands.
You will finally understand how engines work behind the scenes.
And you’ll be ready to continue your journey deeper into game development.

Let’s begin.
Your game dev journey officially starts here.

This course is currently available only in text format, but soon it will also be released as a full visual (video) version on my YouTube channel: Dat_One_Dev.

Connect With Me:

YouTube Channel: DatonedevYT
Discord Community: Join our development discussions

Detailed Written Reviews:

EXPERIENCE: MINI MICRO: My Experience With Mini Micro
EXPERIENCE: ZED CODE EDITOR: My Experience With Zed Code Editor

Video Experiences:

EXPERIENCE: BRAVE: The Brave Browser Experience
EXPERIENCE: MINI MICRO: The Mini Micro Experience

My Current Tech Stack in 2026

Kartik Patel — Sat, 29 Nov 2025 15:32:51 +0000

Introduction

While we're currently in December with one month remaining in 2026, I'm confident in sharing my current technology stack as I have no immediate plans to change these tools. This represents my established comfort zone in development workflows, though I acknowledge that the rapidly evolving tech landscape might bring changes by 2027.

In this overview, I'll detail my current software stack and explain why each component has become integral to my development process.

Primary Programming Language: Go

Go (often referred to as Golang) serves as my primary programming language for most software development projects.

Why Go Works for Me:

Performance Characteristics: Combines low-level control similar to Rust with approachable syntax
Simplicity: Maintains Python-like readability while delivering robust performance
Execution Speed: Compares favorably with C++ for many use cases
Concurrency Model: Exceptionally well-designed and straightforward to implement
Comprehensive Standard Library: Most development needs are covered without external dependencies
Compilation Benefits: Error detection during editing rather than runtime
Static Typing: Provides type safety and better code intelligence

Areas for Improvement:

Repetitive error checking with if err != nil patterns
Occasional rigidity from static typing in rapid prototyping scenarios
Capitalization conventions for exported identifiers

Wails Framework

Wails represents the Go equivalent of Tauri, enabling desktop application development with frontend technologies. I've covered this framework in detail in previous blog posts and appreciate its seamless integration between Go backend logic and modern frontend interfaces.

Secondary Programming Language: MiniScript

Despite its niche status, MiniScript has secured a permanent place in my programming toolkit this year.

Advantages:

Accessibility: Even more approachable than Python for beginners
Supportive Community: Active and helpful, though relatively small
Mini Micro Integration: Tightly coupled with an excellent development environment
Rapid Prototyping: Ideal for quick implementation and testing

Limitations:

Limited Resources: Fewer tutorials and learning materials available compared to mainstream languages

Mini Micro Environment

Mini Micro provides what I consider the most accessible environment for creating simple games and prototypes. As I've mentioned in previous posts, it serves as an exceptional starting point for game development beginners and remains my preferred choice for game jam projects due to its rapid iteration capabilities.

Game Development: Godot

While my focus has shifted toward software development using Go and Wails, Godot remains my engine of choice for game projects.

Strengths:

Lightweight: Minimal resource requirements
Performance: Responsive even on modest hardware
Open Source: Complete transparency and community-driven development
Comprehensive Features: Well-rounded out-of-the-box experience
GD Script: Purpose-built scripting language optimized for game development

Considerations:

3D Performance: While improving, still trails dedicated 3D engines in some scenarios
Asset Pipeline: Occasionally requires additional configuration compared to Unity

Development Tools and Software

Daily Drivers:

Brave: Primary web browser for development and browsing
Zed: Code editor of choice for its speed and minimal resource usage
Notepad++: Lightweight text editor for quick notes and file edits
Aseprite: Specialized pixel art creation and editing
Knowledge Management: Currently evaluating Logseq after extensive Obsidian use
Version Control: Git with GitHub for all project management
Audio Processing: Audacity for editing and format conversion
Screen Recording: Streamlabs despite OBS's lighter footprint, for specific workflow advantages
Device Mirroring: ScrCpy for seamless phone-to-computer connectivity

Android Applications:

Pie Launcher: Minimal, open-source app launcher that revitalizes older devices
Termux: Powerful terminal environment for mobile development tasks

Conclusion

This technology stack represents my current equilibrium between performance, productivity, and personal preference. Each tool has earned its place through extensive use and demonstrated value in my daily workflow.

While technology preferences remain highly personal, this configuration has proven exceptionally effective for my specific needs across software development, content creation, and game development projects.

As the tech landscape continues to evolve, I remain open to exploring new tools that might enhance my workflow, but for now, this stack provides the perfect balance of capability and comfort.

Resource Links

Brave Browser: https://brave.com/
Zed Editor: https://zed.dev/
Mini Micro: https://miniscript.org/MiniMicro/index.html#about
Wails Framework: https://wails.io/
Godot Engine: https://godotengine.org/
Aseprite: https://www.aseprite.org/
Scrcpy: https://github.com/Genymobile/scrcpy
Streamlabs: https://streamlabs.com/
Audacity: https://www.audacityteam.org/
Notepad++: https://notepad-plus-plus.org/
Pie Launcher: https://f-droid.org/en/packages/de.markusfisch.android.pielauncher/
GitHub: https://github.com/

Detailed Written Reviews:

EXPERIENCE: MINI MICRO: My Experience With Mini Micro
EXPERIENCE: ZED CODE EDITOR: My Experience With Zed Code Editor

Video Experiences:

EXPERIENCE: BRAVE: The Brave Browser Experience
EXPERIENCE: MINI MICRO: The Mini Micro Experience

Connect With Me:

YouTube Channel: DatonedevYT
Discord Community: Join our development discussions

This post is part of my Experience Series, documenting my journey with various development tools and technologies.

EXPERIENCE: MINI MICRO

Kartik Patel — Tue, 25 Nov 2025 05:39:28 +0000

My Experience With Mini Micro

Introduction

This is another installment in my Experience Series, where I share detailed reviews of the tools and software I use daily. Previously, I've covered topics like the Zed code editor and Brave browser in video format, but I thought it was time to bring this experience to written form as well.

Today, I want to discuss a tool that many of my viewers have asked about but few truly understand—Mini Micro. Despite being relatively unknown in mainstream game development circles, it's a tool that has significantly shaped my approach to game development.

Before we begin, I want to clarify that this represents my personal experience. Your mileage may vary depending on your background, preferences, and use cases.

Why I Started With Mini Micro

My approach to tools has always leaned toward simplicity and minimalism. When I began my game development journey, I was looking for an environment that was:

Simple to understand and use
Built from the ground up for learning
Not overwhelmed by excessive hype or complexity

Initially, I experimented with Love2D, but as a framework rather than a complete environment, it presented a significant barrier for beginners. Staring at a blank framework can feel overwhelming when you're just starting out.

Mini Micro offered a different approach. It provided everything I needed in one package: simplicity, built-in development tools, and an active community through Micro Jam. While it took some time to grow on me, it eventually became one of my preferred development environments.

Why Mini Micro Stands Out

1. Ideal for Beginners

Many aspiring game developers begin with complex engines like Unreal or C++-based environments, only to find themselves overwhelmed and discouraged. The learning curve can extinguish motivation quickly.

Mini Micro addresses this by making coding accessible and enjoyable. For those who struggle with procrastination or motivation, starting with an engaging environment can make the difference between abandoning game development and building a lasting skill set.

There's a significant difference between copying code from external sources and genuinely understanding programming concepts. Mini Micro encourages the latter by creating an environment where learning to code is intrinsically rewarding. This foundation makes transitioning to more advanced engines like Godot considerably smoother.

2. Streamlined Simplicity

The simplicity of Mini Micro is one of its greatest strengths. While Love2D offers minimalism, it lacks the built-in utilities that make development straightforward for beginners.

For example, implementing collision detection in many environments requires complex mathematical calculations and radius checks. Mini Micro simplifies these common game development tasks with intuitive functions and clear syntax.

This simplicity shouldn't be mistaken for limitation. By reducing syntactic complexity, Mini Micro allows developers to focus on solving actual game design problems rather than battling with the development environment.

3. User-Friendly Interface

Many game development environments suffer from interface overload. Opening tools like GameMaker for the first time can be overwhelming, with countless buttons, panels, and options competing for attention.

Mini Micro takes the opposite approach. The interface is clean and distraction-free, consisting of two main workspaces:

A terminal interface that provides a minimal, focused environment for coding
A built-in code editor with basic tools and customizable themes

This streamlined approach allows developers to concentrate on what matters most: creating games.

My Personal Experience

My experience with Mini Micro has been overwhelmingly positive. While I occasionally encounter challenges or limitations, the supportive community has consistently provided assistance and guidance.

In my assessment of game development environments, Mini Micro occupies the top tier for educational use and prototyping. For beginners interested in game development, I strongly recommend starting with Mini Micro before exploring more complex engines like Unity or Unreal.

The foundation it builds in programming logic and game design principles proves valuable regardless of what tools you use later in your development journey.

My Links

YouTube: https://www.youtube.com/@DatonedevYT
Discord: https://discord.gg/qStHEDfge7
MINI MICRO EXPERIENCE: VIDEO VERSION: https://youtu.be/zyihNwS2epU?si=D3Vykz3O4Ed4BK_A

If you have experiences with Mini Micro or recommendations for other tools I should explore, I welcome your insights in the comments.

Forem: Kartik Patel

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

Mounting a Folder

Writing a Script File

The Editor

Why Didn’t We Use Quotes This Time?

A Small Experiment

What Is an Integer?

OUTRO

Connect With Me

TEXTUAL

VIDEO

Zero To Game Dev - Understanding Mini Micro

Introduction

What Is Mini Micro?

Why Mini Micro Is Beginner Friendly

How Mini Micro Helps You Understand Game Logic

The Language Behind Mini Micro

Installing Mini Micro

Step 1 — Download the Engine

Step 2 — Running Mini Micro

Mini Micro’s Two Main Windows

Terminal

Code Editor

What Is Debugging?

Trying Some Built-In Interfaces

Understanding the Terminal

A Computer Inside Your Computer

Multiple Displays

Step 3 — Basic Commands

1) edit

2) pwd

3) dir

4) mkdir

5) delete

6) cd

7) run

8) load

Quick Summary

OUTRO

Why Did We Start With the Terminal?

What Happens Next?

Connect With Me

TEXTUAL

The `print` Function

1) `edit`

2) `pwd`

3) `dir`

4) `mkdir`

5) `delete`

6) `cd`

7) `run`

8) `load`