Overview
Gramps Connect is an HTML-based way to work on a family tree built with Gramps, the free genealogy software. It follows the same layout and vocabulary as Gramps itself, so if you've used Gramps before, it should feel familiar rather than like a different program you have to relearn. Two things set it apart: it stays fast even on very large trees, and it's built for more than one person to be working on the same tree at the same time.
It comes in two forms. A standalone version runs entirely on your own computer — a genuine alternative to Gramps Desktop for day-to-day work on your own tree, not a limited preview of anything else, and nothing you do in it is sent anywhere (see Installing). A shared, hosted version lets a whole family log in and work on one tree together, which is where the live collaboration features described below come into their own (see Deploying). Either way, the interface is the same — the only difference is whether anyone else is in the tree with you.
- Know which tree you're in. The header names the active tree next to the Gramps Connect logo, so if you're signed into more than one (or sharing a hosted instance with other family trees), it's always clear which one you're looking at.
- Know when the app itself has been updated. On a shared, hosted instance, a tab you've had open for a while can end up running an older build than what the server is now serving. Gramps Connect notices and shows a dismissible "Update available" notification with a Reload button — it never reloads the page for you, since you might have unsaved draft edits open.
- See each other's changes as they happen. When someone else corrects a date or adds a person, your screen updates on its own — no reloading, and no risk of working from a copy of the tree that's already gone stale. Anyone who's changed something in the last few minutes shows up as an avatar next to the user menu, so you can see who else is actively working in the tree with you right now. See Architecture for how this actually works under the hood.
- See who changed what, when. Every record has a History button — open it for a log of that record's own edits (who, when, added/updated/ deleted), newest first, and click any entry for a field-by-field before/after diff. The after-the-fact complement to live sync above: that shows you changes as they happen, this lets you look back later. See Data Model and Editing for more.
- Discussions: threads that can be about something. Discuss a specific record with one click and keep chatting in a floating window while you browse — it never takes over the page you were on — or open the Discussions view and start one from scratch, linking in whatever People, Sources, Citations and Repositories a research question actually turns on, so a discussion can grow into a real gathering point for one line of research, not just a comment thread. One-on-one messages work the same way, just unlinked to anything. See Messaging for details.
- Shared results. When someone runs a report or exports the tree, the finished file shows up where everyone can find and download it, not just in that person's own folder. Clicking Download on one of these confirms with an in-app toast once the save hands off to the browser/OS — helpful on desktop, where the native save dialog it triggers can otherwise be easy to miss. Afterward it asks whether to keep the generated file as a media object in the tree (green Save) or not (plain Don't Save) — Save, or just dismissing the dialog, is the safe default; either way it's a quick regenerate away, so the choice isn't a big deal. Most generated files (and any other Media item) can be viewed in the browser via a View button, not just downloaded — see Data Model and Editing for which formats.
- Automatically generated life stories. For any person or family, the app puts together a narrative slideshow of their lives — their events, the places they happened, and any related photos — with a short written description for each moment. These are editable, not fixed. Generating one offers a couple of options first: for a person, whether to pull in their families too (spouse, children, parents, siblings — not just their own events); for a family, which members' own births and deaths to include.
- Photo comparisons. Place two photos on top of each other — useful for "then and now" pairs, or comparing photos of the same person at different ages.
- Tagging photos, and clicking through them. Draw a region on a photo to mark who or what's in that part of it. Open the photo full-screen and click directly on a tagged face or object to jump straight to that person's or record's page.
- Drill down without losing your place. Pick a person (or family, place, event...) from a list, and everything related to them — their events, family, photos, notes, sources — appears alongside it. Click into any of those and its own details open below, while the list and your original selection stay exactly where they were, however deep you go.
- Search across your whole tree at once. One search box looks through every kind of record — people, families, events, places, sources — together, laid out like a search-engine results page, ranked by how well each result matches, with a snippet of context. Each list also has its own search box, which by default does a fast plain-text match against that record type's common fields; a checkbox next to it switches the same box into GOQL, a small query language for much more specific questions — everyone with a given surname born in a certain place before a certain year, say, or every family where the mother died before the father.
-
Curated filters, no query language required. A "Filters" button
next to every primary list's title (People, Families, Events, Places,
Repositories, Sources, Citations, Media, Notes — every list except
Tags) opens a dialog for picking one from your saved combinations, or
building your own. "Load a saved filter…" reloads a whole named
combination you saved before (its empty first entry starts fresh); the
rest of the dialog stays tucked behind a collapsed "▸ Edit options"
toggle so picking a saved filter and hitting Apply stays a two-click
job, with the full editor one click away for anyone who needs it.
Opening "Edit options" reveals a left-aligned "Custom Rules" button
(styled like the page's own "Filters" button, not a plain text link)
and, under a small "Filter Builder" heading, one AND/OR/NOT
rule-group editor — Females/Males, no recorded birth date, missing
parents, has media, tagged with a name you type in (any tag on the
tree, not a fixed list), born or died between two dates you type in
(any date Gramps understands, not just a bare year), and dozens more
of the same everyday rules the desktop app's old Custom Filter rules
offered, as plain
checkboxes grouped by category, the same ones "+ Add rule" always
opens to (already expanded when the list is empty, so applying a
single rule needs no extra click). Combine several with AND/OR, nest a
rule group inside another to mix the two, and negate any single rule
or whole rule group with its own checkbox — no separate "not" filter
to create, unlike the desktop app. Under the hood it builds the same
GOQL the search box's checkbox mode uses, shown read-only underneath,
also inside "Edit options". (The curated checkbox list itself
currently only covers People and Family, matching the desktop app's
own rule set for those two; every other list still gets the full
dialog — building your own rules, saving/loading whole filters — just
with an empty built-in list to start from.)
Loading a saved filter and then editing its rules directly (inside
"Edit options") is all it takes to change it -- a
small "Unsaved changes" note appears next to the dropdown as a reminder while
you do, and switching to a different saved filter (or back to empty)
while it's showing asks you to confirm first, so an edit in progress
is never silently thrown away by picking something else from the same
dropdown; "Save" (enabled once you've actually changed something) saves
those changes back to that same filter, "Copy…" keeps the original
untouched and makes a separate one instead — defaulting to "that
filter's name (copy)" so it's not left blank — and "Save…" (nothing
loaded yet) gives a fresh arrangement a name for the first time; either
one rejects a name that's already used by another saved filter in that
same list, right in the naming dialog, rather than letting a second
filter silently shadow the first.
"Delete" removes the currently loaded saved filter and empties the
Filter Builder along with it — it lives in the
button row at the bottom alongside Clear/Save/Apply, disabled whenever
nothing's loaded ("New Filter"). Need
a rule that's not in the built-in list? "Custom Rules", inside "Edit
options", opens its own
small manager — name and save a raw GOQL snippet (the one place raw
query text is accepted anywhere in this feature), with the same
circled-"i" syntax reference next to it that the search box's own
GOQL mode uses, for whichever list you opened it from; it's actually
run against your tree in the background as you type, so "Create"/"Save"
only enable once it's confirmed valid, catching a typo right there
instead of the next time the rule gets used. A custom rule can take
its own named, typed parameters, just like a built-in rule (e.g. the
built-in tag/date rules already do) — add one or more
{name}params (String or Integer), reference each as{name}in the GOQL, and once saved it shows a fill-in-the-value field right in "+ Add rule", same as any built-in parameterized rule. Edit or delete any you've made, and each one shows up as an ordinary, reusable rule in "+ Add rule" from then on. There's no separate "Cancel" button on the main dialog — it writes nothing until you actually click Apply, Save, or Copy, so closing it any other way (the × or clicking outside) already does the same thing. Whenever a filter is active, the list header itself shows a plain-language summary next to the "Filters" button and its clear ("×") button — e.g. "Females AND NOT (Widowed OR Divorced)" — so you can tell what's applied without opening the dialog. - Family tree charts. Ancestor and descendant charts, including a circular "fan" style with an option to shade each person's slice by how long they actually lived, so long and short lives are visible at a glance. A third "Generations" style shows a person's parents and their full sibling row — including half, step, and adopted siblings, which the ordinary ancestor chart has no room to show at all — with a "+" to keep expanding outward: a full sibling row appears at every generation you expand to, not just the person you started from. Besides the scrollbars, you can click-and-drag anywhere on the diagram to pan it around, the same way the ancestor/descendant and fan charts already work. A muted gray "−" appears alongside any "+" once that branch has actually been revealed, to fold it back down again without losing anything — the underlying data stays loaded, so expanding it again is instant. Full siblings are grouped together visually with one shared "+" (they always expand into the same parents), while a half- or step-sibling branch gets its own group and label instead, each with its own line drawn up to its own father/mother boxes rather than one ambiguous line in the middle. A group is labeled "half" only when it shares one parent by birth; a group that shares no parent by birth — e.g. a later spouse's own children from an earlier marriage — is labeled "step" instead, even though that later marriage's family record is otherwise indistinguishable from a half-sibling one. Selecting a person and choosing "Expand spouses" from their detail card shows their spouse(s) beside their own card, wherever it appears in the graph — each spouse shown as their own full sibling group (with their own "+" to keep expanding), not just a bare name, since every person here belongs in a sibling group. Their children's own line down to them updates to connect to both parents once the spouse is expanded, rather than just the one person originally shown. A person with children from more than one marriage gets a separate children box per marriage instead of one box merging every child together, each with its own connector line drawn up to that specific marriage's two parents. A horizontal divider marks the boundary between each generation. A "Compact" checkbox (next to the chart's own instructions) drops each card's photo, puts birth/death dates beside the name instead of below it, and lists a sibling or children group as a vertical stack instead of side by side — useful once a sibling row gets wide.
- Maps. See where events took place, and switch the map's appearance to look the way the area did during that historical period rather than a modern map. Every map overlay — outline a family farm's boundary, mark a route someone traveled, or overlay an old survey map or photo onto its real location — belongs to at least one place, and is added from that place's own "Map overlays" section: one button offers both drawing a brand new item and attaching an already-existing overlay here too. An overlay can span several places at once (a boundary or route that covers more than one, say) — it just can't be attached to the same place twice. The drawing editor itself lets you place lines, shapes, and images, dragging an image's four corners independently (free-transform warping) to line it up with the real terrain, and set each image overlay's own opacity and stacking order (which one sits on top when several overlap, like an old county map layered under a more detailed township survey) — a description is required before it can be saved, same as the place attachment. Once saved, a live panel on the map itself lists every overlay and drawn region on the currently open place and on whatever it encloses — opening a state shows its own overlay alongside each of its counties', not just its own. If the next level down has none of its own (say a country whose regions carry no outline but whose smaller divisions do), it keeps descending until it finds a reasonable number of overlays or runs out of places, rather than stopping after exactly one level down — where you can hide any of them or preview a different opacity for the rest of this session — a quick way to compare a modern map against an old one without touching the saved settings — and clicking one flies the map to fit its full extent. A child place's shape or image renders on top of its parent's rather than underneath, so a smaller overlay never disappears under a larger one that encloses it. An overlay's visible date range comes from the date on whichever place you're currently viewing it from — so a farm outline with no date shows all the time, while an old map only appears when the historical mode's year falls inside the era its place's name applied. Overlays with different eras at the same physical spot need their own place records (one for the county-era name, one for the township-era one, say), since a place's date lives on its name, not a per-overlay field. Saving an overlay also fills in coordinates for any of its places that don't have any yet, using the center of whatever was drawn — so a place created just to hold a farm boundary or a route ends up located on the map without having to look up and enter its latitude/longitude by hand. When several places share one overlay this way, each gets spread out slightly around that center instead of landing on the exact same point, so they still separate into their own markers on the map rather than merging into one. It never overwrites coordinates a place already has. If markers ever do end up stacked on the same spot (nothing keeps two places from sharing coordinates by hand), clicking their combined number lists the places underneath so you can still pick one, rather than just zooming in on an empty-looking dot. Arriving on the map from a specific place (its own "Map" link, or a Wikidata-imported overlay) opens its detail card and overlay already showing, named on a chip in the header — clicking empty map to look around closes that card, and clicking the chip's label brings it right back without having to find the marker again.
- Look up a place on Wikidata. Adding a brand-new place first asks how you want to add it — manually, or from Wikidata — rather than mixing a "look up on Wikidata…" button in among the plain fields; picking Wikidata opens the search flow up front, and picking manual just goes straight to the usual fields. Editing an existing place still offers the Wikidata lookup as a plain enrichment button, since there's no such either/or to make there. Either way, searching by name and confirming a match fills in the place's coordinates and creates or links its whole enclosing hierarchy at once — city, county, state, country — each with its own coordinates, instead of creating and connecting every level by hand. A checkbox on that same confirmation screen (on by default) also fetches an outline from Wikidata, when one exists, for each newly-created level and for the place being added itself, so a state or country added this way shows its actual boundary on the map instead of just a pin — the same way a hand-drawn shape or historical map overlay does. Each outline is filled with a color: a hue per place type (country/state/county/city, etc., so every county reads as the same family next to a state's outline) shaded by the place's own Wikidata ID, so sibling places of the same type are still visually distinct from each other. The outline is labeled with the place's name, both in the overlay's own media description and in the Overlays panel's list, instead of showing up as an untitled region.
- A home person. Set a particular person as your own point of reference in the tree, which the Home page and some community add-ons build on.
Clicking the edit button on any record opens its full editing form — a person, family, event, and so on — for changing that record's own details (a name, a date, a description) or its connections to other records, such as exactly how a child relates to their parents.
Creating a brand-new record of the type you're browsing (a new person, a new place, and so on) sits right next to that record's own Edit/Delete buttons, rather than in a separate spot above the list — so adding one and acting on the one you're already looking at are both in the same place.
For smaller, everyday changes, the "+" and "−" buttons are a shortcut: attach an existing citation, photo, or person without opening a full form, or remove one that's already linked. They only change what a record is connected to, not the record's own details.
Not every field of every record type is editable yet — see Data Model and Editing for exactly what's covered today.
Duplicate records can be found and merged, too: select two records of the same type and choose Merge. See Data Model and Editing for how conflicts between the two are handled.
Alongside the built-in features, there's a browsable catalog of small tools other people have written and shared — not limited to what the core developers built in. Browse it from inside the app, and install, update, or remove any of them with a click. Examples already in the catalog include relationship calculators, statistics, and custom lookups. See Gramplets and the Add-on Store for the full picture.
What makes these different from a typical plugin system is that each one is an actual Python program, and it runs right there in your browser, with nothing installed and no server involved. You can open any add-on's code from inside the app and edit it yourself: change how a chart looks, tweak what a lookup searches for, or write a new one from scratch. It's a real, working Python environment sitting inside a web page — genuinely unusual for genealogy software, where "customizing" normally means waiting for someone else to add the feature you want.
Once you've looked at part of your tree, the app remembers it, so browsing, sorting, and searching feel instant afterward — even on trees with tens of thousands of people, where this kind of searching can otherwise take a very long time. See Architecture for how the local cache makes this possible.
Gramps Connect is under active development, and there are things worth knowing aren't there yet — starting with finding and merging duplicate records. See Roadmap and Known Limitations for the fuller picture.
Gramps Connect reads and writes the same file formats as Gramps Desktop and gramps-web (GEDCOM and Gramps XML), so a tree can move freely between all of them.
