Earlier models in Machine Learning aimed to use Mathematics to understand, replicate, and even create patterns from scratch. But this naïve approach reached a limit. A limit sheer computation could not overcome.

These machines were an imperfect creation that paled in the face of the unimaginable complexity of the human brain.

So what better but to replicate the human mind, not only in its function, but rather in its structure as well.

Why try to create something new in order to simulate something we already have knowledge about?

Artificial Neural Networks:

Source: https://www.geeksforgeeks.org/machine-learning/difference-between-ann-and-bnn/

Following this approach, the “Artificial Neural Network” was created. A mathematical model aimed at processing and transmitting data in a manner similar to biological neural networks.

One of the first official attempts at a successful neural network was the “Perceptron”, created by Frank Rosenblatt in 1957, which gained widespread attention from scientists and mathematicians alike for its innovative approach towards modelling the human brain.

The Perceptron

Source: https://www.sciencedirect.com/topics/engineering/perceptron

But little did anyone know that this simple discovery would lead to multiple unprecedented breakthroughs in the field of machine learning.

This model of a sequential data stream processor was widely adopted and researched, leading to highly computationally efficient models such as:

· Multi-Layer Perceptron

· Convolutional Neural Network

· Recurrent Neural Network

· Transformer Network

And the list goes on.

But we wont be talking about those today. The topic of today will be regarding neurons themselves, synapses, and how Hebb’s Theory has led to a unique type of Machine Learning algorithm called “Competitive Learning”.

Hebb’s Theory

Donald Olding Hebb

Donald Olding Hebb was a Canadian psychologist with a deep interest in the mechanism of “learning”. Often called the father of neuropsychology and even the father of neural networks, Donald O. Hebb is an important name in the history of Machine Learning.

Born in Nova Scotia in 1904 to a family of doctors, Hebb earned his Bachelor of Arts degree in 1925. Working at many institutes such as the McGill University, University of Chicago and Queen’s University, Hebb had garnered a passion for the field of Neuropsychology.

He published a book in 1949, namely “The Organization of Behaviour”, which is considered his greatest contribution to the field of Neuroscience. In this book, he talked about the concept of “Hebbian Learning”, known also as “Cell Assembly Learning”.

Source: https://www.datasciencecentral.com/learning-rules-in-neural-network/

Cell Assembly Theory claims that:

“an increase in synaptic efficacy arises from a presynaptic cell's repeated and persistent stimulation of a postsynaptic cell.” -Wikipedia

In layman terms, it states that an increase in the strength of a synapse (the connection between two neurons) is due to the repeated stimulation of the “post-synaptic neuron” (the neuron receiving the signal) by the “pre-synaptic neuron” (the neuron transmitting the signal).

Although it sounds simple, this theory implies much more than what an initial impression signifies.

Often summarized as “Neurons that wire together, fire together”, this approach introduces a concept of specialized neurons.

Naïve Perceptron models house a series of “dumb neurons”, with each neuron having no special purpose, firing for every input and acting as a pawn in the overall computation.

These specialized artificial neurons only fire for a subset of the total input data, with only the most contributive neurons firing for each input, others keeping silent. But how are these special neurons created?

Well you might be surprised by the fact that these neurons do not actually differ in their structure, but rather only in the training process. Every “special neuron” in this network starts its life as a normal neuron.

Formalizing this concept in the field of machine learning was still yet undone, that is, until the foundation of “Competitive Learning”.

Competitive Learning:

Source:https://www.computer.org/csdl/journal/si/2021/06/09415467/1t7h5zvUeOs

Modeled on the concepts laid out in Hebb’s Theory, Competitive Learning aims to bring the concepts of Hebbian Learning to realistic situations.

Competitive Learning is an Unsupervised Machine Learning approach designed to cluster unseen data based on specialized neurons trained to detect that data.

This learning method entails training these specialized neurons based on data the network has never seen before.

In a Competitive Learning Network, our aim is to have only one neuron fire in the layer, instead of the entire cast. This decision is made by locating the most “relevant” neuron in regard to the incoming information and only letting that “winner” neuron decide the output.

Source: https://www.researchgate.net/figure/SOM-Architecture-SOM-training-is-based-on-a-competitive-learning-strategy-1-For-each_fig1_228822871

Training Process:

A Competitive Learning Network starts as a simple multi layer perceptron.

The training process is as follows:

1- Initialize the model and set the weights to a random value between 0 and 1.

2- For the input, calculate the “score” metric for each of the hidden layer neurons with regard to the input. (ex: Inverse of the Euclidean Distance between Input and Weight Vector of the neuron).

3- Find the Neuron with the lowest/ highest score.

4- This input now belongs to the cluster corresponding to this neuron.

5- Adjust the weights of this neuron such that the “score” metric for that input becomes lower/ higher.

6- Go to step 2 for the next input.

In this way, we end up strengthening the “synapse”(here: weight) between the input neurons and the output neurons, synonymous to the concept seen in Hebb’s Theory.

Application:

Competitive Learning has application in many fields, namely:

1) Clustering

2) Dimensionality Reduction

3) Categorization Problems

4) Dynamic Unsupervised Learning

Source: https://www.shanelynn.ie/self-organising-maps-for-customer-segmentation-using-r/

SOM’s used for Customer Segmentation

Dilemma:

“What about the backpropagation?”, you may ask. If only one neuron gets to benefit from one input, then the other neurons will never even get a chance to compete with this “winner” neuron.

