Apply for AI Grants India

India’s open-source ecosystem spans Digital Public Infrastructure (DPI), developer tools, language technology, civic technology, and AI research. The best way to participate is not to wait for a perfect idea: choose an active project, understand its users, make a small verifiable contribution, and build trust with maintainers.

This guide explains how to contribute to Indian open source projects in 2026, whether you are a student, software engineer, researcher, designer, translator, or domain expert. It focuses on practical contribution paths—not only code—and on the checks that matter when software may serve millions of people.

Start with a problem, not a repository

Before opening GitHub, identify the kind of problem you want to work on:

• DPI and civic systems: interoperability, identity-adjacent services, education, health, commerce, mobility, and municipal platforms.
• Indic language technology: speech datasets, OCR, translation, text normalization, evaluation, and tools for low-resource languages.
• Developer infrastructure: APIs, observability, databases, deployment tools, documentation, and security.
• Public-interest applications: legal technology, accessibility, climate, agriculture, and community information systems.

Your choice of project should match both your skills and your available time. A repository with a clear roadmap, recent releases, responsive maintainers, tests, and a welcoming contribution guide is usually a better starting point than a famous but inactive project.

If you are new to AI repositories, first review this guide to contributing to AI GitHub repositories in India. Students can also compare their experience with open-source AI projects for student developers before selecting a technically realistic project.

Where to find Indian projects

Use several discovery channels rather than relying on a single list:

• Search GitHub by language, topic, organisation, and recent commit activity.
• Explore projects from institutions, public-interest technology organisations, universities, and Indian startups.
• Follow FOSS United communities, local meetups, hackathons, and project-specific forums.
• Check whether a Digital Public Good has published its governance, licence, documentation, and deployment guidance.
• Look for issue labels such as good first issue, help wanted, documentation, accessibility, localization, and security.

Useful areas to investigate include Beckn Protocol, DIGIT, Sunbird, AI4Bharat, Bhashini-related language technology, OpenNyAI, Indic language datasets, and open developer tools created by Indian teams. Verify each project’s current activity, licence, ownership, and contribution process before investing time; organisations and repositories can change.

Do not treat “Indian” as a substitute for quality. Assess the project as you would any serious dependency: inspect releases, issue resolution, security practices, documentation quality, and whether users can reproduce the development setup.

Read the repository before writing code

A strong first contribution begins with repository literacy. Read these files in order:

1. README.md for the project’s purpose and supported use cases.
2. CONTRIBUTING.md for setup, branch, testing, and review rules.
3. CODE_OF_CONDUCT.md for community expectations.
4. LICENSE to understand what you may reuse and distribute.
5. Security and governance documents, if available.

Then run the project locally. Record the operating system, runtime versions, package manager, environment variables, database services, and test commands. Use the project’s lockfiles, containers, or development scripts instead of inventing a parallel setup.

For AI projects, also inspect dataset licences, model licences, evaluation scripts, known limitations, and data-provenance notes. A model that performs well in English may fail on code-mixed text, dialects, names, or regional contexts. Work in this area should document those limitations rather than hiding them.

Choose a contribution you can finish

Your first pull request should reduce maintainer workload. Good starting points include:

• Fixing an inaccurate installation step.
• Adding a reproducible test for an existing bug.
• Improving error messages or command-line help.
• Updating API examples and migration notes.
• Adding accessibility labels, keyboard support, or clearer interface copy.
• Translating documentation or interface strings into an Indian language.
• Creating a small benchmark or regression test for Indic text, speech, or OCR.

Before starting a larger change, open an issue or comment on an existing one. Explain the problem, affected users, proposed scope, and how you plan to test it. This avoids duplicated work and gives maintainers a chance to identify architectural constraints.

For a portfolio-oriented path, combine a small code change with evidence: a test, benchmark, before-and-after result, or deployment note. This makes your contribution useful to the project and credible to future employers or collaborators. Beginners may also find ideas in machine learning portfolio projects for beginners in India.

Make a pull request maintainers can review

Keep the change narrow. Separate formatting, refactoring, and feature work unless the repository explicitly asks for them. Follow the existing style and run the full documented test suite before submission.

A useful pull request includes:

• A concise title using the project’s preferred format.
• The problem and affected users.
• What changed and what did not change.
• Tests, benchmarks, screenshots, or reproduction steps.
• Known limitations and follow-up work.
• Links to the relevant issue or design discussion.

Use atomic commits where the project prefers them, but do not rewrite shared branches or force-push carelessly. Respond to review comments with evidence and questions. A request for changes is part of collaboration, not a rejection. If you cannot continue, tell the maintainer rather than leaving an unclear partial implementation.

Contribute beyond code

Indian projects often need contributors who understand language, policy, design, operations, and end-user constraints. You can add value by:

• Reviewing documentation for clarity and technical accuracy.
• Testing software on low-cost devices, slower networks, or regional configurations.
• Building sample applications that show safe integration patterns.
• Improving accessibility for users with disabilities.
• Curating and documenting speech, text, or image data with proper consent and licensing.
• Moderating community channels and helping new contributors find answers.
• Auditing dependencies, permissions, secrets handling, and deployment defaults.

For Indic NLP, domain knowledge is especially valuable. Read the low-resource Indic natural language processing guide to understand why data quality, script variation, annotation standards, and evaluation design matter as much as model architecture.

Responsible contribution to DPI and AI

Software used in public services needs stronger discipline than a weekend demo. Before proposing a feature, ask:

• Does it expose personal or sensitive data unnecessarily?
• Can users understand and challenge an automated decision?
• Does it work for different scripts, accents, devices, and connectivity conditions?
• Are logs, analytics, and telemetry minimised and documented?
• Is the licence compatible with downstream government, nonprofit, and commercial use?
• Can maintainers reproduce the result without proprietary services?

Avoid uploading personal, scraped, or restricted data to public issues and notebooks. Report security vulnerabilities through the project’s private channel, not a public issue. For AI work, publish evaluation methodology and failure cases alongside performance numbers.

Build a long-term open-source track record

One merged pull request is useful; sustained ownership is more valuable. After your first contribution, monitor regressions, review related pull requests, improve tests, and take responsibility for a small subsystem. Attend project calls where available and document decisions for people who were not present.

Funding can support deeper work through programmes such as Google Summer of Code, project fellowships, community grants, and research funding. Treat funding applications like engineering proposals: define users, deliverables, risks, maintenance plans, and measurable outcomes. If your work develops into an open AI or public-interest product, AI Grants India may be relevant for exploring support and mentorship.

The practical formula is straightforward: find an active Indian project, start with a bounded problem, test your work, communicate clearly, and keep showing up. That is how individual contributions become dependable infrastructure for India’s developers, institutions, and citizens.