DEV Community: Mothilal M

We Finished Our AI Chess Coach: Meet Chaturanga ♟️

Mothilal M — Sun, 07 Jun 2026 17:37:48 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge.

What We Built

Chaturanga (चतुरङ्ग) is an AI-powered chess learning app for iOS & Android, built with Flutter. The idea is simple but stubborn: playing chess and understanding it should happen in the same place.

You play real games against an on-device Stockfish engine, and a grandmaster-style AI coach named "Acharya" sits with you the whole time — you can ask "why that move?" or "what would a GM do here?" and get a clear, human explanation instead of a raw engine evaluation. After the game, a debrief shows your best move, your biggest blunder, and the one concept to take away.

It's named after chaturanga, the ancient Indian game that modern chess descends from — chess was born in India, and this app helps it teach.

What's actually in it:

♟️ Play vs Stockfish — on-device engine, adjustable skill (1–20), with a pure-Dart fallback engine on desktop.
🧠 AI coach (Acharya) — context-aware (gets the live FEN + move history), supports OpenAI and Google Gemini, streams replies token-by-token, and works with the built-in proxy or your own API key (stored only in the device's secure storage).
🔍 Post-game debrief — evaluation chart, best/worst move detection, and a "My Mistakes" trainer that resurfaces your blunders to fix later.
📚 Learn & Quizzes — interactive lessons with arrows/highlights and tactical puzzles, with a streak + daily-challenge loop.
🏆 Gamification — XP and 7 progression tiers (Pawn → Grandmaster), daily streaks, and unlockables.
🎨 Make it yours — 16 piece styles, 4 board themes, sound effects, and smart local notifications.
📦 Offline-first & private — the engine runs fully offline and all progress is stored locally (Hive); there is no cloud account and no tracking.

Tech: Flutter · Riverpod · go_router · Stockfish (FFI) · bishop · squares · Hive · dio · flutter_secure_storage.

🔗 Repo: https://github.com/Mothilal-M/Chaturanga

Demo

https://drive.google.com/file/d/1MgDVRSBaVmaM3h-yf7VK43ELnAL8dAGw/view?usp=drive_link

The Comeback Story

This is exactly the kind of project this challenge was made for.

Before: Chaturanga was an ambitious side project I got most of the way through and then stalled. The hard parts were actually done — the Stockfish integration, the AI coaching loop, the board UI, the lessons/quizzes engine — but it was stuck in "almost":

It still had half-removed backend plumbing (leftover Firebase/Remote-Config references) from an architecture I'd abandoned.
The Learn/Quizzes engines worked, but the content was third-party data I couldn't legally publish, so the app couldn't go public.
There was no real README, no license, no public release — it lived only on my machine.

I stopped because the app was maybe 90% done and everything left was the un-fun 10% — licensing the lesson content, ripping out a backend I'd outgrown, and writing docs — so it quietly sat on my drive for months. This challenge was the deadline-shaped nudge I needed to finally clear those blockers and put it in front of people.

After (what I finished for this challenge):

🧹 Cleared the dead backend — removed the Firebase/Remote-Config remnants so the codebase honestly reflects what it is: a private, local-first app.
✍️ Replaced the unpublishable content with my own — wrote an original starter set of lessons and tactical puzzles in the app's JSON format, so Learn & Quizzes work out of the box and the whole thing is safe to open-source.
📖 Made it a real project — proper README, MIT license, repo description/topics, and a clean public history.
🚀 Shipped it — Chaturanga is now public on GitHub for the first time.

The "almost-done project gathering dust" finally became a finished, shippable app. That's the arc.

My Experience with GitHub Copilot

Copilot was the thing that got me over the "last 10%" hump — the unglamorous finishing work that's easy to procrastinate on.

Repo-wide context that paid off. I added a .github/copilot-instructions.md describing the architecture (Riverpod, go_router, Hive, local-only, the AI-coach flow). After that, Copilot's suggestions actually fit my conventions instead of generic Flutter boilerplate.
Regenerating the content. The biggest blocker was replacing the third-party lesson/quiz data. I used Copilot to scaffold new JSON in the exact schema the app expects — lesson trees (root + variations) and puzzles (fen + solutionUcis) — and to sanity-check positions.

The biggest blocker was replacing the third-party lesson/quiz data. I used Copilot Chat to scaffold new JSON in the exact schema the app expects — for example: "Using the lesson/quiz schema in copilot-instructions.md, generate a beginner back-rank-mate puzzle with a fen and solutionUcis." It got the structure right immediately, so I could focus on verifying the chess instead of the JSON.

Cleanup & consistency. Copilot helped me hunt down and remove the stale Firebase references and keep doc comments consistent across files.
Docs at the finish line. It sped up writing the README and this very post structure.

Once Copilot had that instructions file, it stopped guessing and started writing code that fit the project — five minutes of setup paid for itself within the hour. The flip side: it happily produced chess puzzles with illegal or non-mating positions, so I still verified every fen by hand. A good reminder that it accelerates the work but doesn't replace your judgment.

Team @shudiptotrafder and @mothilal

Thanks for reading! If you want to try it or read the code, it's all here: https://github.com/Mothilal-M/Chaturanga ⭐

A note on the repo: this is a brand-new public repository. The original lessons and puzzles, I don't want to distribute the data, so I stripped that out and shipped a small original starter set in its place — Learn and Quizzes now run entirely on my own content, which is what made it safe to open-source.

We Built a Typesense Dashboard with an AI Brain and It's Lowkey Insane 🧠⚡

Mothilal M — Sat, 28 Feb 2026 16:56:37 +0000

TLDR for the scroll-addicted 📱

We built Typesense UI — an open-source, fully interactive dashboard for Typesense with a built-in AI assistant powered by Gemini 2.0 Flash. You can literally talk to your search data in plain English.

It's free. It's open source. It slaps.

👉 GitHub: github.com/Mothilal-hire10x/typesense-ui
👉 Run it instantly: npx typesense-ui

The Origin Story (a.k.a. why we rage-built this) 😤

If you've ever used Typesense, you know it's an absolute beast of a search engine — blazingly fast, typo-tolerant, and open source. But let's be real... managing collections and documents through cURL commands and JSON payloads?

That's giving 2015 energy.

We wanted something that looks like it belongs in 2026. Something with dark mode (obviously), smooth animations, and — here's the plot twist — an AI that actually understands our data and can query it for us.

So we built it. And honestly? It ate and left no crumbs. 🍽️

What Makes This Different? (It's Not Just Another CRUD App)

🤖 AI Assistant That Actually Understands Your Data

This is the main character energy of the whole project.

The built-in AI chat (powered by Gemini 2.0 Flash) doesn't just answer generic questions — it has full Typesense tool-calling capabilities. It can:

List and inspect your collections
Search documents with complex filters
Create, update, and delete documents
Show results in beautifully formatted tables
Ask for confirmation before destructive operations (it's responsible bestie fr fr)

Just type something like:

"Show me all users who signed up last month sorted by name"

And it literally queries your Typesense instance and returns the results. In a table. With pagination. WHAT.

⚡ The Landing Page Goes STUPID Hard

Not gonna lie, we may have gone a little overboard with the landing page. It features:

3D scene built with React Three Fiber & Three.js
GSAP animations with scroll-triggered reveals
Lenis smooth scrolling (that butter-smooth feel)
Magnetic hover effects on CTAs
Fully responsive, dark-themed, cinematic vibes

It's giving Apple product page energy and we're not apologizing for it.

🎨 The Dashboard Itself (Where the Real Work Happens)

Once you connect to your Typesense server, you get:

Feature	What It Does
Collections Sidebar	Browse all collections with doc counts, search/filter
Advanced Table View	Paginated, sortable, with column picker
Live Search	Instant full-text search across all fields
Dynamic Filters	Auto-generated from schema — text, range, boolean
Document Editor	Create, edit, delete docs with JSON editor
Dark/Light Mode	Because we respect the vibe check
Schema Inspector	View full collection schemas at a glance

Everything is real-time. Type a search query, toggle a filter, click a column header — instant response. No loading spinners holding your life hostage.

How to Get Started (It's Embarrassingly Easy)

Option 1: The One-Liner 🏎️

npx typesense-ui

That's it. That's the tweet. It spins up a local server and opens the dashboard. Done.

Option 2: Clone & Vibe

git clone https://github.com/Mothilal-hire10x/typesense-ui.git
cd typesense-ui
npm install
npm run dev

Open http://localhost:3000, enter your Typesense server details, and you're locked in. 🔐

Option 3: Install Globally

npm install -g typesense-ui
typesense-ui

Setting Up the AI Assistant

Click the ✨ sparkle button in the bottom-right
Enter your Gemini API key (get one free here)
Start chatting with your data like it owes you money

The AI in Action — Some Wild Prompts That Just Work

Here are some things you can literally just say to the AI:

🗣️ "What collections do I have?"
→ Lists all collections with doc counts and schemas

🗣️ "Find products cheaper than $50 sorted by price"
→ Searches with filter_by and sort_by, returns a formatted table

🗣️ "Delete the document with ID abc123 from the users collection"
→ Shows a confirmation dialog first (safety first bestie)

🗣️ "What fields does the orders collection have?"
→ Returns the full schema breakdown

🗣️ "Create a new document in products with name 'Widget' and price 29.99"
→ Creates the doc after your confirmation

The AI has function calling — it doesn't just hallucinate answers, it actually executes real Typesense operations. It's like having a senior dev who never sleeps and never complains. We love to see it.

Why Typesense Deserves Better Tooling

Typesense is genuinely one of the best open-source search engines out there. It's:

⚡ Blazingly fast (sub-millisecond searches)
🔤 Typo-tolerant out of the box
🧠 Easy to setup compared to Elasticsearch
💰 Free & open source

But the ecosystem around it — especially for visual management — has been lacking. The official dashboard is decent, but we wanted something that feels modern, powerful, and has AI baked in.

Typesense UI is our attempt to give Typesense the visual experience it deserves.

What's Next? 🔮

Some things on the roadmap:

[ ] Multi-server support — switch between Typesense instances
[ ] Collection creation wizard — visual schema builder
[ ] Export/Import — bulk operations with CSV/JSON
[ ] Query playground — test search queries with syntax highlighting
[ ] Analytics dashboard — search metrics and insights
[ ] More AI models — OpenAI, Claude, local LLMs

If any of these get you hyped, drop a ⭐ on the repo and open an issue with your ideas!

Show Some Love ❤️

If this project saved you time, made you smile, or just impressed you a little bit:

⭐ Star the repo: github.com/Mothilal-hire10x/typesense-ui
🐛 Report bugs: Issues
🤝 Contribute: PRs are always welcome!
📢 Share this post: Help other devs discover it

Wrapping Up

Building this was genuinely one of the most fun projects we've worked on. The intersection of search technology, modern frontend, and AI is such a vibe right now, and we think we're only scratching the surface.

If you're using Typesense (or thinking about it), give Typesense UI a spin. It's free, it's open source, and it might just change how you interact with your search data.

Now go touch some grass. Or don't. We're not your mom. 🌱

Built with React, TypeScript, and an unhealthy amount of caffeine ☕

Follow us for more open-source drops and dev content that doesn't put you to sleep.

Stop Wiring Dependencies by Hand - Meet InjectQ, Python DI Done Right

Mothilal M — Sun, 22 Feb 2026 12:36:40 +0000

You've been there.

A service that needs a database, which needs a config, which needs an env variable that someone hardcoded three months ago and nobody remembers where. You're passing objects down ten layers of constructors. Testing means faking half your app.

It's messy. And it doesn't have to be.

Dependency Injection is the fix - but most Python DI libraries feel like they were designed for a different language. Overly complex, decorator-heavy, or magical in ways that make debugging a nightmare.

So we built InjectQ.

"We wanted DI that feels like Python - not like a Java framework that got lost on its way to PyPI."

What is InjectQ?

InjectQ is a modern, lightweight Python dependency injection library focused on:

✅ Clarity and simplicity
✅ Type safety (works with mypy, pyright)
✅ Async-first APIs
✅ Seamless FastAPI & Taskiq integration
✅ Production-grade performance (270ns per bind)

Links:

📦 PyPI
🐙 GitHub
📖 Docs

Install in one line

pip install injectq

For framework integrations:

pip install injectq[fastapi]   # FastAPI support
pip install injectq[taskiq]    # Taskiq support

Quick Start - Zero config, maximum clarity

from injectq import InjectQ, inject, singleton

container = InjectQ.get_instance()

# Bind a value — dict-style, no ceremony
container[str] = "Hello, World!"

@singleton
class UserService:
    def __init__(self, message: str):
        self.message = message

    def greet(self) -> str:
        return f"Service says: {self.message}"

@inject
def main(service: UserService) -> None:
    print(service.greet())

main()  # → Service says: Hello, World!

That's it. @singleton = one instance app-wide. @inject = auto-resolve from type hints. No XML, no 500-line config, no magic.

Core Features

🔧 Dict-like API

The simplest mental model possible:

from injectq import InjectQ

container = InjectQ.get_instance()

# Bind anything
container[str] = "config_value"
container[Database] = Database()

# Retrieve
db = container[Database]

🎯 Decorator + Type-based Injection

@inject
def process(service: UserService, db: Database):
    # Both auto-resolved from the container
    ...

Also supports Inject[T] for inline type annotations that work with static type checkers.

🔄 Scopes and Lifetimes

from injectq import singleton, transient, scoped

@singleton
class Database: ...       # One instance, lives forever

@transient
class Validator: ...      # New instance every resolution

@scoped("request")
class RequestContext: ... # One per request scope

# Async scopes work too
async with container.scope("request"):
    ctx1 = container.get(RequestContext)
    ctx2 = container.get(RequestContext)
    assert ctx1 is ctx2  # Same instance ✓

🆕 Hybrid Factories - The Feature That Changes Everything

This is new in v0.4 and it's genuinely great.

The problem: You have a factory that needs a database (DI-managed) and a user ID (runtime value). Old way is verbose:

# ❌ Old way — manually resolve everything
db    = container[Database]
cache = container[Cache]
svc   = container.call_factory("user_service", db, cache, "user123")

New way with invoke():

def create_user_service(db: Database, cache: Cache, user_id: str):
    return UserService(db, cache, user_id)

container.bind_factory("user_service", create_user_service)

# ✅ Auto-inject db and cache, you only pass what you know
svc = container.invoke("user_service", user_id="user123")

# Async version
svc = await container.ainvoke("async_service", batch_size=100)

InjectQ resolves what it knows from the container. You provide only the runtime-specific values. Clean.

🚀 FastAPI Integration

from typing import Annotated
from fastapi import FastAPI
from injectq import InjectQ, singleton
from injectq.integrations.fastapi import setup_fastapi, InjectFastAPI

app       = FastAPI()
container = InjectQ.get_instance()
setup_fastapi(container, app)

@singleton
class UserService:
    def get_user(self, user_id: int) -> dict:
        return {"id": user_id}

@app.get("/users/{user_id}")
async def get_user(
    user_id: int,
    user_service: Annotated[UserService, InjectFastAPI(UserService)],
):
    return user_service.get_user(user_id)

🧪 Testing — Mocking Without the Pain

from injectq.testing import override_dependency, test_container

# Override a specific dep for the duration of a block
with override_dependency(Database, MockDatabase()):
    service = container.get(UserService)
    # UserService gets MockDatabase here ✓

# Fully isolated test container — no global state bleed
with test_container() as tc:
    tc.bind(Database, MockDatabase)
    # Clean slate for each test

Pro tip: Use InjectQ.test_mode() with pytest fixtures to auto-reset your container between tests.

🏗️ Modules and Providers

For larger apps, organize your bindings into modules:

from injectq.modules import Module, SimpleModule, ProviderModule, provider

class AppModule(Module):
    def configure(self, binder):
        binder.bind(Config, Config())
        binder.bind(Database, Database)

class Providers(ProviderModule):
    @provider
    def make_notifier(self, db: Database, cfg: Config) -> Notifier:
        return Notifier(db, cfg)

container = InjectQ(modules=[AppModule(), Providers()])

🛡️ Abstract Class Validation

InjectQ validates at bind time, not at resolution time:

from abc import ABC, abstractmethod
from injectq.utils.exceptions import BindingError

class PaymentProcessor(ABC):
    @abstractmethod
    def process_payment(self, amount: float) -> str: ...

# ❌ Raises BindingError immediately — no surprises at runtime
container.bind(PaymentProcessor, PaymentProcessor)

# ✅ Correct — bind the concrete implementation
container.bind(PaymentProcessor, CreditCardProcessor)

Fail fast. Debug less.

Performance Benchmarks

InjectQ isn't just clean — it's fast.

Operation	Speed
Basic bind / get	270–780 nanoseconds
Dependency resolution	~1 microsecond
10-service web request simulation	142 microseconds
1,000+ concurrent operations	Sub-millisecond

Thread-safe by default. Production-ready from day one.

Why InjectQ Over Alternatives?

Feature	InjectQ	dependency-injector	injector
Dict-like API	✅	❌	❌
FastAPI integration	✅ Built-in	✅	❌ Manual
Hybrid factories (invoke)	✅	❌	❌
Async scope contexts	✅	⚠️ Limited	❌
Testing utilities	✅ Built-in	✅	❌ Manual
Taskiq integration	✅	❌	❌
Abstract class guard	✅ Bind-time	❌ Runtime	❌ Runtime

TL;DR

If you're tired of:

Manually wiring dependencies
Global state leaking into tests
Framework integrations that require 200 lines of glue code

InjectQ is for you.

pip install injectq

Built with ♥ by the 10xHub team. MIT Licensed. Contributions welcome.

Have questions or feature requests? Drop them in the comments or open an issue on GitHub. We read everything.