To combat this dilemma, we introduce a slightly more complex approach to competitive learning, namely Self Organizing Maps (SOMs).

Self Organizing Maps:

Source: https://ivape3.blogs.uv.es/2015/03/15/self-organizing-maps-the-kohonens-algorithm-explained/

An SOM aims to backpropagate through every neuron, but the magnitude of change is proportional to the “distance” of these neurons to the “winner” neuron. In this way, neurons “closer” to the winner neuron get to learn more from the input as compared to neurons “farther” from it.

But what do we mean by “closer” and “farther”? Is this Euclidean distance? Is this relative distance? Is this the index of the neurons?

Well its completely up to us, actually. This approach allows us to create a function to define what being “similar” or “closer” to the winner neuron actually entails, be it similar weight values, or anything we want.

Based on this, we get a network where every neuron is fighting to gain dominance over a specific subset of the input stream of data, and we can have a sense of an “interpretable” network.

Source: https://en.wikipedia.org/wiki/File:Somtraining.svg

A Self Organizing Map in Action

Some more complex approaches include:

1- GSOM (Growing Self Organizing Maps)

2- GTM (Generative Topographic Maps)

3- TASOM (Time Adaptive Self Organizing Map)

Comparison with Multi-Layer Perceptrons:

Using SOMs, we can have a graph on neurons with each neuron “learning” certain patterns and gaining individual purpose, as opposed to the neurons we see in regular Multi-Layer Perceptrons.

Although SOM’s come under Unsupervised Learning, they show vast future potential in what we could describe a “neuron” as in the future, and if we could bring this specialized approach into the domain of Supervised Learning.

Conclusion:

With this, we come to an end to this brief overview of Competitive Learning and how Hebb’s Theory can be used in emulating brain activity such as pattern recognition.

With ongoing research in this domain, especially in the field of Non Linear Dimensionality Reductions (NLDR), there is hope for future innovations in both the fields of Unsupervised as well as Supervised Learning from these intuitive concepts from Biology

Thanks for reading The Learning Curve!

This post is public so feel free to share it.

Subscribe for free to receive new posts and support our work.

Subscribe now

1. What on Earth is Agentic AI?

Let’s start simple: you’ve all probably heard of ChatGPT, Gemini, or Copilot — you ask them something, they reply. But those are like really smart assistants. Agentic AI is like the smart assistant who doesn’t just answer your questions, also they plan your day, go out into the world, get things done, and then come back with results.

Imagine:

• Book hotels in your travel destination just with a prompt.

• You tell AI : “Please mail Dr. Jimson Matthews to cancel tomorrow’s lab” and it actually sends an email to the professor through your outlook account.

• Automatically fixes your code in your code editor.
  

That’s the leap from reactive AI to proactive AI — from “answering” to “acting.”

2. How Did We Get Here? (The Journey in Short)

The first trainable perceptron was made by Frank Rosenblatt in 1957. Many ML models we use today were conceptualized before the 2000s. Its only now that hardware has caught up sufficiently for us to deploy them. With deep learning, we got generative AI — tools that could write, draw, code.

The missing piece? Action.
GenAI could talk, but it couldn’t do. The recent shift to agentic AI happened because:

1. Models became good at understanding complex goals.

2. APIs allowed AI to control tools (browsers, spreadsheets, IDEs).

3. There’s a ton of structured + unstructured data available.

4. Cloud providers built infrastructure for AI to operate autonomously.

3. Core Superpowers of Agentic AI

Let’s break down the big traits -

(a) Autonomy

An agent doesn’t need to be spoon-fed every step. You give it the “what” and it figures out the “how.”

Example: In a campus hackathon, you could tell an AI agent “Build me a campus navigation app for freshers.” It would plan the architecture, fetch open map APIs, write the code, and even test it.

(b) Proactive Multistep Planning

Instead of answering one-off prompts, it can:

1. Break the problem into steps.

2. Work through each step in order.

3. Adapt if something goes wrong.

It’s basically project management without the project manager breathing down your neck.

(c) Environment Awareness

Agents can sense and adapt. If a website changes its layout or your data source fails, the AI re-routes without you having to debug every little thing.

For research, that means you could ask:
“Find recent arXiv papers on quantum machine learning, summarize them, and suggest possible project topics.”
The agent can crawl sources, deal with access errors, and still get the output.

4. Where Are They Being Used Right Now?

Let’s see some real-world playgrounds where agentic AI is already making waves.

(a) Cloud & Infrastructure

• AWS Bedrock AgentCore: A framework to deploy enterprise-scale AI agents securely. AWS even set up a $100 million fund to support agent-based startups.
  Think: If you’re building a B2B AI tool in your final year, this is where you’d deploy it.

• Google Cloud Agents: They now have agents for data science, engineering, and coding tasks. These can automatically clean datasets, write SQL queries, or debug Python notebooks.

(b) Government & Enterprise

• SAS AI Agents: Built for transparent decision-making — big in sectors like finance and public policy where explainability matters.

• Microsoft’s Vision: They imagine your entire OS being agentic — your Windows laptop could anticipate your next task and set things up before you click anything.

(c) Creative Industries

• Fashion: Luxury brands like LVMH are testing backend agents for planning product launches.

• Retail: Imagine a shopping site with an AI that knows your style from past orders, then proactively suggests your next outfit.

5. What’s Under the Hood?

