Lignée — A Family Tree Built for Someone I Love (and Generations I'll Never Meet)
I did not build this for a portfolio. I built it for my family.
For the Adjolou and Chamiande lineage — for the people who raised me in Lomé, Togo, and for the children who will one day ask who came before us? This is my Hacktoberfest Weekend Challenge submission under Build for a Friend. The "friend" is not a stranger on the internet. It is someone I love: my family, including future generations I may never meet.
Lignée (French for lineage) is an open-source family tree that turns oral family stories into durable digital memory — with open-source AI at the core, a mind-map you can edit on your phone, and a promise that our kinship will not vanish when the last elder who remembers stops speaking.
Who it's for
Someone I love is not a single person. In West African extended kinship, "family" is wider than a nuclear unit: grandparents, aunts, uncles, cousins, marriages that braid two names together, in-laws who become our people.
I am Dondah Chamiande Adjolou, from Lomé, Togo. Like many families in the diaspora — and many still at home — we carry our history in conversations: around a table, on a phone call, in a funeral speech, in a name whispered to a newborn. That memory is rich. It is also fragile.
Lignée is for:
- Elders whose stories deserve more than a fading recollection
- Parents who want their children to know the tree they grew from
- Cousins scattered across cities and continents who still share one lineage
- Future generations who will open a phone and see faces and names instead of silence
This is not a generic genealogy product. It is a gift I intend to hand over — to my family first, and then to anyone who needs the same thing for theirs.
The problem: oral memory is fading
In many African families, lineage is oral. That is beautiful — and it is at risk.
- Elders pass away, and with them go the precise links: who married whom, which child belonged to which house, how two surnames became one story.
- The diaspora stretches kinship across borders. A cousin in Europe and a cousin in Lomé may share blood and still not share a shared map of the family.
- Young people grow up knowing that they come from somewhere, without knowing how the branches connect.
- Paper notebooks get lost. WhatsApp threads scroll away. A Facebook album is not a tree.
If we do nothing, the next generation inherits love without structure — affection without ancestry they can navigate. I did not want my family's story to depend on whoever happens to remember next Sunday.
I wanted something durable, editable, installable on a phone, and honest about privacy — because family data is not the kind of data you casually hand to a closed cloud.
What Lignée does
Lignée is a web app (and a PWA you can install on your phone) that lets a family build and explore its tree as a living mind-map.
A mind-map of kinship, not a stiff chart
Using React Flow, the tree is a visual graph you can pan, zoom, and rearrange. People are nodes. Marriages, parent–child links, cousins, and in-laws are edges. It feels like thinking on a whiteboard — not like filling a bureaucratic form.
Click-to-edit, rich people cards
Tap a person. Open their card. Add or correct a name, dates, notes, relationships. No ceremony — if Auntie remembers a detail at dinner, you fix it in thirty seconds.
Relationships that match how we actually live
Nuclear-only trees fail African (and many diaspora) families. Lignée models:
- Marriages and unions that connect two branches
- Cousins and extended kinship, not only parents and children
- In-laws — the people who become family by bond, not only by blood
Install it on your phone (PWA)
Family conversations happen on phones. Lignée is a Progressive Web App: install it to the home screen, open it like a native app, and keep the tree close when someone starts telling a story.
Story import — from récit familial to nodes
This is the heart of the project. You paste (or type) a family story — a récit familial — and open-source AI helps turn narrative into structured people and relationships. Then you review, correct, and own the result.
Home view, shown before opening the tree:
Demo walkthrough (screenshots above):
- Open the tree — see the Adjolou/Chamiande mind-map.
- Tap a person — edit their card.
- Paste a short family story — run story import.
- Review suggested nodes and links — accept what is right, fix what is not.
- Install the PWA on your phone — take the tree with you.
Live demo: https://story-lineage.vercel.app
Source (primary public link): https://github.com/Donchaminade/story-lineage
Origin mirror (optional): https://cursor.com/codebase/donchaminade/story-lineage
Demo note: The Vercel serverless deployment uses ephemeral storage, so demo seed data may reload on cold instances; edits made on a prior instance may not persist.
Open-source AI at the core
I refuse to build a family memory tool that only works if a closed vendor stays friendly, cheap, and online.
How story import works
- You provide a natural-language family story (French or English — the language of the telling).
- An open AI pipeline (designed for Ollama and local inference, with a local fallback) extracts candidate people, generations, and relationships.
- The app proposes nodes and edges on the tree.
- A human always reviews. AI suggests; the family decides.
No magic black box that silently rewrites your lineage. Suggestion, then consent.
Why open matters for family data
| Concern | Why open-source AI helps |
|---|---|
| Privacy | Family names, dates, and stories are intimate. Local inference (e.g. Ollama) keeps data on machines you control. |
| No vendor lock-in | Models and providers can be swapped. Your tree is not hostage to one API's pricing or terms. |
| Local option | When the network is weak — or trust is low — local fallback still lets story import run. |
| Inspectability | Open models and open code mean the community can audit how narrative becomes structure. |
Closed AI might be convenient. For family lineage, convenience is not enough. Sovereignty over memory is the feature.
How I built it (honest technical notes)
Stack
- Next.js — app framework, routing, and a clean path to a PWA
- SQLite — simple, portable persistence; easy to back up; no heavy ops tax for a family project
- React Flow — interactive mind-map UX (pan, zoom, nodes, edges)
- PWA — installable on Android/iOS home screens for real family use
- Open AI / Ollama + local fallback — story import without requiring a single proprietary cloud
What went well
- React Flow made "kinship as a graph" feel natural quickly — marriages and cousins are just edges with meaning.
- SQLite kept the data model honest and movable: a family's tree should be something you can copy, backup, and keep.
- Designing for phone-first editing forced clarity: click-to-edit beats multi-step wizards when an elder is mid-story.
What was hard (and still is)
- Modeling extended kinship without drowning the UI — African families are dense graphs; the UX has to stay readable.
- Story import is only as good as the review loop. Hallucinated cousins are worse than missing ones — so the product bias is: suggest carefully, confirm always.
- Bilingual reality (French oral culture, English for this challenge write-up and global open source) — the product must respect the language of the récit, not only the language of the README.
What I would improve next
- Richer media on person cards (photos, voice notes of elders telling the story)
- Stronger conflict resolution when two relatives disagree on a link
- Export/import formats for long-term archival beyond one app
This was a weekend challenge build with a long-horizon intention. The code is a starting lineage of its own: it will grow.
Handing it over — what it means for future generations
When I imagine a child in twenty years opening Lignée, I do not imagine a product demo. I imagine them tapping a great-grandparent's card and reading a note that someone bothered to write down — a marriage that joined Chamiande and Adjolou, a cousin who left and came back, a name that explains their own.
Oral memory gave us warmth. Digital lineage can give us continuity.
I am handing this to my family as a living gift: editable, installable, private by design, open in its AI so we are not tenants on someone else's memory server. If other families fork it for their own surnames and stories, that is the point of open source — lineage that multiplies without being owned.
For Hacktoberfest, this is my weekend challenge. For my family, this is unfinished on purpose: trees grow.
Prize Categories
Overall only.
(This submission does not claim partner tool categories such as Copilot, Cloudflare, Docker, etc., unless those tools were genuinely central to the build. The core stack here is Next.js, SQLite, React Flow, PWA, and open-source AI / Ollama with local fallback.)
Links
- Demo: https://story-lineage.vercel.app
- Repository (primary public link): https://github.com/Donchaminade/story-lineage
- Origin mirror (optional): https://cursor.com/codebase/donchaminade/story-lineage
Challenge tags (for DEV.to)
#devchallenge #weekendchallenge #hf26challenge
Built with care in Lomé's wider story — for the Adjolou/Chamiande lineage, and for anyone who refuses to let family memory evaporate.
Top comments (0)