DEV Community: Ankit Thakur

Starbi

Ankit Thakur — Tue, 13 Oct 2026 09:02:54 +0000

What I Built

Starbi is a small custom PCB that works as a pocket sensor buddy. It's built around a Seeed XIAO ESP32-C3 and combines an OLED display, an MPU6050 motion sensor, a DHT11 temperature and humidity sensor, and two buttons. Tilt it, shake it, or leave it on your desk, and it shows what it senses on screen.

Who would pay for it? Makers, students, and workshop organizers. A first PCB is intimidating, and most people end up with a breadboard full of loose modules and jumper wires. Starbi is a finished, routed board with open design files, so someone can solder it, flash it, and have a working gadget in an afternoon.

The side hustle: sell it as a solder-it-yourself kit (or pre-assembled) through hobbyist marketplaces and maker meetups, or bundle it with a paid beginner PCB workshop. Parts are cheap and the board is small. I haven't sold one yet, so this is the plan rather than a result.

Demo

GitHub repo: https://github.com/ThakuraAnki/Starbi

[Add a screenshot of the PCB editor or 3D view here]

Code

https://github.com/ThakuraAnki/Starbi

How I Built It

I was already planning to make something like a Starbie, so I used it as my starting point. It's a guided project and a good first PCB. I followed the instructions in the original repo: https://github.com/SharKingStudios/Starbie/tree/main

Schematic. I wired up the XIAO ESP32-C3, the OLED display, the MPU6050, the DHT11 sensor, and the two buttons.

Routing. I moved into KiCad's PCB Editor to route everything, but doing it by hand got messy very fast. I looked up some routing tips online to keep things clean. Instead of dragging every ground line around the board, I added a full-board GND copper pour on the top layer so the ground connections happen automatically.

Problems I hit and fixed. When I ran the Design Rules Check (DRC), a few errors came up for trapped, isolated ground pads: Pad 1 on the OLED, Pad 4 on the DHT11, and Pad 2 on J2. After some searching, I found that nearby traces were blocking the ground pour from reaching them. I fixed this by manually routing short bridge tracks from each of those pads out into the ground zone.

Result. After the fix, DRC cleared with 0 unconnected pads.

What I learned: a ground pour saves a lot of routing work, but you still have to check that every ground pad can actually reach it. DRC caught what I couldn't see by eye.

Why Does Open Innovation Matter?

I couldn't have built this without other people's open work. The Starbie repo gave me a guided starting point instead of a blank canvas. KiCad is free and open source, so designing a real PCB cost me nothing. Even my routing fixes came from strangers sharing tips online.

It also matters for the side hustle. Starbi is built on open hardware, so anyone can fork it, swap the sensors, or change the board shape. A small seller doesn't need a license or a gatekeeper. They only need the files, a PCB fab, and an idea. I want to pass that on by keeping my repo open for the next beginner who wants a first board.

Prize Categories

Best Use of Arduino: Starbi is built around the XIAO ESP32-C3, an Arduino-compatible board, and [programmed with the Arduino IDE / Arduino framework, confirm this].

LinguaPal

Ankit Thakur — Tue, 06 Oct 2026 10:42:43 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

LinguaPal is a multi-agent AI English tutor for ESL learners. It trains Reading, Pronunciation, Listening, Writing, and Spelling in one web app, and adapts to each learner's level on the CEFR scale (A1 to C2).

An Orchestrator Agent runs a 6-question placement test, adjusts difficulty from rolling session scores, and generates a 10-minute daily plan built around the learner's weakest skills. Five specialist agents handle the practice, each with its own system prompt and structured output:

Reading: level-appropriate passages, 5 comprehension questions with a rationale for every answer, CEFR-tagged vocabulary, and tap-to-translate on any word (IPA, definition, and mother-tongue translation)
Pronunciation: the learner records their voice in the browser and gets a score out of 100, mispronounced words, IPA contrasts, and articulator tips
Listening: generated two-speaker dialogues, playback at 0.75x, 1.0x, or 1.25x, and a "Listen & Type" dictation mode with word-level diffing
Writing: grammar fixes with the exact replacement and the rule, vocabulary upgrades, tone evaluation, a polished rewrite, and a CEFR estimate
Spelling: orthographic rule explanations, mnemonics, and mini-quizzes built from the learner's own logged mistakes

A spaced repetition engine (SQLite, SM-2 algorithm) resurfaces words and errors right before the learner would forget them. A mascot owl, Pal, encourages learners out loud, and streaks and XP keep them coming back. Mother-tongue help covers 12 languages.