Okay, how does this actually work? In tech terms:

1. Perception Layer – Takes in data from the environment (APIs, files, sensors).

2. Reasoning Layer – Breaks down the goal into sub-goals and decides next steps.

3. Action Layer – Executes those steps (write code, send email, scrape web).

4. Feedback Loop – Monitors the outcome and adjusts the plan if needed.

It’s not one monolithic model — often multiple AI models + traditional code working together in a multi-agent system.

6. Challenges & Risks (a.k.a. Why We Can’t Just Let Them Loose)

• Trust: If an AI agent can take actions, how do you make sure it doesn’t delete your files or email your professor something embarrassing?

• Data Privacy: Agents often need access to sensitive data — a big security headache.

• Error Recovery: What if it books the wrong train ticket or executes wrong code?

• Explainability: For legal or safety reasons, we must know why an agent did something.

Researchers talk about AI TRiSM — Trust, Risk, and Security Management — as the foundation for safe deployment.

7. The Road Ahead (Future You Might Work On This)

Here’s where the next-gen work is heading — and possible career ideas.

1. Self-Healing Systems – Agents that detect when something breaks (like a code pipeline) and fix it instantly.

2. Domain-Specific Agents – Special agents for medicine, law, education.

3. Physical Integration – Think drones, lab robots, or smart grids controlled by AI agents.

4. Modular Architectures – Plug-and-play AI components you can swap out, like Lego blocks for automation.

5. New Business Models – Subscription-based agents, or pay-per-task “AI freelancers”.

8. Why Should You Care ?

• Projects: Agentic AI is a hot area for hackathons, internships, and research papers.

• Jobs: Startups and tech giants are desperate for talent who can design and debug agent workflows.

• Entrepreneurship: You could launch a campus-focused AI product this year and scale it nationwide.

• Interdisciplinary Scope: This is one of those rare tech areas where CS, EE, Mech, Design, and even Bio majors can collaborate. Things are not strictly computer science specific and can be easily learnt by students in any field. Electrical engineers can build the sensor networks and edge devices that feed real-world data to agents, while mechanical engineers and roboticists can integrate them with drones, lab robots, or autonomous machines. Students from Molecular Biology or Biomedical Engineering can develop domain-specific agents for lab automation or patient monitoring. Even business and management students play a key role in identifying high-value use cases and designing operational strategies for agent deployment.

Final Thought

Agentic AI is not just a buzzword. If you start learning how these systems are built, controlled, and evaluated right now, you’ll be ahead of 90% of the tech crowd by the time you graduate.

Further Reading

• Building a Multi Agent AI Travel Planner using Gemini LLM + Crew AI

  https://medium.com/google-cloud/agentic-ai-building-a-multi-agent-ai-travel-planner-using-gemini-llm-crew-ai-6d2e93f72008

• Introduction to Model Context Protocol (MCP)

  https://medium.com/google-cloud/model-context-protocol-mcp-with-google-gemini-llm-a-deep-dive-full-code-ea16e3fac9a3

Has this ever happened to you?
You’re scrolling through LinkedIn when a post catches your eye. Someone’s built something that sounds straight out of a tech dream: predicting stock prices, detecting diseases from medical scans, recommending the perfect movie, or even controlling autonomous robots. It looks complex and cutting-edge. Definitely something that must have taken months of hard work.

Curious, you click the GitHub link, imagining you’ll find thousands of lines of intricate code packed with mathematical formulas, tensor operations, and cryptic algorithm names. You picture a screen filled with matrix multiplications, derivatives, and custom gradient descent loops.

And then… surprise.

The entire “machine learning” part is about ten lines of Python.
A few import statements, a function call or two, maybe some data loading and boom, it works.

Wait, what?
Weren’t we told that machine learning is all about deep statistics, hardcore calculus, and dense linear algebra? Didn’t we believe that every AI project involved writing complex functions for backpropagation and optimization from scratch?

Yet here’s someone building a full-fledged chatbot, image classifier, or prediction system in less than a hundred lines of code and posting it online for the world to see.

So… what’s going on here?

Should we reinvent the wheel?

The appearance of neatly packaged libraries like Pytorch, Scikit-Learn and TensorFlow have opened a serious debate about how we should learn ML. These libraries take care of the complicated math and make writing code much easier. But using these libraries often tempt people into ignoring the underlying systems which are so vital to ML.

This is similar to many ordinary things we do in real life, for example we drive cars without thinking about Internal Combustion Engines.

Here’s a brief way to implement an ML model:-

1. Data Collection
Every machine learning journey starts with data. Sometimes lots of it. If your use case is stock price prediction, you’ll need historical financial data. If it’s medical imaging, you’ll need labelled scans. If it’s a recommendation system, you’ll need user interaction logs.
This step is all about deciding exactly what problem you’re trying to solve and finding the raw material that will make it possible. Sometimes you’re lucky and the data is already neatly packaged on sites like Kaggle. Other times, you’ll have to scrape it from websites, connect to APIs, or manually gather it from different sources.

Think of this as going to the market before cooking . You can’t make a dish without ingredients.

2. Data Preprocessing
Now that you have your “ingredients,” you can’t just throw them into the pot and expect a masterpiece. Real-world data is messy it’s full of missing entries, inconsistent formats, irrelevant information, and random noise.
Data preprocessing is where you clean, organize, and transform your raw data into something a machine can understand. This might involve:

· Filling in missing values so the model doesn’t get confused.

