# Namma Yatri: an open, zero-commission ride platform built in Haskell

> The repository behind an Indian ride-hailing platform that publishes its backend, its data and its roadmap, on the argument that drivers and riders should own the layer between them and the aggregators.

**nammayatri/nammayatri** — A Direct-to-Driver open mobility platform powering the next-generation of mobility applications in India.

- Repository: https://github.com/nammayatri/nammayatri
- Website: https://nammayatri.in
- Stars: 2,570 · Forks: 401
- Language: Haskell
- License: AGPL-3.0
- Published: 2026-10-08 · Updated: 2026-10-08 · Language: en
- Canonical page: https://hysenlabs.com/projects/nammayatri-nammayatri

## A platform argument written into the repository description

The GitHub description calls Namma Yatri a direct-to-driver open mobility platform for India. The README headlines it as an open and driver-centric mobility platform and then lists five vision principles: zero commission for drivers, open data and open code, optimisation toward population scale, multimodal transport, and shared mobility. Those are business commitments written as engineering goals, which tells you what kind of repository this is before you read a line of Haskell.

The zero-commission point is the one that explains the rest. A platform that takes no cut from a driver has to make its economics work some other way, and the README is explicit that the route is utility-like pricing achieved by continuously reducing maps, cloud and development cost while keeping reliability high. That is a cost-engineering brief, not a growth brief, and it is why a codebase organised around cost reduction is more interesting here than another dispatch queue.

The framing is also about ownership. The core values section argues that drivers invest in their vehicles and citizens pay for the service, so both ought to own the platform rather than have an intermediary set the terms. Whether a public repository achieves that is a separate question from whether the code is legible, and legibility is what a reader can actually judge.

## What the tree reveals about the build and the tooling

The primary language is Haskell, and the repository root is consistent with that: `flake.nix` and `flake.lock` sit at the top level, along with `vira.hs` and a `buildtime-analysis/` directory. Development environments are described in `.envrc.backend` and `.envrc.frontend`, which is the usual `direnv` pair, so the frontend is expected to run alongside the backend.

Beyond the application there is a surprising amount of operational scaffolding. `om.yaml` suggests an `om` tool configuration, `ondc_build_diff.patch` points at work against ONDC, the Open Network for Digital Commerce, which is the Indian interoperability spec that a platform like this would have to speak to sell across operators rather than only inside one app. `toll-combinations/` is domain logic about tolls, `NammaTagConcept.md` documents a product concept, and `INVOICE_GENERATION_IMPLEMENTATION.md` records how invoicing was implemented.

Localisation is wired in rather than bolted on. `crowdin.yml`, `crowdin_python_generator_configuration.json` and `crowdinTranslationGenerator.py` show the translations are generated and pushed through Crowdin, which is the practical answer to shipping an India-wide product in many languages.

The one thing the tree does not contain is the source of the client application in any form the reader can build from this repository alone. The README sends you to the `Backend` and `Frontend` sub-project directories for setup instructions, and the top-level listing is a partial view of the root, so the client code may well live in a sibling directory rather than here. That is the gap to check first if you intend to run the whole product rather than read the backend.

## Open data as a public dashboard rather than a promise

The concrete evidence for the open claim is a live dashboard rather than a paragraph. The README links to nammayatri.in/open, and the accompanying screenshots are described as a comprehensive overview of total rides completed, registered users, searches and driver earnings, plus daily trends of searches, completed trips, earnings, registered users and enabled drivers over time.

Publishing driver earnings next to platform-wide ride counts is a specific choice. It is the metric an aggregator is most likely to prefer hiding, and it is also the one a driver would use to check the zero-commission claim. That makes the dashboard the most interesting artefact in the repository for an outside reader: it is a running audit of the platform's own stated principle.

The flip side is that a dashboard is a snapshot, not an audit trail. There is no way to verify a single trip or reconcile a single payout from what is published, so the data supports trust rather than proof. Contributors who want the stronger version would look at the docs directory for schema definitions.

## AGPL-3.0 is the licence decision that makes the rest coherent