How it gets people off the screen: the daily plan is capped at 10 minutes, so it fits into a routine instead of eating an evening. Pronunciation drills get learners speaking out loud, and the dialogues train them to listen, so the practice carries into real conversations.

Who it's for: ESL learners at any level who want daily, personalized practice without a tutor.

Demo

📹 Watch the demo video

Code

🔗 ThakuraAnki/English_Learning_Agents

How I Built It

LinguaPal uses an Orchestrator + Specialist Agent architecture. Each agent has a dedicated system prompt, a distinct teaching goal, and structured output, so the app can render scores, quizzes, and feedback reliably.

Layer	Technologies
Frontend	React 19, Vite, Tailwind CSS
Backend	Node.js (ESM), Express 4, Multer for audio uploads
AI engine	Google Gemini API via the `@google/genai` SDK (`gemini-2.5-flash`)
Audio	Browser `MediaRecorder` for capture, Web Speech API (`SpeechSynthesis`) for spoken playback
Database	SQLite via `better-sqlite3` (WAL mode)
Memory	SuperMemo SM-2 spaced repetition

Pronunciation scoring sends the learner's recording to Gemini's multimodal audio analysis. Every agent is exposed as its own REST endpoint group, which keeps the model layer separate from the rest of the app.

The model layer is the one part that depends on a hosted API, and I'm upfront about that. Everything around it is open: the agent architecture, the SM-2 memory engine, SQLite, and the application code. With no API key set, the app falls back to a built-in Demo Mode with curated drills, so anyone can clone the repo and try it right away.

Why Does Open Innovation Matter?

Language learning is a space where cost and access decide who gets help. A paid tutor is out of reach for many ESL learners, and a tutor that depends on a metered closed API is only as affordable and available as that provider allows.

Open innovation matters here for three reasons:

Cost and access: open-weight models can run locally or on cheap hardware, which makes free tutoring possible for learners and schools.
Privacy: learners' voice recordings and writing are personal. Local inference keeps them on the learner's device.
Adaptability: an open model can be tuned for specific first languages, accents, and common error patterns, which a closed API doesn't allow.

This project currently relies on Gemini, a closed API. I kept the agents as separate, swappable components so the provider can be replaced, and I published the code so others can take it further, including moving it to open-weight models.

Data Structure Mate cutey

Ankit Thakur — Mon, 05 Oct 2026 02:34:38 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

AI Mate is an AI-powered study buddy for learning Data Structures and Algorithms (DSA).

Many students struggle with DSA, not because the topics are impossible, but because nobody explains why a solution works. AI Mate fixes that:

Brute force to optimal: Paste your worst-case solution and AI Mate walks you toward the optimal one, step by step, instead of just dumping the final code.
Real-world applications: For every topic (Arrays, Strings, Linked Lists, Stacks, Queues, and more), it explains where that data structure is used in real software.
Level-based learning: You pick your DSA level when you sign up (beginner, intermediate, advanced), and the explanations match it.
Built-in quizzes: After each explanation, AI Mate gives you short quizzes so you can check whether the concept actually stuck.

I built this for [my friend / classmates / juniors, fill in who] who kept copy-pasting ChatGPT answers and still couldn't explain their own code in interviews.

Demo

🎥 Watch the demo video

Typical flow:

A student opens the website and logs in.
They select their DSA level.
They chat with DSA Mate: ask about a topic, paste a brute-force solution, or request a quiz.
AI Mate explains, optimizes, and quizzes them.

Code

🔗 GitHub Repository

How I Built It

Architecture (high level):

Student → Frontend (login + chat UI)
              ↓
        Backend (request handler)
              ↓
        Backboard GPT API
              ↓
        Response → Frontend

Frontend: The login screen, level selection, and chat interface. Student details (name, level) are stored in the browser's localStorage, so there's no heavy database setup for a weekend build.
Backend: A dedicated backend folder receives chat requests, attaches a teaching-style prompt, calls the Backboard GPT API, and returns the response to the frontend. This also keeps the API key off the client.
Prompt design: The system prompt tells the AI to behave like a teacher: explain the intuition first, show the brute-force approach, identify the bottleneck, then guide toward the optimal solution, and finally offer a quiz.
Token limits: To control API usage, each student session has a token limit. This is a known limitation, and I'd like to improve it.

Challenges I faced:

Getting the AI to teach rather than just answer took a lot of prompt iteration.
Balancing response quality against token limits.
[Add one real challenge you hit.]

What I'd add next:

Persistent accounts with a real database
Progress tracking and weak-topic detection
Code execution to test optimized solutions
Support for Trees, Graphs, and Dynamic Programming

Why Does Open Innovation Matter?