· Removing duplicates or irrelevant entries.

· Normalizing numbers so features are on a similar scale.

· Encoding categories or text into numerical values.
This step is like chopping vegetables, marinating meat, and measuring spices before you start cooking. Without it, the final dish (your model) will likely fail.

3. Model Selection
With clean data ready, it’s time to decide which “chef” will cook your dish. In ML terms, that means choosing an algorithm or architecture.
If your task is simple classification, maybe a decision tree or logistic regression will do. If you’re working on image recognition, you might go for a convolutional neural network (CNN). For text-based problems, you might reach for a transformer model like BERT or GPT.

The good news? You don’t have to implement these models from scratch libraries like scikit-learn, keras, and transformers provide these algorithms pre-built and battle-tested. You just pick one, configure a few settings, and you’re ready to go.

4. Training and Validation
Now comes the heart of the process: teaching your model to recognize patterns in the data.
You feed it your processed dataset, and behind the scenes, it does all the mathematical heavy lifting calculating losses, adjusting weights through backpropagation, optimizing with gradient descent without you writing a single equation.
While training, you also keep a separate validation set to check if your model is actually learning or just memorizing (overfitting). Validation is like tasting your dish while it’s still cooking making sure it’s on track before serving.

5. Evaluation
Once training is done, it’s time for the taste test. You bring out a fresh batch of data your model has never seen before and let it make predictions.
You then score its performance using metrics such as accuracy, precision, recall, F1-score, or loss. This is where you find out if your model is actually useful in the real world or just looks good in theory.

6. Tuning and Iteration
Rarely does the first attempt produce the perfect result. This step is about fine-tuning and iterating until you get the performance you want. You might:

· Adjust hyperparameters like learning rate, number of layers, or batch size.

· Try different algorithms altogether.

· Go back and collect more or better-quality data.
Machine learning is often an iterative process — you loop back to earlier steps, make changes, and try again until you’re satisfied.

And just like that you’ve built and run your first machine learning model.
You didn’t have to manually write matrix multiplications, calculate derivatives by hand, or code your own gradient descent from scratch.
Instead, you stood on the shoulders of giants leveraging years of research and engineering condensed into a few powerful library calls.

So is the mathematics to be ignored completely ?

At some point, curiosity kicks in. You start wondering: What’s actually happening behind the scenes?

Why does changing one parameter make my model better, while another change makes it worse?

What’s going on inside that “train” function?

That’s when you begin the real journey moving from just using machine learning to truly understanding it.

This shift means taking full control of the process. Instead of relying entirely on pre-built tools, you dig into the mechanics of how they work. You stop seeing a model as a “black box” and start understanding it as a system made up of smaller, interacting parts each one with its own purpose.

Here’s what this deeper learning might involve:

• Understanding the math behind training :-

Not to become a mathematician, but to know the “why” behind each step. For example, learning how gradient descent works helps you see why the model gradually improves over time, and why it sometimes gets stuck.

• Building algorithms from scratch :-

Maybe you’ll implement a decision tree, a neural network, or even your own version of linear regression. This isn’t about replacing libraries, but about understanding the steps they perform for you.

• Reading research papers :-

At first, they might seem dense, but they’re where the newest, most powerful ideas in ML appear. Even reading summaries or blog explanations can give you insights into what’s possible.

• Joining a community or study group :-

Whether it’s a local meetup, an online forum, or a college club, being around other learners can help you get answers, stay motivated, and discover new resources.

This path takes more time and effort. It’s like learning how to build and fine-tune an engine instead of just driving a car. You might spend weeks just understanding one algorithm, and months before you feel comfortable with the math. But once you have that knowledge, you’re no longer limited to using pre-built solutions you can create your own. That means you can tackle unique problems, customize models to your exact needs, and even innovate in ways no one else has tried.

Long story short learning the internals of machine learning gives you freedom. You move from being a driver of someone else’s creation to being the engineer who can design anything from a simple go-kart to a rocket.

Conclusion

The choice between using machine learning and learning machine learning comes down to speed versus depth. Using ML is quick to start, requires minimal technical background, and works well for building prototypes or solving well-known problems. However, it often relies on pre-built tools with limited customization and can feel like a “black box.” In contrast, learning ML from the ground up takes longer and demands a deeper commitment to study, but it offers full control, transparency, and the ability to innovate. If your goal is to deliver something fast for a familiar task, using ML is often enough. If you want to push boundaries, address unique challenges, or contribute to cutting-edge research, learning ML is the path to take. In some cases, the most effective approach is to combine both: use ready-made ML components when they are just one part of a larger project, while applying deeper ML knowledge to the critical areas where customization or optimization is essential.

Coming back to the topic, game development isn’t just about fun; it’s a field where creativity meets code and transforms lines of logic into living, breathing worlds. From billion-dollar franchises to deceptively simple sensations or the notoriously rage-inducing, games have proven that both scale and simplicity can be wildly rewarding.

In this article, my aim is to take a deep plunge into this new (🤨) field with you. We’ll explore how game development is a beautiful concoction of almost all other fields of computer science you might be already aware of. We’ll see how one can start exploring this field, how rewarding it can be and also why possibly your definition of “rewards” has been wrong all this time. I’ll try to explain everything in a lucid, fun and engaging manner. With all this, hoping we’re all equally excited, let’s begin!!

Case Study : Flappy Bird – The simpler the better?