The repository is licensed AGPL-3.0, which is the load-bearing choice in this project rather than a formality. An open repository that wants to keep operators honest about their hosted versions needs a licence that reaches the network case, and AGPL is the one that does. A modified server kept private but offered over a network is exactly the scenario it covers.

This is a different posture from an MIT or Apache codebase that happens to be public. It tells a would-be competitor building a hosted fork what they are permitted to do, and it tells a municipality or cooperative that wanted to run their own instance that they are explicitly allowed to. For anyone reading the repository to judge whether the open claim is legal rather than rhetorical, the licence is the first thing to check.

Not legal advice, and it does not settle the trademark or data questions that come with a consumer brand, but it is a clear signal of intent.

## Contributing: GitHub Discussions first, code second

The README routes questions to GitHub Discussions and asks for contributions in five categories: bug reports, code patches, documentation updates, feature requests, and notifications of breaking changes in dependencies. That last one is unusual and worth noting, because a Haskell monorepo whose backend contract changes is a real operational cost for anyone running it.

The guide points to `docs/CONTRIBUTING.md` before anyone starts, which is the right order for a project this size. With 1,408 open issues on the repository, an issue-first contribution process is the difference between a patch being reviewed and a patch disappearing into a queue.

The open question count also tells you where the project spends its attention. That many open issues on an actively pushed branch is a backlog, not a signal of neglect, but it does mean a first-time contributor should read the existing issues to find a piece already in progress.

## Two dates that do not agree

The last push to the default branch was on 2026-09-28, which places this repository in active work right now. The most recent GitHub release is v23.0.0, published on 2024-02-13, with v21.0.0 and v20.0.0 published a few days earlier in the same week. Both facts are on the repository, and they point at different things: branch work is current, while tagged releases stopped more than two years ago.

For a platform deployed as a hosted service that is a perfectly normal pattern, because there is no reason to cut a tag for every change to a service that is always running the branch. For someone who wants to run the backend themselves, it matters a great deal, because there is no tagged artefact to pin to and the release notes stop where the commit history continues.

The practical consequence: read the commit history on `main` for current behaviour, and treat the 2024 release tags as a record of where versioned builds stopped rather than as a version to deploy. Both facts are worth keeping in view when judging the maturity of the platform.

## Conclusion

Namma Yatri is worth reading for anyone who believes ride-hailing infrastructure should be inspectable by the drivers it serves, and the repository backs that up with an AGPL licence, a public dashboard and a public contributor guide. What it is not is a general purpose open mobility stack that you can drop into another city: the domain model is built around Indian auto rickshaws, ONDC and a specific regulatory setting. The most concrete next step is to read `Backend/README.md` for the build and the `docs/CONTRIBUTING.md` guide before judging scope, and to notice that the release tags stopped in February 2024 even though the default branch kept moving afterwards.

## FAQ

### Is Namma Yatri an Indian company?

The repository describes Namma Yatri as an open mobility platform for India, built around driver ownership and a zero-commission model. It is published under AGPL-3.0 with its backend source, product concepts and localisation tooling in the same tree, rather than as a closed commercial product.

### How is Namma Yatri different from Uber?

The stated difference is economic: drivers pay no commission, and the platform says it covers its costs by optimising maps, cloud and development spend rather than by taking a cut of fares. It also publishes its ride, search and driver earnings data on a public dashboard, which a closed operator would not do.

### What language is the Namma Yatri backend written in?

Haskell. The root of the repository carries `flake.nix` and `flake.lock` for a Nix based development environment, along with `vira.hs` and a `buildtime-analysis/` directory, and separate direnv files for backend and frontend work.

### Which licence does Namma Yatri use?

AGPL-3.0. That licence reaches modified versions offered over a network, which is what makes it a meaningful choice for a hosted platform that wants its openness to bind anyone running a fork of the backend.

## Sources

- [License: AGPL-3.0](https://github.com/nammayatri/nammayatri/blob/main/LICENSE)
- [nammayatri/nammayatri on GitHub](https://github.com/nammayatri/nammayatri)
- [Project website](https://nammayatri.in)
- [README](https://github.com/nammayatri/nammayatri/blob/main/README.md)
- [Releases](https://github.com/nammayatri/nammayatri/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/nammayatri-nammayatri