Most students go straight to a chatbot, copy the solution, and move on. They get answers but not understanding.

Open innovation lets small builders like me take powerful public AI APIs and shape them for a specific, real problem. AI Mate doesn't replace the learning process; it works like a good teacher. It tells the whole story behind the code, shows why the brute force is slow, and quizzes you to confirm you understood. Anyone can fork it, change the prompts, and adapt it for their own classmates or subject.

My Agent Session

[Add your DevRelay session link or agent_session embed here, or delete this section if you didn't use one.]

Prize Categories

Best Use of Backboard
Build with R-CLI, Backboard's open-source terminal coding agent, compare open-weight models through a single Backboard API key, or give an open-source project's assistant memory and RAG.

Paging In OS

Ankit Thakur — Tue, 01 Sep 2026 16:19:41 +0000

Paging in Operating System

Paging is a memory management technique used by an Operating System (OS). It is used to manage the main memory efficiently and allows a process to use memory even when its data is not stored continuously in physical memory.

In paging, the logical memory of a process is divided into fixed-size blocks called pages, while the physical memory (RAM) is divided into fixed-size blocks called frames. The size of a page and a frame is always the same.

How Paging Works

When a program is executed:

The program is divided into fixed-size pages.
The main memory is divided into fixed-size frames.
The OS loads the required pages into available frames.
A page table is maintained by the OS to keep track of which page is stored in which frame.
When the CPU generates a logical address, the OS uses the page table to convert it into a physical address.
Example

Suppose a process has 4 pages:

Page 0
Page 1
Page 2
Page 3

And RAM has available frames:

Frame 0
Frame 1
Frame 2
Frame 3

The pages do not have to be stored continuously. For example:

Page Frame
Page 0 Frame 2
Page 1 Frame 0
Page 2 Frame 3
Page 3 Frame 1

The page table stores this mapping.

So, if the CPU wants to access Page 2, the OS checks the page table and finds that Page 2 is present in Frame 3.

Logical and Physical Address

A logical address in paging is divided into two parts:

Logical Address = Page Number + Offset

Page Number: Identifies the page.
Offset: Identifies the exact location inside that page.

The page number is used to find the corresponding frame from the page table. Then the frame number and offset are combined to create the physical address.
Advantages of Paging
It reduces external fragmentation.
Memory can be used more efficiently.
A process does not need to be stored in continuous memory.
It makes virtual memory possible.
Memory allocation becomes easier for the OS.
Disadvantages of Paging
It requires extra memory for maintaining page tables.
Address translation can increase memory access time.
It can cause internal fragmentation, especially when a page is not completely filled.
Large processes may require large page tables.

Types of Operating Systems

Ankit Thakur — Sun, 07 Jun 2026 08:24:04 +0000

An operating system is the software that manages your computer's hardware and provides services to applications. But not all operating systems are built alike — different use cases call for very different designs.

What is an Operating System?
Think of an OS as the bridge between you and your hardware. When you click "open file," the OS handles the disk read, memory allocation, and screen rendering — all invisibly. Without it, every app would need to talk directly to hardware, which would be chaos.

Batch OS

Jobs collected and executed in groups without user interaction. Early IBM systems used this.

Time-Sharing OS

Multiple users share the CPU simultaneously via rapid context switching. Unix is a classic example.

Real-Time OS

Guarantees task completion within strict time deadlines. Used in pacemakers, flight systems.

Distributed OS

Multiple machines appear as one unified system. Powers cloud computing platforms.

Embedded OS
Lightweight OS designed for specific hardware devices like routers, smartwatches, or printers.

fundaments of OS

Ankit Thakur — Thu, 18 Dec 2025 14:46:49 +0000

-: What is an Operating System?
Okay Lets understand Operationg System without knowing its actual definition suppose we have a computer and we want to Store something into our Memory So how will you store it without an operating system. I think you are blank now so You have to convert into binary number system and give to the hardware then store it. Lets take one more example what if I say you can’t open your devices without help of OS I know it is little bit surprising If you Don’t use OS then occur this Issues such as bulky and complex app(Hardware attraction must be System Software)(System Software is basically operates your Application Software), In easy word which application help us in providing basic interfaces such as file management, memory management, System Security, software updates)and Application software is provide actual works such as specific user tasks Such as video editing , Coding IDES & environment, there are so many examples) Operating system central part is Kernel, A kernel is the core component of an (OS)serving as the essential foundation that provides basic services for all other parts of the OS .

Function of OS:-
*Its provides user interface between user devices with its hardware.
*Resource Manger (OS manages all the things our pc).
*Hides Complexities (without knowing how data stores into memory ).

Thnaku!