In 2013, a little-known Vietnamese developer named Dong Nguyen created a simple mobile game called Flappy Bird. Built in just a few days, the game featured a pixelated bird navigating through Mario-like pipes - hardly a graphical masterpiece. For months, it went unnoticed.

But then something unexpected happened: Flappy Bird went viral, climbing app store charts worldwide. At its peak, it was generating over $50,000 per day in ad revenue. The simplicity, frustration, and addictive design turned it into a cultural sensation.

From an unknown indie coder to a name recognized across the gaming industry, Nguyen’s story proved that you don’t need a AAA budget to strike gold. Sometimes, all it takes is a clever idea, solid execution, and a touch of luck.

Case Study: Supercell – From Struggles to Mobile Gaming Giants

In 2010, a small Helsinki-based start-up named Supercell set out to make games. The early days weren’t easy - their first few projects failed, and the company was close to shutting down. Instead of giving up, they embraced a bold philosophy: “the best teams make the best games.”

Supercell gave its small, independent teams full creative freedom. That freedom led to the release of Clash of Clans in 2012 - a mobile strategy game that redefined what mobile gaming could be. It quickly became a global phenomenon, earning millions daily and cementing Supercell’s reputation.

They didn’t stop there. Titles like Clash Royale, Boom Beach, and Brawl Stars followed, each capturing massive audiences worldwide. By 2016, just six years after its founding, Supercell was valued at $10.2 billion, making it one of the most successful gaming companies ever - all from a country with fewer people than New York City.

So what can we conclude from these case studies?

A well-timed idea, coupled with the right execution, can captivate millions of players worldwide — and sometimes even become a cultural phenomenon. Beyond the entertainment, the industry itself is booming, offering lucrative opportunities for developers who are willing to dive in and innovate.

Now that we have a bit of background, let’s say we want to start making games. Now what? How do we do it? What do we need to get started?

The answer is

Game Engines : The powerhouses behind every game

A game engine is the core software framework that powers a video game. It provides ready-made systems for graphics rendering, physics, audio, input handling, AI, and scripting, so developers don’t have to reinvent the wheel every time they make a game.

Without game engines, building even a simple game would require writing thousands of lines of low-level code just to display characters, detect collisions, or play sounds. Engines save time, streamline workflows, and allow developers to focus on creativity, storytelling, and gameplay rather than technical grunt work. The three most popular gaming engines in the world are Unity, Unreal and Godot - all of these are described below.

Unity

Unity is one of the most versatile and widely used game engines in the world. It supports both 2D and 3D development and is especially popular among indie developers and mobile game creators. With its massive asset store, developers can buy or download ready-made models, scripts, and tools to speed up development.

• Strengths:

  • Cross-platform deployment (PC, mobile, console, VR, AR).

  • Beginner-friendly with a large community and tutorials.

  • Huge library of assets and plugins.
    
    

• Notable Games: Among Us, Monument Valley, Pokemon Go, Subnautica.
  
  

• Best For: Beginners, mobile/indie developers, and rapid prototyping.

Unreal Engine

Developed by Epic Games, Unreal Engine is known for its photorealistic graphics and is a staple in the AAA gaming industry. It’s used to build high-end PC, console, and VR games, but it’s also flexible enough for indie developers. Its signature tool, Blueprints, allows for visual scripting, making it easier for non-programmers to create complex mechanics.

• Strengths:

  • Industry-leading graphics and rendering.

  • Visual scripting (Blueprints) + powerful C++ backend.

  • Free to use with a royalty model (Epic takes a small share after success).
    
    

• Notable Games: Fortnite, Valorant, Street Fighter.
  

• Best For: High-end 3D games, cinematic experiences, and VR/AR projects.

Godot

Godot is an open-source game engine that has been rapidly growing in popularity. Unlike Unity or Unreal, it doesn’t have a corporate owner, meaning it’s completely free with no licensing fees or royalties. It’s especially loved by indie developers for 2D games, but it also supports 3D (with improvements coming rapidly). Godot uses its own scripting language called GDScript (similar to Python), but also supports C# and C++.

• Strengths:

  • Lightweight, flexible, and completely free.

  • Excellent for 2D development.

  • Active and passionate open-source community.

• Notable Games: Deponia (port), Kingdoms of the Dump (in dev), many indie titles.
  

• Best For: Indie devs, students, experimental projects, and those who prefer open-source tools.
  
  

In short: Unity is the jack-of-all-trades, Unreal is the AAA powerhouse, and Godot is the rising open-source hero of game engines.

Unity is the standard engine that works well on most devices, whereas Unreal will cause difficulties on low spec PCs. Godot isn’t as popular as the other two options yet and features less intensive resources. Consider these points before selecting your game engine.

Now that we’ve selected a game engine, it’s time to program our game. Thankfully, these game engines make the job quite easy for us and the programming involved is not as hard as one would assume. The programming is largely object-oriented (oops 🥲) and the various libraries and in built functions provided by the game engine specific libraries leave our work down to merely selecting the correct assets, controlling and selecting appropriate game audio, controlling object physics, handling multi-player functionalities, etc. All of this makes developing a simple game fairly easy in a game engine. Another mistake many people make is that they try to learn all the nooks and crannies of the development framework before getting into actual projects. However, a more encouraged approach is to dive right into projects and learn while building. In my experience, this enhances both retention and problem solving skills.

So at this point, go ahead!
Select a simple idea, choose a game engine, fiddle around with some code and come up with a game of your own!

You may also publish it and even monetize it on free-to-use platforms like itch.io, Kongregate, Newground, etc. We would love to see your creations! Share relevant links here (https://forms.gle/YatUbCepKb6pfHjF7) and we’ll go through all of them! (Well the Inter IIT Tech Meet promises a game dev PS every year … soooo 😉)

Make sure you make a submission, preferably by month end. Even a simple one (in fact the simpler the better :) ) would make our efforts worthwhile. You are of course free to use any of the AI tools you use everyday - speaking of which….

Artificial Intelligence, Machine Learning and … Game Development ?

Imagine playing a game where the enemies don’t just follow pre-coded patterns, but actually learn from your every move. You dodge their attacks once, they try something new the next time. This is the promise of Machine Learning (ML) in game development — a shift from predictable scripts to adaptive, intelligent systems.

ML is already sneaking into many corners of game design. Non-playable characters (NPCs) can become smarter, learning strategies instead of mindlessly repeating routines. Worlds can be built dynamically through procedural content generation, meaning every player gets a unique adventure. Games can even adjust their difficulty in real time, predicting when a player is getting bored or frustrated and tweaking the experience to keep them engaged.

It doesn’t stop at gameplay. Machine learning also fuels voice synthesis, motion capture, and lip-syncing, making characters feel more alive. Behind the scenes, ML agents can even playtest games thousands of times faster than humans, spotting bugs or balance issues before release.

From survival horror titles like Alien: Isolation (with its cunning, unpredictable alien) to expansive universes like No Man’s Sky (built on procedural generation), we’ve already seen glimpses of this future. And as ML grows, games will no longer just be hard - coded experiences - they’ll be living, evolving worlds that will learn and react to us, glimpses of which we can already see in various places.

Okay, all of this seems pretty fun. But what do I get out of this?

With the rapid increase in demand for unique indie experiences, the exponential growth of the gaming and entertainment sector, and the relatively low competition in the current market, game development may turn out to be a very rewarding field for aspiring software developers. Conventional game development hackathons, internships and placement opportunities also feature much lower competition compared to standard SDE roles.

Also, yearning for just monetary benefits by jumping into more conventional sectors might seem tempting, but in my humble opinion, a real engineer is not a web developer. Not a data analyst. Not a game developer for that matter. A real engineer is a problem solver, and the sooner you develop the “Give me any problem and I’ll solve it somehow” attitude by venturing into and exploring diverse fields, the richer the long term rewards are.

Beyond just career prospects, game development is a space where logic meets imagination — where the skills you’ve built in coding can breathe life into entire worlds. Whether it’s a simple mobile hit, an indie masterpiece or an immersive universe, every game starts with the same spark: an idea. And with today’s tools, that spark can come from anyone — even you.

So maybe the next time you think about building yet another portfolio website, ask yourself: why not build the next game the world can’t stop playing?

Some interesting resources :

As far as learning is considered, a good mix of documentation, courses and fiddling around is recommended. However, for developing interest, I’d suggest the following channels on YouTube.

1. Code Bullet (@CodeBullet)

2. Dani (@danidev)

3. Game Dev Experiments (@GameDevExperiments)

4. Thomas Brush (@thomasbrush)

Documentation :

1. Unity official documentation : https://docs.unity.com/en-us

2. Unreal official documentation : https://dev.epicgames.com/documentation/en-us/unreal-engine/unreal-engine-5-6-documentation

3. Godot official documentation : https://docs.godotengine.org/en/stable/

Following the viewing of Iron Man, most people think that they can simply hammer together some metal plates, tighten a few bolts, plug in some wires, load some “magic” code, and produce a flawless functional robot instantly. However, robotics is a blend of art and engineering that requires more than a wrench and Wi-Fi. Hardware development and production involve good planning, accurate measurements, intelligent material selection, and mechanical design expertise similar to structural engineering in civil work.Electronics animate your invention, with sensors, microcontrollers, and power supplies functioning as the robot’s nervous system and pulse.Software from motor control programs to advanced AI is the brain, determining how the robot moves, responds, and adapts.When you begin, you don’t require costly resources or a stack of texts. As Rancho in 3 Idiots, your insightful mind, concentration, and imagination are your greatest tools. Start with simple tools, repurposed materials, inexpensive sensors, and minimal code learn by creating, not by expecting the “perfect” lab.

But if you want top-performance robots you’ll have to become proficient in load distribution, structural integrity, circuit reliability, signal processing, and neat, efficient code.

A robot is just as powerful as its weakest link mechanical strength, electrical stability, and software must all be in harmony for it to shine.

From Sketch to Simulation: Crafting Your First Robot in SolidWorks, ROS, and Gazebo:

Building a robot is a pretty wild journey, and these three tools are your best friends. First, you’ve got SolidWorks, which is basically your personal, infinite digital workshop. You get to sculpt every little piece, from tiny screws to the whole frame, right on your computer. It’s like building the most complex LEGO set you can imagine without ever losing a single brick. Then you need to give your robot a brain and a voice. That’s where ROS2 comes in. Think of it as the robot’s nervous system, letting all its different parts the cameras, the motors, the sensors chat with each other so they can work together as one smart, coordinated team. And before you set your creation free in the real world, you send it to a virtual playground called Gazebo. Here, it can run around, practice its moves, and even crash a few times, all without you having to worry about a single dent. It’s the ultimate risk-free sandbox for your robot to learn and grow.

How SolidWorks Works

1. Start with a 2D Sketch

• You pick a plane (front, top, or right) and draw basic shapes (circles, rectangles, lines).

• You then add dimensions and constraints so the shape has exact sizes and relationships.

2. Turn Sketches into 3D Models

• Use features like Extrude (pull the sketch into a solid), Revolve (spin it around an axis), or Sweep/Loft (shape along a path) to create 3D parts.

• You can cut shapes out of solids with Extruded Cut or add details like fillets and chamfers.

3. Create Assemblies

• Multiple parts are brought together in an assembly file.

• Use mates to define how parts connect (hinges, sliders, fixed joints).

• This helps check movement, fit, and function before building.

4. Generate Technical Drawings

• From the 3D model, you can automatically create 2D engineering drawings with dimensions, views, and annotations for manufacturing.

Learning Resources

• Official SolidWorks Tutorials: https://my.solidworks.com/training offers guided lessons and quizzes.

• YouTube Playlists: Find beginner to advanced tutorials, such as SolidWorks Mechanical Design and SolidWorks Beginner Modeling.

ROS Basics -The Robot’s Communication Magic

When you build a robot, you’re really building a team of little programs that work together and ROS2 helps these programs talk smoothly. Here’s how it works:

• Node: Think of a node as a tiny robot brain that does one specific job. For example, a camera node takes pictures; a motor node moves the wheels. Each node is like a specialist in the robot’s team.

• Publisher: This node sends out information. Imagine the camera node publishing a new image every second like a radio DJ broadcasting a show.

• Subscriber: These nodes listen for information. The image-processing node subscribes to the camera’s broadcast to get pictures and analyze them.

• Topic: Topics are channels carrying info between nodes, like radio frequencies. Nodes agree to send and listen on specific topics e.g., /camera_feed carries camera images to whoever needs them.

• Message: The actual data being sent the package inside the envelope. For example, image pixels themselves are messages.

A Real-World Twist: LiDAR Car Example

Imagine an autonomous car safely driving through busy streets. It uses a LiDAR sensor to “see” the world by sending out laser pulses and measuring distances.

Here’s how ROS2 helps the car’s brain parts talk:

• LiDAR Node (Publisher): This node collects raw data from the LiDAR sensor points showing distances to nearby objects. Every few milliseconds, it publishes this data on a topic called /lidar_points.

• Message Example: A list of points, each with X, Y, Z coordinates representing objects around the car. For example, “I see an object 2 meters ahead at coordinates (1.0, 0.5, 0.0), another at (3.0, -1.0, 0.0).”

• Obstacle Detection Node (Subscriber): This node listens to /lidar_points. When new data arrives, it processes the points to decide if something is too close and if the car should stop or steer away.

Key Point:
The LiDAR node doesn’t care how obstacle detection works it just publishes accurate data. The obstacle detection node doesn’t care how LiDAR collects data it just listens and reacts.

In simple terms:

• The publisher says: “Here’s where the obstacles are!”

• The subscriber listens and decides: “Is anything too close? Let’s react!”

• The topic /lidar_points is the communication channel connecting them.
  

This publisher–subscriber model lets different robot parts work independently but communicate clearly making it easier to build complex, reliable robots!

It’s just basic Thing how ros2 works it includes lots of code and lots of brain storming first of all it works on linux yeah no more windows you are engineer and linux give you pretty cool things to do

ROS2 GUIDE AND HOW TO INSTALL IT -

1. How to install Linux - https://docs.google.com/document/d/1ovVjGJeb6f9STikrlrPXCSZVJJ6iNLbGXxo_WtIGy2w/edit?tab=t.0

2. How to install and use = https://panav.gitbook.io/robotics-handbook/ros-advanced/ros-1/manual-and-quick-setup

3. Documentation = https://docs.ros.org/

Gazebo:-

Gazebo is a 3D robot simulator where you can simulate and debug your robot design, code, and sensors in simulation prior to getting hands on real hardware.

How it works:-

3D Environment:

Gazebo replicates a simulated environment from a small lab space to a crowded street intersection with real-world lighting, texture, and hazards.

Physics Engine:

It employs engines such as ODE, Bullet, or DART to compute forces, friction, collisions, and even gravity. Your robot crashes, falls, and responds exactly as it would in the real world.

Robot Models (URDF/SDF):You provide Gazebo with your design of robot as SDF (Simulation Description Format) or URDF (Unified Robot Description Format) that defines its weight, dimensions, joints, and sensors.

Sensors Simulation:

Gazebo can mimic real sensors LiDAR scans, camera images, GPS signals and provide that information to your software as if it were from real hardware.

Integration with ROS2:

ROS2 talks to Gazebo using plugins, therefore your ROS nodes (publishers/subscribers) can publish commands and subscribe to simulated sensor data. That is, you can author the code you write in Gazebo and then run it on your real robot with minimal modification.

1.How to install Gazebo : https://gazebosim.org/docs/latest/install_ubuntu/

2. Build your First Robot: https://gazebosim.org/docs/fortress/building_robot/

SENSE of Sensors,microcontrollers and microprocessors:-

Microcontrollers:-

One of the most awesome aspects of robotics is the microcontroller a small but mighty computer that is the brain of your robot. It contains a CPU to execute information, RAM to hold it temporarily, and flash memory to hold it permanently. The microcontroller speaks to the outside world via I/O pins, which may read from sensors and write to devices such as motors, LEDs, or speakers. Microcontrollers are a total requirement in robotics whether you’re creating an autonomous car, a drone, or even a simple tic-tac-toe-playing robot, they read data, process it, and get your creation moving.

Many of you have heard of Arduino and ESP32 two of the most popular microcontrollers in the world. They’re like the tech version of “Chhota Packet, Bada Dhamaka” You can connect them to your phone via Bluetooth or link them with a controller, and give instructions so your robot can work for you, talk for you, or even walk for you.

Wokwi (for basic simulations)- https://wokwi.com

Basic arduino playlist- https://youtube.com/playlist?list=PLV3C-t_tgjGE1USbPg2jrrDMu26F_M7K-&si=OevVRh300v3_cV-M

Basic Documentation - https://docs.arduino.cc/tutorials/

Microprocessors:-Microprocessors are like crazy cpu boards like the Jetson Nano or Raspberry Pi. These are just like tiny computers, complete with CPUs and RAM, usually ranging from 4 GB to 8 GB. They run on Windows or Linux. And here’s the wild part: you can even run a local LLM on them. Isn’t that crazy? It’s like the power of AI on the palm of my hand.

Other examples include the Raspberry Pi 4, Raspberry Pi 5, NVIDIA Jetson Xavier NX, and the BeagleBone Black. These little boards are like superheroes in disguise tiny but surprisingly powerful. Some, like the Jetson series, even come with their own GPU , which makes them perfect for AI and robotics.

People use them for everything from robot dogs that follow you around to retro gaming consoles. Basically, it’s the nerd version of “pocket magic.”

Sensors:-

And then, the sensors your robot’s eyes, ears, nose, and whiskers. There’s a sensor for just about everything: temperature, distance, height, depth, speed, angle, thrust, weight, and the like. Using them, you don’t have to be a master, you simply find the one you’re looking for, read the instructions, and plug it in. And then it’s a matter of testing, debugging, and sorting things out, typically with a happy mess of jumper cables scattered across your workbench. Coupled with microcontrollers, sensors are what allow your robot to sense, think, and behave.

PCB and Control System:-

PCB (Printed Circuit Board) design is the process of creating the layout for electronic circuits, ensuring all components are correctly connected and manufacturable. The process involves schematic capture, component placement, routing, and generating manufacturing files (Gerber files).This is where the real engineering magic happens. A PCB isn’t just a green plate with lines it’s the highway system that tells electricity where to go. When you’re designing one, you’ve got to think about signal integrity, power distribution, grounding, and component placement (because putting a capacitor in the wrong spot can turn your circuit into a fireworks show ). On the control systems side, you’re basically playing conductor , making sure motors, sensors, and feedback loops all stay in rhythm. That means brushing up on PID controllers, stability analysis, and tuning methods. If you’re diving into this world, don’t just copy circuits from the internet actually learn to read schematics, run simulations (like LTspice), and use tools like KiCad, EasyEDA or Altium for designing and testing PCBs.

Machine learning:-

These days we see companies like NVIDIA showing off crazy robots and AI demos almost every week it feels like they’re pushing the limits nonstop. At the core of all this is Machine Learning, one of the most important parts of robotics. It’s basically the brain that handles how your robot sees the real world and understands what’s happening around it. With deep learning, it can recognize faces, objects, and even hand gestures.

Then there’s reinforcement learning (RL), which is super cool because it teaches your robot by letting it play around and learn from mistakes. Imagine training a robot dog: at first, it stumbles everywhere, but every time it walks straight, you give it a “virtual cookie.” Over time, it figures out the best way to move, balance, or even play fetch. RL has been used to train drones to fly smoothly, robotic arms to solve Rubik’s cubes, and even robots that learn soccer tricks.

People use ML in robots for all sorts of things: drones that can dodge obstacles, vacuum cleaners that map out your house, or arms that can pick the right fruit from a tree without squashing it. And the crazy part is, you don’t always need a supercomputer sometimes even a small GPU board like a Jetson Nano can run these models.

What to learn:-

I see a lot of people getting confused about what to learn in robotics it feels like too much at once. The learning curve in robotics is very deep, and you can’t master everything easily. You have to study consistently and put in real effort. But here’s the thing: just start. You’ll learn by doing, you’ll make mistakes, and those mistakes will teach you. Once you start, curiosity takes over, and meta’s recommendation algorithms do the rest

Robotics doesn’t have as many learning resources compared to other fields. I’ve noticed that when a niche doesn’t have too many resources, the people who actually take the time to learn it become rare and valuable. So the very first skill you need is learning how to search for anything. The below flowchart is very simple just to give you basic sight how You can learn and differentiate topics.

If you want to explore more about robotics- https://panav.gitbook.io/robotics-handbook(Credits - Panav Arpit Raj)

Most of what you just read isn’t even 1% of robotics because robotics isn’t something you can fully learn from reading; you have to do it yourself, with countless sleepless nights along the way. You’ll never be 100% “ready” it’s a leap of faith every time you start building. You might do everything right, but maybe one jumper wire isn’t making contact, or an IC is busted, and suddenly you have to check everything your circuits, sensor outputs, and code. One wrong connection and boom back to square one. But in the end, it’s all part of the fun, and the struggle becomes something you’ll remember. And finally, when your code works or when your robot moves or when your simulation works,you will understand why you